Added ParseAndCheckFileInProject

Author: ncave

src/dotnet/Fable.Repl/Interfaces.fs

@@ -52,6 +52,7 @@ type IFableManager =
     abstract ClearParseCaches: checker: IChecker -> unit
     abstract ParseFSharpScript: checker: IChecker * fileName: string * source: string -> IParseResults
     abstract ParseFSharpProject: checker: IChecker * projectFileName: string * fileNames: string[] * sources: string[] -> IParseResults
+    abstract ParseFSharpFileInProject: checker: IChecker * fileName: string * projectFileName: string * fileNames: string[] * sources: string[] -> IParseResults
     abstract GetParseErrors: parseResults: IParseResults -> Error[]
     abstract GetDeclarationLocation: parseResults: IParseResults * line: int * col: int * lineText: string -> Async<Range option>
     abstract GetToolTipText: parseResults: IParseResults * line: int * col: int * lineText: string -> Async<string[]>

src/dotnet/Fable.Repl/Main.fs

@@ -11,20 +11,19 @@ type CheckerImpl(checker: InteractiveChecker) =
     member __.Checker = checker
     interface IChecker
 
-let mapErrors (checkProjectResults: FSharpCheckProjectResults) =
-    checkProjectResults.Errors
-    |> Array.map (fun er -> {
-        FileName = er.FileName
-        StartLineAlternate = er.StartLineAlternate
-        StartColumn = er.StartColumn
-        EndLineAlternate = er.EndLineAlternate
-        EndColumn = er.EndColumn
-        Message = er.Message
+let mapError (error: FSharpErrorInfo) =
+    {
+        FileName = error.FileName
+        StartLineAlternate = error.StartLineAlternate
+        StartColumn = error.StartColumn
+        EndLineAlternate = error.EndLineAlternate
+        EndColumn = error.EndColumn
+        Message = error.Message
         IsWarning =
-            match er.Severity with
+            match error.Severity with
             | FSharpErrorSeverity.Error -> false
             | FSharpErrorSeverity.Warning -> true
-    })
+    }
 
 type ParseResults (optimizedProject: Lazy<Project>,
                    unoptimizedProject: Lazy<Project>,
@@ -42,7 +41,7 @@ type ParseResults (optimizedProject: Lazy<Project>,
     member __.CheckProjectResults = checkProjectResults
 
     interface IParseResults with
-        member __.Errors = mapErrors checkProjectResults
+        member __.Errors = checkProjectResults.Errors |> Array.map mapError
 
 let inline private tryGetLexerSymbolIslands (sym: Lexer.LexerSymbol) =
   match sym.Text with
@@ -134,12 +133,12 @@ let makeProject projectOptions (projectResults: FSharpCheckProjectResults) optim
     project
 
 let parseFSharpScript (checker: InteractiveChecker) projectFileName fileName source =
-    let parseResults, typeCheckResults, projectResults =
+    let parseResults, checkResults, projectResults =
         checker.ParseAndCheckScript (projectFileName, fileName, source)
     let projectOptions = makeProjOptions projectFileName [| fileName |]
     let optimizedProject = lazy (makeProject projectOptions projectResults true)
     let unoptimizedProject = lazy (makeProject projectOptions projectResults false)
-    ParseResults (optimizedProject, unoptimizedProject, Some parseResults, Some typeCheckResults, projectResults)
+    ParseResults (optimizedProject, unoptimizedProject, Some parseResults, Some checkResults, projectResults)
 
 let parseFSharpProject (checker: InteractiveChecker) projectFileName fileNames sources =
     let projectResults = checker.ParseAndCheckProject (projectFileName, fileNames, sources)
@@ -148,6 +147,13 @@ let parseFSharpProject (checker: InteractiveChecker) projectFileName fileNames s
     let unoptimizedProject = lazy (makeProject projectOptions projectResults false)
     ParseResults (optimizedProject, unoptimizedProject, None, None, projectResults)
 
+let parseFSharpFileInProject (checker: InteractiveChecker) fileName projectFileName fileNames sources =
+    let parseResults, checkResultsOpt, projectResults = checker.ParseAndCheckFileInProject (fileName, projectFileName, fileNames, sources)
+    let projectOptions = makeProjOptions projectFileName fileNames
+    let optimizedProject = lazy (makeProject projectOptions projectResults true)
+    let unoptimizedProject = lazy (makeProject projectOptions projectResults false)
+    ParseResults (optimizedProject, unoptimizedProject, Some parseResults, checkResultsOpt, projectResults)
+
 let tooltipToString (el: FSharpToolTipElement<string>): string[] =
     let dataToString (data: FSharpToolTipElementData<string>) =
         [| match data.ParamName with
@@ -254,6 +260,10 @@ let init () =
             let c = checker :?> CheckerImpl
             parseFSharpProject c.Checker projectFileName fileNames sources :> IParseResults
 
+        member __.ParseFSharpFileInProject(checker, fileName, projectFileName, fileNames, sources) =
+            let c = checker :?> CheckerImpl
+            parseFSharpFileInProject c.Checker fileName projectFileName fileNames sources :> IParseResults
+
         member __.GetParseErrors(parseResults:IParseResults) =
             parseResults.Errors
 

src/dotnet/Fable.Repl/bench/app.fs

@@ -31,26 +31,27 @@ let main argv =
         | [|metadataPath; testScriptPath; compiledScriptPath|] -> metadataPath, testScriptPath, compiledScriptPath
         | _ -> metadataPath, testScriptPath, testScriptPath.Replace(".fsx", ".js")
     try
-        let optimized = false
-        // let writeAst = false
+        let optimize = false
         // let fsAstFile = Fable.Path.ChangeExtension(testScriptPath, ".fsharp.ast.txt")
         // let babelAstFile = Fable.Path.ChangeExtension(testScriptPath, ".babel.ast.json")
+        let projectFileName = "project"
+        let fileName = testScriptPath
         let source = readAllText testScriptPath
         let fable = Fable.Repl.Main.init ()
-        let createChecker () = fable.CreateChecker(references, readAllBytes metadataPath, None)
+        let createChecker () = fable.CreateChecker(references, readAllBytes metadataPath, [||], optimize)
         let ms0, checker = measureTime createChecker ()
         printfn "InteractiveChecker created in %d ms" ms0
-        let parseFSharpScript () = fable.ParseFSharpScript(checker, testScriptPath, source)
-        let parseFable (res, fileName) = fable.CompileToBabelAst(fableLibraryDir, res, fileName, optimized)
+        // let parseFSharpScript () = fable.ParseFSharpScript(checker, fileName, source)
+        let parseFSharpScript () = fable.ParseFSharpFileInProject(checker, fileName, projectFileName, [|fileName|], [|source|])
+        let parseFable (res, fileName) = fable.CompileToBabelAst(fableLibraryDir, res, fileName, optimize)
         let bench i =
-            let fileName = testScriptPath
             let ms1, parseRes = measureTime parseFSharpScript ()
             let errors = fable.GetParseErrors parseRes
             errors |> Array.iter (printfn "Error: %A")
             if errors.Length > 0 then failwith "Too many errors."
             let ms2, babelAst = measureTime parseFable (parseRes, fileName)
-            // if i = 1 && writeAst then
-            //     // let fsAstStr = fable.FSharpAstToString(parseRes, fileName, optimized)
+            // if i = 1 then
+            //     // let fsAstStr = fable.FSharpAstToString(parseRes, fileName, optimize)
             //     // printfn "%s Typed AST: %s" fileName fsAstStr
             //     // writeAllText fsAstFile fsAstStr
             //     // printfn "Babel AST: %s" (toJson babelAst)