Please enable JavaScript.

Coggle requires JavaScript to display documents.

F# Compiler Services (Editor Services (Parse and Check (then we need to…

- - - - Using the FSharpChecker component in multi-project, incremental and interactive editing situations may involve knowledge of the FSharpChecker operations queue and the FSharpChecker caches.
- - - - Need instance of FSharpChecker
        let cheker = FSharpChecker.Create()
      - add reference FSharp.Compiler.Service.dll
        
        open System
        open Microsoft.FSharp.Compiler.SourceCodeServices
      - checker.GetProjectOptionsFromScriptRoot(...)
      - checker.ParseFileInProject(...)
      - /// Get untyped tree for a specified input
        
        let getUntypedTree (file, input) =
        // Get compiler options for the 'project' implied by a single script file
        
        let projOptions =
        checker.GetProjectOptionsFromScript(file, input)
        |> Async.RunSynchronously
        // Run the first phase (untyped parsing) of the compiler
        let parseFileResults =
        checker.ParseFileInProject(file, input, projOptions)
        |> Async.RunSynchronously
        match parseFileResults.ParseTree with
        | Some tree -> tree
        | None -> failwith "Something went wrong during parsing!"
  - - - /// Walk over a pattern - this is for example used in
        /// let <pat> = <expr> or in the 'match' expression
        
        let rec visitPattern = function
        | SynPat.Wild(_) -> ...
      - /// Walk over an expression - if expression contains two or three
        /// sub-expressions (two if the 'else' branch is missing), let expression
        /// contains pattern and two sub-expressions
        
        let rec visitExpression = function
        | SynExpr.IfThenElse(cond, trueBranch, falseBranchOpt, , , , ) -> ...
    - - /// Walk over a list of declarations in a module. This is anything
        /// that you can write as a top-level inside module (let bindings,
        /// nested modules, type declarations etc.)
        
        let visitDeclarations decls =
        for declaration in decls do
        match declaration with
        | SynModuleDecl.Let(isRec, bindings, range) ->
        // Let binding as a declaration is similar to let binding
        // as an expression (in visitExpression), but has no body
        for binding in bindings do ...
  - - - discriminated unions that represent different elements
        
        F# AST Definition
- - - - let allUsesOfAllSignatureSymbols =
        [ for s in allSymbols do
        let uses = wholeProjectResults.GetUsesOfSymbol(s) |> Async.RunSynchronously
        yield s.ToString(), uses ]
  - - - fill in the ProjectReferences entry in ProjectOptions, which recursively specifies the project options for dependent projects
        
        project reference still needs a corresponding -r:path-to-output-of-project.dll command line argument in ProjectOptions, along with an entry in ProjectReferences
      - To efficiently analyze a set of F# projects which include cross-references, you should populate the ProjectReferences correctly and then analyze each project in turn.