F# Compiler Guide


Compiler Services: Project Analysis

This tutorial demonstrates how you can analyze a whole project using services provided by the F# compiler.

NOTE: The FSharp.Compiler.Service API is subject to change when later versions of the nuget package are published.

Getting whole-project results

As in the previous tutorial (using untyped AST), we start by referencing FSharp.Compiler.Service.dll, opening the relevant namespace and creating an instance of InteractiveChecker:

// Reference F# compiler API
#r "FSharp.Compiler.Service.dll"

open System
open System.Collections.Generic
open FSharp.Compiler.CodeAnalysis
open FSharp.Compiler.Symbols
open FSharp.Compiler.Text

// Create an interactive checker instance
let checker = FSharpChecker.Create()

Here are our sample inputs:

module Inputs =
    open System.IO

    let base1 = Path.GetTempFileName()
    let fileName1 = Path.ChangeExtension(base1, ".fs")
    let base2 = Path.GetTempFileName()
    let fileName2 = Path.ChangeExtension(base2, ".fs")
    let dllName = Path.ChangeExtension(base2, ".dll")
    let projFileName = Path.ChangeExtension(base2, ".fsproj")

    let fileSource1 =
        """
module M

type C() =
    member x.P = 1

let xxx = 3 + 4
let fff () = xxx + xxx
    """

    File.WriteAllText(fileName1, fileSource1)

    let fileSource2 =
        """
module N

open M

type D1() =
    member x.SomeProperty = M.xxx

type D2() =
    member x.SomeProperty = M.fff() + D1().P

// Generate a warning
let y2 = match 1 with 1 -> M.xxx
    """

    File.WriteAllText(fileName2, fileSource2)

We use GetProjectOptionsFromCommandLineArgs to treat two files as a project:

let projectOptions =
    let sysLib nm =
        if System.Environment.OSVersion.Platform = System.PlatformID.Win32NT then
            // file references only valid on Windows
            System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
            + @"\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\"
            + nm
            + ".dll"
        else
            let sysDir =
                System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory()

            let (++) a b = System.IO.Path.Combine(a, b)
            sysDir ++ nm + ".dll"

    let fsCore4300 () =
        if System.Environment.OSVersion.Platform = System.PlatformID.Win32NT then
            // file references only valid on Windows
            System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFilesX86)
            + @"\Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\4.3.0.0\FSharp.Core.dll"
        else
            sysLib "FSharp.Core"

    checker.GetProjectOptionsFromCommandLineArgs(
        Inputs.projFileName,
        [| yield "--simpleresolution"
           yield "--noframework"
           yield "--debug:full"
           yield "--define:DEBUG"
           yield "--optimize-"
           yield "--out:" + Inputs.dllName
           yield "--doc:test.xml"
           yield "--warn:3"
           yield "--fullpaths"
           yield "--flaterrors"
           yield "--target:library"
           yield Inputs.fileName1
           yield Inputs.fileName2
           let references =
               [ sysLib "mscorlib"
                 sysLib "System"
                 sysLib "System.Core"
                 fsCore4300 () ]

           for r in references do
               yield "-r:" + r |]
    )

Now check the entire project (using the files saved on disk):

let wholeProjectResults =
    checker.ParseAndCheckProject(projectOptions)
    |> Async.RunSynchronously

Now look at the errors and warnings:

wholeProjectResults.Diagnostics.Length // 1

wholeProjectResults.Diagnostics.[0]
    .Message.Contains("Incomplete pattern matches on this expression") // yes it does

wholeProjectResults.Diagnostics.[0].StartLine
wholeProjectResults.Diagnostics.[0].EndLine
wholeProjectResults.Diagnostics.[0].StartColumn
wholeProjectResults.Diagnostics.[0].EndColumn

Now look at the inferred signature for the project:

[ for x in wholeProjectResults.AssemblySignature.Entities -> x.DisplayName ] // ["N"; "M"]

[ for x in
      wholeProjectResults.AssemblySignature.Entities.[0]
          .NestedEntities -> x.DisplayName ] // ["D1"; "D2"]

[ for x in
      wholeProjectResults.AssemblySignature.Entities.[1]
          .NestedEntities -> x.DisplayName ] // ["C"]

[ for x in
      wholeProjectResults.AssemblySignature.Entities.[0]
          .MembersFunctionsAndValues -> x.DisplayName ] // ["y"; "y2"]

You can also get all symbols in the project:

let rec allSymbolsInEntities (entities: IList<FSharpEntity>) =
    [ for e in entities do
          yield (e :> FSharpSymbol)

          for x in e.MembersFunctionsAndValues do
              yield (x :> FSharpSymbol)

          for x in e.UnionCases do
              yield (x :> FSharpSymbol)

          for x in e.FSharpFields do
              yield (x :> FSharpSymbol)

          yield! allSymbolsInEntities e.NestedEntities ]

let allSymbols =
    allSymbolsInEntities wholeProjectResults.AssemblySignature.Entities

After checking the whole project, you can access the background results for individual files in the project. This will be fast and will not involve any additional checking.

let backgroundParseResults1, backgroundTypedParse1 =
    checker.GetBackgroundCheckResultsForFileInProject(Inputs.fileName1, projectOptions)
    |> Async.RunSynchronously

You can now resolve symbols in each file:

let xSymbolUseOpt =
    backgroundTypedParse1.GetSymbolUseAtLocation(9, 9, "", [ "xxx" ])

let xSymbolUse = xSymbolUseOpt.Value

let xSymbol = xSymbolUse.Symbol

You can find out more about a symbol by doing type checks on various symbol kinds:

let xSymbolAsValue =
    match xSymbol with
    | :? FSharpMemberOrFunctionOrValue as xSymbolAsVal -> xSymbolAsVal
    | _ -> failwith "we expected this to be a member, function or value"

For each symbol, you can look up the references to that symbol:

let usesOfXSymbol =
    wholeProjectResults.GetUsesOfSymbol(xSymbol)

You can iterate all the defined symbols in the inferred signature and find where they are used:

let allUsesOfAllSignatureSymbols =
    [ for s in allSymbols do
          let uses = wholeProjectResults.GetUsesOfSymbol(s)
          yield s.ToString(), uses ]

You can also look at all the symbols uses in the whole project (including uses of symbols with local scope)

let allUsesOfAllSymbols =
    wholeProjectResults.GetAllUsesOfAllSymbols()

You can also request checks of updated versions of files within the project (note that the other files in the project are still read from disk, unless you are using the FileSystem API):

let parseResults1, checkAnswer1 =
    checker.ParseAndCheckFileInProject(Inputs.fileName1, 0, SourceText.ofString Inputs.fileSource1, projectOptions)
    |> Async.RunSynchronously

let checkResults1 =
    match checkAnswer1 with
    | FSharpCheckFileAnswer.Succeeded x -> x
    | _ -> failwith "unexpected aborted"

let parseResults2, checkAnswer2 =
    checker.ParseAndCheckFileInProject(Inputs.fileName2, 0, SourceText.ofString Inputs.fileSource2, projectOptions)
    |> Async.RunSynchronously

let checkResults2 =
    match checkAnswer2 with
    | FSharpCheckFileAnswer.Succeeded x -> x
    | _ -> failwith "unexpected aborted"

Again, you can resolve symbols and ask for references:

let xSymbolUse2Opt =
    checkResults1.GetSymbolUseAtLocation(9, 9, "", [ "xxx" ])

let xSymbolUse2 = xSymbolUse2Opt.Value

let xSymbol2 = xSymbolUse2.Symbol

let usesOfXSymbol2 =
    wholeProjectResults.GetUsesOfSymbol(xSymbol2)

Or ask for all the symbols uses in the file (including uses of symbols with local scope)

let allUsesOfAllSymbolsInFile1 =
    checkResults1.GetAllUsesOfAllSymbolsInFile()

Or ask for all the uses of one symbol in one file:

let allUsesOfXSymbolInFile1 =
    checkResults1.GetUsesOfSymbolInFile(xSymbol2)

let allUsesOfXSymbolInFile2 =
    checkResults2.GetUsesOfSymbolInFile(xSymbol2)

Analyzing multiple projects

If you have multiple F# projects to analyze which include references from some projects to others, then the simplest way to do this is to build the projects and specify the cross-project references using a -r:path-to-output-of-project.dll argument in the ProjectOptions. However, this requires the build of each project to succeed, producing the DLL file on disk which can be referred to.

In some situations, e.g. in an IDE, you may wish to allow references to other F# projects prior to successful compilation to a DLL. To do this, fill in the ProjectReferences entry in ProjectOptions, which recursively specifies the project options for dependent projects. Each project reference still needs a corresponding -r:path-to-output-of-project.dll command line argument in ProjectOptions, along with an entry in ProjectReferences. The first element of each tuple in the ProjectReferences entry should be the DLL name, i.e. path-to-output-of-project.dll. This should be the same as the text used in the -r project reference.

When a project reference is used, the analysis will make use of the results of incremental analysis of the referenced F# project from source files, without requiring the compilation of these files to DLLs.

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.

NOTE: Project references are disabled if the assembly being referred to contains type provider components - specifying the project reference will have no effect beyond forcing the analysis of the project, and the DLL will still be required on disk.

Summary

As you have seen, the ParseAndCheckProject lets you access results of project-wide analysis such as symbol references. To learn more about working with symbols, see Symbols.

Using the FSharpChecker component in multi-project, incremental and interactive editing situations may involve knowledge of the FSharpChecker operations queue and the FSharpChecker caches.

namespace System
namespace System.Collections
namespace System.Collections.Generic
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp
namespace FSharp.Compiler
namespace FSharp.Compiler.CodeAnalysis
namespace FSharp.Compiler.Symbols
Multiple items
namespace FSharp

--------------------
namespace Microsoft.FSharp

--------------------
type FSharpAttribute = member Format : context:FSharpDisplayContext -> string member IsAttribute : unit -> bool member AttributeType : FSharpEntity member ConstructorArguments : IList<FSharpType * obj> member IsUnresolved : bool member NamedArguments : IList<FSharpType * string * bool * obj> member Range : range
<summary> Represents a custom attribute attached to F# source code or a compiler .NET component </summary>
namespace FSharp.Compiler.Text
val checker : FSharpChecker
type FSharpChecker = member CheckFileInProject : parseResults:FSharpParseFileResults * fileName:string * fileVersion:int * sourceText:ISourceText * options:FSharpProjectOptions * ?userOpName:string -> Async<FSharpCheckFileAnswer> member ClearCache : options:seq<FSharpProjectOptions> * ?userOpName:string -> unit member ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients : unit -> unit member Compile : argv:string [] * ?userOpName:string -> Async<FSharpDiagnostic [] * int> + 1 overload member CompileToDynamicAssembly : otherFlags:string [] * execute:(TextWriter * TextWriter) option * ?userOpName:string -> Async<FSharpDiagnostic [] * int * Assembly option> + 1 overload member FindBackgroundReferencesInFile : fileName:string * options:FSharpProjectOptions * symbol:FSharpSymbol * ?canInvalidateProject:bool * ?userOpName:string -> Async<seq<range>> member GetBackgroundCheckResultsForFileInProject : fileName:string * options:FSharpProjectOptions * ?userOpName:string -> Async<FSharpParseFileResults * FSharpCheckFileResults> member GetBackgroundParseResultsForFileInProject : fileName:string * options:FSharpProjectOptions * ?userOpName:string -> Async<FSharpParseFileResults> member GetBackgroundSemanticClassificationForFile : fileName:string * options:FSharpProjectOptions * ?userOpName:string -> Async<SemanticClassificationView option> member GetParsingOptionsFromCommandLineArgs : sourceFiles:string list * argv:string list * ?isInteractive:bool * ?isEditing:bool -> FSharpParsingOptions * FSharpDiagnostic list + 1 overload ...
<summary> Used to parse and check F# source code. </summary>
static member FSharpChecker.Create : ?projectCacheSize:int * ?keepAssemblyContents:bool * ?keepAllBackgroundResolutions:bool * ?legacyReferenceResolver:LegacyReferenceResolver * ?tryGetMetadataSnapshot:FSharp.Compiler.AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * ?suggestNamesForErrors:bool * ?keepAllBackgroundSymbolUses:bool * ?enableBackgroundItemKeyStoreAndSemanticClassification:bool * ?enablePartialTypeChecking:bool -> FSharpChecker
namespace System.IO
val base1 : string
type Path = static member ChangeExtension : path: string * extension: string -> string static member Combine : path1: string * path2: string -> string + 3 overloads static member EndsInDirectorySeparator : path: ReadOnlySpan<char> -> bool + 1 overload static member GetDirectoryName : path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload static member GetExtension : path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload static member GetFileName : path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload static member GetFileNameWithoutExtension : path: ReadOnlySpan<char> -> ReadOnlySpan<char> + 1 overload static member GetFullPath : path: string -> string + 1 overload static member GetInvalidFileNameChars : unit -> char [] static member GetInvalidPathChars : unit -> char [] ...
<summary>Performs operations on <see cref="T:System.String" /> instances that contain file or directory path information. These operations are performed in a cross-platform manner.</summary>
Path.GetTempFileName() : string
val fileName1 : string
Path.ChangeExtension(path: string, extension: string) : string
val base2 : string
val fileName2 : string
val dllName : string
val projFileName : string
val fileSource1 : string
type File = static member AppendAllLines : path: string * contents: IEnumerable<string> -> unit + 1 overload static member AppendAllLinesAsync : path: string * contents: IEnumerable<string> * encoding: Encoding *?cancellationToken: CancellationToken -> Task + 1 overload static member AppendAllText : path: string * contents: string -> unit + 1 overload static member AppendAllTextAsync : path: string * contents: string * encoding: Encoding *?cancellationToken: CancellationToken -> Task + 1 overload static member AppendText : path: string -> StreamWriter static member Copy : sourceFileName: string * destFileName: string -> unit + 1 overload static member Create : path: string -> FileStream + 2 overloads static member CreateText : path: string -> StreamWriter static member Decrypt : path: string -> unit static member Delete : path: string -> unit ...
<summary>Provides static methods for the creation, copying, deletion, moving, and opening of a single file, and aids in the creation of <see cref="T:System.IO.FileStream" /> objects.</summary>
File.WriteAllText(path: string, contents: string) : unit
File.WriteAllText(path: string, contents: string, encoding: Text.Encoding) : unit
val fileSource2 : string
val projectOptions : FSharpProjectOptions
val sysLib : (string -> string)
val nm : string
type Environment = static member Exit : exitCode: int -> unit static member ExpandEnvironmentVariables : name: string -> string static member FailFast : message: string -> unit + 1 overload static member GetCommandLineArgs : unit -> string [] static member GetEnvironmentVariable : variable: string -> string + 1 overload static member GetEnvironmentVariables : unit -> IDictionary + 1 overload static member GetFolderPath : folder: SpecialFolder -> string + 1 overload static member GetLogicalDrives : unit -> string [] static member SetEnvironmentVariable : variable: string * value: string -> unit + 1 overload static member CommandLine : string ...
<summary>Provides information about, and means to manipulate, the current environment and platform. This class cannot be inherited.</summary>
property Environment.OSVersion: OperatingSystem with get
<summary>Gets the current platform identifier and version number.</summary>
<exception cref="T:System.InvalidOperationException">This property was unable to obtain the system version. -or- The obtained platform identifier is not a member of <see cref="T:System.PlatformID" /></exception>
<returns>The platform identifier and version number.</returns>
property OperatingSystem.Platform: PlatformID with get
<summary>Gets a <see cref="T:System.PlatformID" /> enumeration value that identifies the operating system platform.</summary>
<returns>One of the <see cref="T:System.PlatformID" /> values.</returns>
type PlatformID = | Win32S = 0 | Win32Windows = 1 | Win32NT = 2 | WinCE = 3 | Unix = 4 | Xbox = 5 | MacOSX = 6 | Other = 7
<summary>Identifies the operating system, or platform, supported by an assembly.</summary>
field PlatformID.Win32NT: PlatformID = 2
<summary>The operating system is Windows NT or later.</summary>
Environment.GetFolderPath(folder: Environment.SpecialFolder) : string
Environment.GetFolderPath(folder: Environment.SpecialFolder, option: Environment.SpecialFolderOption) : string
type SpecialFolder = | Desktop = 0 | Programs = 2 | MyDocuments = 5 | Personal = 5 | Favorites = 6 | Startup = 7 | Recent = 8 | SendTo = 9 | StartMenu = 11 | MyMusic = 13 ...
<summary>Specifies enumerated constants used to retrieve directory paths to system special folders.</summary>
field Environment.SpecialFolder.ProgramFilesX86: Environment.SpecialFolder = 42
<summary>The x86 Program Files folder. Added in the .NET Framework 4.</summary>
val sysDir : string
namespace System.Runtime
namespace System.Runtime.InteropServices
type RuntimeEnvironment = static member FromGlobalAccessCache : a: Assembly -> bool static member GetRuntimeDirectory : unit -> string static member GetRuntimeInterfaceAsIntPtr : clsid: Guid * riid: Guid -> nativeint static member GetRuntimeInterfaceAsObject : clsid: Guid * riid: Guid -> obj static member GetSystemVersion : unit -> string static member SystemConfigurationFile : string
<summary>Provides a collection of <see langword="static" /> methods that return information about the common language runtime environment.</summary>
Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory() : string
val a : string
val b : string
IO.Path.Combine([<ParamArray>] paths: string []) : string
IO.Path.Combine(path1: string, path2: string) : string
IO.Path.Combine(path1: string, path2: string, path3: string) : string
IO.Path.Combine(path1: string, path2: string, path3: string, path4: string) : string
val fsCore4300 : (unit -> string)
member FSharpChecker.GetProjectOptionsFromCommandLineArgs : projectFileName:string * argv:string [] * ?loadedTimeStamp:DateTime * ?isInteractive:bool * ?isEditing:bool -> FSharpProjectOptions
module Inputs from Project
val references : string list
val r : string
val wholeProjectResults : FSharpCheckProjectResults
member FSharpChecker.ParseAndCheckProject : options:FSharpProjectOptions * ?userOpName:string -> Async<FSharpCheckProjectResults>
Multiple items
type Async = static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool> static member AwaitTask : task:Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool> static member CancelDefaultToken : unit -> unit static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>> static member Choice : computations:seq<Async<'T option>> -> Async<'T option> static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...
<summary>Holds static members for creating and manipulating asynchronous computations.</summary>
<remarks> See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>. </remarks>
<category index="1">Async Programming</category>


--------------------
type Async<'T> =
<summary> An asynchronous computation, which, when run, will eventually produce a value of type T, or else raises an exception. </summary>
<remarks> This type has no members. Asynchronous computations are normally specified either by using an async expression or the static methods in the <see cref="T:Microsoft.FSharp.Control.Async" /> type. See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">F# Language Guide - Async Workflows</a>. </remarks>
<namespacedoc><summary> Library functionality for asynchronous programming, events and agents. See also <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/asynchronous-workflows">Asynchronous Programming</a>, <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/members/events">Events</a> and <a href="https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/lazy-expressions">Lazy Expressions</a> in the F# Language Guide. </summary></namespacedoc>
<category index="1">Async Programming</category>
static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:Threading.CancellationToken -> 'T
property FSharpCheckProjectResults.Diagnostics: FSharp.Compiler.Diagnostics.FSharpDiagnostic [] with get
<summary> The errors returned by processing the project </summary>
property Array.Length: int with get
<summary>Gets the total number of elements in all the dimensions of the <see cref="T:System.Array" />.</summary>
<exception cref="T:System.OverflowException">The array is multidimensional and contains more than <see cref="F:System.Int32.MaxValue" /> elements.</exception>
<returns>The total number of elements in all the dimensions of the <see cref="T:System.Array" />; zero if there are no elements in the array.</returns>
val x : FSharpEntity
property FSharpCheckProjectResults.AssemblySignature: FSharpAssemblySignature with get
<summary> Get a view of the overall signature of the assembly. Only valid to use if HasCriticalErrors is false. </summary>
property FSharpAssemblySignature.Entities: IList<FSharpEntity> with get
<summary> The (non-nested) module and type definitions in this signature </summary>
property FSharpEntity.DisplayName: string with get
<summary> Get the name of the type or module as displayed in F# code </summary>
val x : FSharpMemberOrFunctionOrValue
property FSharpMemberOrFunctionOrValue.DisplayName: string with get
<summary> Get the name as presented in F# error messages and documentation </summary>
val allSymbolsInEntities : entities:IList<FSharpEntity> -> FSharpSymbol list
val entities : IList<FSharpEntity>
type IList<'T> = inherit ICollection<'T> inherit IEnumerable<'T> inherit IEnumerable member IndexOf : item: 'T -> int member Insert : index: int * item: 'T -> unit member RemoveAt : index: int -> unit member Item : 'T
<summary>Represents a collection of objects that can be individually accessed by index.</summary>
<typeparam name="T">The type of elements in the list.</typeparam>
type FSharpEntity = inherit FSharpSymbol private new : SymbolEnv * EntityRef -> FSharpEntity member GetPublicNestedEntities : unit -> seq<FSharpEntity> member TryGetFullCompiledName : unit -> string option member TryGetFullDisplayName : unit -> string option member TryGetFullName : unit -> string option member TryGetMembersFunctionsAndValues : unit -> IList<FSharpMemberOrFunctionOrValue> member TryGetMetadataText : unit -> ISourceText option member AbbreviatedType : FSharpType member AccessPath : string ...
<summary> A subtype of FSharpSymbol that represents a type definition or module as seen by the F# language </summary>
val e : FSharpEntity
type FSharpSymbol = member GetEffectivelySameAsHash : unit -> int member HasAttribute : unit -> bool member IsAccessible : FSharpAccessibilityRights -> bool member IsEffectivelySameAs : other:FSharpSymbol -> bool member TryGetAttribute : unit -> FSharpAttribute option static member private Create : g:TcGlobals * thisCcu:CcuThunk * thisCcuTyp:ModuleOrNamespaceType * tcImports:TcImports * item:Item -> FSharpSymbol + 1 overload abstract member Accessibility : FSharpAccessibility member Assembly : FSharpAssembly abstract member Attributes : IList<FSharpAttribute> member DeclarationLocation : range option ...
<summary> Represents a symbol in checked F# source code or a compiled .NET component. The subtype of the symbol may reveal further information and can be one of FSharpEntity, FSharpUnionCase FSharpField, FSharpGenericParameter, FSharpStaticParameter, FSharpMemberOrFunctionOrValue, FSharpParameter, or FSharpActivePatternCase. </summary>
property FSharpEntity.MembersFunctionsAndValues: IList<FSharpMemberOrFunctionOrValue> with get
<summary> Get the properties, events and methods of a type definitions, or the functions and values of a module </summary>
val x : FSharpUnionCase
property FSharpEntity.UnionCases: IList<FSharpUnionCase> with get
<summary> Get the cases of a union type </summary>
val x : FSharpField
property FSharpEntity.FSharpFields: IList<FSharpField> with get
<summary> Get the fields of a record, class, struct or enum from the perspective of the F# language. This includes static fields, the 'val' bindings in classes and structs, and the value definitions in enums. For classes, the list may include compiler generated fields implied by the use of primary constructors. </summary>
property FSharpEntity.NestedEntities: IList<FSharpEntity> with get
<summary> Get the modules and types defined in a module, or the nested types of a type </summary>
val allSymbols : FSharpSymbol list
val backgroundParseResults1 : FSharpParseFileResults
val backgroundTypedParse1 : FSharpCheckFileResults
member FSharpChecker.GetBackgroundCheckResultsForFileInProject : fileName:string * options:FSharpProjectOptions * ?userOpName:string -> Async<FSharpParseFileResults * FSharpCheckFileResults>
val xSymbolUseOpt : FSharpSymbolUse option
member FSharpCheckFileResults.GetSymbolUseAtLocation : line:int * colAtEndOfNames:int * lineText:string * names:string list -> FSharpSymbolUse option
val xSymbolUse : FSharpSymbolUse
property Option.Value: FSharpSymbolUse with get
<summary>Get the value of a 'Some' option. A NullReferenceException is raised if the option is 'None'.</summary>
val xSymbol : FSharpSymbol
property FSharpSymbolUse.Symbol: FSharpSymbol with get
<summary> The symbol referenced </summary>
val xSymbolAsValue : FSharpMemberOrFunctionOrValue
type FSharpMemberOrFunctionOrValue = inherit FSharpSymbol private new : SymbolEnv * ValRef -> FSharpMemberOrFunctionOrValue + 1 overload member FormatLayout : displayContext:FSharpDisplayContext -> TaggedText [] member GetOverloads : matchParameterNumber:bool -> IList<FSharpMemberOrFunctionOrValue> option member GetReturnTypeLayout : displayContext:FSharpDisplayContext -> TaggedText [] option member GetWitnessPassingInfo : unit -> (string * IList<FSharpParameter>) option member TryGetFullCompiledOperatorNameIdents : unit -> string [] option member TryGetFullDisplayName : unit -> string option override Accessibility : FSharpAccessibility member ApparentEnclosingEntity : FSharpEntity ...
<summary> A subtype of F# symbol that represents an F# method, property, event, function or value, including extension members. </summary>
val xSymbolAsVal : FSharpMemberOrFunctionOrValue
val failwith : message:string -> 'T
<summary>Throw a <see cref="T:System.Exception" /> exception.</summary>
<param name="message">The exception message.</param>
<returns>The result value.</returns>
val usesOfXSymbol : FSharpSymbolUse []
member FSharpCheckProjectResults.GetUsesOfSymbol : symbol:FSharpSymbol * ?cancellationToken:Threading.CancellationToken -> FSharpSymbolUse []
val allUsesOfAllSignatureSymbols : (string * FSharpSymbolUse []) list
val s : FSharpSymbol
val uses : FSharpSymbolUse []
Object.ToString() : string
val allUsesOfAllSymbols : FSharpSymbolUse []
member FSharpCheckProjectResults.GetAllUsesOfAllSymbols : ?cancellationToken:Threading.CancellationToken -> FSharpSymbolUse []
val parseResults1 : FSharpParseFileResults
val checkAnswer1 : FSharpCheckFileAnswer
member FSharpChecker.ParseAndCheckFileInProject : fileName:string * fileVersion:int * sourceText:ISourceText * options:FSharpProjectOptions * ?userOpName:string -> Async<FSharpParseFileResults * FSharpCheckFileAnswer>
module SourceText from FSharp.Compiler.Text
<summary> Functions related to ISourceText objects </summary>
val ofString : string -> ISourceText
<summary> Creates an ISourceText object from the given string </summary>
val checkResults1 : FSharpCheckFileResults
type FSharpCheckFileAnswer = | Aborted | Succeeded of FSharpCheckFileResults
<summary> The result of calling TypeCheckResult including the possibility of abort and background compiler not caught up. </summary>
union case FSharpCheckFileAnswer.Succeeded: FSharpCheckFileResults -> FSharpCheckFileAnswer
<summary> Success </summary>
val x : FSharpCheckFileResults
val parseResults2 : FSharpParseFileResults
val checkAnswer2 : FSharpCheckFileAnswer
val checkResults2 : FSharpCheckFileResults
val xSymbolUse2Opt : FSharpSymbolUse option
val xSymbolUse2 : FSharpSymbolUse
val xSymbol2 : FSharpSymbol
val usesOfXSymbol2 : FSharpSymbolUse []
val allUsesOfAllSymbolsInFile1 : seq<FSharpSymbolUse>
member FSharpCheckFileResults.GetAllUsesOfAllSymbolsInFile : ?cancellationToken:Threading.CancellationToken -> seq<FSharpSymbolUse>
val allUsesOfXSymbolInFile1 : FSharpSymbolUse []
member FSharpCheckFileResults.GetUsesOfSymbolInFile : symbol:FSharpSymbol * ?cancellationToken:Threading.CancellationToken -> FSharpSymbolUse []
val allUsesOfXSymbolInFile2 : FSharpSymbolUse []