Merge pull request #678 from dsyme/add-test1

add compile tests

Author: dsyme

docs/content/compiler.fsx

@@ -28,17 +28,18 @@ First, we need to reference the libraries that contain F# interactive service:
 *)
 
 #r "FSharp.Compiler.Service.dll"
-open Microsoft.FSharp.Compiler.SimpleSourceCodeServices
 open System.IO
+open Microsoft.FSharp.Compiler.SourceCodeServices
 
-let scs = SimpleSourceCodeServices()
+// Create an interactive checker instance 
+let checker = FSharpChecker.Create()
 
 (**
 Now write content to a temporary file:
 
 *)
 let fn = Path.GetTempFileName()
-let fn2 = Path.ChangeExtension(fn, ".fs")
+let fn2 = Path.ChangeExtension(fn, ".fsx")
 let fn3 = Path.ChangeExtension(fn, ".dll")
 
 File.WriteAllText(fn2, """
@@ -54,7 +55,7 @@ let x = 3 + 4
 Now invoke the compiler:
 *)
 
-let errors1, exitCode1 = scs.Compile([| "fsc.exe"; "-o"; fn3; "-a"; fn2 |])
+let errors1, exitCode1 = checker.Compile([| "fsc.exe"; "-o"; fn3; "-a"; fn2 |])
 
 (** 
 
@@ -67,7 +68,7 @@ module M
 let x = 1.0 + "" // a type error
 """)
 
-let errors1b, exitCode1b = scs.Compile([| "fsc.exe"; "-o"; fn3; "-a"; fn2 |])
+let errors1b, exitCode1b = checker.Compile([| "fsc.exe"; "-o"; fn3; "-a"; fn2 |])
 
 (**
 
@@ -83,11 +84,11 @@ You still have to pass the "-o" option to name the output file, but the output f
 The 'None' option indicates that the initiatlization code for the assembly is not executed. 
 *)
 let errors2, exitCode2, dynAssembly2 = 
-    scs.CompileToDynamicAssembly([| "-o"; fn3; "-a"; fn2 |], execute=None)
+    checker.CompileToDynamicAssembly([| "-o"; fn3; "-a"; fn2 |], execute=None)
 
 (*
 Passing 'Some' for the 'execute' parameter executes  the initiatlization code for the assembly.
 *)
 let errors3, exitCode3, dynAssembly3 = 
-    scs.CompileToDynamicAssembly([| "-o"; fn3; "-a"; fn2 |], Some(stdout,stderr))
+    checker.CompileToDynamicAssembly([| "-o"; fn3; "-a"; fn2 |], Some(stdout,stderr))
 

docs/content/tokenizer.fsx

@@ -28,7 +28,7 @@ file name of the source code. The defined symbols are required because the
 tokenizer handles `#if` directives. The file name is required only to specify
 locations of the source code (and it does not have to exist):
 *)
-let sourceTok = FSharpSourceTokenizer([], "C:\\test.fsx")
+let sourceTok = FSharpSourceTokenizer([], Some "C:\\test.fsx")
 (**
 Using the `sourceTok` object, we can now (repeatedly) tokenize lines of 
 F# source code.

docs/content/typedtree.fsx

@@ -241,7 +241,7 @@ let rec visitExpr f (e:FSharpExpr) =
         visitExpr f baseCallExpr
         List.iter (visitObjMember f) overrides
         List.iter (snd >> List.iter (visitObjMember f)) interfaceImplementations
-    | BasicPatterns.TraitCall(sourceTypes, traitName, typeArgs, typeInstantiation, argExprs) -> 
+    | BasicPatterns.TraitCall(sourceTypes, traitName, typeArgs, typeInstantiation, argTypes, argExprs) -> 
         visitExprs f argExprs
     | BasicPatterns.ValueSet(valToSet, valueExpr) -> 
         visitExpr f valueExpr

paket.dependencies

@@ -1,3 +1,5 @@
+frameworks: net46, netstandard16, netcoreapp10
+
 source https://www.myget.org/F/dotnet-core/api/v3/index.json
 source https://www.nuget.org/api/v2/
 

samples/FscExe/FscMain.fs

@@ -8,10 +8,10 @@ open System.IO
 open System.Reflection
 open System.Runtime.CompilerServices
 open Microsoft.FSharp.Compiler
+open Microsoft.FSharp.Compiler.SourceCodeServices
 open Microsoft.FSharp.Compiler.AbstractIL.IL // runningOnMono 
 open Microsoft.FSharp.Compiler.AbstractIL.Internal.Library
 open Microsoft.FSharp.Compiler.ErrorLogger
-open Microsoft.FSharp.Compiler.SimpleSourceCodeServices
 open Microsoft.FSharp.Compiler.Range
 
 #if FX_RESHAPED_REFLECTION
@@ -83,7 +83,7 @@ module FSharpResidentCompiler =
                               let! (pwd,argv, reply: AsyncReplyChannel<_>) = inbox.Receive()
                               if !progress then printfn "server agent: got compilation request, argv = %A" argv
                               Environment.CurrentDirectory <- pwd
-                              let errors, exitCode = SimpleSourceCodeServices().Compile (argv); 
+                              let errors, exitCode = FSharpChecker.Create().Compile (argv); 
                               for error in errors do eprintfn "%s" (error.ToString())
                               if !progress then printfn "server: finished compilation request, argv = %A" argv
                               let output = outputCollector.GetTextAndClear()
@@ -286,7 +286,7 @@ module Driver =
             match exitCodeOpt with 
             | Some exitCode -> exitCode
             | None -> 
-                let errors, exitCode = SimpleSourceCodeServices().Compile (argv) 
+                let errors, exitCode = FSharpChecker.Create().Compile (argv) 
                 for error in errors do eprintfn "%s" (error.ToString())
                 exitCode
 
@@ -295,7 +295,7 @@ module Driver =
             0
 
         else
-            let errors, exitCode = SimpleSourceCodeServices().Compile (argv)
+            let errors, exitCode = FSharpChecker.Create().Compile (argv)
             for error in errors do eprintfn "%s" (error.ToString())
             exitCode
 

tests/service/EditorTests.fs

@@ -31,7 +31,6 @@ open System
 open System.IO
 open Microsoft.FSharp.Compiler
 open Microsoft.FSharp.Compiler.SourceCodeServices
-open Microsoft.FSharp.Compiler.SimpleSourceCodeServices
 open FSharp.Compiler.Service.Tests.Common
 
 let stringMethods = 

tests/service/FscTests.fs

@@ -15,7 +15,6 @@ open System.IO
 
 open Microsoft.FSharp.Compiler
 open Microsoft.FSharp.Compiler.SourceCodeServices
-open Microsoft.FSharp.Compiler.SimpleSourceCodeServices
 open FSharp.Compiler.Service.Tests
 open FSharp.Compiler.Service.Tests.Common
 
@@ -111,7 +110,6 @@ type DebugMode =
     | Full
 
 let checker = FSharpChecker.Create()
-let compiler = new SimpleSourceCodeServices()
 
 /// Ensures the default FSharp.Core referenced by the F# compiler service (if none is 
 /// provided explicitly) is available in the output directory.
@@ -127,10 +125,10 @@ let ensureDefaultFSharpCoreAvailable tmpDir  =
         File.Copy(fsCoreDefaultReference(), Path.Combine(tmpDir, Path.GetFileName(fsCoreDefaultReference())), overwrite = true)
 #endif
 
-let compile isDll debugMode (assemblyName : string) (code : string) (dependencies : string list) =
+let compile isDll debugMode (assemblyName : string) (ext: string) (code : string) (dependencies : string list) (extraArgs: string list) =
     let tmp = Path.Combine(Path.GetTempPath(),"test"+string(hash (isDll,debugMode,assemblyName,code,dependencies)))
     try Directory.CreateDirectory(tmp) |> ignore with _ -> ()
-    let sourceFile = Path.Combine(tmp, assemblyName + ".fs")
+    let sourceFile = Path.Combine(tmp, assemblyName + "." + ext)
     let outFile = Path.Combine(tmp, assemblyName + if isDll then ".dll" else ".exe")
     let pdbFile = Path.Combine(tmp, assemblyName + pdbExtension isDll)
     do File.WriteAllText(sourceFile, code)
@@ -158,23 +156,26 @@ let compile isDll debugMode (assemblyName : string) (code : string) (dependencie
 
             yield sprintf "--out:%s" outFile
 
+            yield! extraArgs
+
             yield sourceFile
+
         |]
 
     ensureDefaultFSharpCoreAvailable tmp
 
     printfn "args: %A" args
-    let errorInfo, id = compiler.Compile args
+    let errorInfo, id = checker.Compile args
     for err in errorInfo do 
        printfn "error: %A" err
     if id <> 0 then raise <| CompilationError(assemblyName, id, errorInfo)
     Assert.AreEqual (errorInfo.Length, 0)
     outFile
 
 //sizeof<nativeint>
-let compileAndVerify isDll debugMode assemblyName code dependencies =
+let compileAndVerify isDll debugMode assemblyName ext code dependencies =
     let verifier = new PEVerifier ()
-    let outFile = compile isDll debugMode assemblyName code dependencies 
+    let outFile = compile isDll debugMode assemblyName ext code dependencies  []
     verifier.Verify outFile
     outFile
 
@@ -186,7 +187,7 @@ let compileAndVerifyAst (name : string, ast : Ast.ParsedInput list, references :
 
     ensureDefaultFSharpCoreAvailable outDir
 
-    let errors, id = compiler.Compile(ast, name, outFile, references, executable = false)
+    let errors, id = checker.Compile(ast, name, outFile, references, executable = false)
     for err in errors do printfn "error: %A" err
     Assert.AreEqual (errors.Length, 0)
     if id <> 0 then raise <| CompilationError(name, id, errors)
@@ -225,7 +226,7 @@ module Foo
     printfn "done!" // make the code have some initialization effect
 """
 
-    compileAndVerify true PdbOnly "Foo" code [] |> ignore
+    compileAndVerify true PdbOnly "Foo" "fs" code [] |> ignore
 
 [<Test>]
 let ``3. Simple FSC executable test`` () =
@@ -236,7 +237,7 @@ module Bar
     let main _ = printfn "Hello, World!" ; 42
 
 """
-    let outFile = compileAndVerify false PdbOnly "Bar" code []
+    let outFile = compileAndVerify false PdbOnly "Bar" "fs" code []
 
     use proc = Process.Start(outFile, "")
     proc.WaitForExit()
@@ -295,7 +296,8 @@ module Bar
 
 """    
     try
-        compile false PdbOnly "Bar" code [] |> ignore
+        let outFile : string = compile false PdbOnly "Bar" "fs" code [] [] 
+        ()
     with
     | :? CompilationError as exn  ->
             Assert.AreEqual(6,exn.Data2.[0].StartLineAlternate)
@@ -307,19 +309,51 @@ let ``Check cols are indexed by 1`` () =
     let code = "let x = 1 + a"
 
     try
-        compile false PdbOnly "Foo" code [] |> ignore
+        let outFile : string = compile false PdbOnly "Foo" "fs" code [] []
+        ()
     with
     | :? CompilationError as exn  ->
             Assert.True(exn.Data2.[0].ToString().Contains("Foo.fs (1,13)-(1,14)"))
     | _  -> failwith "No compilation error"
 
 
+[<Test>]
+let ``Check compile of bad fsx`` () =
+    let code = """
+#load "missing.fsx"
+#r "missing.dll"
+    """
+
+    try
+        let outFile : string = compile false PdbOnly "Foo" "fsx" code [] []
+        ()
+    with
+    | :? CompilationError as exn  ->
+            Assert.True(exn.Data2.[0].ToString().Contains("Could not load file '"))
+            Assert.True(exn.Data2.[0].ToString().Contains("missing.fsx"))
+            Assert.True(exn.Data2.[1].ToString().Contains("Could not locate the assembly \"missing.dll\""))
+    | _  -> failwith "No compilation error"
+
+
+[<Test>]
+let ``Check compile of good fsx with bad option`` () =
+    let code = """
+let x = 1
+    """
+
+    try
+        let outFile : string = compile false PdbOnly "Foo" "fsx" code []  ["-r:missing.dll"]
+        ()
+    with
+    | :? CompilationError as exn  ->
+            Assert.True(exn.Data2.[0].ToString().Contains("startup (1,1)-(1,81) parameter error Could not resolve this reference"))
+    | _  -> failwith "No compilation error"
+
 
 #if STRESS
 // For this stress test the aim is to check if we have a memory leak
 
 module StressTest1 = 
-    open Microsoft.FSharp.Compiler.SimpleSourceCodeServices
     open System.IO
 
     [<Test>]
@@ -335,7 +369,8 @@ type C() =
 let x = 3 + 4
 """
 
-        compile true PdbOnly "Foo" code [] |> ignore
+        let outFile : string = compile true PdbOnly "Foo" "fs" code [] []
+        ()
 
 #endif
 

tests/service/ProjectOptionsTests.fs

@@ -439,24 +439,40 @@ let ``Project file parsing -- report files``() =
     for f in Directory.EnumerateFiles(dir41,"*",SearchOption.AllDirectories) do 
      printfn "File: %s" f
 
+[<Test>]
+let ``Test OtherOptions order for GetProjectOptionsFromScript`` () = 
+    let test scriptName expected2 =
+        let scriptPath = __SOURCE_DIRECTORY__ + @"/data/ScriptProject/" + scriptName + ".fsx"
+        let scriptSource = File.ReadAllText scriptPath
+        let projOpts = checker.GetProjectOptionsFromScript(scriptPath, scriptSource) |> Async.RunSynchronously
+
+        projOpts.OtherOptions
+        |> Array.map Path.GetFileNameWithoutExtension
+        |> shouldEqual  expected2
+    let otherArgs = [|"--noframework"; "3"; "System.Numerics"; "mscorlib"; "FSharp.Core"; "System"; "System.Xml"; "System.Runtime.Remoting"; "System.Runtime.Serialization.Formatters.Soap"; "System.Data"; "System.Drawing"; "System.Core"; "System.Runtime"; "System.Linq"; "System.Reflection"; "System.Linq.Expressions"; "System.Threading.Tasks"; "System.IO"; "System.Net.Requests"; "System.Collections"; "System.Runtime.Numerics"; "System.Threading"; "System.Web"; "System.Web.Services"; "System.Windows.Forms"; "FSharp.Compiler.Interactive.Settings"|]
+    test "Main1" otherArgs
+    test "Main2" otherArgs
+    test "Main3" otherArgs
+    test "Main4" otherArgs
+    test "MainBad" otherArgs
+
+
 #endif
 
 [<Test>]
 let ``Test ProjectFileNames order for GetProjectOptionsFromScript`` () = // See #594
     let test scriptName expected =
         let scriptPath = __SOURCE_DIRECTORY__ + @"/data/ScriptProject/" + scriptName + ".fsx"
         let scriptSource = File.ReadAllText scriptPath
-        let projOpts =
-            checker.GetProjectOptionsFromScript(scriptPath, scriptSource)
-            |> Async.RunSynchronously
+        let projOpts = checker.GetProjectOptionsFromScript(scriptPath, scriptSource) |> Async.RunSynchronously
         projOpts.ProjectFileNames
         |> Array.map Path.GetFileNameWithoutExtension
-        |> (=) expected
-        |> shouldEqual true
-    test "Main1" [|"BaseLib1"; "Lib1"; "Lib2"; "Main1"|]
-    test "Main2" [|"BaseLib1"; "Lib1"; "Lib2"; "Lib3"; "Main2"|]
-    test "Main3" [|"Lib3"; "Lib4"; "Main3"|]
-    test "Main4" [|"BaseLib2"; "Lib5"; "BaseLib1"; "Lib1"; "Lib2"; "Main4"|]
+        |> shouldEqual  expected
+    test "Main1" [|"BaseLib1"; "Lib1"; "Lib2"; "Main1"|] 
+    test "Main2" [|"BaseLib1"; "Lib1"; "Lib2"; "Lib3"; "Main2"|] 
+    test "Main3" [|"Lib3"; "Lib4"; "Main3"|] 
+    test "Main4" [|"BaseLib2"; "Lib5"; "BaseLib1"; "Lib1"; "Lib2"; "Main4"|] 
+    test "MainBad" [|"MainBad"|] 
 
 #endif
 

tests/service/data/ScriptProject/MainBad.fsx

@@ -0,0 +1,2 @@
+#load "NotExist1.fsx"
+#r "NotExist.dll"