Merge branch 'master' of https://github.com/fsharp/FSharp.Compiler.Service into fix-tpexpres

Author: dsyme

.travis.yml

@@ -1,5 +1,13 @@
 language: csharp
 
+os:
+  - linux
+  - osx
+
+mono:
+  - latest
+  - 4.0.5
+
 sudo: false
 
 install:

docs/content/interactive.fsx

@@ -31,6 +31,7 @@ First, we need to reference the libraries that contain F# interactive service:
 *)
 
 #r "FSharp.Compiler.Service.dll"
+open Microsoft.FSharp.Compiler.SourceCodeServices
 open Microsoft.FSharp.Compiler.Interactive.Shell
 
 (**
@@ -81,7 +82,7 @@ and other top-level statements.
 let evalInteraction text = 
   fsiSession.EvalInteraction(text)
 (**
-The two functions take string as an argument and evaluate (or execute) it as F# code. The code 
+The two functions each take a string as an argument and evaluate (or execute) it as F# code. The code 
 passed to them does not require `;;` at the end. Just enter the code that you want to execute:
 *)
 evalExpression "42+1"
@@ -97,6 +98,49 @@ let evalScript scriptPath =
 File.WriteAllText("sample.fsx", "let twenty = 10 + 10")
 evalScript "sample.fsx"
 
+(**
+Catching errors
+------------------
+
+``EvalExpression``, ``EvalInteraction`` and ``EvalScript`` are awkward if the
+code has type checking warnings or errors, or if evaluation fails with an exception.
+In these cases you can use ``EvalExpressionNonThrowing``, ``EvalInteractionNonThrowing``
+and ``EvalScriptNonThrowing``. These return a tuple of a result and an array of ``FSharpErrorInfo`` values.
+These represent the errors and warnings. The result part is a ``Choice<_,_>`` between an actual 
+result and an exception.
+
+The result part of ``EvalExpression`` and ``EvalExpressionNonThrowing`` is an optional ``FSharpValue``.
+If that value is not present then it just indicates that the expression didn't have a tangible
+result that could be represented as a .NET object.  This siutation shouldn't actually
+occur for any normal input expressions, and only for primitives used in libraries.
+*)
+
+File.WriteAllText("sample.fsx", "let twenty = 'a' + 10.0")
+let result, warnings = fsiSession.EvalScriptNonThrowing "sample.fsx"
+
+// show the result
+match result with 
+| Choice1Of2 () -> printfn "checked and executed ok"
+| Choice2Of2 exn -> printfn "execution exception: %s" exn.Message
+
+(**
+Gives:
+
+    execution exception: Operation could not be completed due to earlier error
+*)
+
+// show the errors and warnings
+for w in warnings do 
+   printfn "Warning %s at %d,%d" w.Message w.StartLineAlternate w.StartColumn 
+
+(**
+Gives:
+
+    Warning The type 'float' does not match the type 'char' at 1,19
+    Warning The type 'float' does not match the type 'char' at 1,17
+*)
+
+
 (**
 Type checking in the evaluation context
 ------------------
@@ -129,8 +173,8 @@ You can also request declaration list information, tooltip text and symbol resol
 *)
 open Microsoft.FSharp.Compiler
 
-let identToken = Parser.tagOfToken(Parser.token.IDENT("")) 
-checkResults.GetToolTipTextAlternate(1, 2, "xxx + xx", ["xxx"], identToken) // a tooltip
+// get a tooltip
+checkResults.GetToolTipTextAlternate(1, 2, "xxx + xx", ["xxx"], FSharpTokenTag.IDENT) 
 
 checkResults.GetSymbolUseAtLocation(1, 2, "xxx + xx", ["xxx"]) // symbol xxx
 

docs/content/project.fsx

@@ -23,6 +23,7 @@ of `InteractiveChecker`:
 *)
 // Reference F# compiler API
 #r "FSharp.Compiler.Service.dll"
+#r "FSharp.Compiler.Service.ProjectCracker.dll"
 
 open System
 open System.Collections.Generic
@@ -316,7 +317,7 @@ for any project that builds cleanly using the command line tools 'xbuild' or 'ms
 
 let projectFile  = __SOURCE_DIRECTORY__ + @"/../../src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj"
 
-checker.GetProjectOptionsFromProjectFile(projectFile)
+ProjectCracker.GetProjectOptionsFromProjectFile(projectFile)
 
 
 (**
@@ -325,7 +326,7 @@ You can also request RELEASE mode and set other build configuration parameters:
 
 *)
 
-checker.GetProjectOptionsFromProjectFile(projectFile, [("Configuration", "Release")])
+ProjectCracker.GetProjectOptionsFromProjectFile(projectFile, [("Configuration", "Release")])
 
 (**
 

src/fsharp/ErrorLogger.fs

@@ -38,7 +38,7 @@ let rec findOriginalException err =
 
 
 /// Thrown when we stop processing the F# Interactive entry or #load.
-exception StopProcessing of string
+exception StopProcessing of exn option
 
 
 (* common error kinds *)

src/fsharp/FSharp.Compiler.Service.ProjectCracker.Exe/Program.fs

@@ -378,20 +378,23 @@ module Program =
       // C# referenced projects, as we don't look at them otherwise.
       let referencedProjectOutputs =
           if runningOnMono then
-              [| yield! Array.map (fun (s,_) -> "-r:" + s) referencedProjectOptions
-                 for file in parsedProject.ProjectReferences do
-                     let ext = Path.GetExtension(file)
-                     if ext = ".csproj" || ext = ".vbproj" then
-                         let parsedProject = FSharpProjectFileInfo.Parse(file, properties=properties, enableLogging=false)
-                         match parsedProject.OutputFile with
-                         | None -> ()
-                         | Some f -> yield "-r:" + f |]
+              [ yield! Array.map (fun (s,_) -> "-r:" + s) referencedProjectOptions
+                for file in parsedProject.ProjectReferences do
+                    let ext = Path.GetExtension(file)
+                    if ext = ".csproj" || ext = ".vbproj" then
+                        let parsedProject = FSharpProjectFileInfo.Parse(file, properties=properties, enableLogging=false)
+                        match parsedProject.OutputFile with
+                        | None -> ()
+                        | Some f -> yield "-r:" + f ]
           else
-              [||]
+              []
+
+          // On some versions of Mono the referenced projects are already
+          // correctly included, so we make sure not to introduce duplicates
+          |> List.filter (fun r -> not (Set.contains r (set parsedProject.Options)))
 
       let options = { ProjectFile = file
-                      Options = Array.append (Array.ofList (parsedProject.Options))
-                                             referencedProjectOutputs
+                      Options = Array.ofSeq (parsedProject.Options @ referencedProjectOutputs)
                       ReferencedProjectOptions = referencedProjectOptions
                       LogOutput = parsedProject.LogOutput }
 

src/fsharp/FSharp.Compiler.Service.ProjectCracker/ProjectCracker.fs

@@ -13,7 +13,7 @@ type ProjectCracker =
     static member GetProjectOptionsFromProjectFileLogged(projectFileName : string, ?properties : (string * string) list, ?loadedTimeStamp, ?enableLogging) =
         let loadedTimeStamp = defaultArg loadedTimeStamp DateTime.MaxValue // Not 'now', we don't want to force reloading
         let properties = defaultArg properties []
-        let enableLogging = defaultArg enableLogging false
+        let enableLogging = defaultArg enableLogging true
         let logMap = ref Map.empty
 
         let rec convert (opts: FSharp.Compiler.Service.ProjectCracker.Exe.ProjectOptions) : FSharpProjectOptions =
@@ -50,4 +50,8 @@ type ProjectCracker =
         convert opts, !logMap
 
     static member GetProjectOptionsFromProjectFile(projectFileName : string, ?properties : (string * string) list, ?loadedTimeStamp) =
-        fst (ProjectCracker.GetProjectOptionsFromProjectFileLogged(projectFileName, ?properties=properties, ?loadedTimeStamp=loadedTimeStamp))
+        fst (ProjectCracker.GetProjectOptionsFromProjectFileLogged(
+                projectFileName,
+                ?properties=properties,
+                ?loadedTimeStamp=loadedTimeStamp,
+                enableLogging=false))

src/fsharp/fsc.fs

@@ -2099,7 +2099,7 @@ type InProcCompiler() =
         let exitCode = ref 0
         let exiter = 
             { new Exiter with
-                 member this.Exit n = exitCode := n; raise (StopProcessing "") }
+                 member this.Exit n = exitCode := n; raise (StopProcessing None) }
         try 
             typecheckAndCompile(argv, false, true, exiter, loggerProvider, None, None)
         with