F# Compiler Services


コンパイラサービス: プロジェクトの分析

このチュートリアルではF#コンパイラによって提供されるサービスを使用して プロジェクト全体を分析する方法について紹介します。

注意: 以下で使用しているAPIは試験的なもので、 最新のnugetパッケージの公開に伴って変更されることがあります。

プロジェクト全体の結果を取得する

以前の(型無しASTを使った)チュートリアル と同じく、 まずは FSharp.Compiler.Service.dll への参照追加と、適切な名前空間のオープン、 FSharpChecker インスタンスの作成を行います:

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
9: 
// F#コンパイラAPIへの参照
#r "FSharp.Compiler.Service.dll"

open System
open System.Collections.Generic
open Microsoft.FSharp.Compiler.SourceCodeServices

// インタラクティブチェッカーのインスタンスを作成
let checker = FSharpChecker.Create()

今回のサンプル入力は以下の通りです:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
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()

// 警告を発生させる
let y2 = match 1 with 1 -> M.xxx
    """
    File.WriteAllText(fileName2, fileSource2)

GetProjectOptionsFromCommandLineArgs を使用して、 2つのファイルを1つのプロジェクトとして扱えるようにします:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
let projectOptions = 
    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 = 
             [ @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\mscorlib.dll" 
               @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.dll" 
               @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\System.Core.dll" 
               @"C:\Program Files (x86)\Reference Assemblies\Microsoft\FSharp\.NETFramework\v4.0\4.3.0.0\FSharp.Core.dll"]  
           for r in references do
                 yield "-r:" + r |])

そして(ディスク上に保存されたファイルを使用して) プロジェクト全体をチェックします:

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

発生したエラーと警告は以下のようにしてチェックできます:

1: 
2: 
3: 
4: 
5: 
6: 
7: 
wholeProjectResults.Errors.Length // 1
wholeProjectResults.Errors.[0].Message.Contains("Incomplete pattern matches on this expression") // true

wholeProjectResults.Errors.[0].StartLineAlternate // 13
wholeProjectResults.Errors.[0].EndLineAlternate // 13
wholeProjectResults.Errors.[0].StartColumn // 15
wholeProjectResults.Errors.[0].EndColumn // 16

推測されたプロジェクトのシグネチャをチェックします:

1: 
2: 
3: 
4: 
[ 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 ] // ["y2"]

プロジェクト内の全シンボルを取得することもできます:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
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

プロジェクト全体のチェックが完了した後は、 プロジェクト内の各ファイルに対する個別の結果を取得することもできます。 この処理は即座に完了し、改めてチェックが実行されることもありません。

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

そしてそれぞれのファイル内にあるシンボルを解決できます:

1: 
2: 
3: 
let xSymbol = 
    backgroundTypedParse1.GetSymbolUseAtLocation(9,9,"",["xxx"])
    |> Async.RunSynchronously

それぞれのシンボルに対して、シンボルへの参照を検索することもできます:

1: 
let usesOfXSymbol = wholeProjectResults.GetUsesOfSymbol(xSymbol.Value.Symbol)

推測されたシグネチャ内にあるすべての定義済みシンボルに対して、 それらがどこで使用されているのかを探し出すこともできます:

1: 
2: 
3: 
let allUsesOfAllSignatureSymbols = 
    [ for s in allSymbols do 
         yield s.ToString(), wholeProjectResults.GetUsesOfSymbol(s) ]

(ローカルスコープで使用されているものも含めて) プロジェクト全体で使用されているすべてのシンボルを確認することもできます:

1: 
let allUsesOfAllSymbols = wholeProjectResults.GetAllUsesOfAllSymbols()

また、プロジェクト内のファイルに対して、更新後のバージョンに対して チェックを実行するようにリクエストすることもできます (なお FileSystem API を使用していない場合には、 プロジェクト内のその他のファイルがまだディスクから 読み取り中であることに注意してください):

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
let parseResults1, checkAnswer1 = 
    checker.ParseAndCheckFileInProject(Inputs.fileName1, 0, Inputs.fileSource1, projectOptions) 
    |> Async.RunSynchronously

let checkResults1 = 
    match checkAnswer1 with 
    | FSharpCheckFileAnswer.Succeeded x ->  x 
    | _ -> failwith "想定外の終了状態です"

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

let checkResults2 = 
    match checkAnswer2 with 
    | FSharpCheckFileAnswer.Succeeded x ->  x 
    | _ -> failwith "想定外の終了状態です"

そして再びシンボルを解決したり、参照を検索したりすることができます:

1: 
2: 
3: 
4: 
5: 
let xSymbol2 = 
    checkResults1.GetSymbolUseAtLocation(9,9,"",["xxx"]) 
    |> Async.RunSynchronously

let usesOfXSymbol2 = wholeProjectResults.GetUsesOfSymbol(xSymbol2.Value.Symbol)

あるいは(ローカルスコープで使用されているシンボルも含めて) ファイル中で使用されているすべてのシンボルを検索することもできます:

1: 
let allUsesOfAllSymbolsInFile1 = checkResults1.GetAllUsesOfAllSymbolsInFile()

あるいは特定のファイル中で使用されているシンボルを検索することもできます:

1: 
2: 
3: 
let allUsesOfXSymbolInFile1 = checkResults1.GetUsesOfSymbolInFile(xSymbol2.Value.Symbol)

let allUsesOfXSymbolInFile2 = checkResults2.GetUsesOfSymbolInFile(xSymbol2.Value.Symbol)

複数プロジェクトの分析

複数のプロジェクトにまたがった参照があるような、 複数のF# プロジェクトを分析したい場合、 それらのプロジェクトを一旦ビルドして、 ProjectOptionsで -r:プロジェクト-出力-までの-パス.dll 引数を指定して プロジェクトの相互参照を設定すると一番簡単です。 しかしこの場合、それぞれのプロジェクトが正しくビルド出来、 DLLファイルが参照可能なディスク上に生成されなければいけません。

たとえばIDEを操作している場合など、状況によっては DLLのコンパイルが通るようになる前に プロジェクトを参照したいことがあるでしょう。 この場合はProjectOptionsのReferencedProjectsを設定します。 この値には依存するプロジェクトのオプションを再帰的に指定します。 それぞれのプロジェクト参照にはやはり、 ReferencedProjectsのエントリそれぞれに対応する -r:プロジェクト-出力-までの-パス.dll というコマンドライン引数を ProjectOptionsに設定する必要があります。

プロジェクト参照が設定されると、ソースファイルからのF#プロジェクト分析処理が インクリメンタル分析の結果を使用して行われるようになります。 その際にはソースファイルファイルをDLLへとコンパイルする必要はありません。

相互参照を含むようなF#プロジェクトを効率よく分析するには、 ReferencedProjectsを正しく設定した後、 それぞれのプロジェクトを順番通りに分析していくとよいでしょう。

注意: プロジェクトの参照機能は試作段階です。 プロジェクトの参照を使用すると、依存先のプロジェクトがまだ分析中で、 要求したサービスがまだ利用できないことがあるため、 コンパイラサービスの性能が低下することがあります。 注意: アセンブリが型プロバイダーのコンポーネントを含む場合、 プロジェクト参照機能は利用できません。 プロジェクトの分析処理を強制しない限りはプロジェクト参照を設定しても 効果がありません。 また、分析を強制する場合にはディスク上にDLLが存在しなければいけません。

まとめ

これまで説明してきた通り、 ParseAndCheckProject を使用すると シンボルの参照などのようなプロジェクト全体の解析結果にアクセスできるようになります。 シンボルに対する処理の詳細については シンボル のページを参照してください。

namespace System
namespace System.Collections
namespace System.Collections.Generic
namespace Microsoft
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Compiler
namespace Microsoft.FSharp.Compiler.SourceCodeServices
val checker : FSharpChecker

Full name: Project.checker
type FSharpChecker
member CheckFileInProject : parsed:FSharpParseFileResults * filename:string * fileversion:int * source:string * options:FSharpProjectOptions * ?isResultObsolete:IsResultObsolete * ?textSnapshotInfo:obj -> Async<FSharpCheckFileAnswer>
member CheckFileInProjectIfReady : parsed:FSharpParseFileResults * filename:string * fileversion:int * source:string * options:FSharpProjectOptions * ?isResultObsolete:IsResultObsolete * ?textSnapshotInfo:obj -> Async<FSharpCheckFileAnswer option>
member CheckProjectInBackground : options:FSharpProjectOptions -> unit
member ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients : unit -> unit
member Compile : argv:string [] -> FSharpErrorInfo [] * int
member Compile : ast:ParsedInput list * assemblyName:string * outFile:string * dependencies:string list * ?pdbFile:string * ?executable:bool * ?noframework:bool -> FSharpErrorInfo [] * int
member CompileToDynamicAssembly : otherFlags:string [] * execute:(TextWriter * TextWriter) option -> FSharpErrorInfo [] * int * Assembly option
member CompileToDynamicAssembly : ast:ParsedInput list * assemblyName:string * dependencies:string list * execute:(TextWriter * TextWriter) option * ?debug:bool * ?noframework:bool -> FSharpErrorInfo [] * int * Assembly option
member GetBackgroundCheckResultsForFileInProject : filename:string * options:FSharpProjectOptions -> Async<FSharpParseFileResults * FSharpCheckFileResults>
member GetBackgroundParseResultsForFileInProject : filename:string * options:FSharpProjectOptions -> Async<FSharpParseFileResults>
member GetProjectOptionsFromCommandLineArgs : projectFileName:string * argv:string [] * ?loadedTimeStamp:DateTime -> FSharpProjectOptions
member GetProjectOptionsFromScript : filename:string * source:string * ?loadedTimeStamp:DateTime * ?otherFlags:string [] * ?useFsiAuxLib:bool -> Async<FSharpProjectOptions>
member InvalidateAll : unit -> unit
member InvalidateConfiguration : options:FSharpProjectOptions -> unit
member KeepProjectAlive : options:FSharpProjectOptions -> Async<IDisposable>
member MatchBracesAlternate : filename:string * source:string * options:FSharpProjectOptions -> Async<(range * range) []>
member NotifyProjectCleaned : options:FSharpProjectOptions -> unit
member ParseAndCheckFileInProject : filename:string * fileversion:int * source:string * options:FSharpProjectOptions * ?isResultObsolete:IsResultObsolete * ?textSnapshotInfo:obj -> Async<FSharpParseFileResults * FSharpCheckFileAnswer>
member ParseAndCheckProject : options:FSharpProjectOptions -> Async<FSharpCheckProjectResults>
member ParseFileInProject : filename:string * source:string * options:FSharpProjectOptions -> Async<FSharpParseFileResults>
member TryGetRecentCheckResultsForFile : filename:string * options:FSharpProjectOptions * ?source:string -> (FSharpParseFileResults * FSharpCheckFileResults * int) option
member BeforeBackgroundFileCheck : IEvent<string>
member CurrentQueueLength : int
member FileChecked : IEvent<string>
member FileParsed : IEvent<string>
member private FrameworkImportsCache : FrameworkImportsCache
member ImplicitlyStartBackgroundWork : bool
member MaxMemory : int
member MaxMemoryReached : IEvent<unit>
member PauseBeforeBackgroundWork : int
member ProjectChecked : IEvent<string>
member private ReactorOps : IReactorOperations
member private ReferenceResolver : Resolver
member ImplicitlyStartBackgroundWork : bool with set
member MaxMemory : int with set
member PauseBeforeBackgroundWork : int with set
static member Create : ?projectCacheSize:int * ?keepAssemblyContents:bool * ?keepAllBackgroundResolutions:bool * ?msbuildEnabled:bool -> FSharpChecker
static member GlobalForegroundParseCountStatistic : int
static member GlobalForegroundTypeCheckCountStatistic : int

Full name: Microsoft.FSharp.Compiler.SourceCodeServices.FSharpChecker
static member FSharpChecker.Create : ?projectCacheSize:int * ?keepAssemblyContents:bool * ?keepAllBackgroundResolutions:bool * ?msbuildEnabled:bool -> FSharpChecker
namespace System.IO
val base1 : string

Full name: Project.Inputs.base1
type Path =
  static val DirectorySeparatorChar : char
  static val AltDirectorySeparatorChar : char
  static val VolumeSeparatorChar : char
  static val InvalidPathChars : char[]
  static val PathSeparator : char
  static member ChangeExtension : path:string * extension:string -> string
  static member Combine : [<ParamArray>] paths:string[] -> string + 3 overloads
  static member GetDirectoryName : path:string -> string
  static member GetExtension : path:string -> string
  static member GetFileName : path:string -> string
  ...

Full name: System.IO.Path
Path.GetTempFileName() : string
val fileName1 : string

Full name: Project.Inputs.fileName1
Path.ChangeExtension(path: string, extension: string) : string
val base2 : string

Full name: Project.Inputs.base2
val fileName2 : string

Full name: Project.Inputs.fileName2
val dllName : string

Full name: Project.Inputs.dllName
val projFileName : string

Full name: Project.Inputs.projFileName
val fileSource1 : string

Full name: Project.Inputs.fileSource1
type File =
  static member AppendAllLines : path:string * contents:IEnumerable<string> -> unit + 1 overload
  static member AppendAllText : path:string * contents:string -> unit + 1 overload
  static member AppendText : path:string -> StreamWriter
  static member Copy : sourceFileName:string * destFileName:string -> unit + 1 overload
  static member Create : path:string -> FileStream + 3 overloads
  static member CreateText : path:string -> StreamWriter
  static member Decrypt : path:string -> unit
  static member Delete : path:string -> unit
  static member Encrypt : path:string -> unit
  static member Exists : path:string -> bool
  ...

Full name: System.IO.File
File.WriteAllText(path: string, contents: string) : unit
File.WriteAllText(path: string, contents: string, encoding: Text.Encoding) : unit
val fileSource2 : string

Full name: Project.Inputs.fileSource2
val projectOptions : FSharpProjectOptions

Full name: Project.projectOptions
member FSharpChecker.GetProjectOptionsFromCommandLineArgs : projectFileName:string * argv:string [] * ?loadedTimeStamp:DateTime -> FSharpProjectOptions
module Inputs

from Project
val references : string list
val r : string
val wholeProjectResults : FSharpCheckProjectResults

Full name: Project.wholeProjectResults
member FSharpChecker.ParseAndCheckProject : options:FSharpProjectOptions -> 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 -> Async<unit>
static member AwaitTask : task:Task<'T> -> Async<'T>
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 FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
static member Ignore : computation:Async<'T> -> Async<unit>
static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:CancellationToken -> 'T
static member Sleep : millisecondsDueTime:int -> Async<unit>
static member Start : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions * ?cancellationToken:CancellationToken -> Task<'T>
static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions -> Async<Task<'T>>
static member StartImmediate : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:CancellationToken -> unit
static member SwitchToContext : syncContext:SynchronizationContext -> Async<unit>
static member SwitchToNewThread : unit -> Async<unit>
static member SwitchToThreadPool : unit -> Async<unit>
static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>
static member CancellationToken : Async<CancellationToken>
static member DefaultCancellationToken : CancellationToken

Full name: Microsoft.FSharp.Control.Async

--------------------
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>
static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:Threading.CancellationToken -> 'T
property FSharpCheckProjectResults.Errors: Compiler.FSharpErrorInfo []
property Array.Length: int
val x : FSharpEntity
property FSharpCheckProjectResults.AssemblySignature: FSharpAssemblySignature
property FSharpAssemblySignature.Entities: IList<FSharpEntity>
property FSharpEntity.DisplayName: string
val x : FSharpMemberOrFunctionOrValue
property FSharpMemberOrFunctionOrValue.DisplayName: string
val allSymbolsInEntities : entities:IList<FSharpEntity> -> FSharpSymbol list

Full name: Project.allSymbolsInEntities
val entities : IList<FSharpEntity>
type IList<'T> =
  member IndexOf : item:'T -> int
  member Insert : index:int * item:'T -> unit
  member Item : int -> 'T with get, set
  member RemoveAt : index:int -> unit

Full name: System.Collections.Generic.IList<_>
type FSharpEntity =
  inherit FSharpSymbol
  private new : cenv * EntityRef -> FSharpEntity
  member AbbreviatedType : FSharpType
  member AccessPath : string
  member Accessibility : FSharpAccessibility
  member AllInterfaces : IList<FSharpType>
  member ArrayRank : int
  member Attributes : IList<FSharpAttribute>
  member BaseType : FSharpType option
  member CompiledName : string
  ...

Full name: Microsoft.FSharp.Compiler.SourceCodeServices.FSharpEntity
val e : FSharpEntity
type FSharpSymbol =
  member IsAccessible : FSharpAccessibilityRights -> bool
  member IsEffectivelySameAs : other:FSharpSymbol -> bool
  member Assembly : FSharpAssembly
  member DeclarationLocation : range option
  member DisplayName : string
  member FullName : string
  member ImplementationLocation : range option
  member private Item : Item
  member SignatureLocation : range option
  static member private Create : g:TcGlobals * thisCcu:CcuThunk * tcImports:TcImports * item:Item -> FSharpSymbol

Full name: Microsoft.FSharp.Compiler.SourceCodeServices.FSharpSymbol
property FSharpEntity.MembersFunctionsAndValues: IList<FSharpMemberOrFunctionOrValue>
val x : FSharpUnionCase
property FSharpEntity.UnionCases: IList<FSharpUnionCase>
val x : FSharpField
property FSharpEntity.FSharpFields: IList<FSharpField>
property FSharpEntity.NestedEntities: IList<FSharpEntity>
val allSymbols : FSharpSymbol list

Full name: Project.allSymbols
val backgroundParseResults1 : FSharpParseFileResults

Full name: Project.backgroundParseResults1
val backgroundTypedParse1 : FSharpCheckFileResults

Full name: Project.backgroundTypedParse1
member FSharpChecker.GetBackgroundCheckResultsForFileInProject : filename:string * options:FSharpProjectOptions -> Async<FSharpParseFileResults * FSharpCheckFileResults>
val xSymbol : FSharpSymbolUse option

Full name: Project.xSymbol
member FSharpCheckFileResults.GetSymbolUseAtLocation : line:int * colAtEndOfNames:int * lineText:string * names:string list -> Async<FSharpSymbolUse option>
val usesOfXSymbol : Async<FSharpSymbolUse []>

Full name: Project.usesOfXSymbol
member FSharpCheckProjectResults.GetUsesOfSymbol : symbol:FSharpSymbol -> Async<FSharpSymbolUse []>
property Option.Value: FSharpSymbolUse
property FSharpSymbolUse.Symbol: FSharpSymbol
val allUsesOfAllSignatureSymbols : (string * Async<FSharpSymbolUse []>) list

Full name: Project.allUsesOfAllSignatureSymbols
val s : FSharpSymbol
Object.ToString() : string
val allUsesOfAllSymbols : Async<FSharpSymbolUse []>

Full name: Project.allUsesOfAllSymbols
member FSharpCheckProjectResults.GetAllUsesOfAllSymbols : unit -> Async<FSharpSymbolUse []>
val parseResults1 : FSharpParseFileResults

Full name: Project.parseResults1
val checkAnswer1 : FSharpCheckFileAnswer

Full name: Project.checkAnswer1
member FSharpChecker.ParseAndCheckFileInProject : filename:string * fileversion:int * source:string * options:FSharpProjectOptions * ?isResultObsolete:IsResultObsolete * ?textSnapshotInfo:obj -> Async<FSharpParseFileResults * FSharpCheckFileAnswer>
val checkResults1 : FSharpCheckFileResults

Full name: Project.checkResults1
type FSharpCheckFileAnswer =
  | Aborted
  | Succeeded of FSharpCheckFileResults

Full name: Microsoft.FSharp.Compiler.SourceCodeServices.FSharpCheckFileAnswer
union case FSharpCheckFileAnswer.Succeeded: FSharpCheckFileResults -> FSharpCheckFileAnswer
val x : FSharpCheckFileResults
val failwith : message:string -> 'T

Full name: Microsoft.FSharp.Core.Operators.failwith
val parseResults2 : FSharpParseFileResults

Full name: Project.parseResults2
val checkAnswer2 : FSharpCheckFileAnswer

Full name: Project.checkAnswer2
val checkResults2 : FSharpCheckFileResults

Full name: Project.checkResults2
val xSymbol2 : FSharpSymbolUse option

Full name: Project.xSymbol2
val usesOfXSymbol2 : Async<FSharpSymbolUse []>

Full name: Project.usesOfXSymbol2
val allUsesOfAllSymbolsInFile1 : Async<FSharpSymbolUse []>

Full name: Project.allUsesOfAllSymbolsInFile1
member FSharpCheckFileResults.GetAllUsesOfAllSymbolsInFile : unit -> Async<FSharpSymbolUse []>
val allUsesOfXSymbolInFile1 : Async<FSharpSymbolUse []>

Full name: Project.allUsesOfXSymbolInFile1
member FSharpCheckFileResults.GetUsesOfSymbolInFile : symbol:FSharpSymbol -> Async<FSharpSymbolUse []>
val allUsesOfXSymbolInFile2 : Async<FSharpSymbolUse []>

Full name: Project.allUsesOfXSymbolInFile2
Fork me on GitHub