fix syntax errors and transitive errors in scripts

FSharp.sln

@@ -196,16 +196,6 @@ Global
 		{4239EFEA-E746-446A-BF7A-51FCBAB13946}.Release|Any CPU.Build.0 = Release|Any CPU
 		{4239EFEA-E746-446A-BF7A-51FCBAB13946}.Release|x86.ActiveCfg = Release|Any CPU
 		{4239EFEA-E746-446A-BF7A-51FCBAB13946}.Release|x86.Build.0 = Release|Any CPU
-		{BF5C6D92-D053-4216-9C42-B62F5F5C5E91}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{BF5C6D92-D053-4216-9C42-B62F5F5C5E91}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{BF5C6D92-D053-4216-9C42-B62F5F5C5E91}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{BF5C6D92-D053-4216-9C42-B62F5F5C5E91}.Debug|x86.Build.0 = Debug|Any CPU
-		{BF5C6D92-D053-4216-9C42-B62F5F5C5E91}.Proto|Any CPU.ActiveCfg = Release|Any CPU
-		{BF5C6D92-D053-4216-9C42-B62F5F5C5E91}.Proto|x86.ActiveCfg = Release|Any CPU
-		{BF5C6D92-D053-4216-9C42-B62F5F5C5E91}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{BF5C6D92-D053-4216-9C42-B62F5F5C5E91}.Release|Any CPU.Build.0 = Release|Any CPU
-		{BF5C6D92-D053-4216-9C42-B62F5F5C5E91}.Release|x86.ActiveCfg = Release|Any CPU
-		{BF5C6D92-D053-4216-9C42-B62F5F5C5E91}.Release|x86.Build.0 = Release|Any CPU
 		{2E60864A-E3FF-4BCC-810F-DC7C34E6B236}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{2E60864A-E3FF-4BCC-810F-DC7C34E6B236}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2E60864A-E3FF-4BCC-810F-DC7C34E6B236}.Debug|x86.ActiveCfg = Debug|Any CPU
@@ -245,7 +235,6 @@ Global
 		{A8D9641A-9170-4CF4-8FE0-6DB8C134E1B5} = {CFE3259A-2D30-4EB0-80D5-E8B5F3D01449}
 		{88E2D422-6852-46E3-A740-83E391DC7973} = {CFE3259A-2D30-4EB0-80D5-E8B5F3D01449}
 		{4239EFEA-E746-446A-BF7A-51FCBAB13946} = {CFE3259A-2D30-4EB0-80D5-E8B5F3D01449}
-		{BF5C6D92-D053-4216-9C42-B62F5F5C5E91} = {CFE3259A-2D30-4EB0-80D5-E8B5F3D01449}
 		{2E60864A-E3FF-4BCC-810F-DC7C34E6B236} = {CFE3259A-2D30-4EB0-80D5-E8B5F3D01449}
 		{BDA4D411-6AD9-4B3E-A3B3-07BAD6BEF1ED} = {CFE3259A-2D30-4EB0-80D5-E8B5F3D01449}
 	EndGlobalSection

src/fsharp/CompileOps.fsi

@@ -74,48 +74,53 @@ val ParseInput : (UnicodeLexing.Lexbuf -> Parser.token) * ErrorLogger * UnicodeL
 //--------------------------------------------------------------------------
 
 /// Get the location associated with an error
-val GetRangeOfError : PhasedError -> range option
+val GetRangeOfDiagnostic : PhasedDiagnostic -> range option
 
 /// Get the number associated with an error
-val GetErrorNumber : PhasedError -> int
+val GetDiagnosticNumber : PhasedDiagnostic -> int
 
 /// Split errors into a "main" error and a set of associated errors
-val SplitRelatedErrors : PhasedError -> PhasedError * PhasedError list
+val SplitRelatedDiagnostics : PhasedDiagnostic -> PhasedDiagnostic * PhasedDiagnostic list
 
 /// Output an error to a buffer
-val OutputPhasedError : ErrorLogger.ErrorStyle -> StringBuilder -> PhasedError -> bool -> unit
+val OutputPhasedDiagnostic : ErrorStyle -> StringBuilder -> PhasedDiagnostic -> isError: bool -> unit
 
 /// Output an error or warning to a buffer
-val OutputErrorOrWarning : implicitIncludeDir:string * showFullPaths: bool * flattenErrors: bool * errorStyle: ErrorStyle *  warning:bool -> StringBuilder -> PhasedError -> unit
+val OutputDiagnostic : implicitIncludeDir:string * showFullPaths: bool * flattenErrors: bool * errorStyle: ErrorStyle *  isError:bool -> StringBuilder -> PhasedDiagnostic -> unit
 
 /// Output extra context information for an error or warning to a buffer
-val OutputErrorOrWarningContext : prefix:string -> fileLineFunction:(string -> int -> string) -> StringBuilder -> PhasedError -> unit
+val OutputDiagnosticContext : prefix:string -> fileLineFunction:(string -> int -> string) -> StringBuilder -> PhasedDiagnostic -> unit
 
+/// Part of LegacyHostedCompilerForTesting
 [<RequireQualifiedAccess>]
-type ErrorLocation =
+type DiagnosticLocation =
     { Range : range
       File : string
       TextRepresentation : string
       IsEmpty : bool }
 
+/// Part of LegacyHostedCompilerForTesting
 [<RequireQualifiedAccess>]
-type CanonicalInformation = 
+type DiagnosticCanonicalInformation = 
     { ErrorNumber : int
       Subcategory : string
       TextRepresentation : string }
 
+/// Part of LegacyHostedCompilerForTesting
 [<RequireQualifiedAccess>]
-type DetailedIssueInfo = 
-    { Location : ErrorLocation option
-      Canonical : CanonicalInformation
+type DiagnosticDetailedInfo = 
+    { Location : DiagnosticLocation option
+      Canonical : DiagnosticCanonicalInformation
       Message : string }
 
+/// Part of LegacyHostedCompilerForTesting
 [<RequireQualifiedAccess>]
-type ErrorOrWarning = 
+type Diagnostic = 
     | Short of bool * string
-    | Long of bool * DetailedIssueInfo
+    | Long of bool * DiagnosticDetailedInfo
 
-val CollectErrorOrWarning : implicitIncludeDir:string * showFullPaths: bool * flattenErrors: bool * errorStyle: ErrorStyle *  warning:bool * PhasedError -> seq<ErrorOrWarning>
+/// Part of LegacyHostedCompilerForTesting
+val CollectDiagnostic : implicitIncludeDir:string * showFullPaths: bool * flattenErrors: bool * errorStyle: ErrorStyle *  warning:bool * PhasedDiagnostic -> seq<Diagnostic>
 
 //----------------------------------------------------------------------------
 // Resolve assembly references 
@@ -717,10 +722,10 @@ val TypeCheckOneInputAndFinishEventually :
         -> Eventually<(TcEnv * TopAttribs * TypedImplFile list) * TcState>
 
 /// Indicates if we should report a warning
-val ReportWarning : globalWarnLevel: int * specificWarnOff: int list * specificWarnOn: int list -> PhasedError -> bool
+val ReportWarning : globalWarnLevel: int * specificWarnOff: int list * specificWarnOn: int list -> PhasedDiagnostic -> bool
 
 /// Indicates if we should report a warning as an error
-val ReportWarningAsError : globalWarnLevel: int * specificWarnOff: int list * specificWarnOn: int list * specificWarnAsError: int list * specificWarnAsWarn: int list * globalWarnAsError: bool -> PhasedError -> bool
+val ReportWarningAsError : globalWarnLevel: int * specificWarnOff: int list * specificWarnOn: int list * specificWarnAsError: int list * specificWarnAsWarn: int list * globalWarnAsError: bool -> PhasedDiagnostic -> bool
 
 //----------------------------------------------------------------------------
 // #load closure
@@ -732,6 +737,14 @@ type CodeContext =
     | Compilation
     | Editing
 
+[<RequireQualifiedAccess>]
+type LoadClosureInput = 
+    { FileName: string
+      SyntaxTree: ParsedInput option
+      ParseDiagnostics: (PhasedDiagnostic * bool) list 
+      MetaCommandDiagnostics: (PhasedDiagnostic * bool) list  }
+
+
 [<RequireQualifiedAccess>]
 type LoadClosure = 
     { /// The source files along with the ranges of the #load positions in each file.
@@ -740,26 +753,26 @@ type LoadClosure =
       /// The resolved references along with the ranges of the #r positions in each file.
       References: (string * AssemblyResolution list) list
 
-      /// The list of references that were not resolved during load closure. These may still be extension references.
+      /// The list of references that were not resolved during load closure.
       UnresolvedReferences : UnresolvedAssemblyReference list
 
-      /// The list of all sources in the closure with inputs when available
-      Inputs: (string * ParsedInput option * PhasedError list * PhasedError list) list
+      /// The list of all sources in the closure with inputs when available, with associated parse errors and warnings
+      Inputs: LoadClosureInput list
+
+      /// The original #load references, including those that didn't resolve
+      OriginalLoadReferences: (range * string) list
 
       /// The #nowarns
       NoWarns: (string * range list) list
 
-      /// Errors seen while processing resolutions
-      ResolutionErrors : PhasedError list
-
-      /// Warnings seen while processing resolutions
-      ResolutionWarnings : PhasedError list 
+      /// Diagnostics seen while processing resolutions
+      ResolutionDiagnostics : (PhasedDiagnostic * bool)  list
 
-      /// *Parse* errors seen while parsing root of closure
-      RootErrors : PhasedError list
+      /// Diagnostics to show for root of closure (used by fsc.fs)
+      AllRootFileDiagnostics : (PhasedDiagnostic * bool) list
 
-      /// *Parse* warnings seen while parsing root of closure
-      RootWarnings : PhasedError list }
+      /// Diagnostics seen while processing the compiler options implied root of closure
+      LoadClosureRootFileDiagnostics : (PhasedDiagnostic * bool) list }   
 
     // Used from service.fs, when editing a script file
     static member ComputeClosureOfSourceText : referenceResolver: ReferenceResolver.Resolver * filename: string * source: string * implicitDefines:CodeContext * useSimpleResolution: bool * useFsiAuxLib: bool * lexResourceManager: Lexhelp.LexResourceManager * applyCompilerOptions: (TcConfigBuilder -> unit) * assumeDotNetFramework : bool -> LoadClosure

src/fsharp/CompileOptions.fs

@@ -1350,7 +1350,7 @@ let GetGeneratedILModuleName (t:CompilerTarget) (s:string) =
 
 let ignoreFailureOnMono1_1_16 f = try f() with _ -> ()
 
-let DoWithErrorColor isWarn f =
+let DoWithErrorColor isError f =
     if not enableConsoleColoring then
         f()
     else
@@ -1367,7 +1367,7 @@ let DoWithErrorColor isWarn f =
               try
                 let warnColor  = if Console.BackgroundColor = ConsoleColor.White then ConsoleColor.DarkBlue else ConsoleColor.Cyan
                 let errorColor = ConsoleColor.Red
-                ignoreFailureOnMono1_1_16 (fun () -> Console.ForegroundColor <- (if isWarn then warnColor else errorColor))
+                ignoreFailureOnMono1_1_16 (fun () -> Console.ForegroundColor <- (if isError then errorColor else warnColor))
                 f()
               finally
                 ignoreFailureOnMono1_1_16 (fun () -> Console.ForegroundColor <- c)

src/fsharp/CompileOptions.fsi

@@ -92,7 +92,7 @@ val NormalizeAssemblyRefs : TcImports -> (AbstractIL.IL.ILScopeRef -> AbstractIL
 // Miscellany
 val ignoreFailureOnMono1_1_16 : (unit -> unit) -> unit
 val mutable enableConsoleColoring : bool
-val DoWithErrorColor : bool -> (unit -> 'a) -> 'a
+val DoWithErrorColor : isError:bool -> (unit -> 'a) -> 'a
 val ReportTime : TcConfig -> string -> unit
 val GetAbbrevFlagSet : TcConfigBuilder -> bool -> Set<string>
 val PostProcessCompilerArgs : string Set -> string [] -> string list

src/fsharp/ErrorLogger.fs

@@ -176,9 +176,10 @@ module BuildPhaseSubcategory =
     let Internal = "internal"          // Compiler ICE
 
 [<System.Diagnostics.DebuggerDisplay("{DebugDisplay()}")>]
-type PhasedError = { Exception:exn; Phase:BuildPhase } with
+type PhasedDiagnostic = 
+    { Exception:exn; Phase:BuildPhase }
     /// Construct a phased error
-    static member Create(exn:exn,phase:BuildPhase) : PhasedError =
+    static member Create(exn:exn,phase:BuildPhase) : PhasedDiagnostic =
         System.Diagnostics.Debug.Assert(phase<>BuildPhase.DefaultPhase, sprintf "Compile error seen with no phase to attribute it to.%A %s %s" phase exn.Message exn.StackTrace )        
         {Exception = exn; Phase=phase}
     member this.DebugDisplay() =
@@ -236,9 +237,9 @@ type PhasedError = { Exception:exn; Phase:BuildPhase } with
         // Sanity check ensures that Phase matches Subcategory            
 #if DEBUG
         if isPhaseInCompile then 
-            System.Diagnostics.Debug.Assert(PhasedError.IsSubcategoryOfCompile(pe.Subcategory()), "Subcategory did not match isPhaesInCompile=true")
+            System.Diagnostics.Debug.Assert(PhasedDiagnostic.IsSubcategoryOfCompile(pe.Subcategory()), "Subcategory did not match isPhaesInCompile=true")
         else
-            System.Diagnostics.Debug.Assert(not(PhasedError.IsSubcategoryOfCompile(pe.Subcategory())), "Subcategory did not match isPhaseInCompile=false")
+            System.Diagnostics.Debug.Assert(not(PhasedDiagnostic.IsSubcategoryOfCompile(pe.Subcategory())), "Subcategory did not match isPhaseInCompile=false")
 #endif            
         isPhaseInCompile
 
@@ -248,39 +249,33 @@ type ErrorLogger(nameForDebugging:string) =
     abstract ErrorCount: int
     // The 'Impl' factoring enables a developer to place a breakpoint at the non-Impl 
     // code just below and get a breakpoint for all error logger implementations.
-    abstract WarnSinkImpl: PhasedError -> unit
-    abstract ErrorSinkImpl: PhasedError -> unit
-    member this.WarnSink err = 
-        this.WarnSinkImpl err
-    member this.ErrorSink err =
-        this.ErrorSinkImpl err
+    abstract DiagnosticSink: phasedError: PhasedDiagnostic * isError: bool -> unit
     member this.DebugDisplay() = sprintf "ErrorLogger(%s)" nameForDebugging
-    // Record the reported error/warning numbers for SQM purpose
-    abstract ErrorNumbers : int list
-    abstract WarningNumbers : int list
-    default this.ErrorNumbers = []
-    default this.WarningNumbers = []
 
 let DiscardErrorsLogger = 
     { new ErrorLogger("DiscardErrorsLogger") with 
-            member x.WarnSinkImpl(e) = 
-                ()
-            member x.ErrorSinkImpl(e) = 
-                ()
-            member x.ErrorCount = 
-                0 }
+            member x.DiagnosticSink(phasedError,isError) = ()
+            member x.ErrorCount = 0 }
 
 let AssertFalseErrorLogger =
     { new ErrorLogger("AssertFalseErrorLogger") with 
-            member x.WarnSinkImpl(e) = 
-                assert false; ()
-            member x.ErrorSinkImpl(e) = 
-                assert false; ()
-            member x.ErrorCount = 
-                assert false; 0 }
+            member x.DiagnosticSink(phasedError,isError) = assert false; ()
+            member x.ErrorCount = assert false; 0 }
+
+type CapturingErrorLogger(nm) = 
+    inherit ErrorLogger(nm) 
+    let mutable errorCount = 0 
+    let diagnostics = ResizeArray()
+    override x.DiagnosticSink(phasedError, isError) = 
+        if isError then errorCount <- errorCount + 1
+        diagnostics.Add (phasedError, isError) 
+    override x.ErrorCount = errorCount
+    member x.Diagnostics = diagnostics |> Seq.toList
+    member x.CommitDelayedDiagnostics(errorLogger:ErrorLogger) = 
+        // Eagerly grab all the errors and warnings from the mutable collection
+        let errors = diagnostics.ToArray()
+        errors |> Array.iter errorLogger.DiagnosticSink
 
-/// When no errorLogger is installed (on the thread) use this one.
-let uninitializedErrorLoggerFallback = ref AssertFalseErrorLogger
 
 /// Type holds thread-static globals for use by the compile.
 type internal CompileThreadStatic =
@@ -301,7 +296,7 @@ type internal CompileThreadStatic =
     static member ErrorLogger
         with get() = 
             match box CompileThreadStatic.errorLogger with
-            | null -> !uninitializedErrorLoggerFallback
+            | null -> AssertFalseErrorLogger
             | _ -> CompileThreadStatic.errorLogger
         and set v = CompileThreadStatic.errorLogger <- v
 
@@ -343,15 +338,30 @@ module ErrorLoggerExtensions =
 #endif
 
     type ErrorLogger with  
-        member x.ErrorR  exn = match exn with StopProcessing | ReportedError _ -> raise exn | _ -> x.ErrorSink(PhasedError.Create(exn,CompileThreadStatic.BuildPhase))
-        member x.Warning exn = match exn with StopProcessing | ReportedError _ -> raise exn | _ -> x.WarnSink(PhasedError.Create(exn,CompileThreadStatic.BuildPhase))
-        member x.Error   exn = x.ErrorR exn; raise (ReportedError (Some exn))
-        member x.PhasedError   (ph:PhasedError) = 
-            x.ErrorSink ph
+
+        member x.ErrorR  exn = 
+            match exn with 
+            | StopProcessing 
+            | ReportedError _ -> raise exn 
+            | _ -> x.DiagnosticSink(PhasedDiagnostic.Create(exn,CompileThreadStatic.BuildPhase), true)
+
+        member x.Warning exn = 
+            match exn with 
+            | StopProcessing 
+            | ReportedError _ -> raise exn 
+            | _ -> x.DiagnosticSink(PhasedDiagnostic.Create(exn,CompileThreadStatic.BuildPhase), false)
+
+        member x.Error   exn = 
+            x.ErrorR exn
+            raise (ReportedError (Some exn))
+
+        member x.SimulateError   (ph:PhasedDiagnostic) = 
+            x.DiagnosticSink (ph, true)
             raise (ReportedError (Some ph.Exception))
+
         member x.ErrorRecovery (exn:exn) (m:range) =
             // Never throws ReportedError.
-            // Throws StopProcessing and exceptions raised by the ErrorSink(exn) handler.
+            // Throws StopProcessing and exceptions raised by the DiagnosticSink(exn) handler.
             match exn with
             (* Don't send ThreadAbortException down the error channel *)
 #if FX_REDUCED_EXCEPTIONS
@@ -370,13 +380,13 @@ module ErrorLoggerExtensions =
             // Do standard error recovery.
             // Additionally ignore/catch StopProcessing. [This is the only catch handler for StopProcessing].
             // Additionally ignore/catch ReportedError.
-            // Can throw other exceptions raised by the ErrorSink(exn) handler.         
+            // Can throw other exceptions raised by the DiagnosticSink(exn) handler.         
             match exn with
             | StopProcessing | WrappedError(StopProcessing,_) -> () // suppress, so skip error recovery.
             | _ ->
                 try  x.ErrorRecovery exn m
                 with
-                  | StopProcessing | WrappedError(StopProcessing,_) -> () // catch, e.g. raised by ErrorSink.
+                  | StopProcessing | WrappedError(StopProcessing,_) -> () // catch, e.g. raised by DiagnosticSink.
                   | ReportedError _ | WrappedError(ReportedError _,_)  -> () // catch, but not expected unless ErrorRecovery is changed.
         member x.ErrorRecoveryNoRange (exn:exn) =
             x.ErrorRecovery exn range0
@@ -395,8 +405,7 @@ let PushErrorLoggerPhaseUntilUnwind(errorLoggerTransformer : ErrorLogger -> #Err
     let newInstalled = ref true
     let newIsInstalled() = if !newInstalled then () else (assert false; (); (*failwith "error logger used after unwind"*)) // REVIEW: ok to throw?
     let chkErrorLogger = { new ErrorLogger("PushErrorLoggerPhaseUntilUnwind") with
-                             member x.WarnSinkImpl(e)  = newIsInstalled(); newErrorLogger.WarnSink(e)
-                             member x.ErrorSinkImpl(e) = newIsInstalled(); newErrorLogger.ErrorSink(e)
+                             member x.DiagnosticSink(phasedError, isError) = newIsInstalled(); newErrorLogger.DiagnosticSink(phasedError, isError)
                              member x.ErrorCount   = newIsInstalled(); newErrorLogger.ErrorCount }
     CompileThreadStatic.ErrorLogger <- chkErrorLogger
     { new System.IDisposable with 
@@ -406,17 +415,17 @@ let PushErrorLoggerPhaseUntilUnwind(errorLoggerTransformer : ErrorLogger -> #Err
 
 let SetThreadBuildPhaseNoUnwind(phase:BuildPhase) = CompileThreadStatic.BuildPhase <- phase
 let SetThreadErrorLoggerNoUnwind(errorLogger)     = CompileThreadStatic.ErrorLogger <- errorLogger
-let SetUninitializedErrorLoggerFallback errLogger = uninitializedErrorLoggerFallback := errLogger
 
 // Global functions are still used by parser and TAST ops.
 let errorR  exn = CompileThreadStatic.ErrorLogger.ErrorR exn
 let warning exn = CompileThreadStatic.ErrorLogger.Warning exn
 let error   exn = CompileThreadStatic.ErrorLogger.Error exn
 // for test only
-let phasedError (p : PhasedError) = CompileThreadStatic.ErrorLogger.PhasedError p
+let simulateError (p : PhasedDiagnostic) = CompileThreadStatic.ErrorLogger.SimulateError p
 
-let errorSink pe = CompileThreadStatic.ErrorLogger.ErrorSink pe
-let warnSink pe = CompileThreadStatic.ErrorLogger.WarnSink pe
+let diagnosticSink (phasedError, isError) = CompileThreadStatic.ErrorLogger.DiagnosticSink (phasedError, isError)
+let errorSink pe = diagnosticSink (pe, true)
+let warnSink pe = diagnosticSink (pe, false)
 let errorRecovery exn m = CompileThreadStatic.ErrorLogger.ErrorRecovery exn m
 let stopProcessingRecovery exn m = CompileThreadStatic.ErrorLogger.StopProcessingRecovery exn m
 let errorRecoveryNoRange exn = CompileThreadStatic.ErrorLogger.ErrorRecoveryNoRange exn
@@ -439,8 +448,7 @@ let suppressErrorReporting f =
     try
         let errorLogger = 
             { new ErrorLogger("suppressErrorReporting") with 
-                member x.WarnSinkImpl(_exn) = ()
-                member x.ErrorSinkImpl(_exn) = ()
+                member x.DiagnosticSink(_phasedError,_isError) = ()
                 member x.ErrorCount = 0 }
         SetThreadErrorLoggerNoUnwind(errorLogger)
         f()