Fix 469 - meaningful errors from EvalScript etc

Author: dsyme

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/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 

src/fsharp/fsi/fsi.fs

@@ -13,6 +13,7 @@
 module Microsoft.FSharp.Compiler.Interactive.Shell
 
 open System.IO
+open Microsoft.FSharp.Compiler
 open Microsoft.FSharp.Compiler.SourceCodeServices
 
 [<Class>]
@@ -146,6 +147,15 @@ type FsiEvaluationSession =
     /// by input from 'stdin'.
     member EvalInteraction : code: string -> unit
 
+    /// Execute the code as if it had been entered as one or more interactions, with an
+    /// implicit termination at the end of the input. Stop on first error, discarding the rest
+    /// of the input. Errors and warnings are collected apart from any exception arising from execution
+    /// which is returned via a Choice. Execution is performed on the 'Run()' thread.
+    ///
+    /// Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered
+    /// by input from 'stdin'.
+    member EvalInteractionNonThrowing : code: string -> Choice<unit, exn> * FSharpErrorInfo[]
+
     /// Execute the given script. Stop on first error, discarding the rest
     /// of the script. Errors are sent to the output writer, a 'true' return value indicates there
     /// were no errors overall. Execution is performed on the 'Run()' thread.
@@ -154,16 +164,33 @@ type FsiEvaluationSession =
     /// by input from 'stdin'.
     member EvalScript : filePath: string -> unit
 
+    /// Execute the given script. Stop on first error, discarding the rest
+    /// of the script. Errors and warnings are collected apart from any exception arising from execution
+    /// which is returned via a Choice. Execution is performed on the 'Run()' thread.
+    ///
+    /// Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered
+    /// by input from 'stdin'.
+    member EvalScriptNonThrowing : filePath: string -> Choice<unit, exn> * FSharpErrorInfo[]
+
     /// Execute the code as if it had been entered as one or more interactions, with an
     /// implicit termination at the end of the input. Stop on first error, discarding the rest
-    /// of the input. Errors are sent to the output writer, a 'true' return value indicates there
-    /// were no errors overall. Parsing is performed on the current thread, and execution is performed 
+    /// of the input. Errors are sent to the output writer. Parsing is performed on the current thread, and execution is performed 
     /// sycnhronously on the 'main' thread.
     ///
     /// Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered
     /// by input from 'stdin'.
     member EvalExpression : code: string -> FsiValue option
 
+    /// Execute the code as if it had been entered as one or more interactions, with an
+    /// implicit termination at the end of the input. Stop on first error, discarding the rest
+    /// of the input. Errors and warnings are collected apart from any exception arising from execution
+    /// which is returned via a Choice. Parsing is performed on the current thread, and execution is performed 
+    /// sycnhronously on the 'main' thread.
+    ///
+    /// Due to a current limitation, it is not fully thread-safe to run this operation concurrently with evaluation triggered
+    /// by input from 'stdin'.
+    member EvalExpressionNonThrowing : code: string -> Choice<FsiValue option, exn> * FSharpErrorInfo[] 
+
     /// Raised when an interaction is successfully typechecked and executed, resulting in an update to the
     /// type checking state.  
     ///

src/fsharp/fsi/fsi.fsi

@@ -1084,7 +1084,7 @@ type FrameworkImportsCache(keepStrongly) =
 
 
 /// An error logger that capture errors, filtering them according to warning levels etc.
-type CompilationErrorLogger (debugName:string, tcConfig:TcConfig) = 
+type internal CompilationErrorLogger (debugName:string, tcConfig:TcConfig) = 
     inherit ErrorLogger("CompilationErrorLogger("+debugName+")")
 
     let warningsSeenInScope = new ResizeArray<_>()
@@ -1192,7 +1192,7 @@ type IncrementalBuilder(frameworkTcImportsCache: FrameworkImportsCache, tcConfig
     // This operation is done when constructing the builder itself, rather than as an incremental task. 
     let nonFrameworkAssemblyInputs = 
         // Note we are not calling errorLogger.GetErrors() anywhere for this task. 
-        // REVIEW: Consider if this is ok. I believe so, because this is a background build and we aren'T currently reporting errors from the background build. 
+        // This is ok because not much can actually go wrong here.
         let errorLogger = CompilationErrorLogger("nonFrameworkAssemblyInputs", tcConfig)
         // Return the disposable object that cleans up
         use _holder = new CompilationGlobalsScope(errorLogger,BuildPhase.Parameter, projectDirectory) 
@@ -1207,12 +1207,11 @@ type IncrementalBuilder(frameworkTcImportsCache: FrameworkImportsCache, tcConfig
                         DateTime.Now                               
                 with e -> 
                     // Note we are not calling errorLogger.GetErrors() anywhere for this task. This warning will not be reported...
-                    // REVIEW: Consider if this is ok. I believe so, because this is a background build and we aren't currently reporting errors from the background build. 
                     errorLogger.Warning(e)
                     DateTime.Now                               
             yield (Choice1Of2 r.resolvedPath,originalTimeStamp)  
             for pr in projectReferences  do
-            yield Choice2Of2 pr, defaultArg (pr.GetLogicalTimeStamp()) DateTime.Now]
+                yield Choice2Of2 pr, defaultArg (pr.GetLogicalTimeStamp()) DateTime.Now]
 
     // The IncrementalBuilder needs to hold up to one item that needs to be disposed, which is the tcImports for the incremental
     // build. 
@@ -1725,7 +1724,7 @@ type IncrementalBuilder(frameworkTcImportsCache: FrameworkImportsCache, tcConfig
                         else MSBuildResolver.CompileTimeLike
 
                 tcConfigB.conditionalCompilationDefines <- 
-                    let define = if useScriptResolutionRules then "INTERACTIVE" else "COMPILED"
+                    let define = if useScriptResolutionRules then "INTERACTIVE" else "MPILED"
                     define::tcConfigB.conditionalCompilationDefines
 
                 tcConfigB.projectReferences <- projectReferences

src/fsharp/vs/IncrementalBuild.fs

@@ -52,6 +52,16 @@ type internal FrameworkImportsCache =
     member Clear: unit -> unit
     member Downsize: unit -> unit
   
+/// An error logger that capture errors, filtering them according to warning levels etc.
+type internal CompilationErrorLogger = 
+    inherit ErrorLogger
+
+    /// Create the error logger
+    new : debugName:string * tcConfig:TcConfig ->  CompilationErrorLogger
+            
+    /// Get the captured errors
+    member GetErrors : unit -> (PhasedError * FSharpErrorSeverity) list
+
 /// Represents the state in the incremental graph assocaited with checking a file
 type internal PartialCheckResults = 
     { TcState : TcState 

src/fsharp/vs/IncrementalBuild.fsi

@@ -136,7 +136,7 @@ namespace Microsoft.FSharp.Compiler.SimpleSourceCodeServices
         let tryCompile errorLogger f = 
             use unwindParsePhase = PushThreadBuildPhaseUntilUnwind (BuildPhase.Parse)            
             use unwindEL_2 = PushErrorLoggerPhaseUntilUnwind (fun _ -> errorLogger)
-            let exiter = { new Exiter with member x.Exit n = raise (StopProcessing "") }
+            let exiter = { new Exiter with member x.Exit n = raise (StopProcessing None) }
             try 
                 f exiter
                 0

src/fsharp/vs/SimpleServices.fs

@@ -1527,7 +1527,8 @@ module internal Parser =
             for e in relatedErrors do 
                 yield! oneError true e ]
 
-    let CreateErrorInfos (tcConfig:TcConfig, allErrors, mainInputFileName, fileInfo, errors) = 
+    let CreateErrorInfos (tcConfig:TcConfig, allErrors, mainInputFileName, errors) = 
+        let fileInfo = (Int32.MaxValue, Int32.MaxValue)
         [| for (exn,warn) in errors do 
               yield! ReportError (tcConfig, allErrors, mainInputFileName, fileInfo, (exn, warn)) |]
 
@@ -2392,8 +2393,7 @@ type BackgroundCompiler(projectCacheSize, keepAssemblyContents, keepAllBackgroun
             | Some builder -> 
             let inputOpt,_,_,parseErrors = builder.GetParseResultsForFile filename            
             let dependencyFiles = builder.Dependencies 
-            let fileInfo = (Int32.MaxValue, Int32.MaxValue)
-            let errors = [| yield! creationErrors; yield! Parser.CreateErrorInfos (builder.TcConfig, false, filename, fileInfo, parseErrors) |]
+            let errors = [| yield! creationErrors; yield! Parser.CreateErrorInfos (builder.TcConfig, false, filename, parseErrors) |]
             FSharpParseFileResults(errors = errors, input = inputOpt, parseHadErrors = false, dependencyFiles = dependencyFiles)
         )
 
@@ -2508,9 +2508,8 @@ type BackgroundCompiler(projectCacheSize, keepAssemblyContents, keepAllBackgroun
             | Some builder -> 
                 let (inputOpt, _, _, untypedErrors) = builder.GetParseResultsForFile filename  
                 let tcProj = builder.GetCheckResultsAfterFileInProject filename 
-                let fileInfo = (Int32.MaxValue, Int32.MaxValue)
-                let untypedErrors = [| yield! creationErrors; yield! Parser.CreateErrorInfos (builder.TcConfig, false, filename, fileInfo, untypedErrors) |]
-                let tcErrors = [| yield! creationErrors; yield! Parser.CreateErrorInfos (builder.TcConfig, false, filename, fileInfo, tcProj.Errors) |]
+                let untypedErrors = [| yield! creationErrors; yield! Parser.CreateErrorInfos (builder.TcConfig, false, filename, untypedErrors) |]
+                let tcErrors = [| yield! creationErrors; yield! Parser.CreateErrorInfos (builder.TcConfig, false, filename, tcProj.Errors) |]
                 let parseResults = FSharpParseFileResults(errors = untypedErrors, input = inputOpt, parseHadErrors = false, dependencyFiles = builder.Dependencies)
                 let loadClosure = scriptClosureCache.TryGet options 
                 let scope = 
@@ -2539,8 +2538,7 @@ type BackgroundCompiler(projectCacheSize, keepAssemblyContents, keepAllBackgroun
             FSharpCheckProjectResults (keepAssemblyContents, Array.ofList creationErrors, None, reactorOps)
         | Some builder -> 
             let (tcProj, ilAssemRef, tcAssemblyDataOpt, tcAssemblyExprOpt)  = builder.GetCheckResultsAndImplementationsForProject()
-            let fileInfo = (Int32.MaxValue, Int32.MaxValue)
-            let errors = [| yield! creationErrors; yield! Parser.CreateErrorInfos (tcProj.TcConfig, true, Microsoft.FSharp.Compiler.TcGlobals.DummyFileNameForRangesWithoutASpecificLocation, fileInfo, tcProj.Errors) |]
+            let errors = [| yield! creationErrors; yield! Parser.CreateErrorInfos (tcProj.TcConfig, true, Microsoft.FSharp.Compiler.TcGlobals.DummyFileNameForRangesWithoutASpecificLocation, tcProj.Errors) |]
             FSharpCheckProjectResults (keepAssemblyContents, errors, Some(tcProj.TcGlobals, tcProj.TcImports, tcProj.TcState.Ccu, tcProj.TcState.PartialAssemblySignature, tcProj.TcSymbolUses, tcProj.TopAttribs, tcAssemblyDataOpt, ilAssemRef, tcProj.TcEnvAtEnd.AccessRights, tcAssemblyExprOpt), reactorOps)
 
     /// Get the timestamp that would be on the output if fully built immediately
@@ -3238,6 +3236,9 @@ type FSharpChecker(projectCacheSize, keepAssemblyContents, keepAllBackgroundReso
 type FsiInteractiveChecker(reactorOps: IReactorOperations, tcConfig, tcGlobals, tcImports, tcState, loadClosure) =
     let keepAssemblyContents = false
 
+    static member CreateErrorInfos (tcConfig, allErrors, mainInputFileName, errors) = 
+        Parser.CreateErrorInfos(tcConfig, allErrors, mainInputFileName, errors)
+
     member __.ParseAndCheckInteraction (source) =
 
         let mainInputFileName = "stdin.fsx" 

src/fsharp/vs/service.fs

@@ -722,6 +722,7 @@ type FSharpChecker =
 type internal FsiInteractiveChecker =
     internal new : ops: IReactorOperations * tcConfig: TcConfig * tcGlobals: TcGlobals * tcImports: TcImports * tcState: TcState * loadClosure: LoadClosure option ->  FsiInteractiveChecker 
     member internal ParseAndCheckInteraction : source:string -> FSharpParseFileResults * FSharpCheckFileResults * FSharpCheckProjectResults
+    static member internal CreateErrorInfos : tcConfig: TcConfig * allErrors:bool * mainInputFileName : string * seq<ErrorLogger.PhasedError * FSharpErrorSeverity> -> FSharpErrorInfo[]
 
 /// Information about the compilation environment
 type [<Class>] CompilerEnvironment =