F# Compiler Services


コンパイラサービス: シンボルの処理

このチュートリアルでは、F#コンパイラによって提供される シンボルの扱い方についてのデモを紹介します。 シンボルの参照に関する情報については プロジェクト全体の分析 も参考にしてください。

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

これまでと同じく、 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.IO
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: 
let parseAndTypeCheckSingleFile (file, input) = 
    // スタンドアロンの(スクリプト)ファイルを表すコンテキストを取得
    let projOptions = 
        checker.GetProjectOptionsFromScript(file, input)
        |> Async.RunSynchronously

    let parseFileResults, checkFileResults = 
        checker.ParseAndCheckFileInProject(file, 0, input, projOptions) 
        |> Async.RunSynchronously

    // 型チェックが成功(あるいは100%に到達)するまで待機
    match checkFileResults with
    | FSharpCheckFileAnswer.Succeeded(res) -> parseFileResults, res
    | res -> failwithf "Parsing did not finish... (%A)" res

let file = "/home/user/Test.fsx"

ファイルに対する解決済みのシグネチャ情報を取得する

ファイルに対する型チェックが完了すると、 TypeCheckResultsPartialAssemblySignature プロパティを参照することにより、 チェック中の特定のファイルを含む、推論されたプロジェクトのシグネチャに アクセスすることができます。

モジュールや型、属性、メンバ、値、関数、共用体、レコード型、測定単位、 およびその他のF#言語要素に対する完全なシグネチャ情報が参照できます。

ただし型付き式ツリーに対する情報は(今のところ)この方法では利用できません。

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
let input2 = 
      """
[<System.CLSCompliant(true)>]
let foo(x, y) = 
    let msg = String.Concat("Hello"," ","world")
    if true then 
        printfn "x = %d, y = %d" x y 
        printfn "%s" msg

type C() = 
    member x.P = 1
      """
let parseFileResults, checkFileResults = 
    parseAndTypeCheckSingleFile(file, input2)

これでコードに対する部分的なアセンブリのシグネチャが取得できるようになります:

1: 
2: 
3: 
let partialAssemblySignature = checkFileResults.PartialAssemblySignature

partialAssemblySignature.Entities.Count = 1  // エンティティは1つ

そしてコードを含むモジュールに関連したエンティティを取得します:

1: 
2: 
3: 
let moduleEntity = partialAssemblySignature.Entities.[0]

moduleEntity.DisplayName = "Test"

そしてコード内の型定義に関連したエンティティを取得します:

1: 
let classEntity = moduleEntity.NestedEntities.[0]

そしてコード内で定義された関数に関連した値を取得します:

1: 
let fnVal = moduleEntity.MembersFunctionsAndValues.[0]

関数値に関するプロパティの値を確認してみましょう。

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
fnVal.Attributes.Count // 1
fnVal.CurriedParameterGroups.Count // 1
fnVal.CurriedParameterGroups.[0].Count // 2
fnVal.CurriedParameterGroups.[0].[0].Name // "x"
fnVal.CurriedParameterGroups.[0].[1].Name // "y"
fnVal.DeclarationLocation.StartLine // 3
fnVal.DisplayName // "foo"
fnVal.EnclosingEntity.DisplayName // "Test"
fnVal.EnclosingEntity.DeclarationLocation.StartLine // 1
fnVal.GenericParameters.Count // 0
fnVal.InlineAnnotation // FSharpInlineAnnotation.OptionalInline
fnVal.IsActivePattern // false
fnVal.IsCompilerGenerated // false
fnVal.IsDispatchSlot // false
fnVal.IsExtensionMember // false
fnVal.IsPropertyGetterMethod // false
fnVal.IsImplicitConstructor // false
fnVal.IsInstanceMember // false
fnVal.IsMember // false
fnVal.IsModuleValueOrMember // true
fnVal.IsMutable // false
fnVal.IsPropertySetterMethod // false
fnVal.IsTypeFunction // false

次に、この関数の型がファーストクラスの値として使用されているかどうかチェックします。 (ちなみに CurriedParameterGroups プロパティには引数の名前など、 より多くの情報も含まれています)

1: 
2: 
3: 
4: 
5: 
6: 
7: 
fnVal.FullType // int * int -> unit
fnVal.FullType.IsFunctionType // true
fnVal.FullType.GenericArguments.[0] // int * int 
fnVal.FullType.GenericArguments.[0].IsTupleType // true
let argTy1 = fnVal.FullType.GenericArguments.[0].GenericArguments.[0]

argTy1.TypeDefinition.DisplayName // int

というわけで int * int -> unit という型を表現するオブジェクトが取得できて、 その1つめの 'int' を確認できたわけです。 また、以下のようにすると 'int' 型についてのより詳細な情報が取得でき、 それが名前付きの型であり、F#の型省略形 type int = int32 であることがわかります:

1: 
2: 
argTy1.HasTypeDefinition // true
argTy1.TypeDefinition.IsFSharpAbbreviation // true

型省略形の右辺、つまり int32 についてもチェックしてみましょう:

1: 
2: 
3: 
let argTy1b = argTy1.TypeDefinition.AbbreviatedType
argTy1b.TypeDefinition.Namespace // Some "Microsoft.FSharp.Core" 
argTy1b.TypeDefinition.CompiledName // "int32" 

そして再び型省略形 type int32 = System.Int32 から型に関する完全な情報が取得できます:

1: 
2: 
3: 
let argTy1c = argTy1b.TypeDefinition.AbbreviatedType
argTy1c.TypeDefinition.Namespace // Some "System" 
argTy1c.TypeDefinition.CompiledName // "Int32" 

ファイルに対する型チェックの結果には、 コンパイル時に使用されたプロジェクト(あるいはスクリプト)のオプションに関する ProjectContext と呼ばれる情報も含まれています:

1: 
2: 
3: 
4: 
5: 
6: 
let projectContext = checkFileResults.ProjectContext

for ass in projectContext.GetReferencedAssemblies() do
    match ass.FileName with 
    | None -> printfn "コンパイル時にファイルの存在しないアセンブリを参照しました"
    | Some s -> printfn "コンパイル時にアセンブリ '%s' を参照しました" s

注意:

  • 不完全なコードが存在する場合、一部あるいはすべての属性が意図したとおりには 並ばないことがあります。
  • (実際には非常によくあることですが)一部のアセンブリが見つからない場合、 外部アセンブリに関連する値やメンバ、エンティティにおける 'IsUnresolved' が trueになることがあります。 IsUnresolvedによる例外に対処できるよう、堅牢なコードにしておくべきです。

プロジェクト全体に対するシンボル情報を取得する

プロジェクト全体をチェックする場合、チェッカーを作成した後に parseAndCheckScript を呼び出します。 今回の場合は単に1つのスクリプトだけが含まれたプロジェクトをチェックします。 異なる "projOptions" を指定すると、巨大なプロジェクトに対する設定を 構成することもできます。

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
let parseAndCheckScript (file, input) = 
    let projOptions = 
        checker.GetProjectOptionsFromScript(file, input)
        |> Async.RunSynchronously

    let projResults = 
        checker.ParseAndCheckProject(projOptions) 
        |> Async.RunSynchronously

    projResults

そして特定の入力に対してこの関数を呼び出します:

1: 
2: 
3: 
4: 
let tmpFile = Path.ChangeExtension(System.IO.Path.GetTempFileName() , "fs")
File.WriteAllText(tmpFile, input2)

let projectResults = parseAndCheckScript(tmpFile, input2)

結果は以下の通りです:

1: 
2: 
3: 
4: 
5: 
6: 
7: 
let assemblySig = projectResults.AssemblySignature

assemblySig.Entities.Count = 1  // エンティティは1つ
assemblySig.Entities.[0].Namespace  // null
assemblySig.Entities.[0].DisplayName // "Tmp28D0"
assemblySig.Entities.[0].MembersFunctionsAndValues.Count // 1 
assemblySig.Entities.[0].MembersFunctionsAndValues.[0].DisplayName // "foo" 
namespace System
namespace System.IO
namespace Microsoft
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Compiler
namespace Microsoft.FSharp.Compiler.SourceCodeServices
val checker : FSharpChecker

Full name: Symbols.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
val parseAndTypeCheckSingleFile : file:string * input:string -> FSharpParseFileResults * FSharpCheckFileResults

Full name: Symbols.parseAndTypeCheckSingleFile
val file : string
val input : string
val projOptions : FSharpProjectOptions
member FSharpChecker.GetProjectOptionsFromScript : filename:string * source:string * ?loadedTimeStamp:DateTime * ?otherFlags:string [] * ?useFsiAuxLib:bool -> Async<FSharpProjectOptions>
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
val parseFileResults : FSharpParseFileResults
val checkFileResults : FSharpCheckFileAnswer
member FSharpChecker.ParseAndCheckFileInProject : filename:string * fileversion:int * source:string * options:FSharpProjectOptions * ?isResultObsolete:IsResultObsolete * ?textSnapshotInfo:obj -> Async<FSharpParseFileResults * FSharpCheckFileAnswer>
type FSharpCheckFileAnswer =
  | Aborted
  | Succeeded of FSharpCheckFileResults

Full name: Microsoft.FSharp.Compiler.SourceCodeServices.FSharpCheckFileAnswer
union case FSharpCheckFileAnswer.Succeeded: FSharpCheckFileResults -> FSharpCheckFileAnswer
val res : FSharpCheckFileResults
val res : FSharpCheckFileAnswer
val failwithf : format:Printf.StringFormat<'T,'Result> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.failwithf
val file : string

Full name: Symbols.file
val input2 : string

Full name: Symbols.input2
val parseFileResults : FSharpParseFileResults

Full name: Symbols.parseFileResults
val checkFileResults : FSharpCheckFileResults

Full name: Symbols.checkFileResults
val partialAssemblySignature : FSharpAssemblySignature

Full name: Symbols.partialAssemblySignature
property FSharpCheckFileResults.PartialAssemblySignature: FSharpAssemblySignature
property FSharpAssemblySignature.Entities: Collections.Generic.IList<FSharpEntity>
property Collections.Generic.ICollection.Count: int
val moduleEntity : FSharpEntity

Full name: Symbols.moduleEntity
property FSharpEntity.DisplayName: string
val classEntity : FSharpEntity

Full name: Symbols.classEntity
property FSharpEntity.NestedEntities: Collections.Generic.IList<FSharpEntity>
val fnVal : FSharpMemberOrFunctionOrValue

Full name: Symbols.fnVal
property FSharpEntity.MembersFunctionsAndValues: Collections.Generic.IList<FSharpMemberOrFunctionOrValue>
property FSharpMemberOrFunctionOrValue.Attributes: Collections.Generic.IList<FSharpAttribute>
property FSharpMemberOrFunctionOrValue.CurriedParameterGroups: Collections.Generic.IList<Collections.Generic.IList<FSharpParameter>>
property FSharpMemberOrFunctionOrValue.DeclarationLocation: Compiler.Range.range
property Compiler.Range.range.StartLine: int
property FSharpMemberOrFunctionOrValue.DisplayName: string
property FSharpMemberOrFunctionOrValue.EnclosingEntity: FSharpEntity
property FSharpEntity.DeclarationLocation: Compiler.Range.range
property FSharpMemberOrFunctionOrValue.GenericParameters: Collections.Generic.IList<FSharpGenericParameter>
property FSharpMemberOrFunctionOrValue.InlineAnnotation: FSharpInlineAnnotation
property FSharpMemberOrFunctionOrValue.IsActivePattern: bool
property FSharpMemberOrFunctionOrValue.IsCompilerGenerated: bool
property FSharpMemberOrFunctionOrValue.IsDispatchSlot: bool
property FSharpMemberOrFunctionOrValue.IsExtensionMember: bool
property FSharpMemberOrFunctionOrValue.IsPropertyGetterMethod: bool
property FSharpMemberOrFunctionOrValue.IsImplicitConstructor: bool
property FSharpMemberOrFunctionOrValue.IsInstanceMember: bool
property FSharpMemberOrFunctionOrValue.IsMember: bool
property FSharpMemberOrFunctionOrValue.IsModuleValueOrMember: bool
property FSharpMemberOrFunctionOrValue.IsMutable: bool
property FSharpMemberOrFunctionOrValue.IsPropertySetterMethod: bool
property FSharpMemberOrFunctionOrValue.IsTypeFunction: bool
property FSharpMemberOrFunctionOrValue.FullType: FSharpType
property FSharpType.IsFunctionType: bool
property FSharpType.GenericArguments: Collections.Generic.IList<FSharpType>
val argTy1 : FSharpType

Full name: Symbols.argTy1
property FSharpType.TypeDefinition: FSharpEntity
property FSharpType.HasTypeDefinition: bool
property FSharpEntity.IsFSharpAbbreviation: bool
val argTy1b : FSharpType

Full name: Symbols.argTy1b
property FSharpEntity.AbbreviatedType: FSharpType
property FSharpEntity.Namespace: string option
property FSharpEntity.CompiledName: string
val argTy1c : FSharpType

Full name: Symbols.argTy1c
val projectContext : FSharpProjectContext

Full name: Symbols.projectContext
property FSharpCheckFileResults.ProjectContext: FSharpProjectContext
val ass : FSharpAssembly
member FSharpProjectContext.GetReferencedAssemblies : unit -> FSharpAssembly list
property FSharpAssembly.FileName: string option
union case Option.None: Option<'T>
val printfn : format:Printf.TextWriterFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.printfn
union case Option.Some: Value: 'T -> Option<'T>
val s : string
val parseAndCheckScript : file:string * input:string -> FSharpCheckProjectResults

Full name: Symbols.parseAndCheckScript
val projResults : FSharpCheckProjectResults
member FSharpChecker.ParseAndCheckProject : options:FSharpProjectOptions -> Async<FSharpCheckProjectResults>
val tmpFile : string

Full name: Symbols.tmpFile
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.ChangeExtension(path: string, extension: string) : string
Path.GetTempFileName() : string
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 projectResults : FSharpCheckProjectResults

Full name: Symbols.projectResults
val assemblySig : FSharpAssemblySignature

Full name: Symbols.assemblySig
property FSharpCheckProjectResults.AssemblySignature: FSharpAssemblySignature
Fork me on GitHub