From 4a053f5cec90ac9c1edc1a6b5355f2193ae56108 Mon Sep 17 00:00:00 2001 From: Don Syme Date: Fri, 11 Dec 2020 16:07:33 +0000 Subject: [PATCH 1/8] add signatures --- src/fsharp/AccessibilityLogic.fsi | 389 + src/fsharp/AttributeChecking.fsi | 545 + src/fsharp/CompilerGlobalState.fs | 5 - src/fsharp/CompilerGlobalState.fsi | 54 + src/fsharp/ErrorLogger.fs | 21 +- src/fsharp/ErrorLogger.fsi | 339 + src/fsharp/ErrorResolutionHints.fsi | 37 + .../FSharp.Compiler.Service.fsproj | 83 +- src/fsharp/FSharp.Compiler.Service/all.fsi | 28623 ++++++++++++++++ src/fsharp/InfoReader.fsi | 931 + src/fsharp/MethodCalls.fsi | 1972 ++ src/fsharp/MethodOverrides.fsi | 911 + src/fsharp/ParseHelpers.fs | 6 +- src/fsharp/ParseHelpers.fsi | 109 + src/fsharp/PrettyNaming.fs | 5 +- src/fsharp/PrettyNaming.fsi | 178 + src/fsharp/QueueList.fs | 23 +- src/fsharp/QueueList.fsi | 58 + src/fsharp/ReferenceResolver.fs | 8 +- src/fsharp/ReferenceResolver.fsi | 56 + src/fsharp/SignatureConformance.fsi | 675 + .../SimulatedMSBuildReferenceResolver.fs | 4 - .../SimulatedMSBuildReferenceResolver.fsi | 8 + src/fsharp/SyntaxTreeOps.fsi | 265 + src/fsharp/TypeRelations.fsi | 291 + src/fsharp/TypedTreeBasics.fsi | 228 + src/fsharp/XmlAdapters.fsi | 9 + src/fsharp/XmlDoc.fs | 2 +- src/fsharp/XmlDoc.fsi | 56 + src/fsharp/absil/illib.fs | 11 +- src/fsharp/absil/illib.fsi | 692 + src/fsharp/absil/ilreflect.fsi | 56 + src/fsharp/infos.fsi | 2612 ++ src/fsharp/lib.fs | 64 +- src/fsharp/lib.fsi | 274 + src/fsharp/utils/CompilerLocationUtils.fs | 6 +- src/fsharp/utils/CompilerLocationUtils.fsi | 43 + src/fsharp/utils/EditDistance.fsi | 12 + .../SurfaceArea.netstandard.fs | 1 - 39 files changed, 39589 insertions(+), 73 deletions(-) create mode 100644 src/fsharp/AccessibilityLogic.fsi create mode 100644 src/fsharp/AttributeChecking.fsi create mode 100644 src/fsharp/CompilerGlobalState.fsi create mode 100644 src/fsharp/ErrorLogger.fsi create mode 100644 src/fsharp/ErrorResolutionHints.fsi create mode 100644 src/fsharp/FSharp.Compiler.Service/all.fsi create mode 100644 src/fsharp/InfoReader.fsi create mode 100644 src/fsharp/MethodCalls.fsi create mode 100644 src/fsharp/MethodOverrides.fsi create mode 100644 src/fsharp/ParseHelpers.fsi create mode 100644 src/fsharp/PrettyNaming.fsi create mode 100644 src/fsharp/QueueList.fsi create mode 100644 src/fsharp/ReferenceResolver.fsi create mode 100644 src/fsharp/SignatureConformance.fsi create mode 100644 src/fsharp/SimulatedMSBuildReferenceResolver.fsi create mode 100644 src/fsharp/SyntaxTreeOps.fsi create mode 100644 src/fsharp/TypeRelations.fsi create mode 100644 src/fsharp/TypedTreeBasics.fsi create mode 100644 src/fsharp/XmlAdapters.fsi create mode 100644 src/fsharp/XmlDoc.fsi create mode 100644 src/fsharp/absil/illib.fsi create mode 100644 src/fsharp/absil/ilreflect.fsi create mode 100644 src/fsharp/infos.fsi create mode 100644 src/fsharp/lib.fsi create mode 100644 src/fsharp/utils/CompilerLocationUtils.fsi create mode 100644 src/fsharp/utils/EditDistance.fsi diff --git a/src/fsharp/AccessibilityLogic.fsi b/src/fsharp/AccessibilityLogic.fsi new file mode 100644 index 00000000000..3d5aadc98cc --- /dev/null +++ b/src/fsharp/AccessibilityLogic.fsi @@ -0,0 +1,389 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +/// The basic logic of private/internal/protected/InternalsVisibleTo/public accessibility +module internal FSharp.Compiler.AccessibilityLogic + +open FSharp.Compiler.AbstractIL.IL +open FSharp.Compiler +open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.Infos +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeBasics +open FSharp.Compiler.TypedTreeOps +open FSharp.Compiler.TcGlobals + +#if !NO_EXTENSIONTYPING +open FSharp.Compiler.ExtensionTyping +#endif + +/// Represents the 'keys' a particular piece of code can use to access other constructs?. +[] +type AccessorDomain = + /// AccessibleFrom(cpaths, tyconRefOpt) + /// + /// cpaths: indicates we have the keys to access any members private to the given paths + /// tyconRefOpt: indicates we have the keys to access any protected members of the super types of 'TyconRef' + | AccessibleFrom of CompilationPath list * TyconRef option + + /// An AccessorDomain which returns public items + | AccessibleFromEverywhere + + /// An AccessorDomain which returns everything but .NET private/internal items. + /// This is used + /// - when solving member trait constraints, which are solved independently of accessibility + /// - for failure paths in error reporting, e.g. to produce an error that an F# item is not accessible + /// - an adhoc use in service.fs to look up a delegate signature + | AccessibleFromSomeFSharpCode + + /// An AccessorDomain which returns all items + | AccessibleFromSomewhere + + // Hashing and comparison is used for the memoization tables keyed by an accessor domain. + // It is dependent on a TcGlobals because of the TyconRef in the data structure + static member CustomGetHashCode(ad:AccessorDomain) = + match ad with + | AccessibleFrom _ -> 1 + | AccessibleFromEverywhere -> 2 + | AccessibleFromSomeFSharpCode -> 3 + | AccessibleFromSomewhere -> 4 + static member CustomEquals(g:TcGlobals, ad1:AccessorDomain, ad2:AccessorDomain) = + match ad1, ad2 with + | AccessibleFrom(cs1, tc1), AccessibleFrom(cs2, tc2) -> (cs1 = cs2) && (match tc1, tc2 with None, None -> true | Some tc1, Some tc2 -> tyconRefEq g tc1 tc2 | _ -> false) + | AccessibleFromEverywhere, AccessibleFromEverywhere -> true + | AccessibleFromSomeFSharpCode, AccessibleFromSomeFSharpCode -> true + | AccessibleFromSomewhere, AccessibleFromSomewhere -> true + | _ -> false + +/// Indicates if an F# item is accessible +let IsAccessible ad taccess = + match ad with + | AccessibleFromEverywhere -> canAccessFromEverywhere taccess + | AccessibleFromSomeFSharpCode -> canAccessFromSomewhere taccess + | AccessibleFromSomewhere -> true + | AccessibleFrom (cpaths, _tcrefViewedFromOption) -> + List.exists (canAccessFrom taccess) cpaths + +/// Indicates if an IL member is accessible (ignoring its enclosing type) +let private IsILMemberAccessible g amap m (tcrefOfViewedItem : TyconRef) ad access = + match ad with + | AccessibleFromEverywhere -> + access = ILMemberAccess.Public + + | AccessibleFromSomeFSharpCode -> + (access = ILMemberAccess.Public || + access = ILMemberAccess.Family || + access = ILMemberAccess.FamilyOrAssembly) + + | AccessibleFrom (cpaths, tcrefViewedFromOption) -> + + let accessibleByFamily = + ((access = ILMemberAccess.Family || + access = ILMemberAccess.FamilyOrAssembly) && + match tcrefViewedFromOption with + | None -> false + | Some tcrefViewedFrom -> + ExistsHeadTypeInEntireHierarchy g amap m (generalizedTyconRef tcrefViewedFrom) tcrefOfViewedItem) + + let accessibleByInternalsVisibleTo = + (access = ILMemberAccess.Assembly || access = ILMemberAccess.FamilyOrAssembly) && + canAccessFromOneOf cpaths tcrefOfViewedItem.CompilationPath + + let accessibleByFamilyAndAssembly = + access = ILMemberAccess.FamilyAndAssembly && + canAccessFromOneOf cpaths tcrefOfViewedItem.CompilationPath && + match tcrefViewedFromOption with + | None -> false + | Some tcrefViewedFrom -> + ExistsHeadTypeInEntireHierarchy g amap m (generalizedTyconRef tcrefViewedFrom) tcrefOfViewedItem + + (access = ILMemberAccess.Public) || accessibleByFamily || accessibleByInternalsVisibleTo || accessibleByFamilyAndAssembly + + | AccessibleFromSomewhere -> + true + +/// Indicates if tdef is accessible. If tdef.Access = ILTypeDefAccess.Nested then encTyconRefOpt s TyconRef of enclosing type +/// and visibility of tdef is obtained using member access rules +let private IsILTypeDefAccessible (amap : Import.ImportMap) m ad encTyconRefOpt (tdef: ILTypeDef) = + match tdef.Access with + | ILTypeDefAccess.Nested nestedAccess -> + match encTyconRefOpt with + | None -> assert false; true + | Some encTyconRef -> IsILMemberAccessible amap.g amap m encTyconRef ad nestedAccess + | _ -> + match ad with + | AccessibleFromSomewhere -> true + | AccessibleFromEverywhere + | AccessibleFromSomeFSharpCode + | AccessibleFrom _ -> tdef.Access = ILTypeDefAccess.Public + +/// Indicates if a TyconRef is visible through the AccessibleFrom(cpaths, _). +/// Note that InternalsVisibleTo extends those cpaths. +let private IsTyconAccessibleViaVisibleTo ad (tcrefOfViewedItem:TyconRef) = + match ad with + | AccessibleFromEverywhere + | AccessibleFromSomewhere + | AccessibleFromSomeFSharpCode -> false + | AccessibleFrom (cpaths, _tcrefViewedFromOption) -> + canAccessFromOneOf cpaths tcrefOfViewedItem.CompilationPath + +/// Indicates if given IL based TyconRef is accessible. If TyconRef is nested then we'll +/// walk though the list of enclosing types and test if all of them are accessible +let private IsILTypeInfoAccessible amap m ad (tcrefOfViewedItem : TyconRef) = + let (TILObjectReprData(scoref, enc, tdef)) = tcrefOfViewedItem.ILTyconInfo + let rec check parentTycon path = + let ilTypeDefAccessible = + match parentTycon with + | None -> + match path with + | [] -> assert false; true // in this case path should have at least one element + | [x] -> IsILTypeDefAccessible amap m ad None x // shortcut for non-nested types + | x :: xs -> + // check if enclosing type x is accessible. + // if yes - create parent tycon for type 'x' and continue with the rest of the path + IsILTypeDefAccessible amap m ad None x && + ( + let parentILTyRef = mkRefForNestedILTypeDef scoref ([], x) + let parentTycon = Import.ImportILTypeRef amap m parentILTyRef + check (Some (parentTycon, [x])) xs + ) + | (Some (parentTycon, parentPath)) -> + match path with + | [] -> true // end of path is reached - success + | x :: xs -> + // check if x is accessible from the parent tycon + // if yes - create parent tycon for type 'x' and continue with the rest of the path + IsILTypeDefAccessible amap m ad (Some parentTycon) x && + ( + let parentILTyRef = mkRefForNestedILTypeDef scoref (parentPath, x) + let parentTycon = Import.ImportILTypeRef amap m parentILTyRef + check (Some (parentTycon, parentPath @ [x])) xs + ) + ilTypeDefAccessible || IsTyconAccessibleViaVisibleTo ad tcrefOfViewedItem + + check None (enc @ [tdef]) + +/// Indicates if an IL member associated with the given ILType is accessible +let private IsILTypeAndMemberAccessible g amap m adType ad (ty: ILTypeInfo) access = + IsILTypeInfoAccessible amap m adType ty.TyconRefOfRawMetadata && IsILMemberAccessible g amap m ty.TyconRefOfRawMetadata ad access + +/// Indicates if an entity is accessible +let IsEntityAccessible amap m ad (tcref:TyconRef) = + if tcref.IsILTycon then + IsILTypeInfoAccessible amap m ad tcref + else + tcref.Accessibility |> IsAccessible ad + +/// Check that an entity is accessible +let CheckTyconAccessible amap m ad tcref = + let res = IsEntityAccessible amap m ad tcref + if not res then + errorR(Error(FSComp.SR.typeIsNotAccessible tcref.DisplayName, m)) + res + +/// Indicates if a type definition and its representation contents are accessible +let IsTyconReprAccessible amap m ad tcref = + IsEntityAccessible amap m ad tcref && + IsAccessible ad tcref.TypeReprAccessibility + +/// Check that a type definition and its representation contents are accessible +let CheckTyconReprAccessible amap m ad tcref = + CheckTyconAccessible amap m ad tcref && + (let res = IsAccessible ad tcref.TypeReprAccessibility + if not res then + errorR (Error (FSComp.SR.unionCasesAreNotAccessible tcref.DisplayName, m)) + res) + +/// Indicates if a type is accessible (both definition and instantiation) +let rec IsTypeAccessible g amap m ad ty = + match tryAppTy g ty with + | ValueNone -> true + | ValueSome(tcref, tinst) -> + IsEntityAccessible amap m ad tcref && IsTypeInstAccessible g amap m ad tinst + +and IsTypeInstAccessible g amap m ad tinst = + match tinst with + | [] -> true + | _ -> List.forall (IsTypeAccessible g amap m ad) tinst + +/// Indicate if a provided member is accessible +let IsProvidedMemberAccessible (amap:Import.ImportMap) m ad ty access = + let g = amap.g + if IsTypeAccessible g amap m ad ty then + match tryTcrefOfAppTy g ty with + | ValueNone -> true + | ValueSome tcrefOfViewedItem -> + IsILMemberAccessible g amap m tcrefOfViewedItem ad access + else + false + +/// Compute the accessibility of a provided member +let ComputeILAccess isPublic isFamily isFamilyOrAssembly isFamilyAndAssembly = + if isPublic then ILMemberAccess.Public + elif isFamily then ILMemberAccess.Family + elif isFamilyOrAssembly then ILMemberAccess.FamilyOrAssembly + elif isFamilyAndAssembly then ILMemberAccess.FamilyAndAssembly + else ILMemberAccess.Private + +/// IndiCompute the accessibility of a provided member +let IsILFieldInfoAccessible g amap m ad x = + match x with + | ILFieldInfo (tinfo, fd) -> IsILTypeAndMemberAccessible g amap m ad ad tinfo fd.Access +#if !NO_EXTENSIONTYPING + | ProvidedField (amap, tpfi, m) -> + let access = tpfi.PUntaint((fun fi -> ComputeILAccess fi.IsPublic fi.IsFamily fi.IsFamilyOrAssembly fi.IsFamilyAndAssembly), m) + IsProvidedMemberAccessible amap m ad x.ApparentEnclosingType access +#endif + +let GetILAccessOfILEventInfo (ILEventInfo (tinfo, edef)) = + (resolveILMethodRef tinfo.RawMetadata edef.AddMethod).Access + +let IsILEventInfoAccessible g amap m ad einfo = + let access = GetILAccessOfILEventInfo einfo + IsILTypeAndMemberAccessible g amap m ad ad einfo.ILTypeInfo access + +let private IsILMethInfoAccessible g amap m adType ad ilminfo = + match ilminfo with + | ILMethInfo (_, ty, None, mdef, _) -> IsILTypeAndMemberAccessible g amap m adType ad (ILTypeInfo.FromType g ty) mdef.Access + | ILMethInfo (_, _, Some declaringTyconRef, mdef, _) -> IsILMemberAccessible g amap m declaringTyconRef ad mdef.Access + +let GetILAccessOfILPropInfo (ILPropInfo(tinfo, pdef)) = + let tdef = tinfo.RawMetadata + let ilAccess = + match pdef.GetMethod, pdef.SetMethod with + | Some mref, None + | None, Some mref -> (resolveILMethodRef tdef mref).Access + + | Some mrefGet, Some mrefSet -> + // + // Dotnet properties have a getter and a setter method, each of which can have a separate visibility public, protected, private etc ... + // This code computes the visibility for the property by choosing the most visible method. This approximation is usefull for cases + // where the compiler needs to know the visibility of the property. + // The specific ordering for choosing the most visible is: + // ILMemberAccess.Public, + // ILMemberAccess.FamilyOrAssembly + // ILMemberAccess.Assembly + // ILMemberAccess.Family + // ILMemberAccess.FamilyAndAssembly + // ILMemberAccess.Private + // ILMemberAccess.CompilerControlled + // + let getA = (resolveILMethodRef tdef mrefGet).Access + let setA = (resolveILMethodRef tdef mrefSet).Access + + // Use the accessors to determine the visibility of the property. + // N.B. It is critical to keep the ordering in decreasing visibility order in the following match expression + match getA, setA with + | ILMemberAccess.Public, _ + | _, ILMemberAccess.Public -> ILMemberAccess.Public + + | ILMemberAccess.FamilyOrAssembly, _ + | _, ILMemberAccess.FamilyOrAssembly -> ILMemberAccess.FamilyOrAssembly + + | ILMemberAccess.Assembly, _ + | _, ILMemberAccess.Assembly -> ILMemberAccess.Assembly + + | ILMemberAccess.Family, _ + | _, ILMemberAccess.Family -> ILMemberAccess.Family + + | ILMemberAccess.FamilyAndAssembly, _ + | _, ILMemberAccess.FamilyAndAssembly -> ILMemberAccess.FamilyAndAssembly + + | ILMemberAccess.Private, _ + | _, ILMemberAccess.Private -> ILMemberAccess.Private + + | ILMemberAccess.CompilerControlled, _ + | _, ILMemberAccess.CompilerControlled -> ILMemberAccess.CompilerControlled + + | None, None -> ILMemberAccess.Public + + ilAccess + +let IsILPropInfoAccessible g amap m ad pinfo = + let ilAccess = GetILAccessOfILPropInfo pinfo + IsILTypeAndMemberAccessible g amap m ad ad pinfo.ILTypeInfo ilAccess + +let IsValAccessible ad (vref:ValRef) = + vref.Accessibility |> IsAccessible ad + +let CheckValAccessible m ad (vref:ValRef) = + if not (IsValAccessible ad vref) then + errorR (Error (FSComp.SR.valueIsNotAccessible vref.DisplayName, m)) + +let IsUnionCaseAccessible amap m ad (ucref:UnionCaseRef) = + IsTyconReprAccessible amap m ad ucref.TyconRef && + IsAccessible ad ucref.UnionCase.Accessibility + +let CheckUnionCaseAccessible amap m ad (ucref:UnionCaseRef) = + CheckTyconReprAccessible amap m ad ucref.TyconRef && + (let res = IsAccessible ad ucref.UnionCase.Accessibility + if not res then + errorR (Error (FSComp.SR.unionCaseIsNotAccessible ucref.CaseName, m)) + res) + +let IsRecdFieldAccessible amap m ad (rfref:RecdFieldRef) = + IsTyconReprAccessible amap m ad rfref.TyconRef && + IsAccessible ad rfref.RecdField.Accessibility + +let CheckRecdFieldAccessible amap m ad (rfref:RecdFieldRef) = + CheckTyconReprAccessible amap m ad rfref.TyconRef && + (let res = IsAccessible ad rfref.RecdField.Accessibility + if not res then + errorR (Error (FSComp.SR.fieldIsNotAccessible rfref.FieldName, m)) + res) + +let CheckRecdFieldInfoAccessible amap m ad (rfinfo:RecdFieldInfo) = + CheckRecdFieldAccessible amap m ad rfinfo.RecdFieldRef |> ignore + +let CheckILFieldInfoAccessible g amap m ad finfo = + if not (IsILFieldInfoAccessible g amap m ad finfo) then + errorR (Error (FSComp.SR.structOrClassFieldIsNotAccessible finfo.FieldName, m)) + +/// Uses a separate accessibility domains for containing type and method itself +/// This makes sense cases like +/// type A() = +/// type protected B() = +/// member this.Public() = () +/// member protected this.Protected() = () +/// type C() = +/// inherit A() +/// let x = A.B() +/// do x.Public() +/// when calling x.SomeMethod() we need to use 'adTyp' do verify that type of x is accessible from C +/// and 'ad' to determine accessibility of SomeMethod. +/// I.e when calling x.Public() and x.Protected() -in both cases first check should succeed and second - should fail in the latter one. +let IsTypeAndMethInfoAccessible amap m accessDomainTy ad = function + | ILMeth (g, x, _) -> IsILMethInfoAccessible g amap m accessDomainTy ad x + | FSMeth (_, _, vref, _) -> IsValAccessible ad vref + | DefaultStructCtor(g, ty) -> IsTypeAccessible g amap m ad ty +#if !NO_EXTENSIONTYPING + | ProvidedMeth(amap, tpmb, _, m) as etmi -> + let access = tpmb.PUntaint((fun mi -> ComputeILAccess mi.IsPublic mi.IsFamily mi.IsFamilyOrAssembly mi.IsFamilyAndAssembly), m) + IsProvidedMemberAccessible amap m ad etmi.ApparentEnclosingType access +#endif +let IsMethInfoAccessible amap m ad minfo = IsTypeAndMethInfoAccessible amap m ad ad minfo + +let IsPropInfoAccessible g amap m ad = function + | ILProp ilpinfo -> IsILPropInfoAccessible g amap m ad ilpinfo + | FSProp (_, _, Some vref, None) + | FSProp (_, _, None, Some vref) -> IsValAccessible ad vref + | FSProp (_, _, Some vrefGet, Some vrefSet) -> + // pick most accessible + IsValAccessible ad vrefGet || IsValAccessible ad vrefSet +#if !NO_EXTENSIONTYPING + | ProvidedProp (amap, tppi, m) as pp-> + let access = + let a = tppi.PUntaint((fun ppi -> + let tryGetILAccessForProvidedMethodBase (mi : ProvidedMethodBase) = + match mi with + | null -> None + | mi -> Some(ComputeILAccess mi.IsPublic mi.IsFamily mi.IsFamilyOrAssembly mi.IsFamilyAndAssembly) + match tryGetILAccessForProvidedMethodBase(ppi.GetGetMethod()) with + | None -> tryGetILAccessForProvidedMethodBase(ppi.GetSetMethod()) + | x -> x), m) + defaultArg a ILMemberAccess.Public + IsProvidedMemberAccessible amap m ad pp.ApparentEnclosingType access +#endif + | _ -> false + +let IsFieldInfoAccessible ad (rfref:RecdFieldInfo) = + IsAccessible ad rfref.RecdField.Accessibility diff --git a/src/fsharp/AttributeChecking.fsi b/src/fsharp/AttributeChecking.fsi new file mode 100644 index 00000000000..fc09a339c0f --- /dev/null +++ b/src/fsharp/AttributeChecking.fsi @@ -0,0 +1,545 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +/// Logic associated with checking "ObsoleteAttribute" and other attributes +/// on items from name resolution +module internal FSharp.Compiler.AttributeChecking + +open System +open System.Collections.Generic +open FSharp.Compiler.AbstractIL.IL +open FSharp.Compiler.AbstractIL.Internal.Library + +open FSharp.Compiler +open FSharp.Compiler.Range +open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.Infos +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeOps +open FSharp.Compiler.TcGlobals + +#if !NO_EXTENSIONTYPING +open FSharp.Compiler.ExtensionTyping +open Microsoft.FSharp.Core.CompilerServices +#endif + +exception ObsoleteWarning of string * range +exception ObsoleteError of string * range + +let fail() = failwith "This custom attribute has an argument that can not yet be converted using this API" + +let rec private evalILAttribElem e = + match e with + | ILAttribElem.String (Some x) -> box x + | ILAttribElem.String None -> null + | ILAttribElem.Bool x -> box x + | ILAttribElem.Char x -> box x + | ILAttribElem.SByte x -> box x + | ILAttribElem.Int16 x -> box x + | ILAttribElem.Int32 x -> box x + | ILAttribElem.Int64 x -> box x + | ILAttribElem.Byte x -> box x + | ILAttribElem.UInt16 x -> box x + | ILAttribElem.UInt32 x -> box x + | ILAttribElem.UInt64 x -> box x + | ILAttribElem.Single x -> box x + | ILAttribElem.Double x -> box x + | ILAttribElem.Null -> null + | ILAttribElem.Array (_, a) -> box [| for i in a -> evalILAttribElem i |] + // TODO: typeof<..> in attribute values + | ILAttribElem.Type (Some _t) -> fail() + | ILAttribElem.Type None -> null + | ILAttribElem.TypeRef (Some _t) -> fail() + | ILAttribElem.TypeRef None -> null + +let rec private evalFSharpAttribArg g e = + match e with + | Expr.Const (c, _, _) -> + match c with + | Const.Bool b -> box b + | Const.SByte i -> box i + | Const.Int16 i -> box i + | Const.Int32 i -> box i + | Const.Int64 i -> box i + | Const.Byte i -> box i + | Const.UInt16 i -> box i + | Const.UInt32 i -> box i + | Const.UInt64 i -> box i + | Const.Single i -> box i + | Const.Double i -> box i + | Const.Char i -> box i + | Const.Zero -> null + | Const.String s -> box s + | _ -> fail() + | Expr.Op (TOp.Array, _, a, _) -> box [| for i in a -> evalFSharpAttribArg g i |] + | TypeOfExpr g ty -> box ty + // TODO: | TypeDefOfExpr g ty + | _ -> fail() + +type AttribInfo = + | FSAttribInfo of TcGlobals * Attrib + | ILAttribInfo of TcGlobals * Import.ImportMap * ILScopeRef * ILAttribute * range + + member x.Range = + match x with + | FSAttribInfo(_, attrib) -> attrib.Range + | ILAttribInfo (_, _, _, _, m) -> m + + member x.TyconRef = + match x with + | FSAttribInfo(_g, Attrib(tcref, _, _, _, _, _, _)) -> tcref + | ILAttribInfo (g, amap, scoref, a, m) -> + let ty = ImportILType scoref amap m [] a.Method.DeclaringType + tcrefOfAppTy g ty + + member x.ConstructorArguments = + match x with + | FSAttribInfo(g, Attrib(_, _, unnamedArgs, _, _, _, _)) -> + unnamedArgs + |> List.map (fun (AttribExpr(origExpr, evaluatedExpr)) -> + let ty = tyOfExpr g origExpr + let obj = evalFSharpAttribArg g evaluatedExpr + ty, obj) + | ILAttribInfo (g, amap, scoref, cattr, m) -> + let parms, _args = decodeILAttribData g.ilg cattr + [ for (argty, argval) in Seq.zip cattr.Method.FormalArgTypes parms -> + let ty = ImportILType scoref amap m [] argty + let obj = evalILAttribElem argval + ty, obj ] + + member x.NamedArguments = + match x with + | FSAttribInfo(g, Attrib(_, _, _, namedArgs, _, _, _)) -> + namedArgs + |> List.map (fun (AttribNamedArg(nm, _, isField, AttribExpr(origExpr, evaluatedExpr))) -> + let ty = tyOfExpr g origExpr + let obj = evalFSharpAttribArg g evaluatedExpr + ty, nm, isField, obj) + | ILAttribInfo (g, amap, scoref, cattr, m) -> + let _parms, namedArgs = decodeILAttribData g.ilg cattr + [ for (nm, argty, isProp, argval) in namedArgs -> + let ty = ImportILType scoref amap m [] argty + let obj = evalILAttribElem argval + let isField = not isProp + ty, nm, isField, obj ] + + +/// Check custom attributes. This is particularly messy because custom attributes come in in three different +/// formats. +let AttribInfosOfIL g amap scoref m (attribs: ILAttributes) = + attribs.AsList |> List.map (fun a -> ILAttribInfo (g, amap, scoref, a, m)) + +let AttribInfosOfFS g attribs = + attribs |> List.map (fun a -> FSAttribInfo (g, a)) + +let GetAttribInfosOfEntity g amap m (tcref:TyconRef) = + match metadataOfTycon tcref.Deref with +#if !NO_EXTENSIONTYPING + // TODO: provided attributes + | ProvidedTypeMetadata _info -> [] + //let provAttribs = info.ProvidedType.PApply((fun a -> (a :> IProvidedCustomAttributeProvider)), m) + //match provAttribs.PUntaint((fun a -> a. .GetAttributeConstructorArgs(provAttribs.TypeProvider.PUntaintNoFailure(id), atref.FullName)), m) with + //| Some args -> f3 args + //| None -> None +#endif + | ILTypeMetadata (TILObjectReprData(scoref, _, tdef)) -> + tdef.CustomAttrs |> AttribInfosOfIL g amap scoref m + | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> + tcref.Attribs |> List.map (fun a -> FSAttribInfo (g, a)) + + +let GetAttribInfosOfMethod amap m minfo = + match minfo with + | ILMeth (g, ilminfo, _) -> ilminfo.RawMetadata.CustomAttrs |> AttribInfosOfIL g amap ilminfo.MetadataScope m + | FSMeth (g, _, vref, _) -> vref.Attribs |> AttribInfosOfFS g + | DefaultStructCtor _ -> [] +#if !NO_EXTENSIONTYPING + // TODO: provided attributes + | ProvidedMeth (_, _mi, _, _m) -> + [] + +#endif + +let GetAttribInfosOfProp amap m pinfo = + match pinfo with + | ILProp ilpinfo -> ilpinfo.RawMetadata.CustomAttrs |> AttribInfosOfIL ilpinfo.TcGlobals amap ilpinfo.ILTypeInfo.ILScopeRef m + | FSProp(g, _, Some vref, _) + | FSProp(g, _, _, Some vref) -> vref.Attribs |> AttribInfosOfFS g + | FSProp _ -> failwith "GetAttribInfosOfProp: unreachable" +#if !NO_EXTENSIONTYPING + // TODO: provided attributes + | ProvidedProp _ -> [] +#endif + +let GetAttribInfosOfEvent amap m einfo = + match einfo with + | ILEvent ileinfo -> ileinfo.RawMetadata.CustomAttrs |> AttribInfosOfIL einfo.TcGlobals amap ileinfo.ILTypeInfo.ILScopeRef m + | FSEvent(_, pi, _vref1, _vref2) -> GetAttribInfosOfProp amap m pi +#if !NO_EXTENSIONTYPING + // TODO: provided attributes + | ProvidedEvent _ -> [] +#endif + +/// Analyze three cases for attributes declared on type definitions: IL-declared attributes, F#-declared attributes and +/// provided attributes. +// +// This is used for AttributeUsageAttribute, DefaultMemberAttribute and ConditionalAttribute (on attribute types) +let TryBindTyconRefAttribute g m (AttribInfo (atref, _) as args) (tcref:TyconRef) f1 f2 f3 = + ignore m; ignore f3 + match metadataOfTycon tcref.Deref with +#if !NO_EXTENSIONTYPING + | ProvidedTypeMetadata info -> + let provAttribs = info.ProvidedType.PApply((fun a -> (a :> IProvidedCustomAttributeProvider)), m) + match provAttribs.PUntaint((fun a -> a.GetAttributeConstructorArgs(provAttribs.TypeProvider.PUntaintNoFailure(id), atref.FullName)), m) with + | Some args -> f3 args + | None -> None +#endif + | ILTypeMetadata (TILObjectReprData(_, _, tdef)) -> + match TryDecodeILAttribute g atref tdef.CustomAttrs with + | Some attr -> f1 attr + | _ -> None + | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> + match TryFindFSharpAttribute g args tcref.Attribs with + | Some attr -> f2 attr + | _ -> None + +/// Analyze three cases for attributes declared on methods: IL-declared attributes, F#-declared attributes and +/// provided attributes. +let BindMethInfoAttributes m minfo f1 f2 f3 = + ignore m; ignore f3 + match minfo with + | ILMeth (_, x, _) -> f1 x.RawMetadata.CustomAttrs + | FSMeth (_, _, vref, _) -> f2 vref.Attribs + | DefaultStructCtor _ -> f2 [] +#if !NO_EXTENSIONTYPING + | ProvidedMeth (_, mi, _, _) -> f3 (mi.PApply((fun st -> (st :> IProvidedCustomAttributeProvider)), m)) +#endif + +/// Analyze three cases for attributes declared on methods: IL-declared attributes, F#-declared attributes and +/// provided attributes. +let TryBindMethInfoAttribute g m (AttribInfo(atref, _) as attribSpec) minfo f1 f2 f3 = +#if !NO_EXTENSIONTYPING +#else + // to prevent unused parameter warning + ignore f3 +#endif + BindMethInfoAttributes m minfo + (fun ilAttribs -> TryDecodeILAttribute g atref ilAttribs |> Option.bind f1) + (fun fsAttribs -> TryFindFSharpAttribute g attribSpec fsAttribs |> Option.bind f2) +#if !NO_EXTENSIONTYPING + (fun provAttribs -> + match provAttribs.PUntaint((fun a -> a.GetAttributeConstructorArgs(provAttribs.TypeProvider.PUntaintNoFailure(id), atref.FullName)), m) with + | Some args -> f3 args + | None -> None) +#else + (fun _provAttribs -> None) +#endif + +/// Try to find a specific attribute on a method, where the attribute accepts a string argument. +/// +/// This is just used for the 'ConditionalAttribute' attribute +let TryFindMethInfoStringAttribute g m attribSpec minfo = + TryBindMethInfoAttribute g m attribSpec minfo + (function ([ILAttribElem.String (Some msg) ], _) -> Some msg | _ -> None) + (function (Attrib(_, _, [ AttribStringArg msg ], _, _, _, _)) -> Some msg | _ -> None) + (function ([ Some ((:? string as msg) : obj) ], _) -> Some msg | _ -> None) + +/// Check if a method has a specific attribute. +let MethInfoHasAttribute g m attribSpec minfo = + TryBindMethInfoAttribute g m attribSpec minfo + (fun _ -> Some ()) + (fun _ -> Some ()) + (fun _ -> Some ()) + |> Option.isSome + + +/// Check IL attributes for 'ObsoleteAttribute', returning errors and warnings as data +let private CheckILAttributes (g: TcGlobals) isByrefLikeTyconRef cattrs m = + let (AttribInfo(tref,_)) = g.attrib_SystemObsolete + match TryDecodeILAttribute g tref cattrs with + | Some ([ILAttribElem.String (Some msg) ], _) when not isByrefLikeTyconRef -> + WarnD(ObsoleteWarning(msg, m)) + | Some ([ILAttribElem.String (Some msg); ILAttribElem.Bool isError ], _) when not isByrefLikeTyconRef -> + if isError then + ErrorD (ObsoleteError(msg, m)) + else + WarnD (ObsoleteWarning(msg, m)) + | Some ([ILAttribElem.String None ], _) when not isByrefLikeTyconRef -> + WarnD(ObsoleteWarning("", m)) + | Some _ when not isByrefLikeTyconRef -> + WarnD(ObsoleteWarning("", m)) + | _ -> + CompleteD + +let langVersionPrefix = "--langversion:preview" + +/// Check F# attributes for 'ObsoleteAttribute', 'CompilerMessageAttribute' and 'ExperimentalAttribute', +/// returning errors and warnings as data +let CheckFSharpAttributes (g:TcGlobals) attribs m = + let isExperimentalAttributeDisabled (s:string) = + if g.compilingFslib then + true + else + g.langVersion.IsPreviewEnabled && (s.IndexOf(langVersionPrefix, StringComparison.OrdinalIgnoreCase) >= 0) + + if isNil attribs then CompleteD + else + (match TryFindFSharpAttribute g g.attrib_SystemObsolete attribs with + | Some(Attrib(_, _, [ AttribStringArg s ], _, _, _, _)) -> + WarnD(ObsoleteWarning(s, m)) + | Some(Attrib(_, _, [ AttribStringArg s; AttribBoolArg(isError) ], _, _, _, _)) -> + if isError then + ErrorD (ObsoleteError(s, m)) + else + WarnD (ObsoleteWarning(s, m)) + | Some _ -> + WarnD(ObsoleteWarning("", m)) + | None -> + CompleteD + ) ++ (fun () -> + + match TryFindFSharpAttribute g g.attrib_CompilerMessageAttribute attribs with + | Some(Attrib(_, _, [ AttribStringArg s ; AttribInt32Arg n ], namedArgs, _, _, _)) -> + let msg = UserCompilerMessage(s, n, m) + let isError = + match namedArgs with + | ExtractAttribNamedArg "IsError" (AttribBoolArg v) -> v + | _ -> false + // If we are using a compiler that supports nameof then error 3501 is always suppressed. + // See attribute on FSharp.Core 'nameof' + if n = 3501 then CompleteD + elif isError && (not g.compilingFslib || n <> 1204) then ErrorD msg + else WarnD msg + | _ -> + CompleteD + ) ++ (fun () -> + + match TryFindFSharpAttribute g g.attrib_ExperimentalAttribute attribs with + | Some(Attrib(_, _, [ AttribStringArg(s) ], _, _, _, _)) -> + if isExperimentalAttributeDisabled s then + CompleteD + else + WarnD(Experimental(s, m)) + | Some _ -> + WarnD(Experimental(FSComp.SR.experimentalConstruct (), m)) + | _ -> + CompleteD + ) ++ (fun () -> + + match TryFindFSharpAttribute g g.attrib_UnverifiableAttribute attribs with + | Some _ -> + WarnD(PossibleUnverifiableCode(m)) + | _ -> + CompleteD + ) + +#if !NO_EXTENSIONTYPING +/// Check a list of provided attributes for 'ObsoleteAttribute', returning errors and warnings as data +let private CheckProvidedAttributes (g: TcGlobals) m (provAttribs: Tainted) = + let (AttribInfo(tref, _)) = g.attrib_SystemObsolete + match provAttribs.PUntaint((fun a -> a.GetAttributeConstructorArgs(provAttribs.TypeProvider.PUntaintNoFailure(id), tref.FullName)), m) with + | Some ([ Some (:? string as msg) ], _) -> WarnD(ObsoleteWarning(msg, m)) + | Some ([ Some (:? string as msg); Some (:?bool as isError) ], _) -> + if isError then + ErrorD (ObsoleteError(msg, m)) + else + WarnD (ObsoleteWarning(msg, m)) + | Some ([ None ], _) -> + WarnD(ObsoleteWarning("", m)) + | Some _ -> + WarnD(ObsoleteWarning("", m)) + | None -> + CompleteD +#endif + +/// Indicate if a list of IL attributes contains 'ObsoleteAttribute'. Used to suppress the item in intellisense. +let CheckILAttributesForUnseen (g: TcGlobals) cattrs _m = + let (AttribInfo(tref, _)) = g.attrib_SystemObsolete + Option.isSome (TryDecodeILAttribute g tref cattrs) + +/// Checks the attributes for CompilerMessageAttribute, which has an IsHidden argument that allows +/// items to be suppressed from intellisense. +let CheckFSharpAttributesForHidden g attribs = + not (isNil attribs) && + (match TryFindFSharpAttribute g g.attrib_CompilerMessageAttribute attribs with + | Some(Attrib(_, _, [AttribStringArg _; AttribInt32Arg messageNumber], + ExtractAttribNamedArg "IsHidden" (AttribBoolArg v), _, _, _)) -> + // Message number 62 is for "ML Compatibility". Items labelled with this are visible in intellisense + // when mlCompatibility is set. + v && not (messageNumber = 62 && g.mlCompatibility) + | _ -> false) + || + (match TryFindFSharpAttribute g g.attrib_ComponentModelEditorBrowsableAttribute attribs with + | Some(Attrib(_, _, [AttribInt32Arg state], _, _, _, _)) -> state = int System.ComponentModel.EditorBrowsableState.Never + | _ -> false) + +/// Indicate if a list of F# attributes contains 'ObsoleteAttribute'. Used to suppress the item in intellisense. +let CheckFSharpAttributesForObsolete g attribs = + not (isNil attribs) && (HasFSharpAttribute g g.attrib_SystemObsolete attribs) + +/// Indicate if a list of F# attributes contains 'ObsoleteAttribute'. Used to suppress the item in intellisense. +/// Also check the attributes for CompilerMessageAttribute, which has an IsHidden argument that allows +/// items to be suppressed from intellisense. +let CheckFSharpAttributesForUnseen g attribs _m = + not (isNil attribs) && + (CheckFSharpAttributesForObsolete g attribs || + CheckFSharpAttributesForHidden g attribs) + +#if !NO_EXTENSIONTYPING +/// Indicate if a list of provided attributes contains 'ObsoleteAttribute'. Used to suppress the item in intellisense. +let CheckProvidedAttributesForUnseen (provAttribs: Tainted) m = + provAttribs.PUntaint((fun a -> a.GetAttributeConstructorArgs(provAttribs.TypeProvider.PUntaintNoFailure(id), typeof.FullName).IsSome), m) +#endif + +/// Check the attributes associated with a property, returning warnings and errors as data. +let CheckPropInfoAttributes pinfo m = + match pinfo with + | ILProp(ILPropInfo(_, pdef)) -> CheckILAttributes pinfo.TcGlobals false pdef.CustomAttrs m + | FSProp(g, _, Some vref, _) + | FSProp(g, _, _, Some vref) -> CheckFSharpAttributes g vref.Attribs m + | FSProp _ -> failwith "CheckPropInfoAttributes: unreachable" +#if !NO_EXTENSIONTYPING + | ProvidedProp (amap, pi, m) -> + CheckProvidedAttributes amap.g m (pi.PApply((fun st -> (st :> IProvidedCustomAttributeProvider)), m)) + +#endif + + +/// Check the attributes associated with a IL field, returning warnings and errors as data. +let CheckILFieldAttributes g (finfo:ILFieldInfo) m = + match finfo with + | ILFieldInfo(_, pd) -> + CheckILAttributes g false pd.CustomAttrs m |> CommitOperationResult +#if !NO_EXTENSIONTYPING + | ProvidedField (amap, fi, m) -> + CheckProvidedAttributes amap.g m (fi.PApply((fun st -> (st :> IProvidedCustomAttributeProvider)), m)) |> CommitOperationResult +#endif + +/// Check the attributes associated with a method, returning warnings and errors as data. +let CheckMethInfoAttributes g m tyargsOpt minfo = + let search = + BindMethInfoAttributes m minfo + (fun ilAttribs -> Some(CheckILAttributes g false ilAttribs m)) + (fun fsAttribs -> + let res = + CheckFSharpAttributes g fsAttribs m ++ (fun () -> + if Option.isNone tyargsOpt && HasFSharpAttribute g g.attrib_RequiresExplicitTypeArgumentsAttribute fsAttribs then + ErrorD(Error(FSComp.SR.tcFunctionRequiresExplicitTypeArguments(minfo.LogicalName), m)) + else + CompleteD) + Some res) +#if !NO_EXTENSIONTYPING + (fun provAttribs -> Some (CheckProvidedAttributes g m provAttribs)) +#else + (fun _provAttribs -> None) +#endif + match search with + | Some res -> res + | None -> CompleteD // no attribute = no errors + +/// Indicate if a method has 'Obsolete', 'CompilerMessageAttribute' or 'TypeProviderEditorHideMethodsAttribute'. +/// Used to suppress the item in intellisense. +let MethInfoIsUnseen g m ty minfo = + let isUnseenByObsoleteAttrib () = + match BindMethInfoAttributes m minfo + (fun ilAttribs -> Some(CheckILAttributesForUnseen g ilAttribs m)) + (fun fsAttribs -> Some(CheckFSharpAttributesForUnseen g fsAttribs m)) +#if !NO_EXTENSIONTYPING + (fun provAttribs -> Some(CheckProvidedAttributesForUnseen provAttribs m)) +#else + (fun _provAttribs -> None) +#endif + with + | Some res -> res + | None -> false + + let isUnseenByHidingAttribute () = +#if !NO_EXTENSIONTYPING + not (isObjTy g ty) && + isAppTy g ty && + isObjTy g minfo.ApparentEnclosingType && + let tcref = tcrefOfAppTy g ty + match tcref.TypeReprInfo with + | TProvidedTypeExtensionPoint info -> + info.ProvidedType.PUntaint((fun st -> (st :> IProvidedCustomAttributeProvider).GetHasTypeProviderEditorHideMethodsAttribute(info.ProvidedType.TypeProvider.PUntaintNoFailure(id))), m) + | _ -> + // This attribute check is done by name to ensure compilation doesn't take a dependency + // on Microsoft.FSharp.Core.CompilerServices.TypeProviderEditorHideMethodsAttribute. + // + // We are only interested in filtering out the method on System.Object, so it is sufficient + // just to look at the attributes on IL methods. + if tcref.IsILTycon then + tcref.ILTyconRawMetadata.CustomAttrs.AsArray + |> Array.exists (fun attr -> attr.Method.DeclaringType.TypeSpec.Name = typeof.FullName) + else + false +#else + ty |> ignore + false +#endif + + //let isUnseenByBeingTupleMethod () = isAnyTupleTy g ty + + isUnseenByObsoleteAttrib () || isUnseenByHidingAttribute () //|| isUnseenByBeingTupleMethod () + +/// Indicate if a property has 'Obsolete' or 'CompilerMessageAttribute'. +/// Used to suppress the item in intellisense. +let PropInfoIsUnseen m pinfo = + match pinfo with + | ILProp (ILPropInfo(_, pdef) as ilpinfo) -> + // Properties on .NET tuple types are resolvable but unseen + isAnyTupleTy pinfo.TcGlobals ilpinfo.ILTypeInfo.ToType || + CheckILAttributesForUnseen pinfo.TcGlobals pdef.CustomAttrs m + | FSProp (g, _, Some vref, _) + | FSProp (g, _, _, Some vref) -> CheckFSharpAttributesForUnseen g vref.Attribs m + | FSProp _ -> failwith "CheckPropInfoAttributes: unreachable" +#if !NO_EXTENSIONTYPING + | ProvidedProp (_amap, pi, m) -> + CheckProvidedAttributesForUnseen (pi.PApply((fun st -> (st :> IProvidedCustomAttributeProvider)), m)) m +#endif + +/// Check the attributes on an entity, returning errors and warnings as data. +let CheckEntityAttributes g (x:TyconRef) m = + if x.IsILTycon then + CheckILAttributes g (isByrefLikeTyconRef g m x) x.ILTyconRawMetadata.CustomAttrs m + else + CheckFSharpAttributes g x.Attribs m + +/// Check the attributes on a union case, returning errors and warnings as data. +let CheckUnionCaseAttributes g (x:UnionCaseRef) m = + CheckEntityAttributes g x.TyconRef m ++ (fun () -> + CheckFSharpAttributes g x.Attribs m) + +/// Check the attributes on a record field, returning errors and warnings as data. +let CheckRecdFieldAttributes g (x:RecdFieldRef) m = + CheckEntityAttributes g x.TyconRef m ++ (fun () -> + CheckFSharpAttributes g x.PropertyAttribs m) + +/// Check the attributes on an F# value, returning errors and warnings as data. +let CheckValAttributes g (x:ValRef) m = + CheckFSharpAttributes g x.Attribs m + +/// Check the attributes on a record field, returning errors and warnings as data. +let CheckRecdFieldInfoAttributes g (x:RecdFieldInfo) m = + CheckRecdFieldAttributes g x.RecdFieldRef m + + +// Identify any security attributes +let IsSecurityAttribute (g: TcGlobals) amap (casmap : Dictionary) (Attrib(tcref, _, _, _, _, _, _)) m = + // There's no CAS on Silverlight, so we have to be careful here + match g.attrib_SecurityAttribute with + | None -> false + | Some attr -> + match attr.TyconRef.TryDeref with + | ValueSome _ -> + let tcs = tcref.Stamp + match casmap.TryGetValue tcs with + | true, c -> c + | _ -> + let exists = ExistsInEntireHierarchyOfType (fun t -> typeEquiv g t (mkAppTy attr.TyconRef [])) g amap m AllowMultiIntfInstantiations.Yes (mkAppTy tcref []) + casmap.[tcs] <- exists + exists + | ValueNone -> false + +let IsSecurityCriticalAttribute g (Attrib(tcref, _, _, _, _, _, _)) = + (tyconRefEq g tcref g.attrib_SecurityCriticalAttribute.TyconRef || tyconRefEq g tcref g.attrib_SecuritySafeCriticalAttribute.TyconRef) + diff --git a/src/fsharp/CompilerGlobalState.fs b/src/fsharp/CompilerGlobalState.fs index 08e977aa3b7..589a145baf0 100644 --- a/src/fsharp/CompilerGlobalState.fs +++ b/src/fsharp/CompilerGlobalState.fs @@ -74,17 +74,12 @@ type StableNiceNameGenerator() = type internal CompilerGlobalState () = /// A global generator of compiler generated names - // ++GLOBAL MUTABLE STATE (concurrency safe by locking inside NiceNameGenerator) let globalNng = NiceNameGenerator() - /// A global generator of stable compiler generated names - // MUTABLE STATE (concurrency safe by locking inside StableNiceNameGenerator) let globalStableNameGenerator = StableNiceNameGenerator () /// A name generator used by IlxGen for static fields, some generated arguments and other things. - /// REVIEW: this will mean the hosted compiler service is not deterministic. We should at least create a new one - /// of these for each compilation. let ilxgenGlobalNng = NiceNameGenerator () member __.NiceNameGenerator = globalNng diff --git a/src/fsharp/CompilerGlobalState.fsi b/src/fsharp/CompilerGlobalState.fsi new file mode 100644 index 00000000000..77ba46b2782 --- /dev/null +++ b/src/fsharp/CompilerGlobalState.fsi @@ -0,0 +1,54 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +/// Defines the global environment for all type checking. + +module FSharp.Compiler.CompilerGlobalState + +open FSharp.Compiler.Range + +/// Generates compiler-generated names. Each name generated also includes the StartLine number of the range passed in +/// at the point of first generation. +/// +/// This type may be accessed concurrently, though in practice it is only used from the compilation thread. +/// It is made concurrency-safe since a global instance of the type is allocated in tast.fs, and it is good +/// policy to make all globally-allocated objects concurrency safe in case future versions of the compiler +/// are used to host multiple concurrent instances of compilation. +type NiceNameGenerator = + + new: unit -> NiceNameGenerator + member FreshCompilerGeneratedName: name:string * m:range -> string + member Reset: unit -> unit + +/// Generates compiler-generated names marked up with a source code location, but if given the same unique value then +/// return precisely the same name. Each name generated also includes the StartLine number of the range passed in +/// at the point of first generation. +/// +/// This type may be accessed concurrently, though in practice it is only used from the compilation thread. +/// It is made concurrency-safe since a global instance of the type is allocated in tast.fs. +type StableNiceNameGenerator = + + new: unit -> StableNiceNameGenerator + member GetUniqueCompilerGeneratedName: name:string * m:range * uniq:int64 -> string + member Reset: unit -> unit + +type internal CompilerGlobalState = + + new: unit -> CompilerGlobalState + + /// A name generator used by IlxGen for static fields, some generated arguments and other things. + member IlxGenNiceNameGenerator: NiceNameGenerator + + /// A global generator of compiler generated names + member NiceNameGenerator: NiceNameGenerator + + /// A global generator of stable compiler generated names + member StableNameGenerator: StableNiceNameGenerator + +type Unique = int64 + +/// Concurrency-safe +val newUnique: (unit -> int64) + +/// Unique name generator for stamps attached to to val_specs, tycon_specs etc. +/// Concurrency-safe +val newStamp: (unit -> int64) diff --git a/src/fsharp/ErrorLogger.fs b/src/fsharp/ErrorLogger.fs index 7705278dcee..1e391eb2aaf 100644 --- a/src/fsharp/ErrorLogger.fs +++ b/src/fsharp/ErrorLogger.fs @@ -254,8 +254,8 @@ type PhasedDiagnostic = // Recovery is to treat this as a 'build' error. Downstream, the project system and language service will treat this as // if it came from the build and not the language service. false - /// Return true if this phase is one that's known to be part of the 'compile'. This is the initial phase of the entire compilation that + /// Return true if this phase is one that's known to be part of the 'compile'. This is the initial phase of the entire compilation that /// the language service knows about. member pe.IsPhaseInCompile() = let isPhaseInCompile = @@ -513,13 +513,12 @@ let conditionallySuppressErrorReporting cond f = if cond then suppressErrorRepor //------------------------------------------------------------------------ // Errors as data: Sometimes we have to reify errors as data, e.g. if backtracking -// -// REVIEW: consider using F# computation expressions here +/// The result type of a computational modality to colelct warnings and possibly fail [] type OperationResult<'T> = - | OkResult of (* warnings: *) exn list * 'T - | ErrorResult of (* warnings: *) exn list * exn + | OkResult of warnings: exn list * 'T + | ErrorResult of warnings: exn list * exn type ImperativeOperationResult = OperationResult @@ -536,9 +535,13 @@ let CommitOperationResult res = let RaiseOperationResult res : unit = CommitOperationResult res let ErrorD err = ErrorResult([], err) + let WarnD err = OkResult([err], ()) + let CompleteD = OkResult([], ()) + let ResultD x = OkResult([], x) + let CheckNoErrorsAndGetWarnings res = match res with | OkResult (warns, _) -> Some warns @@ -624,7 +627,6 @@ module OperationResult = | ErrorResult(warnings, err) -> ErrorResult(warnings, err) // Code below is for --flaterrors flag that is only used by the IDE - let stringThatIsAProxyForANewlineInFlatErrors = new System.String [|char 29 |] let NewlineifyErrorString (message:string) = message.Replace(stringThatIsAProxyForANewlineInFlatErrors, Environment.NewLine) @@ -675,13 +677,6 @@ type public FSharpErrorSeverityOptions = WarnAsWarn = [] } - -// See https://github.com/Microsoft/visualfsharp/issues/6417, if a compile of the FSharp.Compiler.Services.dll or other compiler -// binary produces exactly 65536 methods then older versions of the compiler raise a bug. If you hit this bug again then try adding -// this back in. -// let dummyMethodFOrBug6417A() = () -// let dummyMethodFOrBug6417B() = () - let private tryLanguageFeatureErrorAux (langVersion: LanguageVersion) (langFeature: LanguageFeature) (m: range) = if not (langVersion.SupportsFeature langFeature) then let featureStr = langVersion.GetFeatureString langFeature diff --git a/src/fsharp/ErrorLogger.fsi b/src/fsharp/ErrorLogger.fsi new file mode 100644 index 00000000000..32939980d54 --- /dev/null +++ b/src/fsharp/ErrorLogger.fsi @@ -0,0 +1,339 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module public FSharp.Compiler.ErrorLogger + +open System +open FSharp.Compiler +open FSharp.Compiler.Range +open FSharp.Compiler.Features + +/// Represents the style being used to format errors +[] +type ErrorStyle = + | DefaultErrors + | EmacsErrors + | TestErrors + | VSErrors + | GccErrors + +/// Thrown when we want to add some range information to a .NET exception +exception WrappedError of exn * range + +/// Thrown when immediate, local error recovery is not possible. This indicates +/// we've reported an error but need to make a non-local transfer of control. +/// Error recovery may catch this and continue (see 'errorRecovery') +/// +/// The exception that caused the report is carried as data because in some +/// situations (LazyWithContext) we may need to re-report the original error +/// when a lazy thunk is re-evaluated. +exception ReportedError of exn option + +val findOriginalException: err:exn -> exn + +type Suggestions = (string -> unit) -> unit + +val NoSuggestions: Suggestions + +/// Thrown when we stop processing the F# Interactive entry or #load. +exception StopProcessingExn of exn option + +val ( |StopProcessing|_| ): exn:exn -> unit option + +val StopProcessing<'T> : exn + +exception NumberedError of (int * string) * range + +exception Error of (int * string) * range + +exception InternalError of msg: string * range + +exception UserCompilerMessage of string * int * range + +exception LibraryUseOnly of range + +exception Deprecated of string * range + +exception Experimental of string * range + +exception PossibleUnverifiableCode of range + +exception UnresolvedReferenceNoRange of string + +exception UnresolvedReferenceError of string * range + +exception UnresolvedPathReferenceNoRange of string * string + +exception UnresolvedPathReference of string * string * range + +exception ErrorWithSuggestions of (int * string) * range * string * Suggestions + +val inline protectAssemblyExploration: dflt:'a -> f:(unit -> 'a) -> 'a + +val inline protectAssemblyExplorationF: dflt:(string * string -> 'a) -> f:(unit -> 'a) -> 'a + +val inline protectAssemblyExplorationNoReraise: dflt1:'a -> dflt2:'a -> f:(unit -> 'a) -> 'a + +val AttachRange: m:range -> exn:exn -> exn + +type Exiter = + abstract member Exit: int -> 'T + +val QuitProcessExiter: Exiter + +/// Closed enumeration of build phases. +[] +type BuildPhase = + | DefaultPhase + | Compile + | Parameter + | Parse + | TypeCheck + | CodeGen + | Optimize + | IlxGen + | IlGen + | Output + | Interactive + +/// Literal build phase subcategory strings. +module BuildPhaseSubcategory = + [] val DefaultPhase: string = "" + [] val Compile: string = "compile" + [] val Parameter: string = "parameter" + [] val Parse: string = "parse" + [] val TypeCheck: string = "typecheck" + [] val CodeGen: string = "codegen" + [] val Optimize: string = "optimize" + [] val IlxGen: string = "ilxgen" + [] val IlGen: string = "ilgen" + [] val Output: string = "output" + [] val Interactive: string = "interactive" + [] val Internal: string = "internal" + +type PhasedDiagnostic = + { Exception: exn + Phase: BuildPhase } + + /// Construct a phased error + static member Create: exn:exn * phase:BuildPhase -> PhasedDiagnostic + + /// Return true if the textual phase given is from the compile part of the build process. + /// This set needs to be equal to the set of subcategories that the language service can produce. + static member IsSubcategoryOfCompile: subcategory:string -> bool + + member DebugDisplay: unit -> string + + /// Return true if this phase is one that's known to be part of the 'compile'. This is the initial phase of the entire compilation that + /// the language service knows about. + member IsPhaseInCompile: unit -> bool + + /// This is the textual subcategory to display in error and warning messages (shows only under --vserrors): + /// + /// file1.fs(72): subcategory warning FS0072: This is a warning message + /// + member Subcategory: unit -> string + +[] +type ErrorLogger = + + new: nameForDebugging:string -> ErrorLogger + + member DebugDisplay: unit -> string + + abstract member DiagnosticSink: phasedError:PhasedDiagnostic * isError:bool -> unit + + abstract member ErrorCount: int + +val DiscardErrorsLogger: ErrorLogger + +val AssertFalseErrorLogger: ErrorLogger + +type CapturingErrorLogger = + inherit ErrorLogger + + new: nm:string -> CapturingErrorLogger + + member CommitDelayedDiagnostics: errorLogger:ErrorLogger -> unit + + override DiagnosticSink: phasedError:PhasedDiagnostic * isError:bool -> unit + + member Diagnostics: (PhasedDiagnostic * bool) list + + override ErrorCount: int + +[] +type internal CompileThreadStatic = + + static member BuildPhase: BuildPhase + + static member BuildPhaseUnchecked: BuildPhase + + static member ErrorLogger: ErrorLogger + +module ErrorLoggerExtensions = + + val tryAndDetectDev15: bool + + /// Instruct the exception not to reset itself when thrown again. + val PreserveStackTrace: exn:'a -> unit + + /// Reraise an exception if it is one we want to report to Watson. + val ReraiseIfWatsonable: exn:exn -> unit + + type ErrorLogger with + member ErrorR: exn:exn -> unit + member Warning: exn:exn -> unit + member Error: exn:exn -> 'b + member SimulateError: ph:PhasedDiagnostic -> 'a + member ErrorRecovery: exn:exn -> m:range -> unit + member StopProcessingRecovery: exn:exn -> m:range -> unit + member ErrorRecoveryNoRange: exn:exn -> unit + +/// NOTE: The change will be undone when the returned "unwind" object disposes +val PushThreadBuildPhaseUntilUnwind: phase:BuildPhase -> System.IDisposable + +/// NOTE: The change will be undone when the returned "unwind" object disposes +val PushErrorLoggerPhaseUntilUnwind: errorLoggerTransformer:(ErrorLogger -> #ErrorLogger) -> System.IDisposable + +val SetThreadBuildPhaseNoUnwind: phase:BuildPhase -> unit + +val SetThreadErrorLoggerNoUnwind: errorLogger:ErrorLogger -> unit + +val errorR: exn:exn -> unit + +val warning: exn:exn -> unit + +val error: exn:exn -> 'a + +val simulateError: p:PhasedDiagnostic -> 'a + +val diagnosticSink: phasedError:PhasedDiagnostic * isError:bool -> unit + +val errorSink: pe:PhasedDiagnostic -> unit + +val warnSink: pe:PhasedDiagnostic -> unit + +val errorRecovery: exn:exn -> m:range -> unit + +val stopProcessingRecovery: exn:exn -> m:range -> unit + +val errorRecoveryNoRange: exn:exn -> unit + +val report: f:(unit -> 'a) -> 'a + +val deprecatedWithError: s:string -> m:range -> unit + +val mutable reportLibraryOnlyFeatures: bool + +val libraryOnlyError: m:range -> unit + +val libraryOnlyWarning: m:range -> unit + +val deprecatedOperator: m:range -> unit + +val mlCompatWarning: s:System.String -> m:range -> unit + +val suppressErrorReporting: f:(unit -> 'a) -> 'a + +val conditionallySuppressErrorReporting: cond:bool -> f:(unit -> 'a) -> 'a + +/// The result type of a computational modality to colelct warnings and possibly fail +[] +type OperationResult<'T> = + | OkResult of warnings: exn list * 'T + | ErrorResult of warnings: exn list * exn + +type ImperativeOperationResult = OperationResult + +val ReportWarnings: warns:#exn list -> unit + +val CommitOperationResult: res:OperationResult<'a> -> 'a + +val RaiseOperationResult: res:OperationResult -> unit + +val ErrorD: err:exn -> OperationResult<'a> + +val WarnD: err:exn -> OperationResult + +val CompleteD: OperationResult + +val ResultD: x:'a -> OperationResult<'a> + +val CheckNoErrorsAndGetWarnings: res:OperationResult<'a> -> exn list option + +val ( ++ ): res:OperationResult<'a> -> f:('a -> OperationResult<'b>) -> OperationResult<'b> + +/// Stop on first error. Accumulate warnings and continue. +val IterateD: f:('a -> OperationResult) -> xs:'a list -> OperationResult + +val WhileD: gd:(unit -> bool) -> body:(unit -> OperationResult) -> OperationResult + +val MapD: f:('a -> OperationResult<'b>) -> xs:'a list -> OperationResult<'b list> + +type TrackErrorsBuilder = + + new: unit -> TrackErrorsBuilder + + member Bind: res:OperationResult<'h> * k:('h -> OperationResult<'i>) -> OperationResult<'i> + + member Combine: expr1:OperationResult<'c> * expr2:('c -> OperationResult<'d>) -> OperationResult<'d> + + member Delay: fn:(unit -> 'b) -> (unit -> 'b) + + member For: seq:'e list * k:('e -> OperationResult) -> OperationResult + + member Return: res:'g -> OperationResult<'g> + + member ReturnFrom: res:'f -> 'f + + member Run: fn:(unit -> 'a) -> 'a + + member While: gd:(unit -> bool) * k:(unit -> OperationResult) -> OperationResult + + member Zero: unit -> OperationResult + +val trackErrors: TrackErrorsBuilder + +val OptionD: f:('a -> OperationResult) -> xs:'a option -> OperationResult + +val IterateIdxD: f:(int -> 'a -> OperationResult) -> xs:'a list -> OperationResult + +/// Stop on first error. Accumulate warnings and continue. +val Iterate2D: f:('a -> 'b -> OperationResult) -> xs:'a list -> ys:'b list -> OperationResult + +val TryD: f:(unit -> OperationResult<'a>) -> g:(exn -> OperationResult<'a>) -> OperationResult<'a> + +val RepeatWhileD: nDeep:int -> body:(int -> OperationResult) -> OperationResult + +val AtLeastOneD: f:('a -> OperationResult) -> l:'a list -> OperationResult + +module OperationResult = + val inline ignore: res:OperationResult<'a> -> OperationResult + +// For --flaterrors flag that is only used by the IDE +val stringThatIsAProxyForANewlineInFlatErrors: String + +val NewlineifyErrorString: message:string -> string + +/// fixes given string by replacing all control chars with spaces. +/// NOTE: newlines are recognized and replaced with stringThatIsAProxyForANewlineInFlatErrors (ASCII 29, the 'group separator'), +/// which is decoded by the IDE with 'NewlineifyErrorString' back into newlines, so that multi-line errors can be displayed in QuickInfo +val NormalizeErrorString: text:string -> string + +type FSharpErrorSeverityOptions = + { WarnLevel: int + GlobalWarnAsError: bool + WarnOff: int list + WarnOn: int list + WarnAsError: int list + WarnAsWarn: int list } + + static member Default: FSharpErrorSeverityOptions + +val internal checkLanguageFeatureError: langVersion:LanguageVersion -> langFeature:LanguageFeature -> m:range -> unit + +val internal checkLanguageFeatureErrorRecover: langVersion:LanguageVersion -> langFeature:LanguageFeature -> m:range -> unit + +val internal tryLanguageFeatureErrorOption: langVersion:LanguageVersion -> langFeature:LanguageFeature -> m:range -> exn option + +val internal languageFeatureNotSupportedInLibraryError: langVersion:LanguageVersion -> langFeature:LanguageFeature -> m:range -> 'a diff --git a/src/fsharp/ErrorResolutionHints.fsi b/src/fsharp/ErrorResolutionHints.fsi new file mode 100644 index 00000000000..a99b769770f --- /dev/null +++ b/src/fsharp/ErrorResolutionHints.fsi @@ -0,0 +1,37 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +/// Functions to format error message details +module internal FSharp.Compiler.ErrorResolutionHints + +open Internal.Utilities +open FSharp.Compiler.AbstractIL.Internal.Library +open System +open System.Collections +open System.Collections.Generic + +/// We report a candidate if its edit distance is <= the threshold. +/// The threshold is set to about a quarter of the number of characters. +val IsInEditDistanceProximity: idText:string -> suggestion:string -> bool + +/// Demangles a suggestion +val DemangleOperator: nm:string -> string + +type SuggestionBufferEnumerator = + + interface IDisposable + interface IEnumerator + interface IEnumerator + new: tail:int * data: KeyValuePair [] -> SuggestionBufferEnumerator + +type SuggestionBuffer = + + interface IEnumerable + interface IEnumerable + + new: idText:string -> SuggestionBuffer + + member Add: suggestion:string -> unit + + member Disabled: bool + + member IsEmpty: bool diff --git a/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj b/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj index 19a0ac2afe6..ce22a67f26f 100644 --- a/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj +++ b/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj @@ -8,7 +8,7 @@ $(DefineConstants);COMPILER_SERVICE_AS_DLL $(DefineConstants);COMPILER $(DefineConstants);ENABLE_MONO_SUPPORT - $(OtherFlags) /warnon:3218 /warnon:1182 /warnon:3390 --times + $(OtherFlags) --sig:all.fsi /warnon:3218 /warnon:1182 /warnon:3390 --times true true @@ -130,6 +130,9 @@ Utilities\HashMultiMap.fs + + Utilities\EditDistance.fsi + Utilities\EditDistance.fs @@ -145,6 +148,9 @@ Utilities\ildiag.fs + + Utilities\illib.fsi + Utilities\illib.fs @@ -172,6 +178,9 @@ Utilities\bytes.fs + + Utilities\XmlAdapters.fsi + Utilities\XmlAdapters.fs @@ -181,9 +190,15 @@ Utilities\InternalCollections.fs + + Utilities\QueueList.fsi + Utilities\QueueList.fs + + Utilities\lib.fsi + Utilities\lib.fs @@ -208,9 +223,15 @@ ErrorLogging\range.fs + + ErrorLogging\ErrorLogger.fsi + ErrorLogging\ErrorLogger.fs + + ErrorLogging\ErrorResolutionHints.fsi + ErrorLogging\ErrorResolutionHints.fs @@ -270,6 +291,9 @@ AbsIL\ilsupp.fs + + AbsIL\FsYaccOut\ilpars.fsi + AbsIL\FsYaccOut\ilpars.fs @@ -300,19 +324,34 @@ AbsIL\ilwrite.fs + + AbsIL\ilreflect.fsi + AbsIL\ilreflect.fs + + ReferenceResolution\ReferenceResolver.fsi + ReferenceResolution\ReferenceResolver.fs + + ReferenceResolution/SimulatedMSBuildReferenceResolver.fsi + ReferenceResolution/SimulatedMSBuildReferenceResolver.fs + + CompilerLocation\CompilerLocationUtils.fsi + CompilerLocation\CompilerLocationUtils.fs + + PrettyNaming\PrettyNaming.fsi + PrettyNaming\PrettyNaming.fs @@ -359,15 +398,24 @@ ParserAndUntypedAST\layout.fs + + ParserAndUntypedAST\XmlDoc.fsi + ParserAndUntypedAST\XmlDoc.fs ParserAndUntypedAST\SyntaxTree.fs + + ParserAndUntypedAST\SyntaxTreeOps.fsi + ParserAndUntypedAST\SyntaxTreeOps.fs + + ParserAndUntypedAST\ParseHelpers.fsi + ParserAndUntypedAST\ParseHelpers.fs @@ -413,12 +461,18 @@ TypedTree\QuotationPickler.fs + + TypedTree\CompilerGlobalState.fsi + TypedTree\CompilerGlobalState.fs TypedTree\TypedTree.fs + + TypedTree\TypedTreeBasics.fsi + TypedTree\TypedTreeBasics.fs @@ -443,21 +497,39 @@ Logic\import.fs + + Logic\infos.fsi + Logic\infos.fs + + Logic\AccessibilityLogic.fsi + Logic\AccessibilityLogic.fs + + Logic\AttributeChecking.fsi + Logic\AttributeChecking.fs + + Logic\TypeRelations.fsi + Logic\TypeRelations.fs + + Logic\InfoReader.fsi + Logic\InfoReader.fs + + Logic\NicePrint.fsi + Logic\NicePrint.fs @@ -473,12 +545,21 @@ Logic\NameResolution.fs + + Logic\SignatureConformance.fsi + Logic\SignatureConformance.fs + + Logic\MethodOverrides.fsi + Logic\MethodOverrides.fs + + Logic\MethodCalls.fsi + Logic\MethodCalls.fs diff --git a/src/fsharp/FSharp.Compiler.Service/all.fsi b/src/fsharp/FSharp.Compiler.Service/all.fsi new file mode 100644 index 00000000000..8f0f272fada --- /dev/null +++ b/src/fsharp/FSharp.Compiler.Service/all.fsi @@ -0,0 +1,28623 @@ +namespace FSharp.Compiler + module CompilerGlobalState = + type NiceNameGenerator = + + new: unit -> NiceNameGenerator + member + FreshCompilerGeneratedName: name:string * m:Range.range -> string + member Reset: unit -> unit + + type StableNiceNameGenerator = + + new: unit -> StableNiceNameGenerator + member + GetUniqueCompilerGeneratedName: name:string * m:Range.range * + uniq:int64 -> string + member Reset: unit -> unit + + type internal CompilerGlobalState = + + new: unit -> CompilerGlobalState + member IlxGenNiceNameGenerator: NiceNameGenerator + member NiceNameGenerator: NiceNameGenerator + member StableNameGenerator: StableNiceNameGenerator + + type Unique = int64 + val newUnique: (unit -> int64) + val newStamp: (unit -> int64) + + +namespace FSharp.Compiler + module internal TypedTree = + type Stamp = int64 + and StampMap<'T> = Map + [] + and ValInline = + | PseudoVal + | Always + | Optional + | Never + with + member MustInline: bool + + and ValRecursiveScopeInfo = + | ValInRecScope of bool + | ValNotInRecScope + and ValMutability = + | Immutable + | Mutable + [] + and TyparDynamicReq = + | No + | Yes + and ValBaseOrThisInfo = + | CtorThisVal + | BaseVal + | NormalVal + | MemberThisVal + [] + and ValFlags = + + new: recValInfo:ValRecursiveScopeInfo * baseOrThis:ValBaseOrThisInfo * + isCompGen:bool * inlineInfo:ValInline * isMutable:ValMutability * + isModuleOrMemberBinding:bool * isExtensionMember:bool * + isIncrClassSpecialMember:bool * isTyFunc:bool * allowTypeInst:bool * + isGeneratedEventVal:bool -> ValFlags + new: flags:int64 -> ValFlags + member SetIsCompilerGenerated: isCompGen:bool -> ValFlags + member + WithRecursiveValInfo: recValInfo:ValRecursiveScopeInfo -> ValFlags + member BaseOrThisInfo: ValBaseOrThisInfo + member HasBeenReferenced: bool + member IgnoresByrefScope: bool + member InlineInfo: ValInline + member IsCompiledAsStaticPropertyWithoutField: bool + member IsCompilerGenerated: bool + member IsExtensionMember: bool + member IsFixed: bool + member IsGeneratedEventVal: bool + member IsIncrClassSpecialMember: bool + member IsMemberOrModuleBinding: bool + member IsTypeFunction: bool + member MakesNoCriticalTailcalls: bool + member MutabilityInfo: ValMutability + member PermitsExplicitTypeInstantiation: bool + member PickledBits: int64 + member RecursiveValInfo: ValRecursiveScopeInfo + member WithHasBeenReferenced: ValFlags + member WithIgnoresByrefScope: ValFlags + member WithIsCompiledAsStaticPropertyWithoutField: ValFlags + member WithIsFixed: ValFlags + member WithIsMemberOrModuleBinding: ValFlags + member WithMakesNoCriticalTailcalls: ValFlags + + [] + and TyparKind = + | Type + | Measure + with + override ToString: unit -> string + member AttrName: string voption + + [] + and TyparRigidity = + | Rigid + | WillBeRigid + | WarnIfNotRigid + | Flexible + | Anon + with + member ErrorIfUnified: bool + member WarnIfMissingConstraint: bool + member WarnIfUnified: bool + + [] + and TyparFlags = + + new: kind:TyparKind * rigidity:TyparRigidity * isFromError:bool * + isCompGen:bool * staticReq:SyntaxTree.TyparStaticReq * + dynamicReq:TyparDynamicReq * equalityDependsOn:bool * + comparisonDependsOn:bool -> TyparFlags + new: flags:int32 -> TyparFlags + member WithCompatFlex: b:bool -> TyparFlags + member ComparisonConditionalOn: bool + member DynamicReq: TyparDynamicReq + member EqualityConditionalOn: bool + member IsCompatFlex: bool + member IsCompilerGenerated: bool + member IsFromError: bool + member Kind: TyparKind + member PickledBits: int32 + member Rigidity: TyparRigidity + member StaticReq: SyntaxTree.TyparStaticReq + + [] + and EntityFlags = + + new: usesPrefixDisplay:bool * isModuleOrNamespace:bool * + preEstablishedHasDefaultCtor:bool * hasSelfReferentialCtor:bool * + isStructRecordOrUnionType:bool -> EntityFlags + new: flags:int64 -> EntityFlags + member WithIsAssumedReadOnly: flag:bool -> EntityFlags + member WithIsByRefLike: flag:bool -> EntityFlags + member WithIsReadOnly: flag:bool -> EntityFlags + member HasSelfReferentialConstructor: bool + member IsModuleOrNamespace: bool + member IsPrefixDisplay: bool + member IsStructRecordOrUnionType: bool + member PickledBits: int64 + member PreEstablishedHasDefaultConstructor: bool + member TryIsAssumedReadOnly: bool voption + member TryIsByRefLike: bool voption + member TryIsReadOnly: bool voption + static member ReservedBitForPickleFormatTyconReprFlag: int64 + + and UndefinedName = + with + inherit exn + interface System.Collections.IStructuralEquatable + val Data0: int + val Data1: string -> string + val Data2: SyntaxTree.Ident + val Data3: ErrorLogger.Suggestions + + and InternalUndefinedItemRef = + with + inherit exn + interface System.Collections.IStructuralEquatable + val Data0: string * string * string -> int * string + val Data1: string + val Data2: string + val Data3: string + + and ModuleOrNamespaceKind = + | FSharpModuleWithSuffix + | ModuleOrType + | Namespace + and PublicPath = + | PubPath of string [] + with + member EnclosingPath: string [] + + and CompilationPath = + | CompPath of + AbstractIL.IL.ILScopeRef * (string * ModuleOrNamespaceKind) list + with + static member + DemangleEntityName: nm:string -> k:ModuleOrNamespaceKind -> string + member + NestedCompPath: n:string -> + modKind:ModuleOrNamespaceKind -> CompilationPath + member NestedPublicPath: id:SyntaxTree.Ident -> PublicPath + member AccessPath: (string * ModuleOrNamespaceKind) list + member DemangledPath: string list + member ILScopeRef: AbstractIL.IL.ILScopeRef + member MangledPath: string list + member ParentCompPath: CompilationPath + + [] + and EntityOptionalData = + { mutable entity_compiled_name: string option + mutable entity_other_range: (Range.range * bool) option + mutable entity_kind: TyparKind + mutable entity_xmldoc: XmlDoc.XmlDoc + mutable entity_xmldocsig: string + mutable entity_tycon_abbrev: TType option + mutable entity_tycon_repr_accessibility: Accessibility + mutable entity_accessibility: Accessibility + mutable entity_exn_info: ExceptionInfo } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and Entity = + { mutable entity_typars: + AbstractIL.Internal.Library.LazyWithContext + mutable entity_flags: EntityFlags + mutable entity_stamp: Stamp + mutable entity_logical_name: string + mutable entity_range: Range.range + mutable entity_attribs: Attribs + mutable entity_tycon_repr: TyconRepresentation + mutable entity_tycon_tcaug: TyconAugmentation + mutable entity_modul_contents: Lib.MaybeLazy + mutable entity_pubpath: PublicPath option + mutable entity_cpath: CompilationPath option + mutable entity_il_repr_cache: Lib.cache + mutable entity_opt_data: EntityOptionalData option } + with + static member New: _reason:'b -> data:Entity -> Entity + static member NewEmptyEntityOptData: unit -> EntityOptionalData + static member NewUnlinked: unit -> Entity + member + GetDisplayName: ?withStaticParameters:bool * ?withTypars:bool * + ?withUnderscoreTypars:bool -> string + member GetFieldByIndex: n:int -> RecdField + member GetFieldByName: n:string -> RecdField option + member GetUnionCaseByName: n:string -> UnionCase option + member Link: tg:EntityData -> unit + member SetAttribs: attribs:Attribs -> unit + member SetCompiledName: name:string option -> unit + member SetExceptionInfo: exn_info:ExceptionInfo -> unit + member SetIsAssumedReadOnly: b:bool -> unit + member SetIsByRefLike: b:bool -> unit + member SetIsReadOnly: b:bool -> unit + member SetIsStructRecordOrUnion: b:bool -> unit + member SetOtherRange: m:(Range.range * bool) -> unit + member SetTypeAbbrev: tycon_abbrev:TType option -> unit + member SetTypeOrMeasureKind: kind:TyparKind -> unit + override ToString: unit -> string + member Typars: m:Range.range -> Typars + member Accessibility: Accessibility + member AllFieldTable: TyconRecdFields + member AllFieldsArray: RecdField [] + member AllFieldsAsList: RecdField list + member AllGeneratedValues: ValRef list + member AllInstanceFieldsAsList: RecdField list + member Attribs: Attribs + member CompilationPath: CompilationPath + member CompilationPathOpt: CompilationPath option + member CompiledName: string + member CompiledReprCache: Lib.cache + member CompiledRepresentation: CompiledTypeRepr + member CompiledRepresentationForNamedType: AbstractIL.IL.ILTypeRef + [ (0))>] + member DebugText: string + member DefinitionRange: Range.range + member DemangledModuleOrNamespaceName: string + member DisplayName: string + member DisplayNameWithStaticParameters: string + member DisplayNameWithStaticParametersAndTypars: string + member DisplayNameWithStaticParametersAndUnderscoreTypars: string + member EntityCompiledName: string option + member ExceptionInfo: ExceptionInfo + member FSharpObjectModelTypeInfo: TyconObjModelData + member GeneratedCompareToValues: (ValRef * ValRef) option + member GeneratedCompareToWithComparerValues: ValRef option + member GeneratedHashAndEqualsValues: (ValRef * ValRef) option + member + GeneratedHashAndEqualsWithComparerValues: (ValRef * ValRef * ValRef) option + member HasSelfReferentialConstructor: bool + member ILTyconInfo: TILObjectReprData + member ILTyconRawMetadata: AbstractIL.IL.ILTypeDef + member Id: SyntaxTree.Ident + member ImmediateInterfaceTypesOfFSharpTycon: TType list + member + ImmediateInterfacesOfFSharpTycon: (TType * bool * Range.range) list + member IsAsmReprTycon: bool + member IsEnumTycon: bool + member IsErased: bool + member IsExceptionDecl: bool + member IsFSharpClassTycon: bool + member IsFSharpDelegateTycon: bool + member IsFSharpEnumTycon: bool + member IsFSharpInterfaceTycon: bool + member IsFSharpObjectModelTycon: bool + member IsFSharpStructOrEnumTycon: bool + member IsHiddenReprTycon: bool + member IsILEnumTycon: bool + member IsILStructOrEnumTycon: bool + member IsILTycon: bool + member IsLinked: bool + member IsMeasureableReprTycon: bool + member IsModule: bool + member IsModuleOrNamespace: bool + member IsNamespace: bool + member IsPrefixDisplay: bool + member IsProvided: bool + member IsProvidedErasedTycon: bool + member IsProvidedGeneratedTycon: bool + member IsProvidedNamespace: bool + member IsRecordTycon: bool + member IsStaticInstantiationTycon: bool + member IsStructOrEnumTycon: bool + member IsStructRecordOrUnionTycon: bool + member IsTypeAbbrev: bool + member IsUnionTycon: bool + member LogicalName: string + member + MembersOfFSharpTyconByName: AbstractIL.Internal.Library.NameMultiMap + member MembersOfFSharpTyconSorted: ValRef list + member ModuleOrNamespaceType: ModuleOrNamespaceType + member PreEstablishedHasDefaultConstructor: bool + member PublicPath: PublicPath option + member Range: Range.range + member SigRange: Range.range + member Stamp: Stamp + member TrueFieldsAsList: RecdField list + member TrueInstanceFieldsAsList: RecdField list + member TryIsAssumedReadOnly: bool voption + member TryIsByRefLike: bool voption + member TryIsReadOnly: bool voption + member TyparsNoRange: Typars + member TypeAbbrev: TType option + member TypeContents: TyconAugmentation + member TypeOrMeasureKind: TyparKind + member TypeReprAccessibility: Accessibility + member TypeReprInfo: TyconRepresentation + member UnionCasesArray: UnionCase [] + member UnionCasesAsList: UnionCase list + member UnionTypeInfo: TyconUnionData voption + member XmlDoc: XmlDoc.XmlDoc + member XmlDocSig: string + + and EntityData = Entity + and ParentRef = + | Parent of EntityRef + | ParentNone + [] + and CompiledTypeRepr = + | ILAsmNamed of + AbstractIL.IL.ILTypeRef * AbstractIL.IL.ILBoxity * + AbstractIL.IL.ILType option + | ILAsmOpen of AbstractIL.IL.ILType + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and TyconAugmentation = + { mutable tcaug_compare: (ValRef * ValRef) option + mutable tcaug_compare_withc: ValRef option + mutable tcaug_equals: (ValRef * ValRef) option + mutable tcaug_hash_and_equals_withc: (ValRef * ValRef * ValRef) option + mutable tcaug_hasObjectGetHashCode: bool + tcaug_adhoc_list: ResizeArray + mutable tcaug_adhoc: AbstractIL.Internal.Library.NameMultiMap + mutable tcaug_interfaces: (TType * bool * Range.range) list + mutable tcaug_super: TType option + mutable tcaug_closed: bool + mutable tcaug_abstract: bool } + with + static member Create: unit -> TyconAugmentation + member SetCompare: x:(ValRef * ValRef) -> unit + member SetCompareWith: x:ValRef -> unit + member SetEquals: x:(ValRef * ValRef) -> unit + member SetHasObjectGetHashCode: b:bool -> unit + member SetHashAndEqualsWith: x:(ValRef * ValRef * ValRef) -> unit + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and TyconRepresentation = + | TFSharpObjectRepr of TyconObjModelData + | TRecdRepr of TyconRecdFields + | TUnionRepr of TyconUnionData + | TILObjectRepr of TILObjectReprData + | TAsmRepr of AbstractIL.IL.ILType + | TMeasureableRepr of TType + | TProvidedTypeExtensionPoint of TProvidedTypeInfo + | TProvidedNamespaceExtensionPoint of + ExtensionTyping.ResolutionEnvironment * + Tainted list + | TNoRepr + with + override ToString: unit -> string + + [] + and TILObjectReprData = + | TILObjectReprData of + scope: AbstractIL.IL.ILScopeRef * nesting: AbstractIL.IL.ILTypeDef list * + definition: AbstractIL.IL.ILTypeDef + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and TProvidedTypeInfo = + { ResolutionEnvironment: ExtensionTyping.ResolutionEnvironment + ProvidedType: Tainted + LazyBaseType: + AbstractIL.Internal.Library.LazyWithContext + IsClass: bool + IsSealed: bool + IsAbstract: bool + IsInterface: bool + IsStructOrEnum: bool + IsEnum: bool + UnderlyingTypeOfEnum: unit -> TType + IsDelegate: unit -> bool + IsErased: bool + IsSuppressRelocate: bool } + with + member BaseTypeForErased: m:Range.range * objTy:TType -> TType + override ToString: unit -> string + [ (0))>] + member DebugText: string + member IsGenerated: bool + + and TyconObjModelKind = + | TTyconClass + | TTyconInterface + | TTyconStruct + | TTyconDelegate of SlotSig + | TTyconEnum + with + member IsValueType: bool + + [] + and TyconObjModelData = + { fsobjmodel_kind: TyconObjModelKind + fsobjmodel_vslots: ValRef list + fsobjmodel_rfields: TyconRecdFields } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and TyconRecdFields = + { FieldsByIndex: RecdField [] + FieldsByName: AbstractIL.Internal.Library.NameMap } + with + member FieldByIndex: n:int -> RecdField + member FieldByName: nm:string -> RecdField option + override ToString: unit -> string + member AllFieldsAsList: RecdField list + [ (0))>] + member DebugText: string + member TrueFieldsAsList: RecdField list + member TrueInstanceFieldsAsList: RecdField list + + [] + and TyconUnionCases = + { CasesByIndex: UnionCase [] + CasesByName: AbstractIL.Internal.Library.NameMap } + with + member GetUnionCaseByIndex: n:int -> UnionCase + override ToString: unit -> string + [ (0))>] + member DebugText: string + member UnionCasesAsList: UnionCase list + + [] + and TyconUnionData = + { CasesTable: TyconUnionCases + CompiledRepresentation: + Lib.cache } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + member UnionCasesAsList: UnionCase list + + [] + and UnionCase = + { FieldTable: TyconRecdFields + ReturnType: TType + XmlDoc: XmlDoc.XmlDoc + mutable XmlDocSig: string + Id: SyntaxTree.Ident + mutable OtherRangeOpt: (Range.range * bool) option + Accessibility: Accessibility + mutable Attribs: Attribs } + with + member GetFieldByIndex: n:int -> RecdField + member GetFieldByName: nm:string -> RecdField option + override ToString: unit -> string + member CompiledName: string + [ (0))>] + member DebugText: string + member DefinitionRange: Range.range + member DisplayName: string + member IsNullary: bool + member Range: Range.range + member RecdFields: RecdField list + member RecdFieldsArray: RecdField [] + member SigRange: Range.range + + [] + and RecdField = + { rfield_mutable: bool + rfield_xmldoc: XmlDoc.XmlDoc + mutable rfield_xmldocsig: string + rfield_type: TType + rfield_static: bool + rfield_volatile: bool + rfield_secret: bool + rfield_const: Const option + rfield_access: Accessibility + mutable rfield_pattribs: Attribs + mutable rfield_fattribs: Attribs + rfield_id: SyntaxTree.Ident + rfield_name_generated: bool + mutable rfield_other_range: (Range.range * bool) option } + with + override ToString: unit -> string + member Accessibility: Accessibility + [ (0))>] + member DebugText: string + member DefinitionRange: Range.range + member FieldAttribs: Attribs + member FormalType: TType + member Id: SyntaxTree.Ident + member IsCompilerGenerated: bool + member IsMutable: bool + member IsStatic: bool + member IsVolatile: bool + member IsZeroInit: bool + member LiteralValue: Const option + member Name: string + member PropertyAttribs: Attribs + member Range: Range.range + member SigRange: Range.range + member XmlDoc: XmlDoc.XmlDoc + member XmlDocSig: string + + [] + and ExceptionInfo = + | TExnAbbrevRepr of TyconRef + | TExnAsmRepr of AbstractIL.IL.ILTypeRef + | TExnFresh of TyconRecdFields + | TExnNone + with + override ToString: unit -> string + + [] + and ModuleOrNamespaceType = + + new: kind:ModuleOrNamespaceKind * + vals:Internal.Utilities.QueueList * + entities:Internal.Utilities.QueueList -> + ModuleOrNamespaceType + member AddEntity: tycon:Tycon -> ModuleOrNamespaceType + member AddModuleOrNamespaceByMutation: modul:ModuleOrNamespace -> unit + member AddProvidedTypeEntity: entity:Entity -> unit + member AddVal: vspec:Val -> ModuleOrNamespaceType + override ToString: unit -> string + member TryLinkVal: ccu:CcuThunk * key:ValLinkageFullKey -> Val voption + member + ActivePatternElemRefLookupTable: AbstractIL.Internal.Library.NameMap option ref + member AllEntities: Internal.Utilities.QueueList + member + AllEntitiesByCompiledAndLogicalMangledNames: AbstractIL.Internal.Library.NameMap + member + AllEntitiesByLogicalMangledName: AbstractIL.Internal.Library.NameMap + member AllValsAndMembers: Internal.Utilities.QueueList + member + AllValsAndMembersByLogicalNameUncached: AbstractIL.Internal.Library.MultiMap + member + AllValsAndMembersByPartialLinkageKey: AbstractIL.Internal.Library.MultiMap + member AllValsByLogicalName: AbstractIL.Internal.Library.NameMap + [ (0))>] + member DebugText: string + member ExceptionDefinitions: Entity list + member + ExceptionDefinitionsByDemangledName: AbstractIL.Internal.Library.NameMap + member ModuleAndNamespaceDefinitions: Entity list + member ModuleOrNamespaceKind: ModuleOrNamespaceKind + member + ModulesAndNamespacesByDemangledName: AbstractIL.Internal.Library.NameMap + member TypeAndExceptionDefinitions: Entity list + member TypeDefinitions: Entity list + member + TypesByAccessNames: AbstractIL.Internal.Library.LayeredMultiMap + member + TypesByDemangledNameAndArity: AbstractIL.Internal.Library.LayeredMap + member TypesByMangledName: AbstractIL.Internal.Library.NameMap + + and ModuleOrNamespace = Entity + and Tycon = Entity + [] + and Accessibility = + | TAccess of CompilationPath list + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and TyparOptionalData = + { mutable typar_il_name: string option + mutable typar_xmldoc: XmlDoc.XmlDoc + mutable typar_constraints: TyparConstraint list + mutable typar_attribs: Attribs } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + and TyparData = Typar + [] + and Typar = + { mutable typar_id: SyntaxTree.Ident + mutable typar_flags: TyparFlags + mutable typar_stamp: Stamp + mutable typar_solution: TType option + mutable typar_astype: TType + mutable typar_opt_data: TyparOptionalData option } + with + static member New: data:TyparData -> Typar + static member NewUnlinked: unit -> Typar + member Link: tg:TyparData -> unit + member SetAttribs: attribs:Attrib list -> unit + member SetComparisonDependsOn: b:bool -> unit + member SetCompilerGenerated: b:bool -> unit + member SetConstraints: cs:TyparConstraint list -> unit + member SetDynamicReq: b:TyparDynamicReq -> unit + member SetEqualityDependsOn: b:bool -> unit + member SetILName: il_name:string option -> unit + member SetIdent: id:SyntaxTree.Ident -> unit + member SetIsCompatFlex: b:bool -> unit + member SetRigidity: b:TyparRigidity -> unit + member SetStaticReq: b:SyntaxTree.TyparStaticReq -> unit + override ToString: unit -> string + member AsType: TType + member Attribs: Attribs + member ComparisonConditionalOn: bool + member Constraints: TyparConstraint list + [ (0))>] + member DebugText: string + member DisplayName: string + member DynamicReq: TyparDynamicReq + member EqualityConditionalOn: bool + member ILName: string option + member Id: SyntaxTree.Ident + member IsCompatFlex: bool + member IsCompilerGenerated: bool + member IsErased: bool + member IsFromError: bool + member IsLinked: bool + member IsSolved: bool + member Kind: TyparKind + member Name: string + member Range: Range.range + member Rigidity: TyparRigidity + member Solution: TType option + member Stamp: Stamp + member StaticReq: SyntaxTree.TyparStaticReq + member XmlDoc: XmlDoc.XmlDoc + + [] + and TyparConstraint = + | CoercesTo of TType * Range.range + | DefaultsTo of int * TType * Range.range + | SupportsNull of Range.range + | MayResolveMember of TraitConstraintInfo * Range.range + | IsNonNullableStruct of Range.range + | IsReferenceType of Range.range + | SimpleChoice of TTypes * Range.range + | RequiresDefaultConstructor of Range.range + | IsEnum of TType * Range.range + | SupportsComparison of Range.range + | SupportsEquality of Range.range + | IsDelegate of TType * TType * Range.range + | IsUnmanaged of Range.range + with + override ToString: unit -> string + + [] + and TraitWitnessInfo = + | TraitWitnessInfo of + TTypes * string * SyntaxTree.MemberFlags * TTypes * TType option + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + member MemberName: string + member ReturnType: TType option + + [] + and TraitConstraintInfo = + | TTrait of + tys: TTypes * memberName: string * _memFlags: SyntaxTree.MemberFlags * + argTys: TTypes * returnTy: TType option * + solution: TraitConstraintSln option ref + with + override ToString: unit -> string + member ArgumentTypes: TTypes + [ (0))>] + member DebugText: string + member MemberFlags: SyntaxTree.MemberFlags + member MemberName: string + member ReturnType: TType option + member Solution: TraitConstraintSln option + member TraitKey: TraitWitnessInfo + + [] + and TraitConstraintSln = + | FSMethSln of TType * ValRef * TypeInst + | FSRecdFieldSln of TypeInst * RecdFieldRef * bool + | FSAnonRecdFieldSln of AnonRecdTypeInfo * TypeInst * int + | ILMethSln of + TType * AbstractIL.IL.ILTypeRef option * AbstractIL.IL.ILMethodRef * + TypeInst + | ClosedExprSln of Expr + | BuiltInSln + with + override ToString: unit -> string + + [] + and ValLinkagePartialKey = + { MemberParentMangledName: string option + MemberIsOverride: bool + LogicalName: string + TotalArgCount: int } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and ValLinkageFullKey = + + new: partialKey:ValLinkagePartialKey * typeForLinkage:TType option -> + ValLinkageFullKey + override ToString: unit -> string + [ (0))>] + member DebugText: string + member PartialKey: ValLinkagePartialKey + member TypeForLinkage: TType option + + [] + and ValOptionalData = + { mutable val_compiled_name: string option + mutable val_other_range: (Range.range * bool) option + mutable val_const: Const option + mutable val_defn: Expr option + mutable val_repr_info: ValReprInfo option + mutable val_access: Accessibility + mutable val_xmldoc: XmlDoc.XmlDoc + mutable val_member_info: ValMemberInfo option + mutable val_declaring_entity: ParentRef + mutable val_xmldocsig: string + mutable val_attribs: Attribs } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + and ValData = Val + [] + and Val = + { mutable val_logical_name: string + mutable val_range: Range.range + mutable val_type: TType + mutable val_stamp: Stamp + mutable val_flags: ValFlags + mutable val_opt_data: ValOptionalData option } + with + static member New: data:Val -> Val + static member NewEmptyValOptData: unit -> ValOptionalData + static member NewUnlinked: unit -> Val + member + CompiledName: compilerGlobalState:CompilerGlobalState.CompilerGlobalState option -> + string + member GetLinkageFullKey: unit -> ValLinkageFullKey + member GetLinkagePartialKey: unit -> ValLinkagePartialKey + member Link: tg:ValData -> unit + member SetAttribs: attribs:Attribs -> unit + member SetData: tg:ValData -> unit + member SetDeclaringEntity: parent:ParentRef -> unit + member SetHasBeenReferenced: unit -> unit + member SetIgnoresByrefScope: unit -> unit + member SetIsCompiledAsStaticPropertyWithoutField: unit -> unit + member SetIsFixed: unit -> unit + member SetIsMemberOrModuleBinding: unit -> unit + member SetMakesNoCriticalTailcalls: unit -> unit + member SetMemberInfo: member_info:ValMemberInfo -> unit + member SetOtherRange: m:(Range.range * bool) -> unit + member SetType: ty:TType -> unit + member SetValDefn: val_defn:Expr -> unit + member SetValRec: b:ValRecursiveScopeInfo -> unit + member SetValReprInfo: info:ValReprInfo option -> unit + override ToString: unit -> string + member Accessibility: Accessibility + member ApparentEnclosingEntity: ParentRef + member Attribs: Attrib list + member BaseOrThisInfo: ValBaseOrThisInfo + member CoreDisplayName: string + [ (0))>] + member DebugText: string + member DeclaringEntity: ParentRef + member DefinitionRange: Range.range + member DisplayName: string + member HasBeenReferenced: bool + member HasDeclaringEntity: bool + member Id: SyntaxTree.Ident + member IgnoresByrefScope: bool + member InlineInfo: ValInline + member IsClassConstructor: bool + member IsCompiledAsStaticPropertyWithoutField: bool + member IsCompiledAsTopLevel: bool + member IsCompiledIntoModule: bool + member IsCompilerGenerated: bool + member IsConstructor: bool + member IsDispatchSlot: bool + member IsExtensionMember: bool + member IsFixed: bool + member IsIncrClassConstructor: bool + member IsIncrClassGeneratedMember: bool + member IsInstanceMember: bool + member IsIntrinsicMember: bool + member IsLinked: bool + member IsMember: bool + member IsMemberOrModuleBinding: bool + member IsModuleBinding: bool + member IsMutable: bool + member IsOverrideOrExplicitImpl: bool + member IsTypeFunction: bool + member LiteralValue: Const option + member LogicalName: string + member MakesNoCriticalTailcalls: bool + member MemberApparentEntity: TyconRef + member MemberInfo: ValMemberInfo option + member MustInline: bool + member NumObjArgs: int + member PermitsExplicitTypeInstantiation: bool + member PropertyName: string + member PublicPath: ValPublicPath option + member Range: Range.range + member RecursiveValInfo: ValRecursiveScopeInfo + member ReflectedDefinition: Expr option + member SigRange: Range.range + member Stamp: Stamp + member TauType: TType + member TopValDeclaringEntity: EntityRef + member Typars: Typars + member Type: TType + member TypeScheme: Typars * TType + member ValCompiledName: string option + member ValReprInfo: ValReprInfo option + member XmlDoc: XmlDoc.XmlDoc + member XmlDocSig: string + + [] + and ValMemberInfo = + { ApparentEnclosingEntity: TyconRef + mutable ImplementedSlotSigs: SlotSig list + mutable IsImplemented: bool + MemberFlags: SyntaxTree.MemberFlags } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and NonLocalValOrMemberRef = + { EnclosingEntity: EntityRef + ItemKey: ValLinkageFullKey } + with + override ToString: unit -> string + member AssemblyName: string + member Ccu: CcuThunk + [ (0))>] + member DebugText: string + + [] + and ValPublicPath = + | ValPubPath of PublicPath * ValLinkageFullKey + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and NonLocalEntityRef = + | NonLocalEntityRef of CcuThunk * string [] + with + static member + TryDerefEntityPath: ccu:CcuThunk * path:string [] * i:int * + entity:Entity -> Entity voption + static member + TryDerefEntityPathViaProvidedType: ccu:CcuThunk * path:string [] * + i:int * entity:Entity -> + Entity voption + override ToString: unit -> string + member TryDeref: canError:bool -> Entity voption + member AssemblyName: string + member Ccu: CcuThunk + [ (0))>] + member DebugText: string + member Deref: Entity + member DisplayName: string + member EnclosingMangledPath: string [] + member LastItemMangledName: string + member ModuleOrNamespaceType: ModuleOrNamespaceType + member Path: string [] + + [] + and EntityRef = + { mutable binding: Lib.NonNullSlot + nlr: NonLocalEntityRef } + with + member GetFieldByIndex: n:int -> RecdField + member GetFieldByName: n:string -> RecdField option + member GetUnionCaseByName: n:string -> UnionCase option + member MakeNestedRecdFieldRef: rf:RecdField -> RecdFieldRef + member MakeNestedUnionCaseRef: uc:UnionCase -> UnionCaseRef + member private Resolve: canError:bool -> unit + member SetIsAssumedReadOnly: b:bool -> unit + member SetIsByRefLike: b:bool -> unit + member SetIsReadOnly: b:bool -> unit + override ToString: unit -> string + member Typars: m:Range.range -> Typars + member Accessibility: Accessibility + member AllFieldAsRefList: RecdFieldRef list + member AllFieldTable: TyconRecdFields + member AllFieldsArray: RecdField [] + member AllFieldsAsList: RecdField list + member AllInstanceFieldsAsList: RecdField list + member Attribs: Attribs + member CanDeref: bool + member CompilationPath: CompilationPath + member CompilationPathOpt: CompilationPath option + member CompiledName: string + member CompiledReprCache: Lib.cache + member CompiledRepresentation: CompiledTypeRepr + member CompiledRepresentationForNamedType: AbstractIL.IL.ILTypeRef + [ (0))>] + member DebugText: string + member DefinitionRange: Range.range + member DemangledModuleOrNamespaceName: string + member Deref: Entity + member DisplayName: string + member DisplayNameWithStaticParameters: string + member DisplayNameWithStaticParametersAndTypars: string + member DisplayNameWithStaticParametersAndUnderscoreTypars: string + member ExceptionInfo: ExceptionInfo + member FSharpObjectModelTypeInfo: TyconObjModelData + member GeneratedCompareToValues: (ValRef * ValRef) option + member GeneratedCompareToWithComparerValues: ValRef option + member GeneratedHashAndEqualsValues: (ValRef * ValRef) option + member + GeneratedHashAndEqualsWithComparerValues: (ValRef * ValRef * ValRef) option + member HasSelfReferentialConstructor: bool + member ILTyconInfo: TILObjectReprData + member ILTyconRawMetadata: AbstractIL.IL.ILTypeDef + member Id: SyntaxTree.Ident + member ImmediateInterfaceTypesOfFSharpTycon: TType list + member + ImmediateInterfacesOfFSharpTycon: (TType * bool * Range.range) list + member IsAsmReprTycon: bool + member IsEnumTycon: bool + member IsErased: bool + member IsExceptionDecl: bool + member IsFSharpDelegateTycon: bool + member IsFSharpEnumTycon: bool + member IsFSharpInterfaceTycon: bool + member IsFSharpObjectModelTycon: bool + member IsFSharpStructOrEnumTycon: bool + member IsHiddenReprTycon: bool + member IsILEnumTycon: bool + member IsILStructOrEnumTycon: bool + member IsILTycon: bool + member IsLocalRef: bool + member IsMeasureableReprTycon: bool + member IsModule: bool + member IsModuleOrNamespace: bool + member IsNamespace: bool + member IsPrefixDisplay: bool + member IsProvided: bool + member IsProvidedErasedTycon: bool + member IsProvidedGeneratedTycon: bool + member IsProvidedNamespace: bool + member IsRecordTycon: bool + member IsResolved: bool + member IsStaticInstantiationTycon: bool + member IsStructOrEnumTycon: bool + member IsTypeAbbrev: bool + member IsUnionTycon: bool + member LogicalName: string + member + MembersOfFSharpTyconByName: AbstractIL.Internal.Library.NameMultiMap + member MembersOfFSharpTyconSorted: ValRef list + member ModuleOrNamespaceType: ModuleOrNamespaceType + member PreEstablishedHasDefaultConstructor: bool + member PublicPath: PublicPath option + member Range: Range.range + member ResolvedTarget: Lib.NonNullSlot + member SigRange: Range.range + member Stamp: Stamp + member TrueFieldsAsList: RecdField list + member TrueInstanceFieldsAsList: RecdField list + member TrueInstanceFieldsAsRefList: RecdFieldRef list + member TryDeref: Lib.NonNullSlot voption + member TryIsAssumedReadOnly: bool voption + member TryIsByRefLike: bool voption + member TryIsReadOnly: bool voption + member TyparsNoRange: Typars + member TypeAbbrev: TType option + member TypeContents: TyconAugmentation + member TypeOrMeasureKind: TyparKind + member TypeReprAccessibility: Accessibility + member TypeReprInfo: TyconRepresentation + member UnionCasesArray: UnionCase [] + member UnionCasesAsList: UnionCase list + member UnionCasesAsRefList: UnionCaseRef list + member UnionTypeInfo: TyconUnionData voption + member XmlDoc: XmlDoc.XmlDoc + member XmlDocSig: string + + and ModuleOrNamespaceRef = EntityRef + and TyconRef = EntityRef + [] + and ValRef = + { mutable binding: Lib.NonNullSlot + nlr: NonLocalValOrMemberRef } + with + override ToString: unit -> string + member Accessibility: Accessibility + member ApparentEnclosingEntity: ParentRef + member Attribs: Attrib list + member BaseOrThisInfo: ValBaseOrThisInfo + member + CompiledName: (CompilerGlobalState.CompilerGlobalState option -> + string) + member CoreDisplayName: string + [ (0))>] + member DebugText: string + member DeclaringEntity: ParentRef + member DefinitionRange: Range.range + member Deref: Val + member DisplayName: string + member HasDeclaringEntity: bool + member Id: SyntaxTree.Ident + member InlineInfo: ValInline + member IsCompiledAsTopLevel: bool + member IsCompilerGenerated: bool + member IsConstructor: bool + member IsDispatchSlot: bool + member IsExtensionMember: bool + member IsIncrClassConstructor: bool + member IsIncrClassGeneratedMember: bool + member IsInstanceMember: bool + member IsLocalRef: bool + member IsMember: bool + member IsMemberOrModuleBinding: bool + member IsModuleBinding: bool + member IsMutable: bool + member IsOverrideOrExplicitImpl: bool + member IsPropertyGetterMethod: bool + member IsPropertySetterMethod: bool + member IsResolved: bool + member IsTypeFunction: bool + member LiteralValue: Const option + member LogicalName: string + member MakesNoCriticalTailcalls: bool + member MemberApparentEntity: TyconRef + member MemberInfo: ValMemberInfo option + member MustInline: bool + member NumObjArgs: int + member PermitsExplicitTypeInstantiation: bool + member PropertyName: string + member PublicPath: ValPublicPath option + member Range: Range.range + member RecursiveValInfo: ValRecursiveScopeInfo + member ReflectedDefinition: Expr option + member ResolvedTarget: Lib.NonNullSlot + member SigRange: Range.range + member Stamp: Stamp + member TauType: TType + member TopValDeclaringEntity: EntityRef + member TryDeref: Val voption + member Typars: Typars + member Type: TType + member TypeScheme: Typars * TType + member ValReprInfo: ValReprInfo option + member XmlDoc: XmlDoc.XmlDoc + member XmlDocSig: string + + [] + and UnionCaseRef = + | UnionCaseRef of TyconRef * string + with + member FieldByIndex: n:int -> RecdField + override ToString: unit -> string + member AllFieldsAsList: RecdField list + member Attribs: Attribs + member CaseName: string + [ (0))>] + member DebugText: string + member DefinitionRange: Range.range + member Index: int + member Range: Range.range + member ReturnType: TType + member SigRange: Range.range + member TryUnionCase: UnionCase voption + member Tycon: Entity + member TyconRef: TyconRef + member UnionCase: UnionCase + + [] + and RecdFieldRef = + | RecdFieldRef of TyconRef * string + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + member DefinitionRange: Range.range + member FieldName: string + member Index: int + member PropertyAttribs: Attribs + member Range: Range.range + member RecdField: RecdField + member SigRange: Range.range + member TryRecdField: RecdField voption + member Tycon: Entity + member TyconRef: TyconRef + + [] + and TType = + | TType_forall of Typars * TType + | TType_app of TyconRef * TypeInst + | TType_anon of AnonRecdTypeInfo * TType list + | TType_tuple of TupInfo * TTypes + | TType_fun of TType * TType + | TType_ucase of UnionCaseRef * TypeInst + | TType_var of Typar + | TType_measure of Measure + with + member GetAssemblyName: unit -> string + override ToString: unit -> string + [ (0))>] + member DebugText: string + + and TypeInst = TType list + and TTypes = TType list + [] + and AnonRecdTypeInfo = + { mutable Assembly: CcuThunk + mutable TupInfo: TupInfo + mutable SortedIds: SyntaxTree.Ident [] + mutable Stamp: Stamp + mutable SortedNames: string [] } + with + static member + Create: ccu:CcuThunk * tupInfo:TupInfo * ids:SyntaxTree.Ident [] -> + AnonRecdTypeInfo + static member NewUnlinked: unit -> AnonRecdTypeInfo + member Link: d:AnonRecdTypeInfo -> unit + member ILTypeRef: AbstractIL.IL.ILTypeRef + member IsLinked: bool + + [] + and TupInfo = | Const of bool + [] + and Measure = + | Var of Typar + | Con of TyconRef + | Prod of Measure * Measure + | Inv of Measure + | One + | RationalPower of Measure * Rational.Rational + with + override ToString: unit -> string + + and Attribs = Attrib list + [] + and AttribKind = + | ILAttrib of AbstractIL.IL.ILMethodRef + | FSAttrib of ValRef + with + override ToString: unit -> string + + [] + and Attrib = + | Attrib of + TyconRef * AttribKind * AttribExpr list * AttribNamedArg list * bool * + System.AttributeTargets option * Range.range + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + member Range: Range.range + member TyconRef: TyconRef + + [] + and AttribExpr = + | AttribExpr of Expr * Expr + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and AttribNamedArg = + | AttribNamedArg of (string * TType * bool * AttribExpr) + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and Const = + | Bool of bool + | SByte of sbyte + | Byte of byte + | Int16 of int16 + | UInt16 of uint16 + | Int32 of int32 + | UInt32 of uint32 + | Int64 of int64 + | UInt64 of uint64 + | IntPtr of int64 + | UIntPtr of uint64 + | Single of single + | Double of double + | Char of char + | String of string + | Decimal of System.Decimal + | Unit + | Zero + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and DecisionTree = + | TDSwitch of + Expr * DecisionTreeCase list * DecisionTree option * Range.range + | TDSuccess of Exprs * int + | TDBind of Binding * DecisionTree + with + override ToString: unit -> string + + [] + and DecisionTreeCase = + | TCase of DecisionTreeTest * DecisionTree + with + override ToString: unit -> string + member CaseTree: DecisionTree + [ (0))>] + member DebugText: string + member Discriminator: DecisionTreeTest + + [] + and DecisionTreeTest = + | UnionCase of UnionCaseRef * TypeInst + | ArrayLength of int * TType + | Const of Const + | IsNull + | IsInst of TType * TType + | ActivePatternCase of + Expr * TTypes * (ValRef * TypeInst) option * int * + PrettyNaming.ActivePatternInfo + | Error of Range.range + with + override ToString: unit -> string + + [] + and DecisionTreeTarget = + | TTarget of Val list * Expr * SyntaxTree.DebugPointForTarget + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + and Bindings = Binding list + [] + and Binding = + | TBind of Val * Expr * SyntaxTree.DebugPointForBinding + with + override ToString: unit -> string + member DebugPoint: SyntaxTree.DebugPointForBinding + [ (0))>] + member DebugText: string + member Expr: Expr + member Var: Val + + [] + and ActivePatternElemRef = + | APElemRef of PrettyNaming.ActivePatternInfo * ValRef * int + with + override ToString: unit -> string + member ActivePatternInfo: PrettyNaming.ActivePatternInfo + member ActivePatternVal: ValRef + member CaseIndex: int + [ (0))>] + member DebugText: string + + [] + and ValReprInfo = + | ValReprInfo of TyparReprInfo list * ArgReprInfo list list * ArgReprInfo + with + override ToString: unit -> string + member ArgInfos: ArgReprInfo list list + member ArgNames: string list option + member AritiesOfArgs: int list + [ (0))>] + member DebugText: string + member HasNoArgs: bool + member KindsOfTypars: TyparKind list + member NumCurriedArgs: int + member NumTypars: int + member TotalArgCount: int + + [] + and ArgReprInfo = + { mutable Attribs: Attribs + mutable Name: SyntaxTree.Ident option } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + and TyparReprInfo = | TyparReprInfo of SyntaxTree.Ident * TyparKind + and Typars = Typar list + and Exprs = Expr list + and Vals = Val list + [] + and Expr = + | Const of value: Const * range: Range.range * constType: TType + | Val of valRef: ValRef * flags: ValUseFlag * range: Range.range + | Sequential of + expr1: Expr * expr2: Expr * kind: SequentialOpKind * + debugPoint: SyntaxTree.DebugPointAtSequential * range: Range.range + | Lambda of + unique: CompilerGlobalState.Unique * ctorThisValOpt: Val option * + baseValOpt: Val option * valParams: Val list * bodyExpr: Expr * + range: Range.range * overallType: TType + | TyLambda of + unique: CompilerGlobalState.Unique * typeParams: Typars * bodyExpr: Expr * + range: Range.range * overallType: TType + | App of + funcExpr: Expr * formalType: TType * typeArgs: TypeInst * args: Exprs * + range: Range.range + | LetRec of + bindings: Bindings * bodyExpr: Expr * range: Range.range * + frees: FreeVarsCache + | Let of + binding: Binding * bodyExpr: Expr * range: Range.range * + frees: FreeVarsCache + | Obj of + unique: CompilerGlobalState.Unique * objTy: TType * baseVal: Val option * + ctorCall: Expr * overrides: ObjExprMethod list * + interfaceImpls: (TType * ObjExprMethod list) list * range: Range.range + | Match of + debugPoint: SyntaxTree.DebugPointForBinding * inputRange: Range.range * + decision: DecisionTree * targets: DecisionTreeTarget array * + fullRange: Range.range * exprType: TType + | StaticOptimization of + conditions: StaticOptimization list * expr: Expr * alternativeExpr: Expr * + range: Range.range + | Op of op: TOp * typeArgs: TypeInst * args: Exprs * range: Range.range + | Quote of + quotedExpr: Expr * + quotationInfo: + ((AbstractIL.IL.ILTypeRef list * TTypes * Exprs * + QuotationPickler.ExprData) * + (AbstractIL.IL.ILTypeRef list * TTypes * Exprs * + QuotationPickler.ExprData)) option ref * isFromQueryExpression: bool * + range: Range.range * quotedType: TType + | WitnessArg of traitInfo: TraitConstraintInfo * range: Range.range + | TyChoose of typeParams: Typars * bodyExpr: Expr * range: Range.range + | Link of Expr ref + with + member ToDebugString: depth:int -> string + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and TOp = + | UnionCase of UnionCaseRef + | ExnConstr of TyconRef + | Tuple of TupInfo + | AnonRecd of AnonRecdTypeInfo + | AnonRecdGet of AnonRecdTypeInfo * int + | Array + | Bytes of byte [] + | UInt16s of uint16 [] + | While of SyntaxTree.DebugPointAtWhile * SpecialWhileLoopMarker + | For of SyntaxTree.DebugPointAtFor * ForLoopStyle + | TryWith of SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith + | TryFinally of + SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally + | Recd of RecordConstructionInfo * TyconRef + | ValFieldSet of RecdFieldRef + | ValFieldGet of RecdFieldRef + | ValFieldGetAddr of RecdFieldRef * readonly: bool + | UnionCaseTagGet of TyconRef + | UnionCaseProof of UnionCaseRef + | UnionCaseFieldGet of UnionCaseRef * int + | UnionCaseFieldGetAddr of UnionCaseRef * int * readonly: bool + | UnionCaseFieldSet of UnionCaseRef * int + | ExnFieldGet of TyconRef * int + | ExnFieldSet of TyconRef * int + | TupleFieldGet of TupInfo * int + | ILAsm of instrs: AbstractIL.IL.ILInstr list * retTypes: TTypes + | RefAddrGet of bool + | Coerce + | Reraise + | Return + | Goto of AbstractIL.IL.ILCodeLabel + | Label of AbstractIL.IL.ILCodeLabel + | TraitCall of TraitConstraintInfo + | LValueOp of LValueOperation * ValRef + | ILCall of + isVirtual: bool * isProtected: bool * isStruct: bool * isCtor: bool * + valUseFlag: ValUseFlag * isProperty: bool * noTailCall: bool * + ilMethRef: AbstractIL.IL.ILMethodRef * enclTypeInst: TypeInst * + methInst: TypeInst * retTypes: TTypes + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + and RecordConstructionInfo = + | RecdExprIsObjInit + | RecdExpr + and ConstrainedCallInfo = TType option + and SpecialWhileLoopMarker = + | NoSpecialWhileLoopMarker + | WhileLoopForCompiledForEachExprMarker + and ForLoopStyle = + | FSharpForLoopUp + | FSharpForLoopDown + | CSharpForLoopUp + and LValueOperation = + | LAddrOf of readonly: bool + | LByrefGet + | LSet + | LByrefSet + and SequentialOpKind = + | NormalSeq + | ThenDoSeq + and ValUseFlag = + | PossibleConstrainedCall of TType + | NormalValUse + | CtorValUsedAsSuperInit + | CtorValUsedAsSelfInit + | VSlotDirectCall + and StaticOptimization = + | TTyconEqualsTycon of TType * TType + | TTyconIsStruct of TType + [] + and ObjExprMethod = + | TObjExprMethod of + SlotSig * Attribs * Typars * Val list list * Expr * Range.range + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + member Id: SyntaxTree.Ident + + [] + and SlotSig = + | TSlotSig of + methodName: string * implementedType: TType * classTypars: Typars * + methodTypars: Typars * formalParams: SlotParam list list * + formalReturn: TType option + with + override ToString: unit -> string + member ClassTypars: Typars + [ (0))>] + member DebugText: string + member FormalParams: SlotParam list list + member FormalReturnType: TType option + member ImplementedType: TType + member MethodTypars: Typars + member Name: string + + [] + and SlotParam = + | TSlotParam of + paramName: string option * paramType: TType * isIn: bool * isOut: bool * + isOptional: bool * attributes: Attribs + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + member Type: TType + + [] + and ModuleOrNamespaceExprWithSig = + | ModuleOrNamespaceExprWithSig of + moduleType: ModuleOrNamespaceType * contents: ModuleOrNamespaceExpr * + range: Range.range + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + member Type: ModuleOrNamespaceType + + [] + and ModuleOrNamespaceExpr = + | TMAbstract of ModuleOrNamespaceExprWithSig + | TMDefs of ModuleOrNamespaceExpr list + | TMDefLet of Binding * Range.range + | TMDefDo of Expr * Range.range + | TMDefRec of + isRec: bool * Tycon list * ModuleOrNamespaceBinding list * Range.range + with + override ToString: unit -> string + member DebugText: string + + [] + and ModuleOrNamespaceBinding = + | Binding of Binding + | Module of ModuleOrNamespace * ModuleOrNamespaceExpr + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and TypedImplFile = + | TImplFile of + SyntaxTree.QualifiedNameOfFile * SyntaxTree.ScopedPragma list * + ModuleOrNamespaceExprWithSig * bool * bool * StampMap + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and TypedImplFileAfterOptimization = + { ImplFile: TypedImplFile + OptimizeDuringCodeGen: bool -> Expr -> Expr } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and TypedAssemblyAfterOptimization = + | TypedAssemblyAfterOptimization of TypedImplFileAfterOptimization list + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and CcuData = + { FileName: string option + ILScopeRef: AbstractIL.IL.ILScopeRef + Stamp: Stamp + QualifiedName: string option + SourceCodeDirectory: string + IsFSharp: bool + IsProviderGenerated: bool + InvalidateEvent: IEvent + ImportProvidedType: Tainted -> TType + mutable UsesFSharp20PlusQuotations: bool + mutable Contents: ModuleOrNamespace + TryGetILModuleDef: unit -> AbstractIL.IL.ILModuleDef option + MemberSignatureEquality: TType -> TType -> bool + TypeForwarders: CcuTypeForwarderTable } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + and CcuTypeForwarderTable = Map<(string [] * string),System.Lazy> + and CcuReference = string + [] + and CcuThunk = + { mutable target: CcuData + name: CcuReference } + with + static member Create: nm:CcuReference * x:CcuData -> CcuThunk + static member CreateDelayed: nm:CcuReference -> CcuThunk + member EnsureDerefable: requiringPath:string [] -> unit + member Fixup: avail:CcuThunk -> unit + member + ImportProvidedType: ty:Tainted -> TType + member MemberSignatureEquality: ty1:TType * ty2:TType -> bool + override ToString: unit -> string + member TryForward: nlpath:string [] * item:string -> EntityRef option + member TryGetILModuleDef: unit -> AbstractIL.IL.ILModuleDef option + member AssemblyName: string + member Contents: Entity + [ (0))>] + member DebugText: string + member Deref: CcuData + member FileName: string option + member ILScopeRef: AbstractIL.IL.ILScopeRef + member IsFSharp: bool + member IsProviderGenerated: bool + member IsUnresolvedReference: bool + member QualifiedName: string option + member RootModulesAndNamespaces: Entity list + member RootTypeAndExceptionDefinitions: Entity list + member SourceCodeDirectory: string + member Stamp: Stamp + member TypeForwarders: Map<(string [] * string),System.Lazy> + member UsesFSharp20PlusQuotations: bool + + [] + and CcuResolutionResult = + | ResolvedCcu of CcuThunk + | UnresolvedCcu of string + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + [] + and PickledCcuInfo = + { mspec: ModuleOrNamespace + compileTimeWorkingDir: string + usesQuotations: bool } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + and FreeLocals = AbstractIL.Internal.Zset + and FreeTypars = AbstractIL.Internal.Zset + and FreeTycons = AbstractIL.Internal.Zset + and FreeRecdFields = AbstractIL.Internal.Zset + and FreeUnionCases = AbstractIL.Internal.Zset + [] + and FreeTyvars = + { FreeTycons: FreeTycons + FreeTraitSolutions: FreeLocals + FreeTypars: FreeTypars } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + and FreeVarsCache = Lib.cache + [] + and FreeVars = + { FreeLocals: FreeLocals + UsesMethodLocalConstructs: bool + UsesUnboundRethrow: bool + FreeLocalTyconReprs: FreeTycons + FreeRecdFields: FreeRecdFields + FreeUnionCases: FreeUnionCases + FreeTyvars: FreeTyvars } + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + + and Construct = + + new: unit -> Construct + static member + ComputeDefinitionLocationOfProvidedItem: p:Tainted<#ExtensionTyping.IProvidedCustomAttributeProvider> -> + Range.range option + static member + KeyTyconByAccessNames: nm:string -> + x:'T -> + System.Collections.Generic.KeyValuePair [] + static member + KeyTyconByDecodedName: nm:string -> + x:'T -> + System.Collections.Generic.KeyValuePair + static member + MakeRecdFieldsTable: ucs:RecdField list -> TyconRecdFields + static member MakeUnionCases: ucs:UnionCase list -> TyconUnionData + static member MakeUnionRepr: ucs:UnionCase list -> TyconRepresentation + static member + NewCcuContents: sref:AbstractIL.IL.ILScopeRef -> + m:Range.range -> + nm:string -> + mty:ModuleOrNamespaceType -> ModuleOrNamespace + static member NewClonedModuleOrNamespace: orig:Tycon -> Entity + static member NewClonedTycon: orig:Tycon -> Entity + static member + NewEmptyModuleOrNamespaceType: mkind:ModuleOrNamespaceKind -> + ModuleOrNamespaceType + static member + NewExn: cpath:CompilationPath option -> + id:SyntaxTree.Ident -> + access:Accessibility -> + repr:ExceptionInfo -> + attribs:Attribs -> doc:XmlDoc.XmlDoc -> Entity + static member NewFreeVarsCache: unit -> Lib.cache<'a> + static member + NewILTycon: nlpath:CompilationPath option -> + nm:string * m:Range.range -> + tps:AbstractIL.Internal.Library.LazyWithContext -> + scoref:AbstractIL.IL.ILScopeRef * + enc:AbstractIL.IL.ILTypeDef list * + tdef:AbstractIL.IL.ILTypeDef -> + mtyp:Lib.MaybeLazy -> + Entity + static member + NewModifiedModuleOrNamespace: f:(ModuleOrNamespaceType -> + ModuleOrNamespaceType) -> + orig:Tycon -> Entity + static member + NewModifiedTycon: f:(Tycon -> Entity) -> orig:Tycon -> Entity + static member NewModifiedVal: f:(Val -> Val) -> orig:Val -> Val + static member + NewModuleOrNamespace: cpath:CompilationPath option -> + access:Accessibility -> + id:SyntaxTree.Ident -> + xml:XmlDoc.XmlDoc -> + attribs:Attrib list -> + mtype:Lib.MaybeLazy -> + ModuleOrNamespace + static member + NewModuleOrNamespaceType: mkind:ModuleOrNamespaceKind -> + tycons:Entity list -> + vals:Val list -> ModuleOrNamespaceType + static member + NewProvidedTycon: resolutionEnvironment:ExtensionTyping.ResolutionEnvironment * + st:Tainted * + importProvidedType:(Tainted -> + TType) * + isSuppressRelocate:bool * m:Range.range * + ?access:Accessibility * ?cpath:CompilationPath -> + Entity + static member + NewProvidedTyconRepr: resolutionEnvironment:ExtensionTyping.ResolutionEnvironment * + st:Tainted * + importProvidedType:(Tainted -> + TType) * + isSuppressRelocate:bool * m:Range.range -> + TyconRepresentation + static member + NewRecdField: stat:bool -> + konst:Const option -> + id:SyntaxTree.Ident -> + nameGenerated:bool -> + ty:TType -> + isMutable:bool -> + isVolatile:bool -> + pattribs:Attribs -> + fattribs:Attribs -> + docOption:XmlDoc.XmlDoc -> + access:Accessibility -> + secret:bool -> RecdField + static member NewRigidTypar: nm:string -> m:Range.range -> Typar + static member + NewTycon: cpath:CompilationPath option * nm:string * m:Range.range * + access:Accessibility * reprAccess:Accessibility * + kind:TyparKind * + typars:AbstractIL.Internal.Library.LazyWithContext * + doc:XmlDoc.XmlDoc * usesPrefixDisplay:bool * + preEstablishedHasDefaultCtor:bool * + hasSelfReferentialCtor:bool * + mtyp:Lib.MaybeLazy -> Entity + static member + NewTypar: kind:TyparKind * rigid:TyparRigidity * SyntaxTree.SynTypar * + isFromError:bool * dynamicReq:TyparDynamicReq * + attribs:Attrib list * eqDep:bool * compDep:bool -> Typar + static member + NewUnionCase: id:SyntaxTree.Ident -> + tys:RecdField list -> + rty:TType -> + attribs:Attribs -> + docOption:XmlDoc.XmlDoc -> + access:Accessibility -> UnionCase + static member + NewVal: logicalName:string * m:Range.range * + compiledName:string option * ty:TType * + isMutable:ValMutability * isCompGen:bool * + arity:ValReprInfo option * access:Accessibility * + recValInfo:ValRecursiveScopeInfo * + specialRepr:ValMemberInfo option * + baseOrThis:ValBaseOrThisInfo * attribs:Attrib list * + inlineInfo:ValInline * doc:XmlDoc.XmlDoc * + isModuleOrMemberBinding:bool * isExtensionMember:bool * + isIncrClassSpecialMember:bool * isTyFunc:bool * + allowTypeInst:bool * isGeneratedEventVal:bool * + konst:Const option * actualParent:ParentRef -> Val + + + +namespace FSharp.Compiler + module internal TypedTreeBasics = + val getNameOfScopeRef: sref:AbstractIL.IL.ILScopeRef -> string + module ValReprInfo = + val unnamedTopArg1: TypedTree.ArgReprInfo + val unnamedTopArg: TypedTree.ArgReprInfo list + val unitArgData: TypedTree.ArgReprInfo list list + val unnamedRetVal: TypedTree.ArgReprInfo + val selfMetadata: TypedTree.ArgReprInfo list + val emptyValData: TypedTree.ValReprInfo + val InferTyparInfo: + tps:TypedTree.Typar list -> TypedTree.TyparReprInfo list + val InferArgReprInfo: v:TypedTree.Val -> TypedTree.ArgReprInfo + val InferArgReprInfos: + vs:TypedTree.Val list list -> TypedTree.ValReprInfo + val HasNoArgs: TypedTree.ValReprInfo -> bool + + val typeOfVal: v:TypedTree.Val -> TypedTree.TType + val typesOfVals: v:TypedTree.Val list -> TypedTree.TType list + val nameOfVal: v:TypedTree.Val -> string + val arityOfVal: v:TypedTree.Val -> TypedTree.ValReprInfo + val tupInfoRef: TypedTree.TupInfo + val tupInfoStruct: TypedTree.TupInfo + val mkTupInfo: b:bool -> TypedTree.TupInfo + val structnessDefault: bool + val mkRawRefTupleTy: tys:TypedTree.TTypes -> TypedTree.TType + val mkRawStructTupleTy: tys:TypedTree.TTypes -> TypedTree.TType + val mapTImplFile: + f:(TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig) -> + TypedTree.TypedImplFile -> TypedTree.TypedImplFile + val mapAccImplFile: + f:('a -> TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig * 'b) -> + z:'a -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile * 'b + val foldTImplFile: + f:('a -> TypedTree.ModuleOrNamespaceExprWithSig -> 'b) -> + z:'a -> TypedTree.TypedImplFile -> 'b + val typarEq: lv1:TypedTree.Typar -> lv2:TypedTree.Typar -> bool + val typarRefEq: tp1:TypedTree.Typar -> tp2:TypedTree.Typar -> bool + val valEq: lv1:TypedTree.Val -> lv2:TypedTree.Val -> bool + val ccuEq: mv1:TypedTree.CcuThunk -> mv2:TypedTree.CcuThunk -> bool + val ( |ValDeref| ): vr:TypedTree.ValRef -> TypedTree.Val + val mkRecdFieldRef: + tcref:TypedTree.TyconRef -> f:string -> TypedTree.RecdFieldRef + val mkUnionCaseRef: + tcref:TypedTree.TyconRef -> c:string -> TypedTree.UnionCaseRef + val ERefLocal: x:Lib.NonNullSlot -> TypedTree.EntityRef + val ERefNonLocal: x:TypedTree.NonLocalEntityRef -> TypedTree.EntityRef + val ERefNonLocalPreResolved: + x:Lib.NonNullSlot -> + xref:TypedTree.NonLocalEntityRef -> TypedTree.EntityRef + val ( |ERefLocal|ERefNonLocal| ): + x:TypedTree.EntityRef -> + Choice,TypedTree.NonLocalEntityRef> + val mkLocalTyconRef: + x:Lib.NonNullSlot -> TypedTree.EntityRef + val mkNonLocalEntityRef: + ccu:TypedTree.CcuThunk -> mp:string [] -> TypedTree.NonLocalEntityRef + val mkNestedNonLocalEntityRef: + nleref:TypedTree.NonLocalEntityRef -> + id:string -> TypedTree.NonLocalEntityRef + val mkNonLocalTyconRef: + nleref:TypedTree.NonLocalEntityRef -> id:string -> TypedTree.EntityRef + val mkNonLocalTyconRefPreResolved: + x:Lib.NonNullSlot -> + nleref:TypedTree.NonLocalEntityRef -> id:string -> TypedTree.EntityRef + type EntityRef with + member NestedTyconRef: x:TypedTree.Entity -> TypedTree.EntityRef + type EntityRef with + member + RecdFieldRefInNestedTycon: tycon:TypedTree.Entity -> + id:SyntaxTree.Ident -> + TypedTree.RecdFieldRef + val mkModuleUnionCaseRef: + modref:TypedTree.ModuleOrNamespaceRef -> + tycon:TypedTree.Entity -> + uc:TypedTree.UnionCase -> TypedTree.UnionCaseRef + val VRefLocal: x:Lib.NonNullSlot -> TypedTree.ValRef + val VRefNonLocal: x:TypedTree.NonLocalValOrMemberRef -> TypedTree.ValRef + val VRefNonLocalPreResolved: + x:Lib.NonNullSlot -> + xref:TypedTree.NonLocalValOrMemberRef -> TypedTree.ValRef + val ( |VRefLocal|VRefNonLocal| ): + x:TypedTree.ValRef -> + Choice,TypedTree.NonLocalValOrMemberRef> + val mkNonLocalValRef: + mp:TypedTree.NonLocalEntityRef -> + id:TypedTree.ValLinkageFullKey -> TypedTree.ValRef + val mkNonLocalValRefPreResolved: + x:Lib.NonNullSlot -> + mp:TypedTree.NonLocalEntityRef -> + id:TypedTree.ValLinkageFullKey -> TypedTree.ValRef + val ccuOfValRef: vref:TypedTree.ValRef -> TypedTree.CcuThunk option + val ccuOfTyconRef: eref:TypedTree.EntityRef -> TypedTree.CcuThunk option + val mkTyparTy: tp:TypedTree.Typar -> TypedTree.TType + val copyTypar: tp:TypedTree.Typar -> TypedTree.Typar + val copyTypars: tps:TypedTree.Typar list -> TypedTree.Typar list + val tryShortcutSolvedUnitPar: + canShortcut:bool -> r:TypedTree.Typar -> TypedTree.Measure + val stripUnitEqnsAux: + canShortcut:bool -> unt:TypedTree.Measure -> TypedTree.Measure + val stripTyparEqnsAux: + canShortcut:bool -> ty:TypedTree.TType -> TypedTree.TType + val stripTyparEqns: ty:TypedTree.TType -> TypedTree.TType + val stripUnitEqns: unt:TypedTree.Measure -> TypedTree.Measure + val mkLocalValRef: v:TypedTree.Val -> TypedTree.ValRef + val mkLocalModRef: v:TypedTree.ModuleOrNamespace -> TypedTree.EntityRef + val mkLocalEntityRef: v:TypedTree.Entity -> TypedTree.EntityRef + val mkNonLocalCcuRootEntityRef: + ccu:TypedTree.CcuThunk -> x:TypedTree.Entity -> TypedTree.EntityRef + val mkNestedValRef: + cref:TypedTree.EntityRef -> v:TypedTree.Val -> TypedTree.ValRef + val rescopePubPathToParent: + viewedCcu:TypedTree.CcuThunk -> + TypedTree.PublicPath -> TypedTree.NonLocalEntityRef + val rescopePubPath: + viewedCcu:TypedTree.CcuThunk -> + TypedTree.PublicPath -> TypedTree.NonLocalEntityRef + val valRefInThisAssembly: compilingFslib:bool -> x:TypedTree.ValRef -> bool + val tyconRefUsesLocalXmlDoc: + compilingFslib:bool -> x:TypedTree.TyconRef -> bool + val entityRefInThisAssembly: + compilingFslib:bool -> x:TypedTree.EntityRef -> bool + val arrayPathEq: y1:string [] -> y2:string [] -> bool + val nonLocalRefEq: + TypedTree.NonLocalEntityRef -> TypedTree.NonLocalEntityRef -> bool + val nonLocalRefDefinitelyNotEq: + TypedTree.NonLocalEntityRef -> TypedTree.NonLocalEntityRef -> bool + val pubPathEq: TypedTree.PublicPath -> TypedTree.PublicPath -> bool + val fslibRefEq: + nlr1:TypedTree.NonLocalEntityRef -> TypedTree.PublicPath -> bool + val fslibEntityRefEq: + fslibCcu:TypedTree.CcuThunk -> + eref1:TypedTree.EntityRef -> eref2:TypedTree.EntityRef -> bool + val fslibValRefEq: + fslibCcu:TypedTree.CcuThunk -> + vref1:TypedTree.ValRef -> vref2:TypedTree.ValRef -> bool + val primEntityRefEq: + compilingFslib:bool -> + fslibCcu:TypedTree.CcuThunk -> + x:TypedTree.EntityRef -> y:TypedTree.EntityRef -> bool + val primUnionCaseRefEq: + compilingFslib:bool -> + fslibCcu:TypedTree.CcuThunk -> + TypedTree.UnionCaseRef -> TypedTree.UnionCaseRef -> bool + val primValRefEq: + compilingFslib:bool -> + fslibCcu:TypedTree.CcuThunk -> + x:TypedTree.ValRef -> y:TypedTree.ValRef -> bool + val fullCompPathOfModuleOrNamespace: + m:TypedTree.ModuleOrNamespace -> TypedTree.CompilationPath + val inline canAccessCompPathFrom: + TypedTree.CompilationPath -> TypedTree.CompilationPath -> bool + val canAccessFromOneOf: + cpaths:TypedTree.CompilationPath list -> + cpathTest:TypedTree.CompilationPath -> bool + val canAccessFrom: + TypedTree.Accessibility -> cpath:TypedTree.CompilationPath -> bool + val canAccessFromEverywhere: TypedTree.Accessibility -> bool + val canAccessFromSomewhere: TypedTree.Accessibility -> bool + val isLessAccessible: + TypedTree.Accessibility -> TypedTree.Accessibility -> bool + val accessSubstPaths: + newPath:TypedTree.CompilationPath * oldPath:TypedTree.CompilationPath -> + TypedTree.Accessibility -> TypedTree.Accessibility + val compPathOfCcu: ccu:TypedTree.CcuThunk -> TypedTree.CompilationPath + val taccessPublic: TypedTree.Accessibility + val taccessPrivate: + accessPath:TypedTree.CompilationPath -> TypedTree.Accessibility + val compPathInternal: TypedTree.CompilationPath + val taccessInternal: TypedTree.Accessibility + val combineAccess: + TypedTree.Accessibility -> + TypedTree.Accessibility -> TypedTree.Accessibility + exception Duplicate of string * string * Range.range + exception NameClash of + string * string * string * Range.range * string * + string * Range.range + + +namespace FSharp.Compiler + module internal TcGlobals = + val DummyFileNameForRangesWithoutASpecificLocation: string + val private envRange: Range.range + [] + type IntrinsicValRef = + | IntrinsicValRef of + TypedTree.NonLocalEntityRef * string * bool * TypedTree.TType * + TypedTree.ValLinkageFullKey + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + member Name: string + + val ValRefForIntrinsic: IntrinsicValRef -> TypedTree.ValRef + module FSharpLib = + val CoreOperatorsCheckedName: string + val ControlName: string + val LinqName: string + val CollectionsName: string + val LanguagePrimitivesName: string + val CompilerServicesName: string + val LinqRuntimeHelpersName: string + val RuntimeHelpersName: string + val ExtraTopLevelOperatorsName: string + val NativeInteropName: string + val QuotationsName: string + val ControlPath: string list + val LinqPath: string list + val CollectionsPath: string list + val NativeInteropPath: string [] + val CompilerServicesPath: string [] + val LinqRuntimeHelpersPath: string [] + val RuntimeHelpersPath: string [] + val QuotationsPath: string [] + val RootPathArray: string [] + val CorePathArray: string [] + val LinqPathArray: string [] + val ControlPathArray: string [] + val CollectionsPathArray: string [] + + val private mkNonGenericTy: tcref:TypedTree.TyconRef -> TypedTree.TType + val mkNonLocalTyconRef2: + ccu:TypedTree.CcuThunk -> + path:string [] -> n:string -> TypedTree.EntityRef + val mk_MFCore_tcref: + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFQuotations_tcref: + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFLinq_tcref: + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFCollections_tcref: + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFCompilerServices_tcref: + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFRuntimeHelpers_tcref: + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFControl_tcref: + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + [] + type BuiltinAttribInfo = + | AttribInfo of AbstractIL.IL.ILTypeRef * TypedTree.TyconRef + with + override ToString: unit -> string + [ (0))>] + member DebugText: string + member TyconRef: TypedTree.TyconRef + member TypeRef: AbstractIL.IL.ILTypeRef + + [] + val tname_DebuggerNonUserCodeAttribute: string + = "System.Diagnostics.DebuggerNonUserCodeAttribute" + [] + val tname_DebuggableAttribute_DebuggingModes: string = "DebuggingModes" + [] + val tname_DebuggerHiddenAttribute: string + = "System.Diagnostics.DebuggerHiddenAttribute" + [] + val tname_DebuggerDisplayAttribute: string + = "System.Diagnostics.DebuggerDisplayAttribute" + [] + val tname_DebuggerTypeProxyAttribute: string + = "System.Diagnostics.DebuggerTypeProxyAttribute" + [] + val tname_DebuggerStepThroughAttribute: string + = "System.Diagnostics.DebuggerStepThroughAttribute" + [] + val tname_DebuggerBrowsableAttribute: string + = "System.Diagnostics.DebuggerBrowsableAttribute" + [] + val tname_DebuggerBrowsableState: string + = "System.Diagnostics.DebuggerBrowsableState" + [] + val tname_StringBuilder: string = "System.Text.StringBuilder" + [] + val tname_IComparable: string = "System.IComparable" + [] + val tname_Exception: string = "System.Exception" + [] + val tname_Missing: string = "System.Reflection.Missing" + [] + val tname_FormattableString: string = "System.FormattableString" + [] + val tname_SerializationInfo: string + = "System.Runtime.Serialization.SerializationInfo" + [] + val tname_StreamingContext: string + = "System.Runtime.Serialization.StreamingContext" + [] + val tname_SecurityPermissionAttribute: string + = "System.Security.Permissions.SecurityPermissionAttribute" + [] + val tname_Delegate: string = "System.Delegate" + [] + val tname_ValueType: string = "System.ValueType" + [] + val tname_Enum: string = "System.Enum" + [] + val tname_Array: string = "System.Array" + [] + val tname_RuntimeArgumentHandle: string = "System.RuntimeArgumentHandle" + [] + val tname_RuntimeTypeHandle: string = "System.RuntimeTypeHandle" + [] + val tname_RuntimeMethodHandle: string = "System.RuntimeMethodHandle" + [] + val tname_RuntimeFieldHandle: string = "System.RuntimeFieldHandle" + [] + val tname_CompilerGeneratedAttribute: string + = "System.Runtime.CompilerServices.CompilerGeneratedAttribute" + [] + val tname_DebuggableAttribute: string + = "System.Diagnostics.DebuggableAttribute" + [] + val tname_AsyncCallback: string = "System.AsyncCallback" + [] + val tname_IAsyncResult: string = "System.IAsyncResult" + type TcGlobals = + + new: compilingFslib:bool * ilg:AbstractIL.IL.ILGlobals * + fslibCcu:TypedTree.CcuThunk * + directoryToResolveRelativePaths:string * mlCompatibility:bool * + isInteractive:bool * + tryFindSysTypeCcu:(string list -> string -> + TypedTree.CcuThunk option) * + emitDebugInfoInQuotations:bool * noDebugData:bool * + pathMap:Internal.Utilities.PathMap * + langVersion:Features.LanguageVersion -> TcGlobals + member + AddFieldGeneratedAttrs: mdef:AbstractIL.IL.ILFieldDef -> + AbstractIL.IL.ILFieldDef + member + AddFieldNeverAttrs: mdef:AbstractIL.IL.ILFieldDef -> + AbstractIL.IL.ILFieldDef + member + AddMethodGeneratedAttributes: mdef:AbstractIL.IL.ILMethodDef -> + AbstractIL.IL.ILMethodDef + member + EraseClassUnionDef: cud:AbstractIL.IL.ILTypeRef -> + (AbstractIL.IL.ILTypeDef -> + AbstractIL.Extensions.ILX.Types.IlxUnionInfo -> + AbstractIL.IL.ILTypeDef) + member FindSysAttrib: nm:string -> BuiltinAttribInfo + member FindSysILTypeRef: nm:string -> AbstractIL.IL.ILTypeRef + member + FindSysTyconRef: path:string list -> nm:string -> TypedTree.EntityRef + member + MakeBuiltInWitnessInfo: t:TypedTree.TraitConstraintInfo -> + IntrinsicValRef * TypedTree.TType list + override ToString: unit -> string + member TryFindSysAttrib: nm:string -> BuiltinAttribInfo option + member TryFindSysILTypeRef: nm:string -> AbstractIL.IL.ILTypeRef option + member + TryFindSysTyconRef: path:string list -> + nm:string -> TypedTree.EntityRef option + member + TryMakeOperatorAsBuiltInWitnessInfo: isStringTy:(TcGlobals -> + TypedTree.TType -> + bool) -> + isArrayTy:(TcGlobals -> + TypedTree.TType -> + bool) -> + t:TypedTree.TraitConstraintInfo -> + argExprs:'a list -> + (IntrinsicValRef * + TypedTree.TType list * + 'a list) option + member + decompileType: tcref:TypedTree.EntityRef -> + tinst:TypedTree.TypeInst -> TypedTree.TType + member + improveType: tcref:TypedTree.EntityRef -> + tinst:TypedTree.TType list -> TypedTree.TType + member memoize_file: x:int -> AbstractIL.IL.ILSourceDocument + member + mkDebuggableAttribute: jitOptimizerDisabled:bool -> + AbstractIL.IL.ILAttribute + member + mkDebuggableAttributeV2: jitTracking:bool * + ignoreSymbolStoreSequencePoints:bool * + jitOptimizerDisabled:bool * enableEnC:bool -> + AbstractIL.IL.ILAttribute + member + mkDebuggerDisplayAttribute: s:string -> AbstractIL.IL.ILAttribute + member mkDebuggerHiddenAttribute: unit -> AbstractIL.IL.ILAttribute + member + mkDebuggerStepThroughAttribute: unit -> AbstractIL.IL.ILAttribute + member + unionCaseRefEq: x:TypedTree.UnionCaseRef -> + y:TypedTree.UnionCaseRef -> bool + member valRefEq: x:TypedTree.ValRef -> y:TypedTree.ValRef -> bool + member CompilerGeneratedAttribute: AbstractIL.IL.ILAttribute + member + CompilerGlobalState: CompilerGlobalState.CompilerGlobalState option + member DebuggerBrowsableNeverAttribute: AbstractIL.IL.ILAttribute + member IComparer_ty: TypedTree.TType + member IEqualityComparer_ty: TypedTree.TType + member + System_Runtime_CompilerServices_RuntimeFeature_ty: TypedTree.TType option + member addrof2_vref: TypedTree.ValRef + member addrof_vref: TypedTree.ValRef + member and2_vref: TypedTree.ValRef + member and_vref: TypedTree.ValRef + member array2D_get_info: IntrinsicValRef + member array2D_get_vref: TypedTree.ValRef + member array2D_set_info: IntrinsicValRef + member array3D_get_info: IntrinsicValRef + member array3D_get_vref: TypedTree.ValRef + member array3D_set_info: IntrinsicValRef + member array4D_get_info: IntrinsicValRef + member array4D_get_vref: TypedTree.ValRef + member array4D_set_info: IntrinsicValRef + member array_get_info: IntrinsicValRef + member array_get_vref: TypedTree.ValRef + member array_length_info: IntrinsicValRef + member array_set_info: IntrinsicValRef + member array_tcr_nice: TypedTree.EntityRef + member attrib_AbstractClassAttribute: BuiltinAttribInfo + member attrib_AllowNullLiteralAttribute: BuiltinAttribInfo + member attrib_AttributeUsageAttribute: BuiltinAttribInfo + member attrib_AutoOpenAttribute: BuiltinAttribInfo + member attrib_AutoSerializableAttribute: BuiltinAttribInfo + member attrib_CLIEventAttribute: BuiltinAttribInfo + member attrib_CLIMutableAttribute: BuiltinAttribInfo + member attrib_CallerFilePathAttribute: BuiltinAttribInfo + member attrib_CallerLineNumberAttribute: BuiltinAttribInfo + member attrib_CallerMemberNameAttribute: BuiltinAttribInfo + member attrib_ClassAttribute: BuiltinAttribInfo + member attrib_ComImportAttribute: BuiltinAttribInfo option + member attrib_ComVisibleAttribute: BuiltinAttribInfo + member attrib_ComparisonConditionalOnAttribute: BuiltinAttribInfo + member attrib_CompilationArgumentCountsAttribute: BuiltinAttribInfo + member attrib_CompilationMappingAttribute: BuiltinAttribInfo + member attrib_CompilationRepresentationAttribute: BuiltinAttribInfo + member attrib_CompiledNameAttribute: BuiltinAttribInfo + member attrib_CompilerMessageAttribute: BuiltinAttribInfo + member attrib_ComponentModelEditorBrowsableAttribute: BuiltinAttribInfo + member attrib_ConditionalAttribute: BuiltinAttribInfo + member attrib_ContextStaticAttribute: BuiltinAttribInfo option + member attrib_CustomComparisonAttribute: BuiltinAttribInfo + member attrib_CustomEqualityAttribute: BuiltinAttribInfo + member attrib_CustomOperationAttribute: BuiltinAttribInfo + member attrib_DebuggerDisplayAttribute: BuiltinAttribInfo + member attrib_DebuggerTypeProxyAttribute: BuiltinAttribInfo + member attrib_DefaultAugmentationAttribute: BuiltinAttribInfo + member attrib_DefaultMemberAttribute: BuiltinAttribInfo + member attrib_DefaultParameterValueAttribute: BuiltinAttribInfo option + member attrib_DefaultValueAttribute: BuiltinAttribInfo + member attrib_DllImportAttribute: BuiltinAttribInfo option + member attrib_EntryPointAttribute: BuiltinAttribInfo + member attrib_EqualityConditionalOnAttribute: BuiltinAttribInfo + member attrib_ExperimentalAttribute: BuiltinAttribInfo + member attrib_ExtensionAttribute: BuiltinAttribInfo + member attrib_FieldOffsetAttribute: BuiltinAttribInfo + member attrib_FlagsAttribute: BuiltinAttribInfo + member attrib_GeneralizableValueAttribute: BuiltinAttribInfo + member attrib_IDispatchConstantAttribute: BuiltinAttribInfo option + member attrib_IUnknownConstantAttribute: BuiltinAttribInfo option + member attrib_InAttribute: BuiltinAttribInfo + member attrib_InterfaceAttribute: BuiltinAttribInfo + member attrib_InternalsVisibleToAttribute: BuiltinAttribInfo + member attrib_IsByRefLikeAttribute: BuiltinAttribInfo + member attrib_IsReadOnlyAttribute: BuiltinAttribInfo + member attrib_LiteralAttribute: BuiltinAttribInfo + member attrib_MarshalAsAttribute: BuiltinAttribInfo option + member attrib_MeasureAttribute: BuiltinAttribInfo + member attrib_MeasureableAttribute: BuiltinAttribInfo + member attrib_MethodImplAttribute: BuiltinAttribInfo + member attrib_NoComparisonAttribute: BuiltinAttribInfo + member attrib_NoDynamicInvocationAttribute: BuiltinAttribInfo + member attrib_NoEqualityAttribute: BuiltinAttribInfo + member attrib_NonSerializedAttribute: BuiltinAttribInfo option + member attrib_OptionalArgumentAttribute: BuiltinAttribInfo + member attrib_OptionalAttribute: BuiltinAttribInfo option + member attrib_OutAttribute: BuiltinAttribInfo + member attrib_ParamArrayAttribute: BuiltinAttribInfo + member attrib_PreserveSigAttribute: BuiltinAttribInfo option + member attrib_ProjectionParameterAttribute: BuiltinAttribInfo + member attrib_ReferenceEqualityAttribute: BuiltinAttribInfo + member attrib_ReflectedDefinitionAttribute: BuiltinAttribInfo + member attrib_RequireQualifiedAccessAttribute: BuiltinAttribInfo + member attrib_RequiresExplicitTypeArgumentsAttribute: BuiltinAttribInfo + member attrib_SealedAttribute: BuiltinAttribInfo + member attrib_SecurityAttribute: BuiltinAttribInfo option + member attrib_SecurityCriticalAttribute: BuiltinAttribInfo + member attrib_SecuritySafeCriticalAttribute: BuiltinAttribInfo + member attrib_SpecialNameAttribute: BuiltinAttribInfo option + member attrib_StructAttribute: BuiltinAttribInfo + member attrib_StructLayoutAttribute: BuiltinAttribInfo + member attrib_StructuralComparisonAttribute: BuiltinAttribInfo + member attrib_StructuralEqualityAttribute: BuiltinAttribInfo + member attrib_SystemObsolete: BuiltinAttribInfo + member attrib_ThreadStaticAttribute: BuiltinAttribInfo option + member attrib_TypeForwardedToAttribute: BuiltinAttribInfo + member attrib_UnverifiableAttribute: BuiltinAttribInfo + member attrib_VolatileFieldAttribute: BuiltinAttribInfo + member bitwise_and_info: IntrinsicValRef + member bitwise_and_vref: TypedTree.ValRef + member bitwise_or_info: IntrinsicValRef + member bitwise_or_vref: TypedTree.ValRef + member bitwise_shift_left_info: IntrinsicValRef + member bitwise_shift_left_vref: TypedTree.ValRef + member bitwise_shift_right_info: IntrinsicValRef + member bitwise_shift_right_vref: TypedTree.ValRef + member bitwise_unary_not_info: IntrinsicValRef + member bitwise_unary_not_vref: TypedTree.ValRef + member bitwise_xor_info: IntrinsicValRef + member bitwise_xor_vref: TypedTree.ValRef + member bool_tcr: TypedTree.EntityRef + member bool_ty: TypedTree.TType + member box_info: IntrinsicValRef + member byref2_tcr: TypedTree.EntityRef + member byref_tcr: TypedTree.EntityRef + member byrefkind_InOut_tcr: TypedTree.EntityRef + member byrefkind_In_tcr: TypedTree.EntityRef + member byrefkind_Out_tcr: TypedTree.EntityRef + member byte_checked_info: IntrinsicValRef + member byte_operator_info: IntrinsicValRef + member byte_tcr: TypedTree.EntityRef + member byte_ty: TypedTree.TType + member call_with_witnesses_info: IntrinsicValRef + member cast_quotation_info: IntrinsicValRef + member char_operator_info: IntrinsicValRef + member char_tcr: TypedTree.EntityRef + member char_ty: TypedTree.TType + member check_this_info: IntrinsicValRef + member checked_addition_info: IntrinsicValRef + member checked_multiply_info: IntrinsicValRef + member checked_subtraction_info: IntrinsicValRef + member checked_unary_minus_info: IntrinsicValRef + member choice2_tcr: TypedTree.EntityRef + member choice3_tcr: TypedTree.EntityRef + member choice4_tcr: TypedTree.EntityRef + member choice5_tcr: TypedTree.EntityRef + member choice6_tcr: TypedTree.EntityRef + member choice7_tcr: TypedTree.EntityRef + member compare_operator_vref: TypedTree.ValRef + member compilingFslib: bool + member cons_ucref: TypedTree.UnionCaseRef + member create_event_info: IntrinsicValRef + member create_instance_info: IntrinsicValRef + member date_tcr: TypedTree.EntityRef + member decimal_tcr: TypedTree.EntityRef + member decimal_ty: TypedTree.TType + member deserialize_quoted_FSharp_20_plus_info: IntrinsicValRef + member deserialize_quoted_FSharp_40_plus_info: IntrinsicValRef + member directoryToResolveRelativePaths: string + member dispose_info: IntrinsicValRef + member emitDebugInfoInQuotations: bool + member enumOfValue_vref: TypedTree.ValRef + member enum_operator_info: IntrinsicValRef + member enum_vref: TypedTree.ValRef + member equals_nullable_operator_vref: TypedTree.ValRef + member equals_operator_info: IntrinsicValRef + member equals_operator_vref: TypedTree.ValRef + member exn_tcr: TypedTree.EntityRef + member exn_ty: TypedTree.TType + member expr_tcr: TypedTree.EntityRef + member fail_init_info: IntrinsicValRef + member fail_static_init_info: IntrinsicValRef + member failwith_info: IntrinsicValRef + member failwith_vref: TypedTree.ValRef + member failwithf_info: IntrinsicValRef + member failwithf_vref: TypedTree.ValRef + member fastFunc_tcr: TypedTree.EntityRef + member float32_operator_info: IntrinsicValRef + member float32_tcr: TypedTree.EntityRef + member float32_ty: TypedTree.TType + member float_operator_info: IntrinsicValRef + member float_tcr: TypedTree.EntityRef + member float_ty: TypedTree.TType + member format_tcr: TypedTree.EntityRef + member fsharpref_vref: TypedTree.ValRef + member fslibCcu: TypedTree.CcuThunk + member fslib_IDelegateEvent_tcr: TypedTree.EntityRef + member fslib_IEvent2_tcr: TypedTree.EntityRef + member generateWitnesses: bool + member generic_compare_withc_tuple2_vref: TypedTree.ValRef + member generic_compare_withc_tuple3_vref: TypedTree.ValRef + member generic_compare_withc_tuple4_vref: TypedTree.ValRef + member generic_compare_withc_tuple5_vref: TypedTree.ValRef + member generic_comparison_inner_vref: TypedTree.ValRef + member generic_comparison_withc_inner_vref: TypedTree.ValRef + member generic_comparison_withc_outer_info: IntrinsicValRef + member generic_equality_er_inner_vref: TypedTree.ValRef + member generic_equality_er_outer_info: IntrinsicValRef + member generic_equality_per_inner_vref: TypedTree.ValRef + member generic_equality_withc_inner_vref: TypedTree.ValRef + member generic_equality_withc_outer_info: IntrinsicValRef + member generic_equality_withc_outer_vref: TypedTree.ValRef + member generic_equals_withc_tuple2_vref: TypedTree.ValRef + member generic_equals_withc_tuple3_vref: TypedTree.ValRef + member generic_equals_withc_tuple4_vref: TypedTree.ValRef + member generic_equals_withc_tuple5_vref: TypedTree.ValRef + member generic_hash_inner_vref: TypedTree.ValRef + member generic_hash_withc_inner_vref: TypedTree.ValRef + member generic_hash_withc_outer_info: IntrinsicValRef + member generic_hash_withc_tuple2_vref: TypedTree.ValRef + member generic_hash_withc_tuple3_vref: TypedTree.ValRef + member generic_hash_withc_tuple4_vref: TypedTree.ValRef + member generic_hash_withc_tuple5_vref: TypedTree.ValRef + member get_generic_comparer_info: IntrinsicValRef + member get_generic_er_equality_comparer_info: IntrinsicValRef + member get_generic_per_equality_comparer_info: IntrinsicValRef + member getstring_info: IntrinsicValRef + member greater_than_operator: IntrinsicValRef + member greater_than_operator_vref: TypedTree.ValRef + member greater_than_or_equals_operator: IntrinsicValRef + member greater_than_or_equals_operator_vref: TypedTree.ValRef + member hash_info: IntrinsicValRef + member il_arr_tcr_map: TypedTree.EntityRef [] + member ilg: AbstractIL.IL.ILGlobals + member ilsigptr_tcr: TypedTree.EntityRef + member iltyp_AsyncCallback: AbstractIL.IL.ILType + member iltyp_Exception: AbstractIL.IL.ILType + member iltyp_IAsyncResult: AbstractIL.IL.ILType + member iltyp_IComparable: AbstractIL.IL.ILType + member iltyp_Missing: AbstractIL.IL.ILType + member iltyp_RuntimeFieldHandle: AbstractIL.IL.ILType + member iltyp_RuntimeMethodHandle: AbstractIL.IL.ILType + member iltyp_RuntimeTypeHandle: AbstractIL.IL.ILType + member iltyp_SerializationInfo: AbstractIL.IL.ILType option + member iltyp_StreamingContext: AbstractIL.IL.ILType option + member iltyp_TypedReference: AbstractIL.IL.ILType option + member iltyp_ValueType: AbstractIL.IL.ILType + member ilxPubCloEnv: AbstractIL.Extensions.ILX.EraseClosures.cenv + member inref_tcr: TypedTree.EntityRef + member int16_checked_info: IntrinsicValRef + member int16_operator_info: IntrinsicValRef + member int16_tcr: TypedTree.EntityRef + member int16_ty: TypedTree.TType + member int32_checked_info: IntrinsicValRef + member int32_operator_info: IntrinsicValRef + member int32_tcr: TypedTree.EntityRef + member int32_ty: TypedTree.TType + member int64_checked_info: IntrinsicValRef + member int64_operator_info: IntrinsicValRef + member int64_tcr: TypedTree.EntityRef + member int64_ty: TypedTree.TType + member int_checked_info: IntrinsicValRef + member int_operator_info: IntrinsicValRef + member int_tcr: TypedTree.EntityRef + member int_ty: TypedTree.TType + member invalid_arg_info: IntrinsicValRef + member invalid_arg_vref: TypedTree.ValRef + member invalid_op_info: IntrinsicValRef + member invalid_op_vref: TypedTree.ValRef + member isInteractive: bool + member isnotnull_info: IntrinsicValRef + member isnull_info: IntrinsicValRef + member istype_fast_info: IntrinsicValRef + member istype_fast_vref: TypedTree.ValRef + member istype_info: IntrinsicValRef + member istype_vref: TypedTree.ValRef + member + knownFSharpCoreModules: System.Collections.Generic.IDictionary + member + knownIntrinsics: System.Collections.Concurrent.ConcurrentDictionary<(string * + string option * + string * + int), + TypedTree.ValRef> + member langVersion: Features.LanguageVersion + member lazy_create_info: IntrinsicValRef + member lazy_force_info: IntrinsicValRef + member lazy_tcr_canon: TypedTree.EntityRef + member lazy_tcr_nice: TypedTree.EntityRef + member less_than_operator: IntrinsicValRef + member less_than_operator_vref: TypedTree.ValRef + member less_than_or_equals_operator: IntrinsicValRef + member less_than_or_equals_operator_vref: TypedTree.ValRef + member lift_value_info: IntrinsicValRef + member lift_value_with_defn_info: IntrinsicValRef + member lift_value_with_name_info: IntrinsicValRef + member list_tcr_canon: TypedTree.EntityRef + member list_tcr_nice: TypedTree.EntityRef + member map_tcr_canon: TypedTree.EntityRef + member measureinverse_tcr: TypedTree.EntityRef + member measureone_tcr: TypedTree.EntityRef + member measureproduct_tcr: TypedTree.EntityRef + member methodhandleof_info: IntrinsicValRef + member methodhandleof_vref: TypedTree.ValRef + member mk_IComparable_ty: TypedTree.TType + member mk_IStructuralComparable_ty: TypedTree.TType + member mk_IStructuralEquatable_ty: TypedTree.TType + member mlCompatibility: bool + member nameof_vref: TypedTree.ValRef + member nativeint_checked_info: IntrinsicValRef + member nativeint_operator_info: IntrinsicValRef + member nativeint_tcr: TypedTree.EntityRef + member nativeint_ty: TypedTree.TType + member nativeptr_tcr: TypedTree.EntityRef + member nativeptr_tobyref_vref: TypedTree.ValRef + member new_decimal_info: IntrinsicValRef + member new_format_info: IntrinsicValRef + member new_format_vref: TypedTree.ValRef + member new_query_source_info: IntrinsicValRef + member nil_ucref: TypedTree.UnionCaseRef + member not_equals_operator: IntrinsicValRef + member not_equals_operator_vref: TypedTree.ValRef + member null_arg_info: IntrinsicValRef + member null_arg_vref: TypedTree.ValRef + member nullable_equals_nullable_operator_vref: TypedTree.ValRef + member nullable_equals_operator_vref: TypedTree.ValRef + member obj_ty: TypedTree.TType + member option_defaultValue_info: IntrinsicValRef + member option_tcr_canon: TypedTree.EntityRef + member option_tcr_nice: TypedTree.EntityRef + member option_toNullable_info: IntrinsicValRef + member or2_vref: TypedTree.ValRef + member or_vref: TypedTree.ValRef + member outref_tcr: TypedTree.EntityRef + member pathMap: Internal.Utilities.PathMap + member pdecimal_tcr: TypedTree.EntityRef + member pfloat32_tcr: TypedTree.EntityRef + member pfloat_tcr: TypedTree.EntityRef + member pint16_tcr: TypedTree.EntityRef + member pint64_tcr: TypedTree.EntityRef + member pint8_tcr: TypedTree.EntityRef + member pint_tcr: TypedTree.EntityRef + member pnativeint_tcr: TypedTree.EntityRef + member puint16_tcr: TypedTree.EntityRef + member puint64_tcr: TypedTree.EntityRef + member puint8_tcr: TypedTree.EntityRef + member puint_tcr: TypedTree.EntityRef + member punativeint_tcr: TypedTree.EntityRef + member query_builder_tcref: TypedTree.EntityRef + member query_for_vref: TypedTree.ValRef + member query_run_enumerable_vref: TypedTree.ValRef + member query_run_value_vref: TypedTree.ValRef + member query_select_vref: TypedTree.ValRef + member query_source_as_enum_info: IntrinsicValRef + member query_source_vref: TypedTree.ValRef + member query_value_vref: TypedTree.ValRef + member query_where_vref: TypedTree.ValRef + member query_yield_from_vref: TypedTree.ValRef + member query_yield_vref: TypedTree.ValRef + member query_zero_vref: TypedTree.ValRef + member quote_to_linq_lambda_info: IntrinsicValRef + member raise_info: IntrinsicValRef + member raise_vref: TypedTree.ValRef + member range_int32_op_vref: TypedTree.ValRef + member range_op_vref: TypedTree.ValRef + member range_step_op_vref: TypedTree.ValRef + member raw_expr_tcr: TypedTree.EntityRef + member ref_tuple1_tcr: TypedTree.EntityRef + member ref_tuple2_tcr: TypedTree.EntityRef + member ref_tuple3_tcr: TypedTree.EntityRef + member ref_tuple4_tcr: TypedTree.EntityRef + member ref_tuple5_tcr: TypedTree.EntityRef + member ref_tuple6_tcr: TypedTree.EntityRef + member ref_tuple7_tcr: TypedTree.EntityRef + member ref_tuple8_tcr: TypedTree.EntityRef + member refcell_tcr_canon: TypedTree.EntityRef + member refcell_tcr_nice: TypedTree.EntityRef + member reference_equality_inner_vref: TypedTree.ValRef + member reraise_info: IntrinsicValRef + member reraise_vref: TypedTree.ValRef + member sbyte_checked_info: IntrinsicValRef + member sbyte_operator_info: IntrinsicValRef + member sbyte_tcr: TypedTree.EntityRef + member sbyte_ty: TypedTree.TType + member seq_append_info: IntrinsicValRef + member seq_append_vref: TypedTree.ValRef + member seq_base_tcr: TypedTree.EntityRef + member seq_collect_info: IntrinsicValRef + member seq_collect_vref: TypedTree.ValRef + member seq_delay_info: IntrinsicValRef + member seq_delay_vref: TypedTree.ValRef + member seq_empty_info: IntrinsicValRef + member seq_empty_vref: TypedTree.ValRef + member seq_finally_info: IntrinsicValRef + member seq_finally_vref: TypedTree.ValRef + member seq_generated_info: IntrinsicValRef + member seq_generated_vref: TypedTree.ValRef + member seq_info: IntrinsicValRef + member seq_map_info: IntrinsicValRef + member seq_map_vref: TypedTree.ValRef + member seq_of_functions_info: IntrinsicValRef + member seq_of_functions_vref: TypedTree.ValRef + member seq_singleton_info: IntrinsicValRef + member seq_singleton_vref: TypedTree.ValRef + member seq_tcr: TypedTree.EntityRef + member seq_to_array_info: IntrinsicValRef + member seq_to_list_info: IntrinsicValRef + member seq_using_info: IntrinsicValRef + member seq_using_vref: TypedTree.ValRef + member seq_vref: TypedTree.ValRef + member set_tcr_canon: TypedTree.EntityRef + member sizeof_vref: TypedTree.ValRef + member splice_expr_vref: TypedTree.ValRef + member splice_raw_expr_vref: TypedTree.ValRef + member sprintf_info: IntrinsicValRef + member sprintf_vref: TypedTree.ValRef + member string_ty: TypedTree.TType + member struct_tuple1_tcr: TypedTree.EntityRef + member struct_tuple2_tcr: TypedTree.EntityRef + member struct_tuple3_tcr: TypedTree.EntityRef + member struct_tuple4_tcr: TypedTree.EntityRef + member struct_tuple5_tcr: TypedTree.EntityRef + member struct_tuple6_tcr: TypedTree.EntityRef + member struct_tuple7_tcr: TypedTree.EntityRef + member struct_tuple8_tcr: TypedTree.EntityRef + member suppressed_types: TypedTree.EntityRef list + member system_ArgIterator_tcref: TypedTree.EntityRef option + member system_Array_tcref: TypedTree.EntityRef + member system_Array_ty: TypedTree.TType + member system_Bool_tcref: TypedTree.EntityRef + member system_Byte_tcref: TypedTree.EntityRef + member system_Char_tcref: TypedTree.EntityRef + member system_Decimal_tcref: TypedTree.EntityRef + member system_Delegate_ty: TypedTree.TType + member system_Double_tcref: TypedTree.EntityRef + member system_Enum_ty: TypedTree.TType + member system_ExceptionDispatchInfo_ty: TypedTree.TType option + member system_Exception_ty: TypedTree.TType + member system_FormattableStringFactory_tcref: TypedTree.EntityRef + member system_FormattableStringFactory_ty: TypedTree.TType + member system_FormattableString_tcref: TypedTree.EntityRef + member system_FormattableString_ty: TypedTree.TType + member system_GenericIComparable_tcref: TypedTree.EntityRef + member system_GenericIEquatable_tcref: TypedTree.EntityRef + member system_IDisposable_ty: TypedTree.TType + member system_IFormattable_tcref: TypedTree.EntityRef + member system_IFormattable_ty: TypedTree.TType + member system_IndexOutOfRangeException_tcref: TypedTree.EntityRef + member system_Int16_tcref: TypedTree.EntityRef + member system_Int32_tcref: TypedTree.EntityRef + member system_Int32_ty: TypedTree.TType + member system_Int64_tcref: TypedTree.EntityRef + member system_IntPtr_tcref: TypedTree.EntityRef + member system_LinqExpression_tcref: TypedTree.EntityRef + member system_MarshalByRefObject_tcref: TypedTree.EntityRef option + member system_MarshalByRefObject_ty: TypedTree.TType option + member system_MulticastDelegate_ty: TypedTree.TType + member system_Nullable_tcref: TypedTree.EntityRef + member system_Object_tcref: TypedTree.EntityRef + member system_Object_ty: TypedTree.TType + member system_Reflection_MethodInfo_ty: TypedTree.TType + member system_RuntimeArgumentHandle_tcref: TypedTree.EntityRef option + member system_RuntimeHelpers_ty: TypedTree.TType + member system_RuntimeMethodHandle_ty: TypedTree.TType + member system_RuntimeTypeHandle_ty: TypedTree.TType + member system_SByte_tcref: TypedTree.EntityRef + member system_Single_tcref: TypedTree.EntityRef + member system_String_tcref: TypedTree.EntityRef + member system_String_typ: TypedTree.TType + member system_Type_ty: TypedTree.TType + member system_TypedReference_tcref: TypedTree.EntityRef option + member system_UInt16_tcref: TypedTree.EntityRef + member system_UInt32_tcref: TypedTree.EntityRef + member system_UInt64_tcref: TypedTree.EntityRef + member system_UIntPtr_tcref: TypedTree.EntityRef + member system_Value_tcref: TypedTree.EntityRef + member system_Value_ty: TypedTree.TType + member system_Void_tcref: TypedTree.EntityRef + member tcref_IObservable: TypedTree.EntityRef + member tcref_IObserver: TypedTree.EntityRef + member tcref_IQueryable: TypedTree.EntityRef + member tcref_LanguagePrimitives: TypedTree.EntityRef + member tcref_System_Attribute: TypedTree.EntityRef + member tcref_System_Collections_Generic_Dictionary: TypedTree.EntityRef + member + tcref_System_Collections_Generic_ICollection: TypedTree.EntityRef + member + tcref_System_Collections_Generic_IDictionary: TypedTree.EntityRef + member + tcref_System_Collections_Generic_IEnumerable: TypedTree.EntityRef + member + tcref_System_Collections_Generic_IEnumerator: TypedTree.EntityRef + member + tcref_System_Collections_Generic_IEqualityComparer: TypedTree.EntityRef + member tcref_System_Collections_Generic_IList: TypedTree.EntityRef + member + tcref_System_Collections_Generic_IReadOnlyCollection: TypedTree.EntityRef + member + tcref_System_Collections_Generic_IReadOnlyList: TypedTree.EntityRef + member tcref_System_Collections_Generic_List: TypedTree.EntityRef + member tcref_System_Collections_IComparer: TypedTree.EntityRef + member tcref_System_Collections_IEnumerable: TypedTree.EntityRef + member tcref_System_Collections_IEqualityComparer: TypedTree.EntityRef + member tcref_System_IComparable: TypedTree.EntityRef + member tcref_System_IDisposable: TypedTree.EntityRef + member tcref_System_IStructuralComparable: TypedTree.EntityRef + member tcref_System_IStructuralEquatable: TypedTree.EntityRef + member typedefof_info: IntrinsicValRef + member typedefof_vref: TypedTree.ValRef + member typeof_info: IntrinsicValRef + member typeof_vref: TypedTree.ValRef + member uint16_checked_info: IntrinsicValRef + member uint16_operator_info: IntrinsicValRef + member uint16_tcr: TypedTree.EntityRef + member uint16_ty: TypedTree.TType + member uint32_checked_info: IntrinsicValRef + member uint32_operator_info: IntrinsicValRef + member uint32_tcr: TypedTree.EntityRef + member uint32_ty: TypedTree.TType + member uint64_checked_info: IntrinsicValRef + member uint64_operator_info: IntrinsicValRef + member uint64_tcr: TypedTree.EntityRef + member uint64_ty: TypedTree.TType + member unativeint_checked_info: IntrinsicValRef + member unativeint_operator_info: IntrinsicValRef + member unativeint_tcr: TypedTree.EntityRef + member unativeint_ty: TypedTree.TType + member unbox_fast_info: IntrinsicValRef + member unbox_fast_vref: TypedTree.ValRef + member unbox_info: IntrinsicValRef + member unbox_vref: TypedTree.ValRef + member unchecked_addition_info: IntrinsicValRef + member unchecked_addition_vref: TypedTree.ValRef + member unchecked_defaultof_info: IntrinsicValRef + member unchecked_defaultof_vref: TypedTree.ValRef + member unchecked_division_info: IntrinsicValRef + member unchecked_modulus_info: IntrinsicValRef + member unchecked_multiply_info: IntrinsicValRef + member unchecked_multiply_vref: TypedTree.ValRef + member unchecked_subtraction_info: IntrinsicValRef + member unchecked_subtraction_vref: TypedTree.ValRef + member unchecked_unary_minus_info: IntrinsicValRef + member unchecked_unary_minus_vref: TypedTree.ValRef + member unchecked_unary_not_info: IntrinsicValRef + member unchecked_unary_not_vref: TypedTree.ValRef + member unchecked_unary_plus_info: IntrinsicValRef + member unchecked_unary_plus_vref: TypedTree.ValRef + member unit_tcr_canon: TypedTree.EntityRef + member unit_tcr_nice: TypedTree.EntityRef + member unit_ty: TypedTree.TType + member voidptr_tcr: TypedTree.EntityRef + + val mutable global_g: TcGlobals option + + +namespace FSharp.Compiler + module internal TypedTreeOps = + [] + type TyparMap<'T> = + | TPMap of TypedTree.StampMap<'T> + with + member Add: TypedTree.Typar * 'T -> TyparMap<'T> + member ContainsKey: TypedTree.Typar -> bool + member TryFind: TypedTree.Typar -> 'T option + member Item: TypedTree.Typar -> 'T with get + static member Empty: TyparMap<'T> + + [] + type TyconRefMap<'T> = + + new: imap:TypedTree.StampMap<'T> -> TyconRefMap<'T> + static member OfList: (TypedTree.TyconRef * 'T) list -> TyconRefMap<'T> + member Add: TypedTree.TyconRef -> 'T -> TyconRefMap<'T> + member ContainsKey: TypedTree.TyconRef -> bool + member Remove: TypedTree.TyconRef -> TyconRefMap<'T> + member TryFind: TypedTree.TyconRef -> 'T option + member IsEmpty: bool + member Item: TypedTree.TyconRef -> 'T with get + static member Empty: TyconRefMap<'T> + + [] + type ValMap<'T> = + + new: imap:TypedTree.StampMap<'T> -> ValMap<'T> + static member OfList: (TypedTree.Val * 'T) list -> ValMap<'T> + member Add: TypedTree.Val -> 'T -> ValMap<'T> + member ContainsVal: TypedTree.Val -> bool + member Remove: TypedTree.Val -> ValMap<'T> + member TryFind: TypedTree.Val -> 'T option + member Contents: TypedTree.StampMap<'T> + member IsEmpty: bool + member Item: TypedTree.Val -> 'T with get + static member Empty: ValMap<'T> + + type TyparInst = (TypedTree.Typar * TypedTree.TType) list + type TyconRefRemap = TyconRefMap + type ValRemap = ValMap + val emptyTyconRefRemap: TyconRefRemap + val emptyTyparInst: TyparInst + [] + type Remap = + { tpinst: TyparInst + valRemap: ValRemap + tyconRefRemap: TyconRefRemap + removeTraitSolutions: bool } + with + static member Empty: Remap + + val emptyRemap: Remap + val addTyconRefRemap: + TypedTree.TyconRef -> TypedTree.TyconRef -> Remap -> Remap + val isRemapEmpty: remap:Remap -> bool + val instTyparRef: + tpinst:(TypedTree.Typar * 'a) list -> ty:'a -> tp:TypedTree.Typar -> 'a + val instMeasureTyparRef: + tpinst:(TypedTree.Typar * TypedTree.TType) list -> + unt:TypedTree.Measure -> tp:TypedTree.Typar -> TypedTree.Measure + val remapTyconRef: + TyconRefMap -> + TypedTree.TyconRef -> TypedTree.TyconRef + val remapUnionCaseRef: + TyconRefMap -> + TypedTree.UnionCaseRef -> TypedTree.UnionCaseRef + val remapRecdFieldRef: + TyconRefMap -> + TypedTree.RecdFieldRef -> TypedTree.RecdFieldRef + val mkTyparInst: TypedTree.Typars -> TypedTree.TType list -> TyparInst + val generalizeTypar: tp:TypedTree.Typar -> TypedTree.TType + val generalizeTypars: TypedTree.Typar list -> TypedTree.TType list + val remapTypeAux: tyenv:Remap -> ty:TypedTree.TType -> TypedTree.TType + val remapMeasureAux: + tyenv:Remap -> unt:TypedTree.Measure -> TypedTree.Measure + val remapTupInfoAux: + _tyenv:Remap -> unt:TypedTree.TupInfo -> TypedTree.TupInfo + val remapTypesAux: + tyenv:Remap -> types:TypedTree.TypeInst -> TypedTree.TypeInst + val remapTyparConstraintsAux: + tyenv:Remap -> + cs:TypedTree.TyparConstraint list -> TypedTree.TyparConstraint list + val remapTraitWitnessInfo: + tyenv:Remap -> TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo + val remapTraitInfo: + tyenv:Remap -> + TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo + val bindTypars: + tps:'a list -> tyargs:'b list -> tpinst:('a * 'b) list -> ('a * 'b) list + val copyAndRemapAndBindTyparsFull: + remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> + tyenv:Remap -> tps:TypedTree.Typar list -> TypedTree.Typar list * Remap + val copyAndRemapAndBindTypars: + tyenv:Remap -> tps:TypedTree.Typars -> TypedTree.Typars * Remap + val remapValLinkage: + tyenv:Remap -> + vlink:TypedTree.ValLinkageFullKey -> TypedTree.ValLinkageFullKey + val remapNonLocalValRef: + tyenv:Remap -> + nlvref:TypedTree.NonLocalValOrMemberRef -> + TypedTree.NonLocalValOrMemberRef + val remapValRef: Remap -> TypedTree.ValRef -> TypedTree.ValRef + val remapType: tyenv:Remap -> x:TypedTree.TType -> TypedTree.TType + val remapTypes: tyenv:Remap -> x:TypedTree.TypeInst -> TypedTree.TypeInst + val remapTypeFull: + remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> + tyenv:Remap -> ty:TypedTree.TType -> TypedTree.TType + val remapParam: tyenv:Remap -> TypedTree.SlotParam -> TypedTree.SlotParam + val remapSlotSig: + remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> + tyenv:Remap -> TypedTree.SlotSig -> TypedTree.SlotSig + val mkInstRemap: tpinst:TyparInst -> Remap + val instType: + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.TType -> TypedTree.TType + val instTypes: + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.TypeInst -> TypedTree.TypeInst + val instTrait: + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo + val instTyparConstraints: + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.TyparConstraint list -> TypedTree.TyparConstraint list + val instSlotSig: TyparInst -> TypedTree.SlotSig -> TypedTree.SlotSig + val copySlotSig: TypedTree.SlotSig -> TypedTree.SlotSig + val mkTyparToTyparRenaming: + TypedTree.Typars -> + TypedTree.Typar list -> TyparInst * TypedTree.TType list + val mkTyconInst: + tycon:TypedTree.Tycon -> tinst:TypedTree.TType list -> TyparInst + val mkTyconRefInst: TypedTree.TyconRef -> TypedTree.TType list -> TyparInst + val tyconRefEq: + TcGlobals.TcGlobals -> TypedTree.EntityRef -> TypedTree.EntityRef -> bool + val valRefEq: + TcGlobals.TcGlobals -> TypedTree.ValRef -> TypedTree.ValRef -> bool + val reduceTyconRefAbbrevMeasureable: + TypedTree.TyconRef -> TypedTree.Measure + val stripUnitEqnsFromMeasureAux: + canShortcut:bool -> unt:TypedTree.Measure -> TypedTree.Measure + val stripUnitEqnsFromMeasure: m:TypedTree.Measure -> TypedTree.Measure + val MeasureExprConExponent: + TcGlobals.TcGlobals -> + bool -> TypedTree.EntityRef -> TypedTree.Measure -> Rational.Rational + val MeasureConExponentAfterRemapping: + g:TcGlobals.TcGlobals -> + r:(TypedTree.TyconRef -> TypedTree.EntityRef) -> + ucref:TypedTree.EntityRef -> + unt:TypedTree.Measure -> Rational.Rational + val MeasureVarExponent: + TypedTree.Typar -> TypedTree.Measure -> Rational.Rational + val ListMeasureVarOccs: unt:TypedTree.Measure -> TypedTree.Typar list + val ListMeasureVarOccsWithNonZeroExponents: + TypedTree.Measure -> (TypedTree.Typar * Rational.Rational) list + val ListMeasureConOccsWithNonZeroExponents: + TcGlobals.TcGlobals -> + bool -> + TypedTree.Measure -> (TypedTree.EntityRef * Rational.Rational) list + val ListMeasureConOccsAfterRemapping: + g:TcGlobals.TcGlobals -> + r:(TypedTree.TyconRef -> TypedTree.EntityRef) -> + unt:TypedTree.Measure -> TypedTree.EntityRef list + val MeasurePower: TypedTree.Measure -> int -> TypedTree.Measure + val MeasureProdOpt: + m1:TypedTree.Measure -> m2:TypedTree.Measure -> TypedTree.Measure + val ProdMeasures: TypedTree.Measure list -> TypedTree.Measure + val isDimensionless: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val destUnitParMeasure: + g:TcGlobals.TcGlobals -> unt:TypedTree.Measure -> TypedTree.Typar + val isUnitParMeasure: + g:TcGlobals.TcGlobals -> unt:TypedTree.Measure -> bool + val normalizeMeasure: + TcGlobals.TcGlobals -> TypedTree.Measure -> TypedTree.Measure + val tryNormalizeMeasureInType: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkNativePtrTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkInByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkOutByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkByrefTyWithFlag: + g:TcGlobals.TcGlobals -> + readonly:bool -> ty:TypedTree.TType -> TypedTree.TType + val mkByref2Ty: + g:TcGlobals.TcGlobals -> + ty1:TypedTree.TType -> ty2:TypedTree.TType -> TypedTree.TType + val mkVoidPtrTy: TcGlobals.TcGlobals -> TypedTree.TType + val mkByrefTyWithInference: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType -> TypedTree.TType + val mkArrayTy: + TcGlobals.TcGlobals -> + int -> TypedTree.TType -> Range.range -> TypedTree.TType + val maxTuple: int + val goodTupleFields: int + val isCompiledTupleTyconRef: + TcGlobals.TcGlobals -> TypedTree.EntityRef -> bool + val mkCompiledTupleTyconRef: + TcGlobals.TcGlobals -> bool -> int -> TypedTree.EntityRef + val mkCompiledTupleTy: + TcGlobals.TcGlobals -> bool -> TypedTree.TType list -> TypedTree.TType + val mkOuterCompiledTupleTy: + g:TcGlobals.TcGlobals -> + isStruct:bool -> tupElemTys:TypedTree.TType list -> TypedTree.TType + val applyTyconAbbrev: + abbrevTy:TypedTree.TType -> + tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType + val reduceTyconAbbrev: + tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType + val reduceTyconRefAbbrev: + TypedTree.TyconRef -> TypedTree.TType list -> TypedTree.TType + val reduceTyconMeasureableOrProvided: + g:TcGlobals.TcGlobals -> + tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType + val reduceTyconRefMeasureableOrProvided: + TcGlobals.TcGlobals -> + TypedTree.TyconRef -> TypedTree.TType list -> TypedTree.TType + val stripTyEqnsA: + TcGlobals.TcGlobals -> bool -> TypedTree.TType -> TypedTree.TType + val stripTyEqns: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val evalTupInfoIsStruct: TypedTree.TupInfo -> bool + val evalAnonInfoIsStruct: TypedTree.AnonRecdTypeInfo -> bool + val stripTyEqnsAndErase: + eraseFuncAndTuple:bool -> + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + val stripTyEqnsAndMeasureEqns: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + type Erasure = + | EraseAll + | EraseMeasures + | EraseNone + val stripTyEqnsWrtErasure: + Erasure -> TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val stripExnEqns: TypedTree.TyconRef -> TypedTree.Entity + val primDestForallTy: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> TypedTree.Typars * TypedTree.TType + val destFunTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType * TypedTree.TType + val destAnyTupleTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TupInfo * TypedTree.TTypes + val destRefTupleTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes + val destStructTupleTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes + val destTyparTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar + val destAnyParTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar + val destMeasureTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Measure + val isFunTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isForallTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isAnyTupleTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isRefTupleTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isStructTupleTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isAnonRecdTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isStructAnonRecdTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isUnionTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isReprHiddenTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isFSharpObjModelTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isRecdTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isFSharpStructOrEnumTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isFSharpEnumTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isTyparTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isAnyParTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isMeasureTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isProvenUnionCaseTy: TypedTree.TType -> bool + val mkAppTy: TypedTree.TyconRef -> TypedTree.TypeInst -> TypedTree.TType + val mkProvenUnionCaseTy: + TypedTree.UnionCaseRef -> TypedTree.TypeInst -> TypedTree.TType + val isAppTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val tryAppTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> (TypedTree.TyconRef * TypedTree.TypeInst) voption + val destAppTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TyconRef * TypedTree.TypeInst + val tcrefOfAppTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TyconRef + val argsOfAppTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TypeInst + val tryDestTyparTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar voption + val tryDestFunTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> (TypedTree.TType * TypedTree.TType) voption + val tryTcrefOfAppTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TyconRef voption + val tryDestAnonRecdTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> + (TypedTree.AnonRecdTypeInfo * TypedTree.TType list) voption + val tryAnyParTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar voption + val tryAnyParTyOption: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar option + val ( |AppTy|_| ): + TcGlobals.TcGlobals -> + TypedTree.TType -> (TypedTree.TyconRef * TypedTree.TypeInst) option + val ( |RefTupleTy|_| ): + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TTypes option + val ( |FunTy|_| ): + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> (TypedTree.TType * TypedTree.TType) option + val tryNiceEntityRefOfTy: TypedTree.TType -> TypedTree.TyconRef voption + val tryNiceEntityRefOfTyOption: + TypedTree.TType -> TypedTree.TyconRef option + val mkInstForAppTy: TcGlobals.TcGlobals -> TypedTree.TType -> TyparInst + val domainOfFunTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val rangeOfFunTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val convertToTypeWithMetadataIfPossible: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val stripMeasuresFromTType: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + [] + type TypeEquivEnv = + { EquivTypars: TyparMap + EquivTycons: TyconRefRemap } + with + static member + FromEquivTypars: TypedTree.Typar list -> + TypedTree.Typar list -> TypeEquivEnv + static member + FromTyparInst: (TypedTree.Typar * TypedTree.TType) list -> + TypeEquivEnv + member + BindEquivTypars: TypedTree.Typar list -> + TypedTree.Typar list -> TypeEquivEnv + member + BindTyparsToTypes: tps1:TypedTree.Typar list -> + tys2:TypedTree.TType list -> TypeEquivEnv + static member Empty: TypeEquivEnv + + val typeEquivEnvEmpty: TypeEquivEnv + val traitsAEquivAux: + Erasure -> + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TraitConstraintInfo -> + TypedTree.TraitConstraintInfo -> bool + val traitKeysAEquivAux: + Erasure -> + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo -> bool + val returnTypesAEquivAux: + Erasure -> + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TType option -> TypedTree.TType option -> bool + val typarConstraintsAEquivAux: + Erasure -> + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TyparConstraint -> TypedTree.TyparConstraint -> bool + val typarConstraintSetsAEquivAux: + erasureFlag:Erasure -> + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + tp1:TypedTree.Typar -> tp2:TypedTree.Typar -> bool + val typarsAEquivAux: + erasureFlag:Erasure -> + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + tps1:TypedTree.Typar list -> tps2:TypedTree.Typar list -> bool + val tcrefAEquiv: + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.EntityRef -> TypedTree.EntityRef -> bool + val typeAEquivAux: + Erasure -> + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.TType -> TypedTree.TType -> bool + val anonInfoEquiv: + TypedTree.AnonRecdTypeInfo -> TypedTree.AnonRecdTypeInfo -> bool + val structnessAEquiv: + un1:TypedTree.TupInfo -> un2:TypedTree.TupInfo -> bool + val measureAEquiv: + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + un1:TypedTree.Measure -> un2:TypedTree.Measure -> bool + val typesAEquivAux: + erasureFlag:Erasure -> + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + l1:TypedTree.TypeInst -> l2:TypedTree.TypeInst -> bool + val typeEquivAux: + Erasure -> + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType -> bool + val typeAEquiv: + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.TType -> TypedTree.TType -> bool + val typeEquiv: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType -> bool + val traitsAEquiv: + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo -> bool + val traitKeysAEquiv: + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo -> bool + val typarConstraintsAEquiv: + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TyparConstraint -> TypedTree.TyparConstraint -> bool + val typarsAEquiv: + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.Typar list -> TypedTree.Typar list -> bool + val returnTypesAEquiv: + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.TType option -> TypedTree.TType option -> bool + val measureEquiv: + TcGlobals.TcGlobals -> TypedTree.Measure -> TypedTree.Measure -> bool + val getMeasureOfType: + TcGlobals.TcGlobals -> + TypedTree.TType -> (TypedTree.TyconRef * TypedTree.Measure) option + val isErasedType: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val getErasedTypes: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType list + val valOrder: System.Collections.Generic.IComparer + val tyconOrder: System.Collections.Generic.IComparer + val recdFieldRefOrder: + System.Collections.Generic.IComparer + val unionCaseRefOrder: + System.Collections.Generic.IComparer + val mkFunTy: TypedTree.TType -> TypedTree.TType -> TypedTree.TType + val ( --> ): TypedTree.TType -> TypedTree.TType -> TypedTree.TType + val mkForallTy: d:TypedTree.Typars -> r:TypedTree.TType -> TypedTree.TType + val mkForallTyIfNeeded: + TypedTree.Typar list -> TypedTree.TType -> TypedTree.TType + val ( +-> ): TypedTree.Typar list -> TypedTree.TType -> TypedTree.TType + val mkIteratedFunTy: + TypedTree.TType list -> TypedTree.TType -> TypedTree.TType + val mkLambdaArgTy: + m:Range.range -> tys:TypedTree.TType list -> TypedTree.TType + val typeOfLambdaArg: Range.range -> TypedTree.Val list -> TypedTree.TType + val mkMultiLambdaTy: + Range.range -> TypedTree.Val list -> TypedTree.TType -> TypedTree.TType + val mkLambdaTy: + TypedTree.Typar list -> + TypedTree.TType list -> TypedTree.TType -> TypedTree.TType + val ensureCcuHasModuleOrNamespaceAtPath: + TypedTree.CcuThunk -> + SyntaxTree.Ident list -> + TypedTree.CompilationPath -> XmlDoc.XmlDoc -> unit + val stripExpr: TypedTree.Expr -> TypedTree.Expr + val mkCase: + TypedTree.DecisionTreeTest * TypedTree.DecisionTree -> + TypedTree.DecisionTreeCase + val isRefTupleExpr: TypedTree.Expr -> bool + val tryDestRefTupleExpr: TypedTree.Expr -> TypedTree.Exprs + val rangeOfExpr: x:TypedTree.Expr -> Range.range + type Expr with + member Range: Range.range + val primMkMatch: + SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * + TypedTree.DecisionTreeTarget array * Range.range * TypedTree.TType -> + TypedTree.Expr + type MatchBuilder = + + new: SyntaxTree.DebugPointForBinding * Range.range -> MatchBuilder + member + AddResultTarget: TypedTree.Expr * SyntaxTree.DebugPointForTarget -> + TypedTree.DecisionTree + member AddTarget: TypedTree.DecisionTreeTarget -> int + member + Close: TypedTree.DecisionTree * Range.range * TypedTree.TType -> + TypedTree.Expr + member CloseTargets: unit -> TypedTree.DecisionTreeTarget list + + val mkBoolSwitch: + Range.range -> + TypedTree.Expr -> + TypedTree.DecisionTree -> + TypedTree.DecisionTree -> TypedTree.DecisionTree + val primMkCond: + SyntaxTree.DebugPointForBinding -> + SyntaxTree.DebugPointForTarget -> + SyntaxTree.DebugPointForTarget -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCond: + SyntaxTree.DebugPointForBinding -> + SyntaxTree.DebugPointForTarget -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val exprForValRef: Range.range -> TypedTree.ValRef -> TypedTree.Expr + val exprForVal: Range.range -> TypedTree.Val -> TypedTree.Expr + val mkLocalAux: + m:Range.range -> + s:string -> + ty:TypedTree.TType -> + mut:TypedTree.ValMutability -> + compgen:bool -> TypedTree.Val * TypedTree.Expr + val mkLocal: + Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr + val mkCompGenLocal: + Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr + val mkMutableCompGenLocal: + Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr + val mkMultiLambda: + Range.range -> + TypedTree.Val list -> TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val rebuildLambda: + Range.range -> + TypedTree.Val option -> + TypedTree.Val option -> + TypedTree.Val list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkLambda: + Range.range -> + TypedTree.Val -> TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkTypeLambda: + Range.range -> + TypedTree.Typar list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkTypeChoose: + Range.range -> TypedTree.Typar list -> TypedTree.Expr -> TypedTree.Expr + val mkObjExpr: + TypedTree.TType * TypedTree.Val option * TypedTree.Expr * + TypedTree.ObjExprMethod list * + (TypedTree.TType * TypedTree.ObjExprMethod list) list * Range.range -> + TypedTree.Expr + val mkLambdas: + Range.range -> + TypedTree.Typar list -> + TypedTree.Val list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkMultiLambdasCore: + Range.range -> + TypedTree.Val list list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr * TypedTree.TType + val mkMultiLambdas: + Range.range -> + TypedTree.Typar list -> + TypedTree.Val list list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkMemberLambdas: + Range.range -> + TypedTree.Typar list -> + TypedTree.Val option -> + TypedTree.Val option -> + TypedTree.Val list list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkMultiLambdaBind: + TypedTree.Val -> + SyntaxTree.DebugPointForBinding -> + Range.range -> + TypedTree.Typar list -> + TypedTree.Val list list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Binding + val mkBind: + SyntaxTree.DebugPointForBinding -> + TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding + val mkLetBind: + Range.range -> TypedTree.Binding -> TypedTree.Expr -> TypedTree.Expr + val mkLetsBind: + Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr + val mkLetsFromBindings: + Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr + val mkLet: + SyntaxTree.DebugPointForBinding -> + Range.range -> + TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCompGenBind: TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding + val mkCompGenBinds: + TypedTree.Val list -> TypedTree.Expr list -> TypedTree.Binding list + val mkCompGenLet: + Range.range -> + TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCompGenLets: + m:Range.range -> + vs:TypedTree.Val list -> + xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr + val mkCompGenLetsFromBindings: + m:Range.range -> + vs:TypedTree.Val list -> + xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr + val mkInvisibleBind: TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding + val mkInvisibleBinds: + TypedTree.Val list -> TypedTree.Expr list -> TypedTree.Binding list + val mkInvisibleLet: + Range.range -> + TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkInvisibleLets: + m:Range.range -> + vs:TypedTree.Val list -> + xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr + val mkInvisibleLetsFromBindings: + m:Range.range -> + vs:TypedTree.Val list -> + xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr + val mkLetRecBinds: + Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr + val NormalizeDeclaredTyparsForEquiRecursiveInference: + TcGlobals.TcGlobals -> TypedTree.Typar list -> TypedTree.Typar list + type TypeScheme = | TypeScheme of TypedTree.Typars * TypedTree.TType + val mkGenericBindRhs: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Typar list -> TypeScheme -> TypedTree.Expr -> TypedTree.Expr + val isBeingGeneralized: TypedTree.Typar -> TypeScheme -> bool + val mkLazyAnd: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkLazyOr: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCoerceExpr: + TypedTree.Expr * TypedTree.TType * Range.range * TypedTree.TType -> + TypedTree.Expr + val mkAsmExpr: + AbstractIL.IL.ILInstr list * TypedTree.TypeInst * TypedTree.Exprs * + TypedTree.TTypes * Range.range -> TypedTree.Expr + val mkUnionCaseExpr: + TypedTree.UnionCaseRef * TypedTree.TypeInst * TypedTree.Exprs * + Range.range -> TypedTree.Expr + val mkExnExpr: + TypedTree.TyconRef * TypedTree.Exprs * Range.range -> TypedTree.Expr + val mkTupleFieldGetViaExprAddr: + tupInfo:TypedTree.TupInfo * e:TypedTree.Expr * tinst:TypedTree.TypeInst * + i:int * m:Range.range -> TypedTree.Expr + val mkAnonRecdFieldGetViaExprAddr: + TypedTree.AnonRecdTypeInfo * TypedTree.Expr * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkRecdFieldGetViaExprAddr: + TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> + TypedTree.Expr + val mkRecdFieldGetAddrViaExprAddr: + readonly:bool * TypedTree.Expr * TypedTree.RecdFieldRef * + TypedTree.TypeInst * Range.range -> TypedTree.Expr + val mkStaticRecdFieldGetAddr: + readonly:bool * TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> + TypedTree.Expr + val mkStaticRecdFieldGet: + TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> + TypedTree.Expr + val mkStaticRecdFieldSet: + TypedTree.RecdFieldRef * TypedTree.TypeInst * TypedTree.Expr * Range.range -> + TypedTree.Expr + val mkArrayElemAddress: + TcGlobals.TcGlobals -> + readonly:bool * AbstractIL.IL.ILReadonly * bool * + AbstractIL.IL.ILArrayShape * TypedTree.TType * TypedTree.Exprs * + Range.range -> TypedTree.Expr + val mkRecdFieldSetViaExprAddr: + TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * + TypedTree.Expr * Range.range -> TypedTree.Expr + val mkUnionCaseTagGetViaExprAddr: + TypedTree.Expr * TypedTree.TyconRef * TypedTree.TypeInst * Range.range -> + TypedTree.Expr + val mkUnionCaseProof: + TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * Range.range -> + TypedTree.Expr + val mkUnionCaseFieldGetProvenViaExprAddr: + TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkUnionCaseFieldGetAddrProvenViaExprAddr: + readonly:bool * TypedTree.Expr * TypedTree.UnionCaseRef * + TypedTree.TypeInst * int * Range.range -> TypedTree.Expr + val mkUnionCaseFieldGetUnprovenViaExprAddr: + TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkUnionCaseFieldSet: + TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * + TypedTree.Expr * Range.range -> TypedTree.Expr + val mkExnCaseFieldGet: + TypedTree.Expr * TypedTree.TyconRef * int * Range.range -> TypedTree.Expr + val mkExnCaseFieldSet: + TypedTree.Expr * TypedTree.TyconRef * int * TypedTree.Expr * Range.range -> + TypedTree.Expr + val mkDummyLambda: + g:TcGlobals.TcGlobals -> + e:TypedTree.Expr * ety:TypedTree.TType -> TypedTree.Expr + val mkWhile: + TcGlobals.TcGlobals -> + SyntaxTree.DebugPointAtWhile * TypedTree.SpecialWhileLoopMarker * + TypedTree.Expr * TypedTree.Expr * Range.range -> TypedTree.Expr + val mkFor: + TcGlobals.TcGlobals -> + SyntaxTree.DebugPointAtFor * TypedTree.Val * TypedTree.Expr * + TypedTree.ForLoopStyle * TypedTree.Expr * TypedTree.Expr * Range.range -> + TypedTree.Expr + val mkTryWith: + TcGlobals.TcGlobals -> + TypedTree.Expr * TypedTree.Val * TypedTree.Expr * TypedTree.Val * + TypedTree.Expr * Range.range * TypedTree.TType * + SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith -> + TypedTree.Expr + val mkTryFinally: + TcGlobals.TcGlobals -> + TypedTree.Expr * TypedTree.Expr * Range.range * TypedTree.TType * + SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally -> + TypedTree.Expr + val mkDefault: Range.range * TypedTree.TType -> TypedTree.Expr + val mkValSet: + Range.range -> TypedTree.ValRef -> TypedTree.Expr -> TypedTree.Expr + val mkAddrSet: + Range.range -> TypedTree.ValRef -> TypedTree.Expr -> TypedTree.Expr + val mkAddrGet: Range.range -> TypedTree.ValRef -> TypedTree.Expr + val mkValAddr: + Range.range -> readonly:bool -> TypedTree.ValRef -> TypedTree.Expr + [] + type ValHash<'T> = + | ValHash of System.Collections.Generic.Dictionary + with + static member Create: unit -> ValHash<'T> + member Add: TypedTree.Val * 'T -> unit + member TryFind: TypedTree.Val -> 'T option + member Values: seq<'T> + + [] + type ValMultiMap<'T> = + + new: contents:TypedTree.StampMap<'T list> -> ValMultiMap<'T> + member Add: TypedTree.Val * 'T -> ValMultiMap<'T> + member ContainsKey: TypedTree.Val -> bool + member Find: TypedTree.Val -> 'T list + member Remove: TypedTree.Val -> ValMultiMap<'T> + member Contents: TypedTree.StampMap<'T list> + static member Empty: ValMultiMap<'T> + + [] + type TyconRefMultiMap<'T> = + + new: contents:TyconRefMap<'T list> -> TyconRefMultiMap<'T> + static member + OfList: (TypedTree.TyconRef * 'T) list -> TyconRefMultiMap<'T> + member Add: TypedTree.TyconRef * 'T -> TyconRefMultiMap<'T> + member Find: TypedTree.TyconRef -> 'T list + static member Empty: TyconRefMultiMap<'T> + + val tryRescopeEntity: + TypedTree.CcuThunk -> TypedTree.Entity -> ValueOption + val tryRescopeVal: + TypedTree.CcuThunk -> + Remap -> TypedTree.Val -> ValueOption + val actualTyOfRecdField: + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.RecdField -> TypedTree.TType + val actualTysOfRecdFields: + inst:(TypedTree.Typar * TypedTree.TType) list -> + rfields:TypedTree.RecdField list -> TypedTree.TType list + val actualTysOfInstanceRecdFields: + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.TyconRef -> TypedTree.TType list + val actualTysOfUnionCaseFields: + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.UnionCaseRef -> TypedTree.TType list + val actualResultTyOfUnionCase: + TypedTree.TType list -> TypedTree.UnionCaseRef -> TypedTree.TType + val recdFieldsOfExnDefRef: TypedTree.TyconRef -> TypedTree.RecdField list + val recdFieldOfExnDefRefByIdx: + x:TypedTree.TyconRef -> n:int -> TypedTree.RecdField + val recdFieldTysOfExnDefRef: TypedTree.TyconRef -> TypedTree.TType list + val recdFieldTyOfExnDefRefByIdx: + x:TypedTree.TyconRef -> j:int -> TypedTree.TType + val actualTyOfRecdFieldForTycon: + TypedTree.Tycon -> + TypedTree.TType list -> TypedTree.RecdField -> TypedTree.TType + val actualTyOfRecdFieldRef: + TypedTree.RecdFieldRef -> TypedTree.TType list -> TypedTree.TType + val actualTyOfUnionFieldRef: + fref:TypedTree.UnionCaseRef -> + n:int -> tinst:TypedTree.TType list -> TypedTree.TType + val destForallTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.Typar list * TypedTree.TType + val tryDestForallTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.Typar list * TypedTree.TType + val stripFunTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType list * TypedTree.TType + val applyForallTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType list -> TypedTree.TType + val reduceIteratedFunTy: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> args:'a list -> TypedTree.TType + val applyTyArgs: + g:TcGlobals.TcGlobals -> + functy:TypedTree.TType -> tyargs:TypedTree.TType list -> TypedTree.TType + val applyTys: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType list * 'T list -> TypedTree.TType + val formalApplyTys: + g:TcGlobals.TcGlobals -> + functy:TypedTree.TType -> + tyargs:'a list * args:'b list -> TypedTree.TType + val stripFunTyN: + TcGlobals.TcGlobals -> + int -> TypedTree.TType -> TypedTree.TType list * TypedTree.TType + val tryDestAnyTupleTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TupInfo * TypedTree.TTypes + val tryDestRefTupleTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes + type UncurriedArgInfos = (TypedTree.TType * TypedTree.ArgReprInfo) list + type CurriedArgInfos = (TypedTree.TType * TypedTree.ArgReprInfo) list list + type TraitWitnessInfos = TypedTree.TraitWitnessInfo list + val GetTopTauTypeInFSharpForm: + TcGlobals.TcGlobals -> + TypedTree.ArgReprInfo list list -> + TypedTree.TType -> + Range.range -> + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType + val destTopForallTy: + TcGlobals.TcGlobals -> + TypedTree.ValReprInfo -> + TypedTree.TType -> TypedTree.Typar list * TypedTree.TType + val GetTopValTypeInFSharpForm: + TcGlobals.TcGlobals -> + TypedTree.ValReprInfo -> + TypedTree.TType -> + Range.range -> + TypedTree.Typar list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType * TypedTree.ArgReprInfo + val IsCompiledAsStaticProperty: + TcGlobals.TcGlobals -> TypedTree.Val -> bool + val IsCompiledAsStaticPropertyWithField: + TcGlobals.TcGlobals -> TypedTree.Val -> bool + val isArrayTyconRef: TcGlobals.TcGlobals -> TypedTree.EntityRef -> bool + val rankOfArrayTyconRef: TcGlobals.TcGlobals -> TypedTree.EntityRef -> int + val destArrayTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val destListTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val tyconRefEqOpt: + g:TcGlobals.TcGlobals -> + tcOpt:TypedTree.EntityRef option -> tc:TypedTree.EntityRef -> bool + val isStringTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isListTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isArrayTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isArray1DTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isUnitTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isObjTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isValueTypeTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isVoidTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isILAppTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isNativePtrTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isInByrefTag: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isInByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isOutByrefTag: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isOutByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val extensionInfoOfTy: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> TypedTree.TyconRepresentation + type TypeDefMetadata = + | ILTypeMetadata of TypedTree.TILObjectReprData + | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata + | ProvidedTypeMetadata of TypedTree.TProvidedTypeInfo + val metadataOfTycon: TypedTree.Tycon -> TypeDefMetadata + val metadataOfTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypeDefMetadata + val isILReferenceTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isILInterfaceTycon: tycon:TypedTree.Tycon -> bool + val rankOfArrayTy: TcGlobals.TcGlobals -> TypedTree.TType -> int + val isFSharpObjModelRefTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isFSharpClassTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isFSharpStructTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isFSharpInterfaceTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isDelegateTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isInterfaceTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isClassTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isStructOrEnumTyconTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isStructRecordOrUnionTyconTy: + TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isStructTyconRef: tcref:TypedTree.TyconRef -> bool + val isStructTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isRefTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isForallFunctionTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isUnmanagedTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isInterfaceTycon: x:TypedTree.Tycon -> bool + val isInterfaceTyconRef: TypedTree.TyconRef -> bool + val isEnumTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val actualReturnTyOfSlotSig: + TypedTree.TType list -> + TypedTree.TType list -> TypedTree.SlotSig -> TypedTree.TType option + val slotSigHasVoidReturnTy: TypedTree.SlotSig -> bool + val returnTyOfMethod: + TcGlobals.TcGlobals -> TypedTree.ObjExprMethod -> TypedTree.TType option + val isAbstractTycon: TypedTree.Tycon -> bool + val MemberIsExplicitImpl: + TcGlobals.TcGlobals -> TypedTree.ValMemberInfo -> bool + val ValIsExplicitImpl: TcGlobals.TcGlobals -> TypedTree.Val -> bool + val ValRefIsExplicitImpl: TcGlobals.TcGlobals -> TypedTree.ValRef -> bool + val emptyFreeLocals: AbstractIL.Internal.Zset + val unionFreeLocals: + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset + val emptyFreeRecdFields: AbstractIL.Internal.Zset + val unionFreeRecdFields: + s1:AbstractIL.Internal.Zset -> + s2:AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset + val emptyFreeUnionCases: AbstractIL.Internal.Zset + val unionFreeUnionCases: + s1:AbstractIL.Internal.Zset -> + s2:AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset + val emptyFreeTycons: AbstractIL.Internal.Zset + val unionFreeTycons: + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset + val typarOrder: System.Collections.Generic.IComparer + val emptyFreeTypars: AbstractIL.Internal.Zset + val unionFreeTypars: + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset + val emptyFreeTyvars: TypedTree.FreeTyvars + val isEmptyFreeTyvars: TypedTree.FreeTyvars -> bool + val unionFreeTyvars: + TypedTree.FreeTyvars -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars + type FreeVarOptions = + { canCache: bool + collectInTypes: bool + includeLocalTycons: bool + includeTypars: bool + includeLocalTyconReprs: bool + includeRecdFields: bool + includeUnionCases: bool + includeLocals: bool } + val CollectAllNoCaching: FreeVarOptions + val CollectTyparsNoCaching: FreeVarOptions + val CollectLocalsNoCaching: FreeVarOptions + val CollectTyparsAndLocalsNoCaching: FreeVarOptions + val CollectAll: FreeVarOptions + val CollectTyparsAndLocals: FreeVarOptions + val CollectTypars: FreeVarOptions + val CollectLocals: FreeVarOptions + val accFreeLocalTycon: + opts:FreeVarOptions -> + x:TypedTree.Tycon -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeTycon: + opts:FreeVarOptions -> + tcref:TypedTree.TyconRef -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val boundTypars: + opts:FreeVarOptions -> + tps:TypedTree.Typar list -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTyparConstraints: + opts:FreeVarOptions -> + cxs:TypedTree.TyparConstraint list -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTyparConstraint: + opts:FreeVarOptions -> + tpc:TypedTree.TyparConstraint -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTrait: + opts:FreeVarOptions -> + TypedTree.TraitConstraintInfo -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInWitnessArg: + opts:FreeVarOptions -> + TypedTree.TraitWitnessInfo -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTraitSln: + opts:FreeVarOptions -> + sln:TypedTree.TraitConstraintSln -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeLocalValInTraitSln: + _opts:'a -> + v:TypedTree.Val -> fvs:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeValRefInTraitSln: + opts:FreeVarOptions -> + vref:TypedTree.ValRef -> + fvs:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeTyparRef: + opts:FreeVarOptions -> + tp:TypedTree.Typar -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInType: + FreeVarOptions -> + TypedTree.TType -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTupInfo: + _opts:FreeVarOptions -> + unt:TypedTree.TupInfo -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInMeasure: + opts:FreeVarOptions -> + unt:TypedTree.Measure -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTypes: + FreeVarOptions -> + TypedTree.TTypes -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val freeInType: FreeVarOptions -> TypedTree.TType -> TypedTree.FreeTyvars + val accFreeInVal: + opts:FreeVarOptions -> + v:TypedTree.Val -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val freeInTypes: FreeVarOptions -> TypedTree.TTypes -> TypedTree.FreeTyvars + val freeInVal: FreeVarOptions -> TypedTree.Val -> TypedTree.FreeTyvars + val freeInTyparConstraints: + opts:FreeVarOptions -> + v:TypedTree.TyparConstraint list -> TypedTree.FreeTyvars + val accFreeInTypars: + FreeVarOptions -> + TypedTree.Typar list -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val addFreeInModuleTy: + mtyp:TypedTree.ModuleOrNamespaceType -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val freeInModuleTy: TypedTree.ModuleOrNamespaceType -> TypedTree.FreeTyvars + val emptyFreeTyparsLeftToRight: 'a list + val unionFreeTyparsLeftToRight: + fvs1:TypedTree.Typar list -> + fvs2:TypedTree.Typar list -> TypedTree.Typar list + val boundTyparsLeftToRight: + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + tps:TypedTree.Typar list -> TypedTree.Typar list + val accFreeInTyparConstraintsLeftToRight: + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + cxs:TypedTree.TyparConstraint list -> TypedTree.Typar list + val accFreeInTyparConstraintLeftToRight: + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + tpc:TypedTree.TyparConstraint -> TypedTree.Typar list + val accFreeInTraitLeftToRight: + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + TypedTree.TraitConstraintInfo -> TypedTree.Typar list + val accFreeTyparRefLeftToRight: + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + tp:TypedTree.Typar -> TypedTree.Typar list + val accFreeInTypeLeftToRight: + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + ty:TypedTree.TType -> TypedTree.Typar list + val accFreeInTupInfoLeftToRight: + _g:TcGlobals.TcGlobals -> + _cxFlag:bool -> + _thruFlag:bool -> + acc:TypedTree.Typar list -> + unt:TypedTree.TupInfo -> TypedTree.Typar list + val accFreeInTypesLeftToRight: + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + tys:TypedTree.TTypes -> TypedTree.Typar list + val freeInTypeLeftToRight: + TcGlobals.TcGlobals -> bool -> TypedTree.TType -> TypedTree.Typar list + val freeInTypesLeftToRight: + TcGlobals.TcGlobals -> bool -> TypedTree.TTypes -> TypedTree.Typar list + val freeInTypesLeftToRightSkippingConstraints: + TcGlobals.TcGlobals -> TypedTree.TTypes -> TypedTree.Typar list + val valOfBind: b:TypedTree.Binding -> TypedTree.Val + val valsOfBinds: TypedTree.Bindings -> TypedTree.Val list + val GetMemberTypeInFSharpForm: + g:TcGlobals.TcGlobals -> + memberFlags:SyntaxTree.MemberFlags -> + arities:TypedTree.ValReprInfo -> + ty:TypedTree.TType -> + m:Range.range -> + TypedTree.Typar list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType * TypedTree.ArgReprInfo + val checkMemberVal: + membInfo:'a option -> arity:'b option -> m:Range.range -> 'a * 'b + val checkMemberValRef: + vref:TypedTree.ValRef -> TypedTree.ValMemberInfo * TypedTree.ValReprInfo + val GetTraitConstraintInfosOfTypars: + TcGlobals.TcGlobals -> + TypedTree.Typars -> TypedTree.TraitConstraintInfo list + val GetTraitWitnessInfosOfTypars: + TcGlobals.TcGlobals -> + numParentTypars:int -> + typars:TypedTree.Typar list -> TypedTree.TraitWitnessInfo list + val CountEnclosingTyparsOfActualParentOfVal: TypedTree.Val -> int + val GetTopValTypeInCompiledForm: + TcGlobals.TcGlobals -> + TypedTree.ValReprInfo -> + int -> + TypedTree.TType -> + Range.range -> + TypedTree.Typar list * TypedTree.TraitWitnessInfo list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType option * TypedTree.ArgReprInfo + val GetMemberTypeInMemberForm: + TcGlobals.TcGlobals -> + SyntaxTree.MemberFlags -> + TypedTree.ValReprInfo -> + int -> + TypedTree.TType -> + Range.range -> + TypedTree.Typar list * TypedTree.TraitWitnessInfo list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType option * TypedTree.ArgReprInfo + val GetTypeOfMemberInMemberForm: + TcGlobals.TcGlobals -> + TypedTree.ValRef -> + TypedTree.Typar list * TypedTree.TraitWitnessInfo list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType option * TypedTree.ArgReprInfo + val GetTypeOfMemberInFSharpForm: + TcGlobals.TcGlobals -> + TypedTree.ValRef -> + TypedTree.Typar list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * TypedTree.TType * + TypedTree.ArgReprInfo + val PartitionValTyparsForApparentEnclosingType: + TcGlobals.TcGlobals -> + TypedTree.Val -> + (TypedTree.Typars * TypedTree.Typar list * TypedTree.Typar list * + TyparInst * TypedTree.TType list) option + val PartitionValTypars: + TcGlobals.TcGlobals -> + TypedTree.Val -> + (TypedTree.Typar list * TypedTree.Typar list * TypedTree.Typar list * + TyparInst * TypedTree.TType list) option + val PartitionValRefTypars: + TcGlobals.TcGlobals -> + TypedTree.ValRef -> + (TypedTree.Typar list * TypedTree.Typar list * TypedTree.Typar list * + TyparInst * TypedTree.TType list) option + val ArgInfosOfMemberVal: + g:TcGlobals.TcGlobals -> + v:TypedTree.Val -> (TypedTree.TType * TypedTree.ArgReprInfo) list list + val ArgInfosOfMember: + TcGlobals.TcGlobals -> + TypedTree.ValRef -> (TypedTree.TType * TypedTree.ArgReprInfo) list list + val GetFSharpViewOfReturnType: + TcGlobals.TcGlobals -> TypedTree.TType option -> TypedTree.TType + val ReturnTypeOfPropertyVal: + TcGlobals.TcGlobals -> TypedTree.Val -> TypedTree.TType + val ArgInfosOfPropertyVal: + TcGlobals.TcGlobals -> + TypedTree.Val -> (TypedTree.TType * TypedTree.ArgReprInfo) list + val generalTyconRefInst: tc:TypedTree.TyconRef -> TypedTree.TType list + val generalizeTyconRef: + TypedTree.TyconRef -> TypedTree.TType list * TypedTree.TType + val generalizedTyconRef: TypedTree.TyconRef -> TypedTree.TType + val isTTyparSupportsStaticMethod: _arg1:TypedTree.TyparConstraint -> bool + val isTTyparCoercesToType: _arg1:TypedTree.TyparConstraint -> bool + val prefixOfStaticReq: SyntaxTree.TyparStaticReq -> string + val prefixOfRigidTypar: TypedTree.Typar -> string + type TyparConstraintsWithTypars = + (TypedTree.Typar * TypedTree.TyparConstraint) list + module PrettyTypes = + val newPrettyTypar: tp:TypedTree.Typar -> nm:string -> TypedTree.Typar + val NewPrettyTypars: + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.Typar list -> + string list -> + TypedTree.Typar list * (TypedTree.Typar * TypedTree.TType) list + val NeedsPrettyTyparName: TypedTree.Typar -> bool + val PrettyTyparNames: + (TypedTree.Typar -> bool) -> + string list -> TypedTree.Typar list -> string list + val PrettifyThings: + g:TcGlobals.TcGlobals -> + foldTys:((TypedTree.Typar list -> TypedTree.TType -> + TypedTree.Typar list) -> 'a list -> 'b -> + TypedTree.Typar list) -> + mapTys:((TypedTree.TType -> TypedTree.TType) -> 'b -> 'b) -> + things:'b -> + 'b * (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyType: + TcGlobals.TcGlobals -> + TypedTree.TType -> + TypedTree.TType * (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyTypePair: + TcGlobals.TcGlobals -> + TypedTree.TType * TypedTree.TType -> + (TypedTree.TType * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyTypes: + TcGlobals.TcGlobals -> + TypedTree.TType list -> + TypedTree.TType list * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyDiscriminantAndTypePairs: + TcGlobals.TcGlobals -> + ('Discriminant * TypedTree.TType) list -> + ('Discriminant * TypedTree.TType) list * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyCurriedTypes: + TcGlobals.TcGlobals -> + TypedTree.TType list list -> + TypedTree.TType list list * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyCurriedSigTypes: + TcGlobals.TcGlobals -> + TypedTree.TType list list * TypedTree.TType -> + (TypedTree.TType list list * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val safeDestAnyParTy: + orig:TypedTree.Typar -> + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.Typar + val tee: f:('a -> 'a -> 'b) -> x:'a -> 'b + val foldUnurriedArgInfos: + f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:UncurriedArgInfos -> 'a + val mapUnurriedArgInfos: + f:(TypedTree.TType -> 'a) -> + x:UncurriedArgInfos -> ('a * TypedTree.ArgReprInfo) list + val foldTypar: + f:('a -> TypedTree.TType -> 'b) -> z:'a -> x:TypedTree.Typar -> 'b + val mapTypar: + g:TcGlobals.TcGlobals -> + f:(TypedTree.TType -> TypedTree.TType) -> + x:TypedTree.Typar -> TypedTree.Typar + val foldTypars: + f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:TypedTree.Typars -> 'a + val mapTypars: + g:TcGlobals.TcGlobals -> + f:(TypedTree.TType -> TypedTree.TType) -> + x:TypedTree.Typars -> TypedTree.Typars + val foldTyparInst: + f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:TyparInst -> 'a + val mapTyparInst: + g:TcGlobals.TcGlobals -> + f:(TypedTree.TType -> TypedTree.TType) -> x:TyparInst -> TyparInst + val PrettifyInstAndTyparsAndType: + TcGlobals.TcGlobals -> + TyparInst * TypedTree.Typars * TypedTree.TType -> + (TyparInst * TypedTree.Typars * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInstAndUncurriedSig: + TcGlobals.TcGlobals -> + TyparInst * UncurriedArgInfos * TypedTree.TType -> + (TyparInst * UncurriedArgInfos * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInstAndCurriedSig: + TcGlobals.TcGlobals -> + TyparInst * TypedTree.TTypes * CurriedArgInfos * TypedTree.TType -> + (TyparInst * TypedTree.TType list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInstAndSig: + TcGlobals.TcGlobals -> + TyparInst * TypedTree.TType list * TypedTree.TType -> + (TyparInst * TypedTree.TType list * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInstAndTypes: + TcGlobals.TcGlobals -> + TyparInst * TypedTree.TType list -> + (TyparInst * TypedTree.TType list) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInstAndType: + TcGlobals.TcGlobals -> + TyparInst * TypedTree.TType -> + (TyparInst * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInst: + TcGlobals.TcGlobals -> + TyparInst -> + TyparInst * (TypedTree.Typar * TypedTree.TyparConstraint) list + + module SimplifyTypes = + val foldTypeButNotConstraints: + f:('a -> TypedTree.TType -> 'a) -> z:'a -> ty:TypedTree.TType -> 'a + val incM: + x:'a -> + m:AbstractIL.Internal.Zmap<'a,int> -> AbstractIL.Internal.Zmap<'a,int> + val accTyparCounts: + z:AbstractIL.Internal.Zmap -> + ty:TypedTree.TType -> AbstractIL.Internal.Zmap + val emptyTyparCounts: AbstractIL.Internal.Zmap + val accTyparCountsMulti: + acc:AbstractIL.Internal.Zmap -> + l:TypedTree.TType list -> + AbstractIL.Internal.Zmap + type TypeSimplificationInfo = + { singletons: AbstractIL.Internal.Zset + inplaceConstraints: + AbstractIL.Internal.Zmap + postfixConstraints: (TypedTree.Typar * TypedTree.TyparConstraint) list } + val typeSimplificationInfo0: TypeSimplificationInfo + val categorizeConstraints: + simplify:bool -> + m:AbstractIL.Internal.Zmap -> + cxs:(TypedTree.Typar * TypedTree.TyparConstraint) list -> + TypeSimplificationInfo + val CollectInfo: + bool -> + TypedTree.TType list -> + (TypedTree.Typar * TypedTree.TyparConstraint) list -> + TypeSimplificationInfo + + [] + type DisplayEnv = + { includeStaticParametersInTypeNames: bool + openTopPathsSorted: Lazy + openTopPathsRaw: string list list + shortTypeNames: bool + suppressNestedTypes: bool + maxMembers: int option + showObsoleteMembers: bool + showHiddenMembers: bool + showTyparBinding: bool + showImperativeTyparAnnotations: bool + suppressInlineKeyword: bool + suppressMutableKeyword: bool + showMemberContainers: bool + shortConstraints: bool + useColonForReturnType: bool + showAttributes: bool + showOverrides: bool + showConstraintTyparAnnotations: bool + abbreviateAdditionalConstraints: bool + showTyparDefaultConstraints: bool + shrinkOverloads: bool + printVerboseSignatures: bool + g: TcGlobals.TcGlobals + contextAccessibility: TypedTree.Accessibility + generatedValueLayout: TypedTree.Val -> Layout.layout option } + with + static member Empty: TcGlobals.TcGlobals -> DisplayEnv + member AddAccessibility: TypedTree.Accessibility -> DisplayEnv + member + AddOpenModuleOrNamespace: TypedTree.ModuleOrNamespaceRef -> + DisplayEnv + member AddOpenPath: string list -> DisplayEnv + member SetOpenPaths: string list list -> DisplayEnv + + val ( +.+ ): s1:string -> s2:string -> string + val layoutOfPath: + p:string list -> Internal.Utilities.StructuredFormat.Layout + val fullNameOfParentOfPubPath: pp:TypedTree.PublicPath -> string voption + val fullNameOfParentOfPubPathAsLayout: + pp:TypedTree.PublicPath -> + Internal.Utilities.StructuredFormat.Layout voption + val fullNameOfPubPath: TypedTree.PublicPath -> string + val fullNameOfPubPathAsLayout: + TypedTree.PublicPath -> Internal.Utilities.StructuredFormat.Layout + val fullNameOfParentOfNonLocalEntityRef: + nlr:TypedTree.NonLocalEntityRef -> string voption + val fullNameOfParentOfNonLocalEntityRefAsLayout: + nlr:TypedTree.NonLocalEntityRef -> + Internal.Utilities.StructuredFormat.Layout voption + val fullNameOfParentOfEntityRef: eref:TypedTree.EntityRef -> string voption + val fullNameOfParentOfEntityRefAsLayout: + eref:TypedTree.EntityRef -> + Internal.Utilities.StructuredFormat.Layout voption + val fullNameOfEntityRef: + nmF:(TypedTree.EntityRef -> string) -> xref:TypedTree.EntityRef -> string + val tagEntityRefName: + xref:TypedTree.EntityRef -> name:string -> Layout.TaggedText + val fullDisplayTextOfTyconRef: TypedTree.TyconRef -> string + val fullNameOfEntityRefAsLayout: + nmF:(TypedTree.EntityRef -> string) -> + xref:TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout + val fullNameOfParentOfValRef: vref:TypedTree.ValRef -> string voption + val fullNameOfParentOfValRefAsLayout: + vref:TypedTree.ValRef -> + Internal.Utilities.StructuredFormat.Layout voption + val fullDisplayTextOfParentOfModRef: TypedTree.EntityRef -> string voption + val fullDisplayTextOfModRef: TypedTree.EntityRef -> string + val fullDisplayTextOfTyconRefAsLayout: + TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout + val fullDisplayTextOfExnRef: TypedTree.EntityRef -> string + val fullDisplayTextOfExnRefAsLayout: + TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout + val fullDisplayTextOfUnionCaseRef: TypedTree.UnionCaseRef -> string + val fullDisplayTextOfRecdFieldRef: TypedTree.RecdFieldRef -> string + val fullDisplayTextOfValRef: TypedTree.ValRef -> string + val fullDisplayTextOfValRefAsLayout: + TypedTree.ValRef -> Internal.Utilities.StructuredFormat.Layout + val fullMangledPathToTyconRef: tcref:TypedTree.TyconRef -> string [] + val tyconRefToFullName: tc:TypedTree.TyconRef -> string + val qualifiedInterfaceImplementationNameAux: + g:TcGlobals.TcGlobals -> x:TypedTree.TType -> string + val qualifiedInterfaceImplementationName: + TcGlobals.TcGlobals -> TypedTree.TType -> string -> string + val qualifiedMangledNameOfTyconRef: TypedTree.TyconRef -> string -> string + val firstEq: p1:'a list -> p2:'a list -> bool when 'a: equality + val firstRem: p1:'a list -> p2:'b list -> 'b list + val trimPathByDisplayEnv: DisplayEnv -> string list -> string + val superOfTycon: TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.TType + val isILAttribByName: + tencl:string list * tname:string -> attr:AbstractIL.IL.ILAttribute -> bool + val isILAttrib: + tref:AbstractIL.IL.ILTypeRef -> attr:AbstractIL.IL.ILAttribute -> bool + val HasILAttribute: + tref:AbstractIL.IL.ILTypeRef -> attrs:AbstractIL.IL.ILAttributes -> bool + val TryDecodeILAttribute: + TcGlobals.TcGlobals -> + AbstractIL.IL.ILTypeRef -> + AbstractIL.IL.ILAttributes -> + (AbstractIL.IL.ILAttribElem list * + AbstractIL.IL.ILAttributeNamedArg list) option + val IsMatchingFSharpAttribute: + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib -> bool + val HasFSharpAttribute: + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool + val findAttrib: + g:TcGlobals.TcGlobals -> + tref:TcGlobals.BuiltinAttribInfo -> + attrs:TypedTree.Attrib list -> TypedTree.Attrib + val TryFindFSharpAttribute: + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> + TypedTree.Attrib list -> TypedTree.Attrib option + val TryFindFSharpAttributeOpt: + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo option -> + TypedTree.Attrib list -> TypedTree.Attrib option + val HasFSharpAttributeOpt: + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo option -> TypedTree.Attrib list -> bool + val IsMatchingFSharpAttributeOpt: + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo option -> TypedTree.Attrib -> bool + val ( |ExtractAttribNamedArg|_| ): + string -> TypedTree.AttribNamedArg list -> TypedTree.AttribExpr option + val ( |AttribInt32Arg|_| ): TypedTree.AttribExpr -> int32 option + val ( |AttribInt16Arg|_| ): TypedTree.AttribExpr -> int16 option + val ( |AttribBoolArg|_| ): TypedTree.AttribExpr -> bool option + val ( |AttribStringArg|_| ): TypedTree.AttribExpr -> string option + val TryFindFSharpBoolAttributeWithDefault: + dflt:bool -> + g:TcGlobals.TcGlobals -> + nm:TcGlobals.BuiltinAttribInfo -> + attrs:TypedTree.Attrib list -> bool option + val TryFindFSharpBoolAttribute: + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool option + val TryFindFSharpBoolAttributeAssumeFalse: + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool option + val TryFindFSharpInt32Attribute: + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> int32 option + val TryFindFSharpStringAttribute: + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> string option + val TryFindILAttribute: + TcGlobals.BuiltinAttribInfo -> AbstractIL.IL.ILAttributes -> bool + val TryFindILAttributeOpt: + TcGlobals.BuiltinAttribInfo option -> AbstractIL.IL.ILAttributes -> bool + val TryBindTyconRefAttribute: + g:TcGlobals.TcGlobals -> + m:Range.range -> + TcGlobals.BuiltinAttribInfo -> + tcref:TypedTree.TyconRef -> + f1:(AbstractIL.IL.ILAttribElem list * + AbstractIL.IL.ILAttributeNamedArg list -> 'a option) -> + f2:(TypedTree.Attrib -> 'a option) -> + f3:(obj option list * (string * obj option) list -> 'a option) -> + 'a option + val TryFindTyconRefBoolAttribute: + TcGlobals.TcGlobals -> + Range.range -> + TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> bool option + val TryFindAttributeUsageAttribute: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool option + val TryFindTyconRefStringAttribute: + TcGlobals.TcGlobals -> + Range.range -> + TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> string option + val TyconRefHasAttribute: + TcGlobals.TcGlobals -> + Range.range -> TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> bool + val isByrefTyconRef: TcGlobals.TcGlobals -> TypedTree.TyconRef -> bool + val isByrefLikeTyconRef: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool + val isSpanLikeTyconRef: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool + val isByrefLikeTy: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val isSpanLikeTy: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val isSpanTyconRef: + g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool + val isSpanTy: TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val tryDestSpanTy: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + (TypedTree.TyconRef * TypedTree.TType) voption + val destSpanTy: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> struct (TypedTree.TyconRef * TypedTree.TType) + val isReadOnlySpanTyconRef: + g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool + val isReadOnlySpanTy: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val tryDestReadOnlySpanTy: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + (TypedTree.TyconRef * TypedTree.TType) voption + val destReadOnlySpanTy: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> struct (TypedTree.TyconRef * TypedTree.TType) + val destByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val ( |ByrefTy|_| ): + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option + val destNativePtrTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val isRefCellTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val destRefCellTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val StripSelfRefCell: + TcGlobals.TcGlobals * TypedTree.ValBaseOrThisInfo * TypedTree.TType -> + TypedTree.TType + val mkRefCellTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkLazyTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkPrintfFormatTy: + TcGlobals.TcGlobals -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.TType -> TypedTree.TType -> TypedTree.TType + val mkOptionTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkNullableTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkListTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val isOptionTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val tryDestOptionTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType voption + val destOptionTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val isNullableTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val tryDestNullableTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType voption + val destNullableTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val ( |NullableTy|_| ): + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option + val ( |StripNullableTy| ): + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val isLinqExpressionTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val tryDestLinqExpressionTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option + val destLinqExpressionTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkNoneCase: TcGlobals.TcGlobals -> TypedTree.UnionCaseRef + val mkSomeCase: TcGlobals.TcGlobals -> TypedTree.UnionCaseRef + val mkSome: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr + val mkNone: + TcGlobals.TcGlobals -> TypedTree.TType -> Range.range -> TypedTree.Expr + val mkOptionGetValueUnprovenViaAddr: + TcGlobals.TcGlobals -> + TypedTree.Expr -> TypedTree.TType -> Range.range -> TypedTree.Expr + type ValRef with + member IsDispatchSlot: bool + val ( |UnopExpr|_| ): + _g:'a -> expr:TypedTree.Expr -> (TypedTree.ValRef * TypedTree.Expr) option + val ( |BinopExpr|_| ): + _g:'a -> + expr:TypedTree.Expr -> + (TypedTree.ValRef * TypedTree.Expr * TypedTree.Expr) option + val ( |SpecificUnopExpr|_| ): + g:TcGlobals.TcGlobals -> + vrefReqd:TypedTree.ValRef -> + expr:TypedTree.Expr -> TypedTree.Expr option + val ( |SpecificBinopExpr|_| ): + g:TcGlobals.TcGlobals -> + vrefReqd:TypedTree.ValRef -> + expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option + val ( |EnumExpr|_| ): + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr option + val ( |BitwiseOrExpr|_| ): + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option + val ( |AttribBitwiseOrExpr|_| ): + TcGlobals.TcGlobals -> + TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option + val isUncheckedDefaultOfValRef: + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val isTypeOfValRef: g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val isSizeOfValRef: g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val isNameOfValRef: TcGlobals.TcGlobals -> TypedTree.ValRef -> bool + val isTypeDefOfValRef: + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val ( |UncheckedDefaultOfExpr|_| ): + g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> TypedTree.TType option + val ( |TypeOfExpr|_| ): + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option + val ( |SizeOfExpr|_| ): + g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> TypedTree.TType option + val ( |TypeDefOfExpr|_| ): + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option + val ( |NameOfExpr|_| ): + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option + val ( |SeqExpr|_| ): TcGlobals.TcGlobals -> TypedTree.Expr -> unit option + module DebugPrint = + val layoutRanges: bool ref + val squareAngleL: + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val angleL: + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val braceL: + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val braceBarL: + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val boolL: _arg1:bool -> Internal.Utilities.StructuredFormat.Layout + val intL: int -> Internal.Utilities.StructuredFormat.Layout + val int64L: n:int64 -> Internal.Utilities.StructuredFormat.Layout + val jlistL: + xL:('a -> Internal.Utilities.StructuredFormat.Layout) -> + xmap:Internal.Utilities.QueueList<'a> -> + Internal.Utilities.StructuredFormat.Layout + val bracketIfL: + x:bool -> + lyt:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val lvalopL: + x:TypedTree.LValueOperation -> + Internal.Utilities.StructuredFormat.Layout + val angleBracketL: + l:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val angleBracketListL: + l:Internal.Utilities.StructuredFormat.Layout list -> + Internal.Utilities.StructuredFormat.Layout + val layoutMemberFlags: + memFlags:SyntaxTree.MemberFlags -> + Internal.Utilities.StructuredFormat.Layout + val stampL: _n:'a -> w:'b -> 'b + val layoutTyconRef: + tc:TypedTree.TyconRef -> Internal.Utilities.StructuredFormat.Layout + val auxTypeL: + env:SimplifyTypes.TypeSimplificationInfo -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val auxTypeAtomL: + env:SimplifyTypes.TypeSimplificationInfo -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val auxTyparsL: + env:SimplifyTypes.TypeSimplificationInfo -> + tcL:Internal.Utilities.StructuredFormat.Layout -> + prefix:bool -> + tinst:TypedTree.TType list -> + Internal.Utilities.StructuredFormat.Layout + val auxTypeWrapL: + env:SimplifyTypes.TypeSimplificationInfo -> + isAtomic:bool -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val auxTyparWrapL: + env:SimplifyTypes.TypeSimplificationInfo -> + isAtomic:bool -> + typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val auxTypar2L: + env:SimplifyTypes.TypeSimplificationInfo -> + typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val auxTyparAtomL: + env:SimplifyTypes.TypeSimplificationInfo -> + typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val auxTyparConstraintTypL: + env:SimplifyTypes.TypeSimplificationInfo -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val auxTraitL: + env:SimplifyTypes.TypeSimplificationInfo -> + ttrait:TypedTree.TraitConstraintInfo -> + Internal.Utilities.StructuredFormat.Layout + val auxTyparConstraintL: + env:SimplifyTypes.TypeSimplificationInfo -> + tp:TypedTree.Typar * tpc:TypedTree.TyparConstraint -> + Internal.Utilities.StructuredFormat.Layout + val auxTyparConstraintsL: + env:SimplifyTypes.TypeSimplificationInfo -> + x:(TypedTree.Typar * TypedTree.TyparConstraint) list -> + Internal.Utilities.StructuredFormat.Layout + val typarL: TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val typarAtomL: + tp:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val typeAtomL: + tau:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val typeL: TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val typarDeclL: + TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val layoutTyparDecls: + tps:TypedTree.Typars -> Internal.Utilities.StructuredFormat.Layout + val rangeL: m:Range.range -> Internal.Utilities.StructuredFormat.Layout + val instL: + tyL:('a -> Internal.Utilities.StructuredFormat.Layout) -> + tys:'a list -> Internal.Utilities.StructuredFormat.Layout + val valRefL: + TypedTree.ValRef -> Internal.Utilities.StructuredFormat.Layout + val layoutAttrib: + TypedTree.Attrib -> Internal.Utilities.StructuredFormat.Layout + val layoutAttribs: + attribs:TypedTree.Attrib list -> + Internal.Utilities.StructuredFormat.Layout + val arityInfoL: + TypedTree.ValReprInfo -> Internal.Utilities.StructuredFormat.Layout + val valL: TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout + val typeOfValL: + TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout + val tslotparamL: + TypedTree.SlotParam -> Internal.Utilities.StructuredFormat.Layout + val slotSigL: + TypedTree.SlotSig -> Internal.Utilities.StructuredFormat.Layout + val memberL: + g:TcGlobals.TcGlobals -> + v:TypedTree.Val -> + membInfo:TypedTree.ValMemberInfo -> + Internal.Utilities.StructuredFormat.Layout + val valAtBindL: + TcGlobals.TcGlobals -> + TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout + val unionCaseRefL: + TypedTree.UnionCaseRef -> Internal.Utilities.StructuredFormat.Layout + val recdFieldRefL: + TypedTree.RecdFieldRef -> Internal.Utilities.StructuredFormat.Layout + val identL: + id:SyntaxTree.Ident -> Internal.Utilities.StructuredFormat.Layout + val constL: + c:TypedTree.Const -> Internal.Utilities.StructuredFormat.Layout + val tyconL: + TcGlobals.TcGlobals -> + TypedTree.Tycon -> Internal.Utilities.StructuredFormat.Layout + val bindingL: + TcGlobals.TcGlobals -> + TypedTree.Binding -> Internal.Utilities.StructuredFormat.Layout + val exprL: + TcGlobals.TcGlobals -> + TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout + val atomL: + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout + val letRecL: + g:TcGlobals.TcGlobals -> + binds:TypedTree.Binding list -> + bodyL:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val letL: + g:TcGlobals.TcGlobals -> + bind:TypedTree.Binding -> + bodyL:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val exprWrapL: + g:TcGlobals.TcGlobals -> + isAtomic:bool -> + expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout + val implFilesL: + TcGlobals.TcGlobals -> + TypedTree.TypedImplFile list -> + Internal.Utilities.StructuredFormat.Layout + val appL: + g:TcGlobals.TcGlobals -> + flayout:Internal.Utilities.StructuredFormat.Layout -> + tys:TypedTree.TypeInst -> + args:TypedTree.Exprs -> Internal.Utilities.StructuredFormat.Layout + val implFileL: + TcGlobals.TcGlobals -> + TypedTree.TypedImplFile -> Internal.Utilities.StructuredFormat.Layout + val mexprL: + g:TcGlobals.TcGlobals -> + x:TypedTree.ModuleOrNamespaceExprWithSig -> + Internal.Utilities.StructuredFormat.Layout + val mdefsL: + g:TcGlobals.TcGlobals -> + defs:TypedTree.ModuleOrNamespaceExpr list -> + Internal.Utilities.StructuredFormat.Layout + val mdefL: + g:TcGlobals.TcGlobals -> + x:TypedTree.ModuleOrNamespaceExpr -> + Internal.Utilities.StructuredFormat.Layout + val mbindL: + g:TcGlobals.TcGlobals -> + x:TypedTree.ModuleOrNamespaceBinding -> + Internal.Utilities.StructuredFormat.Layout + val entityTypeL: + TcGlobals.TcGlobals -> + TypedTree.ModuleOrNamespaceType -> + Internal.Utilities.StructuredFormat.Layout + val entityL: + TcGlobals.TcGlobals -> + TypedTree.ModuleOrNamespace -> + Internal.Utilities.StructuredFormat.Layout + val ccuL: + g:TcGlobals.TcGlobals -> + ccu:TypedTree.CcuThunk -> Internal.Utilities.StructuredFormat.Layout + val decisionTreeL: + TcGlobals.TcGlobals -> + TypedTree.DecisionTree -> Internal.Utilities.StructuredFormat.Layout + val dcaseL: + g:TcGlobals.TcGlobals -> + TypedTree.DecisionTreeCase -> + Internal.Utilities.StructuredFormat.Layout + val dtestL: + g:TcGlobals.TcGlobals -> + x:TypedTree.DecisionTreeTest -> + Internal.Utilities.StructuredFormat.Layout + val targetL: + g:TcGlobals.TcGlobals -> + i:int -> + TypedTree.DecisionTreeTarget -> + Internal.Utilities.StructuredFormat.Layout + val flatValsL: + vs:TypedTree.Val list -> Internal.Utilities.StructuredFormat.Layout list + val tmethodL: + g:TcGlobals.TcGlobals -> + TypedTree.ObjExprMethod -> Internal.Utilities.StructuredFormat.Layout + val iimplL: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType * tmeths:TypedTree.ObjExprMethod list -> + Internal.Utilities.StructuredFormat.Layout + val showType: TypedTree.TType -> string + val showExpr: TcGlobals.TcGlobals -> TypedTree.Expr -> string + val traitL: + TypedTree.TraitConstraintInfo -> + Internal.Utilities.StructuredFormat.Layout + val typarsL: + TypedTree.Typars -> Internal.Utilities.StructuredFormat.Layout + + val wrapModuleOrNamespaceType: + SyntaxTree.Ident -> + TypedTree.CompilationPath -> + TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespace + val wrapModuleOrNamespaceTypeInNamespace: + SyntaxTree.Ident -> + TypedTree.CompilationPath -> + TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType * TypedTree.ModuleOrNamespace + val wrapModuleOrNamespaceExprInNamespace: + SyntaxTree.Ident -> + TypedTree.CompilationPath -> + TypedTree.ModuleOrNamespaceExpr -> TypedTree.ModuleOrNamespaceExpr + val SigTypeOfImplFile: + TypedTree.TypedImplFile -> TypedTree.ModuleOrNamespaceType + type SignatureRepackageInfo = + { RepackagedVals: (TypedTree.ValRef * TypedTree.ValRef) list + RepackagedEntities: (TypedTree.TyconRef * TypedTree.TyconRef) list } + with + member ImplToSigMapping: TypeEquivEnv + static member Empty: SignatureRepackageInfo + + type SignatureHidingInfo = + { HiddenTycons: AbstractIL.Internal.Zset + HiddenTyconReprs: AbstractIL.Internal.Zset + HiddenVals: AbstractIL.Internal.Zset + HiddenRecdFields: AbstractIL.Internal.Zset + HiddenUnionCases: AbstractIL.Internal.Zset } + with + static member Empty: SignatureHidingInfo + + val addValRemap: TypedTree.Val -> TypedTree.Val -> Remap -> Remap + val mkRepackageRemapping: SignatureRepackageInfo -> Remap + val accEntityRemap: + msigty:TypedTree.ModuleOrNamespaceType -> + entity:TypedTree.Entity -> + mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accSubEntityRemap: + msigty:TypedTree.ModuleOrNamespaceType -> + entity:TypedTree.Entity -> + mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val valLinkageAEquiv: + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.Val -> TypedTree.Val -> bool + val accValRemap: + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + msigty:TypedTree.ModuleOrNamespaceType -> + implVal:TypedTree.Val -> + mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val getCorrespondingSigTy: + nm:string -> + msigty:TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType + val accEntityRemapFromModuleOrNamespaceType: + mty:TypedTree.ModuleOrNamespaceType -> + msigty:TypedTree.ModuleOrNamespaceType -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accValRemapFromModuleOrNamespaceType: + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + mty:TypedTree.ModuleOrNamespaceType -> + msigty:TypedTree.ModuleOrNamespaceType -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val ComputeRemappingFromInferredSignatureToExplicitSignature: + TcGlobals.TcGlobals -> + TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType -> + SignatureRepackageInfo * SignatureHidingInfo + val abstractSlotValRefsOfTycons: + TypedTree.Tycon list -> TypedTree.ValRef list + val abstractSlotValsOfTycons: TypedTree.Tycon list -> TypedTree.Val list + val accEntityRemapFromModuleOrNamespace: + msigty:TypedTree.ModuleOrNamespaceType -> + x:TypedTree.ModuleOrNamespaceExpr -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accEntityRemapFromModuleOrNamespaceDefs: + msigty:TypedTree.ModuleOrNamespaceType -> + mdefs:TypedTree.ModuleOrNamespaceExpr list -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accEntityRemapFromModuleOrNamespaceBind: + msigty:TypedTree.ModuleOrNamespaceType -> + x:TypedTree.ModuleOrNamespaceBinding -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accValRemapFromModuleOrNamespace: + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + msigty:TypedTree.ModuleOrNamespaceType -> + x:TypedTree.ModuleOrNamespaceExpr -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accValRemapFromModuleOrNamespaceBind: + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + msigty:TypedTree.ModuleOrNamespaceType -> + x:TypedTree.ModuleOrNamespaceBinding -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accValRemapFromModuleOrNamespaceDefs: + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + msigty:TypedTree.ModuleOrNamespaceType -> + mdefs:TypedTree.ModuleOrNamespaceExpr list -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val ComputeRemappingFromImplementationToSignature: + TcGlobals.TcGlobals -> + TypedTree.ModuleOrNamespaceExpr -> + TypedTree.ModuleOrNamespaceType -> + SignatureRepackageInfo * SignatureHidingInfo + val accTyconHidingInfoAtAssemblyBoundary: + tycon:TypedTree.Tycon -> mhi:SignatureHidingInfo -> SignatureHidingInfo + val accValHidingInfoAtAssemblyBoundary: + vspec:TypedTree.Val -> mhi:SignatureHidingInfo -> SignatureHidingInfo + val accModuleOrNamespaceHidingInfoAtAssemblyBoundary: + mty:TypedTree.ModuleOrNamespaceType -> + acc:SignatureHidingInfo -> SignatureHidingInfo + val ComputeHidingInfoAtAssemblyBoundary: + TypedTree.ModuleOrNamespaceType -> + SignatureHidingInfo -> SignatureHidingInfo + val IsHidden: + setF:('a -> AbstractIL.Internal.Zset<'b>) -> + accessF:('b -> TypedTree.Accessibility) -> + remapF:('c -> 'b -> 'b) -> (('c * 'a) list -> 'b -> bool) + val IsHiddenTycon: + (Remap * SignatureHidingInfo) list -> TypedTree.Tycon -> bool + val IsHiddenTyconRepr: + (Remap * SignatureHidingInfo) list -> TypedTree.Tycon -> bool + val IsHiddenVal: + (Remap * SignatureHidingInfo) list -> TypedTree.Val -> bool + val IsHiddenRecdField: + (Remap * SignatureHidingInfo) list -> TypedTree.RecdFieldRef -> bool + val foldModuleOrNamespaceTy: + ft:(TypedTree.Entity -> 'a -> 'a) -> + fv:(TypedTree.Val -> 'a -> 'a) -> + mty:TypedTree.ModuleOrNamespaceType -> acc:'a -> 'a + val allValsOfModuleOrNamespaceTy: + m:TypedTree.ModuleOrNamespaceType -> TypedTree.Val list + val allEntitiesOfModuleOrNamespaceTy: + m:TypedTree.ModuleOrNamespaceType -> TypedTree.Entity list + val isPublicVal: lv:TypedTree.Val -> bool + val isPublicUnionCase: ucr:TypedTree.UnionCaseRef -> bool + val isPublicRecdField: rfr:TypedTree.RecdFieldRef -> bool + val isPublicTycon: tcref:TypedTree.Tycon -> bool + val freeVarsAllPublic: TypedTree.FreeVars -> bool + val freeTyvarsAllPublic: TypedTree.FreeTyvars -> bool + val ( |LinearMatchExpr|_| ): + TypedTree.Expr -> + (SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * + TypedTree.DecisionTreeTarget * TypedTree.Expr * + SyntaxTree.DebugPointForTarget * Range.range * TypedTree.TType) option + val rebuildLinearMatchExpr: + (SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * + TypedTree.DecisionTreeTarget * TypedTree.Expr * + SyntaxTree.DebugPointForTarget * Range.range * TypedTree.TType) -> + TypedTree.Expr + val ( |LinearOpExpr|_| ): + TypedTree.Expr -> + (TypedTree.TOp * TypedTree.TypeInst * TypedTree.Expr list * + TypedTree.Expr * Range.range) option + val rebuildLinearOpExpr: + (TypedTree.TOp * TypedTree.TypeInst * TypedTree.Expr list * TypedTree.Expr * + Range.range) -> TypedTree.Expr + val emptyFreeVars: TypedTree.FreeVars + val unionFreeVars: + TypedTree.FreeVars -> TypedTree.FreeVars -> TypedTree.FreeVars + val inline accFreeTyvars: + opts:FreeVarOptions -> + f:(FreeVarOptions -> 'a -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars) -> + v:'a -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeVarsInTy: + opts:FreeVarOptions -> + ty:TypedTree.TType -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeVarsInTys: + opts:FreeVarOptions -> + tys:TypedTree.TType list -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreevarsInTycon: + opts:FreeVarOptions -> + tcref:TypedTree.TyconRef -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreevarsInVal: + opts:FreeVarOptions -> + v:TypedTree.Val -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeVarsInTraitSln: + opts:FreeVarOptions -> + tys:TypedTree.TraitConstraintSln -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeVarsInTraitInfo: + opts:FreeVarOptions -> + tys:TypedTree.TraitConstraintInfo -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val boundLocalVal: + opts:FreeVarOptions -> + v:TypedTree.Val -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val boundProtect: fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accUsesFunctionLocalConstructs: + flg:bool -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val bound_rethrow: fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accUsesRethrow: + flg:bool -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val boundLocalVals: + opts:FreeVarOptions -> + vs:TypedTree.Val list -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val bindLhs: + opts:FreeVarOptions -> + bind:TypedTree.Binding -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val freeVarsCacheCompute: + opts:FreeVarOptions -> cache:Lib.cache<'a> -> f:(unit -> 'a) -> 'a + val tryGetFreeVarsCacheValue: + opts:FreeVarOptions -> cache:Lib.cache<'a> -> Lib.NonNullSlot<'a> voption + val accBindRhs: + opts:FreeVarOptions -> + TypedTree.Binding -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInSwitchCases: + FreeVarOptions -> + TypedTree.DecisionTreeCase list -> + TypedTree.DecisionTree option -> + TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInSwitchCase: + opts:FreeVarOptions -> + TypedTree.DecisionTreeCase -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInTest: + opts:FreeVarOptions -> + discrim:TypedTree.DecisionTreeTest -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInDecisionTree: + FreeVarOptions -> + TypedTree.DecisionTree -> TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInValFlags: + opts:FreeVarOptions -> + flag:TypedTree.ValUseFlag -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeLocalVal: + opts:FreeVarOptions -> + v:TypedTree.Val -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accLocalTyconRepr: + opts:FreeVarOptions -> + b:TypedTree.Tycon -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accUsedRecdOrUnionTyconRepr: + opts:FreeVarOptions -> + tc:TypedTree.Tycon -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeUnionCaseRef: + opts:FreeVarOptions -> + ucref:TypedTree.UnionCaseRef -> + fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeRecdFieldRef: + opts:FreeVarOptions -> + rfref:TypedTree.RecdFieldRef -> + fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeExnRef: _exnc:'a -> fvs:'b -> 'b + val accFreeValRef: + opts:FreeVarOptions -> + vref:TypedTree.ValRef -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInMethod: + opts:FreeVarOptions -> + TypedTree.ObjExprMethod -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInMethods: + opts:FreeVarOptions -> + methods:TypedTree.ObjExprMethod list -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInInterfaceImpl: + opts:FreeVarOptions -> + ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInExpr: + opts:FreeVarOptions -> + x:TypedTree.Expr -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInExprLinear: + opts:FreeVarOptions -> + x:TypedTree.Expr -> + acc:TypedTree.FreeVars -> + contf:(TypedTree.FreeVars -> TypedTree.FreeVars) -> + TypedTree.FreeVars + val accFreeInExprNonLinear: + opts:FreeVarOptions -> + x:TypedTree.Expr -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInOp: + opts:FreeVarOptions -> + op:TypedTree.TOp -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInTargets: + FreeVarOptions -> + TypedTree.DecisionTreeTarget array -> + TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInTarget: + opts:FreeVarOptions -> + TypedTree.DecisionTreeTarget -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInFlatExprs: + opts:FreeVarOptions -> + exprs:TypedTree.Exprs -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInExprs: + FreeVarOptions -> + TypedTree.Exprs -> TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInSlotSig: + opts:FreeVarOptions -> + TypedTree.SlotSig -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val freeInDecisionTree: + opts:FreeVarOptions -> dtree:TypedTree.DecisionTree -> TypedTree.FreeVars + val freeInExpr: FreeVarOptions -> TypedTree.Expr -> TypedTree.FreeVars + val accFreeInModuleOrNamespace: + opts:FreeVarOptions -> + mexpr:TypedTree.ModuleOrNamespaceExpr -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInModuleOrNamespaceBind: + opts:FreeVarOptions -> + mbind:TypedTree.ModuleOrNamespaceBinding -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInModuleOrNamespaces: + opts:FreeVarOptions -> + mexprs:TypedTree.ModuleOrNamespaceExpr list -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val freeInBindingRhs: + FreeVarOptions -> TypedTree.Binding -> TypedTree.FreeVars + val freeInModuleOrNamespace: + FreeVarOptions -> TypedTree.ModuleOrNamespaceExpr -> TypedTree.FreeVars + val stripLambda: + expr:TypedTree.Expr * ty:TypedTree.TType -> + TypedTree.Val list list * TypedTree.Expr * TypedTree.TType + val stripLambdaN: + n:int -> + expr:TypedTree.Expr -> TypedTree.Val list list * TypedTree.Expr * int + val tryStripLambdaN: + n:int -> + expr:TypedTree.Expr -> (TypedTree.Val list list * TypedTree.Expr) option + val stripTopLambda: + TypedTree.Expr * TypedTree.TType -> + TypedTree.Typars * TypedTree.Val list list * TypedTree.Expr * + TypedTree.TType + [] + type AllowTypeDirectedDetupling = + | Yes + | No + val InferArityOfExpr: + TcGlobals.TcGlobals -> + AllowTypeDirectedDetupling -> + TypedTree.TType -> + TypedTree.Attrib list list list -> + TypedTree.Attribs -> TypedTree.Expr -> TypedTree.ValReprInfo + val InferArityOfExprBinding: + TcGlobals.TcGlobals -> + AllowTypeDirectedDetupling -> + TypedTree.Val -> TypedTree.Expr -> TypedTree.ValReprInfo + val underlyingTypeOfEnumTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val setValHasNoArity: TypedTree.Val -> TypedTree.Val + val normalizeEnumTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + type StaticOptimizationAnswer = + | Yes = 1y + | No = -1y + | Unknown = 0y + val decideStaticOptimizationConstraint: + g:TcGlobals.TcGlobals -> + c:TypedTree.StaticOptimization -> + haveWitnesses:bool -> StaticOptimizationAnswer + val DecideStaticOptimizations: + TcGlobals.TcGlobals -> + TypedTree.StaticOptimization list -> + haveWitnesses:bool -> StaticOptimizationAnswer + val mkStaticOptimizationExpr: + TcGlobals.TcGlobals -> + TypedTree.StaticOptimization list * TypedTree.Expr * TypedTree.Expr * + Range.range -> TypedTree.Expr + type ValCopyFlag = + | CloneAll + | CloneAllAndMarkExprValsAsCompilerGenerated + | OnlyCloneExprVals + val fixValCopyFlagForQuotations: _arg1:ValCopyFlag -> ValCopyFlag + val markAsCompGen: compgen:ValCopyFlag -> d:TypedTree.Val -> TypedTree.Val + val bindLocalVal: + v:TypedTree.Val -> v':TypedTree.Val -> tmenv:Remap -> Remap + val bindLocalVals: + vs:TypedTree.Val list -> vs':TypedTree.Val list -> tmenv:Remap -> Remap + val bindTycon: + tc:TypedTree.Tycon -> tc':TypedTree.Tycon -> tyenv:Remap -> Remap + val bindTycons: + tcs:Lib.NonNullSlot list -> + tcs':Lib.NonNullSlot list -> tyenv:Remap -> Remap + val remapAttribKind: + tmenv:Remap -> k:TypedTree.AttribKind -> TypedTree.AttribKind + val tmenvCopyRemapAndBindTypars: + remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> + tmenv:Remap -> tps:TypedTree.Typar list -> TypedTree.Typar list * Remap + val remapAttrib: + TcGlobals.TcGlobals -> Remap -> TypedTree.Attrib -> TypedTree.Attrib + val remapAttribExpr: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> TypedTree.AttribExpr -> TypedTree.AttribExpr + val remapAttribs: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> xs:TypedTree.Attrib list -> TypedTree.Attrib list + val remapPossibleForallTy: + TcGlobals.TcGlobals -> Remap -> TypedTree.TType -> TypedTree.TType + val remapArgData: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> argInfo:TypedTree.ArgReprInfo -> TypedTree.ArgReprInfo + val remapValReprInfo: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> TypedTree.ValReprInfo -> TypedTree.ValReprInfo + val remapValData: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> d:TypedTree.ValData -> TypedTree.ValData + val remapParentRef: + tyenv:Remap -> p:TypedTree.ParentRef -> TypedTree.ParentRef + val mapImmediateValsAndTycons: + ft:(TypedTree.Entity -> TypedTree.Entity) -> + fv:(TypedTree.Val -> TypedTree.Val) -> + x:TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespaceType + val copyVal: compgen:ValCopyFlag -> v:TypedTree.Val -> TypedTree.Val + val fixupValData: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> tmenv:Remap -> v2:TypedTree.Val -> unit + val copyAndRemapAndBindVals: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> vs:TypedTree.Val list -> TypedTree.Val list * Remap + val copyAndRemapAndBindVal: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> v:TypedTree.Val -> TypedTree.Val * Remap + val remapExpr: + TcGlobals.TcGlobals -> + ValCopyFlag -> Remap -> TypedTree.Expr -> TypedTree.Expr + val remapTarget: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + TypedTree.DecisionTreeTarget -> TypedTree.DecisionTreeTarget + val remapLinearExpr: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + expr:TypedTree.Expr -> + contf:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr + val remapConstraint: + tyenv:Remap -> + c:TypedTree.StaticOptimization -> TypedTree.StaticOptimization + val remapOp: tmenv:Remap -> op:TypedTree.TOp -> TypedTree.TOp + val remapValFlags: + tmenv:Remap -> x:TypedTree.ValUseFlag -> TypedTree.ValUseFlag + val remapExprs: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> es:TypedTree.Exprs -> TypedTree.Exprs + val remapFlatExprs: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> es:TypedTree.Expr list -> TypedTree.Expr list + val remapDecisionTree: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree + val copyAndRemapAndBindBinding: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> bind:TypedTree.Binding -> TypedTree.Binding * Remap + val copyAndRemapAndBindBindings: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> binds:TypedTree.Bindings -> TypedTree.Bindings * Remap + val remapAndRenameBinds: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenvinner:Remap -> + binds:TypedTree.Bindings -> + vs':TypedTree.Val list -> TypedTree.Bindings + val remapAndRenameBind: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenvinner:Remap -> + TypedTree.Binding -> v':TypedTree.Val -> TypedTree.Binding + val remapMethod: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod + val remapInterfaceImpl: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> + TypedTree.TType * TypedTree.ObjExprMethod list + val remapRecdField: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> x:TypedTree.RecdField -> TypedTree.RecdField + val remapRecdFields: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> x:TypedTree.TyconRecdFields -> TypedTree.TyconRecdFields + val remapUnionCase: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> x:TypedTree.UnionCase -> TypedTree.UnionCase + val remapUnionCases: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> x:TypedTree.TyconUnionData -> TypedTree.TyconUnionData + val remapFsObjData: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> + x:TypedTree.TyconObjModelData -> TypedTree.TyconObjModelData + val remapTyconRepr: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> + repr:TypedTree.TyconRepresentation -> TypedTree.TyconRepresentation + val remapTyconAug: + tmenv:Remap -> + x:TypedTree.TyconAugmentation -> TypedTree.TyconAugmentation + val remapTyconExnInfo: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> inp:TypedTree.ExceptionInfo -> TypedTree.ExceptionInfo + val remapMemberInfo: + g:TcGlobals.TcGlobals -> + m:Range.range -> + topValInfo:TypedTree.ValReprInfo option -> + ty:TypedTree.TType -> + ty':TypedTree.TType -> + tmenv:Remap -> + x:TypedTree.ValMemberInfo -> TypedTree.ValMemberInfo + val copyAndRemapAndBindModTy: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + mty:TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType * Remap + val remapModTy: + g:TcGlobals.TcGlobals -> + _compgen:ValCopyFlag -> + tmenv:Remap -> + mty:TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType + val renameTycon: + g:TcGlobals.TcGlobals -> + tyenv:Remap -> x:TypedTree.Entity -> TypedTree.Entity + val renameVal: tmenv:Remap -> x:TypedTree.Val -> TypedTree.Val + val copyTycon: + compgen:ValCopyFlag -> tycon:TypedTree.Tycon -> TypedTree.Tycon + val copyAndRemapAndBindTyconsAndVals: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + tycons:TypedTree.Entity list -> + vs:TypedTree.Val list -> + TypedTree.Tycon list * TypedTree.Val list * Remap + val allTyconsOfTycon: tycon:TypedTree.Tycon -> seq + val allEntitiesOfModDef: + mdef:TypedTree.ModuleOrNamespaceExpr -> seq + val allValsOfModDef: TypedTree.ModuleOrNamespaceExpr -> seq + val remapAndBindModuleOrNamespaceExprWithSig: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig * Remap + val remapModuleOrNamespaceExprWithSig: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig + val copyAndRemapModDef: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + mdef:TypedTree.ModuleOrNamespaceExpr -> + TypedTree.ModuleOrNamespaceExpr + val remapAndRenameModDefs: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + x:TypedTree.ModuleOrNamespaceExpr list -> + TypedTree.ModuleOrNamespaceExpr list + val remapAndRenameModDef: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + mdef:TypedTree.ModuleOrNamespaceExpr -> + TypedTree.ModuleOrNamespaceExpr + val remapAndRenameModBind: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + x:TypedTree.ModuleOrNamespaceBinding -> + TypedTree.ModuleOrNamespaceBinding + val remapImplFile: + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + mv:TypedTree.TypedImplFile -> TypedTree.TypedImplFile * Remap + val copyModuleOrNamespaceType: + TcGlobals.TcGlobals -> + ValCopyFlag -> + TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespaceType + val copyExpr: + TcGlobals.TcGlobals -> ValCopyFlag -> TypedTree.Expr -> TypedTree.Expr + val copyImplFile: + TcGlobals.TcGlobals -> + ValCopyFlag -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile + val instExpr: + TcGlobals.TcGlobals -> TyparInst -> TypedTree.Expr -> TypedTree.Expr + val remarkExpr: Range.range -> TypedTree.Expr -> TypedTree.Expr + val remarkObjExprMethod: + m:Range.range -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod + val remarkInterfaceImpl: + m:Range.range -> + ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> + TypedTree.TType * TypedTree.ObjExprMethod list + val remarkExprs: m:Range.range -> es:TypedTree.Exprs -> TypedTree.Exprs + val remarkFlatExprs: + m:Range.range -> es:TypedTree.Expr list -> TypedTree.Expr list + val remarkDecisionTree: + m:Range.range -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree + val remarkBinds: + m:Range.range -> binds:TypedTree.Bindings -> TypedTree.Bindings + val remarkBind: m:Range.range -> TypedTree.Binding -> TypedTree.Binding + val isRecdOrStructFieldDefinitelyMutable: f:TypedTree.RecdField -> bool + val isUnionCaseDefinitelyMutable: uc:TypedTree.UnionCase -> bool + val isUnionCaseRefDefinitelyMutable: TypedTree.UnionCaseRef -> bool + val isRecdOrUnionOrStructTyconRefDefinitelyMutable: + TypedTree.TyconRef -> bool + val isExnDefinitelyMutable: TypedTree.TyconRef -> bool + val isUnionCaseFieldMutable: + TcGlobals.TcGlobals -> TypedTree.UnionCaseRef -> int -> bool + val isExnFieldMutable: TypedTree.TyconRef -> int -> bool + val useGenuineField: TypedTree.Tycon -> TypedTree.RecdField -> bool + val ComputeFieldName: TypedTree.Tycon -> TypedTree.RecdField -> string + val isQuotedExprTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val destQuotedExprTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkQuotedExprTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkRawQuotedExprTy: TcGlobals.TcGlobals -> TypedTree.TType + val mkAnyTupledTy: + TcGlobals.TcGlobals -> + TypedTree.TupInfo -> TypedTree.TType list -> TypedTree.TType + val mkAnyAnonRecdTy: + TcGlobals.TcGlobals -> + TypedTree.AnonRecdTypeInfo -> TypedTree.TType list -> TypedTree.TType + val mkRefTupledTy: + TcGlobals.TcGlobals -> TypedTree.TType list -> TypedTree.TType + val mkRefTupledVarsTy: + TcGlobals.TcGlobals -> TypedTree.Val list -> TypedTree.TType + val mkMethodTy: + TcGlobals.TcGlobals -> + TypedTree.TType list list -> TypedTree.TType -> TypedTree.TType + val mkArrayType: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkByteArrayTy: TcGlobals.TcGlobals -> TypedTree.TType + val GenWitnessArgTys: + TcGlobals.TcGlobals -> + TypedTree.TraitWitnessInfo -> TypedTree.TType list list + val GenWitnessTy: + TcGlobals.TcGlobals -> TypedTree.TraitWitnessInfo -> TypedTree.TType + val GenWitnessTys: + TcGlobals.TcGlobals -> TraitWitnessInfos -> TypedTree.TType list + val tyOfExpr: TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType + val primMkApp: + (TypedTree.Expr * TypedTree.TType) -> + TypedTree.TypeInst -> TypedTree.Exprs -> Range.range -> TypedTree.Expr + val isExpansiveUnderInstantiation: + g:TcGlobals.TcGlobals -> + fty0:TypedTree.TType -> + tyargs:'a list -> pargs:'b list -> argsl:'c list -> bool + val mkExprAppAux: + g:TcGlobals.TcGlobals -> + f:TypedTree.Expr -> + fty:TypedTree.TType -> + argsl:TypedTree.Expr list -> m:Range.range -> TypedTree.Expr + val mkAppsAux: + g:TcGlobals.TcGlobals -> + f:TypedTree.Expr -> + fty:TypedTree.TType -> + tyargsl:TypedTree.TType list list -> + argsl:TypedTree.Expr list -> m:Range.range -> TypedTree.Expr + val mkApps: + TcGlobals.TcGlobals -> + (TypedTree.Expr * TypedTree.TType) * TypedTree.TType list list * + TypedTree.Expr list * Range.range -> TypedTree.Expr + val mkTyAppExpr: + Range.range -> + TypedTree.Expr * TypedTree.TType -> + TypedTree.TType list -> TypedTree.Expr + val accTargetsOfDecisionTree: + TypedTree.DecisionTree -> int list -> int list + val mapTargetsOfDecisionTree: + f:(int -> int) -> tree:TypedTree.DecisionTree -> TypedTree.DecisionTree + val mapTargetsOfDecisionTreeCase: + f:(int -> int) -> TypedTree.DecisionTreeCase -> TypedTree.DecisionTreeCase + val eliminateDeadTargetsFromMatch: + tree:TypedTree.DecisionTree -> + targets:'a [] -> TypedTree.DecisionTree * 'a [] + val targetOfSuccessDecisionTree: tree:TypedTree.DecisionTree -> int option + val decisionTreeHasNonTrivialBindings: tree:TypedTree.DecisionTree -> bool + val foldLinearBindingTargetsOfMatch: + tree:TypedTree.DecisionTree -> + targets:TypedTree.DecisionTreeTarget [] -> + TypedTree.DecisionTree * TypedTree.DecisionTreeTarget [] + val simplifyTrivialMatch: + spBind:SyntaxTree.DebugPointForBinding -> + exprm:Range.range -> + matchm:Range.range -> + ty:TypedTree.TType -> + tree:TypedTree.DecisionTree -> + targets:TypedTree.DecisionTreeTarget [] -> TypedTree.Expr + val mkAndSimplifyMatch: + SyntaxTree.DebugPointForBinding -> + Range.range -> + Range.range -> + TypedTree.TType -> + TypedTree.DecisionTree -> + TypedTree.DecisionTreeTarget list -> TypedTree.Expr + type Mutates = + | AddressOfOp + | DefinitelyMutates + | PossiblyMutates + | NeverMutates + exception DefensiveCopyWarning of string * Range.range + val isRecdOrStructTyconRefAssumedImmutable: + TcGlobals.TcGlobals -> TypedTree.TyconRef -> bool + val isTyconRefReadOnly: + g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool + val isTyconRefAssumedReadOnly: + g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> bool + val isRecdOrStructTyconRefReadOnlyAux: + g:TcGlobals.TcGlobals -> + m:Range.range -> isInref:bool -> tcref:TypedTree.TyconRef -> bool + val isRecdOrStructTyconRefReadOnly: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool + val isRecdOrStructTyReadOnlyAux: + g:TcGlobals.TcGlobals -> + m:Range.range -> isInref:bool -> ty:TypedTree.TType -> bool + val isRecdOrStructTyReadOnly: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val CanTakeAddressOf: + g:TcGlobals.TcGlobals -> + m:Range.range -> + isInref:bool -> ty:TypedTree.TType -> mut:Mutates -> bool + val CanTakeAddressOfImmutableVal: + g:TcGlobals.TcGlobals -> + m:Range.range -> vref:TypedTree.ValRef -> mut:Mutates -> bool + val MustTakeAddressOfVal: + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val MustTakeAddressOfByrefGet: + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val CanTakeAddressOfByrefGet: + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> mut:Mutates -> bool + val MustTakeAddressOfRecdField: rfref:TypedTree.RecdField -> bool + val MustTakeAddressOfRecdFieldRef: rfref:TypedTree.RecdFieldRef -> bool + val CanTakeAddressOfRecdFieldRef: + g:TcGlobals.TcGlobals -> + m:Range.range -> + rfref:TypedTree.RecdFieldRef -> + tinst:TypedTree.TType list -> mut:Mutates -> bool + val CanTakeAddressOfUnionFieldRef: + g:TcGlobals.TcGlobals -> + m:Range.range -> + uref:TypedTree.UnionCaseRef -> + cidx:int -> tinst:TypedTree.TType list -> mut:Mutates -> bool + val mkDerefAddrExpr: + mAddrGet:Range.range -> + expr:TypedTree.Expr -> + mExpr:Range.range -> exprTy:TypedTree.TType -> TypedTree.Expr + val mkExprAddrOfExprAux: + TcGlobals.TcGlobals -> + bool -> + bool -> + Mutates -> + TypedTree.Expr -> + TypedTree.ValRef option -> + Range.range -> + (TypedTree.Val * TypedTree.Expr) option * TypedTree.Expr * + bool * bool + val mkExprAddrOfExpr: + TcGlobals.TcGlobals -> + bool -> + bool -> + Mutates -> + TypedTree.Expr -> + TypedTree.ValRef option -> + Range.range -> + (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr * bool * + bool + val mkTupleFieldGet: + TcGlobals.TcGlobals -> + TypedTree.TupInfo * TypedTree.Expr * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkAnonRecdFieldGet: + TcGlobals.TcGlobals -> + TypedTree.AnonRecdTypeInfo * TypedTree.Expr * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkRecdFieldGet: + TcGlobals.TcGlobals -> + TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * + Range.range -> TypedTree.Expr + val mkUnionCaseFieldGetUnproven: + TcGlobals.TcGlobals -> + TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkArray: + TypedTree.TType * TypedTree.Exprs * Range.range -> TypedTree.Expr + val IterateRecursiveFixups: + TcGlobals.TcGlobals -> + TypedTree.Val option -> + (TypedTree.Val option -> TypedTree.Expr -> + (TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr -> unit) -> + TypedTree.Expr * (TypedTree.Expr -> TypedTree.Expr) -> + TypedTree.Expr -> unit + val JoinTyparStaticReq: + SyntaxTree.TyparStaticReq -> + SyntaxTree.TyparStaticReq -> SyntaxTree.TyparStaticReq + type ExprFolder<'State> = + { exprIntercept: + ('State -> TypedTree.Expr -> 'State) -> + ('State -> TypedTree.Expr -> 'State) -> 'State -> TypedTree.Expr -> + 'State + valBindingSiteIntercept: 'State -> bool * TypedTree.Val -> 'State + nonRecBindingsIntercept: 'State -> TypedTree.Binding -> 'State + recBindingsIntercept: 'State -> TypedTree.Bindings -> 'State + dtreeIntercept: 'State -> TypedTree.DecisionTree -> 'State + targetIntercept: + ('State -> TypedTree.Expr -> 'State) -> 'State -> + TypedTree.DecisionTreeTarget -> 'State option + tmethodIntercept: + ('State -> TypedTree.Expr -> 'State) -> 'State -> + TypedTree.ObjExprMethod -> 'State option } + val ExprFolder0: ExprFolder<'State> + type ExprFolders<'State> = + + new: folders:ExprFolder<'State> -> ExprFolders<'State> + member FoldExpr: ('State -> TypedTree.Expr -> 'State) + member FoldImplFile: ('State -> TypedTree.TypedImplFile -> 'State) + + val FoldExpr: ExprFolder<'State> -> ('State -> TypedTree.Expr -> 'State) + val FoldImplFile: + ExprFolder<'State> -> ('State -> TypedTree.TypedImplFile -> 'State) + val ExprStats: TypedTree.Expr -> string + val mkString: + TcGlobals.TcGlobals -> Range.range -> string -> TypedTree.Expr + val mkBool: TcGlobals.TcGlobals -> Range.range -> bool -> TypedTree.Expr + val mkByte: TcGlobals.TcGlobals -> Range.range -> byte -> TypedTree.Expr + val mkUInt16: + TcGlobals.TcGlobals -> Range.range -> uint16 -> TypedTree.Expr + val mkTrue: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkFalse: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkUnit: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkInt32: TcGlobals.TcGlobals -> Range.range -> int32 -> TypedTree.Expr + val mkInt: TcGlobals.TcGlobals -> Range.range -> int32 -> TypedTree.Expr + val mkZero: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkOne: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkTwo: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkMinusOne: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val destInt32: TypedTree.Expr -> int32 option + val isIDelegateEventType: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val destIDelegateEventType: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkIEventType: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType -> TypedTree.TType + val mkIObservableType: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkIObserverType: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkRefCellContentsRef: TcGlobals.TcGlobals -> TypedTree.RecdFieldRef + val mkSequential: + SyntaxTree.DebugPointAtSequential -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCompGenSequential: + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkSequentials: + SyntaxTree.DebugPointAtSequential -> + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr list -> TypedTree.Expr + val mkGetArg0: Range.range -> TypedTree.TType -> TypedTree.Expr + val mkAnyTupled: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TupInfo -> + TypedTree.Expr list -> TypedTree.TypeInst -> TypedTree.Expr + val mkRefTupled: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr list -> TypedTree.TypeInst -> TypedTree.Expr + val mkRefTupledNoTypes: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr list -> TypedTree.Expr + val mkRefTupledVars: + TcGlobals.TcGlobals -> Range.range -> TypedTree.Val list -> TypedTree.Expr + val inversePerm: sigma:int array -> int [] + val permute: sigma:int [] -> data:'T [] -> 'T [] + val existsR: a:int -> b:int -> pred:(int -> bool) -> bool + val liftAllBefore: sigma:int array -> int + val permuteExprList: + sigma:int [] -> + exprs:TypedTree.Expr list -> + ty:TypedTree.TType list -> + names:string list -> TypedTree.Binding list * TypedTree.Expr list + val mkRecordExpr: + TcGlobals.TcGlobals -> + TypedTree.RecordConstructionInfo * TypedTree.TyconRef * + TypedTree.TypeInst * TypedTree.RecdFieldRef list * TypedTree.Expr list * + Range.range -> TypedTree.Expr + val mkAnonRecd: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.AnonRecdTypeInfo -> + SyntaxTree.Ident [] -> + TypedTree.Expr list -> TypedTree.TType list -> TypedTree.Expr + val mkRefCell: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkRefCellGet: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkRefCellSet: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkNil: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCons: + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCompGenLocalAndInvisibleBind: + TcGlobals.TcGlobals -> + string -> + Range.range -> + TypedTree.Expr -> TypedTree.Val * TypedTree.Expr * TypedTree.Binding + val box: AbstractIL.IL.ILInstr + val isinst: AbstractIL.IL.ILInstr + val unbox: AbstractIL.IL.ILInstr + val mkUnbox: + TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr + val mkBox: + TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr + val mkIsInst: + TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr + val mspec_Type_GetTypeFromHandle: + TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mspec_String_Length: + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mspec_String_Concat2: + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mspec_String_Concat3: + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mspec_String_Concat4: + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mspec_String_Concat_Array: + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val fspec_Missing_Value: TcGlobals.TcGlobals -> AbstractIL.IL.ILFieldSpec + val mkInitializeArrayMethSpec: + TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mkInvalidCastExnNewobj: TcGlobals.TcGlobals -> AbstractIL.IL.ILInstr + val typedExprForIntrinsic: + _g:'a -> + m:Range.range -> + TcGlobals.IntrinsicValRef -> TypedTree.Expr * TypedTree.TType + val mkCallGetGenericComparer: + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkCallGetGenericEREqualityComparer: + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkCallGetGenericPEREqualityComparer: + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkCallUnbox: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallUnboxFast: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallTypeTest: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallTypeOf: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCallTypeDefOf: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCallDispose: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeq: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallCreateInstance: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCallGetQuerySourceAsEnumerable: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallNewQuerySource: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallCreateEvent: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGenericComparisonWithComparerOuter: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGenericEqualityEROuter: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGenericEqualityWithComparerOuter: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGenericHashWithComparerOuter: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallEqualsOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallNotEqualsOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallLessThanOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallLessThanOrEqualsOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGreaterThanOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGreaterThanOrEqualsOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallAdditionOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSubtractionOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallMultiplyOperator: + TcGlobals.TcGlobals -> + Range.range -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> + rty:TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallDivisionOperator: + TcGlobals.TcGlobals -> + Range.range -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> + rty:TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallModulusOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallDefaultOf: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCallBitwiseAndOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallBitwiseOrOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallBitwiseXorOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallShiftLeftOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallShiftRightOperator: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallUnaryNegOperator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallUnaryNotOperator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallAdditionChecked: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSubtractionChecked: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallMultiplyChecked: + TcGlobals.TcGlobals -> + Range.range -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> + rty:TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallUnaryNegChecked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToByteChecked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToSByteChecked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt16Checked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt16Checked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToIntChecked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt32Checked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt32Checked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt64Checked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt64Checked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToIntPtrChecked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUIntPtrChecked: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToByteOperator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToSByteOperator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt16Operator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt16Operator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToIntOperator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt32Operator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt32Operator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt64Operator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt64Operator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToSingleOperator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToDoubleOperator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToIntPtrOperator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUIntPtrOperator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToCharOperator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToEnumOperator: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallArrayLength: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallArrayGet: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray2DGet: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray3DGet: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray4DGet: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArraySet: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray2DSet: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray3DSet: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray4DSet: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallHash: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallBox: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallIsNull: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallIsNotNull: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallRaise: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallNewDecimal: + g:TcGlobals.TcGlobals -> + m:Range.range -> + e1:TypedTree.Expr * e2:TypedTree.Expr * e3:TypedTree.Expr * + e4:TypedTree.Expr * e5:TypedTree.Expr -> TypedTree.Expr + val mkCallNewFormat: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.TType -> + formatStringExpr:TypedTree.Expr -> TypedTree.Expr + val tryMkCallBuiltInWitness: + TcGlobals.TcGlobals -> + TypedTree.TraitConstraintInfo -> + TypedTree.Expr list -> Range.range -> TypedTree.Expr option + val tryMkCallCoreFunctionAsBuiltInWitness: + TcGlobals.TcGlobals -> + TcGlobals.IntrinsicValRef -> + TypedTree.TType list -> + TypedTree.Expr list -> Range.range -> TypedTree.Expr option + val TryEliminateDesugaredConstants: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Const -> TypedTree.Expr option + val mkSeqTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkIEnumeratorTy: + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkCallSeqCollect: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqUsing: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqDelay: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqAppend: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqGenerated: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqFinally: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqOfFunctions: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqToArray: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqToList: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqMap: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqSingleton: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqEmpty: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCall_sprintf: + g:TcGlobals.TcGlobals -> + m:Range.range -> + funcTy:TypedTree.TType -> + fmtExpr:TypedTree.Expr -> + fillExprs:TypedTree.Expr list -> TypedTree.Expr + val mkCallDeserializeQuotationFSharp20Plus: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallDeserializeQuotationFSharp40Plus: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallCastQuotation: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallLiftValue: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallLiftValueWithName: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> string -> TypedTree.Expr -> TypedTree.Expr + val mkCallLiftValueWithDefn: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallCheckThis: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallFailInit: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkCallFailStaticInit: + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkCallQuoteToLinqLambdaExpression: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkOptionToNullable: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkOptionDefaultValue: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkLazyDelayed: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkLazyForce: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkGetString: + g:TcGlobals.TcGlobals -> + m:Range.range -> + e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr + val mkGetStringChar: + (TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr -> + TypedTree.Expr) + val mkGetStringLength: + g:TcGlobals.TcGlobals -> + m:Range.range -> e:TypedTree.Expr -> TypedTree.Expr + val mkStaticCall_String_Concat2: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkStaticCall_String_Concat3: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkStaticCall_String_Concat4: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkStaticCall_String_Concat_Array: + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val mkDecr: + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val mkIncr: + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val mkLdlen: + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val mkLdelem: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkILAsmCeq: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkILAsmClt: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkNull: Range.range -> TypedTree.TType -> TypedTree.Expr + val mkThrow: + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val destThrow: + _arg1:TypedTree.Expr -> + (Range.range * TypedTree.TType * TypedTree.Expr) option + val isThrow: TypedTree.Expr -> bool + val mkReraiseLibCall: + TcGlobals.TcGlobals -> TypedTree.TType -> Range.range -> TypedTree.Expr + val mkReraise: Range.range -> TypedTree.TType -> TypedTree.Expr + val tnameCompilationSourceNameAttr: string + val tnameCompilationArgumentCountsAttr: string + val tnameCompilationMappingAttr: string + val tnameSourceConstructFlags: string + val tref_CompilationArgumentCountsAttr: + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef + val tref_CompilationMappingAttr: + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef + val tref_CompilationSourceNameAttr: + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef + val tref_SourceConstructFlags: + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef + val mkCompilationMappingAttrPrim: + g:TcGlobals.TcGlobals -> + k:int32 -> nums:int32 list -> AbstractIL.IL.ILAttribute + val mkCompilationMappingAttr: + TcGlobals.TcGlobals -> int32 -> AbstractIL.IL.ILAttribute + val mkCompilationMappingAttrWithSeqNum: + TcGlobals.TcGlobals -> int32 -> int32 -> AbstractIL.IL.ILAttribute + val mkCompilationMappingAttrWithVariantNumAndSeqNum: + TcGlobals.TcGlobals -> + int32 -> int32 -> int32 -> AbstractIL.IL.ILAttribute + val mkCompilationArgumentCountsAttr: + TcGlobals.TcGlobals -> int32 list -> AbstractIL.IL.ILAttribute + val mkCompilationSourceNameAttr: + TcGlobals.TcGlobals -> string -> AbstractIL.IL.ILAttribute + val mkCompilationMappingAttrForQuotationResource: + TcGlobals.TcGlobals -> + string * AbstractIL.IL.ILTypeRef list -> AbstractIL.IL.ILAttribute + val isTypeProviderAssemblyAttr: cattr:AbstractIL.IL.ILAttribute -> bool + val TryDecodeTypeProviderAssemblyAttr: + AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option + val tname_SignatureDataVersionAttr: string + val tnames_SignatureDataVersionAttr: string list * string + val tref_SignatureDataVersionAttr: unit -> AbstractIL.IL.ILTypeRef + val mkSignatureDataVersionAttr: + TcGlobals.TcGlobals -> + AbstractIL.IL.ILVersionInfo -> AbstractIL.IL.ILAttribute + val tname_AutoOpenAttr: string + val IsSignatureDataVersionAttr: AbstractIL.IL.ILAttribute -> bool + val TryFindAutoOpenAttr: + AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option + val tname_InternalsVisibleToAttr: string + val TryFindInternalsVisibleToAttr: + AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option + val IsMatchingSignatureDataVersionAttr: + AbstractIL.IL.ILGlobals -> + AbstractIL.IL.ILVersionInfo -> AbstractIL.IL.ILAttribute -> bool + val mkCompilerGeneratedAttr: + TcGlobals.TcGlobals -> int32 -> AbstractIL.IL.ILAttribute + val untupledToRefTupled: + g:TcGlobals.TcGlobals -> + vs:TypedTree.Val list -> + TypedTree.Val * (TypedTree.Expr -> TypedTree.Expr) + val AdjustArityOfLambdaBody: + TcGlobals.TcGlobals -> + int -> + TypedTree.Val list -> + TypedTree.Expr -> TypedTree.Val list * TypedTree.Expr + val MultiLambdaToTupledLambda: + TcGlobals.TcGlobals -> + TypedTree.Val list -> TypedTree.Expr -> TypedTree.Val * TypedTree.Expr + val ( |RefTuple|_| ): expr:TypedTree.Expr -> TypedTree.Exprs option + val MultiLambdaToTupledLambdaIfNeeded: + g:TcGlobals.TcGlobals -> + vs:TypedTree.Val list * arg:TypedTree.Expr -> + body:TypedTree.Expr -> + (TypedTree.Val * TypedTree.Expr) list * TypedTree.Expr + val MakeApplicationAndBetaReduceAux: + g:TcGlobals.TcGlobals -> + f:TypedTree.Expr * fty:TypedTree.TType * + tyargsl:TypedTree.TType list list * argsl:TypedTree.Expr list * + m:Range.range -> TypedTree.Expr + val MakeApplicationAndBetaReduce: + TcGlobals.TcGlobals -> + TypedTree.Expr * TypedTree.TType * TypedTree.TType list list * + TypedTree.Expr list * Range.range -> TypedTree.Expr + val MakeArgsForTopArgs: + _g:'a -> + m:Range.range -> + argtysl:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> + tpenv:(TypedTree.Typar * TypedTree.TType) list -> + TypedTree.Val list list + val AdjustValForExpectedArity: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.ValRef -> + TypedTree.ValUseFlag -> + TypedTree.ValReprInfo -> TypedTree.Expr * TypedTree.TType + val IsSubsumptionExpr: g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> bool + val stripTupledFunTy: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> TypedTree.TTypes list * TypedTree.TType + val ( |ExprValWithPossibleTypeInst|_| ): + TypedTree.Expr -> + (TypedTree.ValRef * TypedTree.ValUseFlag * TypedTree.TypeInst * + Range.range) option + val mkCoerceIfNeeded: + TcGlobals.TcGlobals -> + tgtTy:TypedTree.TType -> + srcTy:TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCompGenLetIn: + Range.range -> + string -> + TypedTree.TType -> + TypedTree.Expr -> + (TypedTree.Val * TypedTree.Expr -> TypedTree.Expr) -> + TypedTree.Expr + val AdjustPossibleSubsumptionExpr: + TcGlobals.TcGlobals -> + TypedTree.Expr -> + TypedTree.Expr list -> (TypedTree.Expr * TypedTree.Expr list) option + val NormalizeAndAdjustPossibleSubsumptionExprs: + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr + val etaExpandTypeLambda: + g:TcGlobals.TcGlobals -> + m:Range.range -> + tps:TypedTree.Typar list -> + tm:TypedTree.Expr * ty:TypedTree.TType -> TypedTree.Expr + val AdjustValToTopVal: + TypedTree.Val -> TypedTree.ParentRef -> TypedTree.ValReprInfo -> unit + val LinearizeTopMatchAux: + g:TcGlobals.TcGlobals -> + parent:TypedTree.ParentRef -> + spBind:SyntaxTree.DebugPointForBinding * m:Range.range * + tree:TypedTree.DecisionTree * targets:TypedTree.DecisionTreeTarget [] * + m2:Range.range * ty:TypedTree.TType -> TypedTree.Expr + val LinearizeTopMatch: + TcGlobals.TcGlobals -> + TypedTree.ParentRef -> TypedTree.Expr -> TypedTree.Expr + val commaEncs: strs:seq -> string + val angleEnc: str:string -> string + val ticksAndArgCountTextOfTyconRef: TypedTree.TyconRef -> string + val typarEnc: + _g:'a -> + gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> + typar:TypedTree.Typar -> string + val typeEnc: + g:TcGlobals.TcGlobals -> + gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> + ty:TypedTree.TType -> string + val tyargsEnc: + g:TcGlobals.TcGlobals -> + gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> + args:TypedTree.TypeInst -> string + val XmlDocArgsEnc: + TcGlobals.TcGlobals -> + TypedTree.Typar list * TypedTree.Typar list -> + TypedTree.TType list -> string + val buildAccessPath: TypedTree.CompilationPath option -> string + val prependPath: path:string -> name:string -> string + val XmlDocSigOfVal: + TcGlobals.TcGlobals -> full:bool -> string -> TypedTree.Val -> string + val BuildXmlDocSig: prefix:string -> paths:string list -> string + val XmlDocSigOfUnionCase: (string list -> string) + val XmlDocSigOfField: (string list -> string) + val XmlDocSigOfProperty: (string list -> string) + val XmlDocSigOfTycon: (string list -> string) + val XmlDocSigOfSubModul: (string list -> string) + val XmlDocSigOfEntity: TypedTree.EntityRef -> string + val enum_CompilationRepresentationAttribute_Static: int + val enum_CompilationRepresentationAttribute_Instance: int + val enum_CompilationRepresentationAttribute_StaticInstanceMask: int + val enum_CompilationRepresentationAttribute_ModuleSuffix: int + val enum_CompilationRepresentationAttribute_PermitNull: int + val HasUseNullAsTrueValueAttribute: + g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> bool + val TyconHasUseNullAsTrueValueAttribute: + TcGlobals.TcGlobals -> TypedTree.Tycon -> bool + val CanHaveUseNullAsTrueValueAttribute: + TcGlobals.TcGlobals -> TypedTree.Tycon -> bool + val IsUnionTypeWithNullAsTrueValue: + TcGlobals.TcGlobals -> TypedTree.Tycon -> bool + val TyconCompilesInstanceMembersAsStatic: + g:TcGlobals.TcGlobals -> tycon:TypedTree.Tycon -> bool + val TcrefCompilesInstanceMembersAsStatic: + g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> bool + val isNonNullableStructTyparTy: + TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isReferenceTyparTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val TypeNullNever: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val TypeNullIsExtraValue: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val TypeNullIsTrueValue: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val TypeNullNotLiked: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val TypeSatisfiesNullConstraint: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val TypeHasDefaultValue: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val ( |SpecialComparableHeadType|_| ): + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes option + val ( |SpecialEquatableHeadType|_| ): + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes option + val ( |SpecialNotEquatableHeadType|_| ): + TcGlobals.TcGlobals -> TypedTree.TType -> unit option + val canUseTypeTestFast: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val canUseUnboxFast: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val mkIsInstConditional: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Val -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkNullTest: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkNonNullTest: + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val mkNonNullCond: + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkIfThen: + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val ModuleNameIsMangled: + TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool + val CompileAsEvent: TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool + val MemberIsCompiledAsInstance: + TcGlobals.TcGlobals -> + TypedTree.TyconRef -> + bool -> TypedTree.ValMemberInfo -> TypedTree.Attrib list -> bool + val isSealedTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isComInteropTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool + val ValSpecIsCompiledAsInstance: + TcGlobals.TcGlobals -> TypedTree.Val -> bool + val ValRefIsCompiledAsInstanceMember: + TcGlobals.TcGlobals -> TypedTree.ValRef -> bool + val GetMemberCallInfo: + TcGlobals.TcGlobals -> + TypedTree.ValRef * TypedTree.ValUseFlag -> + int * bool * bool * bool * bool * bool * bool * bool + val TryGetActivePatternInfo: + TypedTree.ValRef -> PrettyNaming.ActivePatternInfo option + type ActivePatternElemRef with + member Name: string + val mkChoiceTyconRef: + g:TcGlobals.TcGlobals -> m:Range.range -> n:int -> TypedTree.EntityRef + val mkChoiceTy: + g:TcGlobals.TcGlobals -> + m:Range.range -> tinst:TypedTree.TType list -> TypedTree.TType + val mkChoiceCaseRef: + TcGlobals.TcGlobals -> Range.range -> int -> int -> TypedTree.UnionCaseRef + type ActivePatternInfo with + member Names: string list + type ActivePatternInfo with + member + ResultType: TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType list -> TypedTree.TType + type ActivePatternInfo with + member + OverallType: TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType list -> TypedTree.TType + val doesActivePatternHaveFreeTypars: + TcGlobals.TcGlobals -> TypedTree.ValRef -> bool + [] + type ExprRewritingEnv = + { PreIntercept: + ((TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr -> + TypedTree.Expr option) option + PostTransform: TypedTree.Expr -> TypedTree.Expr option + PreInterceptBinding: + ((TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Binding -> + TypedTree.Binding option) option + IsUnderQuotations: bool } + val rewriteBind: + env:ExprRewritingEnv -> bind:TypedTree.Binding -> TypedTree.Binding + val rewriteBindStructure: + env:ExprRewritingEnv -> TypedTree.Binding -> TypedTree.Binding + val rewriteBinds: + env:ExprRewritingEnv -> + binds:TypedTree.Binding list -> TypedTree.Binding list + val RewriteExpr: ExprRewritingEnv -> TypedTree.Expr -> TypedTree.Expr + val preRewriteExpr: + env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr option + val postRewriteExpr: + env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr + val rewriteExprStructure: + env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr + val rewriteLinearExpr: + env:ExprRewritingEnv -> + expr:TypedTree.Expr -> + contf:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr + val rewriteExprs: + env:ExprRewritingEnv -> exprs:TypedTree.Exprs -> TypedTree.Exprs + val rewriteFlatExprs: + env:ExprRewritingEnv -> exprs:TypedTree.Expr list -> TypedTree.Expr list + val RewriteDecisionTree: + env:ExprRewritingEnv -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree + val rewriteTarget: + env:ExprRewritingEnv -> + TypedTree.DecisionTreeTarget -> TypedTree.DecisionTreeTarget + val rewriteTargets: + env:ExprRewritingEnv -> + targets:TypedTree.DecisionTreeTarget array -> + TypedTree.DecisionTreeTarget list + val rewriteObjExprOverride: + env:ExprRewritingEnv -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod + val rewriteObjExprInterfaceImpl: + env:ExprRewritingEnv -> + ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> + TypedTree.TType * TypedTree.ObjExprMethod list + val rewriteModuleOrNamespaceExpr: + env:ExprRewritingEnv -> + x:TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig + val rewriteModuleOrNamespaceDefs: + env:ExprRewritingEnv -> + x:TypedTree.ModuleOrNamespaceExpr list -> + TypedTree.ModuleOrNamespaceExpr list + val rewriteModuleOrNamespaceDef: + env:ExprRewritingEnv -> + x:TypedTree.ModuleOrNamespaceExpr -> TypedTree.ModuleOrNamespaceExpr + val rewriteModuleOrNamespaceBinding: + env:ExprRewritingEnv -> + x:TypedTree.ModuleOrNamespaceBinding -> + TypedTree.ModuleOrNamespaceBinding + val rewriteModuleOrNamespaceBindings: + env:ExprRewritingEnv -> + mbinds:TypedTree.ModuleOrNamespaceBinding list -> + TypedTree.ModuleOrNamespaceBinding list + val RewriteImplFile: + ExprRewritingEnv -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile + val MakeExportRemapping: + TypedTree.CcuThunk -> TypedTree.ModuleOrNamespace -> Remap + val remapEntityDataToNonLocal: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> d:TypedTree.Entity -> TypedTree.Entity + val remapTyconToNonLocal: + g:TcGlobals.TcGlobals -> + tmenv:Remap -> x:TypedTree.Entity -> TypedTree.Entity + val remapValToNonLocal: + g:TcGlobals.TcGlobals -> tmenv:Remap -> inp:TypedTree.Val -> TypedTree.Val + val ApplyExportRemappingToEntity: + TcGlobals.TcGlobals -> Remap -> TypedTree.Entity -> TypedTree.Entity + val isCompiledConstraint: cx:TypedTree.TyparConstraint -> bool + val IsGenericValWithGenericConstraints: + TcGlobals.TcGlobals -> TypedTree.Val -> bool + type Entity with + member HasInterface: TcGlobals.TcGlobals -> TypedTree.TType -> bool + type Entity with + member + HasOverride: TcGlobals.TcGlobals -> + string -> TypedTree.TType list -> bool + type Entity with + member + HasMember: TcGlobals.TcGlobals -> + string -> TypedTree.TType list -> bool + type EntityRef with + member HasInterface: TcGlobals.TcGlobals -> TypedTree.TType -> bool + type EntityRef with + member + HasOverride: TcGlobals.TcGlobals -> + string -> TypedTree.TType list -> bool + type EntityRef with + member + HasMember: TcGlobals.TcGlobals -> + string -> TypedTree.TType list -> bool + val mkFastForLoop: + TcGlobals.TcGlobals -> + SyntaxTree.DebugPointAtFor * Range.range * TypedTree.Val * + TypedTree.Expr * bool * TypedTree.Expr * TypedTree.Expr -> + TypedTree.Expr + val IsSimpleSyntacticConstantExpr: + TcGlobals.TcGlobals -> TypedTree.Expr -> bool + val EvalArithBinOp: + opInt8:(sbyte -> sbyte -> sbyte) * opInt16:(int16 -> int16 -> int16) * + opInt32:(int32 -> int32 -> int32) * opInt64:(int64 -> int64 -> int64) * + opUInt8:(byte -> byte -> byte) * opUInt16:(uint16 -> uint16 -> uint16) * + opUInt32:(uint32 -> uint32 -> uint32) * + opUInt64:(uint64 -> uint64 -> uint64) -> + arg1:TypedTree.Expr -> arg2:TypedTree.Expr -> TypedTree.Expr + val EvalAttribArgExpr: + g:TcGlobals.TcGlobals -> x:TypedTree.Expr -> TypedTree.Expr + val EvaledAttribExprEquality: + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr -> bool + val ( |ConstToILFieldInit|_| ): + TypedTree.Const -> AbstractIL.IL.ILFieldInit option + val EvalLiteralExprOrAttribArg: + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr + val GetTypeOfIntrinsicMemberInCompiledForm: + TcGlobals.TcGlobals -> + TypedTree.ValRef -> + TypedTree.Typar list * TypedTree.TraitWitnessInfo list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType option * TypedTree.ArgReprInfo + val mkCompiledTuple: + TcGlobals.TcGlobals -> + bool -> + TypedTree.TType list * TypedTree.Expr list * Range.range -> + TypedTree.EntityRef * TypedTree.TType list * TypedTree.Expr list * + Range.range + val mkILMethodSpecForTupleItem: + _g:TcGlobals.TcGlobals -> + ty:AbstractIL.IL.ILType -> n:int -> AbstractIL.IL.ILMethodSpec + val mkILFieldSpecForTupleItem: + ty:AbstractIL.IL.ILType -> n:int -> AbstractIL.IL.ILFieldSpec + val mkGetTupleItemN: + TcGlobals.TcGlobals -> + Range.range -> + int -> + AbstractIL.IL.ILType -> + bool -> TypedTree.Expr -> TypedTree.TType -> TypedTree.Expr + val ( |Int32Expr|_| ): TypedTree.Expr -> int32 option + val ( |TryFinally|_| ): + expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option + val ( |WhileLoopForCompiledForEachExpr|_| ): + expr:TypedTree.Expr -> + (TypedTree.Expr * TypedTree.Expr * Range.range) option + val ( |Let|_| ): + expr:TypedTree.Expr -> + (TypedTree.Val * TypedTree.Expr * SyntaxTree.DebugPointForBinding * + TypedTree.Expr) option + val ( |RangeInt32Step|_| ): + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> (TypedTree.Expr * int * TypedTree.Expr) option + val ( |GetEnumeratorCall|_| ): + expr:TypedTree.Expr -> TypedTree.ValRef option + val ( |CompiledForEachExpr|_| ): + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> + (TypedTree.TType * TypedTree.Expr * TypedTree.Val * TypedTree.Expr * + (Range.range * Range.range * SyntaxTree.DebugPointAtFor * Range.range * + SyntaxTree.DebugPointAtWhile * Range.range)) option + val ( |CompiledInt32RangeForEachExpr|_| ): + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> + (TypedTree.Expr * int * TypedTree.Expr * TypedTree.Val * + TypedTree.Expr * + (Range.range * Range.range * SyntaxTree.DebugPointAtFor * Range.range * + SyntaxTree.DebugPointAtWhile * Range.range)) option + type OptimizeForExpressionOptions = + | OptimizeIntRangesOnly + | OptimizeAllForExpressions + val DetectAndOptimizeForExpression: + TcGlobals.TcGlobals -> + OptimizeForExpressionOptions -> TypedTree.Expr -> TypedTree.Expr + val ( |InnerExprPat| ): TypedTree.Expr -> TypedTree.Expr + val BindUnitVars: + TcGlobals.TcGlobals -> + (TypedTree.Val list * TypedTree.ArgReprInfo list * TypedTree.Expr) -> + TypedTree.Val list * TypedTree.Expr + val isThreadOrContextStatic: + TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool + val mkUnitDelayLambda: + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val ( |ValApp|_| ): + TcGlobals.TcGlobals -> + TypedTree.ValRef -> + TypedTree.Expr -> + (TypedTree.TypeInst * TypedTree.Exprs * Range.range) option + val CombineCcuContentFragments: + Range.range -> + TypedTree.ModuleOrNamespaceType list -> TypedTree.ModuleOrNamespaceType + type TraitWitnessInfoHashMap<'T> = + System.Collections.Immutable.ImmutableDictionary + val EmptyTraitWitnessInfoHashMap: + TcGlobals.TcGlobals -> TraitWitnessInfoHashMap<'T> + val ( |WhileExpr|_| ): + TypedTree.Expr -> + (SyntaxTree.DebugPointAtWhile * TypedTree.SpecialWhileLoopMarker * + TypedTree.Expr * TypedTree.Expr * Range.range) option + val ( |TryFinallyExpr|_| ): + TypedTree.Expr -> + (SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally * + TypedTree.TType * TypedTree.Expr * TypedTree.Expr * Range.range) option + val ( |ForLoopExpr|_| ): + TypedTree.Expr -> + (SyntaxTree.DebugPointAtFor * TypedTree.ForLoopStyle * TypedTree.Expr * + TypedTree.Expr * TypedTree.Val * TypedTree.Expr * Range.range) option + val ( |TryWithExpr|_| ): + TypedTree.Expr -> + (SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith * + TypedTree.TType * TypedTree.Expr * TypedTree.Val * TypedTree.Expr * + TypedTree.Val * TypedTree.Expr * Range.range) option + val mkLabelled: + Range.range -> + AbstractIL.IL.ILCodeLabel -> TypedTree.Expr -> TypedTree.Expr + + +namespace FSharp.Compiler + module internal TypedTreePickle = + val verbose: bool + val ffailwith: fileName:System.String -> str:System.String -> 'a + [] + type PickledDataWithReferences<'RawData> = + { RawData: 'RawData + FixupThunks: TypedTree.CcuThunk [] } + with + member Fixup: (string -> TypedTree.CcuThunk) -> 'RawData + member OptionalFixup: (string -> TypedTree.CcuThunk option) -> 'RawData + + [] + type Table<'T> = + { name: string + tbl: System.Collections.Generic.Dictionary<'T,int> + mutable rows: ResizeArray<'T> + mutable count: int } + with + static member Create: n:string -> Table<'a> when 'a: equality + member Add: x:'T -> int + member FindOrAdd: x:'T -> int + member AsArray: 'T [] + member Size: int + + [] + type InputTable<'T> = + { itbl_name: string + itbl_rows: 'T array } + val new_itbl: n:string -> r:'a array -> InputTable<'a> + [] + type NodeOutTable<'Data,'Node> = + { NodeStamp: 'Node -> TypedTree.Stamp + NodeName: 'Node -> string + GetRange: 'Node -> Range.range + Deref: 'Node -> 'Data + Name: string + Table: Table } + with + static member + Create: stampF:('a -> TypedTree.Stamp) * nameF:('a -> string) * + rangeF:('a -> Range.range) * derefF:('a -> 'b) * nm:string -> + NodeOutTable<'b,'a> + member Size: int + + [] + type WriterState = + { os: AbstractIL.Internal.ByteBuffer + oscope: TypedTree.CcuThunk + occus: Table + oentities: NodeOutTable + otypars: NodeOutTable + ovals: NodeOutTable + oanoninfos: + NodeOutTable + ostrings: Table + opubpaths: Table + onlerefs: Table + osimpletys: Table + oglobals: TcGlobals.TcGlobals + mutable isStructThisArgPos: bool + ofile: string + oInMem: bool } + val pfailwith: st:WriterState -> str:System.String -> 'a + [] + type NodeInTable<'Data,'Node> = + { LinkNode: 'Node -> 'Data -> unit + IsLinked: 'Node -> bool + Name: string + Nodes: 'Node [] } + with + static member + Create: mkEmpty:(unit -> 'a) * lnk:('a -> 'b -> unit) * + isLinked:('a -> bool) * nm:string * n:int -> + NodeInTable<'b,'a> + member Get: n:int -> 'Node + member Count: int + + [] + type ReaderState = + { is: AbstractIL.Internal.ByteStream + iilscope: AbstractIL.IL.ILScopeRef + iccus: InputTable + ientities: NodeInTable + itypars: NodeInTable + ivals: NodeInTable + ianoninfos: + NodeInTable + istrings: InputTable + ipubpaths: InputTable + inlerefs: InputTable + isimpletys: InputTable + ifile: string + iILModule: AbstractIL.IL.ILModuleDef option } + val ufailwith: st:ReaderState -> str:System.String -> 'a + type 'T pickler = 'T -> WriterState -> unit + val p_byte: int -> WriterState -> unit + val p_bool: bool -> WriterState -> unit + val prim_p_int32: i:int -> st:WriterState -> unit + val p_int32: n:int -> st:WriterState -> unit + val space: unit + val p_space: n:int -> unit -> st:WriterState -> unit + val p_used_space1: f:(WriterState -> unit) -> st:WriterState -> unit + val p_bytes: s:byte [] -> st:WriterState -> unit + val p_prim_string: s:string -> st:WriterState -> unit + val p_int: int -> WriterState -> unit + val p_int8: i:sbyte -> st:WriterState -> unit + val p_uint8: i:byte -> st:WriterState -> unit + val p_int16: i:int16 -> st:WriterState -> unit + val p_uint16: x:uint16 -> st:WriterState -> unit + val p_uint32: x:uint32 -> st:WriterState -> unit + val p_int64: i:int64 -> st:WriterState -> unit + val p_uint64: x:uint64 -> st:WriterState -> unit + val bits_of_float32: x:float32 -> int + val bits_of_float: x:float -> int64 + val p_single: i:float32 -> st:WriterState -> unit + val p_double: i:float -> st:WriterState -> unit + val p_ieee64: i:float -> st:WriterState -> unit + val p_char: i:char -> st:WriterState -> unit + val inline p_tup2: + ('T1 -> WriterState -> unit) -> + ('T2 -> WriterState -> unit) -> ('T1 * 'T2 -> WriterState -> unit) + val inline p_tup3: + ('T1 -> WriterState -> unit) -> + ('T2 -> WriterState -> unit) -> + ('T3 -> WriterState -> unit) -> + ('T1 * 'T2 * 'T3 -> WriterState -> unit) + val inline p_tup4: + ('T1 -> WriterState -> unit) -> + ('T2 -> WriterState -> unit) -> + ('T3 -> WriterState -> unit) -> + ('T4 -> WriterState -> unit) -> + ('T1 * 'T2 * 'T3 * 'T4 -> WriterState -> unit) + val inline p_tup5: + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e -> st:WriterState -> unit + val inline p_tup6: + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f -> + st:WriterState -> unit + val inline p_tup7: + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + p7:('g -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g -> + st:WriterState -> unit + val inline p_tup8: + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + p7:('g -> WriterState -> unit) -> + p8:('h -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * x8:'h -> + st:WriterState -> unit + val inline p_tup9: + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + p7:('g -> WriterState -> unit) -> + p8:('h -> WriterState -> unit) -> + p9:('i -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * x8:'h * + x9:'i -> st:WriterState -> unit + val inline p_tup10: + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + p7:('g -> WriterState -> unit) -> + p8:('h -> WriterState -> unit) -> + p9:('i -> WriterState -> unit) -> + p10:('j -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * + x8:'h * x9:'i * x10:'j -> st:WriterState -> unit + val inline p_tup11: + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + p7:('g -> WriterState -> unit) -> + p8:('h -> WriterState -> unit) -> + p9:('i -> WriterState -> unit) -> + p10:('j -> WriterState -> unit) -> + p11:('k -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * + x8:'h * x9:'i * x10:'j * x11:'k -> + st:WriterState -> unit + val u_byte: ReaderState -> int + type unpickler<'T> = ReaderState -> 'T + val u_bool: ReaderState -> bool + val prim_u_int32: st:ReaderState -> int + val u_int32: st:ReaderState -> int + val u_byte_memory: st:ReaderState -> AbstractIL.Internal.ReadOnlyByteMemory + val u_bytes: st:ReaderState -> byte [] + val u_prim_string: st:ReaderState -> string + val u_int: ReaderState -> int + val u_int8: st:ReaderState -> sbyte + val u_uint8: st:ReaderState -> byte + val u_int16: st:ReaderState -> int16 + val u_uint16: st:ReaderState -> uint16 + val u_uint32: st:ReaderState -> uint32 + val u_int64: st:ReaderState -> int64 + val u_uint64: st:ReaderState -> uint64 + val float32_of_bits: x:int32 -> float32 + val float_of_bits: x:int64 -> float + val u_single: st:ReaderState -> float32 + val u_double: st:ReaderState -> float + val u_ieee64: st:ReaderState -> float + val u_char: st:ReaderState -> char + val u_space: n:int -> st:ReaderState -> unit + val u_used_space1: f:(ReaderState -> 'a) -> st:ReaderState -> 'a option + val inline u_tup2: + (ReaderState -> 'T2) -> (ReaderState -> 'T3) -> (ReaderState -> 'T2 * 'T3) + val inline u_tup3: + (ReaderState -> 'T2) -> + (ReaderState -> 'T3) -> + (ReaderState -> 'T4) -> (ReaderState -> 'T2 * 'T3 * 'T4) + val inline u_tup4: + (ReaderState -> 'T2) -> + (ReaderState -> 'T3) -> + (ReaderState -> 'T4) -> + (ReaderState -> 'T5) -> (ReaderState -> 'T2 * 'T3 * 'T4 * 'T5) + val inline u_tup5: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> st:ReaderState -> 'a * 'b * 'c * 'd * 'e + val inline u_tup6: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f + val inline u_tup7: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f * 'g + val inline u_tup8: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h + val inline u_tup9: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i + val inline u_tup10: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j + val inline u_tup11: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j * + 'k + val inline u_tup12: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j * + 'k * 'l + val inline u_tup13: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + p13:(ReaderState -> 'm) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * + 'j * 'k * 'l * 'm + val inline u_tup14: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + p13:(ReaderState -> 'm) -> + p14:(ReaderState -> 'n) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * + 'j * 'k * 'l * 'm * 'n + val inline u_tup15: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + p13:(ReaderState -> 'm) -> + p14:(ReaderState -> 'n) -> + p15:(ReaderState -> 'o) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * + 'j * 'k * 'l * 'm * 'n * 'o + val inline u_tup16: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + p13:(ReaderState -> 'm) -> + p14:(ReaderState -> 'n) -> + p15:(ReaderState -> 'o) -> + p16:(ReaderState -> 'p) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * + 'i * 'j * 'k * 'l * 'm * 'n * 'o * 'p + val inline u_tup17: + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + p13:(ReaderState -> 'm) -> + p14:(ReaderState -> 'n) -> + p15:(ReaderState -> 'o) -> + p16:(ReaderState -> 'p) -> + p17:(ReaderState -> 'q) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * + 'i * 'j * 'k * 'l * 'm * 'n * 'o * 'p * + 'q + val p_osgn_ref: + _ctxt:string -> + outMap:NodeOutTable<'a,'b> -> x:'b -> st:WriterState -> unit + val p_osgn_decl: + outMap:NodeOutTable<'a,'b> -> + p:('a -> WriterState -> unit) -> x:'b -> st:WriterState -> unit + val u_osgn_ref: inMap:NodeInTable<'a,'b> -> st:ReaderState -> 'b + val u_osgn_decl: + inMap:NodeInTable<'a,'b> -> u:(ReaderState -> 'a) -> st:ReaderState -> 'b + val encode_uniq: tbl:Table<'a> -> key:'a -> int + val lookup_uniq: st:ReaderState -> tbl:InputTable<'a> -> n:int -> 'a + val p_array_core: f:('T -> 'a -> unit) -> x:'T [] -> st:'a -> unit + val p_array: ('T -> WriterState -> unit) -> ('T [] -> WriterState -> unit) + val p_array_ext: + extraf:(WriterState -> unit) option -> + f:('T -> WriterState -> unit) -> x:'T [] -> st:WriterState -> unit + val p_list_core: f:('T -> 'a -> unit) -> xs:'T list -> st:'a -> unit + val p_list: + f:('a -> WriterState -> unit) -> x:'a list -> st:WriterState -> unit + val p_list_ext: + extraf:(WriterState -> unit) option -> + f:('a -> WriterState -> unit) -> x:'a list -> st:WriterState -> unit + val p_List: + f:('T -> WriterState -> unit) -> x:'T list -> st:WriterState -> unit + val p_wrap: f:('T -> 'U) -> p:'U pickler -> x:'T -> st:WriterState -> unit + val p_option: + f:('a -> WriterState -> unit) -> x:'a option -> st:WriterState -> unit + val private p_lazy_impl: + p:('a -> WriterState -> unit) -> v:'a -> st:WriterState -> unit + val p_lazy: + ('T -> WriterState -> unit) -> (System.Lazy<'T> -> WriterState -> unit) + val p_maybe_lazy: + p:('a -> WriterState -> unit) -> + x:Lib.MaybeLazy<'a> -> st:WriterState -> unit + val p_hole: + unit -> (('a -> WriterState -> 'b) -> unit) * ('a -> WriterState -> 'b) + val p_hole2: + unit -> + (('a -> 'b -> WriterState -> 'c) -> unit) * + ('a -> 'b -> WriterState -> 'c) + val u_array_core: f:('a -> 'b) -> n:int -> st:'a -> 'b [] + val u_array: (ReaderState -> 'T) -> (ReaderState -> 'T []) + val u_array_ext: + extraf:(ReaderState -> 'a) -> + f:(ReaderState -> 'b) -> st:ReaderState -> 'a option * 'b [] + val u_list_core: f:('a -> 'b) -> n:int -> st:'a -> 'b list + val u_list: f:(ReaderState -> 'a) -> st:ReaderState -> 'a list + val u_list_ext: + extra:(ReaderState -> 'a) -> + f:(ReaderState -> 'b) -> st:ReaderState -> 'a option * 'b list + val u_List: f:(ReaderState -> 'a) -> st:ReaderState -> 'a list + val u_array_revi: f:(ReaderState -> int -> 'a) -> st:ReaderState -> 'a [] + val u_list_revi: f:(ReaderState -> int -> 'a) -> st:ReaderState -> 'a list + val u_wrap: f:('U -> 'T) -> u:unpickler<'U> -> st:ReaderState -> 'T + val u_option: f:(ReaderState -> 'a) -> st:ReaderState -> 'a option + val u_lazy: (ReaderState -> 'T) -> (ReaderState -> System.Lazy<'T>) + val u_hole: unit -> ((ReaderState -> 'a) -> unit) * (ReaderState -> 'a) + val encode_string: stringTab:Table<'a> -> x:'a -> int + val decode_string: x:'a -> 'a + val lookup_string: + st:ReaderState -> stringTab:InputTable<'a> -> x:int -> 'a + val u_encoded_string: (ReaderState -> string) + val u_string: ReaderState -> string + val u_strings: (ReaderState -> string list) + val u_ints: (ReaderState -> int list) + val p_encoded_string: (string -> WriterState -> unit) + val p_string: string -> WriterState -> unit + val p_strings: (string list -> WriterState -> unit) + val p_ints: (int list -> WriterState -> unit) + val encode_ccuref: ccuTab:Table -> x:TypedTree.CcuThunk -> int + val decode_ccuref: x:'a -> 'a + val lookup_ccuref: st:ReaderState -> ccuTab:InputTable<'a> -> x:int -> 'a + val u_encoded_ccuref: st:ReaderState -> string + val u_ccuref: st:ReaderState -> TypedTree.CcuThunk + val p_encoded_ccuref: x:string -> st:WriterState -> unit + val p_ccuref: s:TypedTree.CcuThunk -> st:WriterState -> unit + val decode_pubpath: + st:ReaderState -> + stringTab:InputTable -> a:int [] -> TypedTree.PublicPath + val lookup_pubpath: + st:ReaderState -> pubpathTab:InputTable<'a> -> x:int -> 'a + val u_encoded_pubpath: (ReaderState -> int []) + val u_pubpath: st:ReaderState -> TypedTree.PublicPath + val encode_pubpath: + stringTab:Table -> + pubpathTab:Table -> TypedTree.PublicPath -> int + val p_encoded_pubpath: (int [] -> WriterState -> unit) + val p_pubpath: x:TypedTree.PublicPath -> st:WriterState -> unit + val decode_nleref: + st:ReaderState -> + ccuTab:InputTable -> + stringTab:InputTable -> + a:int * b:int [] -> TypedTree.NonLocalEntityRef + val lookup_nleref: + st:ReaderState -> nlerefTab:InputTable<'a> -> x:int -> 'a + val u_encoded_nleref: (ReaderState -> int * int []) + val u_nleref: st:ReaderState -> TypedTree.NonLocalEntityRef + val encode_nleref: + ccuTab:Table -> + stringTab:Table -> + nlerefTab:Table -> + thisCcu:TypedTree.CcuThunk -> + nleref:TypedTree.NonLocalEntityRef -> int + val p_encoded_nleref: (int * int [] -> WriterState -> unit) + val p_nleref: x:TypedTree.NonLocalEntityRef -> st:WriterState -> unit + val decode_simpletyp: + st:ReaderState -> + _ccuTab:'a -> + _stringTab:'b -> + nlerefTab:InputTable -> + a:int -> TypedTree.TType + val lookup_simpletyp: + st:ReaderState -> simpleTyTab:InputTable<'a> -> x:int -> 'a + val u_encoded_simpletyp: st:ReaderState -> int + val u_encoded_anoninfo: st:ReaderState -> int + val u_simpletyp: st:ReaderState -> TypedTree.TType + val encode_simpletyp: + ccuTab:Table -> + stringTab:Table -> + nlerefTab:Table -> + simpleTyTab:Table -> + thisCcu:TypedTree.CcuThunk -> a:TypedTree.NonLocalEntityRef -> int + val p_encoded_simpletyp: x:int -> st:WriterState -> unit + val p_encoded_anoninfo: x:int -> st:WriterState -> unit + val p_simpletyp: x:TypedTree.NonLocalEntityRef -> st:WriterState -> unit + val pickleObjWithDanglingCcus: + inMem:bool -> + file:string -> + TcGlobals.TcGlobals -> + scope:TypedTree.CcuThunk -> + ('T -> WriterState -> unit) -> 'T -> byte [] + val check: + ilscope:AbstractIL.IL.ILScopeRef -> inMap:NodeInTable<'a,'b> -> unit + val unpickleObjWithDanglingCcus: + file:string -> + viewedScope:AbstractIL.IL.ILScopeRef -> + ilModule:AbstractIL.IL.ILModuleDef option -> + (ReaderState -> 'T) -> + AbstractIL.Internal.ReadOnlyByteMemory -> + PickledDataWithReferences<'T> + val p_ILPublicKey: x:AbstractIL.IL.PublicKey -> st:WriterState -> unit + val p_ILVersion: x:AbstractIL.IL.ILVersionInfo -> st:WriterState -> unit + val p_ILModuleRef: x:AbstractIL.IL.ILModuleRef -> st:WriterState -> unit + val p_ILAssemblyRef: + x:AbstractIL.IL.ILAssemblyRef -> st:WriterState -> unit + val p_ILScopeRef: x:AbstractIL.IL.ILScopeRef -> st:WriterState -> unit + val u_ILPublicKey: st:ReaderState -> AbstractIL.IL.PublicKey + val u_ILVersion: st:ReaderState -> AbstractIL.IL.ILVersionInfo + val u_ILModuleRef: st:ReaderState -> AbstractIL.IL.ILModuleRef + val u_ILAssemblyRef: st:ReaderState -> AbstractIL.IL.ILAssemblyRef + val u_ILScopeRef: st:ReaderState -> AbstractIL.IL.ILScopeRef + val p_ILHasThis: x:AbstractIL.IL.ILThisConvention -> st:WriterState -> unit + val p_ILArrayShape: AbstractIL.IL.ILArrayShape pickler + val p_ILType: ty:AbstractIL.IL.ILType -> st:WriterState -> unit + val p_ILTypes: tys:AbstractIL.IL.ILType list -> (WriterState -> unit) + val p_ILBasicCallConv: + x:AbstractIL.IL.ILArgConvention -> st:WriterState -> unit + val p_ILCallConv: AbstractIL.IL.ILCallingConv -> st:WriterState -> unit + val p_ILCallSig: + x:AbstractIL.IL.ILCallingSignature -> st:WriterState -> unit + val p_ILTypeRef: x:AbstractIL.IL.ILTypeRef -> st:WriterState -> unit + val p_ILTypeSpec: a:AbstractIL.IL.ILTypeSpec -> st:WriterState -> unit + val u_ILBasicCallConv: st:ReaderState -> AbstractIL.IL.ILArgConvention + val u_ILHasThis: st:ReaderState -> AbstractIL.IL.ILThisConvention + val u_ILCallConv: st:ReaderState -> AbstractIL.IL.ILCallingConv + val u_ILTypeRef: st:ReaderState -> AbstractIL.IL.ILTypeRef + val u_ILArrayShape: unpickler + val u_ILType: st:ReaderState -> AbstractIL.IL.ILType + val u_ILTypes: st:ReaderState -> AbstractIL.IL.ILType list + val u_ILCallSig: (ReaderState -> AbstractIL.IL.ILCallingSignature) + val u_ILTypeSpec: st:ReaderState -> AbstractIL.IL.ILTypeSpec + val p_ILMethodRef: x:AbstractIL.IL.ILMethodRef -> st:WriterState -> unit + val p_ILFieldRef: x:AbstractIL.IL.ILFieldRef -> st:WriterState -> unit + val p_ILMethodSpec: x:AbstractIL.IL.ILMethodSpec -> st:WriterState -> unit + val p_ILFieldSpec: x:AbstractIL.IL.ILFieldSpec -> st:WriterState -> unit + val p_ILBasicType: x:AbstractIL.IL.ILBasicType -> st:WriterState -> unit + val p_ILVolatility: x:AbstractIL.IL.ILVolatility -> st:WriterState -> unit + val p_ILReadonly: x:AbstractIL.IL.ILReadonly -> st:WriterState -> unit + val u_ILMethodRef: st:ReaderState -> AbstractIL.IL.ILMethodRef + val u_ILFieldRef: st:ReaderState -> AbstractIL.IL.ILFieldRef + val u_ILMethodSpec: st:ReaderState -> AbstractIL.IL.ILMethodSpec + val u_ILFieldSpec: st:ReaderState -> AbstractIL.IL.ILFieldSpec + val u_ILBasicType: st:ReaderState -> AbstractIL.IL.ILBasicType + val u_ILVolatility: st:ReaderState -> AbstractIL.IL.ILVolatility + val u_ILReadonly: st:ReaderState -> AbstractIL.IL.ILReadonly + [] + val itag_nop: int = 0 + [] + val itag_ldarg: int = 1 + [] + val itag_ldnull: int = 2 + [] + val itag_ilzero: int = 3 + [] + val itag_call: int = 4 + [] + val itag_add: int = 5 + [] + val itag_sub: int = 6 + [] + val itag_mul: int = 7 + [] + val itag_div: int = 8 + [] + val itag_div_un: int = 9 + [] + val itag_rem: int = 10 + [] + val itag_rem_un: int = 11 + [] + val itag_and: int = 12 + [] + val itag_or: int = 13 + [] + val itag_xor: int = 14 + [] + val itag_shl: int = 15 + [] + val itag_shr: int = 16 + [] + val itag_shr_un: int = 17 + [] + val itag_neg: int = 18 + [] + val itag_not: int = 19 + [] + val itag_conv: int = 20 + [] + val itag_conv_un: int = 21 + [] + val itag_conv_ovf: int = 22 + [] + val itag_conv_ovf_un: int = 23 + [] + val itag_callvirt: int = 24 + [] + val itag_ldobj: int = 25 + [] + val itag_ldstr: int = 26 + [] + val itag_castclass: int = 27 + [] + val itag_isinst: int = 28 + [] + val itag_unbox: int = 29 + [] + val itag_throw: int = 30 + [] + val itag_ldfld: int = 31 + [] + val itag_ldflda: int = 32 + [] + val itag_stfld: int = 33 + [] + val itag_ldsfld: int = 34 + [] + val itag_ldsflda: int = 35 + [] + val itag_stsfld: int = 36 + [] + val itag_stobj: int = 37 + [] + val itag_box: int = 38 + [] + val itag_newarr: int = 39 + [] + val itag_ldlen: int = 40 + [] + val itag_ldelema: int = 41 + [] + val itag_ckfinite: int = 42 + [] + val itag_ldtoken: int = 43 + [] + val itag_add_ovf: int = 44 + [] + val itag_add_ovf_un: int = 45 + [] + val itag_mul_ovf: int = 46 + [] + val itag_mul_ovf_un: int = 47 + [] + val itag_sub_ovf: int = 48 + [] + val itag_sub_ovf_un: int = 49 + [] + val itag_ceq: int = 50 + [] + val itag_cgt: int = 51 + [] + val itag_cgt_un: int = 52 + [] + val itag_clt: int = 53 + [] + val itag_clt_un: int = 54 + [] + val itag_ldvirtftn: int = 55 + [] + val itag_localloc: int = 56 + [] + val itag_rethrow: int = 57 + [] + val itag_sizeof: int = 58 + [] + val itag_ldelem_any: int = 59 + [] + val itag_stelem_any: int = 60 + [] + val itag_unbox_any: int = 61 + [] + val itag_ldlen_multi: int = 62 + [] + val itag_initobj: int = 63 + [] + val itag_initblk: int = 64 + [] + val itag_cpobj: int = 65 + [] + val itag_cpblk: int = 66 + val simple_instrs: (int * AbstractIL.IL.ILInstr) list + val encode_table: + System.Collections.Generic.Dictionary + val encode_instr: si:AbstractIL.IL.ILInstr -> int + val isNoArgInstr: s:AbstractIL.IL.ILInstr -> bool + val decoders: (int * (ReaderState -> AbstractIL.IL.ILInstr)) list + val decode_tab: (ReaderState -> AbstractIL.IL.ILInstr) [] + val p_ILInstr: x:AbstractIL.IL.ILInstr -> st:WriterState -> unit + val u_ILInstr: st:ReaderState -> AbstractIL.IL.ILInstr + val p_Map_core: + pk:('a -> 'b -> unit) -> + pv:('c -> 'b -> unit) -> xs:Map<'a,'c> -> st:'b -> unit + when 'a: comparison + val p_Map: + pk:('a -> WriterState -> unit) -> + pv:('b -> WriterState -> unit) -> x:Map<'a,'b> -> st:WriterState -> unit + when 'a: comparison + val p_qlist: + pv:('a -> WriterState -> unit) -> Internal.Utilities.QueueList<'a> pickler + val p_namemap: + ('T -> WriterState -> unit) -> (Map -> WriterState -> unit) + val u_Map_core: + uk:('a -> 'b) -> uv:('a -> 'c) -> n:int -> st:'a -> Map<'b,'c> + when 'b: comparison + val u_Map: + uk:(ReaderState -> 'a) -> + uv:(ReaderState -> 'b) -> st:ReaderState -> Map<'a,'b> + when 'a: comparison + val u_qlist: + uv:(ReaderState -> 'a) -> unpickler> + val u_namemap: (ReaderState -> 'T) -> (ReaderState -> Map) + val p_pos: x:Range.pos -> st:WriterState -> unit + val p_range: x:Range.range -> st:WriterState -> unit + val p_dummy_range: _x:Range.range -> _st:WriterState -> unit + val p_ident: x:SyntaxTree.Ident -> st:WriterState -> unit + val p_xmldoc: doc:XmlDoc.XmlDoc -> st:WriterState -> unit + val u_pos: st:ReaderState -> Range.pos + val u_range: st:ReaderState -> Range.range + val u_dummy_range: _st:ReaderState -> Range.range + val u_ident: st:ReaderState -> SyntaxTree.Ident + val u_xmldoc: st:ReaderState -> XmlDoc.XmlDoc + val p_local_item_ref: + ctxt:string -> tab:NodeOutTable<'a,'b> -> st:'b -> (WriterState -> unit) + val p_tcref: string -> (TypedTree.EntityRef -> WriterState -> unit) + val p_ucref: (TypedTree.UnionCaseRef -> WriterState -> unit) + val p_rfref: TypedTree.RecdFieldRef -> st:WriterState -> unit + val p_tpref: x:TypedTree.Typar -> st:WriterState -> unit + val u_local_item_ref: tab:NodeInTable<'a,'b> -> st:ReaderState -> 'b + val u_tcref: (ReaderState -> TypedTree.EntityRef) + val u_ucref: (ReaderState -> TypedTree.UnionCaseRef) + val u_rfref: st:ReaderState -> TypedTree.RecdFieldRef + val u_tpref: st:ReaderState -> TypedTree.Typar + val p_ty2: (bool -> TypedTree.TType -> WriterState -> unit) + val fill_p_ty2: ((bool -> TypedTree.TType -> WriterState -> unit) -> unit) + val p_ty: (TypedTree.TType -> WriterState -> unit) + val p_tys: (TypedTree.TType list -> WriterState -> unit) + val p_attribs: (TypedTree.Attribs -> WriterState -> unit) + val fill_p_attribs: ((TypedTree.Attribs -> WriterState -> unit) -> unit) + val checkForInRefStructThisArg: + st:WriterState -> ty:TypedTree.TType -> bool + val p_nonlocal_val_ref: + nlv:TypedTree.NonLocalValOrMemberRef -> st:WriterState -> unit + val p_vref: string -> (TypedTree.ValRef -> WriterState -> unit) + val p_vrefs: ctxt:string -> (TypedTree.ValRef list -> WriterState -> unit) + val u_ty: (ReaderState -> TypedTree.TType) + val fill_u_ty: ((ReaderState -> TypedTree.TType) -> unit) + val u_tys: (ReaderState -> TypedTree.TType list) + val u_attribs: (ReaderState -> TypedTree.Attrib list) + val fill_u_attribs: ((ReaderState -> TypedTree.Attrib list) -> unit) + val u_nonlocal_val_ref: st:ReaderState -> TypedTree.NonLocalValOrMemberRef + val u_vref: (ReaderState -> TypedTree.ValRef) + val u_vrefs: (ReaderState -> TypedTree.ValRef list) + val p_kind: x:TypedTree.TyparKind -> st:WriterState -> unit + val p_member_kind: x:SyntaxTree.MemberKind -> st:WriterState -> unit + val u_kind: st:ReaderState -> TypedTree.TyparKind + val u_member_kind: st:ReaderState -> SyntaxTree.MemberKind + val p_MemberFlags: x:SyntaxTree.MemberFlags -> st:WriterState -> unit + val u_MemberFlags: st:ReaderState -> SyntaxTree.MemberFlags + val u_expr_fwd: (ReaderState -> TypedTree.Expr) + val fill_u_Expr_hole: ((ReaderState -> TypedTree.Expr) -> unit) + val p_expr_fwd: (TypedTree.Expr -> WriterState -> unit) + val fill_p_Expr_hole: ((TypedTree.Expr -> WriterState -> unit) -> unit) + val p_anonInfo_data: + anonInfo:TypedTree.AnonRecdTypeInfo -> st:WriterState -> unit + val p_anonInfo: x:TypedTree.AnonRecdTypeInfo -> st:WriterState -> unit + val p_trait_sln: sln:TypedTree.TraitConstraintSln -> st:WriterState -> unit + val p_trait: TypedTree.TraitConstraintInfo -> st:WriterState -> unit + val u_anonInfo_data: st:ReaderState -> TypedTree.AnonRecdTypeInfo + val u_anonInfo: st:ReaderState -> TypedTree.AnonRecdTypeInfo + val u_trait_sln: st:ReaderState -> TypedTree.TraitConstraintSln + val u_trait: st:ReaderState -> TypedTree.TraitConstraintInfo + val p_rational: q:Rational.Rational -> st:WriterState -> unit + val p_measure_con: tcref:TypedTree.EntityRef -> st:WriterState -> unit + val p_measure_var: v:TypedTree.Typar -> st:WriterState -> unit + val p_measure_one: (WriterState -> unit) + val p_measure_varcon: unt:TypedTree.Measure -> st:WriterState -> unit + val p_measure_pospower: + unt:TypedTree.Measure -> n:int -> st:WriterState -> unit + val p_measure_intpower: + unt:TypedTree.Measure -> n:int -> st:WriterState -> unit + val p_measure_power: + unt:TypedTree.Measure -> q:Rational.Rational -> st:WriterState -> unit + val p_normalized_measure: unt:TypedTree.Measure -> st:WriterState -> unit + val p_measure_expr: unt:TypedTree.Measure -> st:WriterState -> unit + val u_rational: st:ReaderState -> Rational.Rational + val u_measure_expr: st:ReaderState -> TypedTree.Measure + val p_tyar_constraint: + x:TypedTree.TyparConstraint -> st:WriterState -> unit + val p_tyar_constraints: + (TypedTree.TyparConstraint list -> WriterState -> unit) + val u_tyar_constraint: st:ReaderState -> (int -> TypedTree.TyparConstraint) + val u_tyar_constraints: (ReaderState -> TypedTree.TyparConstraint list) + val p_tyar_spec_data: x:TypedTree.Typar -> st:WriterState -> unit + val p_tyar_spec: x:TypedTree.Typar -> st:WriterState -> unit + val p_tyar_specs: (TypedTree.Typar list -> WriterState -> unit) + val u_tyar_spec_data: st:ReaderState -> TypedTree.Typar + val u_tyar_spec: st:ReaderState -> TypedTree.Typar + val u_tyar_specs: (ReaderState -> TypedTree.Typar list) + val p_binds: (TypedTree.Bindings -> WriterState -> unit) + val fill_p_binds: ((TypedTree.Bindings -> WriterState -> unit) -> unit) + val p_targets: (TypedTree.DecisionTreeTarget array -> WriterState -> unit) + val fill_p_targets: + ((TypedTree.DecisionTreeTarget array -> WriterState -> unit) -> unit) + val p_Exprs: (TypedTree.Exprs -> WriterState -> unit) + val fill_p_Exprs: ((TypedTree.Exprs -> WriterState -> unit) -> unit) + val p_constraints: + (TypedTree.StaticOptimization list -> WriterState -> unit) + val fill_p_constraints: + ((TypedTree.StaticOptimization list -> WriterState -> unit) -> unit) + val p_Vals: (TypedTree.Val list -> WriterState -> unit) + val fill_p_Vals: ((TypedTree.Val list -> WriterState -> unit) -> unit) + val u_binds: (ReaderState -> TypedTree.Bindings) + val fill_u_binds: ((ReaderState -> TypedTree.Bindings) -> unit) + val u_targets: (ReaderState -> TypedTree.DecisionTreeTarget array) + val fill_u_targets: + ((ReaderState -> TypedTree.DecisionTreeTarget array) -> unit) + val u_Exprs: (ReaderState -> TypedTree.Exprs) + val fill_u_Exprs: ((ReaderState -> TypedTree.Exprs) -> unit) + val u_constraints: (ReaderState -> TypedTree.StaticOptimization list) + val fill_u_constraints: + ((ReaderState -> TypedTree.StaticOptimization list) -> unit) + val u_Vals: (ReaderState -> TypedTree.Val list) + val fill_u_Vals: ((ReaderState -> TypedTree.Val list) -> unit) + val p_ArgReprInfo: x:TypedTree.ArgReprInfo -> st:WriterState -> unit + val p_TyparReprInfo: TypedTree.TyparReprInfo -> st:WriterState -> unit + val p_ValReprInfo: TypedTree.ValReprInfo -> st:WriterState -> unit + val u_ArgReprInfo: st:ReaderState -> TypedTree.ArgReprInfo + val u_TyparReprInfo: st:ReaderState -> TypedTree.TyparReprInfo + val u_ValReprInfo: st:ReaderState -> TypedTree.ValReprInfo + val p_ranges: + x:(Range.range * Range.range) option -> st:WriterState -> unit + val p_istype: x:TypedTree.ModuleOrNamespaceKind -> st:WriterState -> unit + val p_cpath: TypedTree.CompilationPath -> st:WriterState -> unit + val u_ranges: st:ReaderState -> (Range.range * Range.range) option + val u_istype: st:ReaderState -> TypedTree.ModuleOrNamespaceKind + val u_cpath: st:ReaderState -> TypedTree.CompilationPath + val dummy: x:'a -> 'a + val p_tycon_repr: x:TypedTree.TyconRepresentation -> st:WriterState -> bool + val p_tycon_objmodel_data: + x:TypedTree.TyconObjModelData -> st:WriterState -> unit + val p_attribs_ext: + f:(WriterState -> unit) option -> + x:TypedTree.Attrib list -> st:WriterState -> unit + val p_unioncase_spec: x:TypedTree.UnionCase -> st:WriterState -> unit + val p_exnc_spec_data: x:TypedTree.Entity -> st:WriterState -> unit + val p_exnc_repr: x:TypedTree.ExceptionInfo -> st:WriterState -> unit + val p_exnc_spec: x:TypedTree.Entity -> st:WriterState -> unit + val p_access: TypedTree.Accessibility -> st:WriterState -> unit + val p_recdfield_spec: x:TypedTree.RecdField -> st:WriterState -> unit + val p_rfield_table: x:TypedTree.TyconRecdFields -> st:WriterState -> unit + val p_entity_spec_data: x:TypedTree.Entity -> st:WriterState -> unit + val p_tcaug: p:TypedTree.TyconAugmentation -> st:WriterState -> unit + val p_entity_spec: x:TypedTree.Entity -> st:WriterState -> unit + val p_parentref: x:TypedTree.ParentRef -> st:WriterState -> unit + val p_attribkind: x:TypedTree.AttribKind -> st:WriterState -> unit + val p_attrib: TypedTree.Attrib -> st:WriterState -> unit + val p_attrib_expr: TypedTree.AttribExpr -> st:WriterState -> unit + val p_attrib_arg: TypedTree.AttribNamedArg -> st:WriterState -> unit + val p_member_info: x:TypedTree.ValMemberInfo -> st:WriterState -> unit + val p_tycon_objmodel_kind: + x:TypedTree.TyconObjModelKind -> st:WriterState -> unit + val p_mustinline: x:TypedTree.ValInline -> st:WriterState -> unit + val p_basethis: x:TypedTree.ValBaseOrThisInfo -> st:WriterState -> unit + val p_vrefFlags: x:TypedTree.ValUseFlag -> st:WriterState -> unit + val p_ValData: x:TypedTree.Val -> st:WriterState -> unit + val p_Val: x:TypedTree.Val -> st:WriterState -> unit + val p_modul_typ: + x:TypedTree.ModuleOrNamespaceType -> st:WriterState -> unit + val u_tycon_repr: st:ReaderState -> (bool -> TypedTree.TyconRepresentation) + val u_tycon_objmodel_data: st:ReaderState -> TypedTree.TyconObjModelData + val u_attribs_ext: + extraf:(ReaderState -> 'a) -> + st:ReaderState -> 'a option * TypedTree.Attrib list + val u_unioncase_spec: st:ReaderState -> TypedTree.UnionCase + val u_exnc_spec_data: st:ReaderState -> TypedTree.Entity + val u_exnc_repr: st:ReaderState -> TypedTree.ExceptionInfo + val u_exnc_spec: st:ReaderState -> TypedTree.Tycon + val u_access: st:ReaderState -> TypedTree.Accessibility + val u_recdfield_spec: st:ReaderState -> TypedTree.RecdField + val u_rfield_table: st:ReaderState -> TypedTree.TyconRecdFields + val u_entity_spec_data: st:ReaderState -> TypedTree.Entity + val u_tcaug: st:ReaderState -> TypedTree.TyconAugmentation + val u_entity_spec: st:ReaderState -> TypedTree.Tycon + val u_parentref: st:ReaderState -> TypedTree.ParentRef + val u_attribkind: st:ReaderState -> TypedTree.AttribKind + val u_attrib: st:ReaderState -> TypedTree.Attrib + val u_attrib_expr: st:ReaderState -> TypedTree.AttribExpr + val u_attrib_arg: st:ReaderState -> TypedTree.AttribNamedArg + val u_member_info: st:ReaderState -> TypedTree.ValMemberInfo + val u_tycon_objmodel_kind: st:ReaderState -> TypedTree.TyconObjModelKind + val u_mustinline: st:ReaderState -> TypedTree.ValInline + val u_basethis: st:ReaderState -> TypedTree.ValBaseOrThisInfo + val u_vrefFlags: st:ReaderState -> TypedTree.ValUseFlag + val u_ValData: st:ReaderState -> TypedTree.Val + val u_Val: st:ReaderState -> TypedTree.Val + val u_modul_typ: st:ReaderState -> TypedTree.ModuleOrNamespaceType + val p_const: (TypedTree.Const -> WriterState -> unit) + val u_const: (ReaderState -> TypedTree.Const) + val p_dtree: x:TypedTree.DecisionTree -> st:WriterState -> unit + val p_dtree_case: TypedTree.DecisionTreeCase -> st:WriterState -> unit + val p_dtree_discrim: x:TypedTree.DecisionTreeTest -> st:WriterState -> unit + val p_target: TypedTree.DecisionTreeTarget -> st:WriterState -> unit + val p_bind: TypedTree.Binding -> st:WriterState -> unit + val p_lval_op_kind: x:TypedTree.LValueOperation -> st:WriterState -> unit + val p_recdInfo: + x:TypedTree.RecordConstructionInfo -> st:WriterState -> unit + val u_dtree: st:ReaderState -> TypedTree.DecisionTree + val u_dtree_case: st:ReaderState -> TypedTree.DecisionTreeCase + val u_dtree_discrim: st:ReaderState -> TypedTree.DecisionTreeTest + val u_target: st:ReaderState -> TypedTree.DecisionTreeTarget + val u_bind: st:ReaderState -> TypedTree.Binding + val u_lval_op_kind: st:ReaderState -> TypedTree.LValueOperation + val p_op: x:TypedTree.TOp -> st:WriterState -> unit + val u_op: st:ReaderState -> TypedTree.TOp + val p_expr: (TypedTree.Expr -> WriterState -> unit) + val u_expr: (ReaderState -> TypedTree.Expr) + val p_static_optimization_constraint: + x:TypedTree.StaticOptimization -> st:WriterState -> unit + val p_slotparam: TypedTree.SlotParam -> st:WriterState -> unit + val p_slotsig: TypedTree.SlotSig -> st:WriterState -> unit + val p_method: TypedTree.ObjExprMethod -> st:WriterState -> unit + val p_methods: x:TypedTree.ObjExprMethod list -> st:WriterState -> unit + val p_intf: + TypedTree.TType * TypedTree.ObjExprMethod list -> st:WriterState -> unit + val p_intfs: + x:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> + st:WriterState -> unit + val u_static_optimization_constraint: + st:ReaderState -> TypedTree.StaticOptimization + val u_slotparam: st:ReaderState -> TypedTree.SlotParam + val u_slotsig: st:ReaderState -> TypedTree.SlotSig + val u_method: st:ReaderState -> TypedTree.ObjExprMethod + val u_methods: st:ReaderState -> TypedTree.ObjExprMethod list + val u_intf: + st:ReaderState -> TypedTree.TType * TypedTree.ObjExprMethod list + val u_intfs: + st:ReaderState -> (TypedTree.TType * TypedTree.ObjExprMethod list) list + val pickleModuleOrNamespace: + mspec:TypedTree.Entity -> st:WriterState -> unit + val pickleCcuInfo: (TypedTree.PickledCcuInfo -> WriterState -> unit) + val unpickleModuleOrNamespace: st:ReaderState -> TypedTree.Tycon + val unpickleCcuInfo: ReaderState -> TypedTree.PickledCcuInfo + + +namespace FSharp.Compiler + module internal Import = + type AssemblyLoader = + interface + abstract member + FindCcuFromAssemblyRef: AbstractIL.Internal.Library.CompilationThreadToken * + Range.range * AbstractIL.IL.ILAssemblyRef -> + TypedTree.CcuResolutionResult + abstract member + GetProvidedAssemblyInfo: AbstractIL.Internal.Library.CompilationThreadToken * + Range.range * + Tainted -> + bool * + ExtensionTyping.ProvidedAssemblyStaticLinkingMap option + abstract member + RecordGeneratedTypeRoot: ExtensionTyping.ProviderGeneratedType -> + unit + + [] + type ImportMap = + + new: g:TcGlobals.TcGlobals * assemblyLoader:AssemblyLoader -> ImportMap + member + ILTypeRefToTyconRefCache: System.Collections.Concurrent.ConcurrentDictionary + member assemblyLoader: AssemblyLoader + member g: TcGlobals.TcGlobals + + val CanImportILScopeRef: + env:ImportMap -> m:Range.range -> scoref:AbstractIL.IL.ILScopeRef -> bool + val ImportTypeRefData: + env:ImportMap -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef * path:string [] * + typeName:System.String -> TypedTree.EntityRef + val ImportILTypeRefUncached: + env:ImportMap -> + m:Range.range -> tref:AbstractIL.IL.ILTypeRef -> TypedTree.EntityRef + val ImportILTypeRef: + ImportMap -> Range.range -> AbstractIL.IL.ILTypeRef -> TypedTree.TyconRef + val CanImportILTypeRef: + ImportMap -> Range.range -> AbstractIL.IL.ILTypeRef -> bool + val ImportTyconRefApp: + env:ImportMap -> + tcref:TypedTree.EntityRef -> + tyargs:TypedTree.TType list -> TypedTree.TType + val ImportILType: + ImportMap -> + Range.range -> + TypedTree.TType list -> AbstractIL.IL.ILType -> TypedTree.TType + val CanImportILType: + ImportMap -> Range.range -> AbstractIL.IL.ILType -> bool + val ImportProvidedNamedType: + ImportMap -> + Range.range -> + Tainted -> TypedTree.TyconRef + val ImportProvidedTypeAsILType: + ImportMap -> + Range.range -> + Tainted -> AbstractIL.IL.ILType + val ImportProvidedType: + ImportMap -> + Range.range -> Tainted -> TypedTree.TType + val ImportProvidedMethodBaseAsILMethodRef: + ImportMap -> + Range.range -> + Tainted -> + AbstractIL.IL.ILMethodRef + val ImportILGenericParameters: + (unit -> ImportMap) -> + Range.range -> + AbstractIL.IL.ILScopeRef -> + TypedTree.TType list -> + AbstractIL.IL.ILGenericParameterDefs -> TypedTree.Typar list + val multisetDiscriminateAndMap: + nodef:('Key -> ('Key list * 'Value) list -> 'a) -> + tipf:('Value -> 'a) -> items:('Key list * 'Value) list -> 'a list + when 'Key: equality + val ImportILTypeDef: + amap:(unit -> ImportMap) -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef -> + cpath:TypedTree.CompilationPath -> + enc:AbstractIL.IL.ILTypeDef list -> + nm:string -> tdef:AbstractIL.IL.ILTypeDef -> TypedTree.Entity + val ImportILTypeDefList: + amap:(unit -> ImportMap) -> + m:Range.range -> + cpath:TypedTree.CompilationPath -> + enc:AbstractIL.IL.ILTypeDef list -> + items:(string list * + (string * + Lazy)) list -> + TypedTree.ModuleOrNamespaceType + val ImportILTypeDefs: + amap:(unit -> ImportMap) -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef -> + cpath:TypedTree.CompilationPath -> + enc:AbstractIL.IL.ILTypeDef list -> + tdefs:AbstractIL.IL.ILTypeDefs -> + TypedTree.ModuleOrNamespaceType + val ImportILAssemblyMainTypeDefs: + amap:(unit -> ImportMap) -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef -> + modul:AbstractIL.IL.ILModuleDef -> TypedTree.ModuleOrNamespaceType + val ImportILAssemblyExportedType: + amap:(unit -> ImportMap) -> + m:Range.range -> + auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) -> + scoref:AbstractIL.IL.ILScopeRef -> + exportedType:AbstractIL.IL.ILExportedTypeOrForwarder -> + TypedTree.ModuleOrNamespaceType list + val ImportILAssemblyExportedTypes: + amap:(unit -> ImportMap) -> + m:Range.range -> + auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) -> + scoref:AbstractIL.IL.ILScopeRef -> + exportedTypes:AbstractIL.IL.ILExportedTypesAndForwarders -> + TypedTree.ModuleOrNamespaceType list + val ImportILAssemblyTypeDefs: + amap:(unit -> ImportMap) * m:Range.range * + auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) * + aref:AbstractIL.IL.ILAssemblyRef * mainmod:AbstractIL.IL.ILModuleDef -> + TypedTree.ModuleOrNamespaceType + val ImportILAssemblyTypeForwarders: + (unit -> ImportMap) * Range.range * + AbstractIL.IL.ILExportedTypesAndForwarders -> + Map<(string [] * string),Lazy> + val ImportILAssembly: + (unit -> ImportMap) * Range.range * + (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) * + AbstractIL.IL.ILScopeRef * sourceDir:string * filename:string option * + AbstractIL.IL.ILModuleDef * IEvent -> TypedTree.CcuThunk + + +namespace FSharp.Compiler + module internal Infos = + val ImportILType: + scoref:AbstractIL.IL.ILScopeRef -> + amap:Import.ImportMap -> + m:Range.range -> + importInst:TypedTree.TType list -> + ilty:AbstractIL.IL.ILType -> TypedTree.TType + val CanImportILType: + scoref:AbstractIL.IL.ILScopeRef -> + amap:Import.ImportMap -> + m:Range.range -> ilty:AbstractIL.IL.ILType -> bool + val isExnDeclTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val GetSuperTypeOfType: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ty:TypedTree.TType -> TypedTree.TType option + val mkSystemCollectionsGenericIListTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + [] + type SkipUnrefInterfaces = + | Yes + | No + val GetImmediateInterfacesOfType: + skipUnref:SkipUnrefInterfaces -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ty:TypedTree.TType -> TypedTree.TType list + [] + type AllowMultiIntfInstantiations = + | Yes + | No + val private FoldHierarchyOfTypeAux: + followInterfaces:bool -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + skipUnref:SkipUnrefInterfaces -> + visitor:(TypedTree.TType -> 'a -> 'a) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ty:TypedTree.TType -> acc:'a -> 'a + val FoldPrimaryHierarchyOfType: + f:(TypedTree.TType -> 'a -> 'a) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> acc:'a -> 'a + val FoldEntireHierarchyOfType: + f:(TypedTree.TType -> 'a -> 'a) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> acc:'a -> 'a + val IterateEntireHierarchyOfType: + f:(TypedTree.TType -> unit) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> unit + val ExistsInEntireHierarchyOfType: + f:(TypedTree.TType -> bool) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> bool + val SearchEntireHierarchyOfType: + f:(TypedTree.TType -> bool) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ty:TypedTree.TType -> TypedTree.TType option + val AllSuperTypesOfType: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> TypedTree.TType list + val AllInterfacesOfType: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> TypedTree.TType list + val HaveSameHeadType: + g:TcGlobals.TcGlobals -> + ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool + val HasHeadType: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> ty2:TypedTree.TType -> bool + val ExistsSameHeadTypeInHierarchy: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + typeToSearchFrom:TypedTree.TType -> + typeToLookFor:TypedTree.TType -> bool + val ExistsHeadTypeInEntireHierarchy: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + typeToSearchFrom:TypedTree.TType -> + tcrefToLookFor:TypedTree.TyconRef -> bool + val ImportILTypeFromMetadata: + amap:Import.ImportMap -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef -> + tinst:TypedTree.TType list -> + minst:TypedTree.TType list -> + ilty:AbstractIL.IL.ILType -> TypedTree.TType + val ImportILTypeFromMetadataWithAttributes: + amap:Import.ImportMap -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef -> + tinst:TypedTree.TType list -> + minst:TypedTree.TType list -> + ilty:AbstractIL.IL.ILType -> + cattrs:AbstractIL.IL.ILAttributes -> TypedTree.TType + val ImportParameterTypeFromMetadata: + amap:Import.ImportMap -> + m:Range.range -> + ilty:AbstractIL.IL.ILType -> + cattrs:AbstractIL.IL.ILAttributes -> + scoref:AbstractIL.IL.ILScopeRef -> + tinst:TypedTree.TType list -> + mist:TypedTree.TType list -> TypedTree.TType + val ImportReturnTypeFromMetadata: + amap:Import.ImportMap -> + m:Range.range -> + ilty:AbstractIL.IL.ILType -> + cattrs:AbstractIL.IL.ILAttributes -> + scoref:AbstractIL.IL.ILScopeRef -> + tinst:TypedTree.TType list -> + minst:TypedTree.TType list -> TypedTree.TType option + val CopyTyparConstraints: + m:Range.range -> + tprefInst:TypedTreeOps.TyparInst -> + tporig:TypedTree.Typar -> TypedTree.TyparConstraint list + val FixupNewTypars: + m:Range.range -> + formalEnclosingTypars:TypedTree.Typars -> + tinst:TypedTree.TType list -> + tpsorig:TypedTree.Typars -> + tps:TypedTree.Typars -> TypedTreeOps.TyparInst * TypedTree.TTypes + type ValRef with + member IsFSharpEventProperty: g:TcGlobals.TcGlobals -> bool + type ValRef with + member IsVirtualMember: bool + type ValRef with + member IsDispatchSlotMember: bool + type ValRef with + member IsDefiniteFSharpOverrideMember: bool + type ValRef with + member + IsFSharpExplicitInterfaceImplementation: g:TcGlobals.TcGlobals -> bool + type ValRef with + member ImplementedSlotSignatures: TypedTree.SlotSig list + val GetCompiledReturnTyOfProvidedMethodInfo: + amap:Import.ImportMap -> + m:Range.range -> + mi:Tainted -> + TypedTree.TType option + val ReparentSlotSigToUseMethodTypars: + g:TcGlobals.TcGlobals -> + m:Range.range -> + ovByMethValRef:TypedTree.ValRef -> + slotsig:TypedTree.SlotSig -> TypedTree.SlotSig + val MakeSlotParam: + ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo -> TypedTree.SlotParam + val MakeSlotSig: + nm:string * ty:TypedTree.TType * ctps:TypedTree.Typars * + mtps:TypedTree.Typars * paraml:TypedTree.SlotParam list list * + retTy:TypedTree.TType option -> TypedTree.SlotSig + val private AnalyzeTypeOfMemberVal: + isCSharpExt:bool -> + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType * vref:TypedTree.ValRef -> + TypedTree.Typar list * TypedTree.Typars * TypedTree.TType option * + TypedTree.TType list + val private GetObjTypeOfInstanceExtensionMethod: + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> TypedTree.TType + val private GetArgInfosOfMember: + isCSharpExt:bool -> + g:TcGlobals.TcGlobals -> + vref:TypedTree.ValRef -> + (TypedTree.TType * TypedTree.ArgReprInfo) list list + val private CombineMethInsts: + ttps:TypedTree.Typars -> + mtps:TypedTree.Typars -> + tinst:TypedTree.TTypes -> + minst:TypedTree.TTypes -> (TypedTree.Typar * TypedTree.TType) list + val private GetInstantiationForMemberVal: + g:TcGlobals.TcGlobals -> + isCSharpExt:bool -> + ty:TypedTree.TType * vref:TypedTree.ValRef * + methTyArgs:TypedTree.TypeInst -> + (TypedTree.Typar * TypedTree.TType) list + val private GetInstantiationForPropertyVal: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType * vref:TypedTree.ValRef -> + (TypedTree.Typar * TypedTree.TType) list + type ExtensionMethodPriority = uint64 + type OptionalArgCallerSideValue = + | Constant of AbstractIL.IL.ILFieldInit + | DefaultValue + | MissingValue + | WrapperForIDispatch + | WrapperForIUnknown + | PassByRef of TypedTree.TType * OptionalArgCallerSideValue + type OptionalArgInfo = + | NotOptional + | CalleeSide + | CallerSide of OptionalArgCallerSideValue + with + static member + FieldInitForDefaultParameterValueAttrib: attrib:TypedTree.Attrib -> + AbstractIL.IL.ILFieldInit option + static member + FromILParameter: g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + ilScope:AbstractIL.IL.ILScopeRef -> + ilTypeInst:TypedTree.TType list -> + ilParam:AbstractIL.IL.ILParameter -> + OptionalArgInfo + static member + ValueOfDefaultParameterValueAttrib: TypedTree.Attrib -> + TypedTree.Expr option + member IsOptional: bool + + type CallerInfo = + | NoCallerInfo + | CallerLineNumber + | CallerMemberName + | CallerFilePath + with + override ToString: unit -> string + + [] + type ReflectedArgInfo = + | None + | Quote of bool + with + member AutoQuote: bool + + [] + type ParamNameAndType = + | ParamNameAndType of SyntaxTree.Ident option * TypedTree.TType + with + static member + FromArgInfo: ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo -> + ParamNameAndType + static member + FromMember: isCSharpExtMem:bool -> + g:TcGlobals.TcGlobals -> + vref:TypedTree.ValRef -> ParamNameAndType list list + static member + Instantiate: inst:TypedTreeOps.TyparInst -> + p:ParamNameAndType -> ParamNameAndType + static member + InstantiateCurried: inst:TypedTreeOps.TyparInst -> + paramTypes:ParamNameAndType list list -> + ParamNameAndType list list + + [] + type ParamData = + | ParamData of + isParamArray: bool * isInArg: bool * isOut: bool * + optArgInfo: OptionalArgInfo * callerInfo: CallerInfo * + nameOpt: SyntaxTree.Ident option * reflArgInfo: ReflectedArgInfo * + ttype: TypedTree.TType + type ILFieldInit with + static member + FromProvidedObj: m:Range.range -> v:obj -> AbstractIL.IL.ILFieldInit + val OptionalArgInfoOfProvidedParameter: + amap:Import.ImportMap -> + m:Range.range -> + provParam:Tainted -> + OptionalArgInfo + val GetAndSanityCheckProviderMethod: + m:Range.range -> + mi:Tainted<'T> -> + get:('T -> ExtensionTyping.ProvidedMethodInfo) -> + err:(string * string -> int * string) -> + Tainted + when 'T:> ExtensionTyping.ProvidedMemberInfo + val ArbitraryMethodInfoOfPropertyInfo: + pi:Tainted -> + m:Range.range -> Tainted + [] + type ILTypeInfo = + | ILTypeInfo of + TcGlobals.TcGlobals * TypedTree.TType * AbstractIL.IL.ILTypeRef * + AbstractIL.IL.ILTypeDef + with + static member + FromType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> ILTypeInfo + member Instantiate: inst:TypedTreeOps.TyparInst -> ILTypeInfo + member ILScopeRef: AbstractIL.IL.ILScopeRef + member ILTypeRef: AbstractIL.IL.ILTypeRef + member IsValueType: bool + member Name: string + member RawMetadata: AbstractIL.IL.ILTypeDef + member TcGlobals: TcGlobals.TcGlobals + member ToAppType: TypedTree.TType + member ToType: TypedTree.TType + member TyconRefOfRawMetadata: TypedTree.TyconRef + member TypeInstOfRawMetadata: TypedTree.TypeInst + + [] + type ILMethInfo = + | ILMethInfo of + TcGlobals.TcGlobals * TypedTree.TType * TypedTree.TyconRef option * + AbstractIL.IL.ILMethodDef * TypedTree.Typars + with + member + GetCompiledReturnTy: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> + TypedTree.TType option + member + GetFSharpReturnTy: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> TypedTree.TType + member + GetObjArgTypes: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> TypedTree.TType list + member + GetParamNamesAndTypes: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> + ParamNameAndType list + member + GetParamTypes: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> TypedTree.TType list + member + GetRawArgTypes: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> TypedTree.TType list + member IsDllImport: g:TcGlobals.TcGlobals -> bool + member IsReadOnly: g:TcGlobals.TcGlobals -> bool + member ApparentEnclosingAppType: TypedTree.TType + member ApparentEnclosingType: TypedTree.TType + member DeclaringTyconRef: TypedTree.TyconRef + member DeclaringTypeInst: TypedTree.TType list + member FormalMethodTypars: TypedTree.Typars + member ILExtensionMethodDeclaringTyconRef: TypedTree.TyconRef option + member ILMethodRef: AbstractIL.IL.ILMethodRef + member ILName: string + member IsAbstract: bool + member IsClassConstructor: bool + member IsConstructor: bool + member IsFinal: bool + member IsILExtensionMethod: bool + member IsInstance: bool + member IsNewSlot: bool + member IsProtectedAccessibility: bool + member IsStatic: bool + member IsVirtual: bool + member MetadataScope: AbstractIL.IL.ILScopeRef + member NumParams: int + member ParamMetadata: AbstractIL.IL.ILParameter list + member RawMetadata: AbstractIL.IL.ILMethodDef + member TcGlobals: TcGlobals.TcGlobals + + [] + type MethInfo = + | FSMeth of + TcGlobals.TcGlobals * TypedTree.TType * TypedTree.ValRef * + ExtensionMethodPriority option + | ILMeth of + TcGlobals.TcGlobals * ILMethInfo * ExtensionMethodPriority option + | DefaultStructCtor of TcGlobals.TcGlobals * TypedTree.TType + | ProvidedMeth of + Import.ImportMap * Tainted * + ExtensionMethodPriority option * Range.range + with + static member + CreateILExtensionMeth: amap:Import.ImportMap * m:Range.range * + apparentTy:TypedTree.TType * + declaringTyconRef:TypedTree.TyconRef * + extMethPri:ExtensionMethodPriority option * + md:AbstractIL.IL.ILMethodDef -> MethInfo + static member + CreateILMeth: amap:Import.ImportMap * m:Range.range * + ty:TypedTree.TType * md:AbstractIL.IL.ILMethodDef -> + MethInfo + static member + MethInfosUseIdenticalDefinitions: x1:MethInfo -> x2:MethInfo -> bool + member + AdjustUserTypeInstForFSharpStyleIndexedExtensionMembers: tyargs:TypedTree.TType list -> + TypedTree.TType list + member ComputeHashCode: unit -> int + member + GetCompiledReturnTy: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> + TypedTree.TType option + member + GetFSharpReturnTy: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> TypedTree.TType + member + GetFormalTyparsOfDeclaringType: m:Range.range -> TypedTree.Typar list + member + GetObjArgTypes: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TypeInst -> TypedTree.TType list + member + GetParamAttribs: amap:Import.ImportMap * m:Range.range -> + (bool * bool * bool * OptionalArgInfo * CallerInfo * + ReflectedArgInfo) list list + member + GetParamDatas: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> ParamData list list + member + GetParamTypes: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> + TypedTree.TType list list + member + GetSlotSig: amap:Import.ImportMap * m:Range.range -> + TypedTree.SlotSig + member + HasParamArrayArg: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> bool + member + Instantiate: amap:Import.ImportMap * m:Range.range * + inst:TypedTreeOps.TyparInst -> MethInfo + member + IsReadOnlyExtensionMember: amap:Import.ImportMap * m:Range.range -> + bool + member + ObjArgNeedsAddress: amap:Import.ImportMap * m:Range.range -> bool + override ToString: unit -> string + member + TryObjArgByrefType: amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TypeInst -> + TypedTree.TType option + member ApparentEnclosingAppType: TypedTree.TType + member ApparentEnclosingTyconRef: TypedTree.TyconRef + member ApparentEnclosingType: TypedTree.TType + member ArbitraryValRef: TypedTree.ValRef option + member DebuggerDisplayName: string + member DeclaringTyconRef: TypedTree.TyconRef + member DeclaringTypeInst: TypedTree.TType list + member DisplayName: string + member ExtensionMemberPriority: ExtensionMethodPriority + member ExtensionMemberPriorityOption: ExtensionMethodPriority option + member FormalMethodInst: TypedTree.TypeInst + member FormalMethodTyparInst: TypedTreeOps.TyparInst + member FormalMethodTypars: TypedTree.Typars + member GenericArity: int + member HasDirectXmlComment: bool + member ImplementedSlotSignatures: TypedTree.SlotSig list + member IsAbstract: bool + member IsCSharpStyleExtensionMember: bool + member IsClassConstructor: bool + member IsConstructor: bool + member IsCurried: bool + member IsDefiniteFSharpOverride: bool + member IsDispatchSlot: bool + member IsExtensionMember: bool + member IsFSharpEventPropertyMethod: bool + member IsFSharpExplicitInterfaceImplementation: bool + member IsFSharpStyleExtensionMember: bool + member IsFinal: bool + member IsILMethod: bool + member IsInstance: bool + member IsNewSlot: bool + member IsNullary: bool + member IsProtectedAccessibility: bool + member IsReadOnly: bool + member IsStruct: bool + member IsVirtual: bool + member LogicalName: string + member NumArgs: int list + member + ProvidedStaticParameterInfo: (Tainted * + Tainted []) option + member TcGlobals: TcGlobals.TcGlobals + member XmlDoc: XmlDoc.XmlDoc + + [] + type ILFieldInfo = + | ILFieldInfo of ILTypeInfo * AbstractIL.IL.ILFieldDef + | ProvidedField of + Import.ImportMap * Tainted * + Range.range + with + static member + ILFieldInfosUseIdenticalDefinitions: x1:ILFieldInfo -> + x2:ILFieldInfo -> bool + member ComputeHashCode: unit -> int + member + FieldType: amap:Import.ImportMap * m:Range.range -> TypedTree.TType + override ToString: unit -> string + member ApparentEnclosingAppType: TypedTree.TType + member ApparentEnclosingTyconRef: TypedTree.TyconRef + member ApparentEnclosingType: TypedTree.TType + member DeclaringTyconRef: TypedTree.TyconRef + member FieldName: string + member ILFieldRef: AbstractIL.IL.ILFieldRef + member ILFieldType: AbstractIL.IL.ILType + member ILTypeRef: AbstractIL.IL.ILTypeRef + member IsInitOnly: bool + member IsSpecialName: bool + member IsStatic: bool + member IsValueType: bool + member LiteralValue: AbstractIL.IL.ILFieldInit option + member ScopeRef: AbstractIL.IL.ILScopeRef + member TcGlobals: TcGlobals.TcGlobals + member TypeInst: TypedTree.TypeInst + + [] + type RecdFieldInfo = + | RecdFieldInfo of TypedTree.TypeInst * TypedTree.RecdFieldRef + with + override ToString: unit -> string + member DeclaringType: TypedTree.TType + member FieldType: TypedTree.TType + member IsStatic: bool + member LiteralValue: TypedTree.Const option + member Name: string + member RecdField: TypedTree.RecdField + member RecdFieldRef: TypedTree.RecdFieldRef + member Tycon: TypedTree.Entity + member TyconRef: TypedTree.TyconRef + member TypeInst: TypedTree.TypeInst + + [] + type UnionCaseInfo = + | UnionCaseInfo of TypedTree.TypeInst * TypedTree.UnionCaseRef + with + member GetTyparInst: m:Range.range -> TypedTreeOps.TyparInst + override ToString: unit -> string + member Name: string + member Tycon: TypedTree.Entity + member TyconRef: TypedTree.TyconRef + member TypeInst: TypedTree.TypeInst + member UnionCase: TypedTree.UnionCase + member UnionCaseRef: TypedTree.UnionCaseRef + + [] + type ILPropInfo = + | ILPropInfo of ILTypeInfo * AbstractIL.IL.ILPropertyDef + with + member + GetParamNamesAndTypes: amap:Import.ImportMap * m:Range.range -> + ParamNameAndType list + member + GetParamTypes: amap:Import.ImportMap * m:Range.range -> + TypedTree.TType list + member + GetPropertyType: amap:Import.ImportMap * m:Range.range -> + TypedTree.TType + override ToString: unit -> string + member ApparentEnclosingAppType: TypedTree.TType + member ApparentEnclosingType: TypedTree.TType + member GetterMethod: ILMethInfo + member HasGetter: bool + member HasSetter: bool + member ILTypeInfo: ILTypeInfo + member IsNewSlot: bool + member IsStatic: bool + member IsVirtual: bool + member PropertyName: string + member RawMetadata: AbstractIL.IL.ILPropertyDef + member SetterMethod: ILMethInfo + member TcGlobals: TcGlobals.TcGlobals + + [] + type PropInfo = + | FSProp of + TcGlobals.TcGlobals * TypedTree.TType * TypedTree.ValRef option * + TypedTree.ValRef option + | ILProp of ILPropInfo + | ProvidedProp of + Import.ImportMap * Tainted * + Range.range + with + static member + PropInfosUseIdenticalDefinitions: x1:PropInfo -> x2:PropInfo -> bool + member ComputeHashCode: unit -> int + member + GetParamDatas: amap:Import.ImportMap * m:Range.range -> + ParamData list + member + GetParamNamesAndTypes: amap:Import.ImportMap * m:Range.range -> + ParamNameAndType list + member + GetParamTypes: amap:Import.ImportMap * m:Range.range -> + TypedTree.TType list + member + GetPropertyType: amap:Import.ImportMap * m:Range.range -> + TypedTree.TType + override ToString: unit -> string + member ApparentEnclosingAppType: TypedTree.TType + member ApparentEnclosingTyconRef: TypedTree.TyconRef + member ApparentEnclosingType: TypedTree.TType + member ArbitraryValRef: TypedTree.ValRef option + member DeclaringTyconRef: TypedTree.EntityRef + member DropGetter: PropInfo + member DropSetter: PropInfo + member GetterMethod: MethInfo + member HasDirectXmlComment: bool + member HasGetter: bool + member HasSetter: bool + member ImplementedSlotSignatures: TypedTree.SlotSig list + member IsDefiniteFSharpOverride: bool + member IsDispatchSlot: bool + member IsExtensionMember: bool + member IsFSharpEventProperty: bool + member IsFSharpExplicitInterfaceImplementation: bool + member IsIndexer: bool + member IsNewSlot: bool + member IsStatic: bool + member IsValueType: bool + member IsVirtualProperty: bool + member PropertyName: string + member SetterMethod: MethInfo + member TcGlobals: TcGlobals.TcGlobals + member XmlDoc: XmlDoc.XmlDoc + + [] + type ILEventInfo = + | ILEventInfo of ILTypeInfo * AbstractIL.IL.ILEventDef + with + override ToString: unit -> string + member AddMethod: ILMethInfo + member ApparentEnclosingAppType: TypedTree.TType + member ApparentEnclosingType: TypedTree.TType + member DeclaringTyconRef: TypedTree.TyconRef + member ILTypeInfo: ILTypeInfo + member IsStatic: bool + member Name: string + member RawMetadata: AbstractIL.IL.ILEventDef + member RemoveMethod: ILMethInfo + member TcGlobals: TcGlobals.TcGlobals + member TypeRef: AbstractIL.IL.ILTypeRef + + exception BadEventTransformation of Range.range + val private tyConformsToIDelegateEvent: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val nonStandardEventError: nm:System.String -> m:Range.range -> exn + val FindDelegateTypeOfPropertyEvent: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + nm:System.String -> + m:Range.range -> ty:TypedTree.TType -> TypedTree.TType + [] + type EventInfo = + | FSEvent of + TcGlobals.TcGlobals * PropInfo * TypedTree.ValRef * TypedTree.ValRef + | ILEvent of ILEventInfo + | ProvidedEvent of + Import.ImportMap * Tainted * + Range.range + with + static member + EventInfosUseIdenticalDefinitions: x1:EventInfo -> + x2:EventInfo -> bool + member ComputeHashCode: unit -> int + member + GetDelegateType: amap:Import.ImportMap * m:Range.range -> + TypedTree.TType + override ToString: unit -> string + member AddMethod: MethInfo + member ApparentEnclosingAppType: TypedTree.TType + member ApparentEnclosingTyconRef: TypedTree.TyconRef + member ApparentEnclosingType: TypedTree.TType + member ArbitraryValRef: TypedTree.ValRef option + member DeclaringTyconRef: TypedTree.EntityRef + member EventName: string + member HasDirectXmlComment: bool + member IsExtensionMember: bool + member IsStatic: bool + member IsValueType: bool + member RemoveMethod: MethInfo + member TcGlobals: TcGlobals.TcGlobals + member XmlDoc: XmlDoc.XmlDoc + + val stripByrefTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + type CompiledSig = + | CompiledSig of + TypedTree.TType list list * TypedTree.TType option * TypedTree.Typars * + TypedTreeOps.TyparInst + val CompiledSigOfMeth: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> m:Range.range -> minfo:MethInfo -> CompiledSig + val MethInfosEquivByPartialSig: + erasureFlag:TypedTreeOps.Erasure -> + ignoreFinal:bool -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool + val MethInfosEquivByNameAndPartialSig: + erasureFlag:TypedTreeOps.Erasure -> + ignoreFinal:bool -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool + val PropInfosEquivByNameAndPartialSig: + erasureFlag:TypedTreeOps.Erasure -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> pinfo:PropInfo -> pinfo2:PropInfo -> bool + val MethInfosEquivByNameAndSig: + erasureFlag:TypedTreeOps.Erasure -> + ignoreFinal:bool -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool + val PropInfosEquivByNameAndSig: + erasureFlag:TypedTreeOps.Erasure -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> pinfo:PropInfo -> pinfo2:PropInfo -> bool + val SettersOfPropInfos: + pinfos:PropInfo list -> (MethInfo * PropInfo option) list + val GettersOfPropInfos: + pinfos:PropInfo list -> (MethInfo * PropInfo option) list + + +namespace FSharp.Compiler + module internal AccessibilityLogic = + [] + type AccessorDomain = + | AccessibleFrom of + TypedTree.CompilationPath list * TypedTree.TyconRef option + | AccessibleFromEverywhere + | AccessibleFromSomeFSharpCode + | AccessibleFromSomewhere + with + static member + CustomEquals: g:TcGlobals.TcGlobals * ad1:AccessorDomain * + ad2:AccessorDomain -> bool + static member CustomGetHashCode: ad:AccessorDomain -> int + + val IsAccessible: + ad:AccessorDomain -> taccess:TypedTree.Accessibility -> bool + val private IsILMemberAccessible: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + tcrefOfViewedItem:TypedTree.TyconRef -> + ad:AccessorDomain -> access:AbstractIL.IL.ILMemberAccess -> bool + val private IsILTypeDefAccessible: + amap:Import.ImportMap -> + m:Range.range -> + ad:AccessorDomain -> + encTyconRefOpt:TypedTree.TyconRef option -> + tdef:AbstractIL.IL.ILTypeDef -> bool + val private IsTyconAccessibleViaVisibleTo: + ad:AccessorDomain -> tcrefOfViewedItem:TypedTree.TyconRef -> bool + val private IsILTypeInfoAccessible: + amap:Import.ImportMap -> + m:Range.range -> + ad:AccessorDomain -> tcrefOfViewedItem:TypedTree.TyconRef -> bool + val private IsILTypeAndMemberAccessible: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + adType:AccessorDomain -> + ad:AccessorDomain -> + ty:Infos.ILTypeInfo -> + access:AbstractIL.IL.ILMemberAccess -> bool + val IsEntityAccessible: + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool + val CheckTyconAccessible: + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool + val IsTyconReprAccessible: + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool + val CheckTyconReprAccessible: + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool + val IsTypeAccessible: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> ty:TypedTree.TType -> bool + val IsTypeInstAccessible: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> tinst:TypedTree.TypeInst -> bool + val IsProvidedMemberAccessible: + amap:Import.ImportMap -> + m:Range.range -> + ad:AccessorDomain -> + ty:TypedTree.TType -> access:AbstractIL.IL.ILMemberAccess -> bool + val ComputeILAccess: + isPublic:bool -> + isFamily:bool -> + isFamilyOrAssembly:bool -> + isFamilyAndAssembly:bool -> AbstractIL.IL.ILMemberAccess + val IsILFieldInfoAccessible: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> x:Infos.ILFieldInfo -> bool + val GetILAccessOfILEventInfo: + Infos.ILEventInfo -> AbstractIL.IL.ILMemberAccess + val IsILEventInfoAccessible: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> einfo:Infos.ILEventInfo -> bool + val private IsILMethInfoAccessible: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + adType:AccessorDomain -> + ad:AccessorDomain -> ilminfo:Infos.ILMethInfo -> bool + val GetILAccessOfILPropInfo: + Infos.ILPropInfo -> AbstractIL.IL.ILMemberAccess + val IsILPropInfoAccessible: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> pinfo:Infos.ILPropInfo -> bool + val IsValAccessible: ad:AccessorDomain -> vref:TypedTree.ValRef -> bool + val CheckValAccessible: + m:Range.range -> ad:AccessorDomain -> vref:TypedTree.ValRef -> unit + val IsUnionCaseAccessible: + amap:Import.ImportMap -> + m:Range.range -> + ad:AccessorDomain -> ucref:TypedTree.UnionCaseRef -> bool + val CheckUnionCaseAccessible: + amap:Import.ImportMap -> + m:Range.range -> + ad:AccessorDomain -> ucref:TypedTree.UnionCaseRef -> bool + val IsRecdFieldAccessible: + amap:Import.ImportMap -> + m:Range.range -> + ad:AccessorDomain -> rfref:TypedTree.RecdFieldRef -> bool + val CheckRecdFieldAccessible: + amap:Import.ImportMap -> + m:Range.range -> + ad:AccessorDomain -> rfref:TypedTree.RecdFieldRef -> bool + val CheckRecdFieldInfoAccessible: + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> rfinfo:Infos.RecdFieldInfo -> unit + val CheckILFieldInfoAccessible: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> finfo:Infos.ILFieldInfo -> unit + val IsTypeAndMethInfoAccessible: + amap:Import.ImportMap -> + m:Range.range -> + accessDomainTy:AccessorDomain -> + ad:AccessorDomain -> _arg1:Infos.MethInfo -> bool + val IsMethInfoAccessible: + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> minfo:Infos.MethInfo -> bool + val IsPropInfoAccessible: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ad:AccessorDomain -> _arg1:Infos.PropInfo -> bool + val IsFieldInfoAccessible: + ad:AccessorDomain -> rfref:Infos.RecdFieldInfo -> bool + + +namespace FSharp.Compiler + module internal AttributeChecking = + exception ObsoleteWarning of string * Range.range + exception ObsoleteError of string * Range.range + val fail: unit -> 'a + val private evalILAttribElem: e:AbstractIL.IL.ILAttribElem -> obj + val private evalFSharpAttribArg: + g:TcGlobals.TcGlobals -> e:TypedTree.Expr -> obj + type AttribInfo = + | FSAttribInfo of TcGlobals.TcGlobals * TypedTree.Attrib + | ILAttribInfo of + TcGlobals.TcGlobals * Import.ImportMap * AbstractIL.IL.ILScopeRef * + AbstractIL.IL.ILAttribute * Range.range + with + member ConstructorArguments: (TypedTree.TType * obj) list + member NamedArguments: (TypedTree.TType * string * bool * obj) list + member Range: Range.range + member TyconRef: TypedTree.TyconRef + + val AttribInfosOfIL: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + scoref:AbstractIL.IL.ILScopeRef -> + m:Range.range -> + attribs:AbstractIL.IL.ILAttributes -> AttribInfo list + val AttribInfosOfFS: + g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> AttribInfo list + val GetAttribInfosOfEntity: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> tcref:TypedTree.TyconRef -> AttribInfo list + val GetAttribInfosOfMethod: + amap:Import.ImportMap -> + m:Range.range -> minfo:Infos.MethInfo -> AttribInfo list + val GetAttribInfosOfProp: + amap:Import.ImportMap -> + m:Range.range -> pinfo:Infos.PropInfo -> AttribInfo list + val GetAttribInfosOfEvent: + amap:Import.ImportMap -> + m:Range.range -> einfo:Infos.EventInfo -> AttribInfo list + val TryBindTyconRefAttribute: + g:TcGlobals.TcGlobals -> + m:Range.range -> + TcGlobals.BuiltinAttribInfo -> + tcref:TypedTree.TyconRef -> + f1:(AbstractIL.IL.ILAttribElem list * + AbstractIL.IL.ILAttributeNamedArg list -> 'a option) -> + f2:(TypedTree.Attrib -> 'a option) -> + f3:(obj option list * (string * obj option) list -> 'a option) -> + 'a option + val BindMethInfoAttributes: + m:Range.range -> + minfo:Infos.MethInfo -> + f1:(AbstractIL.IL.ILAttributes -> 'a) -> + f2:(TypedTree.Attrib list -> 'a) -> + f3:(Tainted -> + 'a) -> 'a + val TryBindMethInfoAttribute: + g:TcGlobals.TcGlobals -> + m:Range.range -> + TcGlobals.BuiltinAttribInfo -> + minfo:Infos.MethInfo -> + f1:(AbstractIL.IL.ILAttribElem list * + AbstractIL.IL.ILAttributeNamedArg list -> 'a option) -> + f2:(TypedTree.Attrib -> 'a option) -> + f3:(obj option list * (string * obj option) list -> 'a option) -> + 'a option + val TryFindMethInfoStringAttribute: + g:TcGlobals.TcGlobals -> + m:Range.range -> + attribSpec:TcGlobals.BuiltinAttribInfo -> + minfo:Infos.MethInfo -> string option + val MethInfoHasAttribute: + g:TcGlobals.TcGlobals -> + m:Range.range -> + attribSpec:TcGlobals.BuiltinAttribInfo -> minfo:Infos.MethInfo -> bool + val private CheckILAttributes: + g:TcGlobals.TcGlobals -> + isByrefLikeTyconRef:bool -> + cattrs:AbstractIL.IL.ILAttributes -> + m:Range.range -> ErrorLogger.OperationResult + val langVersionPrefix: string + val CheckFSharpAttributes: + g:TcGlobals.TcGlobals -> + attribs:TypedTree.Attrib list -> + m:Range.range -> ErrorLogger.OperationResult + val private CheckProvidedAttributes: + g:TcGlobals.TcGlobals -> + m:Range.range -> + provAttribs:Tainted -> + ErrorLogger.OperationResult + val CheckILAttributesForUnseen: + g:TcGlobals.TcGlobals -> + cattrs:AbstractIL.IL.ILAttributes -> _m:'a -> bool + val CheckFSharpAttributesForHidden: + g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> bool + val CheckFSharpAttributesForObsolete: + g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> bool + val CheckFSharpAttributesForUnseen: + g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> _m:'a -> bool + val CheckProvidedAttributesForUnseen: + provAttribs:Tainted -> + m:Range.range -> bool + val CheckPropInfoAttributes: + pinfo:Infos.PropInfo -> m:Range.range -> ErrorLogger.OperationResult + val CheckILFieldAttributes: + g:TcGlobals.TcGlobals -> finfo:Infos.ILFieldInfo -> m:Range.range -> unit + val CheckMethInfoAttributes: + g:TcGlobals.TcGlobals -> + m:Range.range -> + tyargsOpt:'a option -> + minfo:Infos.MethInfo -> ErrorLogger.OperationResult + val MethInfoIsUnseen: + g:TcGlobals.TcGlobals -> + m:Range.range -> ty:TypedTree.TType -> minfo:Infos.MethInfo -> bool + val PropInfoIsUnseen: m:'a -> pinfo:Infos.PropInfo -> bool + val CheckEntityAttributes: + g:TcGlobals.TcGlobals -> + x:TypedTree.TyconRef -> + m:Range.range -> ErrorLogger.OperationResult + val CheckUnionCaseAttributes: + g:TcGlobals.TcGlobals -> + x:TypedTree.UnionCaseRef -> + m:Range.range -> ErrorLogger.OperationResult + val CheckRecdFieldAttributes: + g:TcGlobals.TcGlobals -> + x:TypedTree.RecdFieldRef -> + m:Range.range -> ErrorLogger.OperationResult + val CheckValAttributes: + g:TcGlobals.TcGlobals -> + x:TypedTree.ValRef -> m:Range.range -> ErrorLogger.OperationResult + val CheckRecdFieldInfoAttributes: + g:TcGlobals.TcGlobals -> + x:Infos.RecdFieldInfo -> + m:Range.range -> ErrorLogger.OperationResult + val IsSecurityAttribute: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + casmap:System.Collections.Generic.Dictionary -> + TypedTree.Attrib -> m:Range.range -> bool + val IsSecurityCriticalAttribute: + g:TcGlobals.TcGlobals -> TypedTree.Attrib -> bool + + +namespace FSharp.Compiler + module internal TypeRelations = + val TypeDefinitelySubsumesTypeNoCoercion: + ndeep:int -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool + type CanCoerce = + | CanCoerce + | NoCoerce + val TypesFeasiblyEquivalent: + stripMeasures:bool -> + ndeep:int -> + g:TcGlobals.TcGlobals -> + amap:'a -> + m:Range.range -> + ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool + val TypesFeasiblyEquiv: + ndeep:int -> + g:TcGlobals.TcGlobals -> + amap:'a -> + m:Range.range -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool + val TypesFeasiblyEquivStripMeasures: + g:TcGlobals.TcGlobals -> + amap:'a -> + m:Range.range -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool + val TypeFeasiblySubsumesType: + ndeep:int -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + ty1:TypedTree.TType -> + canCoerce:CanCoerce -> ty2:TypedTree.TType -> bool + val ChooseTyparSolutionAndRange: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + tp:TypedTree.Typar -> TypedTree.TType * Range.range + val ChooseTyparSolution: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> tp:TypedTree.Typar -> TypedTree.TType + val IterativelySubstituteTyparSolutions: + g:TcGlobals.TcGlobals -> + tps:TypedTree.Typars -> solutions:TypedTree.TTypes -> TypedTree.TypeInst + val ChooseTyparSolutionsForFreeChoiceTypars: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> e:TypedTree.Expr -> TypedTree.Expr + val tryDestTopLambda: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + TypedTree.ValReprInfo -> + e:TypedTree.Expr * ty:TypedTree.TType -> + (TypedTree.Typars * TypedTree.Val option * TypedTree.Val option * + TypedTree.Val list list * TypedTree.Expr * TypedTree.TType) option + val destTopLambda: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + topValInfo:TypedTree.ValReprInfo -> + e:TypedTree.Expr * ty:TypedTree.TType -> + TypedTree.Typars * TypedTree.Val option * TypedTree.Val option * + TypedTree.Val list list * TypedTree.Expr * TypedTree.TType + val IteratedAdjustArityOfLambdaBody: + g:TcGlobals.TcGlobals -> + arities:int list -> + vsl:TypedTree.Val list list -> + body:TypedTree.Expr -> TypedTree.Val list list * TypedTree.Expr + val IteratedAdjustArityOfLambda: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + topValInfo:TypedTree.ValReprInfo -> + e:TypedTree.Expr -> + TypedTree.Typars * TypedTree.Val option * TypedTree.Val option * + TypedTree.Val list list * TypedTree.Expr * TypedTree.TType + val FindUniqueFeasibleSupertype: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + ty1:TypedTree.TType -> ty2:TypedTree.TType -> TypedTree.TType option + + +namespace FSharp.Compiler + module internal InfoReader = + val SelectImmediateMemberVals: + g:TcGlobals.TcGlobals -> + optFilter:string option -> + f:(TypedTree.ValMemberInfo -> TypedTree.ValRef -> 'a option) -> + tcref:TypedTree.TyconRef -> 'a list + val private checkFilter: optFilter:string option -> nm:string -> bool + val TrySelectMemberVal: + g:TcGlobals.TcGlobals -> + optFilter:string option -> + ty:TypedTree.TType -> + pri:Infos.ExtensionMethodPriority option -> + _membInfo:'a -> vref:TypedTree.ValRef -> Infos.MethInfo option + val GetImmediateIntrinsicMethInfosOfTypeAux: + optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + origTy:TypedTree.TType -> + metadataTy:TypedTree.TType -> Infos.MethInfo list + val GetImmediateIntrinsicMethInfosOfType: + optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list + type PropertyCollector = + + new: g:TcGlobals.TcGlobals * amap:Import.ImportMap * m:Range.range * + ty:TypedTree.TType * optFilter:string option * + ad:AccessibilityLogic.AccessorDomain -> PropertyCollector + member Close: unit -> Infos.PropInfo list + member + Collect: membInfo:TypedTree.ValMemberInfo * vref:TypedTree.ValRef -> + unit + + val GetImmediateIntrinsicPropInfosOfTypeAux: + optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + origTy:TypedTree.TType -> + metadataTy:TypedTree.TType -> Infos.PropInfo list + val GetImmediateIntrinsicPropInfosOfType: + optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list + val IsIndexerType: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> ty:TypedTree.TType -> bool + val GetMostSpecificItemsByType: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + f:('a -> (TypedTree.TType * Range.range) option) -> + xs:'a list -> 'a list + val GetMostSpecificMethodInfosByMethInfoSig: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + ty:TypedTree.TType * minfo:Infos.MethInfo -> + minfos:(TypedTree.TType * Infos.MethInfo) list -> + (TypedTree.TType * Infos.MethInfo) list + val FilterMostSpecificMethInfoSets: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + minfoSets:AbstractIL.Internal.Library.NameMultiMap -> + AbstractIL.Internal.Library.NameMultiMap + type HierarchyItem = + | MethodItem of Infos.MethInfo list list + | PropertyItem of Infos.PropInfo list list + | RecdFieldItem of Infos.RecdFieldInfo + | EventItem of Infos.EventInfo list + | ILFieldItem of Infos.ILFieldInfo list + type InfoReader = + + new: g:TcGlobals.TcGlobals * amap:Import.ImportMap -> InfoReader + member + GetEntireTypeHierarchy: allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * + m:Range.range * ty:TypedTree.TType -> + TypedTree.TType list + member + GetEventInfosOfType: optFilter:string option * + ad:AccessibilityLogic.AccessorDomain * + m:Range.range * ty:TypedTree.TType -> + Infos.EventInfo list + member + GetILFieldInfosOfType: optFilter:string option * + ad:AccessibilityLogic.AccessorDomain * + m:Range.range * ty:TypedTree.TType -> + Infos.ILFieldInfo list + member + GetImmediateIntrinsicEventsOfType: optFilter:string option * + ad:AccessibilityLogic.AccessorDomain * + m:Range.range * ty:TypedTree.TType -> + Infos.EventInfo list + member + GetIntrinsicMostSpecificOverrideMethodSetsOfType: optFilter:string option * + ad:AccessibilityLogic.AccessorDomain * + allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * + m:Range.range * + ty:TypedTree.TType -> + AbstractIL.Internal.Library.NameMultiMap + member + GetPrimaryTypeHierarchy: allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * + m:Range.range * ty:TypedTree.TType -> + TypedTree.TType list + member + GetRawIntrinsicMethodSetsOfType: optFilter:string option * + ad:AccessibilityLogic.AccessorDomain * + allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * + m:Range.range * ty:TypedTree.TType -> + Infos.MethInfo list list + member + GetRawIntrinsicPropertySetsOfType: optFilter:string option * + ad:AccessibilityLogic.AccessorDomain * + allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * + m:Range.range * ty:TypedTree.TType -> + Infos.PropInfo list list + member + GetRecordOrClassFieldsOfType: optFilter:string option * + ad:AccessibilityLogic.AccessorDomain * + m:Range.range * ty:TypedTree.TType -> + Infos.RecdFieldInfo list + member + IsLanguageFeatureRuntimeSupported: langFeature:Features.LanguageFeature -> + bool + member + TryFindNamedItemOfType: nm:string * + ad:AccessibilityLogic.AccessorDomain * + m:Range.range * ty:TypedTree.TType -> + HierarchyItem option + member + TryFindRecdOrClassFieldInfoOfType: nm:string * m:Range.range * + ty:TypedTree.TType -> + Infos.RecdFieldInfo voption + member amap: Import.ImportMap + member g: TcGlobals.TcGlobals + + val private tryLanguageFeatureRuntimeErrorAux: + infoReader:InfoReader -> + langFeature:Features.LanguageFeature -> + m:Range.range -> error:(exn -> unit) -> bool + val checkLanguageFeatureRuntimeError: + infoReader:InfoReader -> + langFeature:Features.LanguageFeature -> m:Range.range -> unit + val checkLanguageFeatureRuntimeErrorRecover: + infoReader:InfoReader -> + langFeature:Features.LanguageFeature -> m:Range.range -> unit + val tryLanguageFeatureRuntimeErrorRecover: + infoReader:InfoReader -> + langFeature:Features.LanguageFeature -> m:Range.range -> bool + val GetIntrinsicConstructorInfosOfTypeAux: + infoReader:InfoReader -> + m:Range.range -> + origTy:TypedTree.TType -> + metadataTy:TypedTree.TType -> Infos.MethInfo list + val GetIntrinsicConstructorInfosOfType: + infoReader:InfoReader -> + m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list + type FindMemberFlag = + | IgnoreOverrides + | PreferOverrides + type private IndexedList<'T> = + + new: itemLists:'T list list * + itemsByName:AbstractIL.Internal.Library.NameMultiMap<'T> -> + IndexedList<'T> + member AddItems: items:'T list * nmf:('T -> string) -> IndexedList<'T> + member + FilterNewItems: keepTest:('a -> 'T -> bool) -> + nmf:('a -> string) -> itemsToAdd:'a list -> 'a list + member ItemsWithName: nm:string -> 'T list + member Items: 'T list list + static member Empty: IndexedList<'T> + + val private FilterItemsInSubTypesBasedOnItemsInSuperTypes: + nmf:('a -> string) -> + keepTest:('a -> 'a -> bool) -> itemLists:'a list list -> 'a list list + val private FilterItemsInSuperTypesBasedOnItemsInSubTypes: + nmf:('a -> string) -> + keepTest:('a -> 'a list -> bool) -> + itemLists:'a list list -> 'a list list + val private ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes: + nmf:('a -> string) -> + equivTest:('a -> 'a -> bool) -> itemLists:'a list list -> 'a list list + val private FilterOverrides: + findFlag:FindMemberFlag -> + isVirt:('a -> bool) * isNewSlot:('a -> bool) * + isDefiniteOverride:('a -> bool) * isFinal:('a -> bool) * + equivSigs:('a -> 'a -> bool) * nmf:('a -> string) -> + items:'a list list -> 'a list list + val private FilterOverridesOfMethInfos: + findFlag:FindMemberFlag -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + minfos:Infos.MethInfo list list -> Infos.MethInfo list list + val private FilterOverridesOfPropInfos: + findFlag:FindMemberFlag -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + props:Infos.PropInfo list list -> Infos.PropInfo list list + val ExcludeHiddenOfMethInfos: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + minfos:Infos.MethInfo list list -> Infos.MethInfo list + val ExcludeHiddenOfPropInfos: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + pinfos:Infos.PropInfo list list -> Infos.PropInfo list + val GetIntrinsicMethInfoSetsOfType: + infoReader:InfoReader -> + optFilter:string option -> + ad:AccessibilityLogic.AccessorDomain -> + allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> + findFlag:FindMemberFlag -> + m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list list + val GetIntrinsicPropInfoSetsOfType: + infoReader:InfoReader -> + optFilter:string option -> + ad:AccessibilityLogic.AccessorDomain -> + allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> + findFlag:FindMemberFlag -> + m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list list + val GetIntrinsicMethInfosOfType: + infoReader:InfoReader -> + optFilter:string option -> + ad:AccessibilityLogic.AccessorDomain -> + allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> + findFlag:FindMemberFlag -> + m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list + val GetIntrinsicPropInfosOfType: + infoReader:InfoReader -> + optFilter:string option -> + ad:AccessibilityLogic.AccessorDomain -> + allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> + findFlag:FindMemberFlag -> + m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list + val TryFindIntrinsicNamedItemOfType: + infoReader:InfoReader -> + nm:string * ad:AccessibilityLogic.AccessorDomain -> + findFlag:FindMemberFlag -> + m:Range.range -> ty:TypedTree.TType -> HierarchyItem option + val TryFindIntrinsicMethInfo: + infoReader:InfoReader -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + nm:string -> ty:TypedTree.TType -> Infos.MethInfo list + val TryFindPropInfo: + infoReader:InfoReader -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + nm:string -> ty:TypedTree.TType -> Infos.PropInfo list + val GetIntrinisicMostSpecificOverrideMethInfoSetsOfType: + infoReader:InfoReader -> + m:Range.range -> + ty:TypedTree.TType -> + AbstractIL.Internal.Library.NameMultiMap + [] + type SigOfFunctionForDelegate = + | SigOfFunctionForDelegate of + Infos.MethInfo * TypedTree.TType list * TypedTree.TType * + TypedTree.TType + val GetSigOfFunctionForDelegate: + infoReader:InfoReader -> + delty:TypedTree.TType -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> SigOfFunctionForDelegate + val TryDestStandardDelegateType: + infoReader:InfoReader -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + delTy:TypedTree.TType -> (TypedTree.TType * TypedTree.TType) option + val IsStandardEventInfo: + infoReader:InfoReader -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> einfo:Infos.EventInfo -> bool + val ArgsTypOfEventInfo: + infoReader:InfoReader -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + einfo:Infos.EventInfo -> TypedTree.TType + val PropTypOfEventInfo: + infoReader:InfoReader -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + einfo:Infos.EventInfo -> TypedTree.TType + + +namespace FSharp.Compiler + module internal NicePrint = + module PrintUtilities = + val bracketIfL: + x:bool -> + lyt:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val squareAngleL: + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val angleL: + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val braceL: + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val braceBarL: + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val comment: str:string -> Internal.Utilities.StructuredFormat.Layout + val layoutsL: ls:Layout.layout list -> Layout.layout + val suppressInheritanceAndInterfacesForTyInSimplifiedDisplays: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> m:Range.range -> ty:TypedTree.TType -> bool + val applyMaxMembers: + maxMembers:int option -> + allDecls:Internal.Utilities.StructuredFormat.Layout list -> + Internal.Utilities.StructuredFormat.Layout list + val adjustILName: n:string -> string + val shrinkOverloads: + layoutFunction:('a -> Internal.Utilities.StructuredFormat.Layout) -> + resultFunction:('a -> Internal.Utilities.StructuredFormat.Layout -> 'b) -> + group:'a list -> 'b list + val layoutTyconRefImpl: + isAttribute:bool -> + denv:TypedTreeOps.DisplayEnv -> + tcref:TypedTree.TyconRef -> + Internal.Utilities.StructuredFormat.Layout + val layoutBuiltinAttribute: + denv:TypedTreeOps.DisplayEnv -> + attrib:TcGlobals.BuiltinAttribInfo -> + Internal.Utilities.StructuredFormat.Layout + + module private PrintIL = + val fullySplitILTypeRef: tref:AbstractIL.IL.ILTypeRef -> string list + val layoutILTypeRefName: + denv:TypedTreeOps.DisplayEnv -> + path:string list -> Internal.Utilities.StructuredFormat.Layout + val layoutILTypeRef: + denv:TypedTreeOps.DisplayEnv -> + tref:AbstractIL.IL.ILTypeRef -> + Internal.Utilities.StructuredFormat.Layout + val layoutILArrayShape: + AbstractIL.IL.ILArrayShape -> Internal.Utilities.StructuredFormat.Layout + val paramsL: ps:Layout.layout list -> Layout.layout + val pruneParams: + Name:string -> + ilTyparSubst:Layout.layout list -> Layout.layout list + val layoutILType: + denv:TypedTreeOps.DisplayEnv -> + ilTyparSubst:Layout.layout list -> + ty:AbstractIL.IL.ILType -> Layout.layout + val layoutILCallingSignature: + denv:TypedTreeOps.DisplayEnv -> + ilTyparSubst:Layout.layout list -> + cons:string option -> + signature:AbstractIL.IL.ILCallingSignature -> Layout.layout + val layoutILFieldInit: + x:AbstractIL.IL.ILFieldInit option -> + Internal.Utilities.StructuredFormat.Layout + val layoutILEnumDefParts: + nm:string -> + litVal:AbstractIL.IL.ILFieldInit option -> + Internal.Utilities.StructuredFormat.Layout + + module private PrintTypes = + val layoutConst: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> + c:TypedTree.Const -> Internal.Utilities.StructuredFormat.Layout + val layoutAccessibility: + denv:TypedTreeOps.DisplayEnv -> + accessibility:TypedTree.Accessibility -> + itemL:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val layoutTyconRef: + denv:TypedTreeOps.DisplayEnv -> + tycon:TypedTree.TyconRef -> Internal.Utilities.StructuredFormat.Layout + val layoutMemberFlags: + memFlags:SyntaxTree.MemberFlags -> + Internal.Utilities.StructuredFormat.Layout + val layoutAttribArg: + denv:TypedTreeOps.DisplayEnv -> + arg:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout + val layoutAttribArgs: + denv:TypedTreeOps.DisplayEnv -> + args:TypedTree.AttribExpr list -> + Internal.Utilities.StructuredFormat.Layout + val layoutAttrib: + denv:TypedTreeOps.DisplayEnv -> + TypedTree.Attrib -> Internal.Utilities.StructuredFormat.Layout + val layoutILAttribElement: + denv:TypedTreeOps.DisplayEnv -> + arg:AbstractIL.IL.ILAttribElem -> + Internal.Utilities.StructuredFormat.Layout + val layoutILAttrib: + denv:TypedTreeOps.DisplayEnv -> + ty:AbstractIL.IL.ILType * args:AbstractIL.IL.ILAttribElem list -> + Internal.Utilities.StructuredFormat.Layout + val layoutAttribs: + denv:TypedTreeOps.DisplayEnv -> + isValue:bool -> + ty:TypedTree.TType -> + kind:TypedTree.TyparKind -> + attrs:TypedTree.Attrib list -> + restL:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val layoutTyparAttribs: + denv:TypedTreeOps.DisplayEnv -> + kind:TypedTree.TyparKind -> + attrs:TypedTree.Attrib list -> + restL:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val layoutTyparRef: + denv:TypedTreeOps.DisplayEnv -> + typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val layoutTyparRefWithInfo: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val layoutConstraintsWithInfo: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + cxs:(TypedTree.Typar * TypedTree.TyparConstraint) list -> + Internal.Utilities.StructuredFormat.Layout + val layoutConstraintWithInfo: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + tp:TypedTree.Typar * tpc:TypedTree.TyparConstraint -> + Internal.Utilities.StructuredFormat.Layout list + val layoutTraitWithInfo: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + TypedTree.TraitConstraintInfo -> + Internal.Utilities.StructuredFormat.Layout + val layoutMeasure: + denv:TypedTreeOps.DisplayEnv -> + unt:TypedTree.Measure -> Internal.Utilities.StructuredFormat.Layout + val layoutTypeAppWithInfoAndPrec: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + tcL:Internal.Utilities.StructuredFormat.Layout -> + prec:int -> + prefix:bool -> + args:TypedTree.TType list -> + Internal.Utilities.StructuredFormat.Layout + val layoutTypeWithInfoAndPrec: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + prec:int -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val layoutTypesWithInfoAndPrec: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + prec:int -> + sep:Internal.Utilities.StructuredFormat.Layout -> + typl:TypedTree.TType list -> + Internal.Utilities.StructuredFormat.Layout + val layoutReturnType: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + rty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val layoutTypeWithInfo: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val layoutType: + denv:TypedTreeOps.DisplayEnv -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val layoutArgInfos: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> + Internal.Utilities.StructuredFormat.Layout list + val layoutGenericParameterTypes: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + _arg1:TypedTree.TType list -> + Internal.Utilities.StructuredFormat.Layout + val layoutTopType: + denv:TypedTreeOps.DisplayEnv -> + env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> + argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> + rty:TypedTree.TType -> + cxs:(TypedTree.Typar * TypedTree.TyparConstraint) list -> + Internal.Utilities.StructuredFormat.Layout + val layoutTyparDecls: + denv:TypedTreeOps.DisplayEnv -> + nmL:Internal.Utilities.StructuredFormat.Layout -> + prefix:bool -> + typars:TypedTree.Typars -> + Internal.Utilities.StructuredFormat.Layout + val layoutTyparConstraint: + denv:TypedTreeOps.DisplayEnv -> + tp:TypedTree.Typar * tpc:TypedTree.TyparConstraint -> + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfInstAndSig: + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst * tys:TypedTree.TTypes * + retTy:TypedTree.TType -> + TypedTreeOps.TyparInst * (TypedTree.TTypes * TypedTree.TType) * + (Internal.Utilities.StructuredFormat.Layout list * + Internal.Utilities.StructuredFormat.Layout) * + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfTopTypeInfoAux: + denv:TypedTreeOps.DisplayEnv -> + prettyArgInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> + prettyRetTy:TypedTree.TType -> + cxs:TypedTreeOps.TyparConstraintsWithTypars -> + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfUncurriedSig: + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst -> + argInfos:TypedTreeOps.UncurriedArgInfos -> + retTy:TypedTree.TType -> + TypedTreeOps.TyparInst * + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfCurriedMemberSig: + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst -> + argInfos:TypedTreeOps.CurriedArgInfos -> + retTy:TypedTree.TType -> + parentTyparTys:TypedTree.TTypes -> + TypedTreeOps.TyparInst * + Internal.Utilities.StructuredFormat.Layout + val prettyArgInfos: + denv:TypedTreeOps.DisplayEnv -> + allTyparInst:TypedTreeOps.TyparInst -> + _arg1:(TypedTree.TType * TypedTree.ArgReprInfo) list -> + (TypedTree.TType * TypedTree.ArgReprInfo) list + val prettyLayoutOfMemberSigCore: + denv:TypedTreeOps.DisplayEnv -> + memberToParentInst:(TypedTree.Typar * TypedTree.TType) list -> + typarInst:TypedTreeOps.TyparInst * methTypars:TypedTree.Typars * + argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list * + retTy:TypedTree.TType -> + TypedTreeOps.TyparInst * TypedTree.Typars * + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfMemberType: + denv:TypedTreeOps.DisplayEnv -> + v:TypedTree.ValRef -> + typarInst:TypedTreeOps.TyparInst -> + argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> + retTy:TypedTree.TType -> + TypedTreeOps.TyparInst * TypedTree.Typars * + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfMemberSig: + denv:TypedTreeOps.DisplayEnv -> + memberToParentInst:(TypedTree.Typar * TypedTree.TType) list * + nm:string * methTypars:TypedTree.Typars * + argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list * + retTy:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val prettyLayoutsOfUnresolvedOverloading: + denv:TypedTreeOps.DisplayEnv -> + argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list -> + retTy:TypedTree.TType -> + genParamTys:seq -> + Internal.Utilities.StructuredFormat.Layout * + Internal.Utilities.StructuredFormat.Layout * + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfType: + denv:TypedTreeOps.DisplayEnv -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfTypeNoConstraints: + denv:TypedTreeOps.DisplayEnv -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val layoutAssemblyName: _denv:'a -> ty:TypedTree.TType -> string + + module private PrintTastMemberOrVals = + val prettyLayoutOfMemberShortOption: + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst -> + v:TypedTree.Val -> + short:bool -> + TypedTreeOps.TyparInst * + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfMember: + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst -> + v:TypedTree.Val -> + TypedTreeOps.TyparInst * + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfMemberNoInstShort: + denv:TypedTreeOps.DisplayEnv -> + v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout + val layoutOfLiteralValue: + literalValue:TypedTree.Const -> + Internal.Utilities.StructuredFormat.Layout + val layoutNonMemberVal: + denv:TypedTreeOps.DisplayEnv -> + tps:TypedTree.Typar list * v:TypedTree.Val * tau:TypedTree.TType * + cxs:TypedTreeOps.TyparConstraintsWithTypars -> + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfValOrMember: + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst -> + v:TypedTree.Val -> + TypedTreeOps.TyparInst * + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfValOrMemberNoInst: + denv:TypedTreeOps.DisplayEnv -> + v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout + + val layoutTyparConstraint: + denv:TypedTreeOps.DisplayEnv -> + TypedTree.Typar * TypedTree.TyparConstraint -> + Internal.Utilities.StructuredFormat.Layout + val outputType: + denv:TypedTreeOps.DisplayEnv -> + os:System.Text.StringBuilder -> x:TypedTree.TType -> unit + val layoutType: + denv:TypedTreeOps.DisplayEnv -> + x:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val outputTypars: + denv:TypedTreeOps.DisplayEnv -> + nm:Layout.TaggedText -> + os:System.Text.StringBuilder -> x:TypedTree.Typars -> unit + val outputTyconRef: + denv:TypedTreeOps.DisplayEnv -> + os:System.Text.StringBuilder -> x:TypedTree.TyconRef -> unit + val layoutTyconRef: + denv:TypedTreeOps.DisplayEnv -> + x:TypedTree.TyconRef -> Internal.Utilities.StructuredFormat.Layout + val layoutConst: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> + c:TypedTree.Const -> Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfMemberSig: + denv:TypedTreeOps.DisplayEnv -> + (TypedTree.Typar * TypedTree.TType) list * string * TypedTree.Typars * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * TypedTree.TType -> + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfUncurriedSig: + denv:TypedTreeOps.DisplayEnv -> + argInfos:TypedTreeOps.TyparInst -> + tau:TypedTreeOps.UncurriedArgInfos -> + (TypedTree.TType -> + TypedTreeOps.TyparInst * + Internal.Utilities.StructuredFormat.Layout) + val prettyLayoutsOfUnresolvedOverloading: + denv:TypedTreeOps.DisplayEnv -> + argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list -> + retTy:TypedTree.TType -> + genericParameters:seq -> + Internal.Utilities.StructuredFormat.Layout * + Internal.Utilities.StructuredFormat.Layout * + Internal.Utilities.StructuredFormat.Layout + module InfoMemberPrinting = + val layoutParamData: + denv:TypedTreeOps.DisplayEnv -> + Infos.ParamData -> Internal.Utilities.StructuredFormat.Layout + val formatParamDataToBuffer: + denv:TypedTreeOps.DisplayEnv -> + os:System.Text.StringBuilder -> pd:Infos.ParamData -> unit + val private layoutMethInfoFSharpStyleCore: + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + minfo:Infos.MethInfo -> + minst:TypedTree.TType list -> + Internal.Utilities.StructuredFormat.Layout + val private layoutMethInfoCSharpStyle: + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + minfo:Infos.MethInfo -> + minst:TypedTree.TType list -> + Internal.Utilities.StructuredFormat.Layout + val prettifyILMethInfo: + amap:Import.ImportMap -> + m:Range.range -> + minfo:Infos.MethInfo -> + typarInst:TypedTreeOps.TyparInst -> + ilMethInfo:Infos.ILMethInfo -> + TypedTreeOps.TyparInst * Infos.MethInfo * TypedTree.TType list + val prettyLayoutOfMethInfoFreeStyle: + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst -> + methInfo:Infos.MethInfo -> + TypedTreeOps.TyparInst * + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfPropInfoFreeStyle: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + pinfo:Infos.PropInfo -> + Internal.Utilities.StructuredFormat.Layout + val formatMethInfoToBufferFreeStyle: + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + os:System.Text.StringBuilder -> minfo:Infos.MethInfo -> unit + val layoutMethInfoFSharpStyle: + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + minfo:Infos.MethInfo -> Internal.Utilities.StructuredFormat.Layout + + module private TastDefinitionPrinting = + val layoutExtensionMember: + denv:TypedTreeOps.DisplayEnv -> + v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout + val layoutExtensionMembers: + denv:TypedTreeOps.DisplayEnv -> + vs:TypedTree.Val list -> Internal.Utilities.StructuredFormat.Layout + val layoutRecdField: + addAccess:bool -> + denv:TypedTreeOps.DisplayEnv -> + fld:TypedTree.RecdField -> + Internal.Utilities.StructuredFormat.Layout + val layoutUnionOrExceptionField: + denv:TypedTreeOps.DisplayEnv -> + isGenerated:('a -> TypedTree.RecdField -> bool) -> + i:'a -> + fld:TypedTree.RecdField -> + Internal.Utilities.StructuredFormat.Layout + val isGeneratedUnionCaseField: pos:int -> f:TypedTree.RecdField -> bool + val isGeneratedExceptionField: pos:'a -> f:TypedTree.RecdField -> bool + val layoutUnionCaseFields: + denv:TypedTreeOps.DisplayEnv -> + isUnionCase:bool -> + fields:TypedTree.RecdField list -> + Internal.Utilities.StructuredFormat.Layout + val layoutUnionCase: + denv:TypedTreeOps.DisplayEnv -> + prefixL:Internal.Utilities.StructuredFormat.Layout -> + ucase:TypedTree.UnionCase -> + Internal.Utilities.StructuredFormat.Layout + val layoutUnionCases: + denv:TypedTreeOps.DisplayEnv -> + ucases:TypedTree.UnionCase list -> + Internal.Utilities.StructuredFormat.Layout list + val breakTypeDefnEqn: repr:TypedTree.TyconRepresentation -> bool + val layoutILFieldInfo: + denv:TypedTreeOps.DisplayEnv -> + amap:Import.ImportMap -> + m:Range.range -> + e:Infos.ILFieldInfo -> Internal.Utilities.StructuredFormat.Layout + val layoutEventInfo: + denv:TypedTreeOps.DisplayEnv -> + amap:Import.ImportMap -> + m:Range.range -> + e:Infos.EventInfo -> Internal.Utilities.StructuredFormat.Layout + val layoutPropInfo: + denv:TypedTreeOps.DisplayEnv -> + amap:Import.ImportMap -> + m:Range.range -> + p:Infos.PropInfo -> Internal.Utilities.StructuredFormat.Layout + val layoutTycon: + denv:TypedTreeOps.DisplayEnv -> + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + simplified:bool -> + typewordL:Internal.Utilities.StructuredFormat.Layout -> + tycon:TypedTree.Tycon -> + Internal.Utilities.StructuredFormat.Layout + val layoutExnDefn: + denv:TypedTreeOps.DisplayEnv -> + exnc:TypedTree.Entity -> Internal.Utilities.StructuredFormat.Layout + val layoutTyconDefns: + denv:TypedTreeOps.DisplayEnv -> + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + tycons:TypedTree.Tycon list -> + Internal.Utilities.StructuredFormat.Layout + + module private InferredSigPrinting = + val layoutInferredSigOfModuleExpr: + showHeader:bool -> + denv:TypedTreeOps.DisplayEnv -> + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + expr:TypedTree.ModuleOrNamespaceExprWithSig -> + Internal.Utilities.StructuredFormat.Layout + + module private PrintData = + val dataExprL: + denv:TypedTreeOps.DisplayEnv -> + expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout + val dataExprWrapL: + denv:TypedTreeOps.DisplayEnv -> + isAtomic:bool -> + expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout + val dataExprsL: + denv:TypedTreeOps.DisplayEnv -> + xs:TypedTree.Exprs -> Internal.Utilities.StructuredFormat.Layout list + + val dataExprL: + denv:TypedTreeOps.DisplayEnv -> + expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout + val outputValOrMember: + denv:TypedTreeOps.DisplayEnv -> + os:System.Text.StringBuilder -> x:TypedTree.Val -> unit + val stringValOrMember: + denv:TypedTreeOps.DisplayEnv -> x:TypedTree.Val -> string + val layoutQualifiedValOrMember: + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst -> + v:TypedTree.Val -> + TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout + val outputQualifiedValOrMember: + denv:TypedTreeOps.DisplayEnv -> + os:System.Text.StringBuilder -> v:TypedTree.Val -> unit + val outputQualifiedValSpec: + denv:TypedTreeOps.DisplayEnv -> + os:System.Text.StringBuilder -> v:TypedTree.Val -> unit + val stringOfQualifiedValOrMember: + denv:TypedTreeOps.DisplayEnv -> v:TypedTree.Val -> string + val formatMethInfoToBufferFreeStyle: + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + buf:System.Text.StringBuilder -> d:Infos.MethInfo -> unit + val prettyLayoutOfMethInfoFreeStyle: + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst -> + minfo:Infos.MethInfo -> + TypedTreeOps.TyparInst * + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfPropInfoFreeStyle: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + d:Infos.PropInfo -> Internal.Utilities.StructuredFormat.Layout + val stringOfMethInfo: + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> d:Infos.MethInfo -> string + val stringOfParamData: + denv:TypedTreeOps.DisplayEnv -> paramData:Infos.ParamData -> string + val layoutOfParamData: + denv:TypedTreeOps.DisplayEnv -> + paramData:Infos.ParamData -> Internal.Utilities.StructuredFormat.Layout + val outputExnDef: + denv:TypedTreeOps.DisplayEnv -> + os:System.Text.StringBuilder -> x:TypedTree.Entity -> unit + val layoutExnDef: + denv:TypedTreeOps.DisplayEnv -> + x:TypedTree.Entity -> Internal.Utilities.StructuredFormat.Layout + val stringOfTyparConstraints: + denv:TypedTreeOps.DisplayEnv -> + x:(TypedTree.Typar * TypedTree.TyparConstraint) list -> string + val outputTycon: + denv:TypedTreeOps.DisplayEnv -> + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + os:System.Text.StringBuilder -> x:TypedTree.Tycon -> unit + val layoutTycon: + denv:TypedTreeOps.DisplayEnv -> + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + x:TypedTree.Tycon -> Internal.Utilities.StructuredFormat.Layout + val layoutUnionCases: + denv:TypedTreeOps.DisplayEnv -> + x:TypedTree.RecdField list -> Internal.Utilities.StructuredFormat.Layout + val outputUnionCases: + denv:TypedTreeOps.DisplayEnv -> + os:System.Text.StringBuilder -> x:TypedTree.RecdField list -> unit + val isGeneratedUnionCaseField: pos:int -> f:TypedTree.RecdField -> bool + val isGeneratedExceptionField: pos:'a -> f:TypedTree.RecdField -> bool + val stringOfTyparConstraint: + denv:TypedTreeOps.DisplayEnv -> + TypedTree.Typar * TypedTree.TyparConstraint -> string + val stringOfTy: denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> string + val prettyLayoutOfType: + denv:TypedTreeOps.DisplayEnv -> + x:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfTypeNoCx: + denv:TypedTreeOps.DisplayEnv -> + x:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val prettyStringOfTy: + denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> string + val prettyStringOfTyNoCx: + denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> string + val stringOfRecdField: + denv:TypedTreeOps.DisplayEnv -> x:TypedTree.RecdField -> string + val stringOfUnionCase: + denv:TypedTreeOps.DisplayEnv -> x:TypedTree.UnionCase -> string + val stringOfExnDef: + denv:TypedTreeOps.DisplayEnv -> x:TypedTree.Entity -> string + val stringOfFSAttrib: + denv:TypedTreeOps.DisplayEnv -> x:TypedTree.Attrib -> string + val stringOfILAttrib: + denv:TypedTreeOps.DisplayEnv -> + AbstractIL.IL.ILType * AbstractIL.IL.ILAttribElem list -> string + val layoutInferredSigOfModuleExpr: + showHeader:bool -> + denv:TypedTreeOps.DisplayEnv -> + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + expr:TypedTree.ModuleOrNamespaceExprWithSig -> + Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfValOrMember: + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst -> + v:TypedTree.Val -> + TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfValOrMemberNoInst: + denv:TypedTreeOps.DisplayEnv -> + v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfMemberNoInstShort: + denv:TypedTreeOps.DisplayEnv -> + v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout + val prettyLayoutOfInstAndSig: + denv:TypedTreeOps.DisplayEnv -> + TypedTreeOps.TyparInst * TypedTree.TTypes * TypedTree.TType -> + TypedTreeOps.TyparInst * (TypedTree.TTypes * TypedTree.TType) * + (Internal.Utilities.StructuredFormat.Layout list * + Internal.Utilities.StructuredFormat.Layout) * + Internal.Utilities.StructuredFormat.Layout + val minimalStringsOfTwoTypes: + denv:TypedTreeOps.DisplayEnv -> + t1:TypedTree.TType -> t2:TypedTree.TType -> string * string * string + val minimalStringsOfTwoValues: + denv:TypedTreeOps.DisplayEnv -> + v1:TypedTree.Val -> v2:TypedTree.Val -> string * string + val minimalStringOfType: + denv:TypedTreeOps.DisplayEnv -> ty:TypedTree.TType -> string + + +namespace FSharp.Compiler + module internal AugmentWithHashCompare = + val mkIComparableCompareToSlotSig: + g:TcGlobals.TcGlobals -> TypedTree.SlotSig + val mkGenericIComparableCompareToSlotSig: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.SlotSig + val mkIStructuralComparableCompareToSlotSig: + g:TcGlobals.TcGlobals -> TypedTree.SlotSig + val mkGenericIEquatableEqualsSlotSig: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.SlotSig + val mkIStructuralEquatableEqualsSlotSig: + g:TcGlobals.TcGlobals -> TypedTree.SlotSig + val mkIStructuralEquatableGetHashCodeSlotSig: + g:TcGlobals.TcGlobals -> TypedTree.SlotSig + val mkGetHashCodeSlotSig: g:TcGlobals.TcGlobals -> TypedTree.SlotSig + val mkEqualsSlotSig: g:TcGlobals.TcGlobals -> TypedTree.SlotSig + val mkThisTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + val mkCompareObjTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + val mkCompareTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + val mkCompareWithComparerTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + val mkEqualsObjTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + val mkEqualsTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + val mkEqualsWithComparerTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + val mkHashTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + val mkHashWithComparerTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + val mkRelBinOp: + g:TcGlobals.TcGlobals -> + op:AbstractIL.IL.ILInstr -> + m:Range.range -> + e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr + val mkClt: + g:TcGlobals.TcGlobals -> + m:Range.range -> + e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr + val mkCgt: + g:TcGlobals.TcGlobals -> + m:Range.range -> + e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr + val mkILLangPrimTy: g:TcGlobals.TcGlobals -> AbstractIL.IL.ILType + val mkILCallGetComparer: + g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.Expr + val mkILCallGetEqualityComparer: + g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.Expr + val mkThisVar: + g:TcGlobals.TcGlobals -> + m:Range.range -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr + val mkShl: + g:TcGlobals.TcGlobals -> + m:Range.range -> acce:TypedTree.Expr -> n:int -> TypedTree.Expr + val mkShr: + g:TcGlobals.TcGlobals -> + m:Range.range -> acce:TypedTree.Expr -> n:int -> TypedTree.Expr + val mkAdd: + g:TcGlobals.TcGlobals -> + m:Range.range -> + e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr + val mkAddToHashAcc: + g:TcGlobals.TcGlobals -> + m:Range.range -> + e:TypedTree.Expr -> + accv:TypedTree.ValRef -> acce:TypedTree.Expr -> TypedTree.Expr + val mkCombineHashGenerators: + g:TcGlobals.TcGlobals -> + m:Range.range -> + exprs:TypedTree.Expr list -> + accv:TypedTree.ValRef -> acce:TypedTree.Expr -> TypedTree.Expr + val mkThatAddrLocal: + g:TcGlobals.TcGlobals -> + m:Range.range -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr + val mkThatAddrLocalIfNeeded: + g:TcGlobals.TcGlobals -> + m:Range.range -> + tcve:TypedTree.Expr -> + ty:TypedTree.TType -> TypedTree.Val option * TypedTree.Expr + val mkThisVarThatVar: + g:TcGlobals.TcGlobals -> + m:Range.range -> + ty:TypedTree.TType -> + TypedTree.Val * TypedTree.Val * TypedTree.Expr * TypedTree.Expr + val mkThatVarBind: + g:TcGlobals.TcGlobals -> + m:Range.range -> + ty:TypedTree.TType -> + thataddrv:TypedTree.Val -> + expr:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr + val mkBindThatAddr: + g:TcGlobals.TcGlobals -> + m:Range.range -> + ty:TypedTree.TType -> + thataddrv:TypedTree.Val -> + thatv:TypedTree.Val -> + thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr + val mkBindThatAddrIfNeeded: + m:Range.range -> + thataddrvOpt:TypedTree.Val option -> + thatv:TypedTree.Val -> expr:TypedTree.Expr -> TypedTree.Expr + val mkDerefThis: + g:TcGlobals.TcGlobals -> + m:Range.range -> + thisv:TypedTree.Val -> thise:TypedTree.Expr -> TypedTree.Expr + val mkCompareTestConjuncts: + g:TcGlobals.TcGlobals -> + m:Range.range -> exprs:TypedTree.Expr list -> TypedTree.Expr + val mkEqualsTestConjuncts: + g:TcGlobals.TcGlobals -> + m:Range.range -> exprs:TypedTree.Expr list -> TypedTree.Expr + val mkMinimalTy: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> TypedTree.TType list * TypedTree.TType + val mkBindNullComparison: + g:TcGlobals.TcGlobals -> + m:Range.range -> + thise:TypedTree.Expr -> + thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr + val mkBindThisNullEquals: + g:TcGlobals.TcGlobals -> + m:Range.range -> + thise:TypedTree.Expr -> + thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr + val mkBindThatNullEquals: + g:TcGlobals.TcGlobals -> + m:Range.range -> + thise:TypedTree.Expr -> + thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr + val mkBindNullHash: + g:TcGlobals.TcGlobals -> + m:Range.range -> + thise:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr + val mkRecdCompare: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + tycon:TypedTree.Tycon -> + TypedTree.Val * TypedTree.Val * TypedTree.Expr + val mkRecdCompareWithComparer: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + tycon:TypedTree.Tycon -> + _thisv:'a * thise:TypedTree.Expr -> + 'b * thate:TypedTree.Expr -> + compe:TypedTree.Expr -> TypedTree.Expr + val mkRecdEquality: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + tycon:TypedTree.Tycon -> + TypedTree.Val * TypedTree.Val * TypedTree.Expr + val mkRecdEqualityWithComparer: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + tycon:TypedTree.Tycon -> + _thisv:'a * thise:TypedTree.Expr -> + thatobje:TypedTree.Expr -> + thatv:TypedTree.Val * thate:TypedTree.Expr -> + compe:TypedTree.Expr -> TypedTree.Expr + val mkExnEquality: + g:TcGlobals.TcGlobals -> + exnref:TypedTree.TyconRef -> + exnc:TypedTree.Tycon -> TypedTree.Val * TypedTree.Val * TypedTree.Expr + val mkExnEqualityWithComparer: + g:TcGlobals.TcGlobals -> + exnref:TypedTree.TyconRef -> + exnc:TypedTree.Tycon -> + _thisv:'a * thise:TypedTree.Expr -> + thatobje:TypedTree.Expr -> + thatv:TypedTree.Val * thate:TypedTree.Expr -> + compe:TypedTree.Expr -> TypedTree.Expr + val mkUnionCompare: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + tycon:TypedTree.Tycon -> + TypedTree.Val * TypedTree.Val * TypedTree.Expr + val mkUnionCompareWithComparer: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + tycon:TypedTree.Tycon -> + _thisv:'a * thise:TypedTree.Expr -> + _thatobjv:'b * thatcaste:TypedTree.Expr -> + compe:TypedTree.Expr -> TypedTree.Expr + val mkUnionEquality: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + tycon:TypedTree.Tycon -> + TypedTree.Val * TypedTree.Val * TypedTree.Expr + val mkUnionEqualityWithComparer: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + tycon:TypedTree.Tycon -> + _thisv:'a * thise:TypedTree.Expr -> + thatobje:TypedTree.Expr -> + thatv:TypedTree.Val * thate:TypedTree.Expr -> + compe:TypedTree.Expr -> TypedTree.Expr + val mkRecdHashWithComparer: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + tycon:TypedTree.Tycon -> + compe:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr + val mkExnHashWithComparer: + g:TcGlobals.TcGlobals -> + exnref:TypedTree.TyconRef -> + exnc:TypedTree.Tycon -> + compe:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr + val mkUnionHashWithComparer: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + tycon:TypedTree.Tycon -> + compe:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr + val isNominalExnc: exnc:TypedTree.Tycon -> bool + val isTrueFSharpStructTycon: _g:'a -> tycon:TypedTree.Tycon -> bool + val canBeAugmentedWithEquals: g:'a -> tycon:TypedTree.Tycon -> bool + val canBeAugmentedWithCompare: g:'a -> tycon:TypedTree.Tycon -> bool + val getAugmentationAttribs: + g:TcGlobals.TcGlobals -> + tycon:TypedTree.Tycon -> + bool * bool * bool option * bool option * bool option * bool option * + bool option * bool option * bool option + val CheckAugmentationAttribs: + bool -> TcGlobals.TcGlobals -> Import.ImportMap -> TypedTree.Tycon -> unit + val TyconIsCandidateForAugmentationWithCompare: + TcGlobals.TcGlobals -> TypedTree.Tycon -> bool + val TyconIsCandidateForAugmentationWithEquals: + TcGlobals.TcGlobals -> TypedTree.Tycon -> bool + val TyconIsCandidateForAugmentationWithHash: + TcGlobals.TcGlobals -> TypedTree.Tycon -> bool + val slotImplMethod: + final:bool * c:TypedTree.TyconRef * slotsig:TypedTree.SlotSig -> + TypedTree.ValMemberInfo + val nonVirtualMethod: c:TypedTree.TyconRef -> TypedTree.ValMemberInfo + val unitArg: TypedTree.ArgReprInfo list list + val unaryArg: TypedTree.ArgReprInfo list list + val tupArg: TypedTree.ArgReprInfo list list + val mkValSpec: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + tmty:TypedTree.TType -> + vis:TypedTree.Accessibility -> + slotsig:TypedTree.SlotSig option -> + methn:string -> + ty:TypedTree.TType -> + argData:TypedTree.ArgReprInfo list list -> TypedTree.Val + val MakeValsForCompareAugmentation: + TcGlobals.TcGlobals -> TypedTree.TyconRef -> TypedTree.Val * TypedTree.Val + val MakeValsForCompareWithComparerAugmentation: + TcGlobals.TcGlobals -> TypedTree.TyconRef -> TypedTree.Val + val MakeValsForEqualsAugmentation: + TcGlobals.TcGlobals -> TypedTree.TyconRef -> TypedTree.Val * TypedTree.Val + val MakeValsForEqualityWithComparerAugmentation: + TcGlobals.TcGlobals -> + TypedTree.TyconRef -> TypedTree.Val * TypedTree.Val * TypedTree.Val + val MakeBindingsForCompareAugmentation: + TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list + val MakeBindingsForCompareWithComparerAugmentation: + TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list + val MakeBindingsForEqualityWithComparerAugmentation: + TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list + val MakeBindingsForEqualsAugmentation: + TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list + val TypeDefinitelyHasEquality: + TcGlobals.TcGlobals -> TypedTree.TType -> bool + + +namespace FSharp.Compiler + module internal NameResolution = + type NameResolver = + + new: g:TcGlobals.TcGlobals * amap:Import.ImportMap * + infoReader:InfoReader.InfoReader * + instantiationGenerator:(Range.range -> TypedTree.Typars -> + TypedTree.TypeInst) -> NameResolver + member InfoReader: InfoReader.InfoReader + member + InstantiationGenerator: (Range.range -> TypedTree.Typars -> + TypedTree.TypeInst) + member amap: Import.ImportMap + member g: TcGlobals.TcGlobals + member languageSupportsNameOf: bool + + val UnionCaseRefsInTycon: + modref:TypedTree.ModuleOrNamespaceRef -> + tycon:TypedTree.Tycon -> TypedTree.UnionCaseRef list + val UnionCaseRefsInModuleOrNamespace: + modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.UnionCaseRef list + val TryFindTypeWithUnionCase: + modref:TypedTree.ModuleOrNamespaceRef -> + id:SyntaxTree.Ident -> TypedTree.Entity option + val TryFindTypeWithRecdField: + modref:TypedTree.ModuleOrNamespaceRef -> + id:SyntaxTree.Ident -> TypedTree.Entity option + val ActivePatternElemsOfValRef: + vref:TypedTree.ValRef -> TypedTree.ActivePatternElemRef list + val TryMkValRefInModRef: + modref:TypedTree.EntityRef -> + vspec:TypedTree.Val -> TypedTree.ValRef option + val ActivePatternElemsOfVal: + modref:TypedTree.EntityRef -> + vspec:TypedTree.Val -> TypedTree.ActivePatternElemRef list + val ActivePatternElemsOfModuleOrNamespace: + TypedTree.ModuleOrNamespaceRef -> + AbstractIL.Internal.Library.NameMap + val ( |AbbrevOrAppTy|_| ): TypedTree.TType -> TypedTree.TyconRef option + [] + type ArgumentContainer = + | Method of Infos.MethInfo + | Type of TypedTree.TyconRef + val emptyTypeInst: TypedTree.TypeInst + type EnclosingTypeInst = TypedTree.TypeInst + val emptyEnclosingTypeInst: EnclosingTypeInst + [] + type Item = + | Value of TypedTree.ValRef + | UnionCase of Infos.UnionCaseInfo * hasRequireQualifiedAccessAttr: bool + | ActivePatternResult of + PrettyNaming.ActivePatternInfo * TypedTree.TType * int * Range.range + | ActivePatternCase of TypedTree.ActivePatternElemRef + | ExnCase of TypedTree.TyconRef + | RecdField of Infos.RecdFieldInfo + | UnionCaseField of Infos.UnionCaseInfo * fieldIndex: int + | AnonRecdField of + TypedTree.AnonRecdTypeInfo * TypedTree.TTypes * int * Range.range + | NewDef of SyntaxTree.Ident + | ILField of Infos.ILFieldInfo + | Event of Infos.EventInfo + | Property of string * Infos.PropInfo list + | MethodGroup of + displayName: string * methods: Infos.MethInfo list * + uninstantiatedMethodOpt: Infos.MethInfo option + | CtorGroup of string * Infos.MethInfo list + | FakeInterfaceCtor of TypedTree.TType + | DelegateCtor of TypedTree.TType + | Types of string * TypedTree.TType list + | CustomOperation of + string * (unit -> string option) * Infos.MethInfo option + | CustomBuilder of string * TypedTree.ValRef + | TypeVar of string * TypedTree.Typar + | ModuleOrNamespaces of TypedTree.ModuleOrNamespaceRef list + | ImplicitOp of SyntaxTree.Ident * TypedTree.TraitConstraintSln option ref + | ArgName of SyntaxTree.Ident * TypedTree.TType * ArgumentContainer option + | SetterArg of SyntaxTree.Ident * Item + | UnqualifiedType of TypedTree.TyconRef list + with + static member + MakeCtorGroup: nm:string * minfos:Infos.MethInfo list -> Item + static member + MakeMethGroup: nm:string * minfos:Infos.MethInfo list -> Item + member DisplayName: string + + val valRefHash: vref:TypedTree.ValRef -> int + [] + type ItemWithInst = + { Item: Item + TyparInst: TypedTreeOps.TyparInst } + val ItemWithNoInst: Item -> ItemWithInst + val ( |ItemWithInst| ): ItemWithInst -> Item * TypedTreeOps.TyparInst + type FieldResolution = | FieldResolution of Infos.RecdFieldInfo * bool + type ExtensionMember = + | FSExtMem of TypedTree.ValRef * Infos.ExtensionMethodPriority + | ILExtMem of + TypedTree.TyconRef * Infos.MethInfo * Infos.ExtensionMethodPriority + with + static member + Comparer: g:TcGlobals.TcGlobals -> + System.Collections.Generic.IEqualityComparer + static member + Equality: g:TcGlobals.TcGlobals -> + e1:ExtensionMember -> e2:ExtensionMember -> bool + static member Hash: e1:ExtensionMember -> int + member Priority: Infos.ExtensionMethodPriority + + type FullyQualifiedFlag = + | FullyQualified + | OpenQualified + type UnqualifiedItems = AbstractIL.Internal.Library.LayeredMap + [] + type NameResolutionEnv = + { eDisplayEnv: TypedTreeOps.DisplayEnv + eUnqualifiedItems: UnqualifiedItems + eUnqualifiedEnclosingTypeInsts: + TypedTreeOps.TyconRefMap + ePatItems: AbstractIL.Internal.Library.NameMap + eModulesAndNamespaces: + AbstractIL.Internal.Library.NameMultiMap + eFullyQualifiedModulesAndNamespaces: + AbstractIL.Internal.Library.NameMultiMap + eFieldLabels: + AbstractIL.Internal.Library.NameMultiMap + eUnqualifiedRecordOrUnionTypeInsts: + TypedTreeOps.TyconRefMap + eTyconsByAccessNames: + AbstractIL.Internal.Library.LayeredMultiMap + eFullyQualifiedTyconsByAccessNames: + AbstractIL.Internal.Library.LayeredMultiMap + eTyconsByDemangledNameAndArity: + AbstractIL.Internal.Library.LayeredMap + eFullyQualifiedTyconsByDemangledNameAndArity: + AbstractIL.Internal.Library.LayeredMap + eIndexedExtensionMembers: TypedTreeOps.TyconRefMultiMap + eUnindexedExtensionMembers: ExtensionMember list + eTypars: AbstractIL.Internal.Library.NameMap } + with + static member Empty: g:TcGlobals.TcGlobals -> NameResolutionEnv + member FindUnqualifiedItem: string -> Item + member + ModulesAndNamespaces: fq:FullyQualifiedFlag -> + AbstractIL.Internal.Library.NameMultiMap + member + TyconsByAccessNames: fq:FullyQualifiedFlag -> + AbstractIL.Internal.Library.LayeredMultiMap + member + TyconsByDemangledNameAndArity: fq:FullyQualifiedFlag -> + AbstractIL.Internal.Library.LayeredMap + member DisplayEnv: TypedTreeOps.DisplayEnv + + [] + type ResultCollectionSettings = + | AllResults + | AtMostOneResult + val NextExtensionMethodPriority: unit -> uint64 + val IsTyconRefUsedForCSharpStyleExtensionMembers: + g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool + val IsTypeUsedForCSharpStyleExtensionMembers: + g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType -> bool + val IsMethInfoPlainCSharpStyleExtensionMember: + g:TcGlobals.TcGlobals -> + m:Range.range -> isEnclExtTy:bool -> minfo:Infos.MethInfo -> bool + val private GetCSharpStyleIndexedExtensionMembersForTyconRef: + amap:Import.ImportMap -> + m:Range.range -> + tcrefOfStaticClass:TypedTree.TyconRef -> + Choice<(TypedTree.TyconRef * ExtensionMember),ExtensionMember> list + val IntrinsicPropInfosOfTypeInScope: + infoReader:InfoReader.InfoReader -> + optFilter:string option -> + ad:AccessibilityLogic.AccessorDomain -> + findFlag:InfoReader.FindMemberFlag -> + m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list + val SelectPropInfosFromExtMembers: + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + optFilter:string option -> + declaringTy:TypedTree.TType -> + m:Range.range -> + extMemInfos:seq -> Infos.PropInfo list + val ExtensionPropInfosOfTypeInScope: + ResultCollectionSettings -> + InfoReader.InfoReader -> + NameResolutionEnv -> + string option -> + AccessibilityLogic.AccessorDomain -> + Range.range -> TypedTree.TType -> Infos.PropInfo list + val AllPropInfosOfTypeInScope: + ResultCollectionSettings -> + InfoReader.InfoReader -> + NameResolutionEnv -> + string option -> + AccessibilityLogic.AccessorDomain -> + InfoReader.FindMemberFlag -> + Range.range -> TypedTree.TType -> Infos.PropInfo list + val IntrinsicMethInfosOfType: + infoReader:InfoReader.InfoReader -> + optFilter:string option -> + ad:AccessibilityLogic.AccessorDomain -> + allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> + findFlag:InfoReader.FindMemberFlag -> + m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list + val TrySelectExtensionMethInfoOfILExtMem: + Range.range -> + Import.ImportMap -> + TypedTree.TType -> + TypedTree.TyconRef * Infos.MethInfo * Infos.ExtensionMethodPriority -> + Infos.MethInfo option + val SelectMethInfosFromExtMembers: + infoReader:InfoReader.InfoReader -> + optFilter:string option -> + apparentTy:TypedTree.TType -> + m:Range.range -> + extMemInfos:seq -> Infos.MethInfo list + val ExtensionMethInfosOfTypeInScope: + collectionSettings:ResultCollectionSettings -> + infoReader:InfoReader.InfoReader -> + nenv:NameResolutionEnv -> + optFilter:string option -> + m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list + val AllMethInfosOfTypeInScope: + ResultCollectionSettings -> + InfoReader.InfoReader -> + NameResolutionEnv -> + string option -> + AccessibilityLogic.AccessorDomain -> + InfoReader.FindMemberFlag -> + Range.range -> TypedTree.TType -> Infos.MethInfo list + [] + type BulkAdd = + | Yes + | No + val AddValRefsToItems: + bulkAddMode:BulkAdd -> + eUnqualifiedItems:UnqualifiedItems -> + vrefs:TypedTree.ValRef [] -> UnqualifiedItems + val AddValRefToExtensionMembers: + pri:Infos.ExtensionMethodPriority -> + eIndexedExtensionMembers:TypedTreeOps.TyconRefMultiMap -> + vref:TypedTree.ValRef -> + TypedTreeOps.TyconRefMultiMap + val AddFakeNamedValRefToNameEnv: + string -> NameResolutionEnv -> TypedTree.ValRef -> NameResolutionEnv + val AddFakeNameToNameEnv: + string -> NameResolutionEnv -> Item -> NameResolutionEnv + val AddValRefsToActivePatternsNameEnv: + ePatItems:Map -> vref:TypedTree.ValRef -> Map + val AddValRefsToNameEnvWithPriority: + bulkAddMode:BulkAdd -> + pri:Infos.ExtensionMethodPriority -> + nenv:NameResolutionEnv -> + vrefs:TypedTree.ValRef [] -> NameResolutionEnv + val AddValRefToNameEnv: + NameResolutionEnv -> TypedTree.ValRef -> NameResolutionEnv + val AddActivePatternResultTagsToNameEnv: + PrettyNaming.ActivePatternInfo -> + NameResolutionEnv -> TypedTree.TType -> Range.range -> NameResolutionEnv + val GeneralizeUnionCaseRef: + ucref:TypedTree.UnionCaseRef -> Infos.UnionCaseInfo + val AddTyconsByDemangledNameAndArity: + bulkAddMode:BulkAdd -> + tcrefs:TypedTree.TyconRef [] -> + tab:AbstractIL.Internal.Library.LayeredMap -> + AbstractIL.Internal.Library.LayeredMap + val AddTyconByAccessNames: + bulkAddMode:BulkAdd -> + tcrefs:TypedTree.TyconRef [] -> + tab:AbstractIL.Internal.Library.LayeredMultiMap -> + AbstractIL.Internal.Library.LayeredMultiMap + val AddRecdField: + rfref:TypedTree.RecdFieldRef -> + tab:AbstractIL.Internal.Library.NameMultiMap -> + Map + val AddUnionCases1: + tab:Map -> + ucrefs:TypedTree.UnionCaseRef list -> Map + val AddUnionCases2: + bulkAddMode:BulkAdd -> + eUnqualifiedItems:UnqualifiedItems -> + ucrefs:TypedTree.UnionCaseRef list -> Map + type TypeNameResolutionFlag = + | ResolveTypeNamesToCtors + | ResolveTypeNamesToTypeRefs + [] + type TypeNameResolutionStaticArgsInfo = + | Indefinite + | Definite of int + with + static member + FromTyArgs: numTyArgs:int -> TypeNameResolutionStaticArgsInfo + member MangledNameForType: nm:string -> string + member HasNoStaticArgsInfo: bool + member NumStaticArgs: int + static member DefiniteEmpty: TypeNameResolutionStaticArgsInfo + + [] + type TypeNameResolutionInfo = + | TypeNameResolutionInfo of + TypeNameResolutionFlag * TypeNameResolutionStaticArgsInfo + with + static member + ResolveToTypeRefs: TypeNameResolutionStaticArgsInfo -> + TypeNameResolutionInfo + member DropStaticArgsInfo: TypeNameResolutionInfo + member ResolutionFlag: TypeNameResolutionFlag + member StaticArgsInfo: TypeNameResolutionStaticArgsInfo + static member Default: TypeNameResolutionInfo + + [] + type PermitDirectReferenceToGeneratedType = + | Yes + | No + val CheckForDirectReferenceToGeneratedType: + tcref:TypedTree.TyconRef * genOk:PermitDirectReferenceToGeneratedType * + m:Range.range -> unit + val AddEntityForProvidedType: + amap:Import.ImportMap * modref:TypedTree.ModuleOrNamespaceRef * + resolutionEnvironment:ExtensionTyping.ResolutionEnvironment * + st:Tainted * m:Range.range -> + TypedTree.EntityRef + val ResolveProvidedTypeNameInEntity: + amap:Import.ImportMap * m:Range.range * typeName:string * + modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.EntityRef list + val LookupTypeNameInEntityHaveArity: + nm:string -> + staticResInfo:TypeNameResolutionStaticArgsInfo -> + mty:TypedTree.ModuleOrNamespaceType -> TypedTree.Tycon option + val LookupTypeNameNoArity: + nm:string -> + byDemangledNameAndArity:AbstractIL.Internal.Library.LayeredMap -> + byAccessNames:AbstractIL.Internal.Library.LayeredMultiMap -> + 'a list + val LookupTypeNameInEntityNoArity: + _m:'a -> + nm:string -> + mtyp:TypedTree.ModuleOrNamespaceType -> TypedTree.Tycon list + val LookupTypeNameInEntityMaybeHaveArity: + amap:Import.ImportMap * m:Range.range * + ad:AccessibilityLogic.AccessorDomain * nm:string * + staticResInfo:TypeNameResolutionStaticArgsInfo * + modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.EntityRef list + val GetNestedTyconRefsOfType: + infoReader:InfoReader.InfoReader -> + amap:Import.ImportMap -> + ad:AccessibilityLogic.AccessorDomain * optFilter:string option * + staticResInfo:TypeNameResolutionStaticArgsInfo * + checkForGenerated:bool * m:Range.range -> + ty:TypedTree.TType -> TypedTree.TypeInst * TypedTree.EntityRef list + val MakeNestedType: + ncenv:NameResolver -> + tinst:TypedTree.TType list -> + m:Range.range -> tcrefNested:TypedTree.TyconRef -> TypedTree.TType + val GetNestedTypesOfType: + ad:AccessibilityLogic.AccessorDomain * ncenv:NameResolver * + optFilter:string option * staticResInfo:TypeNameResolutionStaticArgsInfo * + checkForGenerated:bool * m:Range.range -> + ty:TypedTree.TType -> TypedTree.TType list + val ChooseMethInfosForNameEnv: + g:TcGlobals.TcGlobals -> + m:Range.range -> + ty:TypedTree.TType -> + minfos:Infos.MethInfo list -> + System.Collections.Generic.KeyValuePair list + val ChoosePropInfosForNameEnv: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> + pinfos:Infos.PropInfo list -> + System.Collections.Generic.KeyValuePair list + val ChooseFSharpFieldInfosForNameEnv: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> + rfinfos:Infos.RecdFieldInfo list -> + System.Collections.Generic.KeyValuePair list + val ChooseILFieldInfosForNameEnv: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> + finfos:Infos.ILFieldInfo list -> + System.Collections.Generic.KeyValuePair list + val ChooseEventInfosForNameEnv: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> + einfos:Infos.EventInfo list -> + System.Collections.Generic.KeyValuePair list + val AddStaticContentOfTypeToNameEnv: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + nenv:NameResolutionEnv -> ty:TypedTree.TType -> NameResolutionEnv + val private AddNestedTypesOfTypeToNameEnv: + infoReader:InfoReader.InfoReader -> + amap:Import.ImportMap -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + nenv:NameResolutionEnv -> ty:TypedTree.TType -> NameResolutionEnv + val private AddTyconRefsWithEnclosingTypeInstToNameEnv: + bulkAddMode:BulkAdd -> + ownDefinition:bool -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + root:bool -> + nenv:NameResolutionEnv -> + tinstEnclosing:TypedTree.TypeInst * + tcrefs:TypedTree.TyconRef list -> NameResolutionEnv + val private AddStaticPartsOfTypeToNameEnv: + amap:Import.ImportMap -> + m:Range.range -> + nenv:NameResolutionEnv -> ty:TypedTree.TType -> NameResolutionEnv + val private AddStaticPartsOfTyconRefToNameEnv: + bulkAddMode:BulkAdd -> + ownDefinition:bool -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + nenv:NameResolutionEnv -> + tinstOpt:TypedTree.TypeInst option -> + tcref:TypedTree.TyconRef -> NameResolutionEnv + val private CanAutoOpenTyconRef: + g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool + val private AddPartsOfTyconRefToNameEnv: + bulkAddMode:BulkAdd -> + ownDefinition:bool -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + nenv:NameResolutionEnv -> + tcref:TypedTree.TyconRef -> NameResolutionEnv + val AddTyconRefsToNameEnv: + BulkAdd -> + bool -> + TcGlobals.TcGlobals -> + Import.ImportMap -> + AccessibilityLogic.AccessorDomain -> + Range.range -> + bool -> + NameResolutionEnv -> + TypedTree.TyconRef list -> NameResolutionEnv + val AddExceptionDeclsToNameEnv: + BulkAdd -> NameResolutionEnv -> TypedTree.TyconRef -> NameResolutionEnv + val AddModuleAbbrevToNameEnv: + SyntaxTree.Ident -> + NameResolutionEnv -> + TypedTree.ModuleOrNamespaceRef list -> NameResolutionEnv + val MakeNestedModuleRefs: + modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.EntityRef list + val AddModuleOrNamespaceRefsToNameEnv: + TcGlobals.TcGlobals -> + Import.ImportMap -> + Range.range -> + bool -> + AccessibilityLogic.AccessorDomain -> + NameResolutionEnv -> + TypedTree.ModuleOrNamespaceRef list -> NameResolutionEnv + val AddModuleOrNamespaceContentsToNameEnv: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + root:bool -> + nenv:NameResolutionEnv -> + modref:TypedTree.ModuleOrNamespaceRef -> NameResolutionEnv + val AddModuleOrNamespaceRefsContentsToNameEnv: + TcGlobals.TcGlobals -> + Import.ImportMap -> + AccessibilityLogic.AccessorDomain -> + Range.range -> + bool -> + NameResolutionEnv -> + TypedTree.EntityRef list -> NameResolutionEnv + val AddTypeContentsToNameEnv: + TcGlobals.TcGlobals -> + Import.ImportMap -> + AccessibilityLogic.AccessorDomain -> + Range.range -> + NameResolutionEnv -> TypedTree.TType -> NameResolutionEnv + val AddModuleOrNamespaceRefContentsToNameEnv: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + root:bool -> + nenv:NameResolutionEnv -> + modref:TypedTree.EntityRef -> NameResolutionEnv + val AddModuleOrNamespaceRefToNameEnv: + TcGlobals.TcGlobals -> + Import.ImportMap -> + Range.range -> + bool -> + AccessibilityLogic.AccessorDomain -> + NameResolutionEnv -> TypedTree.EntityRef -> NameResolutionEnv + type CheckForDuplicateTyparFlag = + | CheckForDuplicateTypars + | NoCheckForDuplicateTypars + val AddDeclaredTyparsToNameEnv: + CheckForDuplicateTyparFlag -> + NameResolutionEnv -> TypedTree.Typar list -> NameResolutionEnv + val FreshenTycon: + ncenv:NameResolver -> + m:Range.range -> tcref:TypedTree.TyconRef -> TypedTree.TType + val FreshenTyconWithEnclosingTypeInst: + ncenv:NameResolver -> + m:Range.range -> + tinstEnclosing:TypedTree.TypeInst -> + tcref:TypedTree.TyconRef -> TypedTree.TType + val FreshenUnionCaseRef: + ncenv:NameResolver -> + m:Range.range -> ucref:TypedTree.UnionCaseRef -> Infos.UnionCaseInfo + val FreshenRecdFieldRef: + NameResolver -> + Range.range -> TypedTree.RecdFieldRef -> Infos.RecdFieldInfo + val ResolveUnqualifiedItem: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> m:Range.range -> res:Item -> Item + val OneResult: + res:AbstractIL.Internal.Library.ResultOrException<'a> -> + AbstractIL.Internal.Library.ResultOrException<'a list> + val OneSuccess: + x:'a -> AbstractIL.Internal.Library.ResultOrException<'a list> + val AddResults: + res1:AbstractIL.Internal.Library.ResultOrException<'a list> -> + res2:AbstractIL.Internal.Library.ResultOrException<'a list> -> + AbstractIL.Internal.Library.ResultOrException<'a list> + val NoResultsOrUsefulErrors: + AbstractIL.Internal.Library.ResultOrException<'a list> + val CollectResults: + f:('a -> AbstractIL.Internal.Library.ResultOrException<'b>) -> + _arg1:'a list -> AbstractIL.Internal.Library.ResultOrException<'b list> + val CollectAtMostOneResult: + f:('a -> AbstractIL.Internal.Library.ResultOrException<'b>) -> + inputs:'a list -> AbstractIL.Internal.Library.ResultOrException<'b list> + val CollectResults2: + resultCollectionSettings:ResultCollectionSettings -> + f:('a -> AbstractIL.Internal.Library.ResultOrException<'b>) -> + ('a list -> AbstractIL.Internal.Library.ResultOrException<'b list>) + val MapResults: + f:('a -> 'b) -> + _arg1:AbstractIL.Internal.Library.ResultOrException<'a list> -> + AbstractIL.Internal.Library.ResultOrException<'b list> + val AtMostOneResult: + m:Range.range -> + res:AbstractIL.Internal.Library.ResultOrException<'a list> -> + AbstractIL.Internal.Library.ResultOrException<'a> + val AtMostOneResultQuery: + query2:(unit -> AbstractIL.Internal.Library.ResultOrException<'a list>) -> + res1:AbstractIL.Internal.Library.ResultOrException<'a list> -> + AbstractIL.Internal.Library.ResultOrException<'a list> + val inline ( +++ ): + res1:AbstractIL.Internal.Library.ResultOrException<'a list> -> + query2:(unit -> AbstractIL.Internal.Library.ResultOrException<'a list>) -> + AbstractIL.Internal.Library.ResultOrException<'a list> + val LookupTypeNameInEnvHaveArity: + fq:FullyQualifiedFlag -> + nm:string -> + numTyArgs:int -> nenv:NameResolutionEnv -> TypedTree.TyconRef option + val LookupTypeNameInEnvNoArity: + FullyQualifiedFlag -> + string -> NameResolutionEnv -> TypedTree.TyconRef list + val LookupTypeNameInEnvMaybeHaveArity: + fq:FullyQualifiedFlag -> + nm:string -> + typeNameResInfo:TypeNameResolutionInfo -> + nenv:NameResolutionEnv -> TypedTree.TyconRef list + [] + type ItemOccurence = + | Binding + | Use + | UseInType + | UseInAttribute + | Pattern + | Implemented + | RelatedText + | Open + type OpenDeclaration = + { Target: SyntaxTree.SynOpenDeclTarget + Range: Range.range option + Modules: TypedTree.ModuleOrNamespaceRef list + Types: TypedTree.TType list + AppliedScope: Range.range + IsOwnNamespace: bool } + with + static member + Create: target:SyntaxTree.SynOpenDeclTarget * + modules:TypedTree.ModuleOrNamespaceRef list * + types:TypedTree.TType list * appliedScope:Range.range * + isOwnNamespace:bool -> OpenDeclaration + + type FormatStringCheckContext = + { SourceText: Text.ISourceText + LineStartPositions: int [] } + type ITypecheckResultsSink = + interface + abstract member + NotifyEnvWithScope: Range.range * NameResolutionEnv * + AccessibilityLogic.AccessorDomain -> unit + abstract member + NotifyExprHasType: TypedTree.TType * NameResolutionEnv * + AccessibilityLogic.AccessorDomain * Range.range -> + unit + abstract member + NotifyFormatSpecifierLocation: Range.range * int -> unit + abstract member + NotifyMethodGroupNameResolution: Range.pos * Item * Item * + TypedTreeOps.TyparInst * + ItemOccurence * NameResolutionEnv * + AccessibilityLogic.AccessorDomain * + Range.range * bool -> unit + abstract member + NotifyNameResolution: Range.pos * Item * TypedTreeOps.TyparInst * + ItemOccurence * NameResolutionEnv * + AccessibilityLogic.AccessorDomain * Range.range * + bool -> unit + abstract member NotifyOpenDeclaration: OpenDeclaration -> unit + abstract member CurrentSourceText: Text.ISourceText option + abstract member + FormatStringCheckContext: FormatStringCheckContext option + + val ( |ValRefOfProp|_| ): pi:Infos.PropInfo -> TypedTree.ValRef option + val ( |ValRefOfMeth|_| ): mi:Infos.MethInfo -> TypedTree.ValRef option + val ( |ValRefOfEvent|_| ): evt:Infos.EventInfo -> TypedTree.ValRef option + val ( |RecordFieldUse|_| ): + item:Item -> (string * TypedTree.TyconRef) option + val ( |UnionCaseFieldUse|_| ): + item:Item -> (int * TypedTree.UnionCaseRef) option + val ( |ILFieldUse|_| ): item:Item -> Infos.ILFieldInfo option + val ( |PropertyUse|_| ): item:Item -> Infos.PropInfo option + val ( |FSharpPropertyUse|_| ): item:Item -> TypedTree.ValRef option + val ( |MethodUse|_| ): item:Item -> Infos.MethInfo option + val ( |FSharpMethodUse|_| ): item:Item -> TypedTree.ValRef option + val ( |EntityUse|_| ): item:Item -> TypedTree.TyconRef option + val ( |EventUse|_| ): item:Item -> Infos.EventInfo option + val ( |FSharpEventUse|_| ): item:Item -> TypedTree.ValRef option + val ( |UnionCaseUse|_| ): item:Item -> TypedTree.UnionCaseRef option + val ( |ValUse|_| ): item:Item -> TypedTree.ValRef option + val ( |ActivePatternCaseUse|_| ): + item:Item -> (Range.range * Range.range * int) option + val tyconRefDefnHash: + _g:TcGlobals.TcGlobals -> eref1:TypedTree.EntityRef -> int + val tyconRefDefnEq: + g:TcGlobals.TcGlobals -> + eref1:TypedTree.EntityRef -> eref2:TypedTree.EntityRef -> bool + val valRefDefnHash: _g:TcGlobals.TcGlobals -> vref1:TypedTree.ValRef -> int + val valRefDefnEq: + g:TcGlobals.TcGlobals -> + vref1:TypedTree.ValRef -> vref2:TypedTree.ValRef -> bool + val unionCaseRefDefnEq: + g:TcGlobals.TcGlobals -> + uc1:TypedTree.UnionCaseRef -> uc2:TypedTree.UnionCaseRef -> bool + val ItemsAreEffectivelyEqual: TcGlobals.TcGlobals -> Item -> Item -> bool + val ItemsAreEffectivelyEqualHash: TcGlobals.TcGlobals -> Item -> int + [] + type CapturedNameResolution = + + new: i:Item * tpinst:TypedTreeOps.TyparInst * io:ItemOccurence * + nre:NameResolutionEnv * ad:AccessibilityLogic.AccessorDomain * + m:Range.range -> CapturedNameResolution + member DebugToString: unit -> string + member AccessorDomain: AccessibilityLogic.AccessorDomain + member DisplayEnv: TypedTreeOps.DisplayEnv + member Item: Item + member ItemOccurence: ItemOccurence + member ItemWithInst: ItemWithInst + member NameResolutionEnv: NameResolutionEnv + member Pos: Range.pos + member Range: Range.range + + [] + type TcResolutions = + + new: capturedEnvs:ResizeArray * + capturedExprTypes:ResizeArray * + capturedNameResolutions:ResizeArray * + capturedMethodGroupResolutions:ResizeArray -> + TcResolutions + member + CapturedEnvs: ResizeArray + member + CapturedExpressionTypings: ResizeArray + member + CapturedMethodGroupResolutions: ResizeArray + member CapturedNameResolutions: ResizeArray + static member Empty: TcResolutions + + [] + type TcSymbolUseData = + { Item: Item + ItemOccurence: ItemOccurence + DisplayEnv: TypedTreeOps.DisplayEnv + Range: Range.range } + [] + type TcSymbolUses = + + new: g:TcGlobals.TcGlobals * + capturedNameResolutions:ResizeArray * + formatSpecifierLocations:(Range.range * int) [] -> TcSymbolUses + member + GetFormatSpecifierLocationsAndArity: unit -> (Range.range * int) [] + member GetUsesOfSymbol: Item -> TcSymbolUseData [] + member AllUsesOfSymbols: TcSymbolUseData [] [] + static member Empty: TcSymbolUses + + type TcResultsSinkImpl = + + interface ITypecheckResultsSink + new: tcGlobals:TcGlobals.TcGlobals * ?sourceText:Text.ISourceText -> + TcResultsSinkImpl + member GetFormatSpecifierLocations: unit -> (Range.range * int) [] + member GetOpenDeclarations: unit -> OpenDeclaration [] + member GetResolutions: unit -> TcResolutions + member GetSymbolUses: unit -> TcSymbolUses + + type TcResultsSink = + { mutable CurrentSink: ITypecheckResultsSink option } + with + static member WithSink: ITypecheckResultsSink -> TcResultsSink + static member NoSink: TcResultsSink + + val WithNewTypecheckResultsSink: + ITypecheckResultsSink * TcResultsSink -> System.IDisposable + val TemporarilySuspendReportingTypecheckResultsToSink: + TcResultsSink -> System.IDisposable + val CallEnvSink: + TcResultsSink -> + Range.range * NameResolutionEnv * AccessibilityLogic.AccessorDomain -> + unit + val CallNameResolutionSink: + TcResultsSink -> + Range.range * NameResolutionEnv * Item * TypedTreeOps.TyparInst * + ItemOccurence * AccessibilityLogic.AccessorDomain -> unit + val CallMethodGroupNameResolutionSink: + TcResultsSink -> + Range.range * NameResolutionEnv * Item * Item * TypedTreeOps.TyparInst * + ItemOccurence * AccessibilityLogic.AccessorDomain -> unit + val CallNameResolutionSinkReplacing: + TcResultsSink -> + Range.range * NameResolutionEnv * Item * TypedTreeOps.TyparInst * + ItemOccurence * AccessibilityLogic.AccessorDomain -> unit + val CallExprHasTypeSink: + TcResultsSink -> + Range.range * NameResolutionEnv * TypedTree.TType * + AccessibilityLogic.AccessorDomain -> unit + val CallOpenDeclarationSink: TcResultsSink -> OpenDeclaration -> unit + type ResultTyparChecker = | ResultTyparChecker of (unit -> bool) + val CheckAllTyparsInferrable: + amap:Import.ImportMap -> m:Range.range -> item:Item -> bool + type ResolutionInfo = + | ResolutionInfo of + (Range.range * TypedTree.EntityRef) list * (ResultTyparChecker -> unit) * + tinstEnclosing: EnclosingTypeInst + with + static member + SendEntityPathToSink: sink:TcResultsSink * ncenv:NameResolver * + nenv:NameResolutionEnv * occ:ItemOccurence * + ad:AccessibilityLogic.AccessorDomain * + ResolutionInfo * + typarChecker:ResultTyparChecker -> unit + member + AddEntity: info:(Range.range * TypedTree.EntityRef) -> ResolutionInfo + member AddWarning: f:(ResultTyparChecker -> unit) -> ResolutionInfo + member + WithEnclosingTypeInst: tinstEnclosing:EnclosingTypeInst -> + ResolutionInfo + member EnclosingTypeInst: EnclosingTypeInst + static member Empty: ResolutionInfo + + val CheckForTypeLegitimacyAndMultipleGenericTypeAmbiguities: + tcrefs:(ResolutionInfo * TypedTree.TyconRef) list * + typeNameResInfo:TypeNameResolutionInfo * + genOk:PermitDirectReferenceToGeneratedType * m:Range.range -> + (ResolutionInfo * TypedTree.TyconRef) list + val ResolveLongIdentAsModuleOrNamespace: + TcResultsSink -> + ResultCollectionSettings -> + Import.ImportMap -> + Range.range -> + first:bool -> + FullyQualifiedFlag -> + NameResolutionEnv -> + AccessibilityLogic.AccessorDomain -> + SyntaxTree.Ident -> + SyntaxTree.Ident list -> + isOpenDecl:bool -> + AbstractIL.Internal.Library.ResultOrException<(int * + TypedTree.ModuleOrNamespaceRef * + TypedTree.ModuleOrNamespaceType) list> + val ResolveLongIdentAsModuleOrNamespaceThen: + sink:TcResultsSink -> + atMostOne:ResultCollectionSettings -> + amap:Import.ImportMap -> + m:Range.range -> + fullyQualified:FullyQualifiedFlag -> + nenv:NameResolutionEnv -> + ad:AccessibilityLogic.AccessorDomain -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + isOpenDecl:bool -> + f:(ResolutionInfo -> int -> Range.range -> + TypedTree.ModuleOrNamespaceRef -> + TypedTree.ModuleOrNamespaceType -> + SyntaxTree.Ident -> SyntaxTree.Ident list -> + AbstractIL.Internal.Library.ResultOrException<'a>) -> + AbstractIL.Internal.Library.ResultOrException<'a list> + val private ResolveObjectConstructorPrim: + ncenv:NameResolver -> + edenv:TypedTreeOps.DisplayEnv -> + resInfo:'a -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + ty:TypedTree.TType -> + AbstractIL.Internal.Library.ResultOrException<'a * Item> + val ResolveObjectConstructor: + NameResolver -> + TypedTreeOps.DisplayEnv -> + Range.range -> + AccessibilityLogic.AccessorDomain -> + TypedTree.TType -> + AbstractIL.Internal.Library.ResultOrException + exception IndeterminateType of Range.range + [] + type LookupKind = + | RecdField + | Pattern + | Expr + | Type + | Ctor + val TryFindUnionCaseOfType: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> nm:string -> Infos.UnionCaseInfo voption + val TryFindAnonRecdFieldOfType: + TcGlobals.TcGlobals -> TypedTree.TType -> string -> Item option + val CoreDisplayName: pinfo:Infos.PropInfo -> string + val DecodeFSharpEvent: + pinfos:Infos.PropInfo list -> + ad:AccessibilityLogic.AccessorDomain -> + g:TcGlobals.TcGlobals -> + ncenv:NameResolver -> m:Range.range -> Item option + val GetRecordLabelsForType: + g:TcGlobals.TcGlobals -> + nenv:NameResolutionEnv -> + ty:TypedTree.TType -> System.Collections.Generic.HashSet + val CheckNestedTypesOfType: + ncenv:NameResolver -> + resInfo:ResolutionInfo -> + ad:AccessibilityLogic.AccessorDomain -> + nm:string -> + typeNameResInfo:TypeNameResolutionInfo -> + m:Range.range -> ty:TypedTree.TType -> TypedTree.TType list + val ResolveLongIdentInTypePrim: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + lookupKind:LookupKind -> + resInfo:ResolutionInfo -> + depth:int -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + findFlag:InfoReader.FindMemberFlag -> + typeNameResInfo:TypeNameResolutionInfo -> + ty:TypedTree.TType -> + AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * + Item * + SyntaxTree.Ident list) list> + val ResolveLongIdentInNestedTypes: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + lookupKind:LookupKind -> + resInfo:ResolutionInfo -> + depth:int -> + id:SyntaxTree.Ident -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + id2:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + findFlag:InfoReader.FindMemberFlag -> + typeNameResInfo:TypeNameResolutionInfo -> + tys:TypedTree.TType list -> + AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * + Item * + SyntaxTree.Ident list) list> + val ResolveLongIdentInType: + TcResultsSink -> + NameResolver -> + NameResolutionEnv -> + LookupKind -> + Range.range -> + AccessibilityLogic.AccessorDomain -> + SyntaxTree.Ident -> + InfoReader.FindMemberFlag -> + TypeNameResolutionInfo -> + TypedTree.TType -> Item * SyntaxTree.Ident list + val private ResolveLongIdentInTyconRef: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + lookupKind:LookupKind -> + resInfo:ResolutionInfo -> + depth:int -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + typeNameResInfo:TypeNameResolutionInfo -> + tcref:TypedTree.TyconRef -> + AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * + Item * + SyntaxTree.Ident list) list> + val private ResolveLongIdentInTyconRefs: + atMostOne:ResultCollectionSettings -> + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + lookupKind:LookupKind -> + depth:int -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + typeNameResInfo:TypeNameResolutionInfo -> + idRange:Range.range -> + tcrefs:(ResolutionInfo * TypedTree.EntityRef) list -> + AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * + Item * + SyntaxTree.Ident list) list> + val ( |AccessibleEntityRef|_| ): + amap:Import.ImportMap -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + modref:TypedTree.ModuleOrNamespaceRef -> + mspec:TypedTree.Entity -> TypedTree.EntityRef option + val ResolveExprLongIdentInModuleOrNamespace: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + typeNameResInfo:TypeNameResolutionInfo -> + ad:AccessibilityLogic.AccessorDomain -> + resInfo:ResolutionInfo -> + depth:int -> + m:Range.range -> + modref:TypedTree.EntityRef -> + mty:TypedTree.ModuleOrNamespaceType -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + AbstractIL.Internal.Library.ResultOrException + val ChooseTyconRefInExpr: + ncenv:NameResolver * m:Range.range * ad:AccessibilityLogic.AccessorDomain * + nenv:NameResolutionEnv * id:SyntaxTree.Ident * + typeNameResInfo:TypeNameResolutionInfo * + tcrefs:(ResolutionInfo * TypedTree.TyconRef) list -> + AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * Item) list> + val ResolveUnqualifiedTyconRefs: + nenv:NameResolutionEnv -> + tcrefs:TypedTree.TyconRef list -> + (ResolutionInfo * TypedTree.TyconRef) list + val ResolveExprLongIdentPrim: + sink:TcResultsSink -> + ncenv:NameResolver -> + first:bool -> + fullyQualified:FullyQualifiedFlag -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + nenv:NameResolutionEnv -> + typeNameResInfo:TypeNameResolutionInfo -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + isOpenDecl:bool -> + AbstractIL.Internal.Library.ResultOrException + val ResolveExprLongIdent: + TcResultsSink -> + NameResolver -> + Range.range -> + AccessibilityLogic.AccessorDomain -> + NameResolutionEnv -> + TypeNameResolutionInfo -> + SyntaxTree.Ident list -> + AbstractIL.Internal.Library.ResultOrException + val ResolvePatternLongIdentInModuleOrNamespace: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + numTyArgsOpt:TypeNameResolutionInfo -> + ad:AccessibilityLogic.AccessorDomain -> + resInfo:ResolutionInfo -> + depth:int -> + m:Range.range -> + modref:TypedTree.ModuleOrNamespaceRef -> + mty:TypedTree.ModuleOrNamespaceType -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + AbstractIL.Internal.Library.ResultOrException + exception UpperCaseIdentifierInPattern of Range.range + type WarnOnUpperFlag = + | WarnOnUpperCase + | AllIdsOK + val ResolvePatternLongIdentPrim: + sink:TcResultsSink -> + ncenv:NameResolver -> + fullyQualified:FullyQualifiedFlag -> + warnOnUpper:WarnOnUpperFlag -> + newDef:bool -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + nenv:NameResolutionEnv -> + numTyArgsOpt:TypeNameResolutionInfo -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> Item + val ResolvePatternLongIdent: + TcResultsSink -> + NameResolver -> + WarnOnUpperFlag -> + bool -> + Range.range -> + AccessibilityLogic.AccessorDomain -> + NameResolutionEnv -> + TypeNameResolutionInfo -> SyntaxTree.Ident list -> Item + val ResolveNestedTypeThroughAbbreviation: + ncenv:NameResolver -> + tcref:TypedTree.TyconRef -> m:Range.range -> TypedTree.TyconRef + val ResolveTypeLongIdentInTyconRefPrim: + ncenv:NameResolver -> + typeNameResInfo:TypeNameResolutionInfo -> + ad:AccessibilityLogic.AccessorDomain -> + resInfo:ResolutionInfo -> + genOk:PermitDirectReferenceToGeneratedType -> + depth:int -> + m:Range.range -> + tcref:TypedTree.TyconRef -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + AbstractIL.Internal.Library.ResultOrException + val ResolveTypeLongIdentInTyconRef: + TcResultsSink -> + NameResolver -> + NameResolutionEnv -> + TypeNameResolutionInfo -> + AccessibilityLogic.AccessorDomain -> + Range.range -> + TypedTree.TyconRef -> + SyntaxTree.Ident list -> TypedTree.TyconRef + val SuggestTypeLongIdentInModuleOrNamespace: + depth:int -> + modref:TypedTree.ModuleOrNamespaceRef -> + amap:Import.ImportMap -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> id:SyntaxTree.Ident -> exn + val private ResolveTypeLongIdentInModuleOrNamespace: + sink:TcResultsSink -> + nenv:NameResolutionEnv -> + ncenv:NameResolver -> + typeNameResInfo:TypeNameResolutionInfo -> + ad:AccessibilityLogic.AccessorDomain -> + genOk:PermitDirectReferenceToGeneratedType -> + resInfo:ResolutionInfo -> + depth:int -> + m:Range.range -> + modref:TypedTree.ModuleOrNamespaceRef -> + _mty:TypedTree.ModuleOrNamespaceType -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * + TypedTree.EntityRef) list> + val ResolveTypeLongIdentPrim: + sink:TcResultsSink -> + ncenv:NameResolver -> + occurence:ItemOccurence -> + first:bool -> + fullyQualified:FullyQualifiedFlag -> + m:Range.range -> + nenv:NameResolutionEnv -> + ad:AccessibilityLogic.AccessorDomain -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + staticResInfo:TypeNameResolutionStaticArgsInfo -> + genOk:PermitDirectReferenceToGeneratedType -> + AbstractIL.Internal.Library.ResultOrException + val ResolveTypeLongIdentAux: + sink:TcResultsSink -> + ncenv:NameResolver -> + occurence:ItemOccurence -> + fullyQualified:FullyQualifiedFlag -> + nenv:NameResolutionEnv -> + ad:AccessibilityLogic.AccessorDomain -> + lid:SyntaxTree.Ident list -> + staticResInfo:TypeNameResolutionStaticArgsInfo -> + genOk:PermitDirectReferenceToGeneratedType -> + AbstractIL.Internal.Library.ResultOrException + val ResolveTypeLongIdent: + TcResultsSink -> + NameResolver -> + ItemOccurence -> + FullyQualifiedFlag -> + NameResolutionEnv -> + AccessibilityLogic.AccessorDomain -> + SyntaxTree.Ident list -> + TypeNameResolutionStaticArgsInfo -> + PermitDirectReferenceToGeneratedType -> + AbstractIL.Internal.Library.ResultOrException + val ResolveFieldInModuleOrNamespace: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + ad:AccessibilityLogic.AccessorDomain -> + resInfo:ResolutionInfo -> + depth:int -> + m:Range.range -> + modref:TypedTree.ModuleOrNamespaceRef -> + _mty:TypedTree.ModuleOrNamespaceType -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + AbstractIL.Internal.Library.ResultOrException + val SuggestOtherLabelsOfSameRecordType: + g:TcGlobals.TcGlobals -> + nenv:NameResolutionEnv -> + ty:TypedTree.TType -> + id:SyntaxTree.Ident -> + allFields:SyntaxTree.Ident list -> + System.Collections.Generic.HashSet + val SuggestLabelsOfRelatedRecords: + g:TcGlobals.TcGlobals -> + nenv:NameResolutionEnv -> + id:SyntaxTree.Ident -> allFields:SyntaxTree.Ident list -> exn + val ResolveFieldPrim: + sink:TcResultsSink -> + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + ad:AccessibilityLogic.AccessorDomain -> + ty:TypedTree.TType -> + mp:SyntaxTree.Ident list * id:SyntaxTree.Ident -> + allFields:SyntaxTree.Ident list -> + (ResolutionInfo * FieldResolution) list + val ResolveField: + TcResultsSink -> + NameResolver -> + NameResolutionEnv -> + AccessibilityLogic.AccessorDomain -> + TypedTree.TType -> + SyntaxTree.Ident list * SyntaxTree.Ident -> + SyntaxTree.Ident list -> FieldResolution list + val private ResolveExprDotLongIdent: + ncenv:NameResolver -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + nenv:NameResolutionEnv -> + ty:TypedTree.TType -> + id:SyntaxTree.Ident -> + rest:SyntaxTree.Ident list -> + typeNameResInfo:TypeNameResolutionInfo -> + findFlag:InfoReader.FindMemberFlag -> + ResolutionInfo * Item * SyntaxTree.Ident list + val ComputeItemRange: + wholem:Range.range -> + lid:SyntaxTree.Ident list -> rest:'a list -> Range.range + val FilterMethodGroups: + ncenv:NameResolver -> + itemRange:Range.range -> item:Item -> staticOnly:bool -> Item + val NeedsWorkAfterResolution: namedItem:Item -> bool + [] + type AfterResolution = + | DoNothing + | RecordResolution of + Item option * (TypedTreeOps.TyparInst -> unit) * + (Infos.MethInfo * Infos.PropInfo option * TypedTreeOps.TyparInst -> unit) * + (unit -> unit) + val ResolveLongIdentAsExprAndComputeRange: + TcResultsSink -> + NameResolver -> + Range.range -> + AccessibilityLogic.AccessorDomain -> + NameResolutionEnv -> + TypeNameResolutionInfo -> + SyntaxTree.Ident list -> + AbstractIL.Internal.Library.ResultOrException + val ( |NonOverridable|_| ): namedItem:Item -> unit option + val ResolveExprDotLongIdentAndComputeRange: + TcResultsSink -> + NameResolver -> + Range.range -> + AccessibilityLogic.AccessorDomain -> + NameResolutionEnv -> + TypedTree.TType -> + SyntaxTree.Ident list -> + TypeNameResolutionInfo -> + InfoReader.FindMemberFlag -> + bool -> + Item * Range.range * SyntaxTree.Ident list * + AfterResolution + val FakeInstantiationGenerator: + Range.range -> TypedTree.Typar list -> TypedTree.TType list + val ItemForModuleOrNamespaceRef: v:TypedTree.ModuleOrNamespaceRef -> Item + val ItemForPropInfo: pinfo:Infos.PropInfo -> Item + val IsTyconUnseenObsoleteSpec: + ad:AccessibilityLogic.AccessorDomain -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> x:TypedTree.TyconRef -> allowObsolete:bool -> bool + val IsTyconUnseen: + ad:AccessibilityLogic.AccessorDomain -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> m:Range.range -> x:TypedTree.TyconRef -> bool + val IsValUnseen: + ad:AccessibilityLogic.AccessorDomain -> + g:TcGlobals.TcGlobals -> m:'a -> v:TypedTree.ValRef -> bool + val IsUnionCaseUnseen: + ad:AccessibilityLogic.AccessorDomain -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ucref:TypedTree.UnionCaseRef -> bool + val ItemIsUnseen: + ad:AccessibilityLogic.AccessorDomain -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> m:Range.range -> item:Item -> bool + val ItemOfTyconRef: + ncenv:NameResolver -> m:Range.range -> x:TypedTree.TyconRef -> Item + val ItemOfTy: g:TcGlobals.TcGlobals -> x:TypedTree.TType -> Item + val IsInterestingModuleName: nm:string -> bool + val PartialResolveLookupInModuleOrNamespaceAsModuleOrNamespaceThen: + f:(TypedTree.ModuleOrNamespaceRef -> 'a list) -> + plid:string list -> modref:TypedTree.ModuleOrNamespaceRef -> 'a list + val PartialResolveLongIdentAsModuleOrNamespaceThen: + nenv:NameResolutionEnv -> + plid:string list -> + f:(TypedTree.ModuleOrNamespaceRef -> 'a list) -> 'a list + val ResolveRecordOrClassFieldsOfType: + NameResolver -> + Range.range -> + AccessibilityLogic.AccessorDomain -> + TypedTree.TType -> bool -> Item list + [] + type ResolveCompletionTargets = + | All of (Infos.MethInfo -> TypedTree.TType -> bool) + | SettablePropertiesAndFields + with + member ResolveAll: bool + + val ResolveCompletionsInType: + NameResolver -> + NameResolutionEnv -> + ResolveCompletionTargets -> + Range.range -> + AccessibilityLogic.AccessorDomain -> + bool -> TypedTree.TType -> Item list + val ResolvePartialLongIdentInType: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + isApplicableMeth:ResolveCompletionTargets -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + statics:bool -> + plid:string list -> ty:TypedTree.TType -> Item list + val InfosForTyconConstructors: + ncenv:NameResolver -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + tcref:TypedTree.TyconRef -> Item list + val inline notFakeContainerModule: + tyconNames:System.Collections.Generic.HashSet<'a> -> nm:'a -> bool + val getFakeContainerModulesFromTycons: + tycons:#seq -> System.Collections.Generic.HashSet + val getFakeContainerModulesFromTyconRefs: + tyconRefs:#seq -> + System.Collections.Generic.HashSet + val private EntityRefContainsSomethingAccessible: + ncenv:NameResolver -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + modref:TypedTree.ModuleOrNamespaceRef -> bool + val ResolvePartialLongIdentInModuleOrNamespace: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + isApplicableMeth:ResolveCompletionTargets -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + modref:TypedTree.ModuleOrNamespaceRef -> + plid:string list -> allowObsolete:bool -> Item list + val TryToResolveLongIdentAsType: + NameResolver -> + NameResolutionEnv -> + Range.range -> string list -> TypedTree.TType option + val ResolvePartialLongIdentPrim: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + isApplicableMeth:ResolveCompletionTargets -> + fullyQualified:FullyQualifiedFlag -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + plid:string list -> allowObsolete:bool -> Item list + val ResolvePartialLongIdent: + NameResolver -> + NameResolutionEnv -> + (Infos.MethInfo -> TypedTree.TType -> bool) -> + Range.range -> + AccessibilityLogic.AccessorDomain -> + string list -> bool -> Item list + val ResolvePartialLongIdentInModuleOrNamespaceForRecordFields: + ncenv:NameResolver -> + nenv:'a -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + modref:TypedTree.ModuleOrNamespaceRef -> + plid:string list -> allowObsolete:bool -> Item list + val ResolvePartialLongIdentToClassOrRecdFields: + NameResolver -> + NameResolutionEnv -> + Range.range -> + AccessibilityLogic.AccessorDomain -> + string list -> bool -> Item list + val ResolvePartialLongIdentToClassOrRecdFieldsImpl: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + fullyQualified:FullyQualifiedFlag -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + plid:string list -> allowObsolete:bool -> Item list + val ResolveCompletionsInTypeForItem: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + statics:bool -> ty:TypedTree.TType -> item:Item -> seq + val ResolvePartialLongIdentInTypeForItem: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + statics:bool -> + plid:string list -> item:Item -> ty:TypedTree.TType -> seq + val ResolvePartialLongIdentInModuleOrNamespaceForItem: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + modref:TypedTree.ModuleOrNamespaceRef -> + plid:string list -> item:Item -> seq + val PartialResolveLookupInModuleOrNamespaceAsModuleOrNamespaceThenLazy: + f:(TypedTree.ModuleOrNamespaceRef -> seq<'a>) -> + plid:string list -> modref:TypedTree.ModuleOrNamespaceRef -> seq<'a> + val PartialResolveLongIdentAsModuleOrNamespaceThenLazy: + nenv:NameResolutionEnv -> + plid:string list -> + f:(TypedTree.ModuleOrNamespaceRef -> seq<'a>) -> seq<'a> + val GetCompletionForItem: + ncenv:NameResolver -> + nenv:NameResolutionEnv -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + plid:string list -> item:Item -> seq + val IsItemResolvable: + NameResolver -> + NameResolutionEnv -> + Range.range -> + AccessibilityLogic.AccessorDomain -> string list -> Item -> bool + val GetVisibleNamespacesAndModulesAtPoint: + NameResolver -> + NameResolutionEnv -> + Range.range -> + AccessibilityLogic.AccessorDomain -> + TypedTree.ModuleOrNamespaceRef list + + +namespace FSharp.Compiler + module internal SignatureConformance = + exception RequiredButNotSpecified of + TypedTreeOps.DisplayEnv * + TypedTree.ModuleOrNamespaceRef * string * + (System.Text.StringBuilder -> unit) * + Range.range + exception ValueNotContained of + TypedTreeOps.DisplayEnv * + TypedTree.ModuleOrNamespaceRef * TypedTree.Val * + TypedTree.Val * + (string * string * string -> string) + exception ConstrNotContained of + TypedTreeOps.DisplayEnv * TypedTree.UnionCase * + TypedTree.UnionCase * + (string * string -> string) + exception ExnconstrNotContained of + TypedTreeOps.DisplayEnv * TypedTree.Tycon * + TypedTree.Tycon * + (string * string -> string) + exception FieldNotContained of + TypedTreeOps.DisplayEnv * TypedTree.RecdField * + TypedTree.RecdField * + (string * string -> string) + exception InterfaceNotRevealed of + TypedTreeOps.DisplayEnv * TypedTree.TType * + Range.range + type Checker = + + new: g:TcGlobals.TcGlobals * amap:Import.ImportMap * + denv:TypedTreeOps.DisplayEnv * + remapInfo:TypedTreeOps.SignatureRepackageInfo * checkingSig:bool -> + Checker + member + CheckSignature: aenv:TypedTreeOps.TypeEquivEnv -> + implModRef:TypedTree.ModuleOrNamespaceRef -> + signModType:TypedTree.ModuleOrNamespaceType -> + bool + member + CheckTypars: m:Range.range -> + aenv:TypedTreeOps.TypeEquivEnv -> + implTypars:TypedTree.Typars -> + signTypars:TypedTree.Typars -> bool + + val CheckNamesOfModuleOrNamespaceContents: + denv:TypedTreeOps.DisplayEnv -> + implModRef:TypedTree.ModuleOrNamespaceRef -> + signModType:TypedTree.ModuleOrNamespaceType -> bool + val CheckNamesOfModuleOrNamespace: + denv:TypedTreeOps.DisplayEnv -> + implModRef:TypedTree.ModuleOrNamespaceRef -> + signModType:TypedTree.ModuleOrNamespaceType -> bool + + +namespace FSharp.Compiler + module internal MethodOverrides = + type OverrideCanImplement = + | CanImplementAnyInterfaceSlot + | CanImplementAnyClassHierarchySlot + | CanImplementAnySlot + | CanImplementNoSlots + type OverrideInfo = + | Override of + OverrideCanImplement * TypedTree.TyconRef * SyntaxTree.Ident * + (TypedTree.Typars * TypedTreeOps.TyparInst) * TypedTree.TType list list * + TypedTree.TType option * bool * bool + with + member ArgTypes: TypedTree.TType list list + member BoundingTyconRef: TypedTree.TyconRef + member CanImplement: OverrideCanImplement + member IsCompilerGenerated: bool + member IsFakeEventProperty: bool + member LogicalName: string + member Range: Range.range + member ReturnType: TypedTree.TType option + + type RequiredSlot = + | RequiredSlot of Infos.MethInfo * isOptional: bool + | DefaultInterfaceImplementationSlot of + Infos.MethInfo * isOptional: bool * possiblyNoMostSpecific: bool + with + member HasDefaultInterfaceImplementation: bool + member IsOptional: bool + member MethodInfo: Infos.MethInfo + member PossiblyNoMostSpecificImplementation: bool + + type SlotImplSet = + | SlotImplSet of + RequiredSlot list * + AbstractIL.Internal.Library.NameMultiMap * + OverrideInfo list * Infos.PropInfo list + exception TypeIsImplicitlyAbstract of Range.range + exception OverrideDoesntOverride of + TypedTreeOps.DisplayEnv * OverrideInfo * + Infos.MethInfo option * + TcGlobals.TcGlobals * Import.ImportMap * + Range.range + module DispatchSlotChecking = + val PrintOverrideToBuffer: + denv:TypedTreeOps.DisplayEnv -> + os:System.Text.StringBuilder -> OverrideInfo -> unit + val PrintMethInfoSigToBuffer: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + os:System.Text.StringBuilder -> minfo:Infos.MethInfo -> unit + val FormatOverride: + denv:TypedTreeOps.DisplayEnv -> d:OverrideInfo -> string + val FormatMethInfoSig: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> d:Infos.MethInfo -> string + val GetInheritedMemberOverrideInfo: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + parentType:OverrideCanImplement -> + minfo:Infos.MethInfo -> OverrideInfo + val GetTypeMemberOverrideInfo: + g:TcGlobals.TcGlobals -> + reqdTy:TypedTree.TType -> overrideBy:TypedTree.ValRef -> OverrideInfo + val GetObjectExprOverrideInfo: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + implty:TypedTree.TType * id:SyntaxTree.Ident * + memberFlags:SyntaxTree.MemberFlags * ty:TypedTree.TType * + arityInfo:TypedTree.ValReprInfo * bindingAttribs:TypedTree.Attribs * + rhsExpr:TypedTree.Expr -> + OverrideInfo * + (TypedTree.Val option * TypedTree.Val * TypedTree.Val list list * + TypedTree.Attribs * TypedTree.Expr) + val IsNameMatch: + dispatchSlot:Infos.MethInfo -> overrideBy:OverrideInfo -> bool + val IsImplMatch: + g:TcGlobals.TcGlobals -> + dispatchSlot:Infos.MethInfo -> overrideBy:OverrideInfo -> bool + val IsTyparKindMatch: Infos.CompiledSig -> OverrideInfo -> bool + val IsSigPartialMatch: + g:TcGlobals.TcGlobals -> + dispatchSlot:Infos.MethInfo -> + compiledSig:Infos.CompiledSig -> OverrideInfo -> bool + val IsPartialMatch: + g:TcGlobals.TcGlobals -> + dispatchSlot:Infos.MethInfo -> + compiledSig:Infos.CompiledSig -> overrideBy:OverrideInfo -> bool + val ReverseTyparRenaming: + g:TcGlobals.TcGlobals -> + tinst:(TypedTree.Typar * TypedTree.TType) list -> + (TypedTree.Typar * TypedTree.TType) list + val ComposeTyparInsts: + inst1:('a * TypedTree.TType) list -> + inst2:TypedTreeOps.TyparInst -> ('a * TypedTree.TType) list + val IsSigExactMatch: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> dispatchSlot:Infos.MethInfo -> OverrideInfo -> bool + val IsExactMatch: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + dispatchSlot:Infos.MethInfo -> overrideBy:OverrideInfo -> bool + val OverrideImplementsDispatchSlot: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + dispatchSlot:Infos.MethInfo -> + availPriorOverride:OverrideInfo -> bool + val DispatchSlotIsAlreadyImplemented: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + availPriorOverridesKeyed:AbstractIL.Internal.Library.NameMultiMap -> + dispatchSlot:Infos.MethInfo -> bool + val CheckDispatchSlotsAreImplemented: + denv:TypedTreeOps.DisplayEnv * infoReader:InfoReader.InfoReader * + m:Range.range * nenv:NameResolution.NameResolutionEnv * + sink:NameResolution.TcResultsSink * isOverallTyAbstract:bool * + reqdTy:TypedTree.TType * dispatchSlots:RequiredSlot list * + availPriorOverrides:OverrideInfo list * overrides:OverrideInfo list -> + bool + val GetMostSpecificOverrideInterfaceMethodSets: + infoReader:InfoReader.InfoReader -> + allReqdTys:(TypedTree.TType * Range.range) list -> + Map + val GetMostSpecificOverrideInterfaceMethodsByMethod: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + mostSpecificOverrides:AbstractIL.Internal.Library.NameMultiMap -> + minfo:Infos.MethInfo -> (TypedTree.TType * Infos.MethInfo) list + val GetInterfaceDispatchSlots: + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + availImpliedInterfaces:TypedTree.TType list -> + mostSpecificOverrides:AbstractIL.Internal.Library.NameMultiMap -> + interfaceTy:TypedTree.TType -> RequiredSlot list + val GetClassDispatchSlots: + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> reqdTy:TypedTree.TType -> RequiredSlot list + val GetDispatchSlotSet: + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> + availImpliedInterfaces:TypedTree.TType list -> + mostSpecificOverrides:AbstractIL.Internal.Library.NameMultiMap -> + reqdTy:TypedTree.TType -> + impliedTys:seq -> + (TypedTree.TType * RequiredSlot list) list + val CheckOverridesAreAllUsedOnce: + denv:TypedTreeOps.DisplayEnv * g:TcGlobals.TcGlobals * + amap:Import.ImportMap * isObjExpr:bool * reqdTy:TypedTree.TType * + dispatchSlotsKeyed:AbstractIL.Internal.Library.NameMultiMap * + availPriorOverrides:OverrideInfo list * overrides:OverrideInfo list -> + unit + val GetSlotImplSets: + infoReader:InfoReader.InfoReader -> + denv:TypedTreeOps.DisplayEnv -> + ad:AccessibilityLogic.AccessorDomain -> + isObjExpr:bool -> + allReqdTys:(TypedTree.TType * Range.range) list -> + SlotImplSet list + val CheckImplementationRelationAtEndOfInferenceScope: + infoReader:InfoReader.InfoReader * denv:TypedTreeOps.DisplayEnv * + nenv:NameResolution.NameResolutionEnv * + sink:NameResolution.TcResultsSink * tycon:TypedTree.Tycon * + isImplementation:bool -> unit + + val FinalTypeDefinitionChecksAtEndOfInferenceScope: + infoReader:InfoReader.InfoReader * nenv:NameResolution.NameResolutionEnv * + sink:NameResolution.TcResultsSink * isImplementation:bool * + denv:TypedTreeOps.DisplayEnv -> tycon:TypedTree.Tycon -> unit + val GetAbstractMethInfosForSynMethodDecl: + infoReader:InfoReader.InfoReader * ad:AccessibilityLogic.AccessorDomain * + memberName:SyntaxTree.Ident * bindm:Range.range * + typToSearchForAbstractMembers:(TypedTree.TType * SlotImplSet option) * + valSynData:SyntaxTree.SynValInfo -> + Infos.MethInfo list * Infos.MethInfo list + val GetAbstractPropInfosForSynPropertyDecl: + infoReader:InfoReader.InfoReader * ad:AccessibilityLogic.AccessorDomain * + memberName:SyntaxTree.Ident * bindm:Range.range * + typToSearchForAbstractMembers:(TypedTree.TType * SlotImplSet option) * + _k:'a * _valSynData:'b -> Infos.PropInfo list + + +namespace FSharp.Compiler + module internal MethodCalls = + type CallerArg<'T> = + | CallerArg of + ty: TypedTree.TType * range: Range.range * isOpt: bool * exprInfo: 'T + with + member CallerArgumentType: TypedTree.TType + member Expr: 'T + member IsExplicitOptional: bool + member Range: Range.range + + type CalledArg = + { Position: struct (int * int) + IsParamArray: bool + OptArgInfo: Infos.OptionalArgInfo + CallerInfo: Infos.CallerInfo + IsInArg: bool + IsOutArg: bool + ReflArgInfo: Infos.ReflectedArgInfo + NameOpt: SyntaxTree.Ident option + CalledArgumentType: TypedTree.TType } + val CalledArg: + pos:struct (int * int) * isParamArray:bool * + optArgInfo:Infos.OptionalArgInfo * callerInfo:Infos.CallerInfo * + isInArg:bool * isOutArg:bool * nameOpt:SyntaxTree.Ident option * + reflArgInfo:Infos.ReflectedArgInfo * calledArgTy:TypedTree.TType -> + CalledArg + type AssignedCalledArg<'T> = + { NamedArgIdOpt: SyntaxTree.Ident option + CalledArg: CalledArg + CallerArg: CallerArg<'T> } + with + member Position: struct (int * int) + + type AssignedItemSetterTarget = + | AssignedPropSetter of + Infos.PropInfo * Infos.MethInfo * TypedTree.TypeInst + | AssignedILFieldSetter of Infos.ILFieldInfo + | AssignedRecdFieldSetter of Infos.RecdFieldInfo + type AssignedItemSetter<'T> = + | AssignedItemSetter of + SyntaxTree.Ident * AssignedItemSetterTarget * CallerArg<'T> + type CallerNamedArg<'T> = + | CallerNamedArg of SyntaxTree.Ident * CallerArg<'T> + with + member CallerArg: CallerArg<'T> + member Ident: SyntaxTree.Ident + member Name: string + + [] + type CallerArgs<'T> = + { Unnamed: CallerArg<'T> list list + Named: CallerNamedArg<'T> list list } + with + member ArgumentNamesAndTypes: (string option * TypedTree.TType) list + member CallerArgCounts: int * int + member + CurriedCallerArgs: (CallerArg<'T> list * CallerNamedArg<'T> list) list + static member Empty: CallerArgs<'T> + + val AdjustCalledArgTypeForLinqExpressionsAndAutoQuote: + infoReader:InfoReader.InfoReader -> + callerArgTy:TypedTree.TType -> + calledArg:CalledArg -> m:Range.range -> TypedTree.TType + val AdjustCalledArgTypeForOptionals: + g:TcGlobals.TcGlobals -> + enforceNullableOptionalsKnownTypes:bool -> + calledArg:CalledArg -> + calledArgTy:TypedTree.TType -> + callerArg:CallerArg<'a> -> TypedTree.TType + val AdjustCalledArgType: + infoReader:InfoReader.InfoReader -> + isConstraint:bool -> + enforceNullableOptionalsKnownTypes:bool -> + calledArg:CalledArg -> callerArg:CallerArg<'a> -> TypedTree.TType + type CalledMethArgSet<'T> = + { UnnamedCalledArgs: CalledArg list + UnnamedCallerArgs: CallerArg<'T> list + ParamArrayCalledArgOpt: CalledArg option + ParamArrayCallerArgs: CallerArg<'T> list + AssignedNamedArgs: AssignedCalledArg<'T> list } + with + member NumAssignedNamedArgs: int + member NumUnnamedCalledArgs: int + member NumUnnamedCallerArgs: int + + val MakeCalledArgs: + amap:Import.ImportMap -> + m:Range.range -> + minfo:Infos.MethInfo -> + minst:TypedTree.TType list -> CalledArg list list + type CalledMeth<'T> = + + new: infoReader:InfoReader.InfoReader * + nameEnv:NameResolution.NameResolutionEnv option * + isCheckingAttributeCall:bool * + freshenMethInfo:(Range.range -> Infos.MethInfo -> + TypedTree.TypeInst) * m:Range.range * + ad:AccessibilityLogic.AccessorDomain * minfo:Infos.MethInfo * + calledTyArgs:TypedTree.TType list * + callerTyArgs:TypedTree.TType list * pinfoOpt:Infos.PropInfo option * + callerObjArgTys:TypedTree.TType list * callerArgs:CallerArgs<'T> * + allowParamArgs:bool * allowOutAndOptArgs:bool * + tyargsOpt:TypedTree.TType option -> CalledMeth<'T> + static member GetMethod: x:CalledMeth<'T> -> Infos.MethInfo + member CalledObjArgTys: m:Range.range -> TypedTree.TType list + member GetParamArrayElementType: unit -> TypedTree.TType + member HasCorrectObjArgs: m:Range.range -> bool + member + IsAccessible: m:Range.range * ad:AccessibilityLogic.AccessorDomain -> + bool + member + IsCandidate: m:Range.range * ad:AccessibilityLogic.AccessorDomain -> + bool + override ToString: unit -> string + member AllCalledArgs: CalledArg list list + member AllUnnamedCalledArgs: CalledArg list + member ArgSets: CalledMethArgSet<'T> list + member AssignedItemSetters: AssignedItemSetter<'T> list + member AssignedNamedArgs: AssignedCalledArg<'T> list list + member AssignedUnnamedArgs: AssignedCalledArg<'T> list list + member AssignsAllNamedArgs: bool + member AssociatedPropertyInfo: Infos.PropInfo option + member AttributeAssignedNamedArgs: CallerNamedArg<'T> list + member CalledReturnTypeAfterByrefDeref: TypedTree.TType + member CalledReturnTypeAfterOutArgTupling: TypedTree.TType + member CalledTyArgs: TypedTree.TType list + member CalledTyparInst: TypedTreeOps.TyparInst + member CallerObjArgTys: TypedTree.TType list + member CallerTyArgs: TypedTree.TType list + member HasCorrectArity: bool + member HasCorrectGenericArity: bool + member HasOptArgs: bool + member HasOutArgs: bool + member Method: Infos.MethInfo + member NumArgSets: int + member NumAssignedProps: int + member NumCalledTyArgs: int + member NumCallerTyArgs: int + member ParamArrayCalledArgOpt: CalledArg option + member ParamArrayCallerArgs: CallerArg<'T> list option + member TotalNumAssignedNamedArgs: int + member TotalNumUnnamedCalledArgs: int + member TotalNumUnnamedCallerArgs: int + member UnassignedNamedArgs: CallerNamedArg<'T> list + member UnnamedCalledOptArgs: CalledArg list + member UnnamedCalledOutArgs: CalledArg list + member UsesParamArrayConversion: bool + member amap: Import.ImportMap + member infoReader: InfoReader.InfoReader + + val NamesOfCalledArgs: calledArgs:CalledArg list -> SyntaxTree.Ident list + type ArgumentAnalysis = + | NoInfo + | ArgDoesNotMatch + | CallerLambdaHasArgTypes of TypedTree.TType list + | CalledArgMatchesType of TypedTree.TType + val InferLambdaArgsForLambdaPropagation: + origRhsExpr:SyntaxTree.SynExpr -> int + val ExamineArgumentForLambdaPropagation: + infoReader:InfoReader.InfoReader -> + arg:AssignedCalledArg -> ArgumentAnalysis + val ExamineMethodForLambdaPropagation: + x:CalledMeth -> + (ArgumentAnalysis list list * + (SyntaxTree.Ident * ArgumentAnalysis) list list) option + val IsBaseCall: objArgs:TypedTree.Expr list -> bool + val ComputeConstrainedCallInfo: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + objArgs:TypedTree.Expr list * minfo:Infos.MethInfo -> + TypedTree.TType option + val TakeObjAddrForMethodCall: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + minfo:Infos.MethInfo -> + isMutable:TypedTreeOps.Mutates -> + m:Range.range -> + objArgs:TypedTree.Expr list -> + f:(TypedTree.TType option -> TypedTree.Expr list -> + TypedTree.Expr * 'a) -> TypedTree.Expr * 'a + val BuildILMethInfoCall: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + isProp:bool -> + minfo:Infos.ILMethInfo -> + valUseFlags:TypedTree.ValUseFlag -> + minst:TypedTree.TType list -> + direct:bool -> + args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType + val BuildFSharpMethodApp: + g:TcGlobals.TcGlobals -> + m:Range.range -> + vref:TypedTree.ValRef -> + vexp:TypedTree.Expr -> + vexprty:TypedTree.TType -> + args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType + val BuildFSharpMethodCall: + g:TcGlobals.TcGlobals -> + m:Range.range -> + ty:TypedTree.TType * vref:TypedTree.ValRef -> + valUseFlags:TypedTree.ValUseFlag -> + minst:TypedTree.TType list -> + args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType + val MakeMethInfoCall: + amap:Import.ImportMap -> + m:Range.range -> + minfo:Infos.MethInfo -> + minst:TypedTree.TType list -> args:TypedTree.Exprs -> TypedTree.Expr + val TryImportProvidedMethodBaseAsLibraryIntrinsic: + amap:Import.ImportMap * m:Range.range * + mbase:Tainted -> + TypedTree.ValRef option + val BuildMethodCall: + tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TType list -> + Range.range -> TypedTree.Expr * TypedTree.TType) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + isMutable:TypedTreeOps.Mutates -> + m:Range.range -> + isProp:bool -> + minfo:Infos.MethInfo -> + valUseFlags:TypedTree.ValUseFlag -> + minst:TypedTree.TType list -> + objArgs:TypedTree.Expr list -> + args:TypedTree.Expr list -> + TypedTree.Expr * TypedTree.TType + val BuildObjCtorCall: + g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.Expr + val BuildNewDelegateExpr: + eventInfoOpt:Infos.EventInfo option * g:TcGlobals.TcGlobals * + amap:Import.ImportMap * delegateTy:TypedTree.TType * + invokeMethInfo:Infos.MethInfo * delArgTys:TypedTree.TType list * + f:TypedTree.Expr * fty:TypedTree.TType * m:Range.range -> TypedTree.Expr + val CoerceFromFSharpFuncToDelegate: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + callerArgTy:TypedTree.TType -> + m:Range.range -> + callerArgExpr:TypedTree.Expr -> + delegateTy:TypedTree.TType -> TypedTree.Expr + val AdjustCallerArgExprForCoercions: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + isOutArg:bool -> + calledArgTy:TypedTree.TType -> + reflArgInfo:Infos.ReflectedArgInfo -> + callerArgTy:TypedTree.TType -> + m:Range.range -> + callerArgExpr:TypedTree.Expr -> + 'a option * TypedTree.Expr + val emptyPreBinder: e:TypedTree.Expr -> TypedTree.Expr + val GetDefaultExpressionForCallerSideOptionalArg: + tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> + g:TcGlobals.TcGlobals -> + calledArg:CalledArg -> + currCalledArgTy:TypedTree.TType -> + currDfltVal:Infos.OptionalArgCallerSideValue -> + eCallerMemberName:string option -> + mMethExpr:Range.range -> + (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr + val GetDefaultExpressionForCalleeSideOptionalArg: + g:TcGlobals.TcGlobals -> + calledArg:CalledArg -> + eCallerMemberName:string option -> + mMethExpr:Range.range -> TypedTree.Expr + val GetDefaultExpressionForOptionalArg: + tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> + g:TcGlobals.TcGlobals -> + calledArg:CalledArg -> + eCallerMemberName:string option -> + mItem:Range.range -> + mMethExpr:Range.range -> + (TypedTree.Expr -> TypedTree.Expr) * + AssignedCalledArg + val MakeNullableExprIfNeeded: + infoReader:InfoReader.InfoReader -> + calledArgTy:TypedTree.TType -> + callerArgTy:TypedTree.TType -> + callerArgExpr:TypedTree.Expr -> m:Range.range -> TypedTree.Expr + val AdjustCallerArgForOptional: + tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> + eCallerMemberName:string option -> + infoReader:InfoReader.InfoReader -> + assignedArg:AssignedCalledArg -> + AssignedCalledArg + val AdjustCallerArgsForOptionals: + tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> + eCallerMemberName:string option -> + infoReader:InfoReader.InfoReader -> + calledMeth:CalledMeth -> + mItem:Range.range -> + mMethExpr:Range.range -> + AssignedCalledArg list * + (TypedTree.Expr -> TypedTree.Expr) * + AssignedCalledArg list * + AssignedCalledArg list + val AdjustOutCallerArgs: + g:TcGlobals.TcGlobals -> + calledMeth:CalledMeth<'a> -> + mMethExpr:Range.range -> + AssignedCalledArg list * TypedTree.Expr list * + TypedTree.Binding list + val AdjustParamArrayCallerArgs: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + calledMeth:CalledMeth -> + mMethExpr:Range.range -> + 'a option list * AssignedCalledArg list + val AdjustCallerArgs: + tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> + eCallerMemberName:string option -> + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + calledMeth:CalledMeth -> + objArgs:TypedTree.Expr list -> + lambdaVars:'a option -> + mItem:Range.range -> + mMethExpr:Range.range -> + (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr list * + 'b option list * AssignedCalledArg list * + TypedTree.Expr list * (TypedTree.Expr -> TypedTree.Expr) * + 'c option list * TypedTree.Expr list * + TypedTree.Binding list + module ProvidedMethodCalls = + val private convertConstExpr: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + constant:Tainted -> + TypedTree.Expr + val eraseSystemType: + amap:Import.ImportMap * m:Range.range * + inputType:Tainted -> + Tainted + val convertProvidedExpressionToExprAndWitness: + tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> + TypedTree.TType list -> Range.range -> + TypedTree.Expr * TypedTree.TType) -> + thisArg:TypedTree.Expr option * allArgs:TypedTree.Exprs * + paramVars:Tainted [] * + g:TcGlobals.TcGlobals * amap:Import.ImportMap * + mut:TypedTreeOps.Mutates * isProp:bool * + isSuperInit:TypedTree.ValUseFlag * m:Range.range * + expr:Tainted -> + Tainted option * + (TypedTree.Expr * TypedTree.TType) + val TranslateInvokerExpressionForProvidedMethodCall: + tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> + TypedTree.TType list -> Range.range -> + TypedTree.Expr * TypedTree.TType) -> + g:TcGlobals.TcGlobals * amap:Import.ImportMap * + mut:TypedTreeOps.Mutates * isProp:bool * + isSuperInit:TypedTree.ValUseFlag * + mi:Tainted * + objArgs:TypedTree.Expr list * allArgs:TypedTree.Exprs * m:Range.range -> + Tainted option * + (TypedTree.Expr * TypedTree.TType) + val BuildInvokerExpressionForProvidedMethodCall: + tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> + TypedTree.TType list -> Range.range -> + TypedTree.Expr * TypedTree.TType) -> + g:TcGlobals.TcGlobals * amap:Import.ImportMap * + mi:Tainted * + objArgs:TypedTree.Expr list * mut:TypedTreeOps.Mutates * isProp:bool * + isSuperInit:TypedTree.ValUseFlag * allArgs:TypedTree.Exprs * + m:Range.range -> + Tainted option * TypedTree.Expr * + TypedTree.TType + + val RecdFieldInstanceChecks: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> rfinfo:Infos.RecdFieldInfo -> unit + val ILFieldStaticChecks: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + infoReader:InfoReader.InfoReader -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> finfo:Infos.ILFieldInfo -> unit + val ILFieldInstanceChecks: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> finfo:Infos.ILFieldInfo -> unit + val MethInfoChecks: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + isInstance:bool -> + tyargsOpt:'a option -> + objArgs:TypedTree.Expr list -> + ad:AccessibilityLogic.AccessorDomain -> + m:Range.range -> minfo:Infos.MethInfo -> unit + exception FieldNotMutable of + TypedTreeOps.DisplayEnv * TypedTree.RecdFieldRef * + Range.range + val CheckRecdFieldMutation: + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> rfinfo:Infos.RecdFieldInfo -> unit + val GenWitnessExpr: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + m:Range.range -> + traitInfo:TypedTree.TraitConstraintInfo -> + argExprs:TypedTree.Expr list -> TypedTree.Expr option + val GenWitnessExprLambda: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + m:Range.range -> + traitInfo:TypedTree.TraitConstraintInfo -> + Choice + val GenWitnessArgs: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + m:Range.range -> + traitInfos:TypedTree.TraitConstraintInfo list -> + Choice list + + +namespace FSharp.Compiler + module internal PatternMatchCompilation = + exception MatchIncomplete of bool * (string * bool) option * Range.range + exception RuleNeverMatched of Range.range + exception EnumMatchIncomplete of bool * (string * bool) option * Range.range + type ActionOnFailure = + | ThrowIncompleteMatchException + | IgnoreWithWarning + | Throw + | Rethrow + | FailFilter + [] + type Pattern = + | TPat_const of TypedTree.Const * Range.range + | TPat_wild of Range.range + | TPat_as of Pattern * PatternValBinding * Range.range + | TPat_disjs of Pattern list * Range.range + | TPat_conjs of Pattern list * Range.range + | TPat_query of + (TypedTree.Expr * TypedTree.TType list * + (TypedTree.ValRef * TypedTree.TypeInst) option * int * + PrettyNaming.ActivePatternInfo) * Pattern * Range.range + | TPat_unioncase of + TypedTree.UnionCaseRef * TypedTree.TypeInst * Pattern list * Range.range + | TPat_exnconstr of TypedTree.TyconRef * Pattern list * Range.range + | TPat_tuple of + TypedTree.TupInfo * Pattern list * TypedTree.TType list * Range.range + | TPat_array of Pattern list * TypedTree.TType * Range.range + | TPat_recd of + TypedTree.TyconRef * TypedTree.TypeInst * Pattern list * Range.range + | TPat_range of char * char * Range.range + | TPat_null of Range.range + | TPat_isinst of + TypedTree.TType * TypedTree.TType * PatternValBinding option * + Range.range + | TPat_error of Range.range + with + member Range: Range.range + + and PatternValBinding = | PBind of TypedTree.Val * TypedTreeOps.TypeScheme + and TypedMatchClause = + | TClause of + Pattern * TypedTree.Expr option * TypedTree.DecisionTreeTarget * + Range.range + with + member BoundVals: TypedTree.Val list + member GuardExpr: TypedTree.Expr option + member Pattern: Pattern + member Range: Range.range + member Target: TypedTree.DecisionTreeTarget + + val debug: bool + type SubExprOfInput = + | SubExpr of + (TypedTreeOps.TyparInst -> TypedTree.Expr -> TypedTree.Expr) * + (TypedTree.Expr * TypedTree.Val) + val BindSubExprOfInput: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + gtps:TypedTree.Typar list -> + PatternValBinding -> + m:Range.range -> SubExprOfInput -> TypedTree.Val * TypedTree.Expr + val GetSubExprOfInput: + g:TcGlobals.TcGlobals -> + gtps:'a list * tyargs:TypedTree.TType list * + tinst:TypedTreeOps.TyparInst -> SubExprOfInput -> TypedTree.Expr + type Path = + | PathQuery of Path * CompilerGlobalState.Unique + | PathConj of Path * int + | PathTuple of Path * TypedTree.TypeInst * int + | PathRecd of Path * TypedTree.TyconRef * TypedTree.TypeInst * int + | PathUnionConstr of + Path * TypedTree.UnionCaseRef * TypedTree.TypeInst * int + | PathArray of Path * TypedTree.TType * int * int + | PathExnConstr of Path * TypedTree.TyconRef * int + | PathEmpty of TypedTree.TType + val pathEq: p1:Path -> p2:Path -> bool + type RefutedSet = + | RefutedInvestigation of Path * TypedTree.DecisionTreeTest list + | RefutedWhenClause + val notNullText: string + val otherSubtypeText: string + val ilFieldToTastConst: AbstractIL.IL.ILFieldInit -> TypedTree.Const + exception CannotRefute + val RefuteDiscrimSet: + g:TcGlobals.TcGlobals -> + m:Range.range -> + path:Path -> + discrims:TypedTree.DecisionTreeTest list -> TypedTree.Expr * bool + val CombineRefutations: + g:TcGlobals.TcGlobals -> + r1:TypedTree.Expr -> r2:TypedTree.Expr -> TypedTree.Expr + val ShowCounterExample: + g:TcGlobals.TcGlobals -> + denv:TypedTreeOps.DisplayEnv -> + m:Range.range -> + refuted:RefutedSet list -> (string * bool * bool) option + type RuleNumber = int + type Active = | Active of Path * SubExprOfInput * Pattern + type Actives = Active list + type Frontier = + | Frontier of RuleNumber * Actives * TypedTreeOps.ValMap + type InvestigationPoint = + | Investigation of RuleNumber * TypedTree.DecisionTreeTest * Path + val isMemOfActives: p1:Path -> actives:Active list -> bool + val lookupActive: x:Path -> l:Active list -> SubExprOfInput * Pattern + val removeActive: x:Path -> l:Active list -> Active list + val getDiscrimOfPattern: + g:TcGlobals.TcGlobals -> + tpinst:TypedTreeOps.TyparInst -> + t:Pattern -> TypedTree.DecisionTreeTest option + val constOfDiscrim: discrim:TypedTree.DecisionTreeTest -> TypedTree.Const + val constOfCase: c:TypedTree.DecisionTreeCase -> TypedTree.Const + val discrimsEq: + g:TcGlobals.TcGlobals -> + d1:TypedTree.DecisionTreeTest -> d2:TypedTree.DecisionTreeTest -> bool + val isDiscrimSubsumedBy: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + d1:TypedTree.DecisionTreeTest -> + d2:TypedTree.DecisionTreeTest -> bool + val chooseSimultaneousEdgeSet: + prevOpt:'a option -> + f:('a option -> 'b -> 'a option) -> l:'b list -> 'a list * 'b list + val canCompactConstantClass: c:TypedTree.Const -> bool + val discrimsHaveSameSimultaneousClass: + g:TcGlobals.TcGlobals -> + d1:TypedTree.DecisionTreeTest -> d2:TypedTree.DecisionTreeTest -> bool + val canInvestigate: pat:Pattern -> bool + val ChooseInvestigationPointLeftToRight: frontiers:Frontier list -> Active + val ( |ConstNeedsDefaultCase|_| ): c:TypedTree.Const -> unit option + val BuildSwitch: + inpExprOpt:'a option -> + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> + edges:TypedTree.DecisionTreeCase list -> + dflt:TypedTree.DecisionTree option -> + m:Range.range -> TypedTree.DecisionTree + val layoutPat: pat:Pattern -> Internal.Utilities.StructuredFormat.Layout + val layoutPath: _p:'a -> Internal.Utilities.StructuredFormat.Layout + val layoutActive: Active -> Internal.Utilities.StructuredFormat.Layout + val layoutFrontier: Frontier -> Internal.Utilities.StructuredFormat.Layout + val mkFrontiers: + investigations:(Actives * TypedTreeOps.ValMap) list -> + i:RuleNumber -> Frontier list + val getRuleIndex: Frontier -> RuleNumber + val isPatternPartial: p:Pattern -> bool + val erasePartialPatterns: inpp:Pattern -> Pattern + val erasePartials: inps:Pattern list -> Pattern list + type EdgeDiscrim = + | EdgeDiscrim of int * TypedTree.DecisionTreeTest * Range.range + val getDiscrim: EdgeDiscrim -> TypedTree.DecisionTreeTest + val CompilePatternBasic: + g:TcGlobals.TcGlobals -> + denv:TypedTreeOps.DisplayEnv -> + amap:Import.ImportMap -> + tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> + TypedTree.TType list -> Range.range -> + TypedTree.Expr * TypedTree.TType) -> + infoReader:InfoReader.InfoReader -> + exprm:Range.range -> + matchm:Range.range -> + warnOnUnused:bool -> + warnOnIncomplete:bool -> + actionOnFailure:ActionOnFailure -> + origInputVal:TypedTree.Val * + origInputValTypars:TypedTree.Typar list * + _origInputExprOpt:TypedTree.Expr option -> + typedClauses:TypedMatchClause list -> + inputTy:TypedTree.TType -> + resultTy:TypedTree.TType -> + TypedTree.DecisionTree * + TypedTree.DecisionTreeTarget list + val isPartialOrWhenClause: c:TypedMatchClause -> bool + val CompilePattern: + TcGlobals.TcGlobals -> + TypedTreeOps.DisplayEnv -> + Import.ImportMap -> + (TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TType list -> + Range.range -> TypedTree.Expr * TypedTree.TType) -> + InfoReader.InfoReader -> + Range.range -> + Range.range -> + bool -> + ActionOnFailure -> + TypedTree.Val * TypedTree.Typar list * + TypedTree.Expr option -> + TypedMatchClause list -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.DecisionTree * + TypedTree.DecisionTreeTarget list + + +namespace FSharp.Compiler + module internal ConstraintSolver = + val compgenId: SyntaxTree.Ident + val NewCompGenTypar: + kind:TypedTree.TyparKind * rigid:TypedTree.TyparRigidity * + staticReq:SyntaxTree.TyparStaticReq * dynamicReq:TypedTree.TyparDynamicReq * + error:bool -> TypedTree.Typar + val AnonTyparId: m:Range.range -> SyntaxTree.Ident + val NewAnonTypar: + TypedTree.TyparKind * Range.range * TypedTree.TyparRigidity * + SyntaxTree.TyparStaticReq * TypedTree.TyparDynamicReq -> TypedTree.Typar + val NewNamedInferenceMeasureVar: + _m:'a * rigid:TypedTree.TyparRigidity * var:SyntaxTree.TyparStaticReq * + id:SyntaxTree.Ident -> TypedTree.Typar + val NewInferenceMeasurePar: unit -> TypedTree.Typar + val NewErrorTypar: unit -> TypedTree.Typar + val NewErrorMeasureVar: unit -> TypedTree.Typar + val NewInferenceType: unit -> TypedTree.TType + val NewErrorType: unit -> TypedTree.TType + val NewErrorMeasure: unit -> TypedTree.Measure + val NewByRefKindInferenceType: + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType + val NewInferenceTypes: 'a list -> TypedTree.TType list + val FreshenAndFixupTypars: + Range.range -> + TypedTree.TyparRigidity -> + TypedTree.Typars -> + TypedTree.TType list -> + TypedTree.Typar list -> + TypedTree.Typar list * TypedTreeOps.TyparInst * TypedTree.TTypes + val FreshenTypeInst: + Range.range -> + TypedTree.Typar list -> + TypedTree.Typar list * TypedTreeOps.TyparInst * TypedTree.TTypes + val FreshMethInst: + m:Range.range -> + fctps:TypedTree.Typars -> + tinst:TypedTree.TType list -> + tpsorig:TypedTree.Typar list -> + TypedTree.Typar list * TypedTreeOps.TyparInst * TypedTree.TTypes + val FreshenTypars: + Range.range -> TypedTree.Typar list -> TypedTree.TType list + val FreshenMethInfo: Range.range -> Infos.MethInfo -> TypedTree.TTypes + [] + type ContextInfo = + | NoContext + | IfExpression of Range.range + | OmittedElseBranch of Range.range + | ElseBranchResult of Range.range + | RecordFields + | TupleInRecordFields + | CollectionElement of bool * Range.range + | ReturnInComputationExpression + | YieldInComputationExpression + | RuntimeTypeTest of bool + | DowncastUsedInsteadOfUpcast of bool + | FollowingPatternMatchClause of Range.range + | PatternMatchGuard of Range.range + | SequenceExpression of TypedTree.TType + type OverloadInformation = + { methodSlot: MethodCalls.CalledMeth + amap: Import.ImportMap + error: exn } + type OverloadResolutionFailure = + | NoOverloadsFound of + methodName: string * candidates: OverloadInformation list * + cx: TypedTree.TraitConstraintInfo option + | PossibleCandidates of + methodName: string * candidates: OverloadInformation list * + cx: TypedTree.TraitConstraintInfo option + exception ConstraintSolverTupleDiffLengths of + displayEnv: + TypedTreeOps.DisplayEnv * + TypedTree.TType list * + TypedTree.TType list * + Range.range * Range.range + exception ConstraintSolverInfiniteTypes of + displayEnv: + TypedTreeOps.DisplayEnv * + contextInfo: ContextInfo * + TypedTree.TType * TypedTree.TType * + Range.range * Range.range + exception ConstraintSolverTypesNotInEqualityRelation of + displayEnv: + TypedTreeOps.DisplayEnv * + TypedTree.TType * + TypedTree.TType * + Range.range * + Range.range * + ContextInfo + exception ConstraintSolverTypesNotInSubsumptionRelation of + displayEnv: + TypedTreeOps.DisplayEnv * + argTy: + TypedTree.TType * + paramTy: + TypedTree.TType * + callRange: + Range.range * + parameterRange: + Range.range + exception ConstraintSolverMissingConstraint of + displayEnv: + TypedTreeOps.DisplayEnv * + TypedTree.Typar * + TypedTree.TyparConstraint * + Range.range * Range.range + exception ConstraintSolverError of string * Range.range * Range.range + exception ConstraintSolverRelatedInformation of + string option * Range.range * + exn + exception ErrorFromApplyingDefault of + tcGlobals: TcGlobals.TcGlobals * + displayEnv: TypedTreeOps.DisplayEnv * + TypedTree.Typar * TypedTree.TType * exn * + Range.range + exception ErrorFromAddingTypeEquation of + tcGlobals: TcGlobals.TcGlobals * + displayEnv: TypedTreeOps.DisplayEnv * + actualTy: TypedTree.TType * + expectedTy: TypedTree.TType * exn * + Range.range + exception ErrorsFromAddingSubsumptionConstraint of + tcGlobals: + TcGlobals.TcGlobals * + displayEnv: + TypedTreeOps.DisplayEnv * + actualTy: TypedTree.TType * + expectedTy: + TypedTree.TType * exn * + ContextInfo * + parameterRange: + Range.range + exception ErrorFromAddingConstraint of + displayEnv: TypedTreeOps.DisplayEnv * + exn * Range.range + exception UnresolvedOverloading of + displayEnv: TypedTreeOps.DisplayEnv * + callerArgs: + MethodCalls.CallerArgs * + failure: OverloadResolutionFailure * + Range.range + exception UnresolvedConversionOperator of + displayEnv: TypedTreeOps.DisplayEnv * + TypedTree.TType * TypedTree.TType * + Range.range + type TcValF = + TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TType list -> + Range.range -> TypedTree.Expr * TypedTree.TType + [] + type ConstraintSolverState = + { g: TcGlobals.TcGlobals + amap: Import.ImportMap + InfoReader: InfoReader.InfoReader + TcVal: TcValF + mutable ExtraCxs: + Internal.Utilities.Collections.HashMultiMap } + with + static member + New: TcGlobals.TcGlobals * Import.ImportMap * InfoReader.InfoReader * + TcValF -> ConstraintSolverState + + type ConstraintSolverEnv = + { SolverState: ConstraintSolverState + eContextInfo: ContextInfo + MatchingOnly: bool + m: Range.range + EquivEnv: TypedTreeOps.TypeEquivEnv + DisplayEnv: TypedTreeOps.DisplayEnv } + with + override ToString: unit -> string + member InfoReader: InfoReader.InfoReader + member amap: Import.ImportMap + member g: TcGlobals.TcGlobals + + val MakeConstraintSolverEnv: + contextInfo:ContextInfo -> + css:ConstraintSolverState -> + m:Range.range -> denv:TypedTreeOps.DisplayEnv -> ConstraintSolverEnv + val occursCheck: + g:TcGlobals.TcGlobals -> un:TypedTree.Typar -> ty:TypedTree.TType -> bool + type PermitWeakResolution = + | Yes + | No + with + member Permit: bool + + val isNativeIntegerTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isSignedIntegerTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isUnsignedIntegerTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsIntegerOrIntegerEnumTy: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isIntegerTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isStringTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isCharTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isBoolTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isFpTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isDecimalTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsNonDecimalNumericOrIntegralEnumType: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsNumericOrIntegralEnumType: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsNonDecimalNumericType: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsNumericType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsRelationalType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsCharOrStringType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsAddSubModType: + nm:string -> g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsBitwiseOpType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsBinaryOpOtherArgType: + g:TcGlobals.TcGlobals -> + permitWeakResolution:PermitWeakResolution -> ty:TypedTree.TType -> bool + val IsSignType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + type TraitConstraintSolution = + | TTraitUnsolved + | TTraitBuiltIn + | TTraitSolved of Infos.MethInfo * TypedTree.TypeInst + | TTraitSolvedRecdProp of Infos.RecdFieldInfo * bool + | TTraitSolvedAnonRecdProp of + TypedTree.AnonRecdTypeInfo * TypedTree.TypeInst * int + val BakedInTraitConstraintNames: Set + [] + type Trace = + { mutable actions: ((unit -> unit) * (unit -> unit)) list } + with + static member New: unit -> Trace + member Push: f:(unit -> unit) -> undo:(unit -> unit) -> unit + member Undo: unit -> unit + + type OptionalTrace = + | NoTrace + | WithTrace of Trace + with + member AddFromReplay: source:Trace -> unit + member + CollectThenUndoOrCommit: predicate:('a -> bool) -> + f:(Trace -> 'a) -> 'a + member Exec: f:(unit -> unit) -> undo:(unit -> unit) -> unit + member HasTrace: bool + + val CollectThenUndo: f:(Trace -> 'a) -> 'a + val FilterEachThenUndo: + f:(Trace -> 'a -> ErrorLogger.OperationResult<'b>) -> + meths:'a list -> ('a * exn list * Trace) list + val ShowAccessDomain: ad:AccessibilityLogic.AccessorDomain -> string + exception NonRigidTypar of + displayEnv: TypedTreeOps.DisplayEnv * + string option * Range.range * TypedTree.TType * + TypedTree.TType * Range.range + exception AbortForFailedOverloadResolution + val inline TryD_IgnoreAbortForFailedOverloadResolution: + f1:(unit -> ErrorLogger.OperationResult) -> + f2:(exn -> ErrorLogger.OperationResult) -> + ErrorLogger.OperationResult + exception ArgDoesNotMatchError of + error: + ErrorsFromAddingSubsumptionConstraint * + calledMeth: + MethodCalls.CalledMeth * + calledArg: MethodCalls.CalledArg * + callerArg: + MethodCalls.CallerArg + exception LocallyAbortOperationThatLosesAbbrevs + val localAbortD: ErrorLogger.OperationResult + val PreferUnifyTypar: v1:TypedTree.Typar -> v2:TypedTree.Typar -> bool + val FindPreferredTypar: + vs:(TypedTree.Typar * 'a) list -> (TypedTree.Typar * 'a) list + val SubstMeasure: r:TypedTree.Typar -> ms:TypedTree.Measure -> unit + val TransactStaticReq: + csenv:ConstraintSolverEnv -> + trace:OptionalTrace -> + tpr:TypedTree.Typar -> + req:SyntaxTree.TyparStaticReq -> ErrorLogger.OperationResult + val SolveTypStaticReqTypar: + csenv:ConstraintSolverEnv -> + trace:OptionalTrace -> + req:SyntaxTree.TyparStaticReq -> + tpr:TypedTree.Typar -> ErrorLogger.OperationResult + val SolveTypStaticReq: + csenv:ConstraintSolverEnv -> + trace:OptionalTrace -> + req:SyntaxTree.TyparStaticReq -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val TransactDynamicReq: + trace:OptionalTrace -> + tpr:TypedTree.Typar -> + req:TypedTree.TyparDynamicReq -> ErrorLogger.OperationResult + val SolveTypDynamicReq: + csenv:ConstraintSolverEnv -> + trace:OptionalTrace -> + req:TypedTree.TyparDynamicReq -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val TransactIsCompatFlex: + trace:OptionalTrace -> + tpr:TypedTree.Typar -> req:bool -> ErrorLogger.OperationResult + val SolveTypIsCompatFlex: + csenv:ConstraintSolverEnv -> + trace:OptionalTrace -> + req:bool -> ty:TypedTree.TType -> ErrorLogger.OperationResult + val SubstMeasureWarnIfRigid: + csenv:ConstraintSolverEnv -> + trace:OptionalTrace -> + v:TypedTree.Typar -> + ms:TypedTree.Measure -> ErrorLogger.OperationResult + val UnifyMeasureWithOne: + csenv:ConstraintSolverEnv -> + trace:OptionalTrace -> + ms:TypedTree.Measure -> ErrorLogger.OperationResult + val UnifyMeasures: + csenv:ConstraintSolverEnv -> + trace:OptionalTrace -> + ms1:TypedTree.Measure -> + ms2:TypedTree.Measure -> ErrorLogger.OperationResult + val SimplifyMeasure: + g:TcGlobals.TcGlobals -> + vars:TypedTree.Typar list -> + ms:TypedTree.Measure -> TypedTree.Typar list * TypedTree.Typar option + val SimplifyMeasuresInType: + g:TcGlobals.TcGlobals -> + resultFirst:bool -> + TypedTree.Typar list * TypedTree.Typar list -> + ty:TypedTree.TType -> TypedTree.Typar list * TypedTree.Typar list + val SimplifyMeasuresInTypes: + g:TcGlobals.TcGlobals -> + TypedTree.Typar list * TypedTree.Typar list -> + tys:TypedTree.TypeInst -> TypedTree.Typar list * TypedTree.Typar list + val SimplifyMeasuresInConstraint: + g:TcGlobals.TcGlobals -> + TypedTree.Typar list * TypedTree.Typar list -> + c:TypedTree.TyparConstraint -> + TypedTree.Typar list * TypedTree.Typar list + val SimplifyMeasuresInConstraints: + g:TcGlobals.TcGlobals -> + TypedTree.Typar list * TypedTree.Typar list -> + cs:TypedTree.TyparConstraint list -> + TypedTree.Typar list * TypedTree.Typar list + val GetMeasureVarGcdInType: + v:TypedTree.Typar -> ty:TypedTree.TType -> Rational.Rational + val GetMeasureVarGcdInTypes: + v:TypedTree.Typar -> tys:TypedTree.TypeInst -> Rational.Rational + val NormalizeExponentsInTypeScheme: + uvars:TypedTree.Typar list -> ty:TypedTree.TType -> TypedTree.Typar list + val SimplifyMeasuresInTypeScheme: + TcGlobals.TcGlobals -> + bool -> + TypedTree.Typar list -> + TypedTree.TType -> + TypedTree.TyparConstraint list -> TypedTree.Typar list + val freshMeasure: unit -> TypedTree.Measure + val CheckWarnIfRigid: + csenv:ConstraintSolverEnv -> + ty1:TypedTree.TType -> + r:TypedTree.Typar -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTyparEqualsTypePart1: + csenv:ConstraintSolverEnv -> + m2:Range.range -> + trace:OptionalTrace -> + ty1:TypedTree.TType -> + r:TypedTree.Typar -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTyparEqualsTypePart2: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + r:TypedTree.Typar -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val solveTypMeetsTyparConstraints: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty:TypedTree.TType -> + r:TypedTree.Typar -> ErrorLogger.OperationResult + val SolveTyparEqualsType: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty1:TypedTree.TType -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTyparsEqualTypes: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + tptys:TypedTree.TType list -> + tys:TypedTree.TType list -> ErrorLogger.OperationResult + val SolveAnonInfoEqualsAnonInfo: + csenv:ConstraintSolverEnv -> + m2:Range.range -> + anonInfo1:TypedTree.AnonRecdTypeInfo -> + anonInfo2:TypedTree.AnonRecdTypeInfo -> + ErrorLogger.OperationResult + val SolveTypeEqualsType: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * + TypedTree.TraitConstraintSln) option -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeEqualsTypeKeepAbbrevs: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> ErrorLogger.OperationResult + val private SolveTypeEqualsTypeKeepAbbrevsWithCxsln: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * + TypedTree.TraitConstraintSln) option -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeEqualsTypeEqns: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * + TypedTree.TraitConstraintSln) option -> + origl1:TypedTree.TypeInst -> + origl2:TypedTree.TypeInst -> ErrorLogger.OperationResult + val SolveFunTypeEqn: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * + TypedTree.TraitConstraintSln) option -> + d1:TypedTree.TType -> + d2:TypedTree.TType -> + r1:TypedTree.TType -> + r2:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeSubsumesType: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * + TypedTree.TraitConstraintSln) option -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeSubsumesTypeKeepAbbrevs: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * + TypedTree.TraitConstraintSln) option -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTyparSubtypeOfType: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + tp:TypedTree.Typar -> + ty1:TypedTree.TType -> ErrorLogger.OperationResult + val DepthCheck: + ndeep:int -> m:Range.range -> ErrorLogger.OperationResult + val SolveDimensionlessNumericType: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val SolveMemberConstraint: + csenv:ConstraintSolverEnv -> + ignoreUnresolvedOverload:bool -> + permitWeakResolution:PermitWeakResolution -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + traitInfo:TypedTree.TraitConstraintInfo -> + ErrorLogger.OperationResult + val RecordMemberConstraintSolution: + css:ConstraintSolverState -> + m:Range.range -> + trace:OptionalTrace -> + traitInfo:TypedTree.TraitConstraintInfo -> + res:TraitConstraintSolution -> ErrorLogger.OperationResult + val MemberConstraintSolutionOfMethInfo: + css:ConstraintSolverState -> + m:Range.range -> + minfo:Infos.MethInfo -> + minst:TypedTree.TypeInst -> TypedTree.TraitConstraintSln + val TransactMemberConstraintSolution: + traitInfo:TypedTree.TraitConstraintInfo -> + trace:OptionalTrace -> sln:TypedTree.TraitConstraintSln -> unit + val GetRelevantMethodsForTrait: + csenv:ConstraintSolverEnv -> + permitWeakResolution:PermitWeakResolution -> + nm:string -> TypedTree.TraitConstraintInfo -> Infos.MethInfo list + val GetSupportOfMemberConstraint: + csenv:ConstraintSolverEnv -> + TypedTree.TraitConstraintInfo -> TypedTree.Typar list + val SupportOfMemberConstraintIsFullySolved: + csenv:ConstraintSolverEnv -> TypedTree.TraitConstraintInfo -> bool + val GetFreeTyparsOfMemberConstraint: + csenv:ConstraintSolverEnv -> + TypedTree.TraitConstraintInfo -> TypedTree.Typar list + val MemberConstraintIsReadyForWeakResolution: + csenv:ConstraintSolverEnv -> + traitInfo:TypedTree.TraitConstraintInfo -> bool + val MemberConstraintIsReadyForStrongResolution: + csenv:ConstraintSolverEnv -> + traitInfo:TypedTree.TraitConstraintInfo -> bool + val MemberConstraintSupportIsReadyForDeterminingOverloads: + csenv:ConstraintSolverEnv -> + traitInfo:TypedTree.TraitConstraintInfo -> bool + val SolveRelevantMemberConstraints: + csenv:ConstraintSolverEnv -> + ndeep:int -> + permitWeakResolution:PermitWeakResolution -> + trace:OptionalTrace -> + tps:TypedTree.Typar list -> ErrorLogger.OperationResult + val SolveRelevantMemberConstraintsForTypar: + csenv:ConstraintSolverEnv -> + ndeep:int -> + permitWeakResolution:PermitWeakResolution -> + trace:OptionalTrace -> + tp:TypedTree.Typar -> ErrorLogger.OperationResult + val CanonicalizeRelevantMemberConstraints: + csenv:ConstraintSolverEnv -> + ndeep:int -> + trace:OptionalTrace -> + tps:TypedTree.Typar list -> ErrorLogger.OperationResult + val AddMemberConstraint: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + traitInfo:TypedTree.TraitConstraintInfo -> + support:TypedTree.Typar list -> + frees:TypedTree.Typar list -> + ErrorLogger.OperationResult + val AddConstraint: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + tp:TypedTree.Typar -> + newConstraint:TypedTree.TyparConstraint -> + ErrorLogger.OperationResult + val SolveTypeSupportsNull: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeSupportsComparison: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeSupportsEquality: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeIsEnum: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty:TypedTree.TType -> + underlying:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeIsDelegate: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty:TypedTree.TType -> + aty:TypedTree.TType -> + bty:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeIsNonNullableValueType: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeIsUnmanaged: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeChoice: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty:TypedTree.TType -> + tys:TypedTree.TTypes -> ErrorLogger.OperationResult + val SolveTypeIsReferenceType: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + ty:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeRequiresDefaultConstructor: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + origTy:TypedTree.TType -> ErrorLogger.OperationResult + val SolveTypeRequiresDefaultValue: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m2:Range.range -> + trace:OptionalTrace -> + origTy:TypedTree.TType -> ErrorLogger.OperationResult + val CanMemberSigsMatchUpToCheck: + csenv:ConstraintSolverEnv -> + permitOptArgs:bool -> + alwaysCheckReturn:bool -> + unifyTypes:(TypedTree.TType -> TypedTree.TType -> + ErrorLogger.OperationResult) -> + subsumeTypes:(TypedTree.TType -> TypedTree.TType -> + ErrorLogger.OperationResult) -> + subsumeArg:(MethodCalls.CalledArg -> + MethodCalls.CallerArg<'a> -> + ErrorLogger.OperationResult) -> + reqdRetTyOpt:TypedTree.TType option -> + calledMeth:MethodCalls.CalledMeth<'a> -> + ErrorLogger.ImperativeOperationResult + val private SolveTypeSubsumesTypeWithWrappedContextualReport: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m:Range.range -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * + TypedTree.TraitConstraintSln) option -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> + wrapper:(exn -> #exn) -> ErrorLogger.OperationResult + val private SolveTypeSubsumesTypeWithReport: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m:Range.range -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * + TypedTree.TraitConstraintSln) option -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> ErrorLogger.OperationResult + val private SolveTypeEqualsTypeWithReport: + csenv:ConstraintSolverEnv -> + ndeep:int -> + m:Range.range -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * + TypedTree.TraitConstraintSln) option -> + actual:TypedTree.TType -> + expected:TypedTree.TType -> ErrorLogger.OperationResult + val ArgsMustSubsumeOrConvert: + csenv:ConstraintSolverEnv -> + ndeep:int -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> + isConstraint:bool -> + enforceNullableOptionalsKnownTypes:bool -> + calledArg:MethodCalls.CalledArg -> + callerArg:MethodCalls.CallerArg<'T> -> + ErrorLogger.OperationResult + val MustUnify: + csenv:ConstraintSolverEnv -> + ndeep:int -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> ErrorLogger.OperationResult + val MustUnifyInsideUndo: + csenv:ConstraintSolverEnv -> + ndeep:int -> + trace:Trace -> + cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> ErrorLogger.OperationResult + val ArgsMustSubsumeOrConvertInsideUndo: + csenv:ConstraintSolverEnv -> + ndeep:int -> + trace:Trace -> + cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> + isConstraint:bool -> + calledMeth:MethodCalls.CalledMeth -> + calledArg:MethodCalls.CalledArg -> + MethodCalls.CallerArg -> + ErrorLogger.OperationResult + val TypesMustSubsumeOrConvertInsideUndo: + csenv:ConstraintSolverEnv -> + ndeep:int -> + trace:OptionalTrace -> + cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> + m:Range.range -> + calledArgTy:TypedTree.TType -> + callerArgTy:TypedTree.TType -> + ErrorLogger.OperationResult + val ArgsEquivInsideUndo: + csenv:ConstraintSolverEnv -> + isConstraint:bool -> + calledArg:MethodCalls.CalledArg -> + MethodCalls.CallerArg<'c> -> ErrorLogger.OperationResult + val ReportNoCandidatesError: + csenv:ConstraintSolverEnv -> + nUnnamedCallerArgs:System.Int32 * nNamedCallerArgs:int -> + methodName:System.String -> + ad:AccessibilityLogic.AccessorDomain -> + calledMethGroup:MethodCalls.CalledMeth<'d> list -> + isSequential:('d -> bool) -> ErrorLogger.OperationResult<'e> + val ReportNoCandidatesErrorExpr: + csenv:ConstraintSolverEnv -> + System.Int32 * int -> + methodName:System.String -> + ad:AccessibilityLogic.AccessorDomain -> + calledMethGroup:MethodCalls.CalledMeth list -> + ErrorLogger.OperationResult<'f> + val ReportNoCandidatesErrorSynExpr: + csenv:ConstraintSolverEnv -> + System.Int32 * int -> + methodName:System.String -> + ad:AccessibilityLogic.AccessorDomain -> + calledMethGroup:MethodCalls.CalledMeth list -> + ErrorLogger.OperationResult<'g> + val ResolveOverloading: + csenv:ConstraintSolverEnv -> + trace:OptionalTrace -> + methodName:string -> + ndeep:int -> + cx:TypedTree.TraitConstraintInfo option -> + callerArgs:MethodCalls.CallerArgs -> + ad:AccessibilityLogic.AccessorDomain -> + calledMethGroup:MethodCalls.CalledMeth list -> + permitOptArgs:bool -> + reqdRetTyOpt:TypedTree.TType option -> + MethodCalls.CalledMeth option * + ErrorLogger.OperationResult + val ResolveOverloadingForCall: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> + methodName:string -> + ndeep:int -> + cx:TypedTree.TraitConstraintInfo option -> + callerArgs:MethodCalls.CallerArgs -> + AccessibilityLogic.AccessorDomain -> + calledMethGroup:MethodCalls.CalledMeth list -> + permitOptArgs:bool -> + reqdRetTyOpt:TypedTree.TType option -> + MethodCalls.CalledMeth option * + ErrorLogger.OperationResult + val UnifyUniqueOverloading: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> + System.Int32 * int -> + System.String -> + AccessibilityLogic.AccessorDomain -> + MethodCalls.CalledMeth list -> + TypedTree.TType -> ErrorLogger.OperationResult + val EliminateConstraintsForGeneralizedTypars: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> OptionalTrace -> TypedTree.Typars -> unit + val AddCxTypeEqualsType: + ContextInfo -> + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> TypedTree.TType -> TypedTree.TType -> unit + val UndoIfFailed: f:(Trace -> ErrorLogger.OperationResult<'a>) -> bool + val UndoIfFailedOrWarnings: + f:(Trace -> ErrorLogger.OperationResult<'a>) -> bool + val AddCxTypeEqualsTypeUndoIfFailed: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> TypedTree.TType -> TypedTree.TType -> bool + val AddCxTypeEqualsTypeUndoIfFailedOrWarnings: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> TypedTree.TType -> TypedTree.TType -> bool + val AddCxTypeEqualsTypeMatchingOnlyUndoIfFailed: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> TypedTree.TType -> TypedTree.TType -> bool + val AddCxTypeMustSubsumeTypeUndoIfFailed: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> TypedTree.TType -> TypedTree.TType -> bool + val AddCxTypeMustSubsumeTypeMatchingOnlyUndoIfFailed: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> TypedTree.TType -> TypedTree.TType -> bool + val AddCxTypeMustSubsumeType: + ContextInfo -> + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> + OptionalTrace -> TypedTree.TType -> TypedTree.TType -> unit + val AddCxMethodConstraint: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> OptionalTrace -> TypedTree.TraitConstraintInfo -> unit + val AddCxTypeMustSupportNull: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> OptionalTrace -> TypedTree.TType -> unit + val AddCxTypeMustSupportComparison: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> OptionalTrace -> TypedTree.TType -> unit + val AddCxTypeMustSupportEquality: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> OptionalTrace -> TypedTree.TType -> unit + val AddCxTypeMustSupportDefaultCtor: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> OptionalTrace -> TypedTree.TType -> unit + val AddCxTypeIsReferenceType: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> OptionalTrace -> TypedTree.TType -> unit + val AddCxTypeIsValueType: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> OptionalTrace -> TypedTree.TType -> unit + val AddCxTypeIsUnmanaged: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> OptionalTrace -> TypedTree.TType -> unit + val AddCxTypeIsEnum: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> + OptionalTrace -> TypedTree.TType -> TypedTree.TType -> unit + val AddCxTypeIsDelegate: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> + OptionalTrace -> + TypedTree.TType -> TypedTree.TType -> TypedTree.TType -> unit + val AddCxTyparDefaultsTo: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> + ContextInfo -> TypedTree.Typar -> int -> TypedTree.TType -> unit + val SolveTypeAsError: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> Range.range -> TypedTree.TType -> unit + val ApplyTyparDefaultAtPriority: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> priority:int -> TypedTree.Typar -> unit + val CreateCodegenState: + tcVal:TcValF -> + g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> ConstraintSolverState + val CodegenWitnessExprForTraitConstraint: + TcValF -> + TcGlobals.TcGlobals -> + Import.ImportMap -> + Range.range -> + TypedTree.TraitConstraintInfo -> + TypedTree.Expr list -> + ErrorLogger.OperationResult + val CodegenWitnessesForTyparInst: + TcValF -> + TcGlobals.TcGlobals -> + Import.ImportMap -> + Range.range -> + TypedTree.Typar list -> + TypedTree.TType list -> + ErrorLogger.OperationResult list> + val CodegenWitnessArgForTraitConstraint: + TcValF -> + TcGlobals.TcGlobals -> + Import.ImportMap -> + Range.range -> + TypedTree.TraitConstraintInfo -> + ErrorLogger.OperationResult> + val ChooseTyparSolutionAndSolve: + ConstraintSolverState -> + TypedTreeOps.DisplayEnv -> TypedTree.Typar -> unit + val CheckDeclaredTypars: + TypedTreeOps.DisplayEnv -> + ConstraintSolverState -> + Range.range -> TypedTree.Typar list -> TypedTree.Typar list -> unit + val CanonicalizePartialInferenceProblem: + ConstraintSolverState -> + TypedTreeOps.DisplayEnv -> Range.range -> TypedTree.Typar list -> unit + val IsApplicableMethApprox: + TcGlobals.TcGlobals -> + Import.ImportMap -> + Range.range -> Infos.MethInfo -> TypedTree.TType -> bool + + +namespace FSharp.Compiler + module internal CheckFormatStrings = + type FormatItem = + | Simple of TypedTree.TType + | FuncAndVal + val copyAndFixupFormatTypar: + m:Range.range -> tp:TypedTree.Typar -> TypedTree.TType + val lowestDefaultPriority: int + val mkFlexibleFormatTypar: + m:Range.range -> + tys:TypedTree.TTypes -> dflt:TypedTree.TType -> TypedTree.TType + val mkFlexibleIntFormatTypar: + g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.TType + val mkFlexibleDecimalFormatTypar: + g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.TType + val mkFlexibleFloatFormatTypar: + g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.TType + type FormatInfoRegister = + { mutable leftJustify: bool + mutable numPrefixIfPos: char option + mutable addZeros: bool + mutable precision: bool } + val newInfo: unit -> FormatInfoRegister + val parseFormatStringInternal: + m:Range.range -> + fragRanges:Range.range list -> + g:TcGlobals.TcGlobals -> + isInterpolated:bool -> + isFormattableString:bool -> + context:NameResolution.FormatStringCheckContext option -> + fmt:string -> + printerArgTy:TypedTree.TType -> + printerResidueTy:TypedTree.TType -> + TypedTree.TType list * (Range.range * int) list * string * + TypedTree.TType [] + val ParseFormatString: + m:Range.range -> + fragmentRanges:Range.range list -> + g:TcGlobals.TcGlobals -> + isInterpolated:bool -> + isFormattableString:bool -> + formatStringCheckContext:NameResolution.FormatStringCheckContext option -> + fmt:string -> + printerArgTy:TypedTree.TType -> + printerResidueTy:TypedTree.TType -> + printerResultTy:TypedTree.TType -> + TypedTree.TType list * TypedTree.TType * + TypedTree.TType * TypedTree.TType [] * + (Range.range * int) list * string + val TryCountFormatStringArguments: + m:Range.range -> + g:TcGlobals.TcGlobals -> + isInterpolated:bool -> + fmt:string -> + printerArgTy:TypedTree.TType -> + printerResidueTy:TypedTree.TType -> int option + + +namespace FSharp.Compiler + module internal FindUnsolved = + type env = | Nix + type cenv = + { g: TcGlobals.TcGlobals + amap: Import.ImportMap + denv: TypedTreeOps.DisplayEnv + mutable unsolved: TypedTree.Typars } + with + override ToString: unit -> string + + val accTy: cenv:cenv -> _env:'a -> ty:TypedTree.TType -> unit + val accTypeInst: cenv:cenv -> env:'a -> tyargs:TypedTree.TType list -> unit + val accExpr: cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit + val accMethods: + cenv:cenv -> + env:env -> + baseValOpt:TypedTree.Val option -> + l:TypedTree.ObjExprMethod list -> unit + val accMethod: + cenv:cenv -> + env:env -> + _baseValOpt:TypedTree.Val option -> TypedTree.ObjExprMethod -> unit + val accIntfImpls: + cenv:cenv -> + env:env -> + baseValOpt:TypedTree.Val option -> + l:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> unit + val accIntfImpl: + cenv:cenv -> + env:env -> + baseValOpt:TypedTree.Val option -> + ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> unit + val accOp: + cenv:cenv -> + env:env -> + op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * + _m:Range.range -> unit + val accTraitInfo: + cenv:cenv -> env:env -> TypedTree.TraitConstraintInfo -> unit + val accLambdas: + cenv:cenv -> + env:env -> + topValInfo:TypedTree.ValReprInfo -> + e:TypedTree.Expr -> ety:TypedTree.TType -> unit + val accExprs: cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> unit + val accTargets: + cenv:cenv -> + env:env -> + m:Range.range -> + ty:TypedTree.TType -> + targets:TypedTree.DecisionTreeTarget array -> unit + val accTarget: + cenv:cenv -> + env:env -> + _m:Range.range -> + _ty:TypedTree.TType -> TypedTree.DecisionTreeTarget -> unit + val accDTree: cenv:cenv -> env:env -> x:TypedTree.DecisionTree -> unit + val accSwitch: + cenv:cenv -> + env:env -> + e:TypedTree.Expr * cases:TypedTree.DecisionTreeCase list * + dflt:TypedTree.DecisionTree option * _m:Range.range -> unit + val accDiscrim: + cenv:cenv -> env:env -> d:TypedTree.DecisionTreeTest -> unit + val accAttrib: cenv:cenv -> env:env -> TypedTree.Attrib -> unit + val accAttribs: + cenv:cenv -> env:env -> attribs:TypedTree.Attrib list -> unit + val accValReprInfo: cenv:cenv -> env:env -> TypedTree.ValReprInfo -> unit + val accArgReprInfo: + cenv:cenv -> env:env -> argInfo:TypedTree.ArgReprInfo -> unit + val accVal: cenv:cenv -> env:env -> v:TypedTree.Val -> unit + val accBind: cenv:cenv -> env:env -> bind:TypedTree.Binding -> unit + val accBinds: cenv:cenv -> env:env -> xs:TypedTree.Bindings -> unit + val accTyconRecdField: + cenv:cenv -> env:env -> _tycon:'a -> rfield:TypedTree.RecdField -> unit + val accTycon: cenv:cenv -> env:env -> tycon:TypedTree.Tycon -> unit + val accTycons: cenv:cenv -> env:env -> tycons:TypedTree.Tycon list -> unit + val accModuleOrNamespaceExpr: + cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExprWithSig -> unit + val accModuleOrNamespaceDefs: + cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr list -> unit + val accModuleOrNamespaceDef: + cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr -> unit + val accModuleOrNamespaceBinds: + cenv:cenv -> env:env -> xs:TypedTree.ModuleOrNamespaceBinding list -> unit + val accModuleOrNamespaceBind: + cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceBinding -> unit + val UnsolvedTyparsOfModuleDef: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + denv:TypedTreeOps.DisplayEnv -> + mdef:TypedTree.ModuleOrNamespaceExpr * + extraAttribs:TypedTree.Attrib list -> TypedTree.Typar list + + +namespace FSharp.Compiler + module internal QuotationTranslator = + val verboseCReflect: bool + [] + type IsReflectedDefinition = + | Yes + | No + [] + type QuotationSerializationFormat = + { SupportsWitnesses: bool + SupportsDeserializeEx: bool } + [] + type QuotationGenerationScope = + { g: TcGlobals.TcGlobals + amap: Import.ImportMap + scope: TypedTree.CcuThunk + tcVal: ConstraintSolver.TcValF + referencedTypeDefs: ResizeArray + referencedTypeDefsTable: + System.Collections.Generic.Dictionary + typeSplices: ResizeArray + exprSplices: ResizeArray + isReflectedDefinition: IsReflectedDefinition + quotationFormat: QuotationSerializationFormat + mutable emitDebugInfoInQuotations: bool } + with + static member + ComputeQuotationFormat: TcGlobals.TcGlobals -> + QuotationSerializationFormat + static member + Create: TcGlobals.TcGlobals * Import.ImportMap * TypedTree.CcuThunk * + ConstraintSolver.TcValF * IsReflectedDefinition -> + QuotationGenerationScope + member + Close: unit -> + AbstractIL.IL.ILTypeRef list * + (TypedTree.TType * Range.range) list * + (TypedTree.Expr * Range.range) list + + type QuotationTranslationEnv = + { vs: TypedTreeOps.ValMap + numValsInScope: int + tyvs: TypedTree.StampMap + suppressWitnesses: bool + witnessesInScope: TypedTreeOps.TraitWitnessInfoHashMap + isinstVals: TypedTreeOps.ValMap + substVals: TypedTreeOps.ValMap } + with + static member + CreateEmpty: g:TcGlobals.TcGlobals -> QuotationTranslationEnv + member BindTypar: v:TypedTree.Typar -> QuotationTranslationEnv + member BindTypars: vs:TypedTree.Typar list -> QuotationTranslationEnv + member + BindWitnessInfo: witnessInfo:TypedTree.TraitWitnessInfo -> + QuotationTranslationEnv + member + BindWitnessInfos: witnessInfos:TypedTree.TraitWitnessInfo list -> + QuotationTranslationEnv + + val BindFormalTypars: + env:QuotationTranslationEnv -> + vs:TypedTree.Typar list -> QuotationTranslationEnv + val BindVal: + env:QuotationTranslationEnv -> v:TypedTree.Val -> QuotationTranslationEnv + val BindIsInstVal: + env:QuotationTranslationEnv -> + v:TypedTree.Val -> + ty:TypedTree.TType * e:TypedTree.Expr -> QuotationTranslationEnv + val BindSubstVal: + env:QuotationTranslationEnv -> + v:TypedTree.Val -> e:TypedTree.Expr -> QuotationTranslationEnv + val BindVals: + env:QuotationTranslationEnv -> + vs:TypedTree.Val list -> QuotationTranslationEnv + val BindFlatVals: + env:QuotationTranslationEnv -> + vs:TypedTree.Val list -> QuotationTranslationEnv + exception InvalidQuotedTerm of exn + exception IgnoringPartOfQuotedTermWarning of string * Range.range + val wfail: e:exn -> 'a + val ( |ModuleValueOrMemberUse|_| ): + TcGlobals.TcGlobals -> + TypedTree.Expr -> + (TypedTree.ValRef * TypedTree.ValUseFlag * TypedTree.Expr * + TypedTree.TType * TypedTree.TypeInst * TypedTree.Expr list) option + val ( |SimpleArrayLoopUpperBound|_| ): TypedTree.Expr -> unit option + val ( |SimpleArrayLoopBody|_| ): + TcGlobals.TcGlobals -> + TypedTree.Expr -> + (TypedTree.Expr * TypedTree.TType * TypedTree.Expr) option + val ( |ObjectInitializationCheck|_| ): + TcGlobals.TcGlobals -> TypedTree.Expr -> unit option + val isSplice: TcGlobals.TcGlobals -> TypedTree.ValRef -> bool + val EmitDebugInfoIfNecessary: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + astExpr:QuotationPickler.ExprData -> QuotationPickler.ExprData + val ConvExpr: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + expr:TypedTree.Expr -> QuotationPickler.ExprData + val GetWitnessArgs: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + tps:TypedTree.Typars -> + tyargs:TypedTree.TType list -> QuotationPickler.ExprData list + val ConvWitnessInfo: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + traitInfo:TypedTree.TraitConstraintInfo -> QuotationPickler.ExprData + val private ConvExprCore: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + expr:TypedTree.Expr -> QuotationPickler.ExprData + val ConvLdfld: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + fspec:AbstractIL.IL.ILFieldSpec -> + enclTypeArgs:TypedTree.TypeInst -> + args:TypedTree.Exprs -> QuotationPickler.ExprData + val ConvUnionFieldGet: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + ucref:TypedTree.UnionCaseRef -> + n:int -> + tyargs:TypedTree.TypeInst -> + e:TypedTree.Expr -> QuotationPickler.ExprData + val ConvClassOrRecdFieldGet: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + rfref:TypedTree.RecdFieldRef -> + tyargs:TypedTree.TypeInst -> + args:TypedTree.Exprs -> QuotationPickler.ExprData + val private ConvClassOrRecdFieldGetCore: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + rfref:TypedTree.RecdFieldRef -> + tyargs:TypedTree.TypeInst -> + args:TypedTree.Exprs -> QuotationPickler.ExprData + val ConvLetBind: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + bind:TypedTree.Binding -> + (QuotationPickler.VarData * QuotationPickler.ExprData) option * + QuotationTranslationEnv + val ConvLValueArgs: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + args:TypedTree.Exprs -> QuotationPickler.ExprData list + val ConvLValueExpr: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + expr:TypedTree.Expr -> QuotationPickler.ExprData + val ConvLValueExprCore: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + expr:TypedTree.Expr -> QuotationPickler.ExprData + val ConvObjectModelCall: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + bool * bool * bool * QuotationPickler.NamedTypeData * + QuotationPickler.TypeData list * QuotationPickler.TypeData list * + QuotationPickler.TypeData * string * TypedTree.TypeInst * int * + TypedTree.Expr list * QuotationPickler.ExprData list * + TypedTree.Expr list list -> QuotationPickler.ExprData + val ConvObjectModelCallCore: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + isPropGet:bool * isPropSet:bool * isNewObj:bool * + parentTyconR:QuotationPickler.NamedTypeData * + witnessArgTypesR:QuotationPickler.TypeData list * + methArgTypesR:QuotationPickler.TypeData list * + methRetTypeR:QuotationPickler.TypeData * methName:string * + tyargs:TypedTree.TypeInst * numGenericArgs:int * + objArgs:TypedTree.Expr list * + witnessArgsR:QuotationPickler.ExprData list * + untupledCurriedArgs:TypedTree.Expr list list -> + QuotationPickler.ExprData + val ConvModuleValueApp: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + vref:TypedTree.ValRef -> + tyargs:TypedTree.TypeInst -> + witnessArgs:QuotationPickler.ExprData list -> + args:TypedTree.Expr list list -> QuotationPickler.ExprData + val ConvModuleValueAppCore: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + vref:TypedTree.ValRef -> + tyargs:TypedTree.TypeInst -> + witnessArgsR:QuotationPickler.ExprData list -> + curriedArgs:TypedTree.Expr list list -> + QuotationPickler.ExprData + val ConvExprs: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + args:TypedTree.Exprs -> QuotationPickler.ExprData list + val ConvValRef: + holeOk:bool -> + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + vref:TypedTree.ValRef -> + tyargs:TypedTree.TypeInst -> QuotationPickler.ExprData + val private ConvValRefCore: + holeOk:bool -> + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + vref:TypedTree.ValRef -> + tyargs:TypedTree.TypeInst -> QuotationPickler.ExprData + val ConvUnionCaseRef: + cenv:QuotationGenerationScope -> + ucref:TypedTree.UnionCaseRef -> + m:Range.range -> QuotationPickler.NamedTypeData * string + val ConvRecdFieldRef: + cenv:QuotationGenerationScope -> + rfref:TypedTree.RecdFieldRef -> + m:Range.range -> QuotationPickler.NamedTypeData * string + val ConvVal: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + v:TypedTree.Val -> QuotationPickler.VarData + val ConvTyparRef: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> tp:TypedTree.Typar -> int + val FilterMeasureTyargs: tys:TypedTree.TType list -> TypedTree.TType list + val ConvType: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> ty:TypedTree.TType -> QuotationPickler.TypeData + val ConvTypes: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + tys:TypedTree.TType list -> QuotationPickler.TypeData list + val ConvConst: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> + c:TypedTree.Const -> ty:TypedTree.TType -> QuotationPickler.ExprData + val ConvDecisionTree: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + tgs:TypedTree.DecisionTreeTarget array -> + typR:QuotationPickler.TypeData -> + x:TypedTree.DecisionTree -> QuotationPickler.ExprData + val IsILTypeRefStaticLinkLocal: + cenv:QuotationGenerationScope -> + m:Range.range -> tr:AbstractIL.IL.ILTypeRef -> bool + val ConvILTypeRefUnadjusted: + cenv:QuotationGenerationScope -> + m:Range.range -> + tr:AbstractIL.IL.ILTypeRef -> QuotationPickler.NamedTypeData + val ConvILTypeRef: + cenv:QuotationGenerationScope -> + tr:AbstractIL.IL.ILTypeRef -> QuotationPickler.NamedTypeData + val ConvVoidType: + cenv:QuotationGenerationScope -> + m:Range.range -> QuotationPickler.TypeData + val ConvILType: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + m:Range.range -> ty:AbstractIL.IL.ILType -> QuotationPickler.TypeData + val TryElimErasableTyconRef: + cenv:QuotationGenerationScope -> + m:Range.range -> tcref:TypedTree.TyconRef -> TypedTree.TType option + val ConvTyconRef: + cenv:QuotationGenerationScope -> + tcref:TypedTree.TyconRef -> + m:Range.range -> QuotationPickler.NamedTypeData + val ConvReturnType: + cenv:QuotationGenerationScope -> + envinner:QuotationTranslationEnv -> + m:Range.range -> + retTy:TypedTree.TType option -> QuotationPickler.TypeData + val ConvExprPublic: + QuotationGenerationScope -> + suppressWitnesses:bool -> TypedTree.Expr -> QuotationPickler.ExprData + val ConvMethodBase: + cenv:QuotationGenerationScope -> + env:QuotationTranslationEnv -> + methName:string * v:TypedTree.Val -> QuotationPickler.MethodBaseData + val ConvReflectedDefinition: + QuotationGenerationScope -> + string -> + TypedTree.Val -> + TypedTree.Expr -> + QuotationPickler.MethodBaseData * QuotationPickler.ExprData + + +namespace FSharp.Compiler + module internal PostTypeCheckSemanticChecks = + type env = + { boundTyparNames: string list + boundTypars: TypedTreeOps.TyparMap + argVals: TypedTreeOps.ValMap + sigToImplRemapInfo: + (TypedTreeOps.Remap * TypedTreeOps.SignatureHidingInfo) list + ctorLimitedZone: bool + quote: bool + reflect: bool + external: bool + returnScope: int + isInAppExpr: bool } + with + override ToString: unit -> string + + val BindTypar: env:env -> tp:TypedTree.Typar -> env + val BindTypars: + g:TcGlobals.TcGlobals -> env:env -> tps:TypedTree.Typar list -> env + val BindArgVals: env:env -> vs:TypedTree.Val list -> env + [] + type LimitFlags = + | None = 0 + | ByRef = 1 + | ByRefOfSpanLike = 3 + | ByRefOfStackReferringSpanLike = 5 + | SpanLike = 8 + | StackReferringSpanLike = 16 + [] + type Limit = + { scope: int + flags: LimitFlags } + with + member IsLocal: bool + + val inline HasLimitFlag: targetLimit:LimitFlags -> limit:Limit -> bool + val NoLimit: Limit + val CombineTwoLimits: limit1:Limit -> limit2:Limit -> Limit + val CombineLimits: limits:Limit list -> Limit + type cenv = + { boundVals: System.Collections.Generic.Dictionary + limitVals: System.Collections.Generic.Dictionary + mutable potentialUnboundUsesOfVals: TypedTree.StampMap + mutable anonRecdTypes: TypedTree.StampMap + g: TcGlobals.TcGlobals + amap: Import.ImportMap + infoReader: InfoReader.InfoReader + internalsVisibleToPaths: TypedTree.CompilationPath list + denv: TypedTreeOps.DisplayEnv + viewCcu: TypedTree.CcuThunk + reportErrors: bool + isLastCompiland: bool * bool + isInternalTestSpanStackReferring: bool + mutable usesQuotations: bool + mutable entryPointGiven: bool + tcVal: ConstraintSolver.TcValF } + with + override ToString: unit -> string + + val IsValArgument: env:env -> v:TypedTree.Val -> bool + val IsValLocal: env:env -> v:TypedTree.Val -> bool + val GetLimitVal: + cenv:cenv -> env:env -> m:Range.range -> v:TypedTree.Val -> Limit + val GetLimitValByRef: + cenv:cenv -> env:env -> m:Range.range -> v:TypedTree.Val -> Limit + val LimitVal: cenv:cenv -> v:TypedTree.Val -> limit:Limit -> unit + val BindVal: cenv:cenv -> env:env -> v:TypedTree.Val -> unit + val BindVals: cenv:cenv -> env:env -> vs:TypedTree.Val list -> unit + val RecordAnonRecdInfo: + cenv:cenv -> anonInfo:TypedTree.AnonRecdTypeInfo -> unit + val CheckTypeDeep: + cenv:cenv -> + (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * + (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * + (TypedTree.TraitConstraintSln -> unit) option * + (env * TypedTree.Typar -> unit) option -> + g:TcGlobals.TcGlobals -> + env:env -> isInner:bool -> ty:TypedTree.TType -> unit + val CheckTypesDeep: + cenv:cenv -> + (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * + (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * + (TypedTree.TraitConstraintSln -> unit) option * + (env * TypedTree.Typar -> unit) option -> + g:TcGlobals.TcGlobals -> env:env -> tys:TypedTree.TypeInst -> unit + val CheckTypesDeepNoInner: + cenv:cenv -> + (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * + (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * + (TypedTree.TraitConstraintSln -> unit) option * + (env * TypedTree.Typar -> unit) option -> + g:TcGlobals.TcGlobals -> env:env -> tys:TypedTree.TypeInst -> unit + val CheckTypeConstraintDeep: + cenv:cenv -> + (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * + (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * + (TypedTree.TraitConstraintSln -> unit) option * + (env * TypedTree.Typar -> unit) option -> + g:TcGlobals.TcGlobals -> + env:env -> x:TypedTree.TyparConstraint -> unit + val CheckTraitInfoDeep: + cenv:cenv -> + (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * + (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * + (TypedTree.TraitConstraintSln -> unit) option * + (env * TypedTree.Typar -> unit) option -> + g:TcGlobals.TcGlobals -> + env:env -> TypedTree.TraitConstraintInfo -> unit + val CheckForByrefLikeType: + cenv:cenv -> + env:env -> + m:Range.range -> ty:TypedTree.TType -> check:(unit -> unit) -> unit + val CheckForByrefType: + cenv:cenv -> env:env -> ty:TypedTree.TType -> check:(unit -> unit) -> unit + val CheckEscapes: + cenv:cenv -> + allowProtected:bool -> + m:Range.range -> + syntacticArgs:TypedTree.Val list -> + body:TypedTree.Expr -> TypedTree.FreeVars option + val AccessInternalsVisibleToAsInternal: + thisCompPath:TypedTree.CompilationPath -> + internalsVisibleToPaths:TypedTree.CompilationPath list -> + access:TypedTree.Accessibility -> TypedTree.Accessibility + val CheckTypeForAccess: + cenv:cenv -> + env:env -> + objName:(unit -> System.String) -> + valAcc:TypedTree.Accessibility -> + m:Range.range -> ty:TypedTree.TType -> unit + val WarnOnWrongTypeForAccess: + cenv:cenv -> + env:env -> + objName:(unit -> System.String) -> + valAcc:TypedTree.Accessibility -> + m:Range.range -> ty:TypedTree.TType -> unit + [] + type PermitByRefType = + | None + | NoInnerByRefLike + | SpanLike + | All + [] + type PermitByRefExpr = + | YesTupleOfArgs of int + | Yes + | YesReturnable + | YesReturnableNonLocal + | No + with + member Disallow: bool + member PermitOnlyReturnable: bool + member PermitOnlyReturnableNonLocal: bool + + val inline IsLimitEscapingScope: + env:env -> context:PermitByRefExpr -> limit:Limit -> bool + val mkArgsPermit: n:int -> PermitByRefExpr + val mkArgsForAppliedVal: + isBaseCall:bool -> + vref:TypedTree.ValRef -> argsl:'a list -> PermitByRefExpr list + val mkArgsForAppliedExpr: + isBaseCall:bool -> + argsl:'a list -> x:TypedTree.Expr -> PermitByRefExpr list + val CheckTypeAux: + permitByRefLike:PermitByRefType -> + cenv:cenv -> + env:env -> + m:Range.range -> + ty:TypedTree.TType -> onInnerByrefError:(unit -> unit) -> unit + val CheckType: + permitByRefLike:PermitByRefType -> + cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit + val CheckTypeNoByrefs: + cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit + val CheckTypePermitSpanLike: + cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit + val CheckTypePermitAllByrefs: + cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit + val CheckTypeNoInnerByrefs: + cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit + val CheckTypeInstNoByrefs: + cenv:cenv -> + env:env -> m:Range.range -> tyargs:TypedTree.TType list -> unit + val CheckTypeInstPermitAllByrefs: + cenv:cenv -> + env:env -> m:Range.range -> tyargs:TypedTree.TType list -> unit + val CheckTypeInstNoInnerByrefs: + cenv:cenv -> + env:env -> m:Range.range -> tyargs:TypedTree.TType list -> unit + val ( |OptionalCoerce| ): _arg1:TypedTree.Expr -> TypedTree.Expr + val CheckNoReraise: + cenv:cenv -> + freesOpt:TypedTree.FreeVars option -> body:TypedTree.Expr -> unit + val isSpliceOperator: g:TcGlobals.TcGlobals -> v:TypedTree.ValRef -> bool + type TTypeEquality = + | ExactlyEqual + | FeasiblyEqual + | NotEqual + val compareTypesWithRegardToTypeVariablesAndMeasures: + g:TcGlobals.TcGlobals -> + amap:'a -> + m:Range.range -> + typ1:TypedTree.TType -> typ2:TypedTree.TType -> TTypeEquality + val CheckMultipleInterfaceInstantiations: + cenv:cenv -> + typ:TypedTree.TType -> + interfaces:TypedTree.TType list -> + isObjectExpression:bool -> m:Range.range -> unit + val CheckExprNoByrefs: cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit + val CheckValRef: + cenv:cenv -> + env:env -> + v:TypedTree.ValRef -> m:Range.range -> context:PermitByRefExpr -> unit + val CheckValUse: + cenv:cenv -> + env:env -> + vref:TypedTree.ValRef * vFlags:TypedTree.ValUseFlag * m:Range.range -> + context:PermitByRefExpr -> Limit + val CheckForOverAppliedExceptionRaisingPrimitive: + cenv:cenv -> expr:TypedTree.Expr -> unit + val CheckCallLimitArgs: + cenv:cenv -> + env:env -> + m:Range.range -> + returnTy:TypedTree.TType -> + limitArgs:Limit -> context:PermitByRefExpr -> Limit + val CheckCall: + cenv:cenv -> + env:env -> + m:Range.range -> + returnTy:TypedTree.TType -> + args:TypedTree.Expr list -> + contexts:PermitByRefExpr list -> + context:PermitByRefExpr -> Limit + val CheckCallWithReceiver: + cenv:cenv -> + env:env -> + m:Range.range -> + returnTy:TypedTree.TType -> + args:TypedTree.Expr list -> + contexts:PermitByRefExpr list -> + context:PermitByRefExpr -> Limit + val CheckExprLinear: + cenv:cenv -> + env:env -> + expr:TypedTree.Expr -> + context:PermitByRefExpr -> contf:(Limit -> Limit) -> Limit + val CheckExpr: + cenv:cenv -> + env:env -> origExpr:TypedTree.Expr -> context:PermitByRefExpr -> Limit + val CheckMethods: + cenv:cenv -> + env:env -> + baseValOpt:TypedTree.Val option -> + methods:TypedTree.ObjExprMethod list -> unit + val CheckMethod: + cenv:cenv -> + env:env -> + baseValOpt:TypedTree.Val option -> TypedTree.ObjExprMethod -> unit + val CheckInterfaceImpls: + cenv:cenv -> + env:env -> + baseValOpt:TypedTree.Val option -> + l:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> unit + val CheckInterfaceImpl: + cenv:cenv -> + env:env -> + baseValOpt:TypedTree.Val option -> + _ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> unit + val CheckExprOp: + cenv:cenv -> + env:env -> + op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * + m:Range.range -> + context:PermitByRefExpr -> expr:TypedTree.Expr -> Limit + val CheckLambdas: + isTop:bool -> + memInfo:TypedTree.ValMemberInfo option -> + cenv:cenv -> + env:env -> + inlined:bool -> + topValInfo:TypedTree.ValReprInfo -> + alwaysCheckNoReraise:bool -> + e:TypedTree.Expr -> + mOrig:Range.range -> + ety:TypedTree.TType -> context:PermitByRefExpr -> Limit + val CheckExprs: + cenv:cenv -> + env:env -> + exprs:TypedTree.Expr list -> contexts:PermitByRefExpr list -> Limit + val CheckExprsNoByRefLike: + cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> Limit + val CheckExprsPermitByRefLike: + cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> Limit + val CheckExprsPermitReturnableByRef: + cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> Limit + val CheckExprPermitByRefLike: + cenv:cenv -> env:env -> expr:TypedTree.Expr -> Limit + val CheckExprPermitReturnableByRef: + cenv:cenv -> env:env -> expr:TypedTree.Expr -> Limit + val CheckDecisionTreeTargets: + cenv:cenv -> + env:env -> + targets:TypedTree.DecisionTreeTarget array -> + context:PermitByRefExpr -> Limit + val CheckDecisionTreeTarget: + cenv:cenv -> + env:env -> + context:PermitByRefExpr -> TypedTree.DecisionTreeTarget -> Limit + val CheckDecisionTree: + cenv:cenv -> env:env -> x:TypedTree.DecisionTree -> unit + val CheckDecisionTreeSwitch: + cenv:cenv -> + env:env -> + e:TypedTree.Expr * cases:TypedTree.DecisionTreeCase list * + dflt:TypedTree.DecisionTree option * m:Range.range -> unit + val CheckDecisionTreeTest: + cenv:cenv -> + env:env -> m:Range.range -> discrim:TypedTree.DecisionTreeTest -> unit + val CheckAttrib: cenv:cenv -> env:env -> TypedTree.Attrib -> unit + val CheckAttribExpr: cenv:cenv -> env:env -> TypedTree.AttribExpr -> unit + val CheckAttribArgExpr: cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit + val CheckAttribs: cenv:cenv -> env:env -> attribs:TypedTree.Attribs -> unit + val CheckValInfo: cenv:cenv -> env:env -> TypedTree.ValReprInfo -> unit + val CheckArgInfo: + cenv:cenv -> env:env -> argInfo:TypedTree.ArgReprInfo -> unit + val CheckValSpecAux: + permitByRefLike:PermitByRefType -> + cenv:cenv -> + env:env -> v:TypedTree.Val -> onInnerByrefError:(unit -> unit) -> unit + val CheckValSpec: + permitByRefLike:PermitByRefType -> + cenv:cenv -> env:env -> v:TypedTree.Val -> unit + val AdjustAccess: + isHidden:bool -> + cpath:(unit -> TypedTree.CompilationPath) -> + access:TypedTree.Accessibility -> TypedTree.Accessibility + val CheckBinding: + cenv:cenv -> + env:env -> + alwaysCheckNoReraise:bool -> + context:PermitByRefExpr -> TypedTree.Binding -> Limit + val CheckBindings: cenv:cenv -> env:env -> xs:TypedTree.Bindings -> unit + val CheckModuleBinding: cenv:cenv -> env:env -> TypedTree.Binding -> unit + val CheckModuleBindings: + cenv:cenv -> env:env -> binds:TypedTree.Binding list -> unit + val CheckRecdField: + isUnion:bool -> + cenv:cenv -> + env:env -> tycon:TypedTree.Tycon -> rfield:TypedTree.RecdField -> unit + val CheckEntityDefn: cenv:cenv -> env:env -> tycon:TypedTree.Entity -> unit + val CheckEntityDefns: + cenv:cenv -> env:env -> tycons:TypedTree.Entity list -> unit + val CheckModuleExpr: + cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExprWithSig -> unit + val CheckDefnsInModule: + cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr list -> unit + val CheckNothingAfterEntryPoint: cenv:cenv -> m:Range.range -> unit + val CheckDefnInModule: + cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr -> unit + val CheckModuleSpec: + cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceBinding -> unit + val CheckTopImpl: + g:TcGlobals.TcGlobals * amap:Import.ImportMap * reportErrors:bool * + infoReader:InfoReader.InfoReader * + internalsVisibleToPaths:TypedTree.CompilationPath list * + viewCcu:TypedTree.CcuThunk * tcValF:ConstraintSolver.TcValF * + denv:TypedTreeOps.DisplayEnv * + mexpr:TypedTree.ModuleOrNamespaceExprWithSig * + extraAttribs:TypedTree.Attribs * (bool * bool) * + isInternalTestSpanStackReferring:bool -> + bool * TypedTree.StampMap + + +namespace FSharp.Compiler + module internal CheckExpressions = + val mkNilListPat: + g:TcGlobals.TcGlobals -> + m:Range.range -> ty:TypedTree.TType -> PatternMatchCompilation.Pattern + val mkConsListPat: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> + ph:PatternMatchCompilation.Pattern -> + pt:PatternMatchCompilation.Pattern -> + PatternMatchCompilation.Pattern + exception BakedInMemberConstraintName of string * Range.range + exception FunctionExpected of + TypedTreeOps.DisplayEnv * TypedTree.TType * + Range.range + exception NotAFunction of + TypedTreeOps.DisplayEnv * TypedTree.TType * + Range.range * Range.range + exception NotAFunctionButIndexer of + TypedTreeOps.DisplayEnv * TypedTree.TType * + string option * Range.range * Range.range + exception Recursion of + TypedTreeOps.DisplayEnv * SyntaxTree.Ident * + TypedTree.TType * TypedTree.TType * Range.range + exception RecursiveUseCheckedAtRuntime of + TypedTreeOps.DisplayEnv * + TypedTree.ValRef * Range.range + exception LetRecEvaluatedOutOfOrder of + TypedTreeOps.DisplayEnv * + TypedTree.ValRef * TypedTree.ValRef * + Range.range + exception LetRecCheckedAtRuntime of Range.range + exception LetRecUnsound of + TypedTreeOps.DisplayEnv * TypedTree.ValRef list * + Range.range + exception TyconBadArgs of + TypedTreeOps.DisplayEnv * TypedTree.TyconRef * int * + Range.range + exception UnionCaseWrongArguments of + TypedTreeOps.DisplayEnv * int * int * + Range.range + exception UnionCaseWrongNumberOfArgs of + TypedTreeOps.DisplayEnv * int * int * + Range.range + exception FieldsFromDifferentTypes of + TypedTreeOps.DisplayEnv * + TypedTree.RecdFieldRef * + TypedTree.RecdFieldRef * Range.range + exception FieldGivenTwice of + TypedTreeOps.DisplayEnv * TypedTree.RecdFieldRef * + Range.range + exception MissingFields of string list * Range.range + exception FunctionValueUnexpected of + TypedTreeOps.DisplayEnv * + TypedTree.TType * Range.range + exception UnitTypeExpected of + TypedTreeOps.DisplayEnv * TypedTree.TType * + Range.range + exception UnitTypeExpectedWithEquality of + TypedTreeOps.DisplayEnv * + TypedTree.TType * Range.range + exception UnitTypeExpectedWithPossibleAssignment of + TypedTreeOps.DisplayEnv * + TypedTree.TType * bool * + string * Range.range + exception UnitTypeExpectedWithPossiblePropertySetter of + TypedTreeOps.DisplayEnv * + TypedTree.TType * + string * string * + Range.range + exception UnionPatternsBindDifferentNames of Range.range + exception VarBoundTwice of SyntaxTree.Ident + exception ValueRestriction of + TypedTreeOps.DisplayEnv * bool * TypedTree.Val * + TypedTree.Typar * Range.range + exception ValNotMutable of + TypedTreeOps.DisplayEnv * TypedTree.ValRef * + Range.range + exception ValNotLocal of + TypedTreeOps.DisplayEnv * TypedTree.ValRef * + Range.range + exception InvalidRuntimeCoercion of + TypedTreeOps.DisplayEnv * TypedTree.TType * + TypedTree.TType * Range.range + exception IndeterminateRuntimeCoercion of + TypedTreeOps.DisplayEnv * + TypedTree.TType * TypedTree.TType * + Range.range + exception IndeterminateStaticCoercion of + TypedTreeOps.DisplayEnv * + TypedTree.TType * TypedTree.TType * + Range.range + exception RuntimeCoercionSourceSealed of + TypedTreeOps.DisplayEnv * + TypedTree.TType * Range.range + exception CoercionTargetSealed of + TypedTreeOps.DisplayEnv * TypedTree.TType * + Range.range + exception UpcastUnnecessary of Range.range + exception TypeTestUnnecessary of Range.range + exception StaticCoercionShouldUseBox of + TypedTreeOps.DisplayEnv * + TypedTree.TType * TypedTree.TType * + Range.range + exception SelfRefObjCtor of bool * Range.range + exception VirtualAugmentationOnNullValuedType of Range.range + exception NonVirtualAugmentationOnNullValuedType of Range.range + exception UseOfAddressOfOperator of Range.range + exception DeprecatedThreadStaticBindingWarning of Range.range + exception IntfImplInIntrinsicAugmentation of Range.range + exception IntfImplInExtrinsicAugmentation of Range.range + exception OverrideInIntrinsicAugmentation of Range.range + exception OverrideInExtrinsicAugmentation of Range.range + exception NonUniqueInferredAbstractSlot of + TcGlobals.TcGlobals * + TypedTreeOps.DisplayEnv * string * + Infos.MethInfo * Infos.MethInfo * + Range.range + exception StandardOperatorRedefinitionWarning of string * Range.range + exception InvalidInternalsVisibleToAssemblyName of string * string option + type SafeInitData = + | SafeInitField of TypedTree.RecdFieldRef * TypedTree.RecdField + | NoSafeInitInfo + [] + type CtorInfo = + { ctorShapeCounter: int + safeThisValOpt: TypedTree.Val option + safeInitInfo: SafeInitData + ctorIsImplicit: bool } + [] + type UngeneralizableItem = + + new: computeFreeTyvars:(unit -> TypedTree.FreeTyvars) -> + UngeneralizableItem + member GetFreeTyvars: unit -> TypedTree.FreeTyvars + member CachedFreeLocalTycons: TypedTree.FreeTycons + member CachedFreeTraitSolutions: TypedTree.FreeLocals + member WillNeverHaveFreeTypars: bool + + [] + type TcEnv = + { eNameResEnv: NameResolution.NameResolutionEnv + eUngeneralizableItems: UngeneralizableItem list + ePath: SyntaxTree.Ident list + eCompPath: TypedTree.CompilationPath + eAccessPath: TypedTree.CompilationPath + eAccessRights: AccessibilityLogic.AccessorDomain + eInternalsVisibleCompPaths: TypedTree.CompilationPath list + eModuleOrNamespaceTypeAccumulator: TypedTree.ModuleOrNamespaceType ref + eContextInfo: ConstraintSolver.ContextInfo + eFamilyType: TypedTree.TyconRef option + eCtorInfo: CtorInfo option + eCallerMemberName: string option } + with + override ToString: unit -> string + member AccessRights: AccessibilityLogic.AccessorDomain + member DisplayEnv: TypedTreeOps.DisplayEnv + member NameEnv: NameResolution.NameResolutionEnv + + val ComputeAccessRights: + eAccessPath:TypedTree.CompilationPath -> + eInternalsVisibleCompPaths:TypedTree.CompilationPath list -> + eFamilyType:TypedTree.TyconRef option -> + AccessibilityLogic.AccessorDomain + val InitialExplicitCtorInfo: + safeThisValOpt:TypedTree.Val option * safeInitInfo:SafeInitData -> + CtorInfo + val InitialImplicitCtorInfo: unit -> CtorInfo + val EnterFamilyRegion: tcref:TypedTree.TyconRef -> env:TcEnv -> TcEnv + val ExitFamilyRegion: env:TcEnv -> TcEnv + val AreWithinCtorShape: env:TcEnv -> bool + val AreWithinImplicitCtor: env:TcEnv -> bool + val GetCtorShapeCounter: env:TcEnv -> int + val GetRecdInfo: env:TcEnv -> TypedTree.RecordConstructionInfo + val AdjustCtorShapeCounter: f:(int -> int) -> env:TcEnv -> TcEnv + val ExitCtorShapeRegion: env:TcEnv -> TcEnv + val addFreeItemOfTy: + ty:TypedTree.TType -> + eUngeneralizableItems:UngeneralizableItem list -> + UngeneralizableItem list + val addFreeItemOfModuleTy: + TypedTree.ModuleOrNamespaceType -> + UngeneralizableItem list -> UngeneralizableItem list + val AddValMapToNameEnv: + vs:AbstractIL.Internal.Library.NameMap -> + nenv:NameResolution.NameResolutionEnv -> + NameResolution.NameResolutionEnv + val AddValListToNameEnv: + vs:TypedTree.Val list -> + nenv:NameResolution.NameResolutionEnv -> + NameResolution.NameResolutionEnv + val AddLocalValPrimitive: v:TypedTree.Val -> TcEnv -> TcEnv + val AddLocalValMap: + tcSink:NameResolution.TcResultsSink -> + scopem:Range.range -> + vals:AbstractIL.Internal.Library.NameMap -> + env:TcEnv -> TcEnv + val AddLocalVals: + tcSink:NameResolution.TcResultsSink -> + scopem:Range.range -> vals:TypedTree.Val list -> env:TcEnv -> TcEnv + val AddLocalVal: + NameResolution.TcResultsSink -> + scopem:Range.range -> v:TypedTree.Val -> TcEnv -> TcEnv + val AddDeclaredTypars: + check:NameResolution.CheckForDuplicateTyparFlag -> + typars:TypedTree.Typar list -> env:TcEnv -> TcEnv + type UnscopedTyparEnv = + | UnscopedTyparEnv of AbstractIL.Internal.Library.NameMap + val emptyUnscopedTyparEnv: UnscopedTyparEnv + val AddUnscopedTypar: + n:string -> p:TypedTree.Typar -> UnscopedTyparEnv -> UnscopedTyparEnv + val TryFindUnscopedTypar: + n:string -> UnscopedTyparEnv -> TypedTree.Typar option + val HideUnscopedTypars: + typars:TypedTree.Typar list -> UnscopedTyparEnv -> UnscopedTyparEnv + [] + type TcFileState = + { g: TcGlobals.TcGlobals + mutable recUses: + TypedTreeOps.ValMultiMap + mutable postInferenceChecks: ResizeArray<(unit -> unit)> + mutable createsGeneratedProvidedTypes: bool + isScript: bool + amap: Import.ImportMap + synArgNameGenerator: SyntaxTreeOps.SynArgNameGenerator + tcSink: NameResolution.TcResultsSink + topCcu: TypedTree.CcuThunk + css: ConstraintSolver.ConstraintSolverState + compilingCanonicalFslibModuleType: bool + isSig: bool + haveSig: bool + niceNameGen: CompilerGlobalState.NiceNameGenerator + infoReader: InfoReader.InfoReader + nameResolver: NameResolution.NameResolver + conditionalDefines: string list option + isInternalTestSpanStackReferring: bool + TcSequenceExpressionEntry: + TcFileState -> TcEnv -> TypedTree.TType -> UnscopedTyparEnv -> + bool * bool ref * SyntaxTree.SynExpr -> Range.range -> + TypedTree.Expr * UnscopedTyparEnv + TcArrayOrListSequenceExpression: + TcFileState -> TcEnv -> TypedTree.TType -> UnscopedTyparEnv -> + bool * SyntaxTree.SynExpr -> Range.range -> + TypedTree.Expr * UnscopedTyparEnv + TcComputationExpression: + TcFileState -> TcEnv -> TypedTree.TType -> UnscopedTyparEnv -> + Range.range * TypedTree.Expr * TypedTree.TType * SyntaxTree.SynExpr -> + TypedTree.Expr * UnscopedTyparEnv } + with + static member + Create: g:TcGlobals.TcGlobals * isScript:bool * + niceNameGen:CompilerGlobalState.NiceNameGenerator * + amap:Import.ImportMap * topCcu:TypedTree.CcuThunk * + isSig:bool * haveSig:bool * + conditionalDefines:string list option * + tcSink:NameResolution.TcResultsSink * + tcVal:ConstraintSolver.TcValF * + isInternalTestSpanStackReferring:bool * + tcSequenceExpressionEntry:(TcFileState -> TcEnv -> + TypedTree.TType -> + UnscopedTyparEnv -> + bool * bool ref * + SyntaxTree.SynExpr -> + Range.range -> + TypedTree.Expr * + UnscopedTyparEnv) * + tcArrayOrListSequenceExpression:(TcFileState -> TcEnv -> + TypedTree.TType -> + UnscopedTyparEnv -> + bool * SyntaxTree.SynExpr -> + Range.range -> + TypedTree.Expr * + UnscopedTyparEnv) * + tcComputationExpression:(TcFileState -> TcEnv -> + TypedTree.TType -> + UnscopedTyparEnv -> + Range.range * TypedTree.Expr * + TypedTree.TType * + SyntaxTree.SynExpr -> + TypedTree.Expr * UnscopedTyparEnv) -> + TcFileState + override ToString: unit -> string + + type cenv = TcFileState + val CopyAndFixupTypars: + m:Range.range -> + rigid:TypedTree.TyparRigidity -> + tpsorig:TypedTree.Typars -> + TypedTree.Typars * TypedTreeOps.TyparInst * TypedTree.TType list + val UnifyTypes: + cenv:TcFileState -> + env:TcEnv -> + m:Range.range -> + actualTy:TypedTree.TType -> expectedTy:TypedTree.TType -> unit + val MakeInnerEnvWithAcc: + addOpenToNameEnv:bool -> + env:TcEnv -> + nm:SyntaxTree.Ident -> + mtypeAcc:TypedTree.ModuleOrNamespaceType ref -> + modKind:TypedTree.ModuleOrNamespaceKind -> TcEnv + val MakeInnerEnv: + addOpenToNameEnv:bool -> + env:TcEnv -> + nm:SyntaxTree.Ident -> + modKind:TypedTree.ModuleOrNamespaceKind -> + TcEnv * TypedTree.ModuleOrNamespaceType ref + val MakeInnerEnvForTyconRef: + env:TcEnv -> + tcref:TypedTree.TyconRef -> isExtrinsicExtension:bool -> TcEnv + val MakeInnerEnvForMember: env:TcEnv -> v:TypedTree.Val -> TcEnv + val GetCurrAccumulatedModuleOrNamespaceType: + env:TcEnv -> TypedTree.ModuleOrNamespaceType + val SetCurrAccumulatedModuleOrNamespaceType: + env:TcEnv -> x:TypedTree.ModuleOrNamespaceType -> unit + val LocateEnv: + ccu:TypedTree.CcuThunk -> + env:TcEnv -> enclosingNamespacePath:SyntaxTree.Ident list -> TcEnv + val ShrinkContext: + env:TcEnv -> oldRange:Range.range -> newRange:Range.range -> TcEnv + val UnifyRefTupleType: + contextInfo:ConstraintSolver.ContextInfo -> + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + m:Range.range -> + ty:TypedTree.TType -> ps:'a list -> TypedTree.TTypes + val UnifyTupleTypeAndInferCharacteristics: + contextInfo:ConstraintSolver.ContextInfo -> + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + m:Range.range -> + knownTy:TypedTree.TType -> + isExplicitStruct:bool -> + ps:'a list -> TypedTree.TupInfo * TypedTree.TTypes + val UnifyAnonRecdTypeAndInferCharacteristics: + contextInfo:ConstraintSolver.ContextInfo -> + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + m:Range.range -> + ty:TypedTree.TType -> + isExplicitStruct:bool -> + unsortedNames:SyntaxTree.Ident [] -> + TypedTree.AnonRecdTypeInfo * TypedTree.TType list + val UnifyFunctionTypeUndoIfFailed: + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + m:Range.range -> + ty:TypedTree.TType -> (TypedTree.TType * TypedTree.TType) voption + val UnifyFunctionType: + extraInfo:Range.range option -> + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + mFunExpr:Range.range -> + ty:TypedTree.TType -> TypedTree.TType * TypedTree.TType + val ReportImplicitlyIgnoredBoolExpression: + denv:TypedTreeOps.DisplayEnv -> + m:Range.range -> ty:TypedTree.TType -> expr:TypedTree.Expr -> exn + val UnifyUnitType: + cenv:TcFileState -> + env:TcEnv -> + m:Range.range -> ty:TypedTree.TType -> expr:TypedTree.Expr -> bool + val TryUnifyUnitTypeWithoutWarning: + cenv:TcFileState -> + env:TcEnv -> m:Range.range -> ty:TypedTree.TType -> bool + module AttributeTargets = + val FieldDecl: System.AttributeTargets + val FieldDeclRestricted: System.AttributeTargets + val UnionCaseDecl: System.AttributeTargets + val TyconDecl: System.AttributeTargets + val ExnDecl: System.AttributeTargets + val ModuleDecl: System.AttributeTargets + val Top: System.AttributeTargets + + val ForNewConstructors: + tcSink:NameResolution.TcResultsSink -> + env:TcEnv -> + mObjTy:Range.range -> + methodName:string -> + meths:Infos.MethInfo list -> NameResolution.AfterResolution + val TcSynRationalConst: c:SyntaxTree.SynRationalConst -> Rational.Rational + val TcConst: + cenv:TcFileState -> + ty:TypedTree.TType -> + m:Range.range -> env:TcEnv -> c:SyntaxTree.SynConst -> TypedTree.Const + val TcFieldInit: + Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const + val AdjustValSynInfoInSignature: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo + type PartialValReprInfo = + | PartialValReprInfo of + curriedArgInfos: TypedTree.ArgReprInfo list list * + returnInfo: TypedTree.ArgReprInfo + val TranslateTopArgSynInfo: + isArg:bool -> + m:Range.range -> + tcAttributes:(SyntaxTree.SynAttribute list -> TypedTree.Attribs) -> + SyntaxTree.SynArgInfo -> TypedTree.ArgReprInfo + val TranslateTopValSynInfo: + Range.range -> + tcAttributes:(System.AttributeTargets -> SyntaxTree.SynAttribute list -> + TypedTree.Attribs) -> + synValInfo:SyntaxTree.SynValInfo -> PartialValReprInfo + val TranslatePartialArity: + tps:TypedTree.Typar list -> PartialValReprInfo -> TypedTree.ValReprInfo + val ComputeLogicalName: + id:SyntaxTree.Ident -> memberFlags:SyntaxTree.MemberFlags -> string + type PreValMemberInfo = + | PreValMemberInfo of + memberInfo: TypedTree.ValMemberInfo * logicalName: string * + compiledName: string + val MakeMemberDataAndMangledNameForMemberVal: + g:TcGlobals.TcGlobals * tcref:TypedTree.TyconRef * isExtrinsic:bool * + attrs:TypedTree.Attribs * optImplSlotTys:TypedTree.TType list * + memberFlags:SyntaxTree.MemberFlags * valSynData:SyntaxTree.SynValInfo * + id:SyntaxTree.Ident * isCompGen:bool -> PreValMemberInfo + type OverridesOK = + | OverridesOK + | WarnOnOverrides + | ErrorOnOverrides + type ExplicitTyparInfo = + | ExplicitTyparInfo of + rigidCopyOfDeclaredTypars: TypedTree.Typars * + declaredTypars: TypedTree.Typars * infer: bool + val permitInferTypars: ExplicitTyparInfo + val dontInferTypars: ExplicitTyparInfo + type ArgAndRetAttribs = + | ArgAndRetAttribs of TypedTree.Attribs list list * TypedTree.Attribs + val noArgOrRetAttribs: ArgAndRetAttribs + type DeclKind = + | ModuleOrMemberBinding + | IntrinsicExtensionBinding + | ExtrinsicExtensionBinding + | ClassLetBinding of isStatic: bool + | ObjectExpressionOverrideBinding + | ExpressionBinding + with + static member + AllowedAttribTargets: SyntaxTree.MemberFlags option -> + DeclKind -> System.AttributeTargets + static member CanGeneralizeConstrainedTypars: DeclKind -> bool + static member CanOverrideOrImplement: DeclKind -> OverridesOK + static member ConvertToLinearBindings: DeclKind -> bool + static member ImplicitlyStatic: DeclKind -> bool + static member IsAccessModifierPermitted: DeclKind -> bool + static member IsModuleOrMemberOrExtensionBinding: DeclKind -> bool + static member MustHaveArity: DeclKind -> bool + member CanBeDllImport: bool + + [] + type PrelimValScheme1 = + | PrelimValScheme1 of + id: SyntaxTree.Ident * explicitTyparInfo: ExplicitTyparInfo * + TypedTree.TType * PartialValReprInfo option * PreValMemberInfo option * + bool * TypedTree.ValInline * TypedTree.ValBaseOrThisInfo * + ArgAndRetAttribs * SyntaxTree.SynAccess option * bool + with + member Ident: SyntaxTree.Ident + member Type: TypedTree.TType + + type PrelimValScheme2 = + | PrelimValScheme2 of + SyntaxTree.Ident * TypedTreeOps.TypeScheme * PartialValReprInfo option * + PreValMemberInfo option * bool * TypedTree.ValInline * + TypedTree.ValBaseOrThisInfo * ArgAndRetAttribs * + SyntaxTree.SynAccess option * bool * bool + type ValScheme = + | ValScheme of + id: SyntaxTree.Ident * typeScheme: TypedTreeOps.TypeScheme * + topValInfo: TypedTree.ValReprInfo option * + memberInfo: PreValMemberInfo option * isMutable: bool * + inlineInfo: TypedTree.ValInline * + baseOrThisInfo: TypedTree.ValBaseOrThisInfo * + visibility: SyntaxTree.SynAccess option * compgen: bool * + isIncrClass: bool * isTyFunc: bool * hasDeclaredTypars: bool + with + member GeneralizedTypars: TypedTree.Typars + member TypeScheme: TypedTreeOps.TypeScheme + member ValReprInfo: TypedTree.ValReprInfo option + + type TcPatPhase2Input = + | TcPatPhase2Input of + AbstractIL.Internal.Library.NameMap * bool + with + member RightPath: TcPatPhase2Input + + [] + type CheckedBindingInfo = + | CheckedBindingInfo of + inlineFlag: TypedTree.ValInline * valAttribs: TypedTree.Attribs * + xmlDoc: XmlDoc.XmlDoc * + tcPatPhase2: TcPatPhase2Input -> PatternMatchCompilation.Pattern * + exlicitTyparInfo: ExplicitTyparInfo * + nameToPrelimValSchemeMap: + AbstractIL.Internal.Library.NameMap * + rhsExprChecked: TypedTree.Expr * argAndRetAttribs: ArgAndRetAttribs * + overallPatTy: TypedTree.TType * mBinding: Range.range * + spBind: SyntaxTree.DebugPointForBinding * isCompilerGenerated: bool * + literalValue: TypedTree.Const option * isFixed: bool + with + member Expr: TypedTree.Expr + member SeqPoint: SyntaxTree.DebugPointForBinding + + val GeneralizedTypeForTypeScheme: + typeScheme:TypedTreeOps.TypeScheme -> TypedTree.TType + val NonGenericTypeScheme: ty:TypedTree.TType -> TypedTreeOps.TypeScheme + val UpdateAccModuleOrNamespaceType: + cenv:TcFileState -> + env:TcEnv -> + f:(bool -> TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType) -> unit + val PublishModuleDefn: + cenv:TcFileState -> env:TcEnv -> mspec:TypedTree.Tycon -> unit + val PublishTypeDefn: + cenv:TcFileState -> env:TcEnv -> mspec:TypedTree.Tycon -> unit + val PublishValueDefnPrim: + cenv:TcFileState -> env:TcEnv -> vspec:TypedTree.Val -> unit + val PublishValueDefn: + cenv:TcFileState -> + env:TcEnv -> declKind:DeclKind -> vspec:TypedTree.Val -> unit + val CombineVisibilityAttribs: + vis1:'a option -> vis2:'a option -> m:Range.range -> 'a option + val ComputeAccessAndCompPath: + env:TcEnv -> + declKindOpt:DeclKind option -> + m:Range.range -> + vis:SyntaxTree.SynAccess option -> + overrideVis:TypedTree.Accessibility option -> + actualParent:TypedTree.ParentRef -> + TypedTree.Accessibility * TypedTree.CompilationPath option + val CheckForAbnormalOperatorNames: + cenv:TcFileState -> + idRange:Range.range -> + coreDisplayName:string -> + memberInfoOpt:TypedTree.ValMemberInfo option -> unit + val MakeAndPublishVal: + cenv:TcFileState -> + env:TcEnv -> + altActualParent:TypedTree.ParentRef * inSig:bool * declKind:DeclKind * + vrec:TypedTree.ValRecursiveScopeInfo * vscheme:ValScheme * + attrs:TypedTree.Attribs * doc:XmlDoc.XmlDoc * + konst:TypedTree.Const option * isGeneratedEventVal:bool -> + TypedTree.Val + val MakeAndPublishVals: + cenv:TcFileState -> + env:TcEnv -> + altActualParent:TypedTree.ParentRef * inSig:bool * declKind:DeclKind * + vrec:TypedTree.ValRecursiveScopeInfo * valSchemes:Map<'a,ValScheme> * + attrs:TypedTree.Attribs * doc:XmlDoc.XmlDoc * + literalValue:TypedTree.Const option -> + Map<'a,(TypedTree.Val * TypedTreeOps.TypeScheme)> + when 'a: comparison + val MakeAndPublishBaseVal: + cenv:TcFileState -> + env:TcEnv -> + SyntaxTree.Ident option -> TypedTree.TType -> TypedTree.Val option + val MakeAndPublishSafeThisVal: + cenv:TcFileState -> + env:TcEnv -> + thisIdOpt:SyntaxTree.Ident option -> + thisTy:TypedTree.TType -> TypedTree.Val option + val AdjustAndForgetUsesOfRecValue: + cenv:TcFileState -> + vrefTgt:TypedTree.ValRef -> valScheme:ValScheme -> unit + val AdjustRecType: vspec:TypedTree.Val -> vscheme:ValScheme -> unit + val RecordUseOfRecValue: + cenv:TcFileState -> + vrec:TypedTree.ValRecursiveScopeInfo -> + vrefTgt:TypedTree.ValRef -> + vexp:TypedTree.Expr -> m:Range.range -> TypedTree.Expr + [] + type RecursiveUseFixupPoints = + | RecursiveUseFixupPoints of (TypedTree.Expr ref * Range.range) list + val GetAllUsesOfRecValue: + cenv:TcFileState -> vrefTgt:TypedTree.Val -> RecursiveUseFixupPoints + val ChooseCanonicalDeclaredTyparsAfterInference: + g:TcGlobals.TcGlobals -> + denv:TypedTreeOps.DisplayEnv -> + declaredTypars:TypedTree.Typar list -> + m:Range.range -> TypedTree.Typars + val ChooseCanonicalValSchemeAfterInference: + g:TcGlobals.TcGlobals -> + denv:TypedTreeOps.DisplayEnv -> + vscheme:ValScheme -> m:Range.range -> ValScheme + val PlaceTyparsInDeclarationOrder: + declaredTypars:TypedTree.Typar list -> + generalizedTypars:TypedTree.Typar list -> TypedTree.Typar list + val SetTyparRigid: + TypedTreeOps.DisplayEnv -> Range.range -> TypedTree.Typar -> unit + val GeneralizeVal: + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + enclosingDeclaredTypars:TypedTree.Typar list -> + generalizedTyparsForThisBinding:TypedTree.Typar list -> + PrelimValScheme1 -> PrelimValScheme2 + val GeneralizeVals: + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + enclosingDeclaredTypars:TypedTree.Typar list -> + generalizedTypars:TypedTree.Typar list -> + types:AbstractIL.Internal.Library.NameMap -> + Map + val DontGeneralizeVals: + types:AbstractIL.Internal.Library.NameMap -> + Map + val InferGenericArityFromTyScheme: + TypedTreeOps.TypeScheme -> + partialValReprInfo:PartialValReprInfo -> TypedTree.ValReprInfo + val ComputeIsTyFunc: + id:SyntaxTree.Ident * hasDeclaredTypars:bool * + arityInfo:TypedTree.ValReprInfo option -> bool + val UseSyntacticArity: + declKind:DeclKind -> + typeScheme:TypedTreeOps.TypeScheme -> + partialValReprInfo:PartialValReprInfo -> TypedTree.ValReprInfo option + val CombineSyntacticAndInferredArities: + g:TcGlobals.TcGlobals -> + declKind:DeclKind -> + rhsExpr:TypedTree.Expr -> + prelimScheme:PrelimValScheme2 -> PartialValReprInfo option + val BuildValScheme: + declKind:DeclKind -> + partialArityInfoOpt:PartialValReprInfo option -> + prelimScheme:PrelimValScheme2 -> ValScheme + val UseCombinedArity: + g:TcGlobals.TcGlobals -> + declKind:DeclKind -> + rhsExpr:TypedTree.Expr -> prelimScheme:PrelimValScheme2 -> ValScheme + val UseNoArity: prelimScheme:PrelimValScheme2 -> ValScheme + val MakeAndPublishSimpleVals: + cenv:TcFileState -> + env:TcEnv -> + names:AbstractIL.Internal.Library.NameMap -> + Map * + Map + val MakeAndPublishSimpleValsForMergedScope: + cenv:TcFileState -> + env:TcEnv -> + m:Range.range -> + names:AbstractIL.Internal.Library.NameMap -> + TcEnv * Map * + Map + val FreshenTyconRef: + m:Range.range -> + rigid:TypedTree.TyparRigidity -> + tcref:TypedTree.TyconRef -> + declaredTyconTypars:TypedTree.Typar list -> + TypedTree.TType * TypedTree.Typar list * TypedTreeOps.TyparInst * + TypedTree.TType + val FreshenPossibleForallTy: + g:TcGlobals.TcGlobals -> + m:Range.range -> + rigid:TypedTree.TyparRigidity -> + ty:TypedTree.TType -> + TypedTree.Typar list * TypedTree.Typar list * TypedTree.TType list * + TypedTree.TType + val FreshenTyconRef2: + m:Range.range -> + tcref:TypedTree.TyconRef -> + TypedTree.Typars * TypedTreeOps.TyparInst * TypedTree.TType list * + TypedTree.TType + val FreshenAbstractSlot: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + synTyparDecls:SyntaxTree.SynValTyparDecls -> + absMethInfo:Infos.MethInfo -> + bool * TypedTree.Typars * TypedTree.TType list list * + TypedTree.TType + val BuildFieldMap: + cenv:TcFileState -> + env:TcEnv -> + isPartial:bool -> + ty:TypedTree.TType -> + flds:((SyntaxTree.Ident list * SyntaxTree.Ident) * 'a) list -> + m:Range.range -> + TypedTree.TypeInst * TypedTree.TyconRef * Map * + (string * 'a) list + val ApplyUnionCaseOrExn: + makerForUnionCase:(TypedTree.UnionCaseRef * TypedTree.TypeInst -> 'a) * + makerForExnTag:(TypedTree.TyconRef -> 'a) -> + m:Range.range -> + cenv:TcFileState -> + env:TcEnv -> + overallTy:TypedTree.TType -> + item:NameResolution.Item -> + 'a * TypedTree.TType list * SyntaxTree.Ident list + val ApplyUnionCaseOrExnTypes: + m:Range.range -> + cenv:TcFileState -> + env:TcEnv -> + overallTy:TypedTree.TType -> + c:NameResolution.Item -> + (Range.range -> TypedTree.Exprs -> TypedTree.Expr) * + TypedTree.TType list * SyntaxTree.Ident list + val ApplyUnionCaseOrExnTypesForPat: + m:Range.range -> + cenv:TcFileState -> + env:TcEnv -> + overallTy:TypedTree.TType -> + c:NameResolution.Item -> + (Range.range -> PatternMatchCompilation.Pattern list -> + PatternMatchCompilation.Pattern) * TypedTree.TType list * + SyntaxTree.Ident list + val UnionCaseOrExnCheck: + env:TcEnv -> numArgTys:int -> numArgs:int -> m:Range.range -> unit + val TcUnionCaseOrExnField: + cenv:TcFileState -> + env:TcEnv -> + ty1:TypedTree.TType -> + m:Range.range -> + c:SyntaxTree.Ident list -> + n:int -> + (TypedTree.UnionCaseRef * TypedTree.TypeInst -> 'a) * + (TypedTree.TyconRef -> 'a) -> 'a * TypedTree.TType + type GeneralizeConstrainedTyparOptions = + | CanGeneralizeConstrainedTypars + | DoNotGeneralizeConstrainedTypars + module GeneralizationHelpers = + val ComputeUngeneralizableTypars: + env:TcEnv -> + Internal.Utilities.Collections.Tagged.Set> + val ComputeUnabstractableTycons: env:TcEnv -> TypedTree.FreeTycons + val ComputeUnabstractableTraitSolutions: + env:TcEnv -> TypedTree.FreeLocals + val IsGeneralizableValue: + g:TcGlobals.TcGlobals -> t:TypedTree.Expr -> bool + val CanGeneralizeConstrainedTyparsForDecl: + declKind:DeclKind -> GeneralizeConstrainedTyparOptions + val TrimUngeneralizableTypars: + genConstrainedTyparFlag:GeneralizeConstrainedTyparOptions -> + inlineFlag:TypedTree.ValInline -> + generalizedTypars:TypedTree.Typar list -> + freeInEnv:AbstractIL.Internal.Zset -> + TypedTree.Typar list * AbstractIL.Internal.Zset + val CondenseTypars: + cenv:TcFileState * denv:TypedTreeOps.DisplayEnv * + generalizedTypars:TypedTree.Typars * tauTy:TypedTree.TType * + m:Range.range -> TypedTree.Typar list + val ComputeAndGeneralizeGenericTypars: + cenv:TcFileState * denv:TypedTreeOps.DisplayEnv * m:Range.range * + freeInEnv:TypedTree.FreeTypars * canInferTypars:bool * + genConstrainedTyparFlag:GeneralizeConstrainedTyparOptions * + inlineFlag:TypedTree.ValInline * exprOpt:TypedTree.Expr option * + allDeclaredTypars:TypedTree.Typars * maxInferredTypars:TypedTree.Typars * + tauTy:TypedTree.TType * resultFirst:bool -> TypedTree.Typars + val CheckDeclaredTyparsPermitted: + memFlagsOpt:SyntaxTree.MemberFlags option * declaredTypars:'a list * + m:Range.range -> unit + val ComputeCanInferExtraGeneralizableTypars: + parentRef:TypedTree.ParentRef * canInferTypars:bool * + memFlagsOpt:SyntaxTree.MemberFlags option -> bool + + val ComputeInlineFlag: + memFlagsOption:SyntaxTree.MemberFlags option -> + isInline:bool -> isMutable:bool -> m:Range.range -> TypedTree.ValInline + type NormalizedBindingRhs = + | NormalizedBindingRhs of + simplePats: SyntaxTree.SynSimplePats list * + returnTyOpt: SyntaxTree.SynBindingReturnInfo option * + rhsExpr: SyntaxTree.SynExpr + val PushOnePatternToRhs: + cenv:cenv -> + isMember:bool -> + p:SyntaxTree.SynPat -> NormalizedBindingRhs -> NormalizedBindingRhs + type NormalizedBindingPatternInfo = + | NormalizedBindingPat of + SyntaxTree.SynPat * NormalizedBindingRhs * SyntaxTree.SynValData * + SyntaxTree.SynValTyparDecls + type NormalizedBinding = + | NormalizedBinding of + visibility: SyntaxTree.SynAccess option * + kind: SyntaxTree.SynBindingKind * mustInline: bool * isMutable: bool * + attribs: SyntaxTree.SynAttribute list * xmlDoc: XmlDoc.XmlDoc * + typars: SyntaxTree.SynValTyparDecls * valSynData: SyntaxTree.SynValData * + pat: SyntaxTree.SynPat * rhsExpr: NormalizedBindingRhs * + mBinding: Range.range * spBinding: SyntaxTree.DebugPointForBinding + type IsObjExprBinding = + | ObjExprBinding + | ValOrMemberBinding + module BindingNormalization = + val private PushMultiplePatternsToRhs: + cenv:cenv -> + isMember:bool -> + ps:SyntaxTree.SynPat list -> + NormalizedBindingRhs -> NormalizedBindingRhs + val private MakeNormalizedStaticOrValBinding: + cenv:cenv -> + isObjExprBinding:IsObjExprBinding -> + id:SyntaxTree.Ident -> + vis:SyntaxTree.SynAccess option -> + typars:SyntaxTree.SynValTyparDecls -> + args:SyntaxTree.SynPat list -> + rhsExpr:NormalizedBindingRhs -> + valSynData:SyntaxTree.SynValData -> + NormalizedBindingPatternInfo + val private MakeNormalizedInstanceMemberBinding: + cenv:cenv -> + thisId:SyntaxTree.Ident -> + memberId:SyntaxTree.Ident -> + toolId:SyntaxTree.Ident option -> + vis:SyntaxTree.SynAccess option -> + m:Range.range -> + typars:SyntaxTree.SynValTyparDecls -> + args:SyntaxTree.SynPat list -> + rhsExpr:NormalizedBindingRhs -> + valSynData:SyntaxTree.SynValData -> + NormalizedBindingPatternInfo + val private NormalizeStaticMemberBinding: + cenv:cenv -> + memberFlags:SyntaxTree.MemberFlags -> + valSynData:SyntaxTree.SynValData -> + id:SyntaxTree.Ident -> + vis:SyntaxTree.SynAccess option -> + typars:SyntaxTree.SynValTyparDecls -> + args:SyntaxTree.SynPat list -> + m:Range.range -> + rhsExpr:NormalizedBindingRhs -> + NormalizedBindingPatternInfo + val private NormalizeInstanceMemberBinding: + cenv:cenv -> + memberFlags:SyntaxTree.MemberFlags -> + valSynData:SyntaxTree.SynValData -> + thisId:SyntaxTree.Ident -> + memberId:SyntaxTree.Ident -> + toolId:SyntaxTree.Ident option -> + vis:SyntaxTree.SynAccess option -> + typars:SyntaxTree.SynValTyparDecls -> + args:SyntaxTree.SynPat list -> + m:Range.range -> + rhsExpr:NormalizedBindingRhs -> + NormalizedBindingPatternInfo + val private NormalizeBindingPattern: + cenv:TcFileState -> + nameResolver:NameResolution.NameResolver -> + isObjExprBinding:IsObjExprBinding -> + env:TcEnv -> + valSynData:SyntaxTree.SynValData -> + pat:SyntaxTree.SynPat -> + rhsExpr:NormalizedBindingRhs -> NormalizedBindingPatternInfo + val NormalizeBinding: + isObjExprBinding:IsObjExprBinding -> + cenv:TcFileState -> + env:TcEnv -> binding:SyntaxTree.SynBinding -> NormalizedBinding + + module EventDeclarationNormalization = + val ConvertSynInfo: + m:Range.range -> SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo + val ConvertMemberFlags: + memberFlags:SyntaxTree.MemberFlags -> SyntaxTree.MemberFlags + val private ConvertMemberFlagsOpt: + m:Range.range -> + memberFlagsOpt:SyntaxTree.MemberFlags option -> + SyntaxTree.MemberFlags option + val private ConvertSynData: + m:Range.range -> + valSynData:SyntaxTree.SynValData -> SyntaxTree.SynValData + val private RenameBindingPattern: + f:(string -> string) -> + declPattern:SyntaxTree.SynPat -> SyntaxTree.SynPat + val GenerateExtraBindings: + cenv:TcFileState -> + bindingAttribs:TypedTree.Attribs * binding:NormalizedBinding -> + NormalizedBinding list + + val FreshenObjectArgType: + cenv:TcFileState -> + m:Range.range -> + rigid:TypedTree.TyparRigidity -> + tcref:TypedTree.TyconRef -> + isExtrinsic:bool -> + declaredTyconTypars:TypedTree.Typar list -> + TypedTree.TType * TypedTree.Typar list * + TypedTreeOps.TyparInst * TypedTree.TType * TypedTree.TType + val TcValEarlyGeneralizationConsistencyCheck: + cenv:TcFileState -> + env:TcEnv -> + v:TypedTree.Val * vrec:TypedTree.ValRecursiveScopeInfo * + tinst:TypedTree.TType list * vty:TypedTree.TType * tau:TypedTree.TType * + m:Range.range -> unit + val TcVal: + checkAttributes:bool -> + cenv:TcFileState -> + env:TcEnv -> + tpenv:'a -> + vref:TypedTree.ValRef -> + optInst:(TypedTree.ValUseFlag * + ('a -> TypedTree.TyparKind list -> + TypedTree.TypeInst * 'a)) option -> + optAfterResolution:NameResolution.AfterResolution option -> + m:Range.range -> + TypedTree.Typar list * TypedTree.Expr * bool * + TypedTree.TType * TypedTree.TType list * 'a + val LightweightTcValForUsingInBuildMethodCall: + g:TcGlobals.TcGlobals -> + vref:TypedTree.ValRef -> + vrefFlags:TypedTree.ValUseFlag -> + vrefTypeInst:TypedTree.TTypes -> + m:Range.range -> TypedTree.Expr * TypedTree.TType + type ApplicableExpr = + | ApplicableExpr of cenv * TypedTree.Expr * bool + with + member + SupplyArgument: e2:TypedTree.Expr * m:Range.range -> ApplicableExpr + member Expr: TypedTree.Expr + member Range: Range.range + member Type: TypedTree.TType + + val MakeApplicableExprNoFlex: + cenv:cenv -> expr:TypedTree.Expr -> ApplicableExpr + val MakeApplicableExprWithFlex: + cenv:TcFileState -> env:TcEnv -> expr:TypedTree.Expr -> ApplicableExpr + val TcRuntimeTypeTest: + isCast:bool -> + isOperator:bool -> + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + m:Range.range -> + tgtTy:TypedTree.TType -> srcTy:TypedTree.TType -> unit + val TcStaticUpcast: + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + m:Range.range -> + tgtTy:TypedTree.TType -> srcTy:TypedTree.TType -> unit + val BuildPossiblyConditionalMethodCall: + cenv:TcFileState -> + env:TcEnv -> + isMutable:TypedTreeOps.Mutates -> + m:Range.range -> + isProp:bool -> + minfo:Infos.MethInfo -> + valUseFlags:TypedTree.ValUseFlag -> + minst:TypedTree.TType list -> + objArgs:TypedTree.Expr list -> + args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType + val TryFindIntrinsicOrExtensionMethInfo: + collectionSettings:NameResolution.ResultCollectionSettings -> + cenv:cenv -> + env:TcEnv -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + nm:string -> ty:TypedTree.TType -> Infos.MethInfo list + val TryFindFSharpSignatureInstanceGetterProperty: + cenv:cenv -> + env:TcEnv -> + m:Range.range -> + nm:string -> + ty:TypedTree.TType -> + sigTys:TypedTree.TType list -> Infos.PropInfo option + val BuildDisposableCleanup: + cenv:cenv -> + env:TcEnv -> m:Range.range -> v:TypedTree.Val -> TypedTree.Expr + val BuildOffsetToStringData: + cenv:cenv -> env:TcEnv -> m:Range.range -> TypedTree.Expr + val BuildILFieldGet: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + objExpr:TypedTree.Expr -> finfo:Infos.ILFieldInfo -> TypedTree.Expr + val private CheckFieldLiteralArg: + finfo:Infos.ILFieldInfo -> argExpr:TypedTree.Expr -> m:Range.range -> unit + val BuildILFieldSet: + g:TcGlobals.TcGlobals -> + m:Range.range -> + objExpr:TypedTree.Expr -> + finfo:Infos.ILFieldInfo -> argExpr:TypedTree.Expr -> TypedTree.Expr + val BuildILStaticFieldSet: + m:Range.range -> + finfo:Infos.ILFieldInfo -> argExpr:TypedTree.Expr -> TypedTree.Expr + val BuildRecdFieldSet: + g:TcGlobals.TcGlobals -> + m:Range.range -> + objExpr:TypedTree.Expr -> + rfinfo:Infos.RecdFieldInfo -> + argExpr:TypedTree.Expr -> TypedTree.Expr + val ( |BinOpExpr|_| ): + SyntaxTree.SynExpr -> + (SyntaxTree.Ident * SyntaxTree.SynExpr * SyntaxTree.SynExpr) option + val ( |SimpleEqualsExpr|_| ): + e:SyntaxTree.SynExpr -> (SyntaxTree.SynExpr * SyntaxTree.SynExpr) option + val TryGetNamedArg: + e:SyntaxTree.SynExpr -> + (bool * SyntaxTree.Ident * SyntaxTree.SynExpr) option + val inline IsNamedArg: e:SyntaxTree.SynExpr -> bool + val GetMethodArgs: + arg:SyntaxTree.SynExpr -> + SyntaxTree.SynExpr list * + (bool * SyntaxTree.Ident * SyntaxTree.SynExpr) list + val CompilePatternForMatch: + cenv:TcFileState -> + env:TcEnv -> + mExpr:Range.range -> + matchm:Range.range -> + warnOnUnused:bool -> + actionOnFailure:PatternMatchCompilation.ActionOnFailure -> + inputVal:TypedTree.Val * generalizedTypars:TypedTree.Typars * + inputExprOpt:TypedTree.Expr option -> + clauses:PatternMatchCompilation.TypedMatchClause list -> + inputTy:TypedTree.TType -> + resultTy:TypedTree.TType -> TypedTree.Expr + val CompilePatternForMatchClauses: + cenv:TcFileState -> + env:TcEnv -> + mExpr:Range.range -> + matchm:Range.range -> + warnOnUnused:bool -> + actionOnFailure:PatternMatchCompilation.ActionOnFailure -> + inputExprOpt:TypedTree.Expr option -> + inputTy:TypedTree.TType -> + resultTy:TypedTree.TType -> + tclauses:PatternMatchCompilation.TypedMatchClause list -> + TypedTree.Val * TypedTree.Expr + val AnalyzeArbitraryExprAsEnumerable: + cenv:cenv -> + env:TcEnv -> + localAlloc:bool -> + m:Range.range -> + exprty:TypedTree.TType -> + expr:TypedTree.Expr -> + TypedTree.Val * TypedTree.Expr * TypedTree.TType * + TypedTree.TType * TypedTree.Expr * TypedTree.TType * + TypedTree.Expr * TypedTree.TType * TypedTree.Expr + val ConvertArbitraryExprToEnumerable: + cenv:cenv -> + ty:TypedTree.TType -> + env:TcEnv -> expr:TypedTree.Expr -> TypedTree.Expr * TypedTree.TType + type InitializationGraphAnalysisState = + | Top + | InnerTop + | DefinitelyStrict + | MaybeLazy + | DefinitelyLazy + type PreInitializationGraphEliminationBinding = + { FixupPoints: RecursiveUseFixupPoints + Binding: TypedTree.Binding } + val EliminateInitializationGraphs: + g:TcGlobals.TcGlobals -> + mustHaveArity:bool -> + denv:TypedTreeOps.DisplayEnv -> + bindings:'Binding list -> + iterBindings:((PreInitializationGraphEliminationBinding list -> + unit) -> 'Binding list -> unit) -> + buildLets:(TypedTree.Binding list -> 'Result) -> + mapBindings:((PreInitializationGraphEliminationBinding list -> + TypedTree.Binding list) -> 'Binding list -> + 'Result list) -> + bindsm:Range.range -> 'Result list + val CheckAndRewriteObjectCtor: + g:TcGlobals.TcGlobals -> + env:TcEnv -> ctorLambdaExpr:TypedTree.Expr -> TypedTree.Expr + val buildApp: + cenv:TcFileState -> + expr:ApplicableExpr -> + resultTy:TypedTree.TType -> + arg:TypedTree.Expr -> + m:Range.range -> ApplicableExpr * TypedTree.TType + type DelayedItem = + | DelayedTypeApp of SyntaxTree.SynType list * Range.range * Range.range + | DelayedApp of + SyntaxTree.ExprAtomicFlag * SyntaxTree.SynExpr * Range.range + | DelayedDotLookup of SyntaxTree.Ident list * Range.range + | DelayedDot + | DelayedSet of SyntaxTree.SynExpr * Range.range + val MakeDelayedSet: e:SyntaxTree.SynExpr * m:Range.range -> DelayedItem + type NewSlotsOK = + | NewSlotsOK + | NoNewSlots + type ImplicitlyBoundTyparsAllowed = + | NewTyparsOKButWarnIfNotRigid + | NewTyparsOK + | NoNewTypars + type CheckConstraints = + | CheckCxs + | NoCheckCxs + type MemberOrValContainerInfo = + | MemberOrValContainerInfo of + tcref: TypedTree.TyconRef * + optIntfSlotTy: (TypedTree.TType * MethodOverrides.SlotImplSet) option * + baseValOpt: TypedTree.Val option * safeInitInfo: SafeInitData * + declaredTyconTypars: TypedTree.Typars + type ContainerInfo = + | ContainerInfo of TypedTree.ParentRef * MemberOrValContainerInfo option + with + member ParentRef: TypedTree.ParentRef + + val ExprContainerInfo: ContainerInfo + type NormalizedRecBindingDefn = + | NormalizedRecBindingDefn of + containerInfo: ContainerInfo * newslotsOk: NewSlotsOK * + declKind: DeclKind * binding: NormalizedBinding + type ValSpecResult = + | ValSpecResult of + altActualParent: TypedTree.ParentRef * + memberInfoOpt: PreValMemberInfo option * id: SyntaxTree.Ident * + enclosingDeclaredTypars: TypedTree.Typars * + declaredTypars: TypedTree.Typars * ty: TypedTree.TType * + partialValReprInfo: PartialValReprInfo * declKind: DeclKind + type RecDefnBindingInfo = + | RecDefnBindingInfo of + containerInfo: ContainerInfo * newslotsOk: NewSlotsOK * + declKind: DeclKind * synBinding: SyntaxTree.SynBinding + type RecursiveBindingInfo = + | RecursiveBindingInfo of + recBindIndex: int * containerInfo: ContainerInfo * + enclosingDeclaredTypars: TypedTree.Typars * + inlineFlag: TypedTree.ValInline * vspec: TypedTree.Val * + explicitTyparInfo: ExplicitTyparInfo * + partialValReprInfo: PartialValReprInfo * + memberInfoOpt: PreValMemberInfo option * + baseValOpt: TypedTree.Val option * safeThisValOpt: TypedTree.Val option * + safeInitInfo: SafeInitData * visibility: SyntaxTree.SynAccess option * + ty: TypedTree.TType * declKind: DeclKind + with + member ContainerInfo: ContainerInfo + member DeclKind: DeclKind + member DeclaredTypars: TypedTree.Typars + member EnclosingDeclaredTypars: TypedTree.Typars + member ExplicitTyparInfo: ExplicitTyparInfo + member Index: int + member Val: TypedTree.Val + + type PreCheckingRecursiveBinding = + { SyntacticBinding: NormalizedBinding + RecBindingInfo: RecursiveBindingInfo } + type PreGeneralizationRecursiveBinding = + { ExtraGeneralizableTypars: TypedTree.Typars + CheckedBinding: CheckedBindingInfo + RecBindingInfo: RecursiveBindingInfo } + type PostGeneralizationRecursiveBinding = + { ValScheme: ValScheme + CheckedBinding: CheckedBindingInfo + RecBindingInfo: RecursiveBindingInfo } + with + member GeneralizedTypars: TypedTree.Typars + + type PostSpecialValsRecursiveBinding = + { ValScheme: ValScheme + Binding: TypedTree.Binding } + val CanInferExtraGeneralizedTyparsForRecBinding: + pgrbind:PreGeneralizationRecursiveBinding -> bool + val GetInstanceMemberThisVariable: + vspec:TypedTree.Val * expr:TypedTree.Expr -> TypedTree.Val option + val TcTyparConstraint: + ridx:int -> + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + c:SyntaxTree.SynTypeConstraint -> UnscopedTyparEnv + val TcPseudoMemberSpec: + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + env:TcEnv -> + synTypes:SyntaxTree.SynType list -> + tpenv:UnscopedTyparEnv -> + memSpfn:SyntaxTree.SynMemberSig -> + m:Range.range -> + TypedTree.TraitConstraintInfo * UnscopedTyparEnv + val TcValSpec: + cenv:TcFileState -> + TcEnv -> + DeclKind -> + ImplicitlyBoundTyparsAllowed -> + ContainerInfo -> + SyntaxTree.MemberFlags option -> + thisTyOpt:TypedTree.TType option -> + UnscopedTyparEnv -> + SyntaxTree.SynValSig -> + TypedTree.Attrib list -> + ValSpecResult list * UnscopedTyparEnv + val TcTyparOrMeasurePar: + optKind:TypedTree.TyparKind option -> + cenv:TcFileState -> + env:TcEnv -> + newOk:ImplicitlyBoundTyparsAllowed -> + tpenv:UnscopedTyparEnv -> + SyntaxTree.SynTypar -> TypedTree.Typar * UnscopedTyparEnv + val TcTypar: + cenv:TcFileState -> + env:TcEnv -> + newOk:ImplicitlyBoundTyparsAllowed -> + tpenv:UnscopedTyparEnv -> + tp:SyntaxTree.SynTypar -> TypedTree.Typar * UnscopedTyparEnv + val TcTyparDecl: + cenv:TcFileState -> + env:TcEnv -> SyntaxTree.SynTyparDecl -> TypedTree.Typar + val TcTyparDecls: + cenv:TcFileState -> + env:TcEnv -> + synTypars:SyntaxTree.SynTyparDecl list -> TypedTree.Typar list + val TcTypeOrMeasure: + optKind:TypedTree.TyparKind option -> + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv + val TcType: + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv + val TcMeasure: + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + SyntaxTree.SynType -> + m:Range.range -> TypedTree.Measure * UnscopedTyparEnv + val TcAnonTypeOrMeasure: + optKind:TypedTree.TyparKind option -> + _cenv:TcFileState -> + rigid:TypedTree.TyparRigidity -> + dyn:TypedTree.TyparDynamicReq -> + newOk:ImplicitlyBoundTyparsAllowed -> + m:Range.range -> TypedTree.Typar + val TcTypes: + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + args:SyntaxTree.SynType list -> + TypedTree.TType list * UnscopedTyparEnv + val TcTypesAsTuple: + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + args:(bool * SyntaxTree.SynType) list -> + m:Range.range -> TypedTree.TTypes * UnscopedTyparEnv + val TcMeasuresAsTuple: + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + args:(bool * SyntaxTree.SynType) list -> + m:Range.range -> TypedTree.Measure * UnscopedTyparEnv + val TcTypesOrMeasures: + optKinds:TypedTree.TyparKind list option -> + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + args:SyntaxTree.SynType list -> + m:Range.range -> TypedTree.TType list * UnscopedTyparEnv + val TcTyparConstraints: + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + synConstraints:SyntaxTree.SynTypeConstraint list -> + UnscopedTyparEnv + val TcStaticConstantParameter: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + kind:TypedTree.TType -> + SyntaxTree.SynType -> + idOpt:SyntaxTree.Ident option -> + container:NameResolution.ArgumentContainer -> + obj * UnscopedTyparEnv + val CrackStaticConstantArgs: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + staticParameters:Tainted [] * + args:SyntaxTree.SynType list * + container:NameResolution.ArgumentContainer * + containerName:System.String * m:Range.range -> obj [] + val TcProvidedTypeAppToStaticConstantArgs: + cenv:TcFileState -> + env:TcEnv -> + optGeneratedTypePath:string list option -> + tpenv:UnscopedTyparEnv -> + tcref:TypedTree.TyconRef -> + args:SyntaxTree.SynType list -> + m:Range.range -> + bool * Tainted * + (unit -> unit) + val TryTcMethodAppToStaticConstantArgs: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + minfos:Infos.MethInfo list * + argsOpt:(SyntaxTree.SynType list * 'a) option * + mExprAndArg:Range.range * mItem:Range.range -> Infos.MethInfo option + val TcProvidedMethodAppToStaticConstantArgs: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + minfo:Infos.MethInfo * + methBeforeArguments:Tainted * + staticParams:Tainted [] * + args:SyntaxTree.SynType list * m:Range.range -> + Tainted + val TcProvidedTypeApp: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + tcref:TypedTree.TyconRef -> + args:SyntaxTree.SynType list -> + m:Range.range -> TypedTree.TType * UnscopedTyparEnv + val TcTypeApp: + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + m:Range.range -> + tcref:TypedTree.TyconRef -> + pathTypeArgs:NameResolution.EnclosingTypeInst -> + synArgTys:SyntaxTree.SynType list -> + TypedTree.TType * UnscopedTyparEnv + val TcTypeOrMeasureAndRecover: + optKind:TypedTree.TyparKind option -> + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv + val TcTypeAndRecover: + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv + val TcNestedTypeApplication: + cenv:TcFileState -> + newOk:ImplicitlyBoundTyparsAllowed -> + checkCxs:CheckConstraints -> + occ:NameResolution.ItemOccurence -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + mWholeTypeApp:Range.range -> + ty:TypedTree.TType -> + pathTypeArgs:NameResolution.EnclosingTypeInst -> + tyargs:SyntaxTree.SynType list -> + TypedTree.TType * UnscopedTyparEnv + val TryAdjustHiddenVarNameToCompGenName: + cenv:TcFileState -> + env:TcEnv -> + id:SyntaxTree.Ident -> + altNameRefCellOpt:Ref option -> + SyntaxTree.Ident option + val TcSimplePat: + optArgsOK:bool -> + checkCxs:CheckConstraints -> + cenv:TcFileState -> + ty:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv * names:Map * + takenNames:Set -> + p:SyntaxTree.SynSimplePat -> + string * + (UnscopedTyparEnv * Map * + Set) + val ValidateOptArgOrder: spats:SyntaxTree.SynSimplePats -> unit + val TcSimplePats: + cenv:TcFileState -> + optArgsOK:bool -> + checkCxs:CheckConstraints -> + ty:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv * names:Map * + takenNames:Set -> + p:SyntaxTree.SynSimplePats -> + string list * + (UnscopedTyparEnv * Map * + Set) + val TcSimplePatsOfUnknownType: + cenv:TcFileState -> + optArgsOK:bool -> + checkCxs:CheckConstraints -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + spats:SyntaxTree.SynSimplePats -> + string list * + (UnscopedTyparEnv * Map * Set) + val TcPatBindingName: + cenv:TcFileState -> + env:TcEnv -> + id:SyntaxTree.Ident -> + ty:TypedTree.TType -> + isMemberThis:bool -> + vis1:SyntaxTree.SynAccess option -> + topValData:PartialValReprInfo option -> + inlineFlag:TypedTree.ValInline * + declaredTypars:ExplicitTyparInfo * + argAttribs:ArgAndRetAttribs * isMutable:bool * + vis2:SyntaxTree.SynAccess option * compgen:bool -> + names:Map * + takenNames:Set -> + (TcPatPhase2Input -> + PatternMatchCompilation.PatternValBinding) * + Map * Set + val TcPatAndRecover: + warnOnUpper:NameResolution.WarnOnUpperFlag -> + cenv:TcFileState -> + env:TcEnv -> + topValInfo:PartialValReprInfo option -> + TypedTree.ValInline * ExplicitTyparInfo * ArgAndRetAttribs * bool * + SyntaxTree.SynAccess option * bool -> + tpenv:UnscopedTyparEnv * names:Map * + takenNames:Set -> + ty:TypedTree.TType -> + pat:SyntaxTree.SynPat -> + (TcPatPhase2Input -> PatternMatchCompilation.Pattern) * + (UnscopedTyparEnv * Map * + Set) + val TcPat: + warnOnUpper:NameResolution.WarnOnUpperFlag -> + cenv:TcFileState -> + env:TcEnv -> + topValInfo:PartialValReprInfo option -> + TypedTree.ValInline * ExplicitTyparInfo * ArgAndRetAttribs * bool * + SyntaxTree.SynAccess option * bool -> + tpenv:UnscopedTyparEnv * names:Map * + takenNames:Set -> + ty:TypedTree.TType -> + pat:SyntaxTree.SynPat -> + (TcPatPhase2Input -> PatternMatchCompilation.Pattern) * + (UnscopedTyparEnv * Map * + Set) + val TcPatterns: + warnOnUpper:NameResolution.WarnOnUpperFlag -> + cenv:TcFileState -> + env:TcEnv -> + TypedTree.ValInline * ExplicitTyparInfo * ArgAndRetAttribs * bool * + SyntaxTree.SynAccess option * bool -> + UnscopedTyparEnv * Map * Set -> + argTys:TypedTree.TType list -> + args:SyntaxTree.SynPat list -> + (TcPatPhase2Input -> PatternMatchCompilation.Pattern) list * + (UnscopedTyparEnv * Map * + Set) + val solveTypAsError: + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + m:Range.range -> ty:TypedTree.TType -> unit + val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects: + cenv:TcFileState -> + env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> unit + val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects_Delayed: + cenv:TcFileState -> + env:TcEnv -> tpenv:UnscopedTyparEnv -> delayed:DelayedItem list -> unit + val UnifyTypesAndRecover: + cenv:TcFileState -> + env:TcEnv -> + m:Range.range -> + expectedTy:TypedTree.TType -> actualTy:TypedTree.TType -> unit + val TcExprOfUnknownType: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + expr:SyntaxTree.SynExpr -> + TypedTree.Expr * TypedTree.TType * UnscopedTyparEnv + val TcExprFlex: + cenv:TcFileState -> + flex:bool -> + compat:bool -> + ty:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + e:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv + val TcExpr: + cenv:TcFileState -> + ty:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv + val TcExprNoRecover: + cenv:TcFileState -> + ty:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv + val TcExprOfUnknownTypeThen: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + expr:SyntaxTree.SynExpr -> + delayed:DelayedItem list -> + TypedTree.Expr * TypedTree.TType * UnscopedTyparEnv + val TcExprThatIsCtorBody: + TypedTree.Val option * SafeInitData -> + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv + val TcExprThatCanBeCtorBody: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv + val TcExprThatCantBeCtorBody: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv + val TcStmtThatCantBeCtorBody: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv + val TcStmt: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + synExpr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv + val TryTcStmt: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + synExpr:SyntaxTree.SynExpr -> + bool * TypedTree.Expr * UnscopedTyparEnv + val TcExprThen: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + synExpr:SyntaxTree.SynExpr -> + delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv + val TcExprs: + cenv:TcFileState -> + env:TcEnv -> + m:Range.range -> + tpenv:UnscopedTyparEnv -> + flexes:bool list -> + argTys:TypedTree.TType list -> + args:SyntaxTree.SynExpr list -> + TypedTree.Expr list * UnscopedTyparEnv + val CheckSuperInit: + cenv:TcFileState -> objTy:TypedTree.TType -> m:Range.range -> unit + val TcExprUndelayedNoType: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + synExpr:SyntaxTree.SynExpr -> + TypedTree.Expr * TypedTree.TType * UnscopedTyparEnv + val TcExprUndelayed: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + synExpr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv + val TcIteratedLambdas: + cenv:TcFileState -> + isFirst:bool -> + env:TcEnv -> + overallTy:TypedTree.TType -> + takenNames:Set -> + tpenv:UnscopedTyparEnv -> + e:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv + val TcIndexerThen: + cenv:TcFileState -> + env:TcEnv -> + overallTy:TypedTree.TType -> + mWholeExpr:Range.range -> + mDot:Range.range -> + tpenv:UnscopedTyparEnv -> + wholeExpr:SyntaxTree.SynExpr -> + e1:SyntaxTree.SynExpr -> + indexArgs:SyntaxTree.SynIndexerArg list -> + delayed:DelayedItem list -> + TypedTree.Expr * UnscopedTyparEnv + val TcNewExpr: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + objTy:TypedTree.TType -> + mObjTyOpt:Range.range option -> + superInit:bool -> + arg:SyntaxTree.SynExpr -> + mWholeExprOrObjTy:Range.range -> + TypedTree.Expr * UnscopedTyparEnv + val TcCtorCall: + isNaked:bool -> + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + overallTy:TypedTree.TType -> + objTy:TypedTree.TType -> + mObjTyOpt:Range.range option -> + item:NameResolution.Item -> + superInit:bool -> + args:SyntaxTree.SynExpr list -> + mWholeCall:Range.range -> + delayed:DelayedItem list -> + afterTcOverloadResolutionOpt:NameResolution.AfterResolution option -> + TypedTree.Expr * UnscopedTyparEnv + val TcRecordConstruction: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + optOrigExprInfo:(TypedTree.Expr * TypedTree.Val * TypedTree.Expr) option -> + objTy:TypedTree.TType -> + fldsList:seq -> + m:Range.range -> TypedTree.Expr * UnscopedTyparEnv + val GetNameAndArityOfObjExprBinding: + _cenv:'b -> + _env:'c -> b:NormalizedBinding -> string * SyntaxTree.SynValInfo + val FreshenObjExprAbstractSlot: + cenv:TcFileState -> + env:TcEnv -> + implty:TypedTree.TType -> + virtNameAndArityPairs:((string * 'd) * Infos.MethInfo) list -> + bind:NormalizedBinding * bindAttribs:TypedTree.Attribs * + bindName:string * absSlots:('e * Infos.MethInfo) list -> + (bool * TypedTree.Typars * TypedTree.TType) option + val TcObjectExprBinding: + cenv:cenv -> + env:TcEnv -> + implty:TypedTree.TType -> + tpenv:UnscopedTyparEnv -> + absSlotInfo:(bool * TypedTree.Typars * TypedTree.TType) option * + bind:NormalizedBinding -> + (SyntaxTree.Ident * SyntaxTree.MemberFlags * TypedTree.TType * + TypedTree.Attribs * TypedTree.Expr) * UnscopedTyparEnv + val ComputeObjectExprOverrides: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + impls:(Range.range * TypedTree.TType * SyntaxTree.SynBinding list) list -> + (Range.range * TypedTree.TType * MethodOverrides.RequiredSlot list * + AbstractIL.Internal.Library.NameMultiMap * + MethodOverrides.OverrideInfo list * + (MethodOverrides.OverrideInfo * + (TypedTree.Val option * TypedTree.Val * TypedTree.Val list list * + TypedTree.Attribs * TypedTree.Expr)) list) list * + UnscopedTyparEnv + val CheckSuperType: + cenv:TcFileState -> ty:TypedTree.TType -> m:Range.range -> unit + val TcObjectExpr: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + synObjTy:SyntaxTree.SynType * + argopt:(SyntaxTree.SynExpr * SyntaxTree.Ident option) option * + binds:SyntaxTree.SynBinding list * + extraImpls:SyntaxTree.SynInterfaceImpl list * mNewExpr:Range.range * + mWholeExpr:Range.range -> TypedTree.Expr * UnscopedTyparEnv + val TcConstStringExpr: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + m:Range.range -> + tpenv:UnscopedTyparEnv -> + s:string -> TypedTree.Expr * UnscopedTyparEnv + val TcFormatStringExpr: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + m:Range.range -> + tpenv:UnscopedTyparEnv -> + fmtString:string -> TypedTree.Expr * UnscopedTyparEnv + val TcInterpolatedStringExpr: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + m:Range.range -> + tpenv:UnscopedTyparEnv -> + parts:SyntaxTree.SynInterpolatedStringPart list -> + TypedTree.Expr * UnscopedTyparEnv + val TcConstExpr: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + m:Range.range -> + tpenv:UnscopedTyparEnv -> + c:SyntaxTree.SynConst -> TypedTree.Expr * UnscopedTyparEnv + val TcAssertExpr: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + m:Range.range -> + tpenv:UnscopedTyparEnv -> + x:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv + val TcRecdExpr: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + inherits:(SyntaxTree.SynType * SyntaxTree.SynExpr * Range.range * + SyntaxTree.BlockSeparator option * Range.range) option * + optOrigExpr:(SyntaxTree.SynExpr * SyntaxTree.BlockSeparator) option * + flds:(SyntaxTree.RecordFieldName * SyntaxTree.SynExpr option * + SyntaxTree.BlockSeparator option) list * + mWholeExpr:Range.range -> TypedTree.Expr * UnscopedTyparEnv + val TcAnonRecdExpr: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + isStruct:bool * + optOrigSynExpr:(SyntaxTree.SynExpr * SyntaxTree.BlockSeparator) option * + unsortedFieldIdsAndSynExprsGiven:(SyntaxTree.Ident * + SyntaxTree.SynExpr) list * + mWholeExpr:Range.range -> TypedTree.Expr * UnscopedTyparEnv + val TcForEachExpr: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + pat:SyntaxTree.SynPat * enumSynExpr:SyntaxTree.SynExpr * + bodySynExpr:SyntaxTree.SynExpr * mWholeExpr:Range.range * + spForLoop:SyntaxTree.DebugPointAtFor -> + TypedTree.Expr * UnscopedTyparEnv + val TcQuotationExpr: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + _oper:SyntaxTree.SynExpr * raw:bool * ast:SyntaxTree.SynExpr * + isFromQueryExpression:bool * m:Range.range -> + TypedTree.Expr * UnscopedTyparEnv + val Propagate: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + expr:ApplicableExpr -> + exprty:TypedTree.TType -> delayed:DelayedItem list -> unit + val PropagateThenTcDelayed: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + mExpr:Range.range -> + expr:ApplicableExpr -> + exprty:TypedTree.TType -> + atomicFlag:SyntaxTree.ExprAtomicFlag -> + delayed:DelayedItem list -> + TypedTree.Expr * UnscopedTyparEnv + val TcDelayed: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + mExpr:Range.range -> + expr:ApplicableExpr -> + exprty:TypedTree.TType -> + atomicFlag:SyntaxTree.ExprAtomicFlag -> + delayed:DelayedItem list -> + TypedTree.Expr * UnscopedTyparEnv + val delayRest: + rest:SyntaxTree.Ident list -> + mPrior:Range.range -> delayed:DelayedItem list -> DelayedItem list + val TcNameOfExpr: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> synArg:SyntaxTree.SynExpr -> TypedTree.Expr + val TcNameOfExprResult: + cenv:TcFileState -> + lastIdent:SyntaxTree.Ident -> m:Range.range -> TypedTree.Expr + val TcFunctionApplicationThen: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + mExprAndArg:Range.range -> + expr:ApplicableExpr -> + exprty:TypedTree.TType -> + synArg:SyntaxTree.SynExpr -> + atomicFlag:SyntaxTree.ExprAtomicFlag -> + delayed:DelayedItem list -> + TypedTree.Expr * UnscopedTyparEnv + val GetLongIdentTypeNameInfo: + delayed:DelayedItem list -> NameResolution.TypeNameResolutionInfo + val TcLongIdentThen: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + SyntaxTree.LongIdentWithDots -> + delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv + val TcItemThen: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + tinstEnclosing:NameResolution.EnclosingTypeInst * + item:NameResolution.Item * mItem:Range.range * + rest:SyntaxTree.Ident list * + afterResolution:NameResolution.AfterResolution -> + delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv + val GetSynMemberApplicationArgs: + delayed:DelayedItem list -> + tpenv:'f -> + SyntaxTree.ExprAtomicFlag * + (SyntaxTree.SynType list * Range.range) option * + SyntaxTree.SynExpr list * DelayedItem list * 'f + val TcMemberTyArgsOpt: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + tyargsOpt:(SyntaxTree.SynType list * Range.range) option -> + TypedTree.TType list option * UnscopedTyparEnv + val GetMemberApplicationArgs: + delayed:DelayedItem list -> + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + SyntaxTree.ExprAtomicFlag * TypedTree.TType list option * + SyntaxTree.SynExpr list * DelayedItem list * UnscopedTyparEnv + val TcLookupThen: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + mObjExpr:Range.range -> + objExpr:TypedTree.Expr -> + objExprTy:TypedTree.TType -> + longId:SyntaxTree.Ident list -> + delayed:DelayedItem list -> + mExprAndLongId:Range.range -> + TypedTree.Expr * UnscopedTyparEnv + val TcEventValueThen: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + mItem:Range.range -> + mExprAndItem:Range.range -> + objDetails:(TypedTree.Expr * TypedTree.TType) option -> + einfo:Infos.EventInfo -> + delayed:DelayedItem list -> + TypedTree.Expr * UnscopedTyparEnv + val TcMethodApplicationThen: + cenv:TcFileState -> + env:TcEnv -> + overallTy:TypedTree.TType -> + objTyOpt:TypedTree.TType option -> + tpenv:UnscopedTyparEnv -> + callerTyArgs:TypedTree.TType list option -> + objArgs:TypedTree.Expr list -> + m:Range.range -> + mItem:Range.range -> + methodName:string -> + ad:AccessibilityLogic.AccessorDomain -> + mut:TypedTreeOps.Mutates -> + isProp:bool -> + meths:(Infos.MethInfo * Infos.PropInfo option) list -> + afterResolution:NameResolution.AfterResolution -> + isSuperInit:TypedTree.ValUseFlag -> + args:SyntaxTree.SynExpr list -> + atomicFlag:SyntaxTree.ExprAtomicFlag -> + delayed:DelayedItem list -> + TypedTree.Expr * UnscopedTyparEnv + val GetNewInferenceTypeForMethodArg: + cenv:TcFileState -> + env:'g -> tpenv:'h -> x:SyntaxTree.SynExpr -> TypedTree.TType + val TcMethodApplication: + isCheckingAttributeCall:bool -> + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + tyargsOpt:TypedTree.TType list option -> + objArgs:TypedTree.Expr list -> + mMethExpr:Range.range -> + mItem:Range.range -> + methodName:string -> + objTyOpt:TypedTree.TType option -> + ad:AccessibilityLogic.AccessorDomain -> + mut:TypedTreeOps.Mutates -> + isProp:bool -> + calledMethsAndProps:(Infos.MethInfo * + Infos.PropInfo option) list -> + afterResolution:NameResolution.AfterResolution -> + isSuperInit:TypedTree.ValUseFlag -> + curriedCallerArgs:SyntaxTree.SynExpr list -> + exprTy:TypedTree.TType -> + delayed:DelayedItem list -> + (TypedTree.Expr * + MethodCalls.CallerNamedArg list * + DelayedItem list) * + UnscopedTyparEnv + val TcSetterArgExpr: + cenv:TcFileState -> + env:TcEnv -> + denv:TypedTreeOps.DisplayEnv -> + objExpr:TypedTree.Expr -> + ad:AccessibilityLogic.AccessorDomain -> + MethodCalls.AssignedItemSetter -> + (TypedTree.Expr -> TypedTree.Expr) option * TypedTree.Expr * + Range.range + val TcUnnamedMethodArgs: + cenv:TcFileState -> + env:TcEnv -> + lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * + (SyntaxTree.Ident * + MethodCalls.ArgumentAnalysis) [] []) [] -> + tpenv:UnscopedTyparEnv -> + args:MethodCalls.CallerArg list list -> + MethodCalls.CallerArg list list * + ((MethodCalls.ArgumentAnalysis [] [] * + (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * + UnscopedTyparEnv) + val TcUnnamedMethodArg: + cenv:TcFileState -> + env:TcEnv -> + lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * + (SyntaxTree.Ident * + MethodCalls.ArgumentAnalysis) [] []) [] * + tpenv:UnscopedTyparEnv -> + i:int * j:int * MethodCalls.CallerArg -> + MethodCalls.CallerArg * + ((MethodCalls.ArgumentAnalysis [] [] * + (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * + UnscopedTyparEnv) + val TcMethodNamedArgs: + cenv:TcFileState -> + env:TcEnv -> + lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * + (SyntaxTree.Ident * + MethodCalls.ArgumentAnalysis) [] []) [] -> + tpenv:UnscopedTyparEnv -> + args:MethodCalls.CallerNamedArg list list -> + MethodCalls.CallerNamedArg list list * + ((MethodCalls.ArgumentAnalysis [] [] * + (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * + UnscopedTyparEnv) + val TcMethodNamedArg: + cenv:TcFileState -> + env:TcEnv -> + lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * + (SyntaxTree.Ident * + MethodCalls.ArgumentAnalysis) [] []) [] * + tpenv:UnscopedTyparEnv -> + MethodCalls.CallerNamedArg -> + MethodCalls.CallerNamedArg * + ((MethodCalls.ArgumentAnalysis [] [] * + (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * + UnscopedTyparEnv) + val TcMethodArg: + cenv:TcFileState -> + env:TcEnv -> + lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * + (SyntaxTree.Ident * + MethodCalls.ArgumentAnalysis) [] []) [] * + tpenv:UnscopedTyparEnv -> + lambdaPropagationInfoForArg:MethodCalls.ArgumentAnalysis [] * + MethodCalls.CallerArg -> + MethodCalls.CallerArg * + ((MethodCalls.ArgumentAnalysis [] [] * + (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * + UnscopedTyparEnv) + val TcNewDelegateThen: + cenv:TcFileState -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + mDelTy:Range.range -> + mExprAndArg:Range.range -> + delegateTy:TypedTree.TType -> + arg:SyntaxTree.SynExpr -> + atomicFlag:SyntaxTree.ExprAtomicFlag -> + delayed:DelayedItem list -> + TypedTree.Expr * UnscopedTyparEnv + val bindLetRec: + binds:TypedTree.Bindings -> + m:Range.range -> e:TypedTree.Expr -> TypedTree.Expr + val CheckRecursiveBindingIds: binds:seq -> unit + val TcLinearExprs: + bodyChecker:(TypedTree.TType -> TcEnv -> UnscopedTyparEnv -> + SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv) -> + cenv:TcFileState -> + env:TcEnv -> + overallTy:TypedTree.TType -> + tpenv:UnscopedTyparEnv -> + isCompExpr:bool -> + expr:SyntaxTree.SynExpr -> + cont:(TypedTree.Expr * UnscopedTyparEnv -> + TypedTree.Expr * UnscopedTyparEnv) -> + TypedTree.Expr * UnscopedTyparEnv + val TcAndPatternCompileMatchClauses: + mExpr:Range.range -> + matchm:Range.range -> + actionOnFailure:PatternMatchCompilation.ActionOnFailure -> + cenv:TcFileState -> + inputExprOpt:TypedTree.Expr option -> + inputTy:TypedTree.TType -> + resultTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + synClauses:SyntaxTree.SynMatchClause list -> + TypedTree.Val * TypedTree.Expr * UnscopedTyparEnv + val TcMatchPattern: + cenv:TcFileState -> + inputTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + pat:SyntaxTree.SynPat * optWhenExpr:SyntaxTree.SynExpr option -> + PatternMatchCompilation.Pattern * TypedTree.Expr option * + TypedTree.Val list * TcEnv * UnscopedTyparEnv + val TcMatchClauses: + cenv:TcFileState -> + inputTy:TypedTree.TType -> + resultTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + clauses:SyntaxTree.SynMatchClause list -> + PatternMatchCompilation.TypedMatchClause list * + UnscopedTyparEnv + val TcMatchClause: + cenv:TcFileState -> + inputTy:TypedTree.TType -> + resultTy:TypedTree.TType -> + env:TcEnv -> + isFirst:bool -> + tpenv:UnscopedTyparEnv -> + SyntaxTree.SynMatchClause -> + PatternMatchCompilation.TypedMatchClause * UnscopedTyparEnv + val TcStaticOptimizationConstraint: + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + c:SyntaxTree.SynStaticOptimizationConstraint -> + TypedTree.StaticOptimization * UnscopedTyparEnv + val mkConvToNativeInt: + g:TcGlobals.TcGlobals -> + e:TypedTree.Expr -> m:Range.range -> TypedTree.Expr + val TcAndBuildFixedExpr: + cenv:TcFileState -> + env:TcEnv -> + overallPatTy:TypedTree.TType * fixedExpr:TypedTree.Expr * + overallExprTy:TypedTree.TType * mBinding:Range.range -> TypedTree.Expr + val TcNormalizedBinding: + declKind:DeclKind -> + cenv:cenv -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + overallTy:TypedTree.TType -> + safeThisValOpt:TypedTree.Val option -> + safeInitInfo:SafeInitData -> + enclosingDeclaredTypars:TypedTree.Typar list * + ExplicitTyparInfo -> + bind:NormalizedBinding -> + CheckedBindingInfo * UnscopedTyparEnv + val TcLiteral: + cenv:cenv -> + overallTy:TypedTree.TType -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + attrs:TypedTree.Attribs * synLiteralValExpr:SyntaxTree.SynExpr -> + bool * TypedTree.Const option + val TcBindingTyparDecls: + alwaysRigid:bool -> + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + SyntaxTree.SynValTyparDecls -> + ExplicitTyparInfo * UnscopedTyparEnv + val TcNonrecBindingTyparDecls: + cenv:cenv -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + bind:NormalizedBinding -> ExplicitTyparInfo * UnscopedTyparEnv + val TcNonRecursiveBinding: + declKind:DeclKind -> + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + ty:TypedTree.TType -> + b:SyntaxTree.SynBinding -> CheckedBindingInfo * UnscopedTyparEnv + val TcAttribute: + canFail:bool -> + cenv:TcFileState -> + env:TcEnv -> + attrTgt:System.AttributeTargets -> + synAttr:SyntaxTree.SynAttribute -> + (System.AttributeTargets * TypedTree.Attrib) list * bool + val TcAttributesWithPossibleTargets: + canFail:bool -> + cenv:TcFileState -> + env:TcEnv -> + attrTgt:System.AttributeTargets -> + synAttribs:SyntaxTree.SynAttribute list -> + (System.AttributeTargets * TypedTree.Attrib) list * bool + val TcAttributesMaybeFail: + canFail:bool -> + cenv:TcFileState -> + env:TcEnv -> + attrTgt:System.AttributeTargets -> + synAttribs:SyntaxTree.SynAttribute list -> + TypedTree.Attrib list * bool + val TcAttributesCanFail: + cenv:TcFileState -> + env:TcEnv -> + attrTgt:System.AttributeTargets -> + synAttribs:SyntaxTree.SynAttribute list -> + TypedTree.Attrib list * (unit -> TypedTree.Attribs) + val TcAttributes: + cenv:TcFileState -> + env:TcEnv -> + attrTgt:System.AttributeTargets -> + synAttribs:SyntaxTree.SynAttribute list -> TypedTree.Attribs + val TcLetBinding: + cenv:TcFileState -> + isUse:bool -> + env:TcEnv -> + containerInfo:ContainerInfo -> + declKind:DeclKind -> + tpenv:UnscopedTyparEnv -> + synBinds:SyntaxTree.SynBinding list * + synBindsRange:Range.range * scopem:Range.range -> + (TypedTree.Expr * TypedTree.TType -> + TypedTree.Expr * TypedTree.TType) * TcEnv * + UnscopedTyparEnv + val TcLetBindings: + cenv:TcFileState -> + env:TcEnv -> + containerInfo:ContainerInfo -> + declKind:DeclKind -> + tpenv:UnscopedTyparEnv -> + binds:SyntaxTree.SynBinding list * bindsm:Range.range * + scopem:Range.range -> + TypedTree.ModuleOrNamespaceExpr list * TcEnv * + UnscopedTyparEnv + val CheckMemberFlags: + optIntfSlotTy:'a option -> + newslotsOK:NewSlotsOK -> + overridesOK:OverridesOK -> + memberFlags:SyntaxTree.MemberFlags -> m:Range.range -> unit + val ApplyTypesFromArgumentPatterns: + cenv:TcFileState * env:TcEnv * optArgsOK:bool * ty:TypedTree.TType * + m:Range.range * tpenv:UnscopedTyparEnv * NormalizedBindingRhs * + memberFlagsOpt:SyntaxTree.MemberFlags option -> unit + val ComputeIsComplete: + enclosingDeclaredTypars:TypedTree.Typar list -> + declaredTypars:TypedTree.Typar list -> ty:TypedTree.TType -> bool + val ApplyAbstractSlotInference: + cenv:cenv -> + envinner:TcEnv -> + bindingTy:TypedTree.TType * m:Range.range * + synTyparDecls:SyntaxTree.SynValTyparDecls * + declaredTypars:TypedTree.Typars * memberId:SyntaxTree.Ident * + tcrefObjTy:TypedTree.TType * renaming:TypedTreeOps.TyparInst * + _objTy:'i * + optIntfSlotTy:(TypedTree.TType * MethodOverrides.SlotImplSet) option * + valSynData:SyntaxTree.SynValInfo * memberFlags:SyntaxTree.MemberFlags * + attribs:TypedTree.Attribs -> TypedTree.TType list * TypedTree.Typars + val CheckForNonAbstractInterface: + declKind:DeclKind -> + tcref:TypedTree.TyconRef -> + memberFlags:SyntaxTree.MemberFlags -> m:Range.range -> unit + val AnalyzeRecursiveStaticMemberOrValDecl: + cenv:TcFileState * envinner:TcEnv * tpenv:'j * declKind:DeclKind * + newslotsOK:NewSlotsOK * overridesOK:OverridesOK * + tcrefContainerInfo:MemberOrValContainerInfo option * vis1:'k option * + id:SyntaxTree.Ident * vis2:'k option * declaredTypars:'l * + memberFlagsOpt:SyntaxTree.MemberFlags option * + thisIdOpt:SyntaxTree.Ident option * bindingAttribs:TypedTree.Attribs * + valSynInfo:SyntaxTree.SynValInfo * ty:TypedTree.TType * bindingRhs:'m * + mBinding:Range.range * explicitTyparInfo:'n -> + TcEnv * 'j * SyntaxTree.Ident * 'o option * PreValMemberInfo option * + 'k option * 'k option * TypedTree.Val option * TypedTree.Typar list * + TypedTree.Val option * 'n * 'm * 'l + val AnalyzeRecursiveInstanceMemberDecl: + cenv:cenv * envinner:TcEnv * tpenv:'p * declKind:DeclKind * + synTyparDecls:SyntaxTree.SynValTyparDecls * + valSynInfo:SyntaxTree.SynValInfo * explicitTyparInfo:ExplicitTyparInfo * + newslotsOK:NewSlotsOK * overridesOK:OverridesOK * vis1:'q option * + thisId:SyntaxTree.Ident * memberId:SyntaxTree.Ident * + toolId:SyntaxTree.Ident option * bindingAttribs:TypedTree.Attribs * + vis2:'q option * tcrefContainerInfo:MemberOrValContainerInfo option * + memberFlagsOpt:SyntaxTree.MemberFlags option * ty:TypedTree.TType * + bindingRhs:NormalizedBindingRhs * mBinding:Range.range -> + TcEnv * 'p * SyntaxTree.Ident * SyntaxTree.Ident option * + PreValMemberInfo option * 'q option * 'q option * 'r option * + TypedTree.Typar list * TypedTree.Val option * ExplicitTyparInfo * + NormalizedBindingRhs * TypedTree.Typars + val AnalyzeRecursiveDecl: + cenv:TcFileState * envinner:TcEnv * tpenv:UnscopedTyparEnv * + declKind:DeclKind * synTyparDecls:SyntaxTree.SynValTyparDecls * + declaredTypars:TypedTree.Typars * thisIdOpt:SyntaxTree.Ident option * + valSynInfo:SyntaxTree.SynValInfo * explicitTyparInfo:ExplicitTyparInfo * + newslotsOK:NewSlotsOK * overridesOK:OverridesOK * + vis1:SyntaxTree.SynAccess option * declPattern:SyntaxTree.SynPat * + bindingAttribs:TypedTree.Attribs * + tcrefContainerInfo:MemberOrValContainerInfo option * + memberFlagsOpt:SyntaxTree.MemberFlags option * ty:TypedTree.TType * + bindingRhs:NormalizedBindingRhs * mBinding:Range.range -> + TcEnv * UnscopedTyparEnv * SyntaxTree.Ident * SyntaxTree.Ident option * + PreValMemberInfo option * SyntaxTree.SynAccess option * + SyntaxTree.SynAccess option * TypedTree.Val option * + TypedTree.Typar list * TypedTree.Val option * ExplicitTyparInfo * + NormalizedBindingRhs * TypedTree.Typars + val AnalyzeAndMakeAndPublishRecursiveValue: + overridesOK:OverridesOK -> + isGeneratedEventVal:bool -> + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv * recBindIdx:int -> + NormalizedRecBindingDefn -> + (PreCheckingRecursiveBinding list * TypedTree.Val list) * + (UnscopedTyparEnv * int) + val AnalyzeAndMakeAndPublishRecursiveValues: + overridesOK:OverridesOK -> + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + binds:NormalizedRecBindingDefn list -> + PreCheckingRecursiveBinding list * TypedTree.Val list * + (UnscopedTyparEnv * int) + val TcLetrecBinding: + cenv:TcFileState * envRec:TcEnv * scopem:Range.range * + extraGeneralizableTypars:TypedTree.Typars * + reqdThisValTyOpt:TypedTree.TType option -> + envNonRec:TcEnv * + generalizedRecBinds:PostGeneralizationRecursiveBinding list * + preGeneralizationRecBinds:PreGeneralizationRecursiveBinding list * + tpenv:UnscopedTyparEnv * + uncheckedRecBindsTable:Map -> + rbind:PreCheckingRecursiveBinding -> + TcEnv * PostGeneralizationRecursiveBinding list * + PreGeneralizationRecursiveBinding list * UnscopedTyparEnv * + Map + val TcIncrementalLetRecGeneralization: + cenv:TcFileState -> + scopem:Range.range -> + envNonRec:TcEnv * + generalizedRecBinds:PostGeneralizationRecursiveBinding list * + preGeneralizationRecBinds:PreGeneralizationRecursiveBinding list * + tpenv:UnscopedTyparEnv * + uncheckedRecBindsTable:Map -> + TcEnv * PostGeneralizationRecursiveBinding list * + PreGeneralizationRecursiveBinding list * UnscopedTyparEnv * + Map + val TcLetrecComputeAndGeneralizeGenericTyparsForBinding: + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + freeInEnv:Internal.Utilities.Collections.Tagged.Set> -> + pgrbind:PreGeneralizationRecursiveBinding -> TypedTree.Typar list + val TcLetrecComputeSupportForBinding: + cenv:TcFileState -> + pgrbind:PreGeneralizationRecursiveBinding -> TypedTree.Typar list + val TcLetrecGeneralizeBinding: + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + generalizedTypars:TypedTree.Typar list -> + pgrbind:PreGeneralizationRecursiveBinding -> + PostGeneralizationRecursiveBinding + val TcLetrecComputeCtorSafeThisValBind: + cenv:TcFileState -> + safeThisValOpt:TypedTree.Val option -> TypedTree.Binding option + val MakeCheckSafeInitField: + g:TcGlobals.TcGlobals -> + tinst:TypedTree.TypeInst -> + thisValOpt:TypedTree.Val option -> + rfref:TypedTree.RecdFieldRef -> + reqExpr:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr + val MakeCheckSafeInit: + g:TcGlobals.TcGlobals -> + tinst:TypedTree.TypeInst -> + safeInitInfo:SafeInitData -> + reqExpr:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr + val TcLetrecAdjustMemberForSpecialVals: + cenv:TcFileState -> + pgrbind:PostGeneralizationRecursiveBinding -> + PostSpecialValsRecursiveBinding + val FixupLetrecBind: + cenv:TcFileState -> + denv:TypedTreeOps.DisplayEnv -> + generalizedTyparsForRecursiveBlock:TypedTree.Typars -> + bind:PostSpecialValsRecursiveBinding -> + PreInitializationGraphEliminationBinding + val unionGeneralizedTypars: + typarSets:TypedTree.Typar list list -> TypedTree.Typar list + val TcLetrec: + overridesOK:OverridesOK -> + cenv:TcFileState -> + env:TcEnv -> + tpenv:UnscopedTyparEnv -> + binds:RecDefnBindingInfo list * bindsm:Range.range * + scopem:Range.range -> + TypedTree.Bindings * TcEnv * UnscopedTyparEnv + val TcAndPublishValSpec: + cenv:TcFileState * env:TcEnv * containerInfo:ContainerInfo * + declKind:DeclKind * memFlagsOpt:SyntaxTree.MemberFlags option * + tpenv:UnscopedTyparEnv * valSpfn:SyntaxTree.SynValSig -> + TypedTree.Val list * UnscopedTyparEnv + + +namespace FSharp.Compiler + module internal CheckComputationExpressions = + type cenv = CheckExpressions.TcFileState + type CompExprTranslationPass = + | Initial + | Subsequent + type CustomOperationsMode = + | Allowed + | Denied + val TryFindIntrinsicOrExtensionMethInfo: + collectionSettings:NameResolution.ResultCollectionSettings -> + cenv:cenv -> + env:CheckExpressions.TcEnv -> + m:Range.range -> + ad:AccessibilityLogic.AccessorDomain -> + nm:string -> ty:TypedTree.TType -> Infos.MethInfo list + val IgnoreAttribute: 'a -> 'b option + val ( |ExprAsPat|_| ): f:SyntaxTree.SynExpr -> SyntaxTree.SynPat option + val ( |JoinRelation|_| ): + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + e:SyntaxTree.SynExpr -> + (SyntaxTree.SynExpr * SyntaxTree.SynExpr) option + val elimFastIntegerForLoop: + spBind:SyntaxTree.DebugPointAtFor * id:SyntaxTree.Ident * + start:SyntaxTree.SynExpr * dir:bool * finish:SyntaxTree.SynExpr * + innerExpr:SyntaxTree.SynExpr * m:Range.range -> SyntaxTree.SynExpr + val YieldFree: cenv:cenv -> expr:SyntaxTree.SynExpr -> bool + val ( |SimpleSemicolonSequence|_| ): + cenv:cenv -> + acceptDeprecated:bool -> + cexpr:SyntaxTree.SynExpr -> SyntaxTree.SynExpr list option + val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + expr:SyntaxTree.SynExpr -> unit + val TcComputationExpression: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + overallTy:TypedTree.TType -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + mWhole:Range.range * interpExpr:TypedTree.Expr * + builderTy:TypedTree.TType * comp:SyntaxTree.SynExpr -> + TypedTree.Expr * CheckExpressions.UnscopedTyparEnv + val mkSeqEmpty: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + m:Range.range -> genTy:TypedTree.TType -> TypedTree.Expr + val mkSeqCollect: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + m:Range.range -> + enumElemTy:TypedTree.TType -> + genTy:TypedTree.TType -> + lam:TypedTree.Expr -> enumExpr:TypedTree.Expr -> TypedTree.Expr + val mkSeqUsing: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + m:Range.range -> + resourceTy:TypedTree.TType -> + genTy:TypedTree.TType -> + resourceExpr:TypedTree.Expr -> + lam:TypedTree.Expr -> TypedTree.Expr + val mkSeqDelay: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + m:Range.range -> + genTy:TypedTree.TType -> lam:TypedTree.Expr -> TypedTree.Expr + val mkSeqAppend: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + m:Range.range -> + genTy:TypedTree.TType -> + e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr + val mkSeqFromFunctions: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + m:Range.range -> + genTy:TypedTree.TType -> + e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr + val mkSeqFinally: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + m:Range.range -> + genTy:TypedTree.TType -> + e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr + val mkSeqExprMatchClauses: + pat':PatternMatchCompilation.Pattern * vspecs:TypedTree.Val list -> + innerExpr:TypedTree.Expr -> + PatternMatchCompilation.TypedMatchClause list + val compileSeqExprMatchClauses: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + inputExprMark:Range.range -> + pat:PatternMatchCompilation.Pattern * vspecs:TypedTree.Val list -> + innerExpr:TypedTree.Expr -> + inputExprOpt:TypedTree.Expr option -> + bindPatTy:TypedTree.TType -> + genInnerTy:TypedTree.TType -> TypedTree.Val * TypedTree.Expr + val TcSequenceExpression: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + comp:SyntaxTree.SynExpr -> + overallTy:TypedTree.TType -> + m:Range.range -> + TypedTree.Expr * CheckExpressions.UnscopedTyparEnv + val TcSequenceExpressionEntry: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + overallTy:TypedTree.TType -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + isArrayOrList:bool * isNotNakedRefCell:bool ref * + comp:SyntaxTree.SynExpr -> + m:Range.range -> + TypedTree.Expr * CheckExpressions.UnscopedTyparEnv + val TcArrayOrListSequenceExpression: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + overallTy:TypedTree.TType -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + isArray:bool * comp:SyntaxTree.SynExpr -> + m:Range.range -> + TypedTree.Expr * CheckExpressions.UnscopedTyparEnv + + +namespace FSharp.Compiler + module internal CheckDeclarations = + type cenv = CheckExpressions.TcFileState + type MutRecDataForOpen = + | MutRecDataForOpen of + SyntaxTree.SynOpenDeclTarget * Range.range * appliedScope: Range.range + type MutRecDataForModuleAbbrev = + | MutRecDataForModuleAbbrev of + SyntaxTree.Ident * SyntaxTree.LongIdent * Range.range + [] + type MutRecShape<'TypeData,'LetsData,'ModuleData> = + | Tycon of 'TypeData + | Lets of 'LetsData + | Module of 'ModuleData * MutRecShapes<'TypeData,'LetsData,'ModuleData> + | ModuleAbbrev of MutRecDataForModuleAbbrev + | Open of MutRecDataForOpen + and MutRecShapes<'TypeData,'LetsData,'ModuleData> = + MutRecShape<'TypeData,'LetsData,'ModuleData> list + module MutRecShapes = + val map: + f1:('a -> 'b) -> + f2:('c -> 'd) -> + f3:('e -> 'f) -> + x:MutRecShape<'a,'c,'e> list -> MutRecShape<'b,'d,'f> list + val mapTycons: + f1:('a -> 'b) -> + xs:MutRecShape<'a,'c,'d> list -> MutRecShape<'b,'c,'d> list + val mapTyconsAndLets: + f1:('a -> 'b) -> + f2:('c -> 'd) -> + xs:MutRecShape<'a,'c,'e> list -> MutRecShape<'b,'d,'e> list + val mapLets: + f2:('a -> 'b) -> + xs:MutRecShape<'c,'a,'d> list -> MutRecShape<'c,'b,'d> list + val mapModules: + f1:('a -> 'b) -> + xs:MutRecShape<'c,'d,'a> list -> MutRecShape<'c,'d,'b> list + val mapWithEnv: + fTycon:('Env -> 'a -> 'b) -> + fLets:('Env -> 'c -> 'd) -> + env:'Env -> + x:MutRecShape<'a,'c,('e * 'Env)> list -> + MutRecShape<'b,'d,('e * 'Env)> list + val mapTyconsWithEnv: + f1:('a -> 'b -> 'c) -> + env:'a -> + xs:MutRecShape<'b,'d,('e * 'a)> list -> + MutRecShape<'c,'d,('e * 'a)> list + val mapWithParent: + parent:'a -> + f1:('a -> 'b -> MutRecShapes<'c,'d,'b> -> 'e * 'a) -> + f2:('a -> 'c -> 'f) -> + f3:('a -> 'd -> 'g) -> + xs:MutRecShape<'c,'d,'b> list -> MutRecShape<'f,'g,'e> list + val computeEnvs: + f1:('a -> 'b -> 'Env) -> + f2:('Env -> MutRecShape<'c,'d,'b> list -> 'a) -> + env:'Env -> + xs:MutRecShape<'c,'d,'b> list -> + 'a * MutRecShape<'c,'d,('b * 'a)> list + val extendEnvs: + f1:('Env -> MutRecShape<'a,'b,('c * 'Env)> list -> 'Env) -> + env:'Env -> + xs:MutRecShape<'a,'b,('c * 'Env)> list -> + 'Env * MutRecShape<'a,'b,('c * 'Env)> list + val dropEnvs: + xs:MutRecShape<'a,'b,('c * 'd)> list -> MutRecShape<'a,'b,'c> list + val expandTyconsWithEnv: + f1:('a -> 'b -> 'c list * 'c list) -> + env:'a -> + xs:MutRecShape<'b,'c list,('d * 'a)> list -> + MutRecShape<'b,'c list,('d * 'a)> list + val mapFoldWithEnv: + f1:('a -> 'b -> MutRecShape<'c,'d,('e * 'b)> -> + MutRecShape<'f,'g,('e * 'b)> * 'a) -> + z:'a -> + env:'b -> + xs:MutRecShape<'c,'d,('e * 'b)> list -> + MutRecShape<'f,'g,('e * 'b)> list * 'a + val collectTycons: x:MutRecShape<'a,'b,'c> list -> 'a list + val topTycons: x:MutRecShape<'a,'b,'c> list -> 'a list + val iter: + f1:('a -> unit) -> + f2:('b -> unit) -> + f3:('c -> unit) -> + f4:(MutRecDataForOpen -> unit) -> + f5:(MutRecDataForModuleAbbrev -> unit) -> + x:MutRecShape<'a,'b,'c> list -> unit + val iterTycons: f1:('a -> unit) -> x:MutRecShape<'a,'b,'c> list -> unit + val iterTyconsAndLets: + f1:('a -> unit) -> + f2:('b -> unit) -> x:MutRecShape<'a,'b,'c> list -> unit + val iterModules: f1:('a -> unit) -> x:MutRecShape<'b,'c,'a> list -> unit + val iterWithEnv: + f1:('a -> 'b -> unit) -> + f2:('a -> 'c -> unit) -> + f3:('a -> MutRecDataForOpen -> unit) -> + f4:('a -> MutRecDataForModuleAbbrev -> unit) -> + env:'a -> x:MutRecShape<'b,'c,('d * 'a)> list -> unit + val iterTyconsWithEnv: + f1:('a -> 'b -> unit) -> + env:'a -> xs:MutRecShape<'b,'c,('d * 'a)> list -> unit + + val ModuleOrNamespaceContainerInfo: + modref:TypedTree.EntityRef -> CheckExpressions.ContainerInfo + val TyconContainerInfo: + parent:TypedTree.ParentRef * tcref:TypedTree.TyconRef * + declaredTyconTypars:TypedTree.Typars * + safeInitInfo:CheckExpressions.SafeInitData -> + CheckExpressions.ContainerInfo + type TyconBindingDefn = + | TyconBindingDefn of + CheckExpressions.ContainerInfo * CheckExpressions.NewSlotsOK * + CheckExpressions.DeclKind * SyntaxTree.SynMemberDefn * Range.range + type MutRecSigsInitialData = + MutRecShape list + type MutRecDefnsInitialData = + MutRecShape list + type MutRecDefnsPhase1DataForTycon = + | MutRecDefnsPhase1DataForTycon of + SyntaxTree.SynComponentInfo * SyntaxTree.SynTypeDefnSimpleRepr * + (SyntaxTree.SynType * Range.range) list * + preEstablishedHasDefaultCtor: bool * hasSelfReferentialCtor: bool * + isAtOriginalTyconDefn: bool + type MutRecDefnsPhase1Data = + MutRecShape<(MutRecDefnsPhase1DataForTycon * SyntaxTree.SynMemberDefn list), + CheckExpressions.RecDefnBindingInfo list, + SyntaxTree.SynComponentInfo> list + type MutRecDefnsPhase2DataForTycon = + | MutRecDefnsPhase2DataForTycon of + TypedTree.Tycon option * TypedTree.ParentRef * CheckExpressions.DeclKind * + TypedTree.TyconRef * TypedTree.Val option * + CheckExpressions.SafeInitData * TypedTree.Typars * + SyntaxTree.SynMemberDefn list * Range.range * + CheckExpressions.NewSlotsOK * fixupFinalAttribs: unit -> unit + type MutRecDefnsPhase2DataForModule = + | MutRecDefnsPhase2DataForModule of + TypedTree.ModuleOrNamespaceType ref * TypedTree.ModuleOrNamespace + type MutRecDefnsPhase2Data = + MutRecShape list + type MutRecDefnsPhase2InfoForTycon = + | MutRecDefnsPhase2InfoForTycon of + TypedTree.Tycon option * TypedTree.TyconRef * TypedTree.Typars * + CheckExpressions.DeclKind * TyconBindingDefn list * + fixupFinalAttrs: unit -> unit + type MutRecDefnsPhase2Info = + MutRecShape list + val AddLocalExnDefnAndReport: + tcSink:NameResolution.TcResultsSink -> + scopem:Range.range -> + env:CheckExpressions.TcEnv -> + exnc:TypedTree.Tycon -> CheckExpressions.TcEnv + val AddLocalTyconRefs: + ownDefinition:bool -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + tcrefs:TypedTree.TyconRef list -> + env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv + val AddLocalTycons: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + tycons:TypedTree.Tycon list -> + env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv + val AddLocalTyconsAndReport: + tcSink:NameResolution.TcResultsSink -> + scopem:Range.range -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + tycons:TypedTree.Tycon list -> + env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv + val AddLocalSubModule: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + env:CheckExpressions.TcEnv -> + modul:TypedTree.ModuleOrNamespace -> CheckExpressions.TcEnv + val AddLocalSubModuleAndReport: + tcSink:NameResolution.TcResultsSink -> + scopem:Range.range -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + env:CheckExpressions.TcEnv -> + modul:TypedTree.ModuleOrNamespace -> CheckExpressions.TcEnv + val BuildRootModuleType: + enclosingNamespacePath:SyntaxTree.Ident list -> + cpath:TypedTree.CompilationPath -> + mtyp:TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType * TypedTree.ModuleOrNamespace list + val BuildRootModuleExpr: + enclosingNamespacePath:SyntaxTree.Ident list -> + cpath:TypedTree.CompilationPath -> + mexpr:TypedTree.ModuleOrNamespaceExpr -> + TypedTree.ModuleOrNamespaceExpr + val TryStripPrefixPath: + g:TcGlobals.TcGlobals -> + enclosingNamespacePath:SyntaxTree.Ident list -> + (SyntaxTree.Ident * SyntaxTree.Ident list) option + val AddModuleAbbreviationAndReport: + tcSink:NameResolution.TcResultsSink -> + scopem:Range.range -> + id:SyntaxTree.Ident -> + modrefs:TypedTree.ModuleOrNamespaceRef list -> + env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv + val OpenModuleOrNamespaceRefs: + tcSink:NameResolution.TcResultsSink -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + scopem:Range.range -> + root:bool -> + env:CheckExpressions.TcEnv -> + mvvs:TypedTree.ModuleOrNamespaceRef list -> + openDeclaration:NameResolution.OpenDeclaration -> + CheckExpressions.TcEnv + val OpenTypeContent: + tcSink:NameResolution.TcResultsSink -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + scopem:Range.range -> + env:CheckExpressions.TcEnv -> + typ:TypedTree.TType -> + openDeclaration:NameResolution.OpenDeclaration -> + CheckExpressions.TcEnv + val AddRootModuleOrNamespaceRefs: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + env:CheckExpressions.TcEnv -> + modrefs:TypedTree.ModuleOrNamespaceRef list -> + CheckExpressions.TcEnv + val addInternalsAccessibility: + env:CheckExpressions.TcEnv -> + ccu:TypedTree.CcuThunk -> CheckExpressions.TcEnv + val AddNonLocalCcu: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + scopem:Range.range -> + env:CheckExpressions.TcEnv -> + assemblyName:string -> + ccu:TypedTree.CcuThunk * + internalsVisibleToAttributes:string list -> + CheckExpressions.TcEnv + val AddLocalRootModuleOrNamespace: + NameResolution.TcResultsSink -> + TcGlobals.TcGlobals -> + Import.ImportMap -> + Range.range -> + CheckExpressions.TcEnv -> + TypedTree.ModuleOrNamespaceType -> CheckExpressions.TcEnv + val ImplicitlyOpenOwnNamespace: + tcSink:NameResolution.TcResultsSink -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + scopem:Range.range -> + enclosingNamespacePath:SyntaxTree.Ident list -> + env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv + exception NotUpperCaseConstructor of Range.range + val CheckNamespaceModuleOrTypeName: + g:TcGlobals.TcGlobals -> id:SyntaxTree.Ident -> unit + val CheckDuplicates: + idf:('a -> SyntaxTree.Ident) -> k:string -> elems:'a list -> 'a list + module TcRecdUnionAndEnumDeclarations = + val CombineReprAccess: + parent:TypedTree.ParentRef -> + vis:TypedTree.Accessibility -> TypedTree.Accessibility + val MakeRecdFieldSpec: + _cenv:'a -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + isStatic:bool * konst:TypedTree.Const option * ty':TypedTree.TType * + attrsForProperty:TypedTree.Attribs * + attrsForField:TypedTree.Attribs * id:SyntaxTree.Ident * + nameGenerated:bool * isMutable:bool * vol:bool * + xmldoc:XmlDoc.XmlDoc * vis:SyntaxTree.SynAccess option * + m:Range.range -> TypedTree.RecdField + val TcFieldDecl: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + isIncrClass:bool -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + isStatic:bool * synAttrs:SyntaxTree.SynAttribute list * + id:SyntaxTree.Ident * nameGenerated:bool * + ty:SyntaxTree.SynType * isMutable:bool * xmldoc:XmlDoc.XmlDoc * + vis:SyntaxTree.SynAccess option * m:Range.range -> + TypedTree.RecdField + val TcAnonFieldDecl: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + nm:string -> SyntaxTree.SynField -> TypedTree.RecdField + val TcNamedFieldDecl: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + isIncrClass:bool -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + SyntaxTree.SynField -> TypedTree.RecdField + val TcNamedFieldDecls: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + isIncrClass:bool -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + fields:SyntaxTree.SynField list -> TypedTree.RecdField list + val CheckUnionCaseName: cenv:cenv -> id:SyntaxTree.Ident -> unit + val ValidateFieldNames: + synFields:SyntaxTree.SynField list * tastFields:TypedTree.RecdField list -> + unit + val TcUnionCaseDecl: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + thisTy:TypedTree.TType -> + thisTyInst:TypedTree.TypeInst -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + SyntaxTree.SynUnionCase -> TypedTree.UnionCase + val TcUnionCaseDecls: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + thisTy:TypedTree.TType -> + thisTyInst:TypedTree.TypeInst -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + unionCases:SyntaxTree.SynUnionCase list -> + TypedTree.UnionCase list + val TcEnumDecl: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + thisTy:TypedTree.TType -> + fieldTy:TypedTree.TType -> + SyntaxTree.SynEnumCase -> TypedTree.RecdField + val TcEnumDecls: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + thisTy:TypedTree.TType -> + enumCases:SyntaxTree.SynEnumCase list -> + TypedTree.TType * TypedTree.RecdField list + + val PublishInterface: + cenv:cenv -> + denv:TypedTreeOps.DisplayEnv -> + tcref:TypedTree.TyconRef -> + m:Range.range -> compgen:bool -> ty':TypedTree.TType -> unit + val TcAndPublishMemberSpec: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + containerInfo:CheckExpressions.ContainerInfo -> + declKind:CheckExpressions.DeclKind -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + memb:SyntaxTree.SynMemberSig -> + TypedTree.Val list * CheckExpressions.UnscopedTyparEnv + val TcTyconMemberSpecs: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + containerInfo:CheckExpressions.ContainerInfo -> + declKind:CheckExpressions.DeclKind -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + augSpfn:SyntaxTree.SynMemberSig list -> + TypedTree.Val list * CheckExpressions.UnscopedTyparEnv + val TcOpenLidAndPermitAutoResolve: + tcSink:NameResolution.TcResultsSink -> + env:CheckExpressions.TcEnv -> + amap:Import.ImportMap -> + longId:SyntaxTree.Ident list -> + (int * TypedTree.ModuleOrNamespaceRef * + TypedTree.ModuleOrNamespaceType) list + val TcOpenModuleOrNamespaceDecl: + NameResolution.TcResultsSink -> + TcGlobals.TcGlobals -> + Import.ImportMap -> + Range.range -> + CheckExpressions.TcEnv -> + (SyntaxTree.Ident list * Range.range) -> CheckExpressions.TcEnv + val TcOpenTypeDecl: + cenv:cenv -> + mOpenDecl:Range.range -> + scopem:Range.range -> + env:CheckExpressions.TcEnv -> + synType:SyntaxTree.SynType * m:Range.range -> + CheckExpressions.TcEnv + val TcOpenDecl: + cenv:CheckExpressions.TcFileState -> + mOpenDecl:Range.range -> + scopem:Range.range -> + env:CheckExpressions.TcEnv -> + target:SyntaxTree.SynOpenDeclTarget -> CheckExpressions.TcEnv + exception ParameterlessStructCtor of Range.range + val MakeSafeInitField: + g:TcGlobals.TcGlobals -> + env:CheckExpressions.TcEnv -> + m:Range.range -> isStatic:bool -> TypedTree.RecdField + module IncrClassChecking = + type IncrClassBindingGroup = + | IncrClassBindingGroup of TypedTree.Binding list * bool * bool + | IncrClassDo of TypedTree.Expr * bool + type IncrClassCtorLhs = + { TyconRef: TypedTree.TyconRef + InstanceCtorDeclaredTypars: TypedTree.Typars + StaticCtorValInfo: + System.Lazy + InstanceCtorVal: TypedTree.Val + InstanceCtorValScheme: CheckExpressions.ValScheme + InstanceCtorArgs: TypedTree.Val list + InstanceCtorSafeThisValOpt: TypedTree.Val option + InstanceCtorSafeInitInfo: CheckExpressions.SafeInitData + InstanceCtorBaseValOpt: TypedTree.Val option + InstanceCtorThisVal: TypedTree.Val + NameGenerator: CompilerGlobalState.NiceNameGenerator } + with + member + GetNormalizedInstanceCtorDeclaredTypars: cenv:cenv -> + denv:TypedTreeOps.DisplayEnv -> + m:Range.range -> + TypedTree.Typar list + + val TcImplicitCtorLhs_Phase2A: + cenv:cenv * env:CheckExpressions.TcEnv * + tpenv:CheckExpressions.UnscopedTyparEnv * tcref:TypedTree.TyconRef * + vis:SyntaxTree.SynAccess option * attrs:SyntaxTree.SynAttribute list * + spats:SyntaxTree.SynSimplePat list * thisIdOpt:SyntaxTree.Ident option * + baseValOpt:TypedTree.Val option * + safeInitInfo:CheckExpressions.SafeInitData * m:Range.range * + copyOfTyconTypars:TypedTree.Typar list * objTy:TypedTree.TType * + thisTy:TypedTree.TType * doc:XmlDoc.PreXmlDoc -> IncrClassCtorLhs + val private MakeIncrClassField: + g:TcGlobals.TcGlobals * cpath:TypedTree.CompilationPath * + formalTyparInst:TypedTreeOps.TyparInst * v:TypedTree.Val * isStatic:bool * + rfref:TypedTree.RecdFieldRef -> TypedTree.RecdField + type IncrClassValRepr = + | InVar of bool + | InField of bool * int * TypedTree.RecdFieldRef + | InMethod of bool * TypedTree.Val * TypedTree.ValReprInfo + type IncrClassReprInfo = + { TakenFieldNames: Set + RepInfoTcGlobals: TcGlobals.TcGlobals + ValReprs: AbstractIL.Internal.Zmap + ValsWithRepresentation: AbstractIL.Internal.Zset } + with + static member + Empty: g:TcGlobals.TcGlobals * names:string list -> + IncrClassReprInfo + static member + IsMethodRepr: cenv:cenv -> bind:TypedTree.Binding -> bool + member + ChooseAndAddRepresentation: cenv:cenv * env:CheckExpressions.TcEnv * + isStatic:bool * isCtorArg:bool * + ctorInfo:IncrClassCtorLhs * + staticForcedFieldVars:TypedTree.FreeLocals * + instanceForcedFieldVars:TypedTree.FreeLocals * + bind:TypedTree.Binding -> + IncrClassReprInfo + member + ChooseRepresentation: cenv:cenv * env:CheckExpressions.TcEnv * + isStatic:bool * isCtorArg:bool * + ctorInfo:IncrClassCtorLhs * + staticForcedFieldVars:TypedTree.FreeLocals * + instanceForcedFieldVars:TypedTree.FreeLocals * + takenFieldNames:Set * + bind:TypedTree.Binding -> + IncrClassValRepr * Set + member + FixupIncrClassExprPhase2C: cenv:CheckExpressions.TcFileState -> + thisValOpt:TypedTree.Val option -> + safeStaticInitInfo:CheckExpressions.SafeInitData -> + thisTyInst:TypedTree.TypeInst -> + expr:TypedTree.Expr -> + TypedTree.Expr + member IsValRepresentedAsLocalVar: v:TypedTree.Val -> bool + member IsValRepresentedAsMethod: v:TypedTree.Val -> bool + member IsValWithRepresentation: v:TypedTree.Val -> bool + member LookupRepr: v:TypedTree.Val -> IncrClassValRepr + member + MakeValueAssign: thisValOpt:TypedTree.Val option -> + tinst:TypedTree.TypeInst -> + safeStaticInitInfo:CheckExpressions.SafeInitData -> + v:TypedTree.Val -> + expr:TypedTree.Expr -> + m:Range.range -> TypedTree.Expr + member + MakeValueGetAddress: readonly:bool -> + thisValOpt:TypedTree.Val option -> + tinst:TypedTree.TypeInst -> + safeStaticInitInfo:CheckExpressions.SafeInitData -> + v:TypedTree.Val -> + m:Range.range -> TypedTree.Expr + member + MakeValueLookup: thisValOpt:TypedTree.Val option -> + tinst:TypedTree.TypeInst -> + safeStaticInitInfo:CheckExpressions.SafeInitData -> + v:TypedTree.Val -> + tyargs:TypedTree.TType list -> + m:Range.range -> TypedTree.Expr + member + PublishIncrClassFields: cenv:cenv * denv:TypedTreeOps.DisplayEnv * + cpath:TypedTree.CompilationPath * + ctorInfo:IncrClassCtorLhs * + safeStaticInitInfo:CheckExpressions.SafeInitData -> + unit + member ValNowWithRepresentation: v:TypedTree.Val -> IncrClassReprInfo + + type IncrClassConstructionBindingsPhase2C = + | Phase2CBindings of IncrClassBindingGroup list + | Phase2CCtorJustAfterSuperInit + | Phase2CCtorJustAfterLastLet + val MakeCtorForIncrClassConstructionPhase2C: + cenv:cenv * env:CheckExpressions.TcEnv * ctorInfo:IncrClassCtorLhs * + inheritsExpr:TypedTree.Expr * inheritsIsVisible:bool * + decs:IncrClassConstructionBindingsPhase2C list * + memberBinds:TypedTree.Binding list * + generalizedTyparsForRecursiveBlock:TypedTree.Typar list * + safeStaticInitInfo:CheckExpressions.SafeInitData -> + TypedTree.Expr * TypedTree.Expr option * TypedTree.Binding list * + IncrClassReprInfo + + module MutRecBindingChecking = + type TyconBindingPhase2A = + | Phase2AIncrClassCtor of IncrClassChecking.IncrClassCtorLhs + | Phase2AInherit of + SyntaxTree.SynType * SyntaxTree.SynExpr * TypedTree.Val option * + Range.range + | Phase2AIncrClassBindings of + TypedTree.TyconRef * SyntaxTree.SynBinding list * bool * bool * + Range.range + | Phase2AMember of CheckExpressions.PreCheckingRecursiveBinding + | Phase2AIncrClassCtorJustAfterSuperInit + | Phase2AIncrClassCtorJustAfterLastLet + type TyconBindingsPhase2A = + | TyconBindingsPhase2A of + TypedTree.Tycon option * CheckExpressions.DeclKind * + TypedTree.Val list * TypedTree.TyconRef * TypedTree.Typar list * + TypedTree.TType * TyconBindingPhase2A list + type MutRecDefnsPhase2AData = + MutRecShape list + type TyconBindingPhase2B = + | Phase2BIncrClassCtor of + IncrClassChecking.IncrClassCtorLhs * TypedTree.Binding option + | Phase2BInherit of TypedTree.Expr * TypedTree.Val option + | Phase2BIncrClassBindings of + IncrClassChecking.IncrClassBindingGroup list + | Phase2BMember of int + | Phase2BIncrClassCtorJustAfterSuperInit + | Phase2BIncrClassCtorJustAfterLastLet + type TyconBindingsPhase2B = + | TyconBindingsPhase2B of + TypedTree.Tycon option * TypedTree.TyconRef * TyconBindingPhase2B list + type MutRecDefnsPhase2BData = + MutRecShape list + type TyconBindingPhase2C = + | Phase2CIncrClassCtor of + IncrClassChecking.IncrClassCtorLhs * TypedTree.Binding option + | Phase2CInherit of TypedTree.Expr * TypedTree.Val option + | Phase2CIncrClassBindings of + IncrClassChecking.IncrClassBindingGroup list + | Phase2CMember of + CheckExpressions.PreInitializationGraphEliminationBinding + | Phase2CIncrClassCtorJustAfterSuperInit + | Phase2CIncrClassCtorJustAfterLastLet + type TyconBindingsPhase2C = + | TyconBindingsPhase2C of + TypedTree.Tycon option * TypedTree.TyconRef * TyconBindingPhase2C list + type MutRecDefnsPhase2CData = + MutRecShape list + val TcMutRecBindings_Phase2A_CreateRecursiveValuesAndCheckArgumentPatterns + : + cenv:cenv -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + envMutRec:CheckExpressions.TcEnv * mutRecDefns:MutRecDefnsPhase2Info -> + MutRecDefnsPhase2AData * + CheckExpressions.PreCheckingRecursiveBinding list * + CheckExpressions.UnscopedTyparEnv + val TcMutRecBindings_Phase2B_TypeCheckAndIncrementalGeneralization: + cenv:cenv -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + envInitial:CheckExpressions.TcEnv -> + envMutRec:CheckExpressions.TcEnv * defnsAs:MutRecDefnsPhase2AData * + uncheckedRecBinds:CheckExpressions.PreCheckingRecursiveBinding list * + scopem:Range.range -> + MutRecDefnsPhase2BData * + CheckExpressions.PostGeneralizationRecursiveBinding list * + CheckExpressions.UnscopedTyparEnv + val TcMutRecBindings_Phase2C_FixupRecursiveReferences: + cenv:cenv -> + denv:TypedTreeOps.DisplayEnv * defnsBs:MutRecDefnsPhase2BData * + generalizedTyparsForRecursiveBlock:TypedTree.Typar list * + generalizedRecBinds:CheckExpressions.PostGeneralizationRecursiveBinding list * + scopem:Range.range -> + MutRecShape list + val TcMutRecBindings_Phase2D_ExtractImplicitFieldAndMethodBindings: + cenv:cenv -> + envMutRec:CheckExpressions.TcEnv -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + denv:TypedTreeOps.DisplayEnv * + generalizedTyparsForRecursiveBlock:TypedTree.Typar list * + defnsCs:MutRecDefnsPhase2CData -> + MutRecShape<(TypedTree.Tycon option * + CheckExpressions.PreInitializationGraphEliminationBinding list * + TypedTree.Binding list), + CheckExpressions.PreInitializationGraphEliminationBinding list, + (MutRecDefnsPhase2DataForModule * + CheckExpressions.TcEnv)> list + val TcModuleAbbrevDecl: + cenv:cenv -> + scopem:Range.range -> + env:CheckExpressions.TcEnv -> + id:SyntaxTree.Ident * p:SyntaxTree.Ident list * m:Range.range -> + CheckExpressions.TcEnv + val TcMutRecDefns_UpdateNSContents: + mutRecNSInfo:(TypedTree.ModuleOrNamespace option * + TypedTree.ModuleOrNamespaceType ref) option -> unit + val TcMutRecDefns_UpdateModuleContents: + mutRecNSInfo:(TypedTree.ModuleOrNamespace option * + TypedTree.ModuleOrNamespaceType ref) option -> + defns:MutRecShape<'a,'b,(MutRecDefnsPhase2DataForModule * 'c)> list -> + unit + val TcMutRecDefns_ComputeEnvs: + getTyconOpt:('a -> TypedTree.Tycon option) -> + getVals:('b -> TypedTree.Val list) -> + cenv:cenv -> + report:bool -> + scopem:Range.range -> + m:Range.range -> + envInitial:CheckExpressions.TcEnv -> + mutRecShape:MutRecShape<'a,'b, + MutRecDefnsPhase2DataForModule> list -> + CheckExpressions.TcEnv * + MutRecShape<'a,'b, + (MutRecDefnsPhase2DataForModule * + CheckExpressions.TcEnv)> list + val TcMutRecDefns_Phase2_Bindings: + cenv:cenv -> + envInitial:CheckExpressions.TcEnv -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + bindsm:Range.range -> + scopem:Range.range -> + mutRecNSInfo:(TypedTree.ModuleOrNamespace option * + TypedTree.ModuleOrNamespaceType ref) option -> + envMutRecPrelimWithReprs:CheckExpressions.TcEnv -> + mutRecDefns:MutRecDefnsPhase2Info -> + MutRecShape<(TypedTree.Tycon option * + TypedTree.Binding list), + TypedTree.Binding list, + (MutRecDefnsPhase2DataForModule * + CheckExpressions.TcEnv)> list * + CheckExpressions.TcEnv + + val TcMutRecDefns_Phase2: + cenv:cenv -> + envInitial:CheckExpressions.TcEnv -> + bindsm:Range.range -> + scopem:Range.range -> + mutRecNSInfo:(TypedTree.ModuleOrNamespace option * + TypedTree.ModuleOrNamespaceType ref) option -> + envMutRec:CheckExpressions.TcEnv -> + mutRecDefns:MutRecDefnsPhase2Data -> + MutRecShape<(TypedTree.Tycon option * TypedTree.Binding list), + TypedTree.Binding list, + (MutRecDefnsPhase2DataForModule * + CheckExpressions.TcEnv)> list * + CheckExpressions.TcEnv + module AddAugmentationDeclarations = + val tcaugHasNominalInterface: + g:TcGlobals.TcGlobals -> + tcaug:TypedTree.TyconAugmentation -> tcref:TypedTree.TyconRef -> bool + val AddGenericCompareDeclarations: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + scSet:Set -> tycon:TypedTree.Tycon -> unit + val AddGenericEqualityWithComparerDeclarations: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + seSet:Set -> tycon:TypedTree.Tycon -> unit + val AddGenericCompareBindings: + cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list + val AddGenericCompareWithComparerBindings: + cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list + val AddGenericEqualityWithComparerBindings: + cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list + val AddGenericHashAndComparisonDeclarations: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + scSet:Set -> + seSet:Set -> tycon:TypedTree.Tycon -> unit + val AddGenericHashAndComparisonBindings: + cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list + val AddGenericEqualityBindings: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + tycon:TypedTree.Tycon -> TypedTree.Binding list + + module TyconConstraintInference = + val InferSetOfTyconsSupportingComparable: + cenv:cenv -> + denv:TypedTreeOps.DisplayEnv -> + tyconsWithStructuralTypes:(TypedTree.Tycon * + (TypedTree.TType * 'a) list) list -> + Set + val InferSetOfTyconsSupportingEquatable: + cenv:cenv -> + denv:TypedTreeOps.DisplayEnv -> + tyconsWithStructuralTypes:(TypedTree.Tycon * + (TypedTree.TType * 'a) list) list -> + Set + + val ComputeModuleName: longPath:SyntaxTree.Ident list -> SyntaxTree.Ident + val CheckForDuplicateConcreteType: + env:CheckExpressions.TcEnv -> nm:string -> m:Range.range -> unit + val CheckForDuplicateModule: + env:CheckExpressions.TcEnv -> nm:string -> m:Range.range -> unit + module TcExceptionDeclarations = + val TcExnDefnCore_Phase1A: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + SyntaxTree.SynExceptionDefnRepr -> TypedTree.Entity + val TcExnDefnCore_Phase1G_EstablishRepresentation: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + exnc:TypedTree.Entity -> + SyntaxTree.SynExceptionDefnRepr -> TypedTree.RecdField list + val private TcExnDefnCore: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + synExnDefnRepr:SyntaxTree.SynExceptionDefnRepr -> + TypedTree.Binding list * TypedTree.Entity + val TcExnDefn: + cenv:CheckExpressions.TcFileState -> + envInitial:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + SyntaxTree.SynExceptionDefn * scopem:Range.range -> + TypedTree.Binding list * TypedTree.Entity * + CheckExpressions.TcEnv + val TcExnSignature: + cenv:CheckExpressions.TcFileState -> + envInitial:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + SyntaxTree.SynExceptionSig * scopem:Range.range -> + TypedTree.Binding list * TypedTree.Val list * + TypedTree.EntityRef * CheckExpressions.TcEnv + + module EstablishTypeDefinitionCores = + type TypeRealizationPass = + | FirstPass + | SecondPass + val private ComputeTyconName: + longPath:SyntaxTree.Ident list * doErase:bool * typars:TypedTree.Typars -> + SyntaxTree.Ident + val private GetTyconAttribs: + g:TcGlobals.TcGlobals -> + attrs:TypedTree.Attribs -> bool * bool * bool * bool * bool + val private InferTyconKind: + g:TcGlobals.TcGlobals -> + kind:SyntaxTree.SynTypeDefnKind * attrs:TypedTree.Attribs * + slotsigs:'a list * fields:'b list * inSig:bool * isConcrete:bool * + m:Range.range -> SyntaxTree.SynTypeDefnKind + val private ( |TyconCoreAbbrevThatIsReallyAUnion|_| ): + hasMeasureAttr:bool * envinner:CheckExpressions.TcEnv * + id:SyntaxTree.Ident -> + synTyconRepr:SyntaxTree.SynTypeDefnSimpleRepr -> + (SyntaxTree.Ident * Range.range) option + val private GetStructuralElementsOfTyconDefn: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + MutRecDefnsPhase1DataForTycon -> + tycon:Lib.NonNullSlot -> + (TypedTree.TType * Range.range) list + val ComputeModuleOrNamespaceKind: + g:TcGlobals.TcGlobals -> + isModule:bool -> + typeNames:Set<'a> -> + attribs:TypedTree.Attribs -> + nm:'a -> TypedTree.ModuleOrNamespaceKind when 'a: comparison + val AdjustModuleName: + modKind:TypedTree.ModuleOrNamespaceKind -> nm:string -> string + val InstanceMembersNeedSafeInitCheck: + cenv:cenv -> m:Range.range -> thisTy:TypedTree.TType -> bool + val ComputeInstanceSafeInitInfo: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + m:Range.range -> + thisTy:TypedTree.TType -> CheckExpressions.SafeInitData + val TypeNamesInMutRecDecls: + cenv:CheckExpressions.TcFileState -> + env:CheckExpressions.TcEnv -> + compDecls:MutRecShapes<(MutRecDefnsPhase1DataForTycon * 'MemberInfo), + 'LetInfo,SyntaxTree.SynComponentInfo> -> + Set + val TypeNamesInNonMutRecDecls: + defs:seq -> Set + val TypeNamesInNonMutRecSigDecls: + defs:seq -> Set + val TcTyconDefnCore_Phase1A_BuildInitialModule: + cenv:CheckExpressions.TcFileState -> + envInitial:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + typeNames:Set -> + compInfo:SyntaxTree.SynComponentInfo -> + decls:MutRecShapes<(MutRecDefnsPhase1DataForTycon * 'a),'b, + SyntaxTree.SynComponentInfo> -> + MutRecDefnsPhase2DataForModule * + (TypedTree.ParentRef * Set * CheckExpressions.TcEnv) + val private TcTyconDefnCore_Phase1A_BuildInitialTycon: + cenv:cenv -> + env:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + MutRecDefnsPhase1DataForTycon -> TypedTree.Entity + val private TcTyconDefnCore_Phase1B_EstablishBasicKind: + cenv:cenv -> + inSig:bool -> + envinner:CheckExpressions.TcEnv -> + MutRecDefnsPhase1DataForTycon -> + tycon:TypedTree.Tycon -> + TypedTree.Attrib list * (unit -> TypedTree.Attribs) + val private TcTyconDefnCore_GetGenerateDeclaration_Rhs: + SyntaxTree.SynType -> + (SyntaxTree.LongIdent * SyntaxTree.SynType list * Range.range) option + val private TcTyconDefnCore_TryAsGenerateDeclaration: + cenv:cenv -> + envinner:CheckExpressions.TcEnv -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + tycon:TypedTree.Tycon * rhsType:SyntaxTree.SynType -> + (TypedTree.TyconRef * Tainted * + (unit -> unit) * SyntaxTree.SynType list * Range.range) option + val private + TcTyconDefnCore_Phase1C_EstablishDeclarationForGeneratedSetOfTypes: + cenv:cenv -> + inSig:bool -> + tycon:TypedTree.Tycon * rhsType:SyntaxTree.SynType * + tcrefForContainer:TypedTree.TyconRef * + theRootType:Tainted * + checkTypeName:(unit -> unit) * args:'a list * m:Range.range -> unit + val private TcTyconDefnCore_Phase1C_Phase1E_EstablishAbbreviations: + cenv:cenv -> + envinner:CheckExpressions.TcEnv -> + inSig:bool -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + pass:TypeRealizationPass -> + MutRecDefnsPhase1DataForTycon -> + tycon:TypedTree.Tycon -> attrs:TypedTree.Attribs -> unit + val private + TcTyconDefnCore_Phase1D_Phase1F_EstablishSuperTypesAndInterfaceTypes: + cenv:CheckExpressions.TcFileState -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + inSig:bool -> + pass:TypeRealizationPass -> + envMutRec:CheckExpressions.TcEnv * + mutRecDefns:MutRecShape<((MutRecDefnsPhase1DataForTycon * 'a * + 'b) * + (TypedTree.Tycon * + (TypedTree.Attribs * 'c)) option),'d, + ('e * CheckExpressions.TcEnv)> list -> + unit + val private TcTyconDefnCore_Phase1G_EstablishRepresentation: + cenv:cenv -> + envinner:CheckExpressions.TcEnv -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + inSig:bool -> + MutRecDefnsPhase1DataForTycon -> + tycon:TypedTree.Tycon -> + attrs:TypedTree.Attribs -> + TypedTree.Val option * CheckExpressions.SafeInitData + val private TcTyconDefnCore_CheckForCyclicAbbreviations: + tycons:TypedTree.Entity list -> unit + val TcTyconDefnCore_CheckForCyclicStructsAndInheritance: + cenv:cenv -> tycons:TypedTree.Entity list -> unit + val TcMutRecDefns_CheckExplicitConstraints: + cenv:CheckExpressions.TcFileState -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + m:Range.range -> + checkCxs:CheckExpressions.CheckConstraints -> + envMutRecPrelim:CheckExpressions.TcEnv -> + withEnvs:MutRecShape<((MutRecDefnsPhase1DataForTycon * 'a * 'b) * + TypedTree.Tycon option),'c, + ('d * CheckExpressions.TcEnv)> list -> + unit + val TcMutRecDefns_Phase1: + mkLetInfo:(CheckExpressions.ContainerInfo -> 'LetInfo -> 'a) -> + cenv:cenv -> + envInitial:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + typeNames:Set -> + inSig:bool -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + m:Range.range -> + scopem:Range.range -> + mutRecNSInfo:(TypedTree.ModuleOrNamespace option * + TypedTree.ModuleOrNamespaceType ref) option -> + mutRecDefns:MutRecShapes<(MutRecDefnsPhase1DataForTycon * + 'MemberInfo),'LetInfo, + SyntaxTree.SynComponentInfo> -> + TypedTree.Entity list * CheckExpressions.TcEnv * + MutRecShape<((MutRecDefnsPhase1DataForTycon * + 'MemberInfo * TypedTree.ParentRef) * + TypedTree.Entity option * + (unit -> unit) * + (TypedTree.Val option * + CheckExpressions.SafeInitData)),'a, + (MutRecDefnsPhase2DataForModule * + CheckExpressions.TcEnv)> list + + module TcDeclarations = + val private ComputeTyconDeclKind: + cenv:cenv -> + envForDecls:CheckExpressions.TcEnv -> + tyconOpt:Lib.NonNullSlot option -> + isAtOriginalTyconDefn:bool -> + inSig:bool -> + m:Range.range -> + synTypars:SyntaxTree.SynTyparDecl list -> + synTyparCxs:SyntaxTree.SynTypeConstraint list -> + longPath:SyntaxTree.Ident list -> + CheckExpressions.DeclKind * TypedTree.EntityRef * + TypedTree.Typars + val private isAugmentationTyconDefnRepr: + _arg1:SyntaxTree.SynTypeDefnSimpleRepr -> bool + val private isAutoProperty: _arg1:SyntaxTree.SynMemberDefn -> bool + val private isMember: _arg1:SyntaxTree.SynMemberDefn -> bool + val private isImplicitCtor: _arg1:SyntaxTree.SynMemberDefn -> bool + val private isImplicitInherit: _arg1:SyntaxTree.SynMemberDefn -> bool + val private isAbstractSlot: _arg1:SyntaxTree.SynMemberDefn -> bool + val private isInterface: _arg1:SyntaxTree.SynMemberDefn -> bool + val private isInherit: _arg1:SyntaxTree.SynMemberDefn -> bool + val private isField: _arg1:SyntaxTree.SynMemberDefn -> bool + val private isTycon: _arg1:SyntaxTree.SynMemberDefn -> bool + val private allFalse: ps:('a -> bool) list -> x:'a -> bool + val private CheckMembersForm: ds:SyntaxTree.SynMemberDefn list -> unit + val private SplitTyconDefn: + SyntaxTree.SynTypeDefn -> + MutRecDefnsPhase1DataForTycon * SyntaxTree.SynMemberDefn list + val TcMutRecDefinitions: + cenv:cenv -> + envInitial:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + typeNames:Set -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + m:Range.range -> + scopem:Range.range -> + mutRecNSInfo:(TypedTree.ModuleOrNamespace option * + TypedTree.ModuleOrNamespaceType ref) option -> + mutRecDefns:MutRecDefnsInitialData -> + MutRecShape<(TypedTree.Tycon option * + TypedTree.Binding list), + TypedTree.Binding list, + (MutRecDefnsPhase2DataForModule * + CheckExpressions.TcEnv)> list * + CheckExpressions.TcEnv + val private SplitTyconSignature: + SyntaxTree.SynTypeDefnSig -> + MutRecDefnsPhase1DataForTycon * + (SyntaxTree.SynComponentInfo * SyntaxTree.SynMemberSig list) + val private TcMutRecSignatureDecls_Phase2: + cenv:cenv -> + scopem:Range.range -> + envMutRec:CheckExpressions.TcEnv -> + mutRecDefns:MutRecShape<((MutRecDefnsPhase1DataForTycon * + (SyntaxTree.SynComponentInfo * + SyntaxTree.SynMemberSig list) * + TypedTree.ParentRef) * + Lib.NonNullSlot option * + 'a * 'b), + (CheckExpressions.ContainerInfo * + SyntaxTree.SynValSig), + ('c * CheckExpressions.TcEnv)> list -> + MutRecShape<(TypedTree.Val list * + CheckExpressions.UnscopedTyparEnv), + CheckExpressions.TcEnv,('c * CheckExpressions.TcEnv)> list + val TcMutRecSignatureDecls: + cenv:cenv -> + envInitial:CheckExpressions.TcEnv -> + parent:TypedTree.ParentRef -> + typeNames:Set -> + tpenv:CheckExpressions.UnscopedTyparEnv -> + m:Range.range -> + scopem:Range.range -> + mutRecNSInfo:(TypedTree.ModuleOrNamespace option * + TypedTree.ModuleOrNamespaceType ref) option -> + mutRecSigs:MutRecSigsInitialData -> + CheckExpressions.TcEnv + + val TcSignatureElementNonMutRec: + cenv:CheckExpressions.TcFileState -> + parent:TypedTree.ParentRef -> + typeNames:Set -> + m:Range.range -> + env:CheckExpressions.TcEnv -> + synSigDecl:SyntaxTree.SynModuleSigDecl -> + AbstractIL.Internal.Library.Eventually + val TcSignatureElements: + cenv:CheckExpressions.TcFileState -> + parent:TypedTree.ParentRef -> + m:Range.range -> + env:CheckExpressions.TcEnv -> + xml:XmlDoc.PreXmlDoc -> + mutRecNSInfo:(TypedTree.ModuleOrNamespace option * + TypedTree.ModuleOrNamespaceType ref) option -> + defs:SyntaxTree.SynModuleSigDecl list -> + AbstractIL.Internal.Library.Eventually + val TcSignatureElementsNonMutRec: + cenv:CheckExpressions.TcFileState -> + parent:TypedTree.ParentRef -> + typeNames:Set -> + m:Range.range -> + env:CheckExpressions.TcEnv -> + defs:SyntaxTree.SynModuleSigDecl list -> + AbstractIL.Internal.Library.Eventually + val TcSignatureElementsMutRec: + cenv:CheckExpressions.TcFileState -> + parent:TypedTree.ParentRef -> + typeNames:Set -> + m:Range.range -> + mutRecNSInfo:(TypedTree.ModuleOrNamespace option * + TypedTree.ModuleOrNamespaceType ref) option -> + envInitial:CheckExpressions.TcEnv -> + defs:SyntaxTree.SynModuleSigDecl list -> + AbstractIL.Internal.Library.Eventually + val TcModuleOrNamespaceSignatureElementsNonMutRec: + cenv:CheckExpressions.TcFileState -> + parent:TypedTree.ParentRef -> + env:CheckExpressions.TcEnv -> + id:SyntaxTree.Ident * modKind:TypedTree.ModuleOrNamespaceKind * + defs:SyntaxTree.SynModuleSigDecl list * m:Range.range * + xml:XmlDoc.PreXmlDoc -> + AbstractIL.Internal.Library.Eventually + val ElimModuleDoBinding: + bind:SyntaxTree.SynModuleDecl -> SyntaxTree.SynModuleDecl + val TcMutRecDefnsEscapeCheck: + binds:MutRecShapes<(TypedTree.Tycon option * TypedTree.Binding list), + TypedTree.Binding list,'a> -> + env:CheckExpressions.TcEnv -> unit + val CheckLetOrDoInNamespace: + binds:SyntaxTree.SynBinding list -> m:Range.range -> unit + val TcModuleOrNamespaceElementNonMutRec: + cenv:cenv -> + parent:TypedTree.ParentRef -> + typeNames:Set -> + scopem:Range.range -> + env:CheckExpressions.TcEnv -> + synDecl:SyntaxTree.SynModuleDecl -> + AbstractIL.Internal.Library.Eventually<((TypedTree.ModuleOrNamespaceExpr list -> + TypedTree.ModuleOrNamespaceExpr list) * + (System.AttributeTargets * + TypedTree.Attrib) list) * + CheckExpressions.TcEnv * + CheckExpressions.TcEnv> + val TcModuleOrNamespaceElementsNonMutRec: + cenv:cenv -> + parent:TypedTree.ParentRef -> + typeNames:Set -> + m:Range.range -> + defsSoFar:((TypedTree.ModuleOrNamespaceExpr list -> + TypedTree.ModuleOrNamespaceExpr list) * + (System.AttributeTargets * TypedTree.Attrib) list) list * + env:CheckExpressions.TcEnv * envAtEnd:CheckExpressions.TcEnv -> + moreDefs:SyntaxTree.SynModuleDecl list -> + AbstractIL.Internal.Library.Eventually<((TypedTree.ModuleOrNamespaceExpr list -> + TypedTree.ModuleOrNamespaceExpr list) * + (System.AttributeTargets * + TypedTree.Attrib) list) list * + CheckExpressions.TcEnv> + val TcModuleOrNamespaceElementsMutRec: + cenv:cenv -> + parent:TypedTree.ParentRef -> + typeNames:Set -> + m:Range.range -> + envInitial:CheckExpressions.TcEnv -> + mutRecNSInfo:(TypedTree.ModuleOrNamespace option * + TypedTree.ModuleOrNamespaceType ref) option -> + defs:SyntaxTree.SynModuleDecl list -> + AbstractIL.Internal.Library.Eventually<((TypedTree.ModuleOrNamespaceExpr list -> + TypedTree.ModuleOrNamespaceExpr list) * + (System.AttributeTargets * + TypedTree.Attrib) list) * + CheckExpressions.TcEnv * + CheckExpressions.TcEnv> + val TcMutRecDefsFinish: + cenv:cenv -> + defs:MutRecShape<(TypedTree.Tycon option * TypedTree.Binding list), + TypedTree.Binding list, + (MutRecDefnsPhase2DataForModule * + CheckExpressions.TcEnv)> list -> + m:Range.range -> TypedTree.ModuleOrNamespaceExpr + val TcModuleOrNamespaceElements: + cenv:cenv -> + parent:TypedTree.ParentRef -> + m:Range.range -> + env:CheckExpressions.TcEnv -> + xml:XmlDoc.PreXmlDoc -> + mutRecNSInfo:(TypedTree.ModuleOrNamespace option * + TypedTree.ModuleOrNamespaceType ref) option -> + defs:SyntaxTree.SynModuleDecl list -> + AbstractIL.Internal.Library.Eventually + val ApplyAssemblyLevelAutoOpenAttributeToTcEnv: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + ccu:TypedTree.CcuThunk -> + scopem:Range.range -> + env:CheckExpressions.TcEnv -> + p:System.String * root:bool -> CheckExpressions.TcEnv + val AddCcuToTcEnv: + TcGlobals.TcGlobals * Import.ImportMap * Range.range * + CheckExpressions.TcEnv * assemblyName:string * ccu:TypedTree.CcuThunk * + autoOpens:string list * internalsVisibleToAttributes:string list -> + CheckExpressions.TcEnv + val emptyTcEnv: g:TcGlobals.TcGlobals -> CheckExpressions.TcEnv + val CreateInitialTcEnv: + TcGlobals.TcGlobals * Import.ImportMap * Range.range * assemblyName:string * + (TypedTree.CcuThunk * string list * string list) list -> + CheckExpressions.TcEnv + type ConditionalDefines = string list + type TopAttribs = + { mainMethodAttrs: TypedTree.Attribs + netModuleAttrs: TypedTree.Attribs + assemblyAttrs: TypedTree.Attribs } + val EmptyTopAttrs: TopAttribs + val CombineTopAttrs: TopAttribs -> TopAttribs -> TopAttribs + val IterTyconsOfModuleOrNamespaceType: + f:(TypedTree.Entity -> unit) -> + mty:TypedTree.ModuleOrNamespaceType -> unit + val ApplyDefaults: + cenv:cenv -> + g:TcGlobals.TcGlobals -> + denvAtEnd:TypedTreeOps.DisplayEnv -> + m:Range.range -> + mexpr:TypedTree.ModuleOrNamespaceExpr -> + extraAttribs:TypedTree.Attrib list -> unit + val CheckValueRestriction: + denvAtEnd:TypedTreeOps.DisplayEnv -> + rootSigOpt:'a option -> + implFileTypePriorToSig:TypedTree.ModuleOrNamespaceType -> + m:Range.range -> unit + val SolveInternalUnknowns: + g:TcGlobals.TcGlobals -> + cenv:cenv -> + denvAtEnd:TypedTreeOps.DisplayEnv -> + mexpr:TypedTree.ModuleOrNamespaceExpr -> + extraAttribs:TypedTree.Attrib list -> unit + val CheckModuleSignature: + g:TcGlobals.TcGlobals -> + cenv:cenv -> + m:Range.range -> + denvAtEnd:TypedTreeOps.DisplayEnv -> + rootSigOpt:TypedTree.ModuleOrNamespaceType option -> + implFileTypePriorToSig:TypedTree.ModuleOrNamespaceType -> + implFileSpecPriorToSig:Lib.NonNullSlot -> + mexpr:TypedTree.ModuleOrNamespaceExpr -> + TypedTree.ModuleOrNamespaceExprWithSig + val MakeInitialEnv: + env:CheckExpressions.TcEnv -> + CheckExpressions.TcEnv * TypedTree.ModuleOrNamespaceType ref + val TypeCheckOneImplFile: + TcGlobals.TcGlobals * CompilerGlobalState.NiceNameGenerator * + Import.ImportMap * TypedTree.CcuThunk * (unit -> bool) * + string list option * NameResolution.TcResultsSink * bool -> + CheckExpressions.TcEnv -> + TypedTree.ModuleOrNamespaceType option -> + SyntaxTree.ParsedImplFileInput -> + AbstractIL.Internal.Library.Eventually + val TypeCheckOneSigFile: + TcGlobals.TcGlobals * CompilerGlobalState.NiceNameGenerator * + Import.ImportMap * TypedTree.CcuThunk * (unit -> bool) * + string list option * NameResolution.TcResultsSink * bool -> + CheckExpressions.TcEnv -> + SyntaxTree.ParsedSigFileInput -> + AbstractIL.Internal.Library.Eventually + + +namespace FSharp.Compiler + module internal Optimizer = + val verboseOptimizationInfo: bool + val verboseOptimizations: bool + val i_ldlen: AbstractIL.IL.ILInstr list + [] + val callSize: int = 1 + [] + val forAndWhileLoopSize: int = 5 + [] + val tryWithSize: int = 5 + [] + val tryFinallySize: int = 5 + [] + val closureTotalSize: int = 10 + [] + val methodDefnTotalSize: int = 1 + type TypeValueInfo = | UnknownTypeValue + type ExprValueInfo = + | UnknownValue + | SizeValue of size: int * ExprValueInfo + | ValValue of TypedTree.ValRef * ExprValueInfo + | TupleValue of ExprValueInfo [] + | RecdValue of TypedTree.TyconRef * ExprValueInfo [] + | UnionCaseValue of TypedTree.UnionCaseRef * ExprValueInfo [] + | ConstValue of TypedTree.Const * TypedTree.TType + | CurriedLambdaValue of + id: CompilerGlobalState.Unique * arity: int * size: int * + value: TypedTree.Expr * TypedTree.TType + | ConstExprValue of size: int * value: TypedTree.Expr + type ValInfo = + { ValMakesNoCriticalTailcalls: bool + ValExprInfo: ExprValueInfo } + type ValInfos = + + new: entries:seq -> ValInfos + member Filter: f:(TypedTree.ValRef * ValInfo -> bool) -> ValInfos + member + Map: f:(TypedTree.ValRef * ValInfo -> TypedTree.ValRef * ValInfo) -> + ValInfos + member + TryFind: v:TypedTree.ValRef -> (TypedTree.ValRef * ValInfo) option + member + TryFindForFslib: g:TcGlobals.TcGlobals * vref:TypedTree.ValRef -> + bool * (TypedTree.ValRef * ValInfo) + member Entries: seq + + type ModuleInfo = + { ValInfos: ValInfos + ModuleOrNamespaceInfos: + AbstractIL.Internal.Library.NameMap } + and LazyModuleInfo = Lazy + type ImplFileOptimizationInfo = LazyModuleInfo + type CcuOptimizationInfo = LazyModuleInfo + val braceL: + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val seqL: + xL:('a -> Internal.Utilities.StructuredFormat.Layout) -> + xs:seq<'a> -> Internal.Utilities.StructuredFormat.Layout + val namemapL: + xL:(string -> 'a -> Internal.Utilities.StructuredFormat.Layout) -> + xmap:AbstractIL.Internal.Library.NameMap<'a> -> + Internal.Utilities.StructuredFormat.Layout + val exprValueInfoL: + g:TcGlobals.TcGlobals -> + exprVal:ExprValueInfo -> Internal.Utilities.StructuredFormat.Layout + val exprValueInfosL: + g:TcGlobals.TcGlobals -> + vinfos:ExprValueInfo [] -> Internal.Utilities.StructuredFormat.Layout + val moduleInfoL: + TcGlobals.TcGlobals -> + LazyModuleInfo -> Internal.Utilities.StructuredFormat.Layout + val valInfoL: + g:TcGlobals.TcGlobals -> + x:ValInfo -> Internal.Utilities.StructuredFormat.Layout + type Summary<'Info> = + { Info: 'Info + FunctionSize: int + TotalSize: int + HasEffect: bool + MightMakeCriticalTailcall: bool } + val SizeOfValueInfos: arr:ExprValueInfo [] -> int + val SizeOfValueInfo: x:ExprValueInfo -> int + [] + val minDepthForASizeNode: int = 5 + val MakeValueInfoWithCachedSize: + vdepth:int -> v:ExprValueInfo -> ExprValueInfo + val MakeSizedValueInfo: v:ExprValueInfo -> ExprValueInfo + val BoundValueInfoBySize: vinfo:ExprValueInfo -> ExprValueInfo + [] + val jitOptDefault: bool = true + [] + val localOptDefault: bool = true + [] + val crossModuleOptDefault: bool = true + type OptimizationSettings = + { abstractBigTargets: bool + jitOptUser: bool option + localOptUser: bool option + crossModuleOptUser: bool option + bigTargetSize: int + veryBigExprSize: int + lambdaInlineThreshold: int + reportingPhase: bool + reportNoNeedToTailcall: bool + reportFunctionSizes: bool + reportHasEffect: bool + reportTotalSizes: bool } + with + member EliminateImmediatelyConsumedLocals: unit -> bool + member EliminateRecdFieldGet: unit -> bool + member EliminateSequential: unit -> bool + member EliminateSwitch: unit -> bool + member EliminateTryWithAndTryFinally: unit -> bool + member EliminateTupleFieldGet: unit -> bool + member EliminateUnionCaseFieldGet: unit -> bool + member EliminateUnusedBindings: unit -> bool + member ExpandStructuralValues: unit -> bool + member InlineLambdas: unit -> bool + member KeepOptimizationValues: unit -> bool + member crossModuleOpt: unit -> bool + member jitOpt: unit -> bool + member localOpt: unit -> bool + static member Defaults: OptimizationSettings + + type cenv = + { g: TcGlobals.TcGlobals + TcVal: ConstraintSolver.TcValF + amap: Import.ImportMap + optimizing: bool + scope: TypedTree.CcuThunk + localInternalVals: + System.Collections.Generic.Dictionary + settings: OptimizationSettings + emitTailcalls: bool + casApplied: System.Collections.Generic.Dictionary } + with + override ToString: unit -> string + + [] + type IncrementalOptimizationEnv = + { latestBoundId: SyntaxTree.Ident option + dontInline: AbstractIL.Internal.Zset + dontSplitVars: TypedTreeOps.ValMap + disableMethodSplitting: bool + functionVal: (TypedTree.Val * TypedTree.ValReprInfo) option + typarInfos: (TypedTree.Typar * TypeValueInfo) list + localExternalVals: + AbstractIL.Internal.Library.LayeredMap + globalModuleInfos: + AbstractIL.Internal.Library.LayeredMap } + with + override ToString: unit -> string + static member Empty: IncrementalOptimizationEnv + + val IsPartialExprVal: x:ExprValueInfo -> bool + val CheckInlineValueIsComplete: + v:TypedTree.Val -> res:ExprValueInfo -> unit + val check: + vref:TypedTree.ValRef -> res:ValInfo -> TypedTree.ValRef * ValInfo + val EmptyModuleInfo: System.Lazy + val UnionOptimizationInfos: seq -> System.Lazy + val FindOrCreateModuleInfo: + n:'a -> ss:Map<'a,System.Lazy> -> System.Lazy + when 'a: comparison + val FindOrCreateGlobalModuleInfo: + n:'a -> + ss:AbstractIL.Internal.Library.LayeredMap<'a,System.Lazy> -> + System.Lazy when 'a: comparison + val BindValueInSubModuleFSharpCore: + mp:string [] -> + i:int -> v:TypedTree.Val -> vval:ValInfo -> ss:ModuleInfo -> ModuleInfo + val BindValueInModuleForFslib: + n:string -> + mp:string [] -> + i:int -> + v:TypedTree.Val -> + vval:ValInfo -> + ss:AbstractIL.Internal.Library.NameMap -> + AbstractIL.Internal.Library.NameMap + val BindValueInGlobalModuleForFslib: + n:'a -> + mp:string [] -> + i:int -> + v:TypedTree.Val -> + vval:ValInfo -> + ss:AbstractIL.Internal.Library.LayeredMap<'a, + System.Lazy> -> + Map<'a,System.Lazy> when 'a: comparison + val BindValueForFslib: + nlvref:TypedTree.NonLocalValOrMemberRef -> + v:TypedTree.Val -> + vval:ValInfo -> + env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv + val UnknownValInfo: ValInfo + val mkValInfo: info:Summary -> v:TypedTree.Val -> ValInfo + val BindInternalLocalVal: + cenv:cenv -> v:TypedTree.Val -> vval:ValInfo -> env:'a -> 'a + val BindExternalLocalVal: + cenv:cenv -> + v:TypedTree.Val -> + vval:ValInfo -> + env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv + val BindValsInModuleOrNamespace: + cenv:cenv -> + mval:LazyModuleInfo -> + env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv + val inline BindInternalValToUnknown: cenv:'a -> v:'b -> env:'c -> 'c + val inline BindInternalValsToUnknown: cenv:'a -> vs:'b -> env:'c -> 'c + val BindTypeVar: + tyv:TypedTree.Typar -> + typeinfo:TypeValueInfo -> + env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv + val BindTypeVarsToUnknown: + tps:TypedTree.Typar list -> + env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv + val BindCcu: + TypedTree.CcuThunk -> + LazyModuleInfo -> + IncrementalOptimizationEnv -> + TcGlobals.TcGlobals -> IncrementalOptimizationEnv + val GetInfoForLocalValue: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + v:TypedTree.Val -> m:Range.range -> ValInfo + val TryGetInfoForCcu: + env:IncrementalOptimizationEnv -> + ccu:TypedTree.CcuThunk -> LazyModuleInfo option + val TryGetInfoForEntity: sv:ModuleInfo -> n:string -> ModuleInfo option + val TryGetInfoForPath: + sv:ModuleInfo -> p:string [] -> i:int -> ModuleInfo option + val TryGetInfoForNonLocalEntityRef: + env:IncrementalOptimizationEnv -> + nleref:TypedTree.NonLocalEntityRef -> ModuleInfo option + val GetInfoForNonLocalVal: + cenv:cenv -> + env:IncrementalOptimizationEnv -> vref:TypedTree.ValRef -> ValInfo + val GetInfoForVal: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + m:Range.range -> vref:TypedTree.ValRef -> ValInfo + val stripValue: _arg1:ExprValueInfo -> ExprValueInfo + val ( |StripConstValue|_| ): ev:ExprValueInfo -> TypedTree.Const option + val ( |StripLambdaValue|_| ): + ev:ExprValueInfo -> + (CompilerGlobalState.Unique * int * int * TypedTree.Expr * + TypedTree.TType) option + val destTupleValue: ev:ExprValueInfo -> ExprValueInfo [] option + val destRecdValue: ev:ExprValueInfo -> ExprValueInfo [] option + val ( |StripUnionCaseValue|_| ): + ev:ExprValueInfo -> (TypedTree.UnionCaseRef * ExprValueInfo []) option + val mkBoolVal: g:TcGlobals.TcGlobals -> n:bool -> ExprValueInfo + val mkInt8Val: g:TcGlobals.TcGlobals -> n:sbyte -> ExprValueInfo + val mkInt16Val: g:TcGlobals.TcGlobals -> n:int16 -> ExprValueInfo + val mkInt32Val: g:TcGlobals.TcGlobals -> n:int32 -> ExprValueInfo + val mkInt64Val: g:TcGlobals.TcGlobals -> n:int64 -> ExprValueInfo + val mkUInt8Val: g:TcGlobals.TcGlobals -> n:byte -> ExprValueInfo + val mkUInt16Val: g:TcGlobals.TcGlobals -> n:uint16 -> ExprValueInfo + val mkUInt32Val: g:TcGlobals.TcGlobals -> n:uint32 -> ExprValueInfo + val mkUInt64Val: g:TcGlobals.TcGlobals -> n:uint64 -> ExprValueInfo + val ( |StripInt32Value|_| ): _arg1:ExprValueInfo -> int32 option + val MakeValueInfoForValue: + g:TcGlobals.TcGlobals -> + m:Range.range -> + vref:TypedTree.ValRef -> vinfo:ExprValueInfo -> ExprValueInfo + val MakeValueInfoForRecord: + tcref:TypedTree.TyconRef -> argvals:ExprValueInfo [] -> ExprValueInfo + val MakeValueInfoForTuple: argvals:ExprValueInfo [] -> ExprValueInfo + val MakeValueInfoForUnionCase: + cspec:TypedTree.UnionCaseRef -> argvals:ExprValueInfo [] -> ExprValueInfo + val MakeValueInfoForConst: + c:TypedTree.Const -> ty:TypedTree.TType -> ExprValueInfo + val inline IntegerUnaryOp: + g:TcGlobals.TcGlobals -> + f8:(sbyte -> sbyte) -> + f16:(int16 -> int16) -> + f32:(int -> int) -> + f64:(int64 -> int64) -> + fu8:(byte -> byte) -> + fu16:(uint16 -> uint16) -> + fu32:(uint32 -> uint32) -> + fu64:(uint64 -> uint64) -> + a:ExprValueInfo -> ExprValueInfo option + val inline SignedIntegerUnaryOp: + g:TcGlobals.TcGlobals -> + f8:(sbyte -> sbyte) -> + f16:(int16 -> int16) -> + f32:(int32 -> int32) -> + f64:(int64 -> int64) -> a:ExprValueInfo -> ExprValueInfo option + val inline IntegerBinaryOp: + g:TcGlobals.TcGlobals -> + f8:(sbyte -> sbyte -> sbyte) -> + f16:(int16 -> int16 -> int16) -> + f32:(int -> int -> int) -> + f64:(int64 -> int64 -> int64) -> + fu8:(byte -> byte -> byte) -> + fu16:(uint16 -> uint16 -> uint16) -> + fu32:(uint32 -> uint32 -> uint32) -> + fu64:(uint64 -> uint64 -> uint64) -> + a:ExprValueInfo -> + b:ExprValueInfo -> ExprValueInfo option + val mkAssemblyCodeValueInfo: + g:TcGlobals.TcGlobals -> + instrs:AbstractIL.IL.ILInstr list -> + argvals:ExprValueInfo list -> + tys:TypedTree.TType list -> ExprValueInfo + [] + val localVarSize: int = 1 + val AddTotalSizes: l:Summary<'a> list -> int + val AddFunctionSizes: l:Summary<'a> list -> int + val OrEffects: l:Summary<'a> list -> bool + val OrTailcalls: l:Summary<'a> list -> bool + val OptimizeList: f:('a -> 'b * 'c) -> l:'a list -> 'b list * 'c list + val NoExprs: TypedTree.Expr list * Summary list + val CombineValueInfos: einfos:Summary<'a> list -> res:'b -> Summary<'b> + val CombineValueInfosUnknown: + einfos:Summary<'a> list -> Summary + val AbstractLazyModulInfoByHiding: + isAssemblyBoundary:bool -> + mhi:TypedTreeOps.SignatureHidingInfo -> + (LazyModuleInfo -> LazyModuleInfo) + val AbstractOptimizationInfoToEssentials: + (System.Lazy -> System.Lazy) + val AbstractExprInfoByVars: + boundVars:TypedTree.Val list * boundTyVars:TypedTree.Typar list -> + ivalue:ExprValueInfo -> ExprValueInfo + val RemapOptimizationInfo: + TcGlobals.TcGlobals -> + TypedTreeOps.Remap -> (LazyModuleInfo -> LazyModuleInfo) + val AbstractAndRemapModulInfo: + msg:string -> + g:TcGlobals.TcGlobals -> + m:Range.range -> + repackage:TypedTreeOps.SignatureRepackageInfo * + hidden:TypedTreeOps.SignatureHidingInfo -> + info:LazyModuleInfo -> LazyModuleInfo + [] + val suffixForVariablesThatMayNotBeEliminated: string = "$cont" + val IsTyFuncValRefExpr: _arg1:TypedTree.Expr -> bool + val IsSmallConstExpr: x:TypedTree.Expr -> bool + val ValueOfExpr: expr:TypedTree.Expr -> ExprValueInfo + val IsDiscardableEffectExpr: expr:TypedTree.Expr -> bool + val ValueIsUsedOrHasEffect: + cenv:cenv -> + fvs:(unit -> AbstractIL.Internal.Zset) -> + b:TypedTree.Binding * binfo:Summary<'a> -> bool + val SplitValuesByIsUsedOrHasEffect: + cenv:cenv -> + fvs:(unit -> AbstractIL.Internal.Zset) -> + x:(TypedTree.Binding * Summary<'a>) list -> + TypedTree.Binding list * Summary<'a> list + val IlAssemblyCodeInstrHasEffect: i:AbstractIL.IL.ILInstr -> bool + val IlAssemblyCodeHasEffect: instrs:AbstractIL.IL.ILInstr list -> bool + val ExprHasEffect: TcGlobals.TcGlobals -> TypedTree.Expr -> bool + val ExprsHaveEffect: g:TcGlobals.TcGlobals -> exprs:TypedTree.Exprs -> bool + val BindingsHaveEffect: + g:TcGlobals.TcGlobals -> binds:TypedTree.Bindings -> bool + val BindingHasEffect: + g:TcGlobals.TcGlobals -> bind:TypedTree.Binding -> bool + val OpHasEffect: + g:TcGlobals.TcGlobals -> m:Range.range -> op:TypedTree.TOp -> bool + val TryEliminateBinding: + cenv:cenv -> + _env:'a -> + TypedTree.Binding -> + e2:TypedTree.Expr -> _m:'b -> TypedTree.Expr option + val TryEliminateLet: + cenv:cenv -> + env:'a -> + bind:TypedTree.Binding -> + e2:TypedTree.Expr -> m:Range.range -> TypedTree.Expr * int + val ( |KnownValApp|_| ): + expr:TypedTree.Expr -> + (TypedTree.ValRef * TypedTree.TType list * TypedTree.Expr list) option + val ( |TDBoolSwitch|_| ): + dtree:TypedTree.DecisionTree -> + (TypedTree.Expr * bool * TypedTree.DecisionTree * TypedTree.DecisionTree * + Range.range) option + val ( |ConstantBoolTarget|_| ): + target:TypedTree.DecisionTreeTarget -> bool option + val CountBoolLogicTree: + TypedTree.DecisionTreeTarget [] * int * int * bool -> + tree:TypedTree.DecisionTree -> int * int + val RewriteBoolLogicTree: + TypedTree.DecisionTreeTarget [] * TypedTree.DecisionTree * + TypedTree.DecisionTree * bool -> + tree:TypedTree.DecisionTree -> TypedTree.DecisionTree + val RewriteBoolLogicCase: + TypedTree.DecisionTreeTarget [] * TypedTree.DecisionTree * + TypedTree.DecisionTree * bool -> + TypedTree.DecisionTreeCase -> TypedTree.DecisionTreeCase + val CombineBoolLogic: expr:TypedTree.Expr -> TypedTree.Expr + val CanExpandStructuralBinding: v:TypedTree.Val -> bool + val ExprIsValue: _arg1:TypedTree.Expr -> bool + val MakeStructuralBindingTemp: + v:TypedTree.Val -> + i:'a -> + arg:TypedTree.Expr -> + argTy:TypedTree.TType -> TypedTree.Expr * TypedTree.Binding + val ExpandStructuralBindingRaw: + cenv:cenv -> expr:TypedTree.Expr -> TypedTree.Expr + val RearrangeTupleBindings: + expr:TypedTree.Expr -> + fin:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr option + val ExpandStructuralBinding: + cenv:cenv -> expr:TypedTree.Expr -> TypedTree.Expr + val ( |QueryRun|_| ): + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.TType option) option + val ( |MaybeRefTupled| ): e:TypedTree.Expr -> TypedTree.Exprs + val ( |AnyInstanceMethodApp|_| ): + e:TypedTree.Expr -> + (TypedTree.ValRef * TypedTree.TypeInst * TypedTree.Expr * + TypedTree.Exprs) option + val ( |InstanceMethodApp|_| ): + g:TcGlobals.TcGlobals -> + expectedValRef:TypedTree.ValRef -> + e:TypedTree.Expr -> + (TypedTree.TypeInst * TypedTree.Expr * TypedTree.Exprs) option + val ( |QuerySourceEnumerable|_| ): + g:TcGlobals.TcGlobals -> + _arg1:TypedTree.Expr -> (TypedTree.TType * TypedTree.Expr) option + val ( |QueryFor|_| ): + g:TcGlobals.TcGlobals -> + _arg1:TypedTree.Expr -> + (TypedTree.TType * TypedTree.TType * TypedTree.TType * TypedTree.Expr * + TypedTree.Expr) option + val ( |QueryYield|_| ): + g:TcGlobals.TcGlobals -> + _arg1:TypedTree.Expr -> + (TypedTree.TType * TypedTree.TType * TypedTree.Expr) option + val ( |QueryYieldFrom|_| ): + g:TcGlobals.TcGlobals -> + _arg1:TypedTree.Expr -> + (TypedTree.TType * TypedTree.TType * TypedTree.Expr) option + val ( |QuerySelect|_| ): + g:TcGlobals.TcGlobals -> + _arg1:TypedTree.Expr -> + (TypedTree.TType * TypedTree.TType * TypedTree.TType * TypedTree.Expr * + TypedTree.Expr) option + val ( |QueryZero|_| ): + g:TcGlobals.TcGlobals -> + _arg1:TypedTree.Expr -> (TypedTree.TType * TypedTree.TType) option + val ( |AnyRefTupleTrans| ): + e:TypedTree.Expr -> TypedTree.Exprs * (TypedTree.Exprs -> TypedTree.Expr) + val ( |AnyQueryBuilderOpTrans|_| ): + g:TcGlobals.TcGlobals -> + _arg1:TypedTree.Expr -> + (TypedTree.Expr * (TypedTree.Expr -> TypedTree.Expr)) option + val tryRewriteToSeqCombinators: + g:TcGlobals.TcGlobals -> e:TypedTree.Expr -> TypedTree.Expr option + val TryDetectQueryQuoteAndRun: + cenv:cenv -> expr:TypedTree.Expr -> TypedTree.Expr option + val IsILMethodRefSystemStringConcat: mref:AbstractIL.IL.ILMethodRef -> bool + val IsILMethodRefSystemStringConcatArray: + mref:AbstractIL.IL.ILMethodRef -> bool + val OptimizeExpr: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + expr:TypedTree.Expr -> TypedTree.Expr * Summary + val OptimizeObjectExpr: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + ty:TypedTree.TType * baseValOpt:TypedTree.Val option * + basecall:TypedTree.Expr * overrides:TypedTree.ObjExprMethod list * + iimpls:(TypedTree.TType * TypedTree.ObjExprMethod list) list * + m:Range.range -> TypedTree.Expr * Summary + val OptimizeMethods: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + baseValOpt:TypedTree.Val option -> + methods:TypedTree.ObjExprMethod list -> + TypedTree.ObjExprMethod list * Summary list + val OptimizeMethod: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + baseValOpt:TypedTree.Val option -> + TypedTree.ObjExprMethod -> + TypedTree.ObjExprMethod * Summary + val OptimizeInterfaceImpls: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + baseValOpt:TypedTree.Val option -> + iimpls:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> + (TypedTree.TType * TypedTree.ObjExprMethod list) list * + Summary list + val OptimizeInterfaceImpl: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + baseValOpt:TypedTree.Val option -> + ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> + (TypedTree.TType * TypedTree.ObjExprMethod list) * + Summary + val MakeOptimizedSystemStringConcatCall: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + m:Range.range -> + args:TypedTree.Exprs -> TypedTree.Expr * Summary + val OptimizeExprOp: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * + m:Range.range -> TypedTree.Expr * Summary + val OptimizeExprOpReductions: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * + m:Range.range -> TypedTree.Expr * Summary + val OptimizeExprOpReductionsAfter: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + op:TypedTree.TOp * tyargs:TypedTree.TypeInst * argsR:TypedTree.Exprs * + arginfos:Summary list * m:Range.range -> + TypedTree.Expr * Summary + val OptimizeExprOpFallback: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + op:TypedTree.TOp * tyargs:TypedTree.TypeInst * argsR:TypedTree.Exprs * + m:Range.range -> + arginfos:Summary list -> + valu:ExprValueInfo -> TypedTree.Expr * Summary + val OptimizeConst: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + expr:TypedTree.Expr -> + c:TypedTree.Const * m:Range.range * ty:TypedTree.TType -> + TypedTree.Expr * Summary + val TryOptimizeRecordFieldGet: + cenv:cenv -> + _env:IncrementalOptimizationEnv -> + e1info:Summary * TypedTree.RecdFieldRef * + _tinst:TypedTree.TypeInst * m:Range.range -> ExprValueInfo option + val TryOptimizeTupleFieldGet: + cenv:cenv -> + _env:IncrementalOptimizationEnv -> + _tupInfo:TypedTree.TupInfo * e1info:Summary * + tys:TypedTree.TypeInst * n:int * m:Range.range -> ExprValueInfo option + val TryOptimizeUnionCaseGet: + cenv:cenv -> + _env:IncrementalOptimizationEnv -> + e1info:Summary * cspec:TypedTree.UnionCaseRef * + _tys:TypedTree.TypeInst * n:int * m:Range.range -> + ExprValueInfo option + val OptimizeFastIntegerForLoop: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + spStart:SyntaxTree.DebugPointAtFor * v:TypedTree.Val * + e1:TypedTree.Expr * dir:TypedTree.ForLoopStyle * e2:TypedTree.Expr * + e3:TypedTree.Expr * m:Range.range -> + TypedTree.Expr * Summary + val OptimizeLetRec: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + binds:TypedTree.Bindings * bodyExpr:TypedTree.Expr * m:Range.range -> + TypedTree.Expr * Summary + val OptimizeLinearExpr: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + expr:TypedTree.Expr -> + contf:(TypedTree.Expr * Summary -> + TypedTree.Expr * Summary) -> + TypedTree.Expr * Summary + val OptimizeTryFinally: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + spTry:SyntaxTree.DebugPointAtTry * + spFinally:SyntaxTree.DebugPointAtFinally * e1:TypedTree.Expr * + e2:TypedTree.Expr * m:Range.range * ty:TypedTree.TType -> + TypedTree.Expr * Summary + val OptimizeTryWith: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + e1:TypedTree.Expr * vf:TypedTree.Val * ef:TypedTree.Expr * + vh:TypedTree.Val * eh:TypedTree.Expr * m:Range.range * + ty:TypedTree.TType * spTry:SyntaxTree.DebugPointAtTry * + spWith:SyntaxTree.DebugPointAtWith -> + TypedTree.Expr * Summary + val OptimizeWhileLoop: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + spWhile:SyntaxTree.DebugPointAtWhile * + marker:TypedTree.SpecialWhileLoopMarker * e1:TypedTree.Expr * + e2:TypedTree.Expr * m:Range.range -> + TypedTree.Expr * Summary + val OptimizeTraitCall: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + traitInfo:TypedTree.TraitConstraintInfo * args:TypedTree.Exprs * + m:Range.range -> TypedTree.Expr * Summary + val TryOptimizeVal: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + mustInline:bool * valInfoForVal:ExprValueInfo * m:Range.range -> + TypedTree.Expr option + val TryOptimizeValInfo: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + m:Range.range -> vinfo:Summary -> TypedTree.Expr option + val AddValEqualityInfo: + g:TcGlobals.TcGlobals -> + m:Range.range -> + v:TypedTree.ValRef -> + info:Summary -> Summary + val OptimizeVal: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + expr:TypedTree.Expr -> + v:TypedTree.ValRef * m:Range.range -> + TypedTree.Expr * Summary + val StripToNominalTyconRef: + cenv:cenv -> ty:TypedTree.TType -> TypedTree.TyconRef * TypedTree.TypeInst + val CanDevirtualizeApplication: + cenv:cenv -> + v:TypedTree.ValRef -> + vref:TypedTree.ValRef -> ty:TypedTree.TType -> args:'a list -> bool + val TakeAddressOfStructArgumentIfNeeded: + cenv:cenv -> + vref:TypedTree.ValRef -> + ty:TypedTree.TType -> + args:TypedTree.Expr list -> + m:Range.range -> + (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr list + val DevirtualizeApplication: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + vref:TypedTree.ValRef -> + ty:TypedTree.TType -> + tyargs:TypedTree.TType list -> + args:TypedTree.Expr list -> + m:Range.range -> TypedTree.Expr * Summary + val TryDevirtualizeApplication: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + f:TypedTree.Expr * tyargs:TypedTree.TType list * + args:TypedTree.Expr list * m:Range.range -> + (TypedTree.Expr * Summary) option + val TryInlineApplication: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + finfo:Summary -> + tyargs:TypedTree.TType list * args:TypedTree.Expr list * + m:Range.range -> (TypedTree.Expr * Summary) option + val OptimizeApplication: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + f0:TypedTree.Expr * f0ty:TypedTree.TType * tyargs:TypedTree.TypeInst * + args:TypedTree.Exprs * m:Range.range -> + TypedTree.Expr * Summary + val OptimizeLambdas: + vspec:TypedTree.Val option -> + cenv:cenv -> + env:IncrementalOptimizationEnv -> + topValInfo:TypedTree.ValReprInfo -> + e:TypedTree.Expr -> + ety:TypedTree.TType -> TypedTree.Expr * Summary + val OptimizeExprsThenReshapeAndConsiderSplits: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + exprs:(ExprValueInfo * TypedTree.Expr) list -> + TypedTree.Exprs * Summary list + val OptimizeExprsThenConsiderSplits: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + exprs:TypedTree.Exprs -> TypedTree.Exprs * Summary list + val OptimizeExprThenReshapeAndConsiderSplit: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + shape:ExprValueInfo * e:TypedTree.Expr -> + TypedTree.Expr * Summary + val OptimizeDecisionTreeTargets: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + m:Range.range -> + targets:TypedTree.DecisionTreeTarget [] -> + TypedTree.DecisionTreeTarget list * Summary list + val ReshapeExpr: + cenv:cenv -> shape:ExprValueInfo * e:TypedTree.Expr -> TypedTree.Expr + val OptimizeExprThenConsiderSplit: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + e:TypedTree.Expr -> TypedTree.Expr * Summary + val ComputeSplitToMethodCondition: + flag:bool -> + threshold:int -> + cenv:cenv -> + env:IncrementalOptimizationEnv -> + e:TypedTree.Expr * einfo:Summary<'b> -> bool + val ConsiderSplitToMethod: + flag:bool -> + threshold:int -> + cenv:cenv -> + env:IncrementalOptimizationEnv -> + e:TypedTree.Expr * einfo:Summary -> + TypedTree.Expr * Summary + val OptimizeMatch: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + spMatch:SyntaxTree.DebugPointForBinding * exprm:Range.range * + dtree:TypedTree.DecisionTree * + targets:TypedTree.DecisionTreeTarget array * m:Range.range * + ty:TypedTree.TType -> TypedTree.Expr * Summary + val OptimizeMatchPart2: + cenv:cenv -> + spMatch:SyntaxTree.DebugPointForBinding * exprm:Range.range * + dtreeR:TypedTree.DecisionTree * + targetsR:TypedTree.DecisionTreeTarget list * + dinfo:Summary * tinfos:Summary list * + m:Range.range * ty:TypedTree.TType -> + TypedTree.Expr * Summary + val CombineMatchInfos: + dinfo:Summary<'c> -> tinfo:Summary<'d> -> Summary + val RebuildOptimizedMatch: + spMatch:SyntaxTree.DebugPointForBinding * exprm:Range.range * + m:Range.range * ty:TypedTree.TType * dtree:TypedTree.DecisionTree * + tgs:TypedTree.DecisionTreeTarget list * dinfo:Summary * + tinfos:Summary list -> + TypedTree.Expr * Summary + val OptimizeDecisionTreeTarget: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + _m:Range.range -> + TypedTree.DecisionTreeTarget -> + TypedTree.DecisionTreeTarget * Summary + val OptimizeDecisionTree: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + m:Range.range -> + x:TypedTree.DecisionTree -> + TypedTree.DecisionTree * Summary + val TryOptimizeDecisionTreeTest: + cenv:cenv -> + test:TypedTree.DecisionTreeTest -> vinfo:ExprValueInfo -> bool option + val OptimizeSwitch: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + e:TypedTree.Expr * cases:TypedTree.DecisionTreeCase list * + dflt:TypedTree.DecisionTree option * m:Range.range -> + TypedTree.DecisionTree * Summary + val OptimizeSwitchFallback: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + eR:TypedTree.Expr * einfo:Summary * + cases:TypedTree.DecisionTreeCase list * + dflt:TypedTree.DecisionTree option * m:Range.range -> + TypedTree.DecisionTree * Summary + val OptimizeBinding: + cenv:cenv -> + isRec:bool -> + env:IncrementalOptimizationEnv -> + TypedTree.Binding -> + (TypedTree.Binding * Summary) * + IncrementalOptimizationEnv + val OptimizeBindings: + cenv:cenv -> + isRec:bool -> + env:IncrementalOptimizationEnv -> + xs:TypedTree.Bindings -> + (TypedTree.Binding * Summary) list * + IncrementalOptimizationEnv + val OptimizeModuleExpr: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + x:TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig * LazyModuleInfo + val mkValBind: bind:TypedTree.Binding -> info:'e -> TypedTree.ValRef * 'e + val OptimizeModuleDef: + cenv:cenv -> + env:IncrementalOptimizationEnv * + bindInfosColl:(TypedTree.Binding * Summary) list list -> + x:TypedTree.ModuleOrNamespaceExpr -> + (TypedTree.ModuleOrNamespaceExpr * System.Lazy) * + (IncrementalOptimizationEnv * + (TypedTree.Binding * Summary) list list) + val OptimizeModuleBindings: + cenv:cenv -> + env:IncrementalOptimizationEnv * + bindInfosColl:(TypedTree.Binding * Summary) list list -> + xs:TypedTree.ModuleOrNamespaceBinding list -> + (TypedTree.ModuleOrNamespaceBinding * + Choice<(TypedTree.Binding * Summary), + (string * LazyModuleInfo)>) list * + (IncrementalOptimizationEnv * + (TypedTree.Binding * Summary) list list) + val OptimizeModuleBinding: + cenv:cenv -> + env:IncrementalOptimizationEnv * + bindInfosColl:(TypedTree.Binding * Summary) list list -> + x:TypedTree.ModuleOrNamespaceBinding -> + (TypedTree.ModuleOrNamespaceBinding * + Choice<(TypedTree.Binding * Summary), + (string * LazyModuleInfo)>) * + (IncrementalOptimizationEnv * + (TypedTree.Binding * Summary) list list) + val OptimizeModuleDefs: + cenv:cenv -> + env:IncrementalOptimizationEnv * + bindInfosColl:(TypedTree.Binding * Summary) list list -> + defs:TypedTree.ModuleOrNamespaceExpr list -> + (TypedTree.ModuleOrNamespaceExpr list * System.Lazy) * + (IncrementalOptimizationEnv * + (TypedTree.Binding * Summary) list list) + val OptimizeImplFileInternal: + cenv:cenv -> + env:IncrementalOptimizationEnv -> + isIncrementalFragment:bool -> + hidden:TypedTreeOps.SignatureHidingInfo -> + TypedTree.TypedImplFile -> + IncrementalOptimizationEnv * TypedTree.TypedImplFile * + LazyModuleInfo * TypedTreeOps.SignatureHidingInfo + val OptimizeImplFile: + OptimizationSettings * TypedTree.CcuThunk * TcGlobals.TcGlobals * + ConstraintSolver.TcValF * Import.ImportMap * IncrementalOptimizationEnv * + isIncrementalFragment:bool * emitTailcalls:bool * + TypedTreeOps.SignatureHidingInfo * TypedTree.TypedImplFile -> + (IncrementalOptimizationEnv * TypedTree.TypedImplFile * LazyModuleInfo * + TypedTreeOps.SignatureHidingInfo) * + (bool -> TypedTree.Expr -> TypedTree.Expr) + val p_ExprValueInfo: + x:ExprValueInfo -> st:TypedTreePickle.WriterState -> unit + val p_ValInfo: v:ValInfo -> st:TypedTreePickle.WriterState -> unit + val p_ModuleInfo: x:ModuleInfo -> st:TypedTreePickle.WriterState -> unit + val p_LazyModuleInfo: + x:LazyModuleInfo -> st:TypedTreePickle.WriterState -> unit + val p_CcuOptimizationInfo: + LazyModuleInfo -> TypedTreePickle.WriterState -> unit + val u_ExprInfo: st:TypedTreePickle.ReaderState -> ExprValueInfo + val u_ValInfo: st:TypedTreePickle.ReaderState -> ValInfo + val u_ModuleInfo: st:TypedTreePickle.ReaderState -> ModuleInfo + val u_LazyModuleInfo: st:TypedTreePickle.ReaderState -> LazyModuleInfo + val u_CcuOptimizationInfo: TypedTreePickle.ReaderState -> LazyModuleInfo + + +namespace FSharp.Compiler + module internal Detuple = + val ( |TyappAndApp|_| ): + e:TypedTree.Expr -> + (TypedTree.Expr * TypedTree.TType * TypedTree.TType list * + TypedTree.Exprs * Range.range) option + module GlobalUsageAnalysis = + val bindAccBounds: + vals:AbstractIL.Internal.Zset<'a> -> + _isInDTree:'b * v:'a -> AbstractIL.Internal.Zset<'a> + val GetValsBoundInExpr: + TypedTree.Expr -> AbstractIL.Internal.Zset + type accessor = | TupleGet of int * TypedTree.TType list + type Results = + { Uses: + AbstractIL.Internal.Zmap + Defns: AbstractIL.Internal.Zmap + DecisionTreeBindings: AbstractIL.Internal.Zset + RecursiveBindings: + AbstractIL.Internal.Zmap + TopLevelBindings: AbstractIL.Internal.Zset + IterationIsAtTopLevel: bool } + val z0: Results + val logUse: + f:TypedTree.Val -> + accessor list * TypedTree.TType list * TypedTree.Expr list -> + z:Results -> Results + val logBinding: z:Results -> isInDTree:bool * v:TypedTree.Val -> Results + val logNonRecBinding: z:Results -> bind:TypedTree.Binding -> Results + val logRecBindings: z:Results -> binds:TypedTree.Bindings -> Results + val foldUnderLambda: + f:(Results -> 'a -> Results) -> z:Results -> x:'a -> Results + val UsageFolders: + g:TcGlobals.TcGlobals -> TypedTreeOps.ExprFolder + val GetUsageInfoOfImplFile: + TcGlobals.TcGlobals -> TypedTree.TypedImplFile -> Results + + val internalError: str:string -> 'a + val mkLocalVal: + m:Range.range -> + name:string -> + ty:TypedTree.TType -> + topValInfo:TypedTree.ValReprInfo option -> TypedTree.Val + type TupleStructure = + | UnknownTS + | TupleTS of TupleStructure list + val ValReprInfoForTS: ts:TupleStructure -> TypedTree.ArgReprInfo list list + val andTS: ts:TupleStructure -> tsB:TupleStructure -> TupleStructure + val checkTS: _arg1:TupleStructure -> TupleStructure + val uncheckedExprTS: expr:TypedTree.Expr -> TupleStructure + val uncheckedTypeTS: + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TupleStructure + val exprTS: exprs:TypedTree.Expr -> TupleStructure + val typeTS: g:TcGlobals.TcGlobals -> tys:TypedTree.TType -> TupleStructure + val rebuildTS: + g:TcGlobals.TcGlobals -> + m:Range.range -> + ts:TupleStructure -> vs:TypedTree.Val list -> TypedTree.Expr + type CallPattern = TupleStructure list + val callPatternOrder: (CallPattern -> CallPattern -> int) + val argsCP: exprs:TypedTree.Expr list -> TupleStructure list + val noArgsCP: 'a list + val inline isTrivialCP: xs:'a list -> bool + val minimalCallPattern: + callPattern:TupleStructure list -> TupleStructure list + val commonCallPattern: + callPatterns:TupleStructure list list -> TupleStructure list + val siteCP: + _accessors:'a * _inst:'b * args:TypedTree.Expr list -> TupleStructure list + val sitesCPs: + sites:('a * 'b * TypedTree.Expr list) list -> TupleStructure list list + type TransformedFormal = + | SameArg + | NewArgs of TypedTree.Val list * TypedTree.Expr + type Transform = + { transformCallPattern: CallPattern + transformedFormals: TransformedFormal list + transformedVal: TypedTree.Val } + val mkTransform: + g:TcGlobals.TcGlobals -> + f:TypedTree.Val -> + m:Range.range -> + tps:TypedTree.Typar list -> + x1Ntys:TypedTree.TType list -> + rty:TypedTree.TType -> + callPattern:TupleStructure list * + tyfringes:(TypedTree.TType list * TypedTree.Val list) list -> + Transform + val zipTupleStructureAndType: + g:TcGlobals.TcGlobals -> + ts:TupleStructure -> + ty:TypedTree.TType -> TupleStructure * TypedTree.TType list + val zipTupleStructuresAndTypes: + g:TcGlobals.TcGlobals -> + tss:TupleStructure list -> + tys:TypedTree.TTypes -> TupleStructure list * TypedTree.TType list + val zipCallPatternArgTys: + m:Range.range -> + g:TcGlobals.TcGlobals -> + callPattern:TupleStructure list -> + vss:TypedTree.Val list list -> + TupleStructure list * + (TypedTree.TType list * TypedTree.Val list) list + val decideFormalSuggestedCP: + g:TcGlobals.TcGlobals -> + z:GlobalUsageAnalysis.Results -> + tys:TypedTree.TType list -> + vss:TypedTree.Val list list -> TupleStructure list + val decideTransform: + g:TcGlobals.TcGlobals -> + z:GlobalUsageAnalysis.Results -> + v:TypedTree.Val -> + callPatterns:TupleStructure list list -> + m:Range.range * tps:TypedTree.Typar list * + vss:TypedTree.Val list list * rty:TypedTree.TType -> + (TypedTree.Val * Transform) option + val eligibleVal: + g:TcGlobals.TcGlobals -> m:Range.range -> v:TypedTree.Val -> bool + val determineTransforms: + g:TcGlobals.TcGlobals -> + z:GlobalUsageAnalysis.Results -> + AbstractIL.Internal.Zmap + type penv = + { transforms: AbstractIL.Internal.Zmap + ccu: TypedTree.CcuThunk + g: TcGlobals.TcGlobals } + val hasTransfrom: penv:penv -> f:TypedTree.Val -> Transform option + type env = + { eg: TcGlobals.TcGlobals + prefix: string + m: Range.range } + with + override ToString: unit -> string + + val suffixE: env:env -> s:string -> env + val rangeE: env:env -> m:Range.range -> env + val push: b:'a -> bs:'a list -> 'a list + val pushL: xs:'a list -> bs:'a list -> 'a list + val newLocal: + env:env -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr + val newLocalN: + env:env -> i:'a -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr + val noEffectExpr: + env:env -> + bindings:TypedTree.Binding list -> + x:TypedTree.Expr -> TypedTree.Binding list * TypedTree.Expr + val buildProjections: + env:env -> + bindings:TypedTree.Binding list -> + x:TypedTree.Expr -> + xtys:TypedTree.TType list -> + TypedTree.Binding list * TypedTree.Expr list + val collapseArg: + env:env -> + bindings:TypedTree.Binding list -> + ts:TupleStructure -> + x:TypedTree.Expr -> TypedTree.Binding list * TypedTree.Expr list + val collapseArgs: + env:env -> + bindings:TypedTree.Binding list -> + n:int -> + callPattern:TupleStructure list -> + args:TypedTree.Exprs -> + TypedTree.Binding list * TypedTree.Expr list + val mkLets: + binds:TypedTree.Binding list -> body:TypedTree.Expr -> TypedTree.Expr + val fixupApp: + penv:penv -> + fx:TypedTree.Expr * fty:TypedTree.TType * tys:TypedTree.TypeInst * + args:TypedTree.Exprs * m:Range.range -> TypedTree.Expr + val transFormal: + ybi:TransformedFormal -> xi:TypedTree.Val list -> TypedTree.Val list list + val transRebind: + ybi:TransformedFormal -> xi:TypedTree.Val list -> TypedTree.Binding list + val passBind: penv:penv -> TypedTree.Binding -> TypedTree.Binding + val passBinds: + penv:penv -> binds:TypedTree.Binding list -> TypedTree.Binding list + val passBindRhs: + conv:(TypedTree.Expr -> TypedTree.Expr) -> + TypedTree.Binding -> TypedTree.Binding + val preInterceptExpr: + penv:penv -> + conv:(TypedTree.Expr -> TypedTree.Expr) -> + expr:TypedTree.Expr -> TypedTree.Expr option + val postTransformExpr: + penv:penv -> expr:TypedTree.Expr -> TypedTree.Expr option + val passImplFile: + penv:penv -> assembly:TypedTree.TypedImplFile -> TypedTree.TypedImplFile + val DetupleImplFile: + TypedTree.CcuThunk -> + TcGlobals.TcGlobals -> + TypedTree.TypedImplFile -> TypedTree.TypedImplFile + + +namespace FSharp.Compiler + module internal InnerLambdasToTopLevelFuncs = + val verboseTLR: bool + val internalError: str:string -> 'a + module Zmap = + val force: + k:'a -> + mp:AbstractIL.Internal.Zmap<'a,'b> -> + str:string * soK:('a -> string) -> 'b + + type Tree<'T> = + | TreeNode of Tree<'T> list + | LeafNode of 'T + val fringeTR: tr:Tree<'a> -> 'a list + val emptyTR: Tree<'a> + val destApp: + f:TypedTree.Expr * fty:TypedTree.TType * tys:TypedTree.TType list * + args:'a * m:'b -> + TypedTree.Expr * TypedTree.TType * TypedTree.TType list * 'a * 'b + val showTyparSet: tps:AbstractIL.Internal.Zset -> string + val isDelayedRepr: f:TypedTree.Val -> e:TypedTree.Expr -> bool + val mkLocalNameTypeArity: + compgen:bool -> + m:Range.range -> + name:string -> + ty:TypedTree.TType -> + topValInfo:TypedTree.ValReprInfo option -> TypedTree.Val + val GetValsBoundUnderMustInline: + xinfo:Detuple.GlobalUsageAnalysis.Results -> + AbstractIL.Internal.Zset + val IsRefusedTLR: g:TcGlobals.TcGlobals -> f:TypedTree.Val -> bool + val IsMandatoryTopLevel: f:TypedTree.Val -> bool + val IsMandatoryNonTopLevel: + g:TcGlobals.TcGlobals -> f:TypedTree.Val -> bool + module Pass1_DetermineTLRAndArities = + val GetMaxNumArgsAtUses: + xinfo:Detuple.GlobalUsageAnalysis.Results -> f:TypedTree.Val -> int + val SelectTLRVals: + g:TcGlobals.TcGlobals -> + xinfo:Detuple.GlobalUsageAnalysis.Results -> + f:TypedTree.Val -> e:TypedTree.Expr -> (TypedTree.Val * int) option + val IsValueRecursionFree: + xinfo:Detuple.GlobalUsageAnalysis.Results -> f:TypedTree.Val -> bool + val DumpArity: arityM:AbstractIL.Internal.Zmap -> unit + val DetermineTLRAndArities: + g:TcGlobals.TcGlobals -> + expr:TypedTree.TypedImplFile -> + AbstractIL.Internal.Zset * + AbstractIL.Internal.Zset * + AbstractIL.Internal.Zmap + + type BindingGroupSharingSameReqdItems = + + new: bindings:TypedTree.Bindings -> BindingGroupSharingSameReqdItems + member Contains: v:TypedTree.Val -> bool + override ToString: unit -> string + member IsEmpty: bool + member Pairs: (TypedTree.Val * BindingGroupSharingSameReqdItems) list + member Vals: TypedTree.Vals + + val fclassOrder: + System.Collections.Generic.IComparer + type ReqdItem = + | ReqdSubEnv of TypedTree.Val + | ReqdVal of TypedTree.Val + with + override ToString: unit -> string + + val reqdItemOrder: System.Collections.Generic.IComparer + type ReqdItemsForDefn = + { reqdTypars: AbstractIL.Internal.Zset + reqdItems: AbstractIL.Internal.Zset + m: Range.range } + with + static member + Initial: typars:TypedTree.Typar list -> + m:Range.range -> ReqdItemsForDefn + member + Extend: typars:TypedTree.Typar list * items:ReqdItem list -> + ReqdItemsForDefn + override ToString: unit -> string + member ReqdSubEnvs: TypedTree.Val list + member ReqdVals: TypedTree.Val list + + type Generators = AbstractIL.Internal.Zset + val IsArityMet: + vref:TypedTree.ValRef -> + wf:int -> tys:TypedTree.TypeInst -> args:'a list -> bool + module Pass2_DetermineReqdItems = + type state = + { stack: + (BindingGroupSharingSameReqdItems * Generators * ReqdItemsForDefn) list + reqdItemsMap: + AbstractIL.Internal.Zmap + fclassM: + AbstractIL.Internal.Zmap + revDeclist: BindingGroupSharingSameReqdItems list + recShortCallS: AbstractIL.Internal.Zset } + val state0: state + val PushFrame: + fclass:BindingGroupSharingSameReqdItems -> + reqdTypars0:TypedTree.Typar list * reqdVals0:Generators * + m:Range.range -> state:state -> state + val SaveFrame: + fclass:BindingGroupSharingSameReqdItems -> state:state -> state + val LogRequiredFrom: + gv:TypedTree.Val -> items:ReqdItem list -> state:state -> state + val LogShortCall: gv:TypedTree.Val -> state:state -> state + val FreeInBindings: bs:TypedTree.Binding list -> TypedTree.FreeVars + val ExprEnvIntercept: + tlrS:AbstractIL.Internal.Zset * + arityM:AbstractIL.Internal.Zmap -> + recurseF:(state -> TypedTree.Expr -> state) -> + noInterceptF:(state -> TypedTree.Expr -> state) -> + z:state -> expr:TypedTree.Expr -> state + val CloseReqdTypars: + fclassM:AbstractIL.Internal.Zmap -> + reqdItemsMap:AbstractIL.Internal.Zmap<'a,ReqdItemsForDefn> -> + AbstractIL.Internal.Zmap<'a,ReqdItemsForDefn> + val DumpReqdValMap: + reqdItemsMap:seq> -> unit + val DetermineReqdItems: + tlrS:AbstractIL.Internal.Zset * + arityM:AbstractIL.Internal.Zmap -> + expr:TypedTree.TypedImplFile -> + AbstractIL.Internal.Zmap * + AbstractIL.Internal.Zmap * + BindingGroupSharingSameReqdItems list * + AbstractIL.Internal.Zset + + type PackedReqdItems = + { ep_etps: TypedTree.Typars + ep_aenvs: TypedTree.Val list + ep_pack: TypedTree.Bindings + ep_unpack: TypedTree.Bindings } + exception AbortTLR of Range.range + val FlatEnvPacks: + g:TcGlobals.TcGlobals -> + fclassM:AbstractIL.Internal.Zmap -> + topValS:AbstractIL.Internal.Zset -> + declist:#BindingGroupSharingSameReqdItems list -> + reqdItemsMap:AbstractIL.Internal.Zmap -> + AbstractIL.Internal.Zmap + val DumpEnvPackM: + g:TcGlobals.TcGlobals -> + envPackM:seq> -> + unit + val ChooseReqdItemPackings: + g:TcGlobals.TcGlobals -> + fclassM:AbstractIL.Internal.Zmap -> + topValS:AbstractIL.Internal.Zset -> + declist:#BindingGroupSharingSameReqdItems list -> + reqdItemsMap:AbstractIL.Internal.Zmap -> + AbstractIL.Internal.Zmap + val MakeSimpleArityInfo: + tps:TypedTree.Typar list -> n:int -> TypedTree.ValReprInfo + val CreateNewValuesForTLR: + g:TcGlobals.TcGlobals -> + tlrS:AbstractIL.Internal.Zset -> + arityM:AbstractIL.Internal.Zmap -> + fclassM:AbstractIL.Internal.Zmap -> + envPackM:AbstractIL.Internal.Zmap<'a,PackedReqdItems> -> + AbstractIL.Internal.Zmap + module Pass4_RewriteAssembly = + [] + type RewriteContext = + { ccu: TypedTree.CcuThunk + g: TcGlobals.TcGlobals + tlrS: AbstractIL.Internal.Zset + topValS: AbstractIL.Internal.Zset + arityM: AbstractIL.Internal.Zmap + fclassM: + AbstractIL.Internal.Zmap + recShortCallS: AbstractIL.Internal.Zset + envPackM: + AbstractIL.Internal.Zmap + fHatM: AbstractIL.Internal.Zmap } + type IsRecursive = + | IsRec + | NotRec + type LiftedDeclaration = IsRecursive * TypedTree.Bindings + type RewriteState = + { rws_mustinline: bool + rws_innerLevel: int + rws_preDecs: Tree } + val rewriteState0: RewriteState + val EnterInner: z:RewriteState -> RewriteState + val ExitInner: z:RewriteState -> RewriteState + val EnterMustInline: + b:bool -> + z:RewriteState -> + f:(RewriteState -> 'a * RewriteState) -> RewriteState * 'a + val ExtractPreDecs: + z:RewriteState -> LiftedDeclaration list * RewriteState + val PopPreDecs: z:RewriteState -> RewriteState * Tree + val SetPreDecs: + z:RewriteState -> pdt:Tree -> RewriteState + val LiftTopBinds: _isRec:'a -> _penv:'b -> z:'c -> binds:'d -> 'c * 'd + val MakePreDec: + m:Range.range -> + isRec:IsRecursive * binds:TypedTree.Bindings -> + expr:TypedTree.Expr -> TypedTree.Expr + val MakePreDecs: + m:Range.range -> + preDecs:(IsRecursive * TypedTree.Bindings) list -> + expr:TypedTree.Expr -> TypedTree.Expr + val RecursivePreDecs: + pdsA:Tree<'a * 'b list> -> + pdsB:Tree<'a * 'b list> -> Tree + val ConvertBind: + g:TcGlobals.TcGlobals -> TypedTree.Binding -> TypedTree.Binding + val TransTLRBindings: + penv:RewriteContext -> + binds:TypedTree.Bindings -> + TypedTree.Binding list * TypedTree.Binding list + val GetAEnvBindings: + penv:RewriteContext -> + fc:BindingGroupSharingSameReqdItems -> TypedTree.Binding list + val TransBindings: + xisRec:IsRecursive -> + penv:RewriteContext -> + binds:TypedTree.Bindings -> + TypedTree.Binding list * TypedTree.Binding list + val TransApp: + penv:RewriteContext -> + fx:TypedTree.Expr * fty:TypedTree.TType * tys:TypedTree.TypeInst * + args:TypedTree.Expr list * m:Range.range -> TypedTree.Expr + val TransExpr: + penv:RewriteContext -> + z:RewriteState -> expr:TypedTree.Expr -> TypedTree.Expr * RewriteState + val TransLinearExpr: + penv:RewriteContext -> + z:RewriteState -> + expr:TypedTree.Expr -> + contf:(TypedTree.Expr * RewriteState -> + TypedTree.Expr * RewriteState) -> + TypedTree.Expr * RewriteState + val TransMethod: + penv:RewriteContext -> + z:RewriteState -> + TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod * RewriteState + val TransBindingRhs: + penv:RewriteContext -> + z:RewriteState -> + TypedTree.Binding -> TypedTree.Binding * RewriteState + val TransDecisionTree: + penv:RewriteContext -> + z:RewriteState -> + x:TypedTree.DecisionTree -> TypedTree.DecisionTree * RewriteState + val TransDecisionTreeTarget: + penv:RewriteContext -> + z:RewriteState -> + TypedTree.DecisionTreeTarget -> + TypedTree.DecisionTreeTarget * RewriteState + val TransValBinding: + penv:RewriteContext -> + z:RewriteState -> + bind:TypedTree.Binding -> TypedTree.Binding * RewriteState + val TransValBindings: + penv:RewriteContext -> + z:RewriteState -> + binds:TypedTree.Binding list -> + TypedTree.Binding list * RewriteState + val TransModuleExpr: + penv:RewriteContext -> + z:RewriteState -> + x:TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig * RewriteState + val TransModuleDefs: + penv:RewriteContext -> + z:RewriteState -> + x:TypedTree.ModuleOrNamespaceExpr list -> + TypedTree.ModuleOrNamespaceExpr list * RewriteState + val TransModuleDef: + penv:RewriteContext -> + z:RewriteState -> + x:TypedTree.ModuleOrNamespaceExpr -> + TypedTree.ModuleOrNamespaceExpr * RewriteState + val TransModuleBindings: + penv:RewriteContext -> + z:RewriteState -> + binds:TypedTree.ModuleOrNamespaceBinding list -> + TypedTree.ModuleOrNamespaceBinding list * RewriteState + val TransModuleBinding: + penv:RewriteContext -> + z:RewriteState -> + x:TypedTree.ModuleOrNamespaceBinding -> + TypedTree.ModuleOrNamespaceBinding * RewriteState + val TransImplFile: + penv:RewriteContext -> + z:RewriteState -> + TypedTree.TypedImplFile -> TypedTree.TypedImplFile * RewriteState + + val RecreateUniqueBounds: + g:TcGlobals.TcGlobals -> + expr:TypedTree.TypedImplFile -> TypedTree.TypedImplFile + val MakeTLRDecisions: + TypedTree.CcuThunk -> + TcGlobals.TcGlobals -> + TypedTree.TypedImplFile -> TypedTree.TypedImplFile + + +namespace FSharp.Compiler + module internal LowerCallsAndSeqs = + val InterceptExpr: + g:TcGlobals.TcGlobals -> + cont:(TypedTree.Expr -> TypedTree.Expr) -> + expr:TypedTree.Expr -> TypedTree.Expr option + val LowerImplFile: + g:TcGlobals.TcGlobals -> + assembly:TypedTree.TypedImplFile -> TypedTree.TypedImplFile + val mkLambdaNoType: + g:TcGlobals.TcGlobals -> + m:Range.range -> uv:TypedTree.Val -> e:TypedTree.Expr -> TypedTree.Expr + val callNonOverloadedMethod: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + methName:string -> + ty:TypedTree.TType -> args:TypedTree.Exprs -> TypedTree.Expr + type LoweredSeqFirstPhaseResult = + { phase2: + TypedTree.ValRef * TypedTree.ValRef * TypedTree.ValRef * + Map -> + TypedTree.Expr * TypedTree.Expr * TypedTree.Expr + entryPoints: int list + significantClose: bool + stateVars: TypedTree.ValRef list + asyncVars: TypedTree.FreeVars } + val isVarFreeInExpr: v:TypedTree.Val -> e:TypedTree.Expr -> bool + val ( |Seq|_| ): + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.TType) option + val IsPossibleSequenceExpr: + g:TcGlobals.TcGlobals -> overallExpr:TypedTree.Expr -> bool + val ConvertSequenceExprToObject: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + overallExpr:TypedTree.Expr -> + (TypedTree.ValRef * TypedTree.ValRef * TypedTree.ValRef * + TypedTree.ValRef list * TypedTree.Expr * TypedTree.Expr * + TypedTree.Expr * TypedTree.TType * Range.range) option + + +namespace FSharp.Compiler + module internal AutoBox = + type cenv = + { g: TcGlobals.TcGlobals + amap: Import.ImportMap } + with + override ToString: unit -> string + + val DecideEscapes: + syntacticArgs:TypedTree.Val list -> + body:TypedTree.Expr -> AbstractIL.Internal.Zset + val DecideLambda: + exprF:(AbstractIL.Internal.Zset -> TypedTree.Expr -> + AbstractIL.Internal.Zset) option -> + cenv:cenv -> + topValInfo:TypedTree.ValReprInfo -> + expr:TypedTree.Expr -> + ety:TypedTree.TType -> + z:AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset + val DecideExprOp: + exprF:(AbstractIL.Internal.Zset -> TypedTree.Expr -> + AbstractIL.Internal.Zset) -> + noInterceptF:(AbstractIL.Internal.Zset -> + TypedTree.Expr -> + AbstractIL.Internal.Zset) -> + z:AbstractIL.Internal.Zset -> + expr:TypedTree.Expr -> + op:TypedTree.TOp * tyargs:'a list * args:TypedTree.Expr list -> + AbstractIL.Internal.Zset + val DecideExpr: + cenv:cenv -> + exprF:(AbstractIL.Internal.Zset -> TypedTree.Expr -> + AbstractIL.Internal.Zset) -> + noInterceptF:(AbstractIL.Internal.Zset -> + TypedTree.Expr -> + AbstractIL.Internal.Zset) -> + z:AbstractIL.Internal.Zset -> + expr:TypedTree.Expr -> AbstractIL.Internal.Zset + val DecideBinding: + cenv:cenv -> + z:AbstractIL.Internal.Zset -> + TypedTree.Binding -> AbstractIL.Internal.Zset + val DecideBindings: + cenv:cenv -> + z:AbstractIL.Internal.Zset -> + binds:TypedTree.Binding list -> + AbstractIL.Internal.Zset + val DecideImplFile: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + implFile:TypedTree.TypedImplFile -> + AbstractIL.Internal.Zset + val TransformExpr: + g:TcGlobals.TcGlobals -> + nvs:TypedTreeOps.ValMap<'a * TypedTree.Expr> -> + exprF:(TypedTree.Expr -> TypedTree.Expr) -> + expr:TypedTree.Expr -> TypedTree.Expr option + val TransformBinding: + g:TcGlobals.TcGlobals -> + nvs:TypedTreeOps.ValMap -> + exprF:(TypedTree.Expr -> TypedTree.Expr) -> + TypedTree.Binding -> TypedTree.Binding option + val TransformImplFile: + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + implFile:TypedTree.TypedImplFile -> TypedTree.TypedImplFile + + +namespace FSharp.Compiler + module internal IlxGen = + val IsNonErasedTypar: tp:TypedTree.Typar -> bool + val DropErasedTypars: tps:TypedTree.Typar list -> TypedTree.Typar list + val DropErasedTyargs: tys:TypedTree.TType list -> TypedTree.TType list + val AddNonUserCompilerGeneratedAttribs: + g:TcGlobals.TcGlobals -> + mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef + val debugDisplayMethodName: string + val useHiddenInitCode: bool + val iLdcZero: AbstractIL.IL.ILInstr + val iLdcInt64: i:int64 -> AbstractIL.IL.ILInstr + val iLdcDouble: i:double -> AbstractIL.IL.ILInstr + val iLdcSingle: i:single -> AbstractIL.IL.ILInstr + val mkLdfldMethodDef: + ilMethName:string * reprAccess:AbstractIL.IL.ILMemberAccess * + isStatic:bool * ilTy:AbstractIL.IL.ILType * ilFieldName:string * + ilPropType:AbstractIL.IL.ILType -> AbstractIL.IL.ILMethodDef + val ChooseParamNames: + fieldNamesAndTypes:(string * string * 'a) list -> + (string * string * 'a) list + val CheckCodeDoesSomething: code:AbstractIL.IL.ILCode -> bool + val ChooseFreeVarNames: + takenNames:string list -> ts:string list -> string list + val IsILTypeByref: _arg1:AbstractIL.IL.ILType -> bool + val mainMethName: string + type AttributeDecoder = + + new: namedArgs:TypedTree.AttribNamedArg list -> AttributeDecoder + member FindBool: x:string -> dflt:bool -> bool + member FindInt16: x:string -> dflt:int16 -> int16 + member FindInt32: x:string -> dflt:int32 -> int32 + member FindString: x:string -> dflt:string -> string + member FindTypeName: x:string -> dflt:string -> string + + val mutable reports: (System.IO.TextWriter -> unit) + val AddReport: f:(System.IO.TextWriter -> unit) -> unit + val ReportStatistics: System.IO.TextWriter -> unit + val NewCounter: nm:string -> (unit -> unit) + val CountClosure: (unit -> unit) + val CountMethodDef: (unit -> unit) + val CountStaticFieldDef: (unit -> unit) + val CountCallFuncInstructions: (unit -> unit) + type IlxGenIntraAssemblyInfo = + { StaticFieldInfo: + System.Collections.Generic.Dictionary } + type FakeUnit = | Fake + type IlxGenBackend = + | IlWriteBackend + | IlReflectBackend + [] + type IlxGenOptions = + { fragName: string + generateFilterBlocks: bool + workAroundReflectionEmitBugs: bool + emitConstantArraysUsingStaticDataBlobs: bool + mainMethodInfo: TypedTree.Attribs option + localOptimizationsAreOn: bool + generateDebugSymbols: bool + testFlagEmitFeeFeeAs100001: bool + ilxBackend: IlxGenBackend + isInteractive: bool + isInteractiveItExpr: bool + alwaysCallVirt: bool } + [] + type cenv = + { g: TcGlobals.TcGlobals + amap: Import.ImportMap + tcVal: ConstraintSolver.TcValF + viewCcu: TypedTree.CcuThunk + opts: IlxGenOptions + mutable ilUnitTy: AbstractIL.IL.ILType option + intraAssemblyInfo: IlxGenIntraAssemblyInfo + casApplied: System.Collections.Generic.Dictionary + mutable optimizeDuringCodeGen: bool -> TypedTree.Expr -> TypedTree.Expr + mutable exprRecursionDepth: int + delayedGenMethods: System.Collections.Generic.Queue<(cenv -> unit)> } + with + override ToString: unit -> string + + val mkTypeOfExpr: + cenv:cenv -> m:Range.range -> ilty:AbstractIL.IL.ILType -> TypedTree.Expr + val mkGetNameExpr: + cenv:cenv -> ilt:AbstractIL.IL.ILType -> m:Range.range -> TypedTree.Expr + val useCallVirt: + cenv:cenv -> + boxity:AbstractIL.IL.ILBoxity -> + mspec:AbstractIL.IL.ILMethodSpec -> isBaseCall:bool -> bool + type CompileLocation = + { Scope: AbstractIL.IL.ILScopeRef + TopImplQualifiedName: string + Namespace: string option + Enclosing: string list + QualifiedNameOfFile: string } + val mkTopName: ns:string option -> n:string -> string + val CompLocForFragment: + fragName:string -> ccu:TypedTree.CcuThunk -> CompileLocation + val CompLocForCcu: ccu:TypedTree.CcuThunk -> CompileLocation + val CompLocForSubModuleOrNamespace: + cloc:CompileLocation -> + submod:TypedTree.ModuleOrNamespace -> CompileLocation + val CompLocForFixedPath: + fragName:string -> + qname:string -> TypedTree.CompilationPath -> CompileLocation + val CompLocForFixedModule: + fragName:string -> + qname:string -> mspec:TypedTree.ModuleOrNamespace -> CompileLocation + val NestedTypeRefForCompLoc: + cloc:CompileLocation -> n:string -> AbstractIL.IL.ILTypeRef + val CleanUpGeneratedTypeName: nm:string -> string + val TypeNameForInitClass: cloc:CompileLocation -> string + val TypeNameForImplicitMainMethod: cloc:CompileLocation -> string + val TypeNameForPrivateImplementationDetails: cloc:CompileLocation -> string + val CompLocForInitClass: cloc:CompileLocation -> CompileLocation + val CompLocForImplicitMainMethod: cloc:CompileLocation -> CompileLocation + val CompLocForPrivateImplementationDetails: + cloc:CompileLocation -> CompileLocation + val TypeRefForCompLoc: cloc:CompileLocation -> AbstractIL.IL.ILTypeRef + val mkILTyForCompLoc: cloc:CompileLocation -> AbstractIL.IL.ILType + val ComputeMemberAccess: hidden:bool -> AbstractIL.IL.ILMemberAccess + val ComputePublicTypeAccess: unit -> AbstractIL.IL.ILTypeDefAccess + val ComputeTypeAccess: + tref:AbstractIL.IL.ILTypeRef -> + hidden:bool -> AbstractIL.IL.ILTypeDefAccess + [] + type TypeReprEnv = + + new: reprs:Map * count:int -> TypeReprEnv + static member ForTycon: tycon:TypedTree.Tycon -> TypeReprEnv + static member ForTyconRef: tycon:TypedTree.TyconRef -> TypeReprEnv + static member ForTypars: tps:TypedTree.Typar list -> TypeReprEnv + member Add: tps:TypedTree.Typar list -> TypeReprEnv + member AddOne: tp:TypedTree.Typar -> TypeReprEnv + member Item: tp:TypedTree.Typar * m:Range.range -> uint16 + member Count: int + static member Empty: TypeReprEnv + + val GenTyconRef: tcref:TypedTree.TyconRef -> TypedTree.CompiledTypeRepr + type VoidNotOK = + | VoidNotOK + | VoidOK + val voidCheck: + m:Range.range -> + g:TcGlobals.TcGlobals -> permits:VoidNotOK -> ty:TypedTree.TType -> unit + type PtrsOK = + | PtrTypesOK + | PtrTypesNotOK + val GenReadOnlyAttributeIfNecessary: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> AbstractIL.IL.ILAttribute option + val GenReadOnlyModReqIfNecessary: + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> ilTy:AbstractIL.IL.ILType -> AbstractIL.IL.ILType + val GenTypeArgAux: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> tyarg:TypedTree.TType -> AbstractIL.IL.ILType + val GenTypeArgsAux: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + tyargs:TypedTree.TType list -> AbstractIL.IL.ILType list + val GenTyAppAux: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + repr:TypedTree.CompiledTypeRepr -> + tinst:TypedTree.TType list -> AbstractIL.IL.ILType + val GenILTyAppAux: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + tref:AbstractIL.IL.ILTypeRef * boxity:AbstractIL.IL.ILBoxity * + ilTypeOpt:AbstractIL.IL.ILType option -> + tinst:TypedTree.TType list -> AbstractIL.IL.ILType + val GenNamedTyAppAux: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + ptrsOK:PtrsOK -> + tcref:TypedTree.TyconRef -> + tinst:TypedTree.TType list -> AbstractIL.IL.ILType + val GenTypeAux: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + voidOK:VoidNotOK -> + ptrsOK:PtrsOK -> ty:TypedTree.TType -> AbstractIL.IL.ILType + val GenUnionCaseRef: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + i:int -> + fspecs:TypedTree.RecdField [] -> + AbstractIL.Extensions.ILX.Types.IlxUnionField [] + val GenUnionRef: + amap:Import.ImportMap -> + m:Range.range -> + tcref:TypedTree.TyconRef -> + AbstractIL.Extensions.ILX.Types.IlxUnionRef + val ComputeUnionHasHelpers: + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> + AbstractIL.Extensions.ILX.Types.IlxUnionHasHelpers + val GenUnionSpec: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + tcref:TypedTree.TyconRef -> + tyargs:TypedTree.TypeInst -> + AbstractIL.Extensions.ILX.Types.IlxUnionSpec + val GenUnionCaseSpec: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + ucref:TypedTree.UnionCaseRef -> + tyargs:TypedTree.TypeInst -> + AbstractIL.Extensions.ILX.Types.IlxUnionSpec * int + val GenType: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> ty:TypedTree.TType -> AbstractIL.IL.ILType + val GenTypes: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + tys:TypedTree.TType list -> AbstractIL.IL.ILType list + val GenTypePermitVoid: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> ty:TypedTree.TType -> AbstractIL.IL.ILType + val GenTypesPermitVoid: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + tys:TypedTree.TType list -> AbstractIL.IL.ILType list + val GenTyApp: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + repr:TypedTree.CompiledTypeRepr -> + tyargs:TypedTree.TType list -> AbstractIL.IL.ILType + val GenNamedTyApp: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + tcref:TypedTree.TyconRef -> + tinst:TypedTree.TType list -> AbstractIL.IL.ILType + val GenReturnType: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + returnTyOpt:TypedTree.TType option -> AbstractIL.IL.ILType + val GenParamType: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + isSlotSig:bool -> ty:TypedTree.TType -> AbstractIL.IL.ILType + val GenParamTypes: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + isSlotSig:bool -> + tys:TypedTree.TType list -> AbstractIL.IL.ILType list + val GenTypeArgs: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> + tyargs:TypedTree.TypeInst -> AbstractIL.IL.ILGenericArgs + val GenTypePermitVoidAux: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> ty:TypedTree.TType -> AbstractIL.IL.ILType + val GenFieldSpecForStaticField: + isInteractive:bool * g:TcGlobals.TcGlobals * + ilContainerTy:AbstractIL.IL.ILType * vspec:TypedTree.Val * nm:string * + m:Range.range * cloc:CompileLocation * ilTy:AbstractIL.IL.ILType -> + AbstractIL.IL.ILFieldSpec + val GenRecdFieldRef: + m:Range.range -> + cenv:cenv -> + tyenv:TypeReprEnv -> + rfref:TypedTree.RecdFieldRef -> + tyargs:TypedTree.TType list -> AbstractIL.IL.ILFieldSpec + val GenExnType: + amap:Import.ImportMap -> + m:Range.range -> + tyenv:TypeReprEnv -> ecref:TypedTree.TyconRef -> AbstractIL.IL.ILType + type ArityInfo = int list + [] + type IlxClosureInfo = + { cloExpr: TypedTree.Expr + cloName: string + cloArityInfo: ArityInfo + ilCloFormalReturnTy: AbstractIL.IL.ILType + ilCloAllFreeVars: AbstractIL.Extensions.ILX.Types.IlxClosureFreeVar [] + cloSpec: AbstractIL.Extensions.ILX.Types.IlxClosureSpec + cloAttribs: TypedTree.Attribs + cloILGenericParams: AbstractIL.IL.ILGenericParameterDefs + cloFreeVars: TypedTree.Val list + cloFreeTyvars: TypedTree.Typars + cloWitnessInfos: TypedTreeOps.TraitWitnessInfos + ilCloLambdas: AbstractIL.Extensions.ILX.Types.IlxClosureLambdas + localTypeFuncILGenericArgs: AbstractIL.IL.ILType list + localTypeFuncContractFreeTypars: TypedTree.Typar list + localTypeFuncDirectILGenericParams: AbstractIL.IL.ILGenericParameterDefs + localTypeFuncInternalFreeTypars: TypedTree.Typar list } + [] + type ValStorage = + | Null + | StaticField of + AbstractIL.IL.ILFieldSpec * TypedTree.ValRef * bool * + AbstractIL.IL.ILType * string * AbstractIL.IL.ILType * + AbstractIL.IL.ILMethodRef * AbstractIL.IL.ILMethodRef * + OptionalShadowLocal + | StaticProperty of AbstractIL.IL.ILMethodSpec * OptionalShadowLocal + | Method of + TypedTree.ValReprInfo * TypedTree.ValRef * AbstractIL.IL.ILMethodSpec * + AbstractIL.IL.ILMethodSpec * Range.range * TypedTree.Typars * + TypedTree.Typars * TypedTreeOps.CurriedArgInfos * + TypedTree.ArgReprInfo list * TypedTreeOps.TraitWitnessInfos * + TypedTree.TType list * TypedTree.ArgReprInfo + | Env of + AbstractIL.IL.ILType * AbstractIL.IL.ILFieldSpec * + NamedLocalIlxClosureInfo ref option + | Arg of int + | Local of idx: int * realloc: bool * NamedLocalIlxClosureInfo ref option + and OptionalShadowLocal = + | NoShadowLocal + | ShadowLocal of ValStorage + and NamedLocalIlxClosureInfo = + | NamedLocalIlxClosureInfoGenerator of (IlxGenEnv -> IlxClosureInfo) + | NamedLocalIlxClosureInfoGenerated of IlxClosureInfo + with + override ToString: unit -> string + + and ModuleStorage = + { Vals: Lazy> + SubModules: Lazy> } + with + override ToString: unit -> string + + and BranchCallItem = + | BranchCallClosure of ArityInfo + | BranchCallMethod of + ArityInfo * (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.Typars * int * int * int + with + override ToString: unit -> string + + and Mark = + | Mark of AbstractIL.IL.ILCodeLabel + with + member CodeLabel: AbstractIL.IL.ILCodeLabel + + and sequel = + | EndFilter + | LeaveHandler of (bool * int * Mark) + | Br of Mark + | CmpThenBrOrContinue of Pops * AbstractIL.IL.ILInstr list + | Continue + | DiscardThen of sequel + | Return + | EndLocalScope of sequel * Mark + | ReturnVoid + and Pushes = AbstractIL.IL.ILType list + and Pops = int + and IlxGenEnv = + { tyenv: TypeReprEnv + someTypeInThisAssembly: AbstractIL.IL.ILType + isFinalFile: bool + cloc: CompileLocation + sigToImplRemapInfo: + (TypedTreeOps.Remap * TypedTreeOps.SignatureHidingInfo) list + valsInScope: TypedTreeOps.ValMap> + witnessesInScope: TypedTreeOps.TraitWitnessInfoHashMap + suppressWitnesses: bool + innerVals: (TypedTree.ValRef * (BranchCallItem * Mark)) list + letBoundVars: TypedTree.ValRef list + liveLocals: Lib.IntMap + withinSEH: bool + isInLoop: bool } + with + override ToString: unit -> string + + val discard: sequel + val discardAndReturnVoid: sequel + val SetIsInLoop: isInLoop:bool -> eenv:IlxGenEnv -> IlxGenEnv + val ReplaceTyenv: tyenv:TypeReprEnv -> eenv:IlxGenEnv -> IlxGenEnv + val EnvForTypars: tps:TypedTree.Typar list -> eenv:IlxGenEnv -> IlxGenEnv + val AddTyparsToEnv: + typars:TypedTree.Typar list -> eenv:IlxGenEnv -> IlxGenEnv + val AddSignatureRemapInfo: + _msg:'a -> + rpi:TypedTreeOps.SignatureRepackageInfo * + mhi:TypedTreeOps.SignatureHidingInfo -> eenv:IlxGenEnv -> IlxGenEnv + val OutputStorage: pps:System.IO.TextWriter -> s:ValStorage -> unit + val AddStorageForVal: + g:TcGlobals.TcGlobals -> + v:TypedTree.Val * s:Lazy -> eenv:IlxGenEnv -> IlxGenEnv + val AddStorageForLocalVals: + g:TcGlobals.TcGlobals -> + vals:(TypedTree.Val * ValStorage) list -> eenv:IlxGenEnv -> IlxGenEnv + val AddStorageForLocalWitness: + eenv:IlxGenEnv -> w:TypedTree.TraitWitnessInfo * s:ValStorage -> IlxGenEnv + val AddStorageForLocalWitnesses: + witnesses:(TypedTree.TraitWitnessInfo * ValStorage) list -> + eenv:IlxGenEnv -> IlxGenEnv + val StorageForVal: + g:TcGlobals.TcGlobals -> + m:Range.range -> v:TypedTree.Val -> eenv:IlxGenEnv -> ValStorage + val StorageForValRef: + g:TcGlobals.TcGlobals -> + m:Range.range -> v:TypedTree.ValRef -> eenv:IlxGenEnv -> ValStorage + val ComputeGenerateWitnesses: + g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> bool + val TryStorageForWitness: + _g:TcGlobals.TcGlobals -> + eenv:IlxGenEnv -> w:TypedTree.TraitWitnessInfo -> ValStorage option + val IsValRefIsDllImport: + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val GetMethodSpecForMemberVal: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + memberInfo:TypedTree.ValMemberInfo -> + vref:TypedTree.ValRef -> + AbstractIL.IL.ILMethodSpec * AbstractIL.IL.ILMethodSpec * + TypedTree.Typar list * TypedTree.Typar list * + TypedTreeOps.CurriedArgInfos * TypedTree.ArgReprInfo list * + TypedTree.ArgReprInfo * TypedTreeOps.TraitWitnessInfos * + TypedTree.TType list * TypedTree.TType option + val ComputeFieldSpecForVal: + optIntraAssemblyInfo:IlxGenIntraAssemblyInfo option * isInteractive:bool * + g:TcGlobals.TcGlobals * ilTyForProperty:AbstractIL.IL.ILType * + vspec:TypedTree.Val * nm:string * m:Range.range * cloc:CompileLocation * + ilTy:AbstractIL.IL.ILType * ilGetterMethRef:AbstractIL.IL.ILMethodRef -> + AbstractIL.IL.ILFieldSpec + val ComputeStorageForFSharpValue: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + cloc:CompileLocation -> + optIntraAssemblyInfo:IlxGenIntraAssemblyInfo option -> + optShadowLocal:OptionalShadowLocal -> + isInteractive:bool -> + returnTy:TypedTree.TType -> + vref:TypedTree.ValRef -> m:Range.range -> ValStorage + val ComputeStorageForFSharpMember: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + topValInfo:TypedTree.ValReprInfo -> + memberInfo:TypedTree.ValMemberInfo -> + vref:TypedTree.ValRef -> m:Range.range -> ValStorage + val ComputeStorageForFSharpFunctionOrFSharpExtensionMember: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + cloc:CompileLocation -> + topValInfo:TypedTree.ValReprInfo -> + vref:TypedTree.ValRef -> m:Range.range -> ValStorage + val IsFSharpValCompiledAsMethod: + TcGlobals.TcGlobals -> TypedTree.Val -> bool + val ComputeStorageForTopVal: + amap:Import.ImportMap * g:TcGlobals.TcGlobals * + optIntraAssemblyInfo:IlxGenIntraAssemblyInfo option * isInteractive:bool * + optShadowLocal:OptionalShadowLocal * vref:TypedTree.ValRef * + cloc:CompileLocation -> ValStorage + val ComputeAndAddStorageForLocalTopVal: + amap:Import.ImportMap * g:TcGlobals.TcGlobals * + intraAssemblyFieldTable:IlxGenIntraAssemblyInfo * isInteractive:bool * + optShadowLocal:OptionalShadowLocal -> + cloc:CompileLocation -> v:TypedTree.Val -> eenv:IlxGenEnv -> IlxGenEnv + val ComputeStorageForNonLocalTopVal: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + cloc:CompileLocation -> + modref:TypedTree.EntityRef -> v:TypedTree.Val -> ValStorage + val AddStorageForNonLocalModuleOrNamespaceRef: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + cloc:CompileLocation -> + acc:IlxGenEnv -> + modref:TypedTree.ModuleOrNamespaceRef -> + modul:TypedTree.ModuleOrNamespace -> IlxGenEnv + val AddStorageForExternalCcu: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + eenv:IlxGenEnv -> ccu:TypedTree.CcuThunk -> IlxGenEnv + val AddBindingsForLocalModuleType: + allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> + cloc:CompileLocation -> + eenv:'a -> mty:TypedTree.ModuleOrNamespaceType -> 'a + val AddExternalCcusToIlxGenEnv: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + eenv:IlxGenEnv -> ccus:TypedTree.CcuThunk list -> IlxGenEnv + val AddBindingsForTycon: + allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> + cloc:CompileLocation -> tycon:TypedTree.Tycon -> eenv:'a -> 'a + val AddBindingsForModuleDefs: + allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> + cloc:CompileLocation -> + eenv:'a -> mdefs:TypedTree.ModuleOrNamespaceExpr list -> 'a + val AddBindingsForModuleDef: + allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> + cloc:CompileLocation -> + eenv:'a -> x:TypedTree.ModuleOrNamespaceExpr -> 'a + val AddBindingsForModule: + allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> + cloc:CompileLocation -> + x:TypedTree.ModuleOrNamespaceBinding -> eenv:'a -> 'a + val AddBindingsForModuleTopVals: + _g:'a -> + allocVal:('b -> 'c -> 'c) -> _cloc:'d -> eenv:'c -> vs:'b list -> 'c + val AddIncrementalLocalAssemblyFragmentToIlxGenEnv: + amap:Import.ImportMap * isIncrementalFragment:bool * g:TcGlobals.TcGlobals * + ccu:TypedTree.CcuThunk * fragName:string * + intraAssemblyInfo:IlxGenIntraAssemblyInfo * eenv:IlxGenEnv * + typedImplFiles:TypedTree.TypedImplFile list -> IlxGenEnv + val GenILSourceMarker: + g:TcGlobals.TcGlobals -> m:Range.range -> AbstractIL.IL.ILSourceMarker + val GenPossibleILSourceMarker: + cenv:cenv -> m:Range.range -> AbstractIL.IL.ILSourceMarker option + val HashRangeSorted: + ht:System.Collections.Generic.IDictionary<'a,(int * 'b)> -> 'b list + val MergeOptions: + m:Range.range -> o1:'a option -> o2:'a option -> 'a option + val MergePropertyPair: + m:Range.range -> + pd:AbstractIL.IL.ILPropertyDef -> + pdef:AbstractIL.IL.ILPropertyDef -> AbstractIL.IL.ILPropertyDef + type PropKey = + | PropKey of + string * AbstractIL.IL.ILTypes * AbstractIL.IL.ILThisConvention + val AddPropertyDefToHash: + m:Range.range -> + ht:System.Collections.Generic.Dictionary -> + pdef:AbstractIL.IL.ILPropertyDef -> unit + val MergePropertyDefs: + m:Range.range -> + ilPropertyDefs:#AbstractIL.IL.ILPropertyDef list -> + AbstractIL.IL.ILPropertyDef list + type TypeDefBuilder = + + new: tdef:AbstractIL.IL.ILTypeDef * + tdefDiscards:((AbstractIL.IL.ILMethodDef -> bool) * + (AbstractIL.IL.ILPropertyDef -> bool)) option -> + TypeDefBuilder + member AddEventDef: edef:AbstractIL.IL.ILEventDef -> unit + member AddFieldDef: ilFieldDef:AbstractIL.IL.ILFieldDef -> unit + member AddMethodDef: ilMethodDef:AbstractIL.IL.ILMethodDef -> unit + member + AddOrMergePropertyDef: pdef:AbstractIL.IL.ILPropertyDef * + m:Range.range -> unit + member Close: unit -> AbstractIL.IL.ILTypeDef + member GetCurrentFields: unit -> seq + member + PrependInstructionsToSpecificMethodDef: cond:(AbstractIL.IL.ILMethodDef -> + bool) * + instrs:AbstractIL.IL.ILInstr list * + tag:AbstractIL.IL.ILSourceMarker option -> + unit + member NestedTypeDefs: TypeDefsBuilder + + and TypeDefsBuilder = + + new: unit -> TypeDefsBuilder + member + AddTypeDef: tdef:AbstractIL.IL.ILTypeDef * eliminateIfEmpty:bool * + addAtEnd:bool * + tdefDiscards:((AbstractIL.IL.ILMethodDef -> bool) * + (AbstractIL.IL.ILPropertyDef -> bool)) option -> + unit + member Close: unit -> AbstractIL.IL.ILTypeDef list + member + FindNestedTypeDefBuilder: tref:AbstractIL.IL.ILTypeRef -> + TypeDefBuilder + member FindNestedTypeDefsBuilder: path:string list -> TypeDefsBuilder + member FindTypeDefBuilder: nm:string -> TypeDefBuilder + + type AnonTypeGenerationTable = + + new: unit -> AnonTypeGenerationTable + member + Table: System.Collections.Generic.Dictionary + + type AssemblyBuilder = + + new: cenv:cenv * anonTypeTable:AnonTypeGenerationTable -> + AssemblyBuilder + member + AddEventDef: tref:AbstractIL.IL.ILTypeRef * + edef:AbstractIL.IL.ILEventDef -> unit + member + AddExplicitInitToSpecificMethodDef: cond:(AbstractIL.IL.ILMethodDef -> + bool) * + tref:AbstractIL.IL.ILTypeRef * + fspec:AbstractIL.IL.ILFieldSpec * + sourceOpt:AbstractIL.IL.ILSourceMarker option * + feefee:AbstractIL.IL.ILInstr list * + seqpt:AbstractIL.IL.ILInstr list -> + unit + member + AddFieldDef: tref:AbstractIL.IL.ILTypeRef * + ilFieldDef:AbstractIL.IL.ILFieldDef -> unit + member AddInitializeScriptsInOrderToEntryPoint: unit -> unit + member + AddMethodDef: tref:AbstractIL.IL.ILTypeRef * + ilMethodDef:AbstractIL.IL.ILMethodDef -> unit + member + AddOrMergePropertyDef: tref:AbstractIL.IL.ILTypeRef * + pdef:AbstractIL.IL.ILPropertyDef * + m:Range.range -> unit + member + AddReflectedDefinition: vspec:TypedTree.Val * expr:TypedTree.Expr -> + unit + member + AddScriptInitFieldSpec: fieldSpec:AbstractIL.IL.ILFieldSpec * + range:Range.range -> unit + member + AddTypeDef: tref:AbstractIL.IL.ILTypeRef * + tdef:AbstractIL.IL.ILTypeDef * eliminateIfEmpty:bool * + addAtEnd:bool * + tdefDiscards:((AbstractIL.IL.ILMethodDef -> bool) * + (AbstractIL.IL.ILPropertyDef -> bool)) option -> + unit + member + Close: unit -> + AbstractIL.IL.ILTypeDef list * + ((string * TypedTree.Val) * TypedTree.Expr) list + member + GenerateAnonType: genToStringMethod:(AbstractIL.IL.ILType -> + #seq) * + anonInfo:TypedTree.AnonRecdTypeInfo -> unit + member + GenerateRawDataValueType: cloc:CompileLocation * size:int -> + AbstractIL.IL.ILTypeSpec + member + GetCurrentFields: tref:AbstractIL.IL.ILTypeRef -> + seq + member + GetExplicitEntryPointInfo: unit -> AbstractIL.IL.ILTypeRef option + member GrabExtraBindingsToGenerate: unit -> TypedTree.Binding list + member + LookupAnonType: genToStringMethod:(AbstractIL.IL.ILType -> + #seq) * + anonInfo:TypedTree.AnonRecdTypeInfo -> + AbstractIL.IL.ILMethodRef * + AbstractIL.IL.ILMethodRef [] * AbstractIL.IL.ILType + member + ReplaceNameOfReflectedDefinition: vspec:TypedTree.Val * + newName:string -> unit + member cenv: cenv + + val pop: i:int -> Pops + val Push: tys:Pushes -> Pushes + val Push0: Pushes + val FeeFee: cenv:cenv -> int + val FeeFeeInstr: + cenv:cenv -> doc:AbstractIL.IL.ILSourceDocument -> AbstractIL.IL.ILInstr + type CodeGenBuffer = + + new: m:Range.range * mgbuf:AssemblyBuilder * methodName:string * + alreadyUsedArgs:int -> CodeGenBuffer + member + AllocLocal: ranges:(string * (Mark * Mark)) list * + ty:AbstractIL.IL.ILType * isFixed:bool -> int + member AssertEmptyStack: unit -> unit + member + Close: unit -> + ((string * (Mark * Mark)) list * AbstractIL.IL.ILType * bool) list * + int * + System.Collections.Generic.Dictionary * + AbstractIL.IL.ILInstr [] * + AbstractIL.IL.ILExceptionSpec list * bool + member DoPops: n:Pops -> unit + member DoPushes: pushes:Pushes -> unit + member + EmitExceptionClause: clause:AbstractIL.IL.ILExceptionSpec -> unit + member + EmitInstr: pops:Pops * pushes:Pushes * i:AbstractIL.IL.ILInstr -> + unit + member + EmitInstrs: pops:Pops * pushes:Pushes * is:AbstractIL.IL.ILInstr list -> + unit + member EmitSeqPoint: src:Range.range -> unit + member EmitStartOfHiddenCode: unit -> unit + member private EnsureNopBetweenDebugPoints: unit -> unit + member GenerateDelayMark: _nm:'b -> Mark + member GetCurrentStack: unit -> AbstractIL.IL.ILType list + member GetLastDebugPoint: unit -> Range.range option + member Mark: s:'a -> Mark + member + ReallocLocal: cond:(int -> + (string * (Mark * Mark)) list * + AbstractIL.IL.ILType * bool -> bool) * + ranges:(string * (Mark * Mark)) list * + ty:AbstractIL.IL.ILType * isFixed:bool -> int * bool + member + SetCodeLabelToCodeLabel: lab1:AbstractIL.IL.ILCodeLabel * + lab2:AbstractIL.IL.ILCodeLabel -> unit + member SetCodeLabelToPC: lab:AbstractIL.IL.ILCodeLabel * pc:int -> unit + member SetMark: mark1:Mark * mark2:Mark -> unit + member SetMarkToHere: Mark -> unit + member SetStack: s:AbstractIL.IL.ILType list -> unit + member MethodName: string + member PreallocatedArgCount: int + member mgbuf: AssemblyBuilder + + module CG = + val EmitInstr: + cgbuf:CodeGenBuffer -> + pops:Pops -> pushes:Pushes -> i:AbstractIL.IL.ILInstr -> unit + val EmitInstrs: + cgbuf:CodeGenBuffer -> + pops:Pops -> pushes:Pushes -> is:AbstractIL.IL.ILInstr list -> unit + val EmitSeqPoint: cgbuf:CodeGenBuffer -> src:Range.range -> unit + val GenerateDelayMark: cgbuf:CodeGenBuffer -> nm:'a -> Mark + val SetMark: cgbuf:CodeGenBuffer -> m1:Mark -> m2:Mark -> unit + val SetMarkToHere: cgbuf:CodeGenBuffer -> m1:Mark -> unit + val SetStack: cgbuf:CodeGenBuffer -> s:AbstractIL.IL.ILType list -> unit + val GenerateMark: cgbuf:CodeGenBuffer -> s:'a -> Mark + + val GenString: cenv:cenv -> cgbuf:CodeGenBuffer -> s:string -> unit + val GenConstArray: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + ilElementType:AbstractIL.IL.ILType -> + data:'a [] -> + write:(AbstractIL.Internal.ByteBuffer -> 'a -> unit) -> unit + val CodeGenThen: + cenv:cenv -> + mgbuf:AssemblyBuilder -> + entryPointInfo:(TypedTree.ValRef * BranchCallItem) list * + methodName:string * eenv:IlxGenEnv * alreadyUsedArgs:int * + codeGenFunction:(CodeGenBuffer -> IlxGenEnv -> unit) * m:Range.range -> + AbstractIL.IL.ILLocal list * int * + System.Collections.Generic.Dictionary * + AbstractIL.IL.ILInstr [] * AbstractIL.IL.ILExceptionSpec list * + AbstractIL.IL.ILLocalDebugInfo list * bool + val CodeGenMethod: + cenv:cenv -> + mgbuf:AssemblyBuilder -> + entryPointInfo:(TypedTree.ValRef * BranchCallItem) list * + methodName:string * eenv:IlxGenEnv * alreadyUsedArgs:int * + codeGenFunction:(CodeGenBuffer -> IlxGenEnv -> unit) * m:Range.range -> + AbstractIL.IL.ILInstr [] * AbstractIL.IL.ILMethodBody + val StartDelayedLocalScope: nm:string -> cgbuf:CodeGenBuffer -> Mark * Mark + val StartLocalScope: nm:string -> cgbuf:CodeGenBuffer -> Mark * Mark + val LocalScope: + nm:string -> cgbuf:CodeGenBuffer -> f:(Mark * Mark -> 'a) -> 'a + val compileSequenceExpressions: bool + type EmitDebugPointState = + | SPAlways + | SPSuppress + val BindingEmitsNoCode: + g:TcGlobals.TcGlobals -> b:TypedTree.Binding -> bool + val ComputeDebugPointForBinding: + g:TcGlobals.TcGlobals -> + TypedTree.Binding -> bool * Range.range option * EmitDebugPointState + val BindingEmitsDebugPoint: + g:TcGlobals.TcGlobals -> bind:TypedTree.Binding -> bool + val BindingIsInvisible: TypedTree.Binding -> bool + val BindingEmitsHiddenCode: TypedTree.Binding -> bool + val FirstEmittedCodeWillBeDebugPoint: + g:TcGlobals.TcGlobals -> + sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool + val EmitDebugPointForWholeExpr: + g:TcGlobals.TcGlobals -> + sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool + val EmitHiddenCodeMarkerForWholeExpr: + g:TcGlobals.TcGlobals -> + sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool + val RangeOfDebugPointForWholeExpr: + g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> Range.range + val DoesGenExprStartWithDebugPoint: + g:TcGlobals.TcGlobals -> + sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool + val ProcessDebugPointForExpr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + sp:EmitDebugPointState -> expr:TypedTree.Expr -> unit + val GenExpr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + sp:EmitDebugPointState -> + expr:TypedTree.Expr -> sequel:sequel -> unit + val ProcessDelayedGenMethods: cenv:cenv -> unit + val GenExprWithStackGuard: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + sp:EmitDebugPointState -> + expr:TypedTree.Expr -> sequel:sequel -> unit + val GenExprPreSteps: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + sp:EmitDebugPointState -> + expr:TypedTree.Expr -> sequel:sequel -> bool + val GenExprAux: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + sp:EmitDebugPointState -> + expr:TypedTree.Expr -> sequel:sequel -> unit + val GenExprs: + cenv:cenv -> + cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> es:TypedTree.Expr list -> unit + val CodeGenMethodForExpr: + cenv:cenv -> + mgbuf:AssemblyBuilder -> + spReq:EmitDebugPointState * + entryPointInfo:(TypedTree.ValRef * BranchCallItem) list * + methodName:string * eenv:IlxGenEnv * alreadyUsedArgs:int * + expr0:TypedTree.Expr * sequel0:sequel -> AbstractIL.IL.ILMethodBody + val sequelAfterDiscard: sequel:sequel -> sequel option + val sequelIgnoringEndScopesAndDiscard: sequel:sequel -> sequel + val sequelIgnoreEndScopes: sequel:sequel -> sequel + val GenSequelEndScopes: cgbuf:CodeGenBuffer -> sequel:sequel -> unit + val StringOfSequel: sequel:sequel -> string + val GenSequel: + cenv:cenv -> + cloc:CompileLocation -> cgbuf:CodeGenBuffer -> sequel:sequel -> unit + val GenConstant: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + c:TypedTree.Const * m:Range.range * ty:TypedTree.TType -> + sequel:sequel -> unit + val GenUnitTy: + cenv:cenv -> eenv:IlxGenEnv -> m:Range.range -> AbstractIL.IL.ILType + val GenUnit: + cenv:cenv -> + eenv:IlxGenEnv -> m:Range.range -> cgbuf:CodeGenBuffer -> unit + val GenUnitThenSequel: + cenv:cenv -> + eenv:IlxGenEnv -> + m:Range.range -> + cloc:CompileLocation -> cgbuf:CodeGenBuffer -> sequel:sequel -> unit + val GenAllocTuple: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + tupInfo:TypedTree.TupInfo * args:TypedTree.Exprs * + argtys:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit + val GenGetTupleField: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + tupInfo:TypedTree.TupInfo * e:TypedTree.Expr * + tys:TypedTree.TypeInst * n:int * m:Range.range -> + sequel:sequel -> unit + val GenAllocExn: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + c:TypedTree.TyconRef * args:TypedTree.Exprs * m:Range.range -> + sequel:sequel -> unit + val GenAllocUnionCaseCore: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + c:TypedTree.UnionCaseRef * tyargs:TypedTree.TypeInst * n:int * + m:Range.range -> unit + val GenAllocUnionCase: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + c:TypedTree.UnionCaseRef * tyargs:TypedTree.TypeInst * + args:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit + val GenLinearExpr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + sp:EmitDebugPointState -> + expr:TypedTree.Expr -> + sequel:sequel -> + preSteps:bool -> contf:(FakeUnit -> FakeUnit) -> FakeUnit + val GenAllocRecd: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + ctorInfo:TypedTree.RecordConstructionInfo -> + tcref:TypedTree.TyconRef * argtys:TypedTree.TypeInst * + args:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit + val GenAllocAnonRecd: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + anonInfo:TypedTree.AnonRecdTypeInfo * tyargs:TypedTree.TypeInst * + args:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit + val GenGetAnonRecdField: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + anonInfo:TypedTree.AnonRecdTypeInfo * e:TypedTree.Expr * + tyargs:TypedTree.TypeInst * n:int * m:Range.range -> + sequel:sequel -> unit + val GenNewArraySimple: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + elems:TypedTree.Expr list * elemTy:TypedTree.TType * m:Range.range -> + sequel:sequel -> unit + val GenNewArray: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + elems:TypedTree.Expr list * elemTy:TypedTree.TType * m:Range.range -> + sequel:sequel -> unit + val GenCoerce: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e:TypedTree.Expr * tgty:TypedTree.TType * m:Range.range * + srcty:TypedTree.TType -> sequel:sequel -> unit + val GenReraise: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + rtnty:TypedTree.TType * m:Range.range -> sequel:sequel -> unit + val GenGetExnField: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e:TypedTree.Expr * ecref:TypedTree.TyconRef * fieldNum:int * + m:Range.range -> sequel:sequel -> unit + val GenSetExnField: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e:TypedTree.Expr * ecref:TypedTree.TyconRef * fieldNum:int * + e2:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit + val UnionCodeGen: + cgbuf:CodeGenBuffer -> + AbstractIL.Extensions.ILX.EraseUnions.ICodeGen + val GenUnionCaseProof: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * + tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit + val GenGetUnionCaseField: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * + tyargs:TypedTree.TypeInst * n:int * m:Range.range -> + sequel:sequel -> unit + val GenGetUnionCaseFieldAddr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * + tyargs:TypedTree.TypeInst * n:int * m:Range.range -> + sequel:sequel -> unit + val GenGetUnionCaseTag: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e:TypedTree.Expr * tcref:TypedTree.TyconRef * + tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit + val GenSetUnionCaseField: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * + tyargs:TypedTree.TypeInst * n:int * e2:TypedTree.Expr * + m:Range.range -> sequel:sequel -> unit + val GenGetRecdFieldAddr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e:TypedTree.Expr * f:TypedTree.RecdFieldRef * + tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit + val GenGetStaticFieldAddr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * m:Range.range -> + sequel:sequel -> unit + val GenGetRecdField: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e:TypedTree.Expr * f:TypedTree.RecdFieldRef * + tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit + val GenSetRecdField: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e1:TypedTree.Expr * f:TypedTree.RecdFieldRef * + tyargs:TypedTree.TypeInst * e2:TypedTree.Expr * m:Range.range -> + sequel:sequel -> unit + val GenGetStaticField: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * m:Range.range -> + sequel:sequel -> unit + val GenSetStaticField: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * + e2:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit + val mk_field_pops: isStatic:bool -> n:int -> Pops + val GenFieldGet: + isStatic:bool -> + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + rfref:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * + m:Range.range -> unit + val GenFieldStore: + isStatic:bool -> + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + rfref:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * + m:Range.range -> sequel:sequel -> unit + val GenUntupledArgsDiscardingLoneUnit: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> + numObjArgs:int -> + curriedArgInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> + args:TypedTree.Expr list -> unit + val GenUntupledArgExpr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> + argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list -> + expr:TypedTree.Expr -> unit + val GenWitnessArgFromTraitInfo: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> traitInfo:TypedTree.TraitConstraintInfo -> unit + val GenWitnessArgFromWitnessInfo: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> witnessInfo:TypedTree.TraitWitnessInfo -> unit + val GenWitnessArgsFromWitnessInfos: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> + witnessInfos:seq -> unit + val GenWitnessArgs: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> + tps:TypedTree.Typars -> tyargs:TypedTree.TType list -> unit + val GenApp: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + f:TypedTree.Expr * fty:TypedTree.TType * tyargs:TypedTree.TypeInst * + curriedArgs:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit + val CanTailcall: + hasStructObjArg:bool * ccallInfo:TypedTree.TType option * withinSEH:bool * + hasByrefArg:bool * mustGenerateUnitAfterCall:bool * isDllImport:bool * + isSelfInit:bool * makesNoCriticalTailcalls:bool * sequel:sequel -> + AbstractIL.IL.ILTailcall + val GenNamedLocalTyFuncCall: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + ty:TypedTree.TType -> + cloinfo:IlxClosureInfo -> + tyargs:TypedTree.TypeInst -> m:Range.range -> TypedTree.TType + val GenCurriedArgsAndIndirectCall: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + functy:TypedTree.TType * tyargs:TypedTree.TypeInst * + curriedArgs:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit + val GenIndirectCall: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + functy:TypedTree.TType * tyargs:TypedTree.TType list * + curriedArgs:TypedTree.Expr list * m:Range.range -> + sequel:sequel -> unit + val GenTry: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + Mark * Mark -> + e1:TypedTree.Expr * m:Range.range * resty:TypedTree.TType * + spTry:SyntaxTree.DebugPointAtTry -> + int * IlxGenEnv * (AbstractIL.IL.ILType list * int list) * + (AbstractIL.IL.ILCodeLabel * AbstractIL.IL.ILCodeLabel) * Mark * + AbstractIL.IL.ILType + val GenTryWith: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e1:TypedTree.Expr * vf:TypedTree.Val * ef:TypedTree.Expr * + vh:TypedTree.Val * eh:TypedTree.Expr * m:Range.range * + resty:TypedTree.TType * spTry:SyntaxTree.DebugPointAtTry * + spWith:SyntaxTree.DebugPointAtWith -> sequel:sequel -> unit + val GenTryFinally: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + bodyExpr:TypedTree.Expr * handlerExpr:TypedTree.Expr * m:Range.range * + resty:TypedTree.TType * spTry:SyntaxTree.DebugPointAtTry * + spFinally:SyntaxTree.DebugPointAtFinally -> sequel:sequel -> unit + val GenForLoop: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + spFor:SyntaxTree.DebugPointAtFor * v:TypedTree.Val * + e1:TypedTree.Expr * dir:TypedTree.ForLoopStyle * e2:TypedTree.Expr * + loopBody:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit + val GenWhileLoop: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + spWhile:SyntaxTree.DebugPointAtWhile * e1:TypedTree.Expr * + e2:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit + val GenAsmCode: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + il:AbstractIL.IL.ILInstr list * tyargs:TypedTree.TypeInst * + args:TypedTree.Exprs * returnTys:TypedTree.TTypes * m:Range.range -> + sequel:sequel -> unit + val GenQuotation: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + ast:TypedTree.Expr * + qdataCell:((AbstractIL.IL.ILTypeRef list * TypedTree.TTypes * + TypedTree.Exprs * QuotationPickler.ExprData) * + (AbstractIL.IL.ILTypeRef list * TypedTree.TTypes * + TypedTree.Exprs * QuotationPickler.ExprData)) option ref * + m:Range.range * ety:TypedTree.TType -> sequel:sequel -> unit + val GenILCall: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + virt:bool * valu:bool * newobj:bool * + valUseFlags:TypedTree.ValUseFlag * isDllImport:bool * + ilMethRef:AbstractIL.IL.ILMethodRef * enclArgTys:TypedTree.TypeInst * + methArgTys:TypedTree.TypeInst * argExprs:TypedTree.Exprs * + returnTys:TypedTree.TTypes * m:Range.range -> sequel:sequel -> unit + val CommitCallSequel: + cenv:cenv -> + eenv:IlxGenEnv -> + m:Range.range -> + cloc:CompileLocation -> + cgbuf:CodeGenBuffer -> + mustGenerateUnitAfterCall:bool -> sequel:sequel -> unit + val MakeNotSupportedExnExpr: + cenv:cenv -> + eenv:IlxGenEnv -> + argExpr:TypedTree.Expr * m:Range.range -> TypedTree.Expr + val GenTraitCall: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + traitInfo:TypedTree.TraitConstraintInfo * argExprs:TypedTree.Exprs * + m:Range.range -> expr:TypedTree.Expr -> sequel:sequel -> unit + val GenGetAddrOfRefCellField: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + e:TypedTree.Expr * ty:TypedTree.TType * m:Range.range -> + sequel:sequel -> unit + val GenGetValAddr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + v:TypedTree.ValRef * m:Range.range -> sequel:sequel -> unit + val GenGetByref: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + v:TypedTree.ValRef * m:Range.range -> sequel:sequel -> unit + val GenSetByref: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + v:TypedTree.ValRef * e:TypedTree.Expr * m:Range.range -> + sequel:sequel -> unit + val GenDefaultValue: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> ty:TypedTree.TType * m:Range.range -> unit + val GenGenericParam: + cenv:cenv -> + eenv:IlxGenEnv -> + tp:TypedTree.Typar -> AbstractIL.IL.ILGenericParameterDef + val GenSlotParam: + m:Range.range -> + cenv:cenv -> + eenv:IlxGenEnv -> TypedTree.SlotParam -> AbstractIL.IL.ILParameter + val GenFormalSlotsig: + m:Range.range -> + cenv:cenv -> + eenv:IlxGenEnv -> + TypedTree.SlotSig -> + AbstractIL.IL.ILType * AbstractIL.IL.ILParameter list * + AbstractIL.IL.ILReturn + val instSlotParam: + inst:TypedTreeOps.TyparInst -> TypedTree.SlotParam -> TypedTree.SlotParam + val GenActualSlotsig: + m:Range.range -> + cenv:cenv -> + eenv:IlxGenEnv -> + TypedTree.SlotSig -> + methTyparsOfOverridingMethod:TypedTree.Typars -> + methodParams:TypedTree.Val list -> + AbstractIL.IL.ILParameter list * AbstractIL.IL.ILReturn + val GenNameOfOverridingMethod: + cenv:cenv -> useMethodImpl:bool * slotsig:TypedTree.SlotSig -> string + val GenMethodImpl: + cenv:cenv -> + eenv:IlxGenEnv -> + useMethodImpl:bool * TypedTree.SlotSig -> + m:Range.range -> + string * + (AbstractIL.IL.ILType * TypedTree.Typar list -> + AbstractIL.IL.ILMethodImplDef) + val bindBaseOrThisVarOpt: + cenv:cenv -> + eenv:IlxGenEnv -> baseValOpt:TypedTree.Val option -> IlxGenEnv + val fixupVirtualSlotFlags: + mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef + val renameMethodDef: + nameOfOverridingMethod:string -> + mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef + val fixupMethodImplFlags: + mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef + val GenObjectMethod: + cenv:cenv -> + eenvinner:IlxGenEnv -> + cgbuf:CodeGenBuffer -> + useMethodImpl:bool -> + tmethod:TypedTree.ObjExprMethod -> + ((bool * + (AbstractIL.IL.ILType * TypedTree.Typar list -> + AbstractIL.IL.ILMethodImplDef) * TypedTree.Typars) * + AbstractIL.IL.ILMethodDef) list + val GenObjectExpr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenvouter:IlxGenEnv -> + expr:TypedTree.Expr -> + baseType:TypedTree.TType * baseValOpt:TypedTree.Val option * + basecall:TypedTree.Expr * overrides:TypedTree.ObjExprMethod list * + interfaceImpls:(TypedTree.TType * TypedTree.ObjExprMethod list) list * + m:Range.range -> sequel:sequel -> unit + val GenSequenceExpr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenvouter:IlxGenEnv -> + nextEnumeratorValRef:TypedTree.ValRef * pcvref:TypedTree.ValRef * + currvref:TypedTree.ValRef * stateVars:TypedTree.ValRef list * + generateNextExpr:TypedTree.Expr * closeExpr:TypedTree.Expr * + checkCloseExpr:TypedTree.Expr * seqElemTy:TypedTree.TType * + m:Range.range -> sequel:sequel -> unit + val GenClosureTypeDefs: + cenv:cenv -> + tref:AbstractIL.IL.ILTypeRef * + ilGenParams:AbstractIL.IL.ILGenericParameterDefs * + attrs:AbstractIL.IL.ILAttribute list * + ilCloAllFreeVars:AbstractIL.Extensions.ILX.Types.IlxClosureFreeVar [] * + ilCloLambdas:AbstractIL.Extensions.ILX.Types.IlxClosureLambdas * + ilCtorBody:AbstractIL.IL.ILMethodBody * + mdefs:AbstractIL.IL.ILMethodDef list * + mimpls:AbstractIL.IL.ILMethodImplDef list * ext:AbstractIL.IL.ILType * + ilIntfTys:AbstractIL.IL.ILType list * + cloSpec:AbstractIL.Extensions.ILX.Types.IlxClosureSpec option -> + AbstractIL.IL.ILTypeDef list + val GenStaticDelegateClosureTypeDefs: + cenv:cenv -> + tref:AbstractIL.IL.ILTypeRef * + ilGenParams:AbstractIL.IL.ILGenericParameterDefs * + attrs:AbstractIL.IL.ILAttribute list * + ilCloAllFreeVars:AbstractIL.Extensions.ILX.Types.IlxClosureFreeVar [] * + ilCloLambdas:AbstractIL.Extensions.ILX.Types.IlxClosureLambdas * + ilCtorBody:AbstractIL.IL.ILMethodBody * + mdefs:AbstractIL.IL.ILMethodDef list * + mimpls:AbstractIL.IL.ILMethodImplDef list * ext:AbstractIL.IL.ILType * + ilIntfTys:AbstractIL.IL.ILType list * + staticCloInfo:AbstractIL.Extensions.ILX.Types.IlxClosureSpec option -> + AbstractIL.IL.ILTypeDef list + val GenGenericParams: + cenv:cenv -> + eenv:IlxGenEnv -> + tps:TypedTree.Typar list -> AbstractIL.IL.ILGenericParameterDefs + val GenGenericArgs: + m:Range.range -> + tyenv:TypeReprEnv -> + tps:TypedTree.Typar list -> AbstractIL.IL.ILGenericArgs + val GenLambdaClosure: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + isLocalTypeFunc:bool -> + thisVars:TypedTree.ValRef list -> + expr:TypedTree.Expr -> IlxClosureInfo * Range.range + val GenClosureAlloc: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> cloinfo:IlxClosureInfo * m:Range.range -> unit + val GenLambda: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + isLocalTypeFunc:bool -> + thisVars:TypedTree.ValRef list -> + expr:TypedTree.Expr -> sequel:sequel -> unit + val GenTypeOfVal: + cenv:cenv -> eenv:IlxGenEnv -> v:TypedTree.Val -> AbstractIL.IL.ILType + val GenFreevar: + cenv:cenv -> + m:Range.range -> + eenvouter:IlxGenEnv -> + tyenvinner:TypeReprEnv -> fv:TypedTree.Val -> AbstractIL.IL.ILType + val GetIlxClosureFreeVars: + cenv:cenv -> + m:Range.range -> + thisVars:TypedTree.ValRef list -> + eenvouter:IlxGenEnv -> + takenNames:string list -> + expr:TypedTree.Expr -> + TypedTree.Attribs * TypedTree.Typar list * + TypedTree.Typar list * TypedTree.Typar list * + TypedTreeOps.TraitWitnessInfos * TypedTree.Val list * + AbstractIL.IL.ILTypeRef * + AbstractIL.Extensions.ILX.Types.IlxClosureFreeVar [] * + IlxGenEnv + val GetIlxClosureInfo: + cenv:cenv -> + m:Range.range -> + isLocalTypeFunc:bool -> + canUseStaticField:bool -> + thisVars:TypedTree.ValRef list -> + eenvouter:IlxGenEnv -> + expr:TypedTree.Expr -> + IlxClosureInfo * TypedTree.Expr * IlxGenEnv + val IsNamedLocalTypeFuncVal: + g:TcGlobals.TcGlobals -> v:TypedTree.Val -> expr:TypedTree.Expr -> bool + val GenNamedLocalTypeFuncContractInfo: + cenv:cenv -> + eenv:IlxGenEnv -> + m:Range.range -> + cloinfo:IlxClosureInfo -> + AbstractIL.IL.ILGenericParameterDef list * + AbstractIL.IL.ILGenericParameterDefs * AbstractIL.IL.ILTypeSpec * + AbstractIL.IL.ILType + val GenDelegateExpr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenvouter:IlxGenEnv -> + expr:TypedTree.Expr -> + TypedTree.ObjExprMethod * m:Range.range -> sequel:sequel -> unit + val GenStaticOptimization: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + constraints:TypedTree.StaticOptimization list * e2:TypedTree.Expr * + e3:TypedTree.Expr * _m:Range.range -> sequel:sequel -> unit + val IsSequelImmediate: sequel:sequel -> bool + val GenJoinPoint: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + pos:string -> + eenv:IlxGenEnv -> + ty:TypedTree.TType -> + m:Range.range -> + sequel:sequel -> + sequel * Mark * AbstractIL.IL.ILType list * sequel + val GenDecisionTreeAndTargets: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + stackAtTargets:AbstractIL.IL.ILType list -> + eenv:IlxGenEnv -> + tree:TypedTree.DecisionTree -> + targets:TypedTree.DecisionTreeTarget array -> + repeatSP:(unit -> unit) -> + sequel:sequel -> contf:(FakeUnit -> FakeUnit) -> FakeUnit + val GenPostponedDecisionTreeTargets: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + targetInfos:System.Collections.Generic.KeyValuePair unit) * + TypedTree.Val list * + TypedTree.Bindings * + Mark * Mark) * + bool)> list -> + stackAtTargets:AbstractIL.IL.ILType list -> + sequel:sequel -> contf:(FakeUnit -> FakeUnit) -> FakeUnit + val TryFindTargetInfo: + targetInfos:Lib.IntMap<'a * 'b> -> n:int -> 'a option + val GenDecisionTreeAndTargetsInner: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + inplabOpt:Mark option -> + stackAtTargets:AbstractIL.IL.ILType list -> + eenv:IlxGenEnv -> + tree:TypedTree.DecisionTree -> + targets:TypedTree.DecisionTreeTarget array -> + repeatSP:(unit -> unit) -> + targetInfos:AbstractIL.Internal.Zmap unit) * + TypedTree.Val list * + TypedTree.Bindings * + Mark * Mark) * bool)> -> + sequel:sequel -> + contf:(AbstractIL.Internal.Zmap unit) * + TypedTree.Val list * + TypedTree.Bindings * + Mark * Mark) * bool)> -> + FakeUnit) -> FakeUnit + val GetTarget: targets:'c [] -> n:int -> 'c + val GenDecisionTreeSuccess: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + inplabOpt:Mark option -> + stackAtTargets:AbstractIL.IL.ILType list -> + eenv:IlxGenEnv -> + es:TypedTree.Exprs -> + targetIdx:int -> + targets:TypedTree.DecisionTreeTarget array -> + repeatSP:(unit -> unit) -> + targetInfos:AbstractIL.Internal.Zmap unit) * + TypedTree.Val list * + TypedTree.Bindings * + Mark * Mark) * + bool)> -> + sequel:sequel -> + AbstractIL.Internal.Zmap unit) * + TypedTree.Val list * + TypedTree.Bindings * Mark * + Mark) * bool)> * + (IlxGenEnv * EmitDebugPointState * TypedTree.Expr * + sequel) option + val GenDecisionTreeTarget: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + stackAtTargets:AbstractIL.IL.ILType list -> + targetMarkBeforeBinds:Mark * targetMarkAfterBinds:Mark * + eenvAtTarget:IlxGenEnv * successExpr:TypedTree.Expr * + spTarget:SyntaxTree.DebugPointForTarget * repeatSP:(unit -> unit) * + vs:TypedTree.Val list * binds:TypedTree.Bindings * startScope:Mark * + Scope:Mark -> + sequel:sequel -> + IlxGenEnv * EmitDebugPointState * TypedTree.Expr * sequel + val GenDecisionTreeSwitch: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + inplabOpt:Mark option -> + stackAtTargets:AbstractIL.IL.ILType list -> + eenv:IlxGenEnv -> + e:TypedTree.Expr -> + cases:TypedTree.DecisionTreeCase list -> + defaultTargetOpt:TypedTree.DecisionTree option -> + switchm:Range.range -> + targets:TypedTree.DecisionTreeTarget array -> + repeatSP:(unit -> unit) -> + targetInfos:AbstractIL.Internal.Zmap unit) * + TypedTree.Val list * + TypedTree.Bindings * + Mark * Mark) * + bool)> -> + sequel:sequel -> + contf:(AbstractIL.Internal.Zmap unit) * + TypedTree.Val list * + TypedTree.Bindings * + Mark * Mark) * + bool)> -> + FakeUnit) -> FakeUnit + val GenDecisionTreeCases: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + stackAtTargets:AbstractIL.IL.ILType list -> + eenv:IlxGenEnv -> + defaultTargetOpt:TypedTree.DecisionTree option -> + targets:TypedTree.DecisionTreeTarget array -> + repeatSP:(unit -> unit) -> + targetInfos:AbstractIL.Internal.Zmap unit) * + TypedTree.Val list * + TypedTree.Bindings * + Mark * Mark) * bool)> -> + sequel:sequel -> + caseLabels:Mark list -> + cases:TypedTree.DecisionTreeCase list -> + contf:(AbstractIL.Internal.Zmap unit) * + TypedTree.Val list * + TypedTree.Bindings * + Mark * Mark) * + bool)> -> FakeUnit) -> + FakeUnit + val ( |BoolExpr|_| ): _arg42:TypedTree.Expr -> bool option + val GenDecisionTreeTest: + cenv:cenv -> + cloc:CompileLocation -> + cgbuf:CodeGenBuffer -> + stackAtTargets:AbstractIL.IL.ILType list -> + e:TypedTree.Expr -> + tester:(Pops * Pushes * + Choice<(bool * + AbstractIL.Extensions.ILX.Types.IlxUnionSpec * + int),AbstractIL.IL.ILInstr>) option -> + eenv:IlxGenEnv -> + successTree:TypedTree.DecisionTree -> + failureTree:TypedTree.DecisionTree -> + targets:TypedTree.DecisionTreeTarget array -> + repeatSP:(unit -> unit) -> + targetInfos:AbstractIL.Internal.Zmap unit) * + TypedTree.Val list * + TypedTree.Bindings * + Mark * Mark) * + bool)> -> + sequel:sequel -> + contf:(AbstractIL.Internal.Zmap unit) * + TypedTree.Val list * + TypedTree.Bindings * + Mark * Mark) * + bool)> -> + FakeUnit) -> FakeUnit + val GenLetRecFixup: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + ilxCloSpec:AbstractIL.Extensions.ILX.Types.IlxClosureSpec * + e:TypedTree.Expr * ilField:AbstractIL.IL.ILFieldSpec * + e2:TypedTree.Expr * _m:'d -> unit + val GenLetRecBindings: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> allBinds:TypedTree.Bindings * m:Range.range -> unit + val GenLetRec: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + binds:TypedTree.Bindings * body:TypedTree.Expr * m:Range.range -> + sequel:sequel -> unit + val GenDebugPointForBind: + cenv:cenv -> + cgbuf:CodeGenBuffer -> bind:TypedTree.Binding -> EmitDebugPointState + val GenBinding: + cenv:cenv -> + cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> bind:TypedTree.Binding -> unit + val ComputeMemberAccessRestrictedBySig: + eenv:IlxGenEnv -> vspec:TypedTree.Val -> AbstractIL.IL.ILMemberAccess + val ComputeMethodAccessRestrictedBySig: + eenv:IlxGenEnv -> vspec:TypedTree.Val -> AbstractIL.IL.ILMemberAccess + val GenBindingAfterDebugPoint: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + sp:EmitDebugPointState -> + TypedTree.Binding -> startScopeMarkOpt:Mark option -> unit + val GenMarshal: + cenv:cenv -> + attribs:TypedTree.Attrib list -> + AbstractIL.IL.ILNativeType option * TypedTree.Attrib list + val GenParamAttribs: + cenv:cenv -> + paramTy:TypedTree.TType -> + attribs:TypedTree.Attribs -> + bool * bool * bool * AbstractIL.IL.ILFieldInit option * + AbstractIL.IL.ILNativeType option * TypedTree.Attribs + val GenParams: + cenv:cenv -> + eenv:IlxGenEnv -> + m:Range.range -> + mspec:AbstractIL.IL.ILMethodSpec -> + witnessInfos:TypedTreeOps.TraitWitnessInfos -> + argInfos:TypedTree.ArgReprInfo list -> + methArgTys:TypedTree.TType list -> + implValsOpt:TypedTree.Val list option -> + AbstractIL.IL.ILParameter list + val GenReturnInfo: + cenv:cenv -> + eenv:IlxGenEnv -> + returnTy:TypedTree.TType option -> + ilRetTy:AbstractIL.IL.ILType -> + retInfo:TypedTree.ArgReprInfo -> AbstractIL.IL.ILReturn + val GenPropertyForMethodDef: + compileAsInstance:bool -> + tref:AbstractIL.IL.ILTypeRef -> + mdef:AbstractIL.IL.ILMethodDef -> + v:TypedTree.Val -> + memberInfo:TypedTree.ValMemberInfo -> + ilArgTys:AbstractIL.IL.ILTypes -> + ilPropTy:AbstractIL.IL.ILType -> + ilAttrs:AbstractIL.IL.ILAttributes -> + compiledName:string option -> AbstractIL.IL.ILPropertyDef + val GenEventForProperty: + cenv:cenv -> + eenvForMeth:IlxGenEnv -> + mspec:AbstractIL.IL.ILMethodSpec -> + v:TypedTree.Val -> + ilAttrsThatGoOnPrimaryItem:AbstractIL.IL.ILAttribute list -> + m:Range.range -> + returnTy:TypedTree.TType -> AbstractIL.IL.ILEventDef + val ComputeUseMethodImpl: + cenv:cenv -> v:TypedTree.Val * slotsig:TypedTree.SlotSig -> bool + val ComputeMethodImplNameFixupForMemberBinding: + cenv:cenv -> + v:TypedTree.Val * memberInfo:TypedTree.ValMemberInfo -> string option + val ComputeFlagFixupsForMemberBinding: + cenv:cenv -> + v:TypedTree.Val * memberInfo:TypedTree.ValMemberInfo -> + (#AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef) list + val ComputeMethodImplAttribs: + cenv:cenv -> + _v:TypedTree.Val -> + attrs:TypedTree.Attribs -> + bool * bool * bool * bool * TypedTree.Attrib list + val DelayGenMethodForBinding: + cenv:cenv -> + mgbuf:AssemblyBuilder -> + eenv:IlxGenEnv -> + TypedTree.Val * AbstractIL.IL.ILMethodSpec * bool * bool * + AbstractIL.IL.ILMemberAccess * TypedTree.Typars * TypedTree.Typars * + TypedTree.TraitWitnessInfo list * TypedTreeOps.CurriedArgInfos * + TypedTree.ArgReprInfo list * TypedTree.TType list * + TypedTree.ArgReprInfo * TypedTree.ValReprInfo * TypedTree.Val option * + TypedTree.Val option * TypedTree.Typars * TypedTree.Val list * + TypedTree.Expr * TypedTree.TType -> unit + val GenMethodForBinding: + cenv:cenv -> + mgbuf:AssemblyBuilder -> + eenv:IlxGenEnv -> + v:TypedTree.Val * mspec:AbstractIL.IL.ILMethodSpec * + hasWitnessEntry:bool * generateWitnessArgs:bool * + access:AbstractIL.IL.ILMemberAccess * ctps:TypedTree.Typars * + mtps:TypedTree.Typars * witnessInfos:TypedTree.TraitWitnessInfo list * + curriedArgInfos:TypedTreeOps.CurriedArgInfos * + paramInfos:TypedTree.ArgReprInfo list * argTys:TypedTree.TType list * + retInfo:TypedTree.ArgReprInfo * topValInfo:TypedTree.ValReprInfo * + ctorThisValOpt:TypedTree.Val option * + baseValOpt:TypedTree.Val option * methLambdaTypars:TypedTree.Typars * + methLambdaVars:TypedTree.Val list * methLambdaBody:TypedTree.Expr * + returnTy:TypedTree.TType -> unit + val GenPInvokeMethod: + nm:string * dll:string * namedArgs:TypedTree.AttribNamedArg list -> + bool * AbstractIL.IL.MethodBody + val GenBindings: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> binds:TypedTree.Bindings -> unit + val GenSetVal: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + vref:TypedTree.ValRef * e:TypedTree.Expr * m:Range.range -> + sequel:sequel -> unit + val GenGetValRefAndSequel: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> + v:TypedTree.ValRef -> + storeSequel:(TypedTree.TypeInst * TypedTree.Exprs * Range.range * + sequel) option -> unit + val GenGetVal: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + v:TypedTree.ValRef * m:Range.range -> sequel:sequel -> unit + val GenBindingRhs: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + sp:EmitDebugPointState -> + vspec:TypedTree.Val -> e:TypedTree.Expr -> unit + val CommitStartScope: + cgbuf:CodeGenBuffer -> startScopeMarkOpt:Mark option -> unit + val EmitInitLocal: + cgbuf:CodeGenBuffer -> ty:AbstractIL.IL.ILType -> idx:int -> unit + val EmitSetLocal: cgbuf:CodeGenBuffer -> idx:int -> unit + val EmitGetLocal: + cgbuf:CodeGenBuffer -> ty:AbstractIL.IL.ILType -> idx:int -> unit + val EmitSetStaticField: + cgbuf:CodeGenBuffer -> fspec:AbstractIL.IL.ILFieldSpec -> unit + val EmitGetStaticFieldAddr: + cgbuf:CodeGenBuffer -> + ty:AbstractIL.IL.ILType -> fspec:AbstractIL.IL.ILFieldSpec -> unit + val EmitGetStaticField: + cgbuf:CodeGenBuffer -> + ty:AbstractIL.IL.ILType -> fspec:AbstractIL.IL.ILFieldSpec -> unit + val GenSetStorage: + m:Range.range -> cgbuf:CodeGenBuffer -> storage:ValStorage -> unit + val CommitGetStorageSequel: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> + ty:TypedTree.TType -> + localCloInfo:Ref option -> + storeSequel:(TypedTree.TType list * TypedTree.Expr list * + Range.range * sequel) option -> unit + val GenGetStorageAndSequel: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> + ty:TypedTree.TType * ilTy:AbstractIL.IL.ILType -> + storage:ValStorage -> + storeSequel:(TypedTree.TType list * TypedTree.Expr list * + Range.range * sequel) option -> unit + val GenGetLocalVals: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenvouter:IlxGenEnv -> m:Range.range -> fvs:TypedTree.Val list -> unit + val GenGetLocalVal: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> + vspec:TypedTree.Val -> + storeSequel:(TypedTree.TType list * TypedTree.Expr list * + Range.range * sequel) option -> unit + val GenGetLocalVRef: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> + vref:TypedTree.ValRef -> + storeSequel:(TypedTree.TType list * TypedTree.Expr list * + Range.range * sequel) option -> unit + val GenStoreVal: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> m:Range.range -> vspec:TypedTree.Val -> unit + val AllocLocal: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + compgen:bool -> + v:string * ty:AbstractIL.IL.ILType * isFixed:bool -> + Mark * Mark -> int * bool * IlxGenEnv + val AllocLocalVal: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + v:TypedTree.Val -> + eenv:IlxGenEnv -> + repr:TypedTree.Expr option -> + Mark * Mark -> ValStorage option * IlxGenEnv + val AllocStorageForBind: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + Mark * Mark -> eenv:IlxGenEnv -> bind:TypedTree.Binding -> IlxGenEnv + val AllocStorageForBinds: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + Mark * Mark -> eenv:IlxGenEnv -> binds:TypedTree.Bindings -> IlxGenEnv + val AllocValForBind: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + Mark * Mark -> + eenv:IlxGenEnv -> TypedTree.Binding -> ValStorage option * IlxGenEnv + val AllocTopValWithinExpr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + cloc:CompileLocation -> + Mark * Mark -> v:TypedTree.Val -> eenv:IlxGenEnv -> IlxGenEnv + val EmitSaveStack: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + eenv:IlxGenEnv -> + m:Range.range -> + Mark * Mark -> (AbstractIL.IL.ILType list * int list) * IlxGenEnv + val EmitRestoreStack: + cgbuf:CodeGenBuffer -> + savedStack:AbstractIL.IL.ILType list * savedStackLocals:int list -> unit + val GenAttribArg: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + eenv:IlxGenEnv -> + x:TypedTree.Expr -> + ilArgTy:AbstractIL.IL.ILType -> AbstractIL.IL.ILAttribElem + val GenAttr: + amap:Import.ImportMap -> + g:TcGlobals.TcGlobals -> + eenv:IlxGenEnv -> TypedTree.Attrib -> AbstractIL.IL.ILAttribute + val GenAttrs: + cenv:cenv -> + eenv:IlxGenEnv -> + attrs:TypedTree.Attribs -> AbstractIL.IL.ILAttribute list + val GenCompilationArgumentCountsAttr: + cenv:cenv -> v:TypedTree.Val -> AbstractIL.IL.ILAttribute list + val CreatePermissionSets: + cenv:cenv -> + eenv:IlxGenEnv -> + securityAttributes:TypedTree.Attrib list -> + AbstractIL.IL.ILSecurityDecl list + val GenTypeDefForCompLoc: + cenv:cenv * eenv:IlxGenEnv * mgbuf:AssemblyBuilder * cloc:CompileLocation * + hidden:bool * attribs:TypedTree.Attribs * + initTrigger:AbstractIL.IL.ILTypeInit * eliminateIfEmpty:bool * + addAtEnd:bool -> unit + val GenModuleExpr: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + qname:SyntaxTree.QualifiedNameOfFile -> + lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> + AbstractIL.IL.ILInstr list -> + AbstractIL.IL.ILInstr list -> unit)> -> + eenv:IlxGenEnv -> x:TypedTree.ModuleOrNamespaceExprWithSig -> unit + val GenModuleDefs: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + qname:SyntaxTree.QualifiedNameOfFile -> + lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> + AbstractIL.IL.ILInstr list -> + AbstractIL.IL.ILInstr list -> unit)> -> + eenv:IlxGenEnv -> + mdefs:TypedTree.ModuleOrNamespaceExpr list -> unit + val GenModuleDef: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + qname:SyntaxTree.QualifiedNameOfFile -> + lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> + AbstractIL.IL.ILInstr list -> + AbstractIL.IL.ILInstr list -> unit)> -> + eenv:IlxGenEnv -> x:TypedTree.ModuleOrNamespaceExpr -> unit + val GenModuleBinding: + cenv:cenv -> + cgbuf:CodeGenBuffer -> + qname:SyntaxTree.QualifiedNameOfFile -> + lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> + AbstractIL.IL.ILInstr list -> + AbstractIL.IL.ILInstr list -> unit)> -> + eenv:IlxGenEnv -> + m:Range.range -> x:TypedTree.ModuleOrNamespaceBinding -> unit + val GenImplFile: + cenv:cenv -> + mgbuf:AssemblyBuilder -> + mainInfoOpt:TypedTree.Attribs option -> + eenv:IlxGenEnv -> + implFile:TypedTree.TypedImplFileAfterOptimization -> IlxGenEnv + val GenForceWholeFileInitializationAsPartOfCCtor: + cenv:cenv -> + mgbuf:AssemblyBuilder -> + lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> + AbstractIL.IL.ILInstr list -> + AbstractIL.IL.ILInstr list -> unit)> -> + tref:AbstractIL.IL.ILTypeRef -> m:Range.range -> unit + val GenEqualsOverrideCallingIComparable: + cenv:cenv -> + tcref:TypedTree.TyconRef * ilThisTy:AbstractIL.IL.ILType * _ilThatTy:'f -> + AbstractIL.IL.ILMethodDef + val GenFieldInit: + m:Range.range -> c:TypedTree.Const -> AbstractIL.IL.ILFieldInit + val GenWitnessParams: + cenv:cenv -> + eenv:IlxGenEnv -> + m:Range.range -> + witnessInfos:TypedTreeOps.TraitWitnessInfos -> + AbstractIL.IL.ILParameter list + val GenAbstractBinding: + cenv:cenv -> + eenv:IlxGenEnv -> + tref:AbstractIL.IL.ILTypeRef -> + vref:TypedTree.ValRef -> + AbstractIL.IL.ILMethodDef list * AbstractIL.IL.ILPropertyDef list * + AbstractIL.IL.ILEventDef list + val GenToStringMethod: + cenv:cenv -> + eenv:IlxGenEnv -> + ilThisTy:AbstractIL.IL.ILType -> + m:Range.range -> AbstractIL.IL.ILMethodDef list + val GenTypeDef: + cenv:cenv -> + mgbuf:AssemblyBuilder -> + lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> + AbstractIL.IL.ILInstr list -> + AbstractIL.IL.ILInstr list -> unit)> -> + eenv:IlxGenEnv -> m:Range.range -> tycon:TypedTree.Tycon -> unit + val GenExnDef: + cenv:cenv -> + mgbuf:AssemblyBuilder -> + eenv:IlxGenEnv -> m:Range.range -> exnc:TypedTree.Tycon -> unit + val CodegenAssembly: + cenv:cenv -> + eenv:IlxGenEnv -> + mgbuf:AssemblyBuilder -> + implFiles:TypedTree.TypedImplFileAfterOptimization list -> unit + val GetEmptyIlxGenEnv: + g:TcGlobals.TcGlobals -> ccu:TypedTree.CcuThunk -> IlxGenEnv + type IlxGenResults = + { ilTypeDefs: AbstractIL.IL.ILTypeDef list + ilAssemAttrs: AbstractIL.IL.ILAttribute list + ilNetModuleAttrs: AbstractIL.IL.ILAttribute list + topAssemblyAttrs: TypedTree.Attribs + permissionSets: AbstractIL.IL.ILSecurityDecl list + quotationResourceInfo: (AbstractIL.IL.ILTypeRef list * byte []) list } + val GenerateCode: + cenv:cenv * anonTypeTable:AnonTypeGenerationTable * eenv:IlxGenEnv * + TypedTree.TypedAssemblyAfterOptimization * assemAttribs:TypedTree.Attribs * + moduleAttribs:TypedTree.Attribs -> IlxGenResults + type ExecutionContext = + { LookupFieldRef: AbstractIL.IL.ILFieldRef -> System.Reflection.FieldInfo + LookupMethodRef: + AbstractIL.IL.ILMethodRef -> System.Reflection.MethodInfo + LookupTypeRef: AbstractIL.IL.ILTypeRef -> System.Type + LookupType: AbstractIL.IL.ILType -> System.Type } + val defaultOf: (System.Type -> obj) + val LookupGeneratedValue: + amap:Import.ImportMap -> + ctxt:ExecutionContext -> + eenv:IlxGenEnv -> v:TypedTree.Val -> (obj * System.Type) option + val SetGeneratedValue: + ctxt:ExecutionContext -> + g:TcGlobals.TcGlobals -> + eenv:IlxGenEnv -> + isForced:bool -> v:TypedTree.Val -> value:obj -> unit + val ClearGeneratedValue: + ctxt:ExecutionContext -> + g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> v:TypedTree.Val -> unit + type IlxAssemblyGenerator = + + new: Import.ImportMap * TcGlobals.TcGlobals * ConstraintSolver.TcValF * + TypedTree.CcuThunk -> IlxAssemblyGenerator + member AddExternalCcus: TypedTree.CcuThunk list -> unit + member + AddIncrementalLocalAssemblyFragment: isIncrementalFragment:bool * + fragName:string * + typedImplFiles:TypedTree.TypedImplFile list -> + unit + member ClearGeneratedValue: ExecutionContext * TypedTree.Val -> unit + member + ForceSetGeneratedValue: ExecutionContext * TypedTree.Val * obj -> + unit + member + GenerateCode: IlxGenOptions * + TypedTree.TypedAssemblyAfterOptimization * + TypedTree.Attribs * TypedTree.Attribs -> IlxGenResults + member + LookupGeneratedValue: ExecutionContext * TypedTree.Val -> + (obj * System.Type) option + + + +namespace FSharp.Compiler + module internal DotNetFrameworkDependencies = + type private TypeInThisAssembly + val fSharpCompilerLocation: string + val inline ifEmptyUse: alternative:string -> filename:string -> string + val getFSharpCoreLibraryName: string + val getFsiLibraryName: string + val getDefaultFSharpCoreLocation: string + val getDefaultFsiLibraryLocation: string + val implementationAssemblyDir: string + val getDefaultSystemValueTupleReference: unit -> string option + val zeroVersion: System.Version + val version: string option + val frameworkRefsPackDirectoryRoot: string option + val netcoreTfm: string option + val getWindowsDesktopTfm: unit -> string + val executionTfm: string + val executionRid: string + val isInReferenceAssemblyPackDirectory: filename:string -> bool + val frameworkRefsPackDirectory: string option + val getDependenciesOf: + assemblyReferences:string list -> + System.Collections.Generic.Dictionary + val getDesktopDefaultReferences: useFsiAuxLib:bool -> string list + val fetchPathsForDefaultReferencesForScriptsAndOutOfProjectSources: + useFsiAuxLib:bool -> + useSdkRefs:bool -> assumeDotNetFramework:bool -> string list + val defaultReferencesForScriptsAndOutOfProjectSources: + useFsiAuxLib:bool -> + assumeDotNetFramework:bool -> useSdkRefs:bool -> string list + val systemAssemblies: System.Collections.Generic.HashSet + val basicReferencesForScriptLoadClosure: + useFsiAuxLib:bool -> + useSdkRefs:bool -> assumeDotNetFramework:bool -> string list + + +namespace Microsoft.DotNet.DependencyManager + type AssemblyResolutionProbe = + delegate of Unit -> seq + type AssemblyResolveHandlerCoreclr = + + interface System.IDisposable + new: assemblyProbingPaths:AssemblyResolutionProbe -> + AssemblyResolveHandlerCoreclr + + type AssemblyResolveHandlerDeskTop = + + interface System.IDisposable + new: assemblyProbingPaths:AssemblyResolutionProbe -> + AssemblyResolveHandlerDeskTop + + type AssemblyResolveHandler = + + interface System.IDisposable + new: assemblyProbingPaths:AssemblyResolutionProbe -> + AssemblyResolveHandler + + +namespace Microsoft.DotNet.DependencyManager + type NativeResolutionProbe = + delegate of Unit -> seq + type NativeAssemblyLoadContext = + + inherit System.Runtime.Loader.AssemblyLoadContext + new: unit -> NativeAssemblyLoadContext + override + Load: _path:System.Reflection.AssemblyName -> + System.Reflection.Assembly + member LoadNativeLibrary: path:string -> System.IntPtr + static member NativeLoadContext: NativeAssemblyLoadContext + + type NativeDllResolveHandlerCoreClr = + + interface System.IDisposable + new: nativeProbingRoots:NativeResolutionProbe -> + NativeDllResolveHandlerCoreClr + + type NativeDllResolveHandler = + + interface System.IDisposable + new: _nativeProbingRoots:NativeResolutionProbe -> NativeDllResolveHandler + member internal RefreshPathsInEnvironment: seq -> unit + + +namespace Microsoft.DotNet.DependencyManager + module ReflectionHelper = + val dependencyManagerPattern: string + val dependencyManagerAttributeName: string + val resolveDependenciesMethodName: string + val namePropertyName: string + val keyPropertyName: string + val helpMessagesPropertyName: string + val arrEmpty: string [] + val seqEmpty: seq + val assemblyHasAttribute: + theAssembly:System.Reflection.Assembly -> attributeName:string -> bool + val getAttributeNamed: + theType:System.Type -> attributeName:string -> obj option + val getInstanceProperty<'treturn>: + theType:System.Type -> + propertyName:string -> System.Reflection.PropertyInfo option + val getInstanceMethod<'treturn>: + theType:System.Type -> + parameterTypes:System.Type array -> + methodName:string -> System.Reflection.MethodInfo option + val stripTieWrapper: e:System.Exception -> exn + + [] + type ErrorReportType = + | Warning + | Error + type ResolvingErrorReport = + delegate of ErrorReportType * int * string -> unit + type IResolveDependenciesResult = + interface + abstract member Resolutions: seq + abstract member Roots: seq + abstract member SourceFiles: seq + abstract member StdError: string [] + abstract member StdOut: string [] + abstract member Success: bool + + [] + type IDependencyManagerProvider = + interface + abstract member + ResolveDependencies: scriptDir:string * mainScriptName:string * + scriptName:string * scriptExt:string * + packageManagerTextLines:seq * + tfm:string * rid:string -> + IResolveDependenciesResult + abstract member HelpMessages: string [] + abstract member Key: string + abstract member Name: string + + type ReflectionDependencyManagerProvider = + + interface IDependencyManagerProvider + new: theType:System.Type * nameProperty:System.Reflection.PropertyInfo * + keyProperty:System.Reflection.PropertyInfo * + helpMessagesProperty:System.Reflection.PropertyInfo option * + resolveDeps:System.Reflection.MethodInfo option * + resolveDepsEx:System.Reflection.MethodInfo option * + outputDir:string option -> ReflectionDependencyManagerProvider + static member + InstanceMaker: theType:System.Type * outputDir:string option -> + (unit -> IDependencyManagerProvider) option + static member + MakeResultFromFields: success:bool * stdOut:string array * + stdError:string array * resolutions:seq * + sourceFiles:seq * roots:seq -> + IResolveDependenciesResult + static member + MakeResultFromObject: result:obj -> IResolveDependenciesResult + + type DependencyProvider = + + interface System.IDisposable + new: unit -> DependencyProvider + new: nativeProbingRoots:NativeResolutionProbe -> DependencyProvider + new: assemblyProbingPaths:AssemblyResolutionProbe * + nativeProbingRoots:NativeResolutionProbe -> DependencyProvider + member + CreatePackageManagerUnknownError: seq * string * string * + ResolvingErrorReport -> int * string + member + GetRegisteredDependencyManagerHelpText: seq * string * + ResolvingErrorReport -> + string [] + member + Resolve: packageManager:IDependencyManagerProvider * scriptExt:string * + packageManagerTextLines:seq * + reportError:ResolvingErrorReport * executionTfm:string * + executionRid:string * implicitIncludeDir:string * + mainScriptName:string * fileName:string -> + IResolveDependenciesResult + member + TryFindDependencyManagerByKey: compilerTools:seq * + outputDir:string * + reportError:ResolvingErrorReport * + key:string -> IDependencyManagerProvider + member + TryFindDependencyManagerInPath: compilerTools:seq * + outputDir:string * + reportError:ResolvingErrorReport * + path:string -> + string * IDependencyManagerProvider + + +namespace FSharp.Compiler + module internal CompilerConfig = + val ( ++ ): x:'a list -> s:'a -> 'a list + val FSharpSigFileSuffixes: string list + val mlCompatSuffixes: string list + val FSharpImplFileSuffixes: string list + val FSharpScriptFileSuffixes: string list + val doNotRequireNamespaceOrModuleSuffixes: string list + val FSharpLightSyntaxFileSuffixes: string list + exception FileNameNotResolved of string * string * Range.range + exception LoadedSourceNotFoundIgnoring of string * Range.range + val TryResolveFileUsingPaths: + paths:string list * m:Range.range * name:string -> string option + val ResolveFileUsingPaths: + paths:string list * m:Range.range * name:string -> string + val GetWarningNumber: m:Range.range * warningNumber:string -> int32 option + val ComputeMakePathAbsolute: + implicitIncludeDir:string -> path:string -> string + [] + type CompilerTarget = + | WinExe + | ConsoleExe + | Dll + | Module + with + member IsExe: bool + + [] + type ResolveAssemblyReferenceMode = + | Speculative + | ReportErrors + [] + type CopyFSharpCoreFlag = + | Yes + | No + type VersionFlag = + | VersionString of string + | VersionFile of string + | VersionNone + with + member + GetVersionInfo: implicitIncludeDir:string -> + AbstractIL.IL.ILVersionInfo + member GetVersionString: implicitIncludeDir:string -> string + + type IRawFSharpAssemblyData = + interface + abstract member + GetAutoOpenAttributes: AbstractIL.IL.ILGlobals -> string list + abstract member + GetInternalsVisibleToAttributes: AbstractIL.IL.ILGlobals -> + string list + abstract member + GetRawFSharpOptimizationData: Range.range * ilShortAssemName:string * + fileName:string -> + (string * + (unit -> + AbstractIL.Internal.ReadOnlyByteMemory)) list + abstract member + GetRawFSharpSignatureData: Range.range * ilShortAssemName:string * + fileName:string -> + (string * + (unit -> + AbstractIL.Internal.ReadOnlyByteMemory)) list + abstract member + GetRawTypeForwarders: unit -> + AbstractIL.IL.ILExportedTypesAndForwarders + abstract member + HasMatchingFSharpSignatureDataAttribute: AbstractIL.IL.ILGlobals -> + bool + abstract member + TryGetILModuleDef: unit -> AbstractIL.IL.ILModuleDef option + abstract member HasAnyFSharpSignatureDataAttribute: bool + abstract member ILAssemblyRefs: AbstractIL.IL.ILAssemblyRef list + abstract member ILScopeRef: AbstractIL.IL.ILScopeRef + abstract member ShortAssemblyName: string + + type TimeStampCache = + + new: defaultTimeStamp:System.DateTime -> TimeStampCache + member GetFileTimeStamp: string -> System.DateTime + member + GetProjectReferenceTimeStamp: IProjectReference * + AbstractIL.Internal.Library.CompilationThreadToken -> + System.DateTime + + and IProjectReference = + interface + abstract member + EvaluateRawContents: AbstractIL.Internal.Library.CompilationThreadToken -> + AbstractIL.Internal.Library.Cancellable + abstract member + TryGetLogicalTimeStamp: TimeStampCache * + AbstractIL.Internal.Library.CompilationThreadToken -> + System.DateTime option + abstract member FileName: string + + type AssemblyReference = + | AssemblyReference of Range.range * string * IProjectReference option + with + member SimpleAssemblyNameIs: string -> bool + override ToString: unit -> string + member ProjectReference: IProjectReference option + member Range: Range.range + member Text: string + + type UnresolvedAssemblyReference = + | UnresolvedAssemblyReference of string * AssemblyReference list + type ResolvedExtensionReference = + | ResolvedExtensionReference of + string * AssemblyReference list * + Tainted list + type ImportedAssembly = + { ILScopeRef: AbstractIL.IL.ILScopeRef + FSharpViewOfMetadata: TypedTree.CcuThunk + AssemblyAutoOpenAttributes: string list + AssemblyInternalsVisibleToAttributes: string list + IsProviderGenerated: bool + mutable TypeProviders: Tainted list + FSharpOptimizationData: Lazy> } + type AvailableImportedAssembly = + | ResolvedImportedAssembly of ImportedAssembly + | UnresolvedImportedAssembly of string + type CcuLoadFailureAction = + | RaiseError + | ReturnNone + type Directive = + | Resolution + | Include + type LStatus = + | Unprocessed + | Processed + type PackageManagerLine = + { Directive: Directive + LineStatus: LStatus + Line: string + Range: Range.range } + with + static member + AddLineWithKey: string -> + Directive -> + string -> + Range.range -> + Map -> + Map + static member + RemoveUnprocessedLines: string -> + Map -> + Map + static member + SetLinesAsProcessed: string -> + Map -> + Map + static member StripDependencyManagerKey: string -> string -> string + + [] + type TcConfigBuilder = + { mutable primaryAssembly: AbstractIL.IL.PrimaryAssembly + mutable noFeedback: bool + mutable stackReserveSize: int32 option + mutable implicitIncludeDir: string + mutable openDebugInformationForLaterStaticLinking: bool + defaultFSharpBinariesDir: string + mutable compilingFslib: bool + mutable useIncrementalBuilder: bool + mutable includes: string list + mutable implicitOpens: string list + mutable useFsiAuxLib: bool + mutable framework: bool + mutable resolutionEnvironment: ReferenceResolver.ResolutionEnvironment + mutable implicitlyResolveAssemblies: bool + mutable light: bool option + mutable conditionalCompilationDefines: string list + mutable loadedSources: (Range.range * string * string) list + mutable compilerToolPaths: string list + mutable referencedDLLs: AssemblyReference list + mutable packageManagerLines: Map + mutable projectReferences: IProjectReference list + mutable knownUnresolvedReferences: UnresolvedAssemblyReference list + reduceMemoryUsage: AbstractIL.ILBinaryReader.ReduceMemoryFlag + mutable subsystemVersion: int * int + mutable useHighEntropyVA: bool + mutable inputCodePage: int option + mutable embedResources: string list + mutable errorSeverityOptions: ErrorLogger.FSharpErrorSeverityOptions + mutable mlCompatibility: bool + mutable checkOverflow: bool + mutable showReferenceResolutions: bool + mutable outputDir: string option + mutable outputFile: string option + mutable platform: AbstractIL.IL.ILPlatform option + mutable prefer32Bit: bool + mutable useSimpleResolution: bool + mutable target: CompilerTarget + mutable debuginfo: bool + mutable testFlagEmitFeeFeeAs100001: bool + mutable dumpDebugInfo: bool + mutable debugSymbolFile: string option + mutable typeCheckOnly: bool + mutable parseOnly: bool + mutable importAllReferencesOnly: bool + mutable simulateException: string option + mutable printAst: bool + mutable tokenizeOnly: bool + mutable testInteractionParser: bool + mutable reportNumDecls: bool + mutable printSignature: bool + mutable printSignatureFile: string + mutable xmlDocOutputFile: string option + mutable stats: bool + mutable generateFilterBlocks: bool + mutable signer: string option + mutable container: string option + mutable delaysign: bool + mutable publicsign: bool + mutable version: VersionFlag + mutable metadataVersion: string option + mutable standalone: bool + mutable extraStaticLinkRoots: string list + mutable noSignatureData: bool + mutable onlyEssentialOptimizationData: bool + mutable useOptimizationDataFile: bool + mutable jitTracking: bool + mutable portablePDB: bool + mutable embeddedPDB: bool + mutable embedAllSource: bool + mutable embedSourceList: string list + mutable sourceLink: string + mutable ignoreSymbolStoreSequencePoints: bool + mutable internConstantStrings: bool + mutable extraOptimizationIterations: int + mutable win32res: string + mutable win32manifest: string + mutable includewin32manifest: bool + mutable linkResources: string list + mutable legacyReferenceResolver: ReferenceResolver.Resolver + mutable showFullPaths: bool + mutable errorStyle: ErrorLogger.ErrorStyle + mutable utf8output: bool + mutable flatErrors: bool + mutable maxErrors: int + mutable abortOnError: bool + mutable baseAddress: int32 option + mutable checksumAlgorithm: AbstractIL.ILPdbWriter.HashAlgorithm + mutable showOptimizationData: bool + mutable showTerms: bool + mutable writeTermsToFiles: bool + mutable doDetuple: bool + mutable doTLR: bool + mutable doFinalSimplify: bool + mutable optsOn: bool + mutable optSettings: Optimizer.OptimizationSettings + mutable emitTailcalls: bool + mutable deterministic: bool + mutable preferredUiLang: string option + mutable lcid: int option + mutable productNameForBannerText: string + mutable showBanner: bool + mutable showTimes: bool + mutable showLoadedAssemblies: bool + mutable continueAfterParseFailure: bool + mutable showExtensionTypeMessages: bool + mutable pause: bool + mutable alwaysCallVirt: bool + mutable noDebugData: bool + isInteractive: bool + isInvalidationSupported: bool + mutable emitDebugInfoInQuotations: bool + mutable exename: string option + mutable copyFSharpCore: CopyFSharpCoreFlag + mutable shadowCopyReferences: bool + mutable useSdkRefs: bool + mutable tryGetMetadataSnapshot: + AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot + mutable internalTestSpanStackReferring: bool + mutable noConditionalErasure: bool + mutable pathMap: Internal.Utilities.PathMap + mutable langVersion: Features.LanguageVersion } + with + static member + CreateNew: legacyReferenceResolver:ReferenceResolver.Resolver * + defaultFSharpBinariesDir:string * + reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * + implicitIncludeDir:string * isInteractive:bool * + isInvalidationSupported:bool * + defaultCopyFSharpCore:CopyFSharpCoreFlag * + tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot -> + TcConfigBuilder + static member + SplitCommandLineResourceInfo: string -> + string * string * + AbstractIL.IL.ILResourceAccess + member AddCompilerToolsByPath: string -> unit + member + AddDependencyManagerText: packageManager:Microsoft.DotNet.DependencyManager.IDependencyManagerProvider * + lt:Directive * m:Range.range * path:string -> + unit + member AddEmbeddedResource: string -> unit + member AddEmbeddedSourceFile: string -> unit + member AddIncludePath: Range.range * string * string -> unit + member + AddLoadedSource: m:Range.range * originalPath:string * + pathLoadedFrom:string -> unit + member AddPathMapping: oldPrefix:string * newPrefix:string -> unit + member + AddReferenceDirective: dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider * + m:Range.range * path:string * + directive:Directive -> unit + member AddReferencedAssemblyByPath: Range.range * string -> unit + member DecideNames: string list -> string * string option * string + member GetNativeProbingRoots: unit -> seq + member RemoveReferencedAssemblyByPath: Range.range * string -> unit + member + ResolveSourceFile: m:Range.range * nm:string * pathLoadedFrom:string -> + string + member TurnWarningOff: Range.range * string -> unit + member TurnWarningOn: Range.range * string -> unit + static member Initial: TcConfigBuilder + + [] + type TcConfig = + + private new: data:TcConfigBuilder * validate:bool -> TcConfig + static member Create: TcConfigBuilder * validate:bool -> TcConfig + member CloneToBuilder: unit -> TcConfigBuilder + member + ComputeCanContainEntryPoint: sourceFiles:string list -> + bool list * bool + member ComputeLightSyntaxInitialStatus: string -> bool + member CoreLibraryDllReference: unit -> AssemblyReference + member GetAvailableLoadedSources: unit -> (Range.range * string) list + member GetNativeProbingRoots: unit -> seq + member GetSearchPathsForLibraryFiles: unit -> string list + member GetTargetFrameworkDirectories: unit -> string list + member IsSystemAssembly: string -> bool + member MakePathAbsolute: string -> string + member PrimaryAssemblyDllReference: unit -> AssemblyReference + member + ResolveSourceFile: Range.range * filename:string * + pathLoadedFrom:string -> string + member GenerateOptimizationData: bool + member GenerateSignatureData: bool + member alwaysCallVirt: bool + member baseAddress: int32 option + member checkOverflow: bool + member checksumAlgorithm: AbstractIL.ILPdbWriter.HashAlgorithm + member clrRoot: string option + member compilerToolPaths: string list + member compilingFslib: bool + member conditionalCompilationDefines: string list + member container: string option + member continueAfterParseFailure: bool + member copyFSharpCore: CopyFSharpCoreFlag + member debugSymbolFile: string option + member debuginfo: bool + member delaysign: bool + member deterministic: bool + member doDetuple: bool + member doFinalSimplify: bool + member doTLR: bool + member dumpDebugInfo: bool + member embedAllSource: bool + member embedResources: string list + member embedSourceList: string list + member embeddedPDB: bool + member emitDebugInfoInQuotations: bool + member emitTailcalls: bool + member errorSeverityOptions: ErrorLogger.FSharpErrorSeverityOptions + member errorStyle: ErrorLogger.ErrorStyle + member extraOptimizationIterations: int + member extraStaticLinkRoots: string list + member flatErrors: bool + member framework: bool + member fsharpBinariesDir: string + member generateFilterBlocks: bool + member ignoreSymbolStoreSequencePoints: bool + member implicitIncludeDir: string + member implicitOpens: string list + member implicitlyResolveAssemblies: bool + member importAllReferencesOnly: bool + member includes: string list + member includewin32manifest: bool + member inputCodePage: int option + member internConstantStrings: bool + member internalTestSpanStackReferring: bool + member isInteractive: bool + member isInvalidationSupported: bool + member jitTracking: bool + member knownUnresolvedReferences: UnresolvedAssemblyReference list + member langVersion: Features.LanguageVersion + member lcid: int option + member legacyReferenceResolver: ReferenceResolver.Resolver + member light: bool option + member linkResources: string list + member loadedSources: (Range.range * string * string) list + member maxErrors: int + member metadataVersion: string option + member mlCompatibility: bool + member noConditionalErasure: bool + member noDebugData: bool + member noFeedback: bool + member noSignatureData: bool + member onlyEssentialOptimizationData: bool + member openDebugInformationForLaterStaticLinking: bool + member optSettings: Optimizer.OptimizationSettings + member optsOn: bool + member outputDir: string option + member outputFile: string option + member packageManagerLines: Map + member parseOnly: bool + member pathMap: Internal.Utilities.PathMap + member pause: bool + member platform: AbstractIL.IL.ILPlatform option + member portablePDB: bool + member prefer32Bit: bool + member preferredUiLang: string option + member primaryAssembly: AbstractIL.IL.PrimaryAssembly + member printAst: bool + member printSignature: bool + member printSignatureFile: string + member productNameForBannerText: string + member publicsign: bool + member reduceMemoryUsage: AbstractIL.ILBinaryReader.ReduceMemoryFlag + member referencedDLLs: AssemblyReference list + member reportNumDecls: bool + member resolutionEnvironment: ReferenceResolver.ResolutionEnvironment + member shadowCopyReferences: bool + member showBanner: bool + member showExtensionTypeMessages: bool + member showFullPaths: bool + member showLoadedAssemblies: bool + member showOptimizationData: bool + member showReferenceResolutions: bool + member showTerms: bool + member showTimes: bool + member signer: string option + member simulateException: string option + member sourceLink: string + member stackReserveSize: int32 option + member standalone: bool + member stats: bool + member subsystemVersion: int * int + member target: CompilerTarget + member targetFrameworkVersion: string + member testFlagEmitFeeFeeAs100001: bool + member testInteractionParser: bool + member tokenizeOnly: bool + member + tryGetMetadataSnapshot: AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot + member typeCheckOnly: bool + member useFsiAuxLib: bool + member useHighEntropyVA: bool + member useIncrementalBuilder: bool + member useOptimizationDataFile: bool + member useSdkRefs: bool + member useSimpleResolution: bool + member utf8output: bool + member version: VersionFlag + member win32manifest: string + member win32res: string + member writeTermsToFiles: bool + member xmlDocOutputFile: string option + + [] + type TcConfigProvider = + | TcConfigProvider of + (AbstractIL.Internal.Library.CompilationThreadToken -> TcConfig) + with + static member + BasedOnMutableBuilder: TcConfigBuilder -> TcConfigProvider + static member Constant: TcConfig -> TcConfigProvider + member + Get: AbstractIL.Internal.Library.CompilationThreadToken -> TcConfig + + val GetFSharpCoreLibraryName: unit -> string + + +namespace FSharp.Compiler + module internal CompilerImports = + val ( ++ ): x:'a list -> s:'a -> 'a list + val IsSignatureDataResource: AbstractIL.IL.ILResource -> bool + val IsOptimizationDataResource: AbstractIL.IL.ILResource -> bool + val GetSignatureDataResourceName: AbstractIL.IL.ILResource -> string + val GetOptimizationDataResourceName: r:AbstractIL.IL.ILResource -> string + val IsReflectedDefinitionsResource: AbstractIL.IL.ILResource -> bool + val MakeILResource: + rName:string -> bytes:byte [] -> AbstractIL.IL.ILResource + val PickleToResource: + inMem:bool -> + file:string -> + g:TcGlobals.TcGlobals -> + scope:TypedTree.CcuThunk -> + rName:string -> + p:TypedTreePickle.pickler<'a> -> + x:'a -> AbstractIL.IL.ILResource + val GetSignatureData: + file:string * ilScopeRef:AbstractIL.IL.ILScopeRef * + ilModule:AbstractIL.IL.ILModuleDef option * + byteReader:(unit -> AbstractIL.Internal.ReadOnlyByteMemory) -> + TypedTreePickle.PickledDataWithReferences + val WriteSignatureData: + CompilerConfig.TcConfig * TcGlobals.TcGlobals * TypedTreeOps.Remap * + TypedTree.CcuThunk * filename:string * inMem:bool -> + AbstractIL.IL.ILResource + val GetOptimizationData: + file:string * ilScopeRef:AbstractIL.IL.ILScopeRef * + ilModule:AbstractIL.IL.ILModuleDef option * + byteReader:(unit -> AbstractIL.Internal.ReadOnlyByteMemory) -> + TypedTreePickle.PickledDataWithReferences + val WriteOptimizationData: + TcGlobals.TcGlobals * filename:string * inMem:bool * TypedTree.CcuThunk * + Optimizer.CcuOptimizationInfo -> AbstractIL.IL.ILResource + exception AssemblyNotResolved of string * Range.range + exception MSBuildReferenceResolutionWarning of string * string * Range.range + exception MSBuildReferenceResolutionError of string * string * Range.range + val OpenILBinary: + filename:string * + reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * + pdbDirPath:string option * shadowCopyReferences:bool * + tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot -> + AbstractIL.ILBinaryReader.ILModuleReader + [] + type ResolveAssemblyReferenceMode = + | Speculative + | ReportErrors + type ResolvedExtensionReference = + | ResolvedExtensionReference of + string * CompilerConfig.AssemblyReference list * + Tainted list + [] + type AssemblyResolution = + { originalReference: CompilerConfig.AssemblyReference + resolvedPath: string + prepareToolTip: unit -> string + sysdir: bool + mutable ilAssemblyRef: AbstractIL.IL.ILAssemblyRef option } + with + member + GetILAssemblyRef: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * + tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot -> + AbstractIL.Internal.Library.Cancellable + override ToString: unit -> string + member ProjectReference: CompilerConfig.IProjectReference option + + [] + type ImportedBinary = + { FileName: string + RawMetadata: CompilerConfig.IRawFSharpAssemblyData + ProviderGeneratedAssembly: System.Reflection.Assembly option + IsProviderGenerated: bool + ProviderGeneratedStaticLinkMap: + ExtensionTyping.ProvidedAssemblyStaticLinkingMap option + ILAssemblyRefs: AbstractIL.IL.ILAssemblyRef list + ILScopeRef: AbstractIL.IL.ILScopeRef } + [] + type ImportedAssembly = + { ILScopeRef: AbstractIL.IL.ILScopeRef + FSharpViewOfMetadata: TypedTree.CcuThunk + AssemblyAutoOpenAttributes: string list + AssemblyInternalsVisibleToAttributes: string list + IsProviderGenerated: bool + mutable TypeProviders: Tainted list + FSharpOptimizationData: Lazy> } + type AvailableImportedAssembly = + | ResolvedImportedAssembly of ImportedAssembly + | UnresolvedImportedAssembly of string + type CcuLoadFailureAction = + | RaiseError + | ReturnNone + type TcConfig with + member + TryResolveLibWithDirectories: r:CompilerConfig.AssemblyReference -> + AssemblyResolution option + type TcConfig with + member + ResolveLibWithDirectories: ccuLoadFailureAction:CcuLoadFailureAction * + r:CompilerConfig.AssemblyReference -> + AssemblyResolution option + type TcConfig with + member + MsBuildResolve: references:(string * string) [] * + mode:ResolveAssemblyReferenceMode * + errorAndWarningRange:Range.range * showMessages:bool -> + ReferenceResolver.ResolvedFile [] + type TcConfig with + static member + TryResolveLibsUsingMSBuildRules: tcConfig:CompilerConfig.TcConfig * + originalReferences:CompilerConfig.AssemblyReference list * + errorAndWarningRange:Range.range * + mode:ResolveAssemblyReferenceMode -> + AssemblyResolution list * + CompilerConfig.UnresolvedAssemblyReference list + [] + type TcAssemblyResolutions = + + new: tcConfig:CompilerConfig.TcConfig * results:AssemblyResolution list * + unresolved:CompilerConfig.UnresolvedAssemblyReference list -> + TcAssemblyResolutions + static member + BuildFromPriorResolutions: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfig:CompilerConfig.TcConfig * + AssemblyResolution list * + CompilerConfig.UnresolvedAssemblyReference list -> + TcAssemblyResolutions + static member + GetAllDllReferences: tcConfig:CompilerConfig.TcConfig -> + CompilerConfig.AssemblyReference list + static member + GetAssemblyResolutionInformation: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfig:CompilerConfig.TcConfig -> + AssemblyResolution list * + CompilerConfig.UnresolvedAssemblyReference list + static member + ResolveAssemblyReferences: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfig:CompilerConfig.TcConfig * + assemblyList:CompilerConfig.AssemblyReference list * + knownUnresolved:CompilerConfig.UnresolvedAssemblyReference list -> + TcAssemblyResolutions + static member + SplitNonFoundationalResolutions: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfig:CompilerConfig.TcConfig -> + AssemblyResolution list * + AssemblyResolution list * + CompilerConfig.UnresolvedAssemblyReference list + member + AddResolutionResults: newResults:AssemblyResolution list -> + TcAssemblyResolutions + member + AddUnresolvedReferences: newUnresolved:CompilerConfig.UnresolvedAssemblyReference list -> + TcAssemblyResolutions + member GetAssemblyResolutions: unit -> AssemblyResolution list + member + GetUnresolvedReferences: unit -> + CompilerConfig.UnresolvedAssemblyReference list + member + TryFindByExactILAssemblyRef: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + assemblyRef:AbstractIL.IL.ILAssemblyRef -> + AssemblyResolution option + member + TryFindByOriginalReference: assemblyReference:CompilerConfig.AssemblyReference -> + AssemblyResolution option + member + TryFindByOriginalReferenceText: nm:string -> + AssemblyResolution option + member TryFindByResolvedPath: nm:string -> AssemblyResolution option + member + TryFindBySimpleAssemblyName: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + simpleAssemName:string -> + AssemblyResolution option + + val GetNameOfILModule: m:AbstractIL.IL.ILModuleDef -> string + val MakeScopeRefForILModule: + ilModule:AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILScopeRef + val GetCustomAttributesOfILModule: + ilModule:AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILAttribute list + val GetAutoOpenAttributes: + ilg:AbstractIL.IL.ILGlobals -> + ilModule:AbstractIL.IL.ILModuleDef -> string list + val GetInternalsVisibleToAttributes: + ilg:AbstractIL.IL.ILGlobals -> + ilModule:AbstractIL.IL.ILModuleDef -> string list + type RawFSharpAssemblyDataBackedByFileOnDisk = + + interface CompilerConfig.IRawFSharpAssemblyData + new: ilModule:AbstractIL.IL.ILModuleDef * + ilAssemblyRefs:AbstractIL.IL.ILAssemblyRef list -> + RawFSharpAssemblyDataBackedByFileOnDisk + + [] + type TcImportsSafeDisposal = + + interface System.IDisposable + new: disposeActions:ResizeArray<(unit -> unit)> * + disposeTypeProviderActions:ResizeArray<(unit -> unit)> -> + TcImportsSafeDisposal + override Finalize: unit -> unit + + type TcImportsDllInfoHack = + { FileName: string } + and TcImportsWeakHack = + + new: tcImports:System.WeakReference -> TcImportsWeakHack + member SetDllInfos: value:ImportedBinary list -> unit + member SystemRuntimeContainsType: typeName:string -> bool + member Base: TcImportsWeakHack option + + [] + and TcImports = + + interface System.IDisposable + new: tcConfigP:CompilerConfig.TcConfigProvider * + initialResolutions:TcAssemblyResolutions * + importsBase:TcImports option * + ilGlobalsOpt:AbstractIL.IL.ILGlobals option * + dependencyProviderOpt:Microsoft.DotNet.DependencyManager.DependencyProvider option -> + TcImports + static member + BuildFrameworkTcImports: AbstractIL.Internal.Library.CompilationThreadToken * + CompilerConfig.TcConfigProvider * + AssemblyResolution list * + AssemblyResolution list -> + AbstractIL.Internal.Library.Cancellable + static member + BuildNonFrameworkTcImports: AbstractIL.Internal.Library.CompilationThreadToken * + CompilerConfig.TcConfigProvider * + TcGlobals.TcGlobals * TcImports * + AssemblyResolution list * + CompilerConfig.UnresolvedAssemblyReference list * + Microsoft.DotNet.DependencyManager.DependencyProvider -> + AbstractIL.Internal.Library.Cancellable + static member + BuildTcImports: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfigP:CompilerConfig.TcConfigProvider * + dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> + AbstractIL.Internal.Library.Cancellable + member AllAssemblyResolutions: unit -> AssemblyResolution list + member private AttachDisposeAction: action:(unit -> unit) -> unit + member + private AttachDisposeTypeProviderAction: action:(unit -> unit) -> + unit + member + FindCcu: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + m:Range.range * assemblyName:string * lookupOnly:bool -> + TypedTree.CcuResolutionResult + member + FindCcuFromAssemblyRef: AbstractIL.Internal.Library.CompilationThreadToken * + Range.range * AbstractIL.IL.ILAssemblyRef -> + TypedTree.CcuResolutionResult + member + FindCcuInfo: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + m:Range.range * assemblyName:string * lookupOnly:bool -> + AvailableImportedAssembly + member + FindDllInfo: AbstractIL.Internal.Library.CompilationThreadToken * + Range.range * string -> ImportedBinary + member GetCcusExcludingBase: unit -> TypedTree.CcuThunk list + member GetCcusInDeclOrder: unit -> TypedTree.CcuThunk list + member GetDllInfos: unit -> ImportedBinary list + member GetImportMap: unit -> Import.ImportMap + member GetImportedAssemblies: unit -> ImportedAssembly list + member + GetProvidedAssemblyInfo: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + m:Range.range * + assembly:Tainted -> + bool * + ExtensionTyping.ProvidedAssemblyStaticLinkingMap option + member GetTcGlobals: unit -> TcGlobals.TcGlobals + member + ImplicitLoadIfAllowed: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + m:Range.range * assemblyName:string * + lookupOnly:bool -> unit + member + ImportTypeProviderExtensions: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfig:CompilerConfig.TcConfig * + fileNameOfRuntimeAssembly:string * + ilScopeRefOfRuntimeAssembly:AbstractIL.IL.ILScopeRef * + runtimeAssemblyAttributes:AbstractIL.IL.ILAttribute list * + entityToInjectInto:TypedTree.Entity * + invalidateCcu:Event * + m:Range.range -> + Tainted list + member + private InjectProvidedNamespaceOrTypeIntoEntity: typeProviderEnvironment:ExtensionTyping.ResolutionEnvironment * + tcConfig:CompilerConfig.TcConfig * + m:Range.range * + entity:TypedTree.Entity * + injectedNamespace:string list * + remainingNamespace:string list * + provider:Tainted * + st:Tainted option -> + unit + member IsAlreadyRegistered: nm:string -> bool + member + MkLoaderForMultiModuleILAssemblies: ctok:AbstractIL.Internal.Library.CompilationThreadToken -> + m:Range.range -> + (AbstractIL.IL.ILScopeRef -> + AbstractIL.IL.ILModuleDef) + member + OpenILBinaryModule: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + filename:string * m:Range.range -> + AbstractIL.IL.ILModuleDef * + AbstractIL.IL.ILAssemblyRef list + member + PrepareToImportReferencedFSharpAssembly: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + m:Range.range * + filename:string * + dllinfo:ImportedBinary -> + (unit -> + AvailableImportedAssembly list) + member + PrepareToImportReferencedILAssembly: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + m:Range.range * filename:string * + dllinfo:ImportedBinary -> + (unit -> + AvailableImportedAssembly list) + member + RecordGeneratedTypeRoot: root:ExtensionTyping.ProviderGeneratedType -> + unit + member + RegisterAndImportReferencedAssemblies: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + nms:AssemblyResolution list -> + AbstractIL.Internal.Library.Cancellable + member + RegisterAndPrepareToImportReferencedDll: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + r:AssemblyResolution -> + AbstractIL.Internal.Library.Cancellable + AvailableImportedAssembly list)> + member RegisterCcu: ccuInfo:ImportedAssembly -> unit + member RegisterDll: dllInfo:ImportedBinary -> unit + member + ReportUnresolvedAssemblyReferences: CompilerConfig.UnresolvedAssemblyReference list -> + unit + member + ResolveAssemblyReference: AbstractIL.Internal.Library.CompilationThreadToken * + CompilerConfig.AssemblyReference * + ResolveAssemblyReferenceMode -> + AssemblyResolution list + member private SetILGlobals: ilg:AbstractIL.IL.ILGlobals -> unit + member private SetTcGlobals: g:TcGlobals.TcGlobals -> unit + member SystemRuntimeContainsType: string -> bool + override ToString: unit -> string + member + TryFindDllInfo: AbstractIL.Internal.Library.CompilationThreadToken * + Range.range * string * lookupOnly:bool -> + ImportedBinary option + member + TryFindExistingFullyQualifiedPathByExactAssemblyRef: AbstractIL.Internal.Library.CompilationThreadToken * + AbstractIL.IL.ILAssemblyRef -> + string option + member + TryFindExistingFullyQualifiedPathBySimpleAssemblyName: AbstractIL.Internal.Library.CompilationThreadToken * + string -> + string option + member + TryFindProviderGeneratedAssemblyByName: AbstractIL.Internal.Library.CompilationThreadToken * + assemblyName:string -> + System.Reflection.Assembly option + member + TryResolveAssemblyReference: AbstractIL.Internal.Library.CompilationThreadToken * + CompilerConfig.AssemblyReference * + ResolveAssemblyReferenceMode -> + ErrorLogger.OperationResult + member Base: TcImports option + member CcuTable: AbstractIL.Internal.Library.NameMap + member + DependencyProvider: Microsoft.DotNet.DependencyManager.DependencyProvider + member DllTable: AbstractIL.Internal.Library.NameMap + member + ProviderGeneratedTypeRoots: ExtensionTyping.ProviderGeneratedType list + member Weak: TcImportsWeakHack + + val RequireDLL: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcImports:TcImports * tcEnv:CheckExpressions.TcEnv * + thisAssemblyName:string * referenceRange:Range.range * file:string -> + CheckExpressions.TcEnv * (ImportedBinary list * ImportedAssembly list) + val DefaultReferencesForScriptsAndOutOfProjectSources: bool -> string list + + +namespace FSharp.Compiler + module internal CompilerDiagnostics = + module CompilerService = + val showAssertForUnexpectedException: bool ref + + exception HashIncludeNotAllowedInNonScript of Range.range + exception HashReferenceNotAllowedInNonScript of Range.range + exception HashLoadedSourceHasIssues of exn list * exn list * Range.range + exception HashLoadedScriptConsideredSource of Range.range + exception HashDirectiveNotAllowedInNonScript of Range.range + exception DeprecatedCommandLineOptionFull of string * Range.range + exception DeprecatedCommandLineOptionForHtmlDoc of string * Range.range + exception DeprecatedCommandLineOptionSuggestAlternative of + string * string * + Range.range + exception DeprecatedCommandLineOptionNoDescription of string * Range.range + exception InternalCommandLineOption of string * Range.range + val GetRangeOfDiagnostic: + ErrorLogger.PhasedDiagnostic -> Range.range option + val GetDiagnosticNumber: ErrorLogger.PhasedDiagnostic -> int + val GetWarningLevel: err:ErrorLogger.PhasedDiagnostic -> int + val warningOn: + err:ErrorLogger.PhasedDiagnostic -> + level:int -> specificWarnOn:int list -> bool + val SplitRelatedDiagnostics: + ErrorLogger.PhasedDiagnostic -> + ErrorLogger.PhasedDiagnostic * ErrorLogger.PhasedDiagnostic list + val DeclareMessage: + (string * Printf.StringFormat<'a> -> DiagnosticMessage.ResourceString<'a>) + val SeeAlsoE: unit -> DiagnosticMessage.ResourceString<(string -> string)> + val ConstraintSolverTupleDiffLengthsE: + unit -> DiagnosticMessage.ResourceString<(int -> int -> string)> + val ConstraintSolverInfiniteTypesE: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val ConstraintSolverMissingConstraintE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val ConstraintSolverTypesNotInEqualityRelation1E: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val ConstraintSolverTypesNotInEqualityRelation2E: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val ConstraintSolverTypesNotInSubsumptionRelationE: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val ErrorFromAddingTypeEquation1E: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val ErrorFromAddingTypeEquation2E: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val ErrorFromApplyingDefault1E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val ErrorFromApplyingDefault2E: + unit -> DiagnosticMessage.ResourceString + val ErrorsFromAddingSubsumptionConstraintE: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val UpperCaseIdentifierInPatternE: + unit -> DiagnosticMessage.ResourceString + val NotUpperCaseConstructorE: + unit -> DiagnosticMessage.ResourceString + val FunctionExpectedE: unit -> DiagnosticMessage.ResourceString + val BakedInMemberConstraintNameE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val BadEventTransformationE: + unit -> DiagnosticMessage.ResourceString + val ParameterlessStructCtorE: + unit -> DiagnosticMessage.ResourceString + val InterfaceNotRevealedE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val TyconBadArgsE: + unit -> DiagnosticMessage.ResourceString<(string -> int -> int -> string)> + val IndeterminateTypeE: unit -> DiagnosticMessage.ResourceString + val NameClash1E: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val NameClash2E: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> + string -> string -> string)> + val Duplicate1E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val Duplicate2E: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val UndefinedName2E: unit -> DiagnosticMessage.ResourceString + val FieldNotMutableE: unit -> DiagnosticMessage.ResourceString + val FieldsFromDifferentTypesE: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val VarBoundTwiceE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val RecursionE: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> + string -> string)> + val InvalidRuntimeCoercionE: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val IndeterminateRuntimeCoercionE: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val IndeterminateStaticCoercionE: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val StaticCoercionShouldUseBoxE: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val TypeIsImplicitlyAbstractE: + unit -> DiagnosticMessage.ResourceString + val NonRigidTypar1E: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val NonRigidTypar2E: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val NonRigidTypar3E: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val OBlockEndSentenceE: unit -> DiagnosticMessage.ResourceString + val UnexpectedEndOfInputE: unit -> DiagnosticMessage.ResourceString + val UnexpectedE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val NONTERM_interactionE: unit -> DiagnosticMessage.ResourceString + val NONTERM_hashDirectiveE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_fieldDeclE: unit -> DiagnosticMessage.ResourceString + val NONTERM_unionCaseReprE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_localBindingE: unit -> DiagnosticMessage.ResourceString + val NONTERM_hardwhiteLetBindingsE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_classDefnMemberE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_defnBindingsE: unit -> DiagnosticMessage.ResourceString + val NONTERM_classMemberSpfnE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_valSpfnE: unit -> DiagnosticMessage.ResourceString + val NONTERM_tyconSpfnE: unit -> DiagnosticMessage.ResourceString + val NONTERM_anonLambdaExprE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_attrUnionCaseDeclE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_cPrototypeE: unit -> DiagnosticMessage.ResourceString + val NONTERM_objectImplementationMembersE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_ifExprCasesE: unit -> DiagnosticMessage.ResourceString + val NONTERM_openDeclE: unit -> DiagnosticMessage.ResourceString + val NONTERM_fileModuleSpecE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_patternClausesE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_beginEndExprE: unit -> DiagnosticMessage.ResourceString + val NONTERM_recdExprE: unit -> DiagnosticMessage.ResourceString + val NONTERM_tyconDefnE: unit -> DiagnosticMessage.ResourceString + val NONTERM_exconCoreE: unit -> DiagnosticMessage.ResourceString + val NONTERM_typeNameInfoE: unit -> DiagnosticMessage.ResourceString + val NONTERM_attributeListE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_quoteExprE: unit -> DiagnosticMessage.ResourceString + val NONTERM_typeConstraintE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_Category_ImplementationFileE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_Category_DefinitionE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_Category_SignatureFileE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_Category_PatternE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_Category_ExprE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_Category_TypeE: + unit -> DiagnosticMessage.ResourceString + val NONTERM_typeArgsActualE: + unit -> DiagnosticMessage.ResourceString + val TokenName1E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val TokenName1TokenName2E: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val TokenName1TokenName2TokenName3E: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val RuntimeCoercionSourceSealed1E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val RuntimeCoercionSourceSealed2E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val CoercionTargetSealedE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val UpcastUnnecessaryE: unit -> DiagnosticMessage.ResourceString + val TypeTestUnnecessaryE: unit -> DiagnosticMessage.ResourceString + val OverrideDoesntOverride1E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val OverrideDoesntOverride2E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val OverrideDoesntOverride3E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val OverrideDoesntOverride4E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val UnionCaseWrongArgumentsE: + unit -> DiagnosticMessage.ResourceString<(int -> int -> string)> + val UnionPatternsBindDifferentNamesE: + unit -> DiagnosticMessage.ResourceString + val RequiredButNotSpecifiedE: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val UseOfAddressOfOperatorE: + unit -> DiagnosticMessage.ResourceString + val DefensiveCopyWarningE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val DeprecatedThreadStaticBindingWarningE: + unit -> DiagnosticMessage.ResourceString + val FunctionValueUnexpectedE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val UnitTypeExpectedE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val UnitTypeExpectedWithEqualityE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val UnitTypeExpectedWithPossiblePropertySetterE: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val UnitTypeExpectedWithPossibleAssignmentE: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val UnitTypeExpectedWithPossibleAssignmentToMutableE: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val RecursiveUseCheckedAtRuntimeE: + unit -> DiagnosticMessage.ResourceString + val LetRecUnsound1E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val LetRecUnsound2E: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val LetRecUnsoundInnerE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val LetRecEvaluatedOutOfOrderE: + unit -> DiagnosticMessage.ResourceString + val LetRecCheckedAtRuntimeE: + unit -> DiagnosticMessage.ResourceString + val SelfRefObjCtor1E: unit -> DiagnosticMessage.ResourceString + val SelfRefObjCtor2E: unit -> DiagnosticMessage.ResourceString + val VirtualAugmentationOnNullValuedTypeE: + unit -> DiagnosticMessage.ResourceString + val NonVirtualAugmentationOnNullValuedTypeE: + unit -> DiagnosticMessage.ResourceString + val NonUniqueInferredAbstractSlot1E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val NonUniqueInferredAbstractSlot2E: + unit -> DiagnosticMessage.ResourceString + val NonUniqueInferredAbstractSlot3E: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val NonUniqueInferredAbstractSlot4E: + unit -> DiagnosticMessage.ResourceString + val Failure3E: unit -> DiagnosticMessage.ResourceString<(string -> string)> + val Failure4E: unit -> DiagnosticMessage.ResourceString<(string -> string)> + val MatchIncomplete1E: unit -> DiagnosticMessage.ResourceString + val MatchIncomplete2E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val MatchIncomplete3E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val MatchIncomplete4E: unit -> DiagnosticMessage.ResourceString + val RuleNeverMatchedE: unit -> DiagnosticMessage.ResourceString + val EnumMatchIncomplete1E: unit -> DiagnosticMessage.ResourceString + val ValNotMutableE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val ValNotLocalE: unit -> DiagnosticMessage.ResourceString + val Obsolete1E: unit -> DiagnosticMessage.ResourceString + val Obsolete2E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val ExperimentalE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val PossibleUnverifiableCodeE: + unit -> DiagnosticMessage.ResourceString + val DeprecatedE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val LibraryUseOnlyE: unit -> DiagnosticMessage.ResourceString + val MissingFieldsE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val ValueRestriction1E: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val ValueRestriction2E: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val ValueRestriction3E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val ValueRestriction4E: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val ValueRestriction5E: + unit -> + DiagnosticMessage.ResourceString<(string -> string -> string -> string)> + val RecoverableParseErrorE: + unit -> DiagnosticMessage.ResourceString + val ReservedKeywordE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val IndentationProblemE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val OverrideInIntrinsicAugmentationE: + unit -> DiagnosticMessage.ResourceString + val OverrideInExtrinsicAugmentationE: + unit -> DiagnosticMessage.ResourceString + val IntfImplInIntrinsicAugmentationE: + unit -> DiagnosticMessage.ResourceString + val IntfImplInExtrinsicAugmentationE: + unit -> DiagnosticMessage.ResourceString + val UnresolvedReferenceNoRangeE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val UnresolvedPathReferenceNoRangeE: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val HashIncludeNotAllowedInNonScriptE: + unit -> DiagnosticMessage.ResourceString + val HashReferenceNotAllowedInNonScriptE: + unit -> DiagnosticMessage.ResourceString + val HashDirectiveNotAllowedInNonScriptE: + unit -> DiagnosticMessage.ResourceString + val FileNameNotResolvedE: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val AssemblyNotResolvedE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val HashLoadedSourceHasIssues1E: + unit -> DiagnosticMessage.ResourceString + val HashLoadedSourceHasIssues2E: + unit -> DiagnosticMessage.ResourceString + val HashLoadedScriptConsideredSourceE: + unit -> DiagnosticMessage.ResourceString + val InvalidInternalsVisibleToAssemblyName1E: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val InvalidInternalsVisibleToAssemblyName2E: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val LoadedSourceNotFoundIgnoringE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val MSBuildReferenceResolutionErrorE: + unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> + val TargetInvocationExceptionWrapperE: + unit -> DiagnosticMessage.ResourceString<(string -> string)> + val getErrorString: key:string -> string + val ( |InvalidArgument|_| ): exn:exn -> string option + val OutputPhasedErrorR: + os:System.Text.StringBuilder -> + err:ErrorLogger.PhasedDiagnostic -> canSuggestNames:bool -> unit + val OutputPhasedDiagnostic: + System.Text.StringBuilder -> + ErrorLogger.PhasedDiagnostic -> + flattenErrors:bool -> suggestNames:bool -> unit + val SanitizeFileName: + fileName:string -> implicitIncludeDir:string -> string + [] + type DiagnosticLocation = + { Range: Range.range + File: string + TextRepresentation: string + IsEmpty: bool } + [] + type DiagnosticCanonicalInformation = + { ErrorNumber: int + Subcategory: string + TextRepresentation: string } + [] + type DiagnosticDetailedInfo = + { Location: DiagnosticLocation option + Canonical: DiagnosticCanonicalInformation + Message: string } + [] + type Diagnostic = + | Short of bool * string + | Long of bool * DiagnosticDetailedInfo + val CollectDiagnostic: + implicitIncludeDir:string * showFullPaths:bool * flattenErrors:bool * + errorStyle:ErrorLogger.ErrorStyle * isError:bool * + ErrorLogger.PhasedDiagnostic * suggestNames:bool -> seq + val OutputDiagnostic: + implicitIncludeDir:string * showFullPaths:bool * flattenErrors:bool * + errorStyle:ErrorLogger.ErrorStyle * isError:bool -> + System.Text.StringBuilder -> ErrorLogger.PhasedDiagnostic -> unit + val OutputDiagnosticContext: + prefix:string -> + fileLineFunction:(string -> int -> string) -> + System.Text.StringBuilder -> ErrorLogger.PhasedDiagnostic -> unit + val ReportWarning: + ErrorLogger.FSharpErrorSeverityOptions -> + ErrorLogger.PhasedDiagnostic -> bool + val ReportWarningAsError: + ErrorLogger.FSharpErrorSeverityOptions -> + ErrorLogger.PhasedDiagnostic -> bool + type ErrorLoggerFilteringByScopedPragmas = + + inherit ErrorLogger.ErrorLogger + new: checkFile:bool * scopedPragmas:SyntaxTree.ScopedPragma list * + errorLogger:ErrorLogger.ErrorLogger -> + ErrorLoggerFilteringByScopedPragmas + override + DiagnosticSink: phasedError:ErrorLogger.PhasedDiagnostic * + isError:bool -> unit + override ErrorCount: int + + val GetErrorLoggerFilteringByScopedPragmas: + checkFile:bool * SyntaxTree.ScopedPragma list * ErrorLogger.ErrorLogger -> + ErrorLogger.ErrorLogger + + +namespace FSharp.Compiler + module internal ParseAndCheckInputs = + val CanonicalizeFilename: filename:string -> string + val IsScript: string -> bool + val QualFileNameOfModuleName: + m:Range.range -> + filename:string -> + modname:SyntaxTree.Ident list -> SyntaxTree.QualifiedNameOfFile + val QualFileNameOfFilename: + m:Range.range -> filename:string -> SyntaxTree.QualifiedNameOfFile + val ComputeQualifiedNameOfFileFromUniquePath: + Range.range * string list -> SyntaxTree.QualifiedNameOfFile + val QualFileNameOfSpecs: + filename:string -> + specs:SyntaxTree.SynModuleOrNamespaceSig list -> + SyntaxTree.QualifiedNameOfFile + val QualFileNameOfImpls: + filename:string -> + specs:SyntaxTree.SynModuleOrNamespace list -> + SyntaxTree.QualifiedNameOfFile + val PrependPathToQualFileName: + x:SyntaxTree.Ident list -> + SyntaxTree.QualifiedNameOfFile -> SyntaxTree.QualifiedNameOfFile + val PrependPathToImpl: + x:SyntaxTree.Ident list -> + SyntaxTree.SynModuleOrNamespace -> SyntaxTree.SynModuleOrNamespace + val PrependPathToSpec: + x:SyntaxTree.Ident list -> + SyntaxTree.SynModuleOrNamespaceSig -> SyntaxTree.SynModuleOrNamespaceSig + val PrependPathToInput: + SyntaxTree.Ident list -> SyntaxTree.ParsedInput -> SyntaxTree.ParsedInput + val ComputeAnonModuleName: + check:bool -> + defaultNamespace:string option -> + filename:string -> m:Range.range -> SyntaxTree.Ident list + val PostParseModuleImpl: + _i:'a * defaultNamespace:string option * isLastCompiland:(bool * bool) * + filename:string * impl:SyntaxTree.ParsedImplFileFragment -> + SyntaxTree.SynModuleOrNamespace + val PostParseModuleSpec: + _i:'a * defaultNamespace:string option * isLastCompiland:(bool * bool) * + filename:string * intf:SyntaxTree.ParsedSigFileFragment -> + SyntaxTree.SynModuleOrNamespaceSig + val GetScopedPragmasForInput: + input:SyntaxTree.ParsedInput -> SyntaxTree.ScopedPragma list + val GetScopedPragmasForHashDirective: + hd:SyntaxTree.ParsedHashDirective -> SyntaxTree.ScopedPragma list + val PostParseModuleImpls: + defaultNamespace:string option * filename:string * + isLastCompiland:(bool * bool) * SyntaxTree.ParsedImplFile -> + SyntaxTree.ParsedInput + val PostParseModuleSpecs: + defaultNamespace:string option * filename:string * + isLastCompiland:(bool * bool) * SyntaxTree.ParsedSigFile -> + SyntaxTree.ParsedInput + type ModuleNamesDict = + Map> + val DeduplicateModuleName: + moduleNamesDict:ModuleNamesDict -> + fileName:string -> + qualNameOfFile:SyntaxTree.QualifiedNameOfFile -> + SyntaxTree.QualifiedNameOfFile * ModuleNamesDict + val DeduplicateParsedInputModuleName: + ModuleNamesDict -> + SyntaxTree.ParsedInput -> SyntaxTree.ParsedInput * ModuleNamesDict + val ParseInput: + (Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token) * + ErrorLogger.ErrorLogger * UnicodeLexing.Lexbuf * string option * string * + isLastCompiland:(bool * bool) -> SyntaxTree.ParsedInput + val ShowAllTokensAndExit: + shortFilename:string * tokenizer:LexFilter.LexFilter * + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> unit + val TestInteractionParserAndExit: + tokenizer:LexFilter.LexFilter * + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> 'a + val ReportParsingStatistics: res:SyntaxTree.ParsedInput -> unit + val ParseOneInputLexbuf: + tcConfig:CompilerConfig.TcConfig * + lexResourceManager:Lexhelp.LexResourceManager * + conditionalCompilationDefines:string list * lexbuf:UnicodeLexing.Lexbuf * + filename:string * isLastCompiland:(bool * bool) * + errorLogger:ErrorLogger.ErrorLogger -> SyntaxTree.ParsedInput option + val ValidSuffixes: string list + val ParseOneInputFile: + CompilerConfig.TcConfig * Lexhelp.LexResourceManager * string list * + string * isLastCompiland:(bool * bool) * ErrorLogger.ErrorLogger * bool -> + SyntaxTree.ParsedInput option + val ProcessMetaCommandsFromInput: + (('T -> Range.range * string -> 'T) * + ('T -> Range.range * string * CompilerConfig.Directive -> 'T) * + ('T -> Range.range * string -> unit)) -> + CompilerConfig.TcConfigBuilder * SyntaxTree.ParsedInput * string * 'T -> + 'T + val ApplyNoWarnsToTcConfig: + CompilerConfig.TcConfig * SyntaxTree.ParsedInput * string -> + CompilerConfig.TcConfig + val ApplyMetaCommandsFromInputToTcConfig: + CompilerConfig.TcConfig * SyntaxTree.ParsedInput * string * + Microsoft.DotNet.DependencyManager.DependencyProvider -> + CompilerConfig.TcConfig + val GetInitialTcEnv: + assemblyName:string * Range.range * CompilerConfig.TcConfig * + CompilerImports.TcImports * TcGlobals.TcGlobals -> CheckExpressions.TcEnv + val CheckSimulateException: tcConfig:CompilerConfig.TcConfig -> unit + type RootSigs = + AbstractIL.Internal.Zmap + type RootImpls = AbstractIL.Internal.Zset + val qnameOrder: + System.Collections.Generic.IComparer + [] + type TcState = + { tcsCcu: TypedTree.CcuThunk + tcsCcuType: TypedTree.ModuleOrNamespace + tcsNiceNameGen: CompilerGlobalState.NiceNameGenerator + tcsTcSigEnv: CheckExpressions.TcEnv + tcsTcImplEnv: CheckExpressions.TcEnv + tcsCreatesGeneratedProvidedTypes: bool + tcsRootSigs: RootSigs + tcsRootImpls: RootImpls + tcsCcuSig: TypedTree.ModuleOrNamespaceType } + with + member + NextStateAfterIncrementalFragment: CheckExpressions.TcEnv -> TcState + member Ccu: TypedTree.CcuThunk + member CcuSig: TypedTree.ModuleOrNamespaceType + member CcuType: TypedTree.ModuleOrNamespace + member CreatesGeneratedProvidedTypes: bool + member NiceNameGenerator: CompilerGlobalState.NiceNameGenerator + member TcEnvFromImpls: CheckExpressions.TcEnv + member TcEnvFromSignatures: CheckExpressions.TcEnv + + val GetInitialTcState: + Range.range * string * CompilerConfig.TcConfig * TcGlobals.TcGlobals * + CompilerImports.TcImports * CompilerGlobalState.NiceNameGenerator * + CheckExpressions.TcEnv -> TcState + val TypeCheckOneInputEventually: + checkForErrors:(unit -> bool) * CompilerConfig.TcConfig * + CompilerImports.TcImports * TcGlobals.TcGlobals * + SyntaxTree.LongIdent option * NameResolution.TcResultsSink * TcState * + SyntaxTree.ParsedInput * skipImplIfSigExists:bool -> + AbstractIL.Internal.Library.Eventually<(CheckExpressions.TcEnv * + CheckDeclarations.TopAttribs * + TypedTree.TypedImplFile option * + TypedTree.ModuleOrNamespaceType) * + TcState> + val TypeCheckOneInput: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + checkForErrors:(unit -> bool) * tcConfig:CompilerConfig.TcConfig * + tcImports:CompilerImports.TcImports * tcGlobals:TcGlobals.TcGlobals * + prefixPathOpt:SyntaxTree.LongIdent option -> + tcState:TcState -> + inp:SyntaxTree.ParsedInput -> + (CheckExpressions.TcEnv * CheckDeclarations.TopAttribs * + TypedTree.TypedImplFile option * TypedTree.ModuleOrNamespaceType) * + TcState + val TypeCheckMultipleInputsFinish: + (CheckExpressions.TcEnv * CheckDeclarations.TopAttribs * 'T option * 'U) list * + TcState -> + (CheckExpressions.TcEnv * CheckDeclarations.TopAttribs * 'T list * + 'U list) * TcState + val TypeCheckOneInputAndFinishEventually: + checkForErrors:(unit -> bool) * CompilerConfig.TcConfig * + CompilerImports.TcImports * TcGlobals.TcGlobals * + SyntaxTree.LongIdent option * NameResolution.TcResultsSink * TcState * + SyntaxTree.ParsedInput -> + AbstractIL.Internal.Library.Eventually<(CheckExpressions.TcEnv * + CheckDeclarations.TopAttribs * + TypedTree.TypedImplFile list * + TypedTree.ModuleOrNamespaceType list) * + TcState> + val TypeCheckClosedInputSetFinish: + TypedTree.TypedImplFile list * TcState -> + TcState * TypedTree.TypedImplFile list + val TypeCheckClosedInputSet: + AbstractIL.Internal.Library.CompilationThreadToken * + checkForErrors:(unit -> bool) * CompilerConfig.TcConfig * + CompilerImports.TcImports * TcGlobals.TcGlobals * + SyntaxTree.LongIdent option * TcState * SyntaxTree.ParsedInput list -> + TcState * CheckDeclarations.TopAttribs * TypedTree.TypedImplFile list * + CheckExpressions.TcEnv + + +namespace FSharp.Compiler + module internal ScriptClosure = + [] + type LoadClosureInput = + { FileName: string + SyntaxTree: SyntaxTree.ParsedInput option + ParseDiagnostics: (ErrorLogger.PhasedDiagnostic * bool) list + MetaCommandDiagnostics: (ErrorLogger.PhasedDiagnostic * bool) list } + [] + type LoadClosure = + { SourceFiles: (string * Range.range list) list + References: (string * CompilerImports.AssemblyResolution list) list + PackageReferences: (Range.range * string list) [] + UnresolvedReferences: CompilerConfig.UnresolvedAssemblyReference list + Inputs: LoadClosureInput list + OriginalLoadReferences: (Range.range * string * string) list + NoWarns: (string * Range.range list) list + ResolutionDiagnostics: (ErrorLogger.PhasedDiagnostic * bool) list + AllRootFileDiagnostics: (ErrorLogger.PhasedDiagnostic * bool) list + LoadClosureRootFileDiagnostics: + (ErrorLogger.PhasedDiagnostic * bool) list } + with + static member + ComputeClosureOfScriptFiles: AbstractIL.Internal.Library.CompilationThreadToken * + tcConfig:CompilerConfig.TcConfig * + (string * Range.range) list * + implicitDefines:CodeContext * + lexResourceManager:Lexhelp.LexResourceManager * + dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> + LoadClosure + static member + ComputeClosureOfScriptText: AbstractIL.Internal.Library.CompilationThreadToken * + legacyReferenceResolver:ReferenceResolver.Resolver * + defaultFSharpBinariesDir:string * + filename:string * + sourceText:Text.ISourceText * + implicitDefines:CodeContext * + useSimpleResolution:bool * + useFsiAuxLib:bool * useSdkRefs:bool * + lexResourceManager:Lexhelp.LexResourceManager * + applyCompilerOptions:(CompilerConfig.TcConfigBuilder -> + unit) * + assumeDotNetFramework:bool * + tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * + reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * + dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> + LoadClosure + + [] + type CodeContext = + | CompilationAndEvaluation + | Compilation + | Editing + module ScriptPreprocessClosure = + type ClosureSource = + | ClosureSource of + filename: string * referenceRange: Range.range * + sourceText: Text.ISourceText * parseRequired: bool + type ClosureFile = + | ClosureFile of + string * Range.range * SyntaxTree.ParsedInput option * + (ErrorLogger.PhasedDiagnostic * bool) list * + (ErrorLogger.PhasedDiagnostic * bool) list * + (string * Range.range) list + type Observed = + + new: unit -> Observed + member HaveSeen: check:string -> bool + member SetSeen: check:string -> unit + + val ParseScriptText: + filename:string * sourceText:Text.ISourceText * + tcConfig:CompilerConfig.TcConfig * codeContext:CodeContext * + lexResourceManager:Lexhelp.LexResourceManager * + errorLogger:ErrorLogger.ErrorLogger -> SyntaxTree.ParsedInput option + val CreateScriptTextTcConfig: + legacyReferenceResolver:ReferenceResolver.Resolver * + defaultFSharpBinariesDir:string * filename:string * + codeContext:CodeContext * useSimpleResolution:bool * useFsiAuxLib:bool * + basicReferences:#seq option * + applyCommandLineArgs:(CompilerConfig.TcConfigBuilder -> unit) * + assumeDotNetFramework:bool * useSdkRefs:bool * + tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * + reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag -> + CompilerConfig.TcConfig + val ClosureSourceOfFilename: + filename:string * m:Range.range * inputCodePage:int option * + parseRequired:bool -> ClosureSource list + val ApplyMetaCommandsFromInputToTcConfigAndGatherNoWarn: + tcConfig:CompilerConfig.TcConfig * inp:SyntaxTree.ParsedInput * + pathOfMetaCommandSource:string * + dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> + CompilerConfig.TcConfig * (string * Range.range) list + val FindClosureFiles: + mainFile:string * _m:'a * closureSources:ClosureSource list * + origTcConfig:CompilerConfig.TcConfig * codeContext:CodeContext * + lexResourceManager:Lexhelp.LexResourceManager * + dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> + ClosureFile list * CompilerConfig.TcConfig * + (Range.range * string list) [] + val GetLoadClosure: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + rootFilename:string * closureFiles:ClosureFile list * + tcConfig:CompilerConfig.TcConfig * codeContext:CodeContext * + packageReferences:(Range.range * string list) [] -> LoadClosure + val GetFullClosureOfScriptText: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + legacyReferenceResolver:ReferenceResolver.Resolver * + defaultFSharpBinariesDir:string * filename:string * + sourceText:Text.ISourceText * codeContext:CodeContext * + useSimpleResolution:bool * useFsiAuxLib:bool * useSdkRefs:bool * + lexResourceManager:Lexhelp.LexResourceManager * + applyCommandLineArgs:(CompilerConfig.TcConfigBuilder -> unit) * + assumeDotNetFramework:bool * + tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * + reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * + dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> + LoadClosure + val GetFullClosureOfScriptFiles: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfig:CompilerConfig.TcConfig * files:(string * Range.range) list * + codeContext:CodeContext * lexResourceManager:Lexhelp.LexResourceManager * + dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> + LoadClosure + + + +namespace FSharp.Compiler + module internal CompilerOptions = + module Attributes = + + [] + type OptionSwitch = + | On + | Off + type OptionSpec = + | OptionClear of bool ref + | OptionFloat of (float -> unit) + | OptionInt of (int -> unit) + | OptionSwitch of (OptionSwitch -> unit) + | OptionIntList of (int -> unit) + | OptionIntListSwitch of (int -> OptionSwitch -> unit) + | OptionRest of (string -> unit) + | OptionSet of bool ref + | OptionString of (string -> unit) + | OptionStringList of (string -> unit) + | OptionStringListSwitch of (string -> OptionSwitch -> unit) + | OptionUnit of (unit -> unit) + | OptionHelp of (CompilerOptionBlock list -> unit) + | OptionGeneral of (string list -> bool) * (string list -> string list) + and CompilerOption = + | CompilerOption of + string * string * OptionSpec * Option * string option + and CompilerOptionBlock = + | PublicOptions of string * CompilerOption list + | PrivateOptions of CompilerOption list + val GetOptionsOfBlock: block:CompilerOptionBlock -> CompilerOption list + val FilterCompilerOptionBlock: + (CompilerOption -> bool) -> CompilerOptionBlock -> CompilerOptionBlock + val compilerOptionUsage: CompilerOption -> string + val PrintCompilerOption: CompilerOption -> unit + val PrintPublicOptions: heading:string * opts:CompilerOption list -> unit + val PrintCompilerOptionBlocks: CompilerOptionBlock list -> unit + val dumpCompilerOption: prefix:string -> CompilerOption -> unit + val dumpCompilerOptionBlock: _arg1:CompilerOptionBlock -> unit + val DumpCompilerOptionBlocks: CompilerOptionBlock list -> unit + val isSlashOpt: opt:string -> bool + module ResponseFile = + type ResponseFileData = ResponseFileLine list + and ResponseFileLine = + | CompilerOptionSpec of string + | Comment of string + val parseFile: path:string -> Choice + + val ParseCompilerOptions: + (string -> unit) * CompilerOptionBlock list * string list -> unit + val lexFilterVerbose: bool + val mutable enableConsoleColoring: bool + val setFlag: r:(bool -> 'a) -> n:int -> 'a + val SetOptimizeOff: tcConfigB:CompilerConfig.TcConfigBuilder -> unit + val SetOptimizeOn: tcConfigB:CompilerConfig.TcConfigBuilder -> unit + val SetOptimizeSwitch: + CompilerConfig.TcConfigBuilder -> OptionSwitch -> unit + val SetTailcallSwitch: + CompilerConfig.TcConfigBuilder -> OptionSwitch -> unit + val SetDeterministicSwitch: + tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit + val AddPathMapping: + tcConfigB:CompilerConfig.TcConfigBuilder -> pathPair:string -> unit + val jitoptimizeSwitch: + tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit + val localoptimizeSwitch: + tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit + val crossOptimizeSwitch: + tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit + val splittingSwitch: + tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit + val callVirtSwitch: + tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit + val useHighEntropyVASwitch: + tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit + val subSystemVersionSwitch: + tcConfigB:CompilerConfig.TcConfigBuilder -> text:string -> unit + val SetUseSdkSwitch: + tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit + val ( ++ ): x:'a list -> s:'a -> 'a list + val SetTarget: tcConfigB:CompilerConfig.TcConfigBuilder -> s:string -> unit + val SetDebugSwitch: + CompilerConfig.TcConfigBuilder -> string option -> OptionSwitch -> unit + val SetEmbedAllSourceSwitch: + tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit + val setOutFileName: + tcConfigB:CompilerConfig.TcConfigBuilder -> path:string -> unit + val setSignatureFile: + tcConfigB:CompilerConfig.TcConfigBuilder -> s:string -> unit + val tagString: string + val tagExe: string + val tagWinExe: string + val tagLibrary: string + val tagModule: string + val tagFile: string + val tagFileList: string + val tagDirList: string + val tagPathList: string + val tagResInfo: string + val tagFullPDBOnlyPortable: string + val tagWarnList: string + val tagSymbolList: string + val tagAddress: string + val tagAlgorithm: string + val tagInt: string + val tagPathMap: string + val tagNone: string + val tagLangVersionValues: string + val PrintOptionInfo: CompilerConfig.TcConfigBuilder -> unit + val inputFileFlagsBoth: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val referenceFlagAbbrev: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val compilerToolFlagAbbrev: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val inputFileFlagsFsc: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val inputFileFlagsFsiBase: + _tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val inputFileFlagsFsi: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val errorsAndWarningsFlags: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val outputFileFlagsFsi: + _tcConfigB:CompilerConfig.TcConfigBuilder -> 'a list + val outputFileFlagsFsc: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val resourcesFlagsFsi: _tcConfigB:CompilerConfig.TcConfigBuilder -> 'a list + val resourcesFlagsFsc: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val codeGenerationFlags: + isFsi:bool -> + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val defineSymbol: + tcConfigB:CompilerConfig.TcConfigBuilder -> s:string -> unit + val mlCompatibilityFlag: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val setLanguageVersion: specifiedVersion:string -> Features.LanguageVersion + val languageFlags: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val libFlag: tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val codePageFlag: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val preferredUiLang: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val utf8OutputFlag: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val fullPathsFlag: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val cliRootFlag: + _tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val SetTargetProfile: CompilerConfig.TcConfigBuilder -> string -> unit + val advancedFlagsBoth: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val noFrameworkFlag: + isFsc:bool -> tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val advancedFlagsFsi: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val advancedFlagsFsc: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val testFlag: tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val editorSpecificFlags: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val internalFlags: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val compilingFsLibFlag: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val compilingFsLib20Flag: CompilerOption + val compilingFsLib40Flag: CompilerOption + val compilingFsLibNoBigIntFlag: CompilerOption + val mlKeywordsFlag: CompilerOption + val gnuStyleErrorsFlag: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val deprecatedFlagsBoth: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val deprecatedFlagsFsi: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val deprecatedFlagsFsc: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val DisplayBannerText: CompilerConfig.TcConfigBuilder -> unit + val displayHelpFsc: + tcConfigB:CompilerConfig.TcConfigBuilder -> + blocks:CompilerOptionBlock list -> 'a + val displayVersion: tcConfigB:CompilerConfig.TcConfigBuilder -> 'a + val miscFlagsBoth: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val miscFlagsFsc: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val miscFlagsFsi: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val abbreviatedFlagsBoth: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val abbreviatedFlagsFsi: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val abbreviatedFlagsFsc: + tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list + val GetAbbrevFlagSet: CompilerConfig.TcConfigBuilder -> bool -> Set + val PostProcessCompilerArgs: Set -> string [] -> string list + val testingAndQAFlags: _tcConfigB:'a -> CompilerOption list + val GetCoreFscCompilerOptions: + CompilerConfig.TcConfigBuilder -> CompilerOptionBlock list + val GetCoreServiceCompilerOptions: + CompilerConfig.TcConfigBuilder -> CompilerOptionBlock list + val GetCoreFsiCompilerOptions: + CompilerConfig.TcConfigBuilder -> CompilerOptionBlock list + val ApplyCommandLineArgs: + tcConfigB:CompilerConfig.TcConfigBuilder * sourceFiles:string list * + argv:string list -> string list + val mutable showTermFileCount: int + val PrintWholeAssemblyImplementation: + g:TcGlobals.TcGlobals -> + tcConfig:CompilerConfig.TcConfig -> + outfile:string -> + header:string -> expr:TypedTree.TypedImplFile list -> unit + val mutable tPrev: (float * int []) option + val mutable nPrev: string option + val ReportTime: CompilerConfig.TcConfig -> string -> unit + val ignoreFailureOnMono1_1_16: (unit -> unit) -> unit + val foreBackColor: + unit -> (System.ConsoleColor * System.ConsoleColor) option + val DoWithColor: System.ConsoleColor -> (unit -> 'a) -> 'a + val DoWithErrorColor: bool -> (unit -> 'a) -> 'a + + +namespace FSharp.Compiler + module internal OptimizeInputs = + val mutable showTermFileCount: int + val PrintWholeAssemblyImplementation: + g:TcGlobals.TcGlobals -> + tcConfig:CompilerConfig.TcConfig -> + outfile:string -> + header:string -> expr:TypedTree.TypedImplFile list -> unit + val AddExternalCcuToOptimizationEnv: + TcGlobals.TcGlobals -> + Optimizer.IncrementalOptimizationEnv -> + CompilerImports.ImportedAssembly -> + Optimizer.IncrementalOptimizationEnv + val GetInitialOptimizationEnv: + CompilerImports.TcImports * TcGlobals.TcGlobals -> + Optimizer.IncrementalOptimizationEnv + val ApplyAllOptimizations: + CompilerConfig.TcConfig * TcGlobals.TcGlobals * ConstraintSolver.TcValF * + string * Import.ImportMap * bool * Optimizer.IncrementalOptimizationEnv * + TypedTree.CcuThunk * TypedTree.TypedImplFile list -> + TypedTree.TypedAssemblyAfterOptimization * Optimizer.CcuOptimizationInfo * + Optimizer.IncrementalOptimizationEnv + val CreateIlxAssemblyGenerator: + CompilerConfig.TcConfig * CompilerImports.TcImports * TcGlobals.TcGlobals * + ConstraintSolver.TcValF * TypedTree.CcuThunk -> + IlxGen.IlxAssemblyGenerator + val GenerateIlxCode: + IlxGen.IlxGenBackend * isInteractiveItExpr:bool * isInteractiveOnMono:bool * + CompilerConfig.TcConfig * CheckDeclarations.TopAttribs * + TypedTree.TypedAssemblyAfterOptimization * fragName:string * + IlxGen.IlxAssemblyGenerator -> IlxGen.IlxGenResults + val NormalizeAssemblyRefs: + AbstractIL.Internal.Library.CompilationThreadToken * + AbstractIL.IL.ILGlobals * CompilerImports.TcImports -> + (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILScopeRef) + val GetGeneratedILModuleName: + CompilerConfig.CompilerTarget -> string -> string + + +namespace FSharp.Compiler + module internal XmlDocFileWriter = + module XmlDocWriter = + val hasDoc: doc:XmlDoc.XmlDoc -> bool + val ComputeXmlDocSigs: + tcGlobals:TcGlobals.TcGlobals * generatedCcu:TypedTree.CcuThunk -> unit + val WriteXmlDocFile: + assemblyName:string * generatedCcu:TypedTree.CcuThunk * xmlfile:string -> + unit + + + +namespace FSharp.Compiler + module internal BinaryResourceFormats = + module BinaryGenerationUtilities = + val b0: n:int -> byte + val b1: n:int -> byte + val b2: n:int -> byte + val b3: n:int -> byte + val i16: i:int32 -> byte [] + val i32: i:int32 -> byte [] + val Padded: initialAlignment:int -> v:byte [] -> byte [] + + module ResFileFormat = + val ResFileNode: + dwTypeID:int32 * dwNameID:int32 * wMemFlags:int32 * wLangID:int32 * + data:byte [] -> byte [] + val ResFileHeader: unit -> byte [] + + module VersionResourceFormat = + val VersionInfoNode: data:byte [] -> byte [] + val VersionInfoElement: + wType:int32 * szKey:byte [] * valueOpt:byte [] option * + children:byte [] [] * isString:bool -> byte [] + val Version: version:AbstractIL.IL.ILVersionInfo -> byte [] + val String: string:string * value:string -> byte [] + val StringTable: + language:string * strings:seq -> byte [] + val StringFileInfo: + stringTables:#seq -> byte [] + when 'b:> seq + val VarFileInfo: vars:#seq -> byte [] + val VS_FIXEDFILEINFO: + fileVersion:AbstractIL.IL.ILVersionInfo * + productVersion:AbstractIL.IL.ILVersionInfo * dwFileFlagsMask:int32 * + dwFileFlags:int32 * dwFileOS:int32 * dwFileType:int32 * + dwFileSubtype:int32 * lwFileDate:int64 -> byte [] + val VS_VERSION_INFO: + fixedFileInfo:(AbstractIL.IL.ILVersionInfo * AbstractIL.IL.ILVersionInfo * + int32 * int32 * int32 * int32 * int32 * int64) * + stringFileInfo:seq> * + varFileInfo:seq -> byte [] + val VS_VERSION_INFO_RESOURCE: + (AbstractIL.IL.ILVersionInfo * AbstractIL.IL.ILVersionInfo * int32 * + int32 * int32 * int32 * int32 * int64) * + seq> * seq -> byte [] + + module ManifestResourceFormat = + val VS_MANIFEST_RESOURCE: data:byte [] * isLibrary:bool -> byte [] + + + +namespace FSharp.Compiler + module internal StaticLinking = + type TypeForwarding = + + new: tcImports:CompilerImports.TcImports -> TypeForwarding + member + TypeForwardILTypeRef: tref:AbstractIL.IL.ILTypeRef -> + AbstractIL.IL.ILTypeRef + + val debugStaticLinking: bool + val StaticLinkILModules: + tcConfig:CompilerConfig.TcConfig * ilGlobals:AbstractIL.IL.ILGlobals * + tcImports:CompilerImports.TcImports * + ilxMainModule:AbstractIL.IL.ILModuleDef * + dependentILModules:(TypedTree.CcuThunk option * AbstractIL.IL.ILModuleDef) list -> + AbstractIL.IL.ILModuleDef * + (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILScopeRef) + [] + type Node = + { name: string + data: AbstractIL.IL.ILModuleDef + ccu: TypedTree.CcuThunk option + refs: AbstractIL.IL.ILReferences + mutable edges: Node list + mutable visited: bool } + val FindDependentILModulesForStaticLinking: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfig:CompilerConfig.TcConfig * tcImports:CompilerImports.TcImports * + ilGlobals:AbstractIL.IL.ILGlobals * + ilxMainModule:AbstractIL.IL.ILModuleDef -> + (TypedTree.CcuThunk option * AbstractIL.IL.ILModuleDef) list + val FindProviderGeneratedILModules: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcImports:CompilerImports.TcImports * + providerGeneratedAssemblies:(CompilerImports.ImportedBinary * 'a) list -> + ((TypedTree.CcuThunk option * AbstractIL.IL.ILScopeRef * + AbstractIL.IL.ILModuleDef) * (string * 'a)) list + val StaticLink: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfig:CompilerConfig.TcConfig * tcImports:CompilerImports.TcImports * + ilGlobals:AbstractIL.IL.ILGlobals -> + (AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILModuleDef) + + +namespace FSharp.Compiler + module internal CreateILModule = + module AttributeHelpers = + val TryFindStringAttribute: + g:TcGlobals.TcGlobals -> + attrib:string -> attribs:TypedTree.Attribs -> string option + val TryFindIntAttribute: + g:TcGlobals.TcGlobals -> + attrib:string -> attribs:TypedTree.Attribs -> int32 option + val TryFindBoolAttribute: + g:TcGlobals.TcGlobals -> + attrib:string -> attribs:TypedTree.Attribs -> bool option + val ( |ILVersion|_| ): + versionString:string -> AbstractIL.IL.ILVersionInfo option + + type StrongNameSigningInfo = + | StrongNameSigningInfo of + delaysign: bool * publicsign: bool * signer: string option * + container: string option + val ValidateKeySigningAttributes: + tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * + CheckDeclarations.TopAttribs -> StrongNameSigningInfo + val GetStrongNameSigner: + signingInfo:StrongNameSigningInfo -> + AbstractIL.Internal.StrongNameSign.ILStrongNameSigner option + module MainModuleBuilder = + val injectedCompatTypes: Set + val typesForwardedToMscorlib: Set + val typesForwardedToSystemNumerics: Set + val createMscorlibExportList: + tcGlobals:TcGlobals.TcGlobals -> + AbstractIL.IL.ILExportedTypeOrForwarder list + val createSystemNumericsExportList: + tcConfig:CompilerConfig.TcConfig -> + tcImports:CompilerImports.TcImports -> + AbstractIL.IL.ILExportedTypeOrForwarder list + val fileVersion: + findStringAttr:(string -> string option) -> + assemblyVersion:AbstractIL.IL.ILVersionInfo -> + AbstractIL.IL.ILVersionInfo + val productVersion: + findStringAttr:(string -> string option) -> + fileVersion:AbstractIL.IL.ILVersionInfo -> string + val productVersionToILVersionInfo: string -> AbstractIL.IL.ILVersionInfo + val CreateMainModule: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * + tcImports:CompilerImports.TcImports * pdbfile:'t option * + assemblyName:string * outfile:string * + topAttrs:CheckDeclarations.TopAttribs * + sigDataAttributes:AbstractIL.IL.ILAttribute list * + sigDataResources:AbstractIL.IL.ILResource list * + optDataResources:AbstractIL.IL.ILResource list * + codegenResults:IlxGen.IlxGenResults * + assemVerFromAttrib:AbstractIL.IL.ILVersionInfo option * + metadataVersion:string * secDecls:AbstractIL.IL.ILSecurityDecls -> + AbstractIL.IL.ILModuleDef + + + +namespace FSharp.Compiler + module internal Driver = + [] + type ErrorLoggerUpToMaxErrors = + + inherit ErrorLogger.ErrorLogger + new: tcConfigB:CompilerConfig.TcConfigBuilder * + exiter:ErrorLogger.Exiter * nameForDebugging:string -> + ErrorLoggerUpToMaxErrors + override + DiagnosticSink: err:ErrorLogger.PhasedDiagnostic * isError:bool -> + unit + abstract member + HandleIssue: tcConfigB:CompilerConfig.TcConfigBuilder * + error:ErrorLogger.PhasedDiagnostic * isError:bool -> + unit + abstract member HandleTooManyErrors: text:string -> unit + override ErrorCount: int + + val ConsoleErrorLoggerUpToMaxErrors: + tcConfigB:CompilerConfig.TcConfigBuilder * exiter:ErrorLogger.Exiter -> + ErrorLogger.ErrorLogger + type DelayAndForwardErrorLogger = + + inherit ErrorLogger.CapturingErrorLogger + new: exiter:ErrorLogger.Exiter * + errorLoggerProvider:ErrorLoggerProvider -> + DelayAndForwardErrorLogger + member + ForwardDelayedDiagnostics: tcConfigB:CompilerConfig.TcConfigBuilder -> + unit + + [] + and ErrorLoggerProvider = + + new: unit -> ErrorLoggerProvider + member + CreateDelayAndForwardLogger: exiter:ErrorLogger.Exiter -> + DelayAndForwardErrorLogger + abstract member + CreateErrorLoggerUpToMaxErrors: tcConfigBuilder:CompilerConfig.TcConfigBuilder * + exiter:ErrorLogger.Exiter -> + ErrorLogger.ErrorLogger + + type InProcErrorLoggerProvider = + + new: unit -> InProcErrorLoggerProvider + member CapturedErrors: CompilerDiagnostics.Diagnostic [] + member CapturedWarnings: CompilerDiagnostics.Diagnostic [] + member Provider: ErrorLoggerProvider + + type ConsoleLoggerProvider = + + inherit ErrorLoggerProvider + new: unit -> ConsoleLoggerProvider + override + CreateErrorLoggerUpToMaxErrors: tcConfigBuilder:CompilerConfig.TcConfigBuilder * + exiter:ErrorLogger.Exiter -> + ErrorLogger.ErrorLogger + + val AbortOnError: + errorLogger:ErrorLogger.ErrorLogger * exiter:ErrorLogger.Exiter -> unit + val TypeCheck: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfig:CompilerConfig.TcConfig * tcImports:CompilerImports.TcImports * + tcGlobals:TcGlobals.TcGlobals * errorLogger:ErrorLogger.ErrorLogger * + assemblyName:string * niceNameGen:CompilerGlobalState.NiceNameGenerator * + tcEnv0:CheckExpressions.TcEnv * inputs:SyntaxTree.ParsedInput list * + exiter:ErrorLogger.Exiter -> + ParseAndCheckInputs.TcState * CheckDeclarations.TopAttribs * + TypedTree.TypedImplFile list * CheckExpressions.TcEnv + val AdjustForScriptCompile: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + tcConfigB:CompilerConfig.TcConfigBuilder * + commandLineSourceFiles:string list * + lexResourceManager:Lexhelp.LexResourceManager * + dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> + string list + val SetProcessThreadLocals: + tcConfigB:CompilerConfig.TcConfigBuilder -> unit + val ProcessCommandLineFlags: + tcConfigB:CompilerConfig.TcConfigBuilder * lcidFromCodePage:int option * + argv:string [] -> string list + val EncodeSignatureData: + tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * + exportRemapping:TypedTreeOps.Remap * generatedCcu:TypedTree.CcuThunk * + outfile:string * isIncrementalBuild:bool -> + AbstractIL.IL.ILAttribute list * AbstractIL.IL.ILResource list + val EncodeOptimizationData: + tcGlobals:TcGlobals.TcGlobals * tcConfig:CompilerConfig.TcConfig * + outfile:string * exportRemapping:TypedTreeOps.Remap * + data:(TypedTree.CcuThunk * #Optimizer.CcuOptimizationInfo) * + isIncrementalBuild:bool -> AbstractIL.IL.ILResource list + module InterfaceFileWriter = + val BuildInitialDisplayEnvForSigFileGeneration: + tcGlobals:TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv + val WriteInterfaceFile: + tcGlobals:TcGlobals.TcGlobals * tcConfig:CompilerConfig.TcConfig * + infoReader:InfoReader.InfoReader * + declaredImpls:seq -> unit + + val CopyFSharpCore: + outFile:string * referencedDlls:CompilerConfig.AssemblyReference list -> + unit + val TryFindVersionAttribute: + g:TcGlobals.TcGlobals -> + attrib:string -> + attribName:System.String -> + attribs:TypedTree.Attribs -> + deterministic:bool -> AbstractIL.IL.ILVersionInfo option + [] + type Args<'T> = | Args of 'T + val main1: + ctok:'a * argv:string [] * + legacyReferenceResolver:ReferenceResolver.Resolver * + bannerAlreadyPrinted:bool * + reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * + defaultCopyFSharpCore:CompilerConfig.CopyFSharpCoreFlag * + exiter:ErrorLogger.Exiter * errorLoggerProvider:ErrorLoggerProvider * + disposables:Lib.DisposablesTracker -> + Args<'a * TcGlobals.TcGlobals * CompilerImports.TcImports * + CompilerImports.TcImports * TypedTree.CcuThunk * + TypedTree.TypedImplFile list * CheckDeclarations.TopAttribs * + CompilerConfig.TcConfig * string * string option * string * + ErrorLogger.ErrorLogger * ErrorLogger.Exiter> + when 'a:> AbstractIL.Internal.Library.CompilationThreadToken + val main1OfAst: + ctok:'a * legacyReferenceResolver:ReferenceResolver.Resolver * + reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * + assemblyName:string * target:CompilerConfig.CompilerTarget * outfile:'b * + pdbFile:'c option * dllReferences:string list * noframework:bool * + exiter:ErrorLogger.Exiter * errorLoggerProvider:ErrorLoggerProvider * + disposables:Lib.DisposablesTracker * inputs:SyntaxTree.ParsedInput list -> + Args<'a * TcGlobals.TcGlobals * CompilerImports.TcImports * + CompilerImports.TcImports * TypedTree.CcuThunk * + TypedTree.TypedImplFile list * CheckDeclarations.TopAttribs * + CompilerConfig.TcConfig * 'b * 'c option * string * + ErrorLogger.ErrorLogger * ErrorLogger.Exiter> + when 'a:> AbstractIL.Internal.Library.CompilationThreadToken + val main2: + Args<'a * 'b * CompilerImports.TcImports * 'c * TypedTree.CcuThunk * 'd * + CheckDeclarations.TopAttribs * CompilerConfig.TcConfig * 'e * 'f * + string * #ErrorLogger.ErrorLogger * ErrorLogger.Exiter> -> + Args<'a * CompilerConfig.TcConfig * CompilerImports.TcImports * 'c * 'b * + ErrorLogger.ErrorLogger * TypedTree.CcuThunk * 'e * 'd * + CheckDeclarations.TopAttribs * 'f * string * + AbstractIL.IL.ILVersionInfo option * + CreateILModule.StrongNameSigningInfo * ErrorLogger.Exiter> + when 'b:> TcGlobals.TcGlobals and 'd:> seq + val main3: + Args<'a * CompilerConfig.TcConfig * CompilerImports.TcImports * + CompilerImports.TcImports * 'b * ErrorLogger.ErrorLogger * + TypedTree.CcuThunk * string * TypedTree.TypedImplFile list * 'c * 'd * + 'e * 'f * 'g * ErrorLogger.Exiter> -> + Args<'a * CompilerConfig.TcConfig * CompilerImports.TcImports * 'b * + ErrorLogger.ErrorLogger * TypedTree.CcuThunk * string * + TypedTree.TypedAssemblyAfterOptimization * 'c * 'd * 'e * + AbstractIL.IL.ILAttribute list * AbstractIL.IL.ILResource list * + AbstractIL.IL.ILResource list * 'f * 'g * string * + ErrorLogger.Exiter> when 'b:> TcGlobals.TcGlobals + val main4: + tcImportsCapture:(CompilerImports.TcImports -> unit) option * + dynamicAssemblyCreator:'a option -> + Args<'b * CompilerConfig.TcConfig * CompilerImports.TcImports * + TcGlobals.TcGlobals * 'c * TypedTree.CcuThunk * string * + TypedTree.TypedAssemblyAfterOptimization * + CheckDeclarations.TopAttribs * 'd option * string * + AbstractIL.IL.ILAttribute list * AbstractIL.IL.ILResource list * + AbstractIL.IL.ILResource list * AbstractIL.IL.ILVersionInfo option * + 'e * string * ErrorLogger.Exiter> -> + Args<'b * CompilerConfig.TcConfig * CompilerImports.TcImports * + TcGlobals.TcGlobals * 'c * + (AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILModuleDef) * string * + 'd option * AbstractIL.IL.ILModuleDef * 'e * ErrorLogger.Exiter> + when 'b:> AbstractIL.Internal.Library.CompilationThreadToken and + 'c:> ErrorLogger.ErrorLogger + val main5: + Args<'a * 'b * 'c * 'd * ErrorLogger.ErrorLogger * ('e -> 'f) * 'g * 'h * + 'e * 'i * ErrorLogger.Exiter> -> + Args<'a * 'b * 'c * 'd * ErrorLogger.ErrorLogger * 'f * 'g * 'h * 'i * + ErrorLogger.Exiter> + val main6: + dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * + AbstractIL.IL.ILModuleDef -> unit) option -> + Args<#AbstractIL.Internal.Library.CompilationThreadToken * + CompilerConfig.TcConfig * CompilerImports.TcImports * + TcGlobals.TcGlobals * ErrorLogger.ErrorLogger * + AbstractIL.IL.ILModuleDef * string * string option * + CreateILModule.StrongNameSigningInfo * ErrorLogger.Exiter> -> unit + val mainCompile: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * argv:string [] * + legacyReferenceResolver:ReferenceResolver.Resolver * + bannerAlreadyPrinted:bool * + reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * + defaultCopyFSharpCore:CompilerConfig.CopyFSharpCoreFlag * + exiter:ErrorLogger.Exiter * loggerProvider:ErrorLoggerProvider * + tcImportsCapture:(CompilerImports.TcImports -> unit) option * + dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * + AbstractIL.IL.ILModuleDef -> unit) option -> unit + val compileOfAst: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + legacyReferenceResolver:ReferenceResolver.Resolver * + reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * + assemblyName:string * target:CompilerConfig.CompilerTarget * + targetDll:string * targetPdb:string option * dependencies:string list * + noframework:bool * exiter:ErrorLogger.Exiter * + loggerProvider:ErrorLoggerProvider * inputs:SyntaxTree.ParsedInput list * + tcImportsCapture:(CompilerImports.TcImports -> unit) option * + dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * + AbstractIL.IL.ILModuleDef -> unit) option -> unit + + +namespace FSharp.Compiler.SourceCodeServices + module EnvMisc2 = + val maxMembers: int + + [] + type FSharpErrorSeverity = + | Warning + | Error + module FSharpErrorInfo = + [] + val ObsoleteMessage: string + = "Use FSharpErrorInfo.Range. This API will be removed in a future update." + + [] + type FSharpErrorInfo = + + new: m:Range.range * severity:FSharpErrorSeverity * message:string * + subcategory:string * errorNum:int -> FSharpErrorInfo + static member + CreateFromException: ErrorLogger.PhasedDiagnostic * isError:bool * + Range.range * suggestNames:bool -> FSharpErrorInfo + static member + CreateFromExceptionAndAdjustEof: ErrorLogger.PhasedDiagnostic * + isError:bool * Range.range * + lastPosInFile:(int * int) * + suggestNames:bool -> FSharpErrorInfo + override ToString: unit -> string + member WithEnd: newEnd:Range.pos -> FSharpErrorInfo + member WithStart: newStart:Range.pos -> FSharpErrorInfo + [] + member End: Range.pos + [] + member EndColumn: int + [] + member EndLine: Range.Line0 + [] + member EndLineAlternate: int + member ErrorNumber: int + [] + member FileName: string + member Message: string + member Range: Range.range + member Severity: FSharpErrorSeverity + [] + member Start: Range.pos + [] + member StartColumn: int + [] + member StartLine: Range.Line0 + [] + member StartLineAlternate: int + member Subcategory: string + + [] + type ErrorScope = + + interface System.IDisposable + new: unit -> ErrorScope + static member + Protect: Range.range -> (unit -> 'a) -> (string -> 'a) -> 'a + member TryGetFirstErrorText: unit -> string option + member Diagnostics: FSharpErrorInfo list + member Errors: FSharpErrorInfo list + member FirstError: string option + member Warnings: FSharpErrorInfo list + + type internal CompilationErrorLogger = + + inherit ErrorLogger.ErrorLogger + new: debugName:string * options:ErrorLogger.FSharpErrorSeverityOptions -> + CompilationErrorLogger + override + DiagnosticSink: exn:ErrorLogger.PhasedDiagnostic * isError:bool -> unit + member + GetErrors: unit -> + (ErrorLogger.PhasedDiagnostic * FSharpErrorSeverity) [] + override ErrorCount: int + + type CompilationGlobalsScope = + + interface System.IDisposable + new: ErrorLogger.ErrorLogger * ErrorLogger.BuildPhase -> + CompilationGlobalsScope + + module ErrorHelpers = + val ReportError: + ErrorLogger.FSharpErrorSeverityOptions * allErrors:bool * + mainInputFileName:string * fileInfo:(int * int) * + (ErrorLogger.PhasedDiagnostic * FSharpErrorSeverity) * suggestNames:bool -> + FSharpErrorInfo list + val CreateErrorInfos: + ErrorLogger.FSharpErrorSeverityOptions * allErrors:bool * + mainInputFileName:string * + seq * + suggestNames:bool -> FSharpErrorInfo [] + + type Layout = Internal.Utilities.StructuredFormat.Layout + [] + type FSharpXmlDoc = + | None + | Text of unprocessedLines: string [] * elaboratedXmlLines: string [] + | XmlDocFileSignature of string * string + [] + type FSharpToolTipElementData<'T> = + { MainDescription: 'T + XmlDoc: FSharpXmlDoc + TypeMapping: 'T list + Remarks: 'T option + ParamName: string option } + with + static member + Create: layout:'T * xml:FSharpXmlDoc * ?typeMapping:'T list * + ?paramName:string * ?remarks:'T -> FSharpToolTipElementData<'T> + + [] + type FSharpToolTipElement<'T> = + | None + | Group of FSharpToolTipElementData<'T> list + | CompositionError of string + with + static member + Single: 'T * FSharpXmlDoc * ?typeMapping:'T list * ?paramName:string * + ?remarks:'T -> FSharpToolTipElement<'T> + + type FSharpToolTipElement = FSharpToolTipElement + type FSharpStructuredToolTipElement = FSharpToolTipElement + type FSharpToolTipText<'T> = + | FSharpToolTipText of FSharpToolTipElement<'T> list + type FSharpToolTipText = FSharpToolTipText + type FSharpStructuredToolTipText = FSharpToolTipText + module Tooltips = + val ToFSharpToolTipElement: + FSharpToolTipElement -> FSharpToolTipElement + val ToFSharpToolTipText: + FSharpToolTipText -> FSharpToolTipText + + [] + type CompletionItemKind = + | Field + | Property + | Method of isExtension: bool + | Event + | Argument + | CustomOperation + | Other + type UnresolvedSymbol = + { FullName: string + DisplayName: string + Namespace: string [] } + type CompletionItem = + { ItemWithInst: NameResolution.ItemWithInst + Kind: CompletionItemKind + IsOwnMember: bool + MinorPriority: int + Type: TypedTree.TyconRef option + Unresolved: UnresolvedSymbol option } + with + member Item: NameResolution.Item + + module internal SymbolHelpers = + val OutputFullName: + isListItem:bool -> + ppF:('a -> 'b option) -> + fnF:('a -> Internal.Utilities.StructuredFormat.Layout) -> + r:'a -> Internal.Utilities.StructuredFormat.Layout + val rangeOfValRef: + preferFlag:bool option -> vref:TypedTree.ValRef -> Range.range + val rangeOfEntityRef: + preferFlag:bool option -> eref:TypedTree.EntityRef -> Range.range + val rangeOfPropInfo: + preferFlag:bool option -> pinfo:Infos.PropInfo -> Range.range option + val rangeOfMethInfo: + g:TcGlobals.TcGlobals -> + preferFlag:bool option -> minfo:Infos.MethInfo -> Range.range option + val rangeOfEventInfo: + preferFlag:bool option -> einfo:Infos.EventInfo -> Range.range option + val rangeOfUnionCaseInfo: + preferFlag:bool option -> ucinfo:Infos.UnionCaseInfo -> Range.range + val rangeOfRecdField: + preferFlag:bool option -> rField:TypedTree.RecdField -> Range.range + val rangeOfRecdFieldInfo: + preferFlag:bool option -> rfinfo:Infos.RecdFieldInfo -> Range.range + val rangeOfItem: + TcGlobals.TcGlobals -> + bool option -> NameResolution.Item -> Range.range option + val computeCcuOfTyconRef: + tcref:TypedTree.TyconRef -> TypedTree.CcuThunk option + val ccuOfMethInfo: + g:TcGlobals.TcGlobals -> minfo:Infos.MethInfo -> TypedTree.CcuThunk option + val ccuOfItem: + TcGlobals.TcGlobals -> NameResolution.Item -> TypedTree.CcuThunk option + val fileNameOfItem: + TcGlobals.TcGlobals -> + string option -> Range.range -> NameResolution.Item -> string + val cutFileName: s:string -> string + val libFileOfEntityRef: x:TypedTree.EntityRef -> string option + val ParamNameAndTypesOfUnaryCustomOperation: + TcGlobals.TcGlobals -> Infos.MethInfo -> Infos.ParamNameAndType list + val metaInfoOfEntityRef: + infoReader:InfoReader.InfoReader -> + m:Range.range -> + tcref:TypedTree.EntityRef -> + (string option * TypedTree.Typars * Infos.ILTypeInfo) option + val mkXmlComment: thing:(string option * string) option -> FSharpXmlDoc + val GetXmlDocSigOfEntityRef: + InfoReader.InfoReader -> + Range.range -> TypedTree.EntityRef -> (string option * string) option + val GetXmlDocSigOfScopedValRef: + TcGlobals.TcGlobals -> + TypedTree.TyconRef -> + TypedTree.ValRef -> (string option * string) option + val GetXmlDocSigOfRecdFieldInfo: + Infos.RecdFieldInfo -> (string option * string) option + val GetXmlDocSigOfUnionCaseInfo: + Infos.UnionCaseInfo -> (string option * string) option + val GetXmlDocSigOfMethInfo: + InfoReader.InfoReader -> + Range.range -> Infos.MethInfo -> (string option * string) option + val GetXmlDocSigOfValRef: + TcGlobals.TcGlobals -> TypedTree.ValRef -> (string option * string) option + val GetXmlDocSigOfProp: + InfoReader.InfoReader -> + Range.range -> Infos.PropInfo -> (string option * string) option + val GetXmlDocSigOfEvent: + InfoReader.InfoReader -> + Range.range -> Infos.EventInfo -> (string option * string) option + val GetXmlDocSigOfILFieldInfo: + InfoReader.InfoReader -> + Range.range -> Infos.ILFieldInfo -> (string option * string) option + val GetXmlDocHelpSigOfItemForLookup: + infoReader:InfoReader.InfoReader -> + m:Range.range -> d:NameResolution.Item -> FSharpXmlDoc + val GetXmlCommentForItemAux: + xmlDoc:XmlDoc.XmlDoc option -> + infoReader:InfoReader.InfoReader -> + m:Range.range -> d:NameResolution.Item -> FSharpXmlDoc + val mutable ToolTipFault: string option + val GetXmlCommentForMethInfoItem: + infoReader:InfoReader.InfoReader -> + m:Range.range -> + d:NameResolution.Item -> minfo:Infos.MethInfo -> FSharpXmlDoc + val FormatTyparMapping: + denv:TypedTreeOps.DisplayEnv -> + prettyTyparInst:TypedTreeOps.TyparInst -> + Internal.Utilities.StructuredFormat.Layout list + val FormatOverloadsToList: + infoReader:InfoReader.InfoReader -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + item:NameResolution.ItemWithInst -> + minfos:seq -> FSharpStructuredToolTipElement + val pubpathOfValRef: v:TypedTree.ValRef -> TypedTree.ValPublicPath option + val pubpathOfTyconRef: x:TypedTree.TyconRef -> TypedTree.PublicPath option + val ( |ItemWhereTypIsPreferred|_| ): + item:NameResolution.Item -> TypedTree.TType option + val ItemDisplayPartialEquality: + g:TcGlobals.TcGlobals -> + AbstractIL.Internal.Library.IPartialEqualityComparer + val CompletionItemDisplayPartialEquality: + g:TcGlobals.TcGlobals -> + AbstractIL.Internal.Library.IPartialEqualityComparer + val ItemWithTypeDisplayPartialEquality: + g:TcGlobals.TcGlobals -> + AbstractIL.Internal.Library.IPartialEqualityComparer + val RemoveDuplicateModuleRefs: + modrefs:TypedTree.ModuleOrNamespaceRef list -> + TypedTree.ModuleOrNamespaceRef list + val RemoveDuplicateItems: + TcGlobals.TcGlobals -> + NameResolution.ItemWithInst list -> NameResolution.ItemWithInst list + val RemoveDuplicateCompletionItems: + TcGlobals.TcGlobals -> CompletionItem list -> CompletionItem list + val IsExplicitlySuppressed: + TcGlobals.TcGlobals -> NameResolution.Item -> bool + val RemoveExplicitlySuppressed: + TcGlobals.TcGlobals -> + NameResolution.ItemWithInst list -> NameResolution.ItemWithInst list + val RemoveExplicitlySuppressedCompletionItems: + TcGlobals.TcGlobals -> CompletionItem list -> CompletionItem list + val SimplerDisplayEnv: TypedTreeOps.DisplayEnv -> TypedTreeOps.DisplayEnv + val FullNameOfItem: TcGlobals.TcGlobals -> NameResolution.Item -> string + val GetXmlCommentForItem: + InfoReader.InfoReader -> + Range.range -> NameResolution.Item -> FSharpXmlDoc + val IsAttribute: InfoReader.InfoReader -> NameResolution.Item -> bool + val FormatItemDescriptionToToolTipElement: + isListItem:bool -> + infoReader:InfoReader.InfoReader -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + item:NameResolution.ItemWithInst -> FSharpToolTipElement + val ( |ItemIsProvidedType|_| ): + TcGlobals.TcGlobals -> NameResolution.Item -> TypedTree.TyconRef option + val ( |ItemIsProvidedTypeWithStaticArguments|_| ): + Range.range -> + TcGlobals.TcGlobals -> + NameResolution.Item -> + Tainted [] option + val ( |ItemIsProvidedMethodWithStaticArguments|_| ): + item:NameResolution.Item -> + Tainted [] option + val ( |ItemIsWithStaticArguments|_| ): + Range.range -> + TcGlobals.TcGlobals -> + NameResolution.Item -> + Tainted [] option + val GetF1Keyword: + TcGlobals.TcGlobals -> NameResolution.Item -> string option + val FormatStructuredDescriptionOfItem: + isDecl:bool -> + InfoReader.InfoReader -> + Range.range -> + TypedTreeOps.DisplayEnv -> + NameResolution.ItemWithInst -> FSharpToolTipElement + val FlattenItems: + TcGlobals.TcGlobals -> + Range.range -> NameResolution.Item -> NameResolution.Item list + + +namespace FSharp.Compiler.SourceCodeServices + type FSharpAccessibility = + + new: TypedTree.Accessibility * ?isProtected:bool -> FSharpAccessibility + override ToString: unit -> string + member internal Contents: TypedTree.Accessibility + member IsInternal: bool + member IsPrivate: bool + member IsProtected: bool + member IsPublic: bool + + and SymbolEnv = + + new: TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + thisCcuTyp:TypedTree.ModuleOrNamespaceType option * + tcImports:CompilerImports.TcImports -> SymbolEnv + new: TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + thisCcuTyp:TypedTree.ModuleOrNamespaceType option * + tcImports:CompilerImports.TcImports * amap:Import.ImportMap * + infoReader:InfoReader.InfoReader -> SymbolEnv + member amap: Import.ImportMap + member g: TcGlobals.TcGlobals + member infoReader: InfoReader.InfoReader + member tcImports: CompilerImports.TcImports + member + tcValF: (TypedTree.ValRef -> TypedTree.ValUseFlag -> + TypedTree.TTypes -> Range.range -> + TypedTree.Expr * TypedTree.TType) + member thisCcu: TypedTree.CcuThunk + member thisCcuTy: TypedTree.ModuleOrNamespaceType option + + and FSharpDisplayContext = + + new: denv:(TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv) -> + FSharpDisplayContext + member Contents: g:TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv + member WithShortTypeNames: bool -> FSharpDisplayContext + static member Empty: FSharpDisplayContext + + [] + and FSharpSymbol = + + new: cenv:SymbolEnv * item:(unit -> NameResolution.Item) * + access:(FSharpSymbol -> TypedTree.CcuThunk -> + AccessibilityLogic.AccessorDomain -> bool) -> FSharpSymbol + static member + Create: cenv:SymbolEnv * item:NameResolution.Item -> FSharpSymbol + static member + Create: g:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + thisCcuTyp:TypedTree.ModuleOrNamespaceType * + tcImports:CompilerImports.TcImports * item:NameResolution.Item -> + FSharpSymbol + static member + GetAccessibility: FSharpSymbol -> FSharpAccessibility option + override Equals: other:obj -> bool + member GetEffectivelySameAsHash: unit -> int + override GetHashCode: unit -> int + member IsAccessible: FSharpAccessibilityRights -> bool + member IsEffectivelySameAs: other:FSharpSymbol -> bool + override ToString: unit -> string + member Assembly: FSharpAssembly + member DeclarationLocation: Range.range option + member DisplayName: string + member FullName: string + member ImplementationLocation: Range.range option + member IsExplicitlySuppressed: bool + member internal Item: NameResolution.Item + member SignatureLocation: Range.range option + + and FSharpEntity = + + inherit FSharpSymbol + new: SymbolEnv * TypedTree.EntityRef -> FSharpEntity + override Equals: other:obj -> bool + override GetHashCode: unit -> int + override ToString: unit -> string + member AbbreviatedType: FSharpType + member AccessPath: string + member Accessibility: FSharpAccessibility + member ActivePatternCases: FSharpActivePatternCase list + member AllCompilationPaths: string list + member AllInterfaces: System.Collections.Generic.IList + member ArrayRank: int + member Attributes: System.Collections.Generic.IList + member BaseType: FSharpType option + member CompiledName: string + member DeclarationLocation: Range.range + member DeclaredInterfaces: System.Collections.Generic.IList + member DeclaringEntity: FSharpEntity option + member DisplayName: string + member ElaboratedXmlDoc: System.Collections.Generic.IList + member Entity: TypedTree.EntityRef + member FSharpDelegateSignature: FSharpDelegateSignature + member FSharpFields: System.Collections.Generic.IList + member FullName: string + member + GenericParameters: System.Collections.Generic.IList + member HasAssemblyCodeRepresentation: bool + member HasFSharpModuleSuffix: bool + member IsAbstractClass: bool + member IsArrayType: bool + member IsAttributeType: bool + member IsByRef: bool + member IsClass: bool + member IsDelegate: bool + member IsDisposableType: bool + member IsEnum: bool + member IsFSharp: bool + member IsFSharpAbbreviation: bool + member IsFSharpExceptionDeclaration: bool + member IsFSharpModule: bool + member IsFSharpRecord: bool + member IsFSharpUnion: bool + member IsInterface: bool + member IsMeasure: bool + member IsNamespace: bool + member IsOpaque: bool + member IsProvided: bool + member IsProvidedAndErased: bool + member IsProvidedAndGenerated: bool + member IsStaticInstantiation: bool + member IsUnresolved: bool + member IsValueType: bool + member LogicalName: string + member + MembersFunctionsAndValues: System.Collections.Generic.IList + [] + member + MembersOrValues: System.Collections.Generic.IList + member Namespace: string option + member NestedEntities: System.Collections.Generic.IList + member QualifiedName: string + [] + member RecordFields: System.Collections.Generic.IList + member RepresentationAccessibility: FSharpAccessibility + member + StaticParameters: System.Collections.Generic.IList + member TryFullName: string option + member UnionCases: System.Collections.Generic.IList + member UsesPrefixDisplay: bool + member XmlDoc: System.Collections.Generic.IList + member XmlDocSig: string + + [] + and FSharpUnionCase = + + inherit FSharpSymbol + new: SymbolEnv * TypedTree.UnionCaseRef -> FSharpUnionCase + override Equals: other:obj -> bool + override GetHashCode: unit -> int + override ToString: unit -> string + member Accessibility: FSharpAccessibility + member Attributes: System.Collections.Generic.IList + member CompiledName: string + member DeclarationLocation: Range.range + member ElaboratedXmlDoc: System.Collections.Generic.IList + member HasFields: bool + member IsUnresolved: bool + member Name: string + member ReturnType: FSharpType + member UnionCaseFields: System.Collections.Generic.IList + member private V: TypedTree.UnionCaseRef + member XmlDoc: System.Collections.Generic.IList + member XmlDocSig: string + + and FSharpFieldData = + | AnonField of + TypedTree.AnonRecdTypeInfo * TypedTree.TTypes * int * Range.range + | ILField of Infos.ILFieldInfo + | RecdOrClass of TypedTree.RecdFieldRef + | Union of TypedTree.UnionCaseRef * int + with + member TryDeclaringTyconRef: TypedTree.TyconRef option + member + TryRecdField: Choice + + [] + and FSharpAnonRecordTypeDetails = + + new: cenv:SymbolEnv * anonInfo:TypedTree.AnonRecdTypeInfo -> + FSharpAnonRecordTypeDetails + member Assembly: FSharpAssembly + member CompiledName: string + member EnclosingCompiledTypeNames: string list + member SortedFieldNames: string [] + + [] + and FSharpField = + + inherit FSharpSymbol + new: SymbolEnv * TypedTree.RecdFieldRef -> FSharpField + new: SymbolEnv * TypedTree.UnionCaseRef * int -> FSharpField + new: cenv:SymbolEnv * d:FSharpFieldData -> FSharpField + override Equals: other:obj -> bool + override GetHashCode: unit -> int + override ToString: unit -> string + member Accessibility: FSharpAccessibility + member + AnonRecordFieldDetails: FSharpAnonRecordTypeDetails * FSharpType [] * + int + member DeclarationLocation: Range.range + member DeclaringEntity: FSharpEntity option + member DeclaringUnionCase: FSharpUnionCase option + member ElaboratedXmlDoc: System.Collections.Generic.IList + member FieldAttributes: System.Collections.Generic.IList + member FieldType: FSharpType + member IsAnonRecordField: bool + member IsCompilerGenerated: bool + member IsDefaultValue: bool + member IsLiteral: bool + member IsMutable: bool + member IsNameGenerated: bool + member IsStatic: bool + member IsUnionCaseField: bool + member IsUnresolved: bool + member IsVolatile: bool + member LiteralValue: obj option + member Name: string + member + PropertyAttributes: System.Collections.Generic.IList + member private V: FSharpFieldData + member XmlDoc: System.Collections.Generic.IList + member XmlDocSig: string + + [] + and FSharpRecordField = FSharpField + [] + and FSharpAccessibilityRights = + + new: TypedTree.CcuThunk * AccessibilityLogic.AccessorDomain -> + FSharpAccessibilityRights + member internal Contents: AccessibilityLogic.AccessorDomain + member internal ThisCcu: TypedTree.CcuThunk + + [] + and FSharpActivePatternCase = + + inherit FSharpSymbol + new: cenv:SymbolEnv * apinfo:PrettyNaming.ActivePatternInfo * + ty:TypedTree.TType * n:int * valOpt:TypedTree.ValRef option * + item:NameResolution.Item -> FSharpActivePatternCase + member DeclarationLocation: Range.range + member ElaboratedXmlDoc: System.Collections.Generic.IList + member Group: FSharpActivePatternGroup + member Index: int + member Name: string + member XmlDoc: System.Collections.Generic.IList + member XmlDocSig: string + + [] + and FSharpActivePatternGroup = + + new: cenv:SymbolEnv * apinfo:PrettyNaming.ActivePatternInfo * + ty:TypedTree.TType * valOpt:TypedTree.ValRef option -> + FSharpActivePatternGroup + member DeclaringEntity: FSharpEntity option + member IsTotal: bool + member Name: string option + member Names: System.Collections.Generic.IList + member OverallType: FSharpType + + [] + and FSharpGenericParameter = + + inherit FSharpSymbol + new: SymbolEnv * TypedTree.Typar -> FSharpGenericParameter + override Equals: other:obj -> bool + override GetHashCode: unit -> int + override ToString: unit -> string + member Attributes: System.Collections.Generic.IList + member + Constraints: System.Collections.Generic.IList + member DeclarationLocation: Range.range + member ElaboratedXmlDoc: System.Collections.Generic.IList + member IsCompilerGenerated: bool + member IsMeasure: bool + member IsSolveAtCompileTime: bool + member Name: string + member internal V: TypedTree.Typar + member XmlDoc: System.Collections.Generic.IList + + [] + and FSharpDelegateSignature = + + new: cenv:SymbolEnv * info:TypedTree.SlotSig -> FSharpDelegateSignature + override ToString: unit -> string + member + DelegateArguments: System.Collections.Generic.IList + member DelegateReturnType: FSharpType + + [] + and FSharpAbstractParameter = + + new: cenv:SymbolEnv * info:TypedTree.SlotParam -> FSharpAbstractParameter + member Attributes: System.Collections.Generic.IList + member IsInArg: bool + member IsOptionalArg: bool + member IsOutArg: bool + member Name: string option + member Type: FSharpType + + [] + and FSharpAbstractSignature = + + new: SymbolEnv * TypedTree.SlotSig -> FSharpAbstractSignature + member + AbstractArguments: System.Collections.Generic.IList> + member AbstractReturnType: FSharpType + member DeclaringType: FSharpType + member + DeclaringTypeGenericParameters: System.Collections.Generic.IList + member + MethodGenericParameters: System.Collections.Generic.IList + member Name: string + + [] + and FSharpGenericParameterMemberConstraint = + + new: cenv:SymbolEnv * info:TypedTree.TraitConstraintInfo -> + FSharpGenericParameterMemberConstraint + override ToString: unit -> string + member MemberArgumentTypes: System.Collections.Generic.IList + member MemberIsStatic: bool + member MemberName: string + member MemberReturnType: FSharpType + member MemberSources: System.Collections.Generic.IList + + [] + and FSharpGenericParameterDelegateConstraint = + + new: cenv:SymbolEnv * tupledArgTy:TypedTree.TType * rty:TypedTree.TType -> + FSharpGenericParameterDelegateConstraint + override ToString: unit -> string + member DelegateReturnType: FSharpType + member DelegateTupledArgumentType: FSharpType + + [] + and FSharpGenericParameterDefaultsToConstraint = + + new: cenv:SymbolEnv * pri:int * ty:TypedTree.TType -> + FSharpGenericParameterDefaultsToConstraint + override ToString: unit -> string + member DefaultsToPriority: int + member DefaultsToTarget: FSharpType + + [] + and FSharpGenericParameterConstraint = + + new: cenv:SymbolEnv * cx:TypedTree.TyparConstraint -> + FSharpGenericParameterConstraint + override ToString: unit -> string + member CoercesToTarget: FSharpType + member + DefaultsToConstraintData: FSharpGenericParameterDefaultsToConstraint + member DelegateConstraintData: FSharpGenericParameterDelegateConstraint + member EnumConstraintTarget: FSharpType + member IsCoercesToConstraint: bool + member IsComparisonConstraint: bool + member IsDefaultsToConstraint: bool + member IsDelegateConstraint: bool + member IsEnumConstraint: bool + member IsEqualityConstraint: bool + member IsMemberConstraint: bool + member IsNonNullableValueTypeConstraint: bool + member IsReferenceTypeConstraint: bool + member IsRequiresDefaultConstructorConstraint: bool + member IsSimpleChoiceConstraint: bool + member IsSupportsNullConstraint: bool + member IsUnmanagedConstraint: bool + member MemberConstraintData: FSharpGenericParameterMemberConstraint + member SimpleChoices: System.Collections.Generic.IList + + [] + and FSharpInlineAnnotation = + | PseudoValue + | AlwaysInline + | OptionalInline + | NeverInline + | AggressiveInline + and FSharpMemberOrValData = + | E of Infos.EventInfo + | P of Infos.PropInfo + | M of Infos.MethInfo + | C of Infos.MethInfo + | V of TypedTree.ValRef + and FSharpMemberOrVal = FSharpMemberOrFunctionOrValue + and FSharpMemberFunctionOrValue = FSharpMemberOrFunctionOrValue + [] + and FSharpMemberOrFunctionOrValue = + + inherit FSharpSymbol + new: SymbolEnv * Infos.MethInfo -> FSharpMemberOrFunctionOrValue + new: SymbolEnv * TypedTree.ValRef -> FSharpMemberOrFunctionOrValue + new: cenv:SymbolEnv * d:FSharpMemberOrValData * item:NameResolution.Item -> + FSharpMemberOrFunctionOrValue + override Equals: other:obj -> bool + member + FormatLayout: context:FSharpDisplayContext -> + Internal.Utilities.StructuredFormat.Layout + override GetHashCode: unit -> int + member + GetWitnessPassingInfo: unit -> + (string * + System.Collections.Generic.IList) option + member + Overloads: bool -> + System.Collections.Generic.IList option + override ToString: unit -> string + member Accessibility: FSharpAccessibility + member ApparentEnclosingEntity: FSharpEntity + member Attributes: System.Collections.Generic.IList + member CompiledName: string + member + CurriedParameterGroups: System.Collections.Generic.IList> + member Data: FSharpMemberOrValData + member DeclarationLocation: Range.range + member DeclarationLocationOpt: Range.range option + member DeclaringEntity: FSharpEntity option + member DisplayName: string + member ElaboratedXmlDoc: System.Collections.Generic.IList + member EventAddMethod: FSharpMemberOrFunctionOrValue + member EventDelegateType: FSharpType + member EventForFSharpProperty: FSharpMemberOrFunctionOrValue option + member EventIsStandard: bool + member EventRemoveMethod: FSharpMemberOrFunctionOrValue + member FullType: FSharpType + member + GenericParameters: System.Collections.Generic.IList + member GetterMethod: FSharpMemberOrFunctionOrValue + member HasGetterMethod: bool + member HasSetterMethod: bool + member + ImplementedAbstractSignatures: System.Collections.Generic.IList + member InlineAnnotation: FSharpInlineAnnotation + member IsActivePattern: bool + member IsBaseValue: bool + member IsCompilerGenerated: bool + member IsConstructor: bool + member IsConstructorThisValue: bool + member IsDispatchSlot: bool + member IsEvent: bool + member IsEventAddMethod: bool + member IsEventRemoveMethod: bool + member IsExplicitInterfaceImplementation: bool + member IsExtensionMember: bool + [] + member IsGetterMethod: bool + member IsImplicitConstructor: bool + member IsInstanceMember: bool + member IsInstanceMemberInCompiledCode: bool + member IsMember: bool + member IsMemberThisValue: bool + member IsModuleValueOrMember: bool + member IsMutable: bool + member IsOverrideOrExplicitInterfaceImplementation: bool + [] + member IsOverrideOrExplicitMember: bool + member IsProperty: bool + member IsPropertyGetterMethod: bool + member IsPropertySetterMethod: bool + [] + member IsSetterMethod: bool + member IsTypeFunction: bool + member IsUnresolved: bool + member IsValCompiledAsMethod: bool + member IsValue: bool + member LiteralValue: obj option + member LogicalName: string + member ReturnParameter: FSharpParameter + member SetterMethod: FSharpMemberOrFunctionOrValue + member XmlDoc: System.Collections.Generic.IList + member XmlDocSig: string + + [] + and FSharpType = + + new: g:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + thisCcuTyp:TypedTree.ModuleOrNamespaceType * + tcImports:CompilerImports.TcImports * ty:TypedTree.TType -> + FSharpType + new: SymbolEnv * ty:TypedTree.TType -> FSharpType + static member + Prettify: parameters:System.Collections.Generic.IList> -> + System.Collections.Generic.IList> + static member + Prettify: parameters:System.Collections.Generic.IList -> + System.Collections.Generic.IList + static member Prettify: parameter:FSharpParameter -> FSharpParameter + static member + Prettify: types:System.Collections.Generic.IList -> + System.Collections.Generic.IList + static member Prettify: ty:FSharpType -> FSharpType + static member + Prettify: parameters:System.Collections.Generic.IList> * + returnParameter:FSharpParameter -> + System.Collections.Generic.IList> * + FSharpParameter + member private AdjustType: t:TypedTree.TType -> FSharpType + override Equals: other:obj -> bool + member Format: context:FSharpDisplayContext -> string + member + FormatLayout: context:FSharpDisplayContext -> + Internal.Utilities.StructuredFormat.Layout + override GetHashCode: unit -> int + member + Instantiate: (FSharpGenericParameter * FSharpType) list -> FSharpType + override ToString: unit -> string + member AbbreviatedType: FSharpType + member AllInterfaces: System.Collections.Generic.IList + member AnonRecordTypeDetails: FSharpAnonRecordTypeDetails + member BaseType: FSharpType option + member GenericArguments: System.Collections.Generic.IList + member GenericParameter: FSharpGenericParameter + member HasTypeDefinition: bool + member IsAbbreviation: bool + member IsAnonRecordType: bool + member IsFunctionType: bool + member IsGenericParameter: bool + [] + member IsNamedType: bool + member IsStructTupleType: bool + member IsTupleType: bool + member IsUnresolved: bool + [] + member NamedEntity: FSharpEntity + member TypeDefinition: FSharpEntity + member private V: TypedTree.TType + member private cenv: SymbolEnv + + [] + and FSharpAttribute = + + new: cenv:SymbolEnv * attrib:AttributeChecking.AttribInfo -> + FSharpAttribute + member Format: context:FSharpDisplayContext -> string + override ToString: unit -> string + member AttributeType: FSharpEntity + member + ConstructorArguments: System.Collections.Generic.IList + member IsUnresolved: bool + member + NamedArguments: System.Collections.Generic.IList + member Range: Range.range + + [] + and FSharpStaticParameter = + + inherit FSharpSymbol + new: cenv:SymbolEnv * sp:Tainted * + m:Range.range -> FSharpStaticParameter + override Equals: other:obj -> bool + override GetHashCode: unit -> int + override ToString: unit -> string + member DeclarationLocation: Range.range + member DefaultValue: obj + [] + member HasDefaultValue: bool + member IsOptional: bool + member Kind: FSharpType + member Name: string + member Range: Range.range + + [] + and FSharpParameter = + + inherit FSharpSymbol + new: cenv:SymbolEnv * ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo * + ownerRangeOpt:Range.range option -> FSharpParameter + new: cenv:SymbolEnv * id:SyntaxTree.Ident * ty:TypedTree.TType * + container:NameResolution.ArgumentContainer option -> FSharpParameter + new: cenv:SymbolEnv * paramTy:TypedTree.TType * + topArgInfo:TypedTree.ArgReprInfo * + ownerOpt:NameResolution.ArgumentContainer option * + ownerRangeOpt:Range.range option * isParamArrayArg:bool * + isInArg:bool * isOutArg:bool * isOptionalArg:bool * + isWitnessArg:bool -> FSharpParameter + member AdjustType: ty:TypedTree.TType -> FSharpParameter + override Equals: other:obj -> bool + override GetHashCode: unit -> int + override ToString: unit -> string + member Attributes: System.Collections.Generic.IList + member DeclarationLocation: Range.range + member IsInArg: bool + member IsOptionalArg: bool + member IsOutArg: bool + member IsParamArrayArg: bool + member IsWitnessArg: bool + member Name: string option + member Owner: FSharpSymbol option + member Type: FSharpType + member V: TypedTree.TType + member private ValReprInfo: TypedTree.ArgReprInfo + member cenv: SymbolEnv + + and FSharpAssemblySignature = + + new: tcGlobals:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + thisCcuTyp:TypedTree.ModuleOrNamespaceType * + tcImports:CompilerImports.TcImports * + topAttribs:CheckDeclarations.TopAttribs option * + contents:TypedTree.ModuleOrNamespaceType -> FSharpAssemblySignature + new: cenv:SymbolEnv * ccu:TypedTree.CcuThunk -> FSharpAssemblySignature + new: cenv:SymbolEnv * topAttribs:CheckDeclarations.TopAttribs option * + optViewedCcu:TypedTree.CcuThunk option * + mtyp:TypedTree.ModuleOrNamespaceType -> FSharpAssemblySignature + member FindEntityByPath: string list -> FSharpEntity option + override ToString: unit -> string + member Attributes: System.Collections.Generic.IList + member Entities: System.Collections.Generic.IList + + and FSharpAssembly = + + new: tcGlobals:TcGlobals.TcGlobals * tcImports:CompilerImports.TcImports * + ccu:TypedTree.CcuThunk -> FSharpAssembly + internal new: cenv:SymbolEnv * ccu:TypedTree.CcuThunk -> FSharpAssembly + override ToString: unit -> string + [] + member CodeLocation: string + member Contents: FSharpAssemblySignature + member FileName: string option + member IsProviderGenerated: bool + member QualifiedName: string + member RawCcuThunk: TypedTree.CcuThunk + member SimpleName: string + + [] + and FSharpOpenDeclaration = + + new: target:SyntaxTree.SynOpenDeclTarget * range:Range.range option * + modules:FSharpEntity list * types:FSharpType list * + appliedScope:Range.range * isOwnNamespace:bool -> + FSharpOpenDeclaration + member AppliedScope: Range.range + member IsOwnNamespace: bool + member LongId: SyntaxTree.LongIdent + member Modules: FSharpEntity list + member Range: Range.range option + member Target: SyntaxTree.SynOpenDeclTarget + member Types: FSharpType list + + [] + and FSharpSymbolUse = + + new: g:TcGlobals.TcGlobals * denv:TypedTreeOps.DisplayEnv * + symbol:FSharpSymbol * itemOcc:NameResolution.ItemOccurence * + range:Range.range -> FSharpSymbolUse + override ToString: unit -> string + member DisplayContext: FSharpDisplayContext + member FileName: string + member IsDefinition: bool + member IsFromAttribute: bool + member IsFromComputationExpression: bool + member IsFromDefinition: bool + member IsFromDispatchSlotImplementation: bool + member IsFromOpenStatement: bool + member IsFromPattern: bool + member IsFromType: bool + member IsPrivateToFile: bool + member Range: Range.Range01 + member RangeAlternate: Range.range + member Symbol: FSharpSymbol + + module Impl = + val protect: f:(unit -> 'a) -> 'a + val makeReadOnlyCollection: + arr:seq<'T> -> System.Collections.Generic.IList<'T> + val makeXmlDoc: + doc:XmlDoc.XmlDoc -> System.Collections.Generic.IList + val makeElaboratedXmlDoc: + doc:XmlDoc.XmlDoc -> System.Collections.Generic.IList + val rescopeEntity: + optViewedCcu:TypedTree.CcuThunk option -> + entity:TypedTree.Entity -> TypedTree.EntityRef + val entityIsUnresolved: entity:TypedTree.EntityRef -> bool + val checkEntityIsResolved: entity:TypedTree.EntityRef -> unit + val checkForCrossProjectAccessibility: + ilg:AbstractIL.IL.ILGlobals -> + thisCcu2:TypedTree.CcuThunk * ad2:AccessibilityLogic.AccessorDomain -> + thisCcu1:TypedTree.CcuThunk * taccess1:TypedTree.Accessibility -> bool + val getApproxFSharpAccessibilityOfMember: + declaringEntity:TypedTree.EntityRef -> + ilAccess:AbstractIL.IL.ILMemberAccess -> TypedTree.Accessibility + val getApproxFSharpAccessibilityOfEntity: + entity:TypedTree.EntityRef -> TypedTree.Accessibility + val getLiteralValue: _arg6:TypedTree.Const option -> obj option + val getXmlDocSigForEntity: + cenv:SymbolEnv -> ent:TypedTree.EntityRef -> string + + +namespace FSharp.Compiler.SourceCodeServices + module ExprTranslationImpl = + val nonNil: x:'a list -> bool + type ExprTranslationEnv = + { vs: TypedTreeOps.ValMap + tyvs: TypedTree.StampMap + isinstVals: TypedTreeOps.ValMap + substVals: TypedTreeOps.ValMap + suppressWitnesses: bool + witnessesInScope: TypedTreeOps.TraitWitnessInfoHashMap } + with + static member Empty: g:TcGlobals.TcGlobals -> ExprTranslationEnv + member + BindCurriedVals: vsl:TypedTree.Val list list -> ExprTranslationEnv + member + BindIsInstVal: v:TypedTree.Val -> + ty:TypedTree.TType * e:TypedTree.Expr -> + ExprTranslationEnv + member + BindSubstVal: v:TypedTree.Val -> + e:TypedTree.Expr -> ExprTranslationEnv + member + BindTypar: v:TypedTree.Typar * gp:FSharpGenericParameter -> + ExprTranslationEnv + member + BindTypars: vs:(TypedTree.Typar * #FSharpGenericParameter) list -> + ExprTranslationEnv + member BindVal: v:TypedTree.Val -> ExprTranslationEnv + member BindVals: vs:TypedTree.Val list -> ExprTranslationEnv + + exception IgnoringPartOfQuotedTermWarning of string * Range.range + val wfail: msg:string * m:Range.range -> 'a + + type E = + | Value of FSharpMemberOrFunctionOrValue + | ThisValue of FSharpType + | BaseValue of FSharpType + | Application of FSharpExpr * FSharpType list * FSharpExpr list + | Lambda of FSharpMemberOrFunctionOrValue * FSharpExpr + | TypeLambda of FSharpGenericParameter list * FSharpExpr + | Quote of FSharpExpr + | IfThenElse of FSharpExpr * FSharpExpr * FSharpExpr + | DecisionTree of + FSharpExpr * (FSharpMemberOrFunctionOrValue list * FSharpExpr) list + | DecisionTreeSuccess of int * FSharpExpr list + | Call of + FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * + FSharpType list * FSharpExpr list * FSharpExpr list + | NewObject of + FSharpMemberOrFunctionOrValue * FSharpType list * FSharpExpr list + | LetRec of (FSharpMemberOrFunctionOrValue * FSharpExpr) list * FSharpExpr + | Let of (FSharpMemberOrFunctionOrValue * FSharpExpr) * FSharpExpr + | NewRecord of FSharpType * FSharpExpr list + | ObjectExpr of + FSharpType * FSharpExpr * FSharpObjectExprOverride list * + (FSharpType * FSharpObjectExprOverride list) list + | FSharpFieldGet of FSharpExpr option * FSharpType * FSharpField + | FSharpFieldSet of + FSharpExpr option * FSharpType * FSharpField * FSharpExpr + | NewUnionCase of FSharpType * FSharpUnionCase * FSharpExpr list + | NewAnonRecord of FSharpType * FSharpExpr list + | AnonRecordGet of FSharpExpr * FSharpType * int + | UnionCaseGet of FSharpExpr * FSharpType * FSharpUnionCase * FSharpField + | UnionCaseSet of + FSharpExpr * FSharpType * FSharpUnionCase * FSharpField * FSharpExpr + | UnionCaseTag of FSharpExpr * FSharpType + | UnionCaseTest of FSharpExpr * FSharpType * FSharpUnionCase + | TraitCall of + FSharpType list * string * SyntaxTree.MemberFlags * FSharpType list * + FSharpType list * FSharpExpr list + | NewTuple of FSharpType * FSharpExpr list + | TupleGet of FSharpType * int * FSharpExpr + | Coerce of FSharpType * FSharpExpr + | NewArray of FSharpType * FSharpExpr list + | TypeTest of FSharpType * FSharpExpr + | AddressSet of FSharpExpr * FSharpExpr + | ValueSet of FSharpMemberOrFunctionOrValue * FSharpExpr + | Unused + | DefaultValue of FSharpType + | Const of obj * FSharpType + | AddressOf of FSharpExpr + | Sequential of FSharpExpr * FSharpExpr + | FastIntegerForLoop of FSharpExpr * FSharpExpr * FSharpExpr * bool + | WhileLoop of FSharpExpr * FSharpExpr + | TryFinally of FSharpExpr * FSharpExpr + | TryWith of + FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr * + FSharpMemberOrFunctionOrValue * FSharpExpr + | NewDelegate of FSharpType * FSharpExpr + | ILFieldGet of FSharpExpr option * FSharpType * string + | ILFieldSet of FSharpExpr option * FSharpType * string * FSharpExpr + | ILAsm of string * FSharpType list * FSharpExpr list + | WitnessArg of int + [] + and FSharpObjectExprOverride = + + new: sgn:FSharpAbstractSignature * gps:FSharpGenericParameter list * + args:FSharpMemberOrFunctionOrValue list list * body:FSharpExpr -> + FSharpObjectExprOverride + member Body: FSharpExpr + member CurriedParameterGroups: FSharpMemberOrFunctionOrValue list list + member GenericParameters: FSharpGenericParameter list + member Signature: FSharpAbstractSignature + + [] + and FSharpExpr = + + new: cenv:SymbolEnv * f:(unit -> FSharpExpr) option * e:E * m:Range.range * + ty:TypedTree.TType -> FSharpExpr + override ToString: unit -> string + member E: E + member ImmediateSubExpressions: FSharpExpr list + member Range: Range.range + member Type: FSharpType + member cenv: SymbolEnv + + module FSharpExprConvert = + val IsStaticInitializationField: rfref:TypedTree.RecdFieldRef -> bool + val ( |StaticInitializationCheck|_| ): e:TypedTree.Expr -> unit option + val ( |StaticInitializationCount|_| ): e:TypedTree.Expr -> unit option + val ( |ILUnaryOp|_| ): + e:AbstractIL.IL.ILInstr -> + (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr) option + val ( |ILMulDivOp|_| ): + e:AbstractIL.IL.ILInstr -> + ((#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> + TypedTree.TType -> TypedTree.TType -> TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr) * bool) option + val ( |ILBinaryOp|_| ): + e:AbstractIL.IL.ILInstr -> + (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr) option + val ( |ILConvertOp|_| ): + e:AbstractIL.IL.ILInstr -> + (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr) option + val ( |TTypeConvOp|_| ): + cenv:SymbolEnv -> + ty:TypedTree.TType -> + (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr) option + val ConvType: cenv:SymbolEnv -> ty:TypedTree.TType -> FSharpType + val ConvTypes: + cenv:SymbolEnv -> tys:TypedTree.TType list -> FSharpType list + val ConvILTypeRefApp: + cenv:SymbolEnv -> + m:Range.range -> + tref:AbstractIL.IL.ILTypeRef -> + tyargs:TypedTree.TypeInst -> FSharpType + val ConvUnionCaseRef: + cenv:SymbolEnv -> ucref:TypedTree.UnionCaseRef -> FSharpUnionCase + val ConvRecdFieldRef: + cenv:SymbolEnv -> rfref:TypedTree.RecdFieldRef -> FSharpField + val exprOfExprAddr: cenv:SymbolEnv -> expr:TypedTree.Expr -> TypedTree.Expr + val Mk: + cenv:SymbolEnv -> m:Range.range -> ty:TypedTree.TType -> e:E -> FSharpExpr + val Mk2: cenv:SymbolEnv -> orig:TypedTree.Expr -> e:E -> FSharpExpr + val ConvLValueExpr: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + expr:TypedTree.Expr -> FSharpExpr + val ConvExpr: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + expr:TypedTree.Expr -> FSharpExpr + val ConvExprLinear: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + expr:TypedTree.Expr -> contF:(FSharpExpr -> E) -> E + val ConvExprPrimLinear: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + expr:TypedTree.Expr -> contF:(E -> E) -> E + val ConvModuleValueOrMemberUseLinear: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + expr:TypedTree.Expr * vref:TypedTree.ValRef * + vFlags:TypedTree.ValUseFlag * tyargs:TypedTree.TypeInst * + curriedArgs:TypedTree.Expr list -> contF:(E -> E) -> E + val GetWitnessArgs: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + vref:TypedTree.ValRef -> + m:Range.range -> + tps:TypedTree.Typars -> + tyargs:TypedTree.TypeInst -> FSharpExpr list + val ConvExprPrim: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> expr:TypedTree.Expr -> E + val ConvWitnessInfoPrim: + _cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + traitInfo:TypedTree.TraitConstraintInfo -> E + val ConvWitnessInfo: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + m:Range.range -> traitInfo:TypedTree.TraitConstraintInfo -> FSharpExpr + val ConvLetBind: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + bind:TypedTree.Binding -> + (FSharpMemberOrFunctionOrValue * FSharpExpr) option * + ExprTranslationImpl.ExprTranslationEnv + val ConvILCall: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + isNewObj:bool * valUseFlags:TypedTree.ValUseFlag * + ilMethRef:AbstractIL.IL.ILMethodRef * enclTypeArgs:TypedTree.TypeInst * + methTypeArgs:TypedTree.TypeInst * callArgs:TypedTree.Exprs * + m:Range.range -> E + val ConvObjectModelCallLinear: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + isNewObj:bool * v:FSharpMemberOrFunctionOrValue * + enclTyArgs:TypedTree.TType list * methTyArgs:TypedTree.TType list * + witnessArgsR:FSharpExpr list * callArgs:TypedTree.Expr list -> + contF:(E -> E) -> E + val ConvExprs: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + args:TypedTree.Exprs -> FSharpExpr list + val ConvExprsLinear: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + args:TypedTree.Expr list -> contF:(FSharpExpr list -> E) -> E + val ConvTargetsLinear: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + tgs:TypedTree.DecisionTreeTarget list -> + contF:((FSharpMemberOrFunctionOrValue list * FSharpExpr) list -> E) -> + E + val ConvValRef: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + m:Range.range -> vref:TypedTree.ValRef -> E + val ConvVal: + cenv:SymbolEnv -> v:TypedTree.Val -> FSharpMemberOrFunctionOrValue + val ConvConst: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + m:Range.range -> c:TypedTree.Const -> ty:TypedTree.TType -> E + val ConvDecisionTree: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + dtreeRetTy:TypedTree.TType -> + x:TypedTree.DecisionTree -> m:Range.range -> FSharpExpr + val ConvDecisionTreePrim: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + dtreeRetTy:TypedTree.TType -> x:TypedTree.DecisionTree -> E + val ConvExprOnDemand: + cenv:SymbolEnv -> + env:ExprTranslationImpl.ExprTranslationEnv -> + expr:TypedTree.Expr -> FSharpExpr + + type FSharpAssemblyContents = + + new: tcGlobals:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + thisCcuType:TypedTree.ModuleOrNamespaceType option * + tcImports:CompilerImports.TcImports * + mimpls:TypedTree.TypedImplFile list -> FSharpAssemblyContents + new: cenv:SymbolEnv * mimpls:TypedTree.TypedImplFile list -> + FSharpAssemblyContents + member ImplementationFiles: FSharpImplementationFileContents list + + and FSharpImplementationFileDeclaration = + | Entity of FSharpEntity * FSharpImplementationFileDeclaration list + | MemberOrFunctionOrValue of + FSharpMemberOrFunctionOrValue * FSharpMemberOrFunctionOrValue list list * + FSharpExpr + | InitAction of FSharpExpr + and FSharpImplementationFileContents = + + new: cenv:SymbolEnv * mimpl:TypedTree.TypedImplFile -> + FSharpImplementationFileContents + member Declarations: FSharpImplementationFileDeclaration list + member FileName: string + member HasExplicitEntryPoint: bool + member IsScript: bool + member QualifiedName: string + + module BasicPatterns = + val ( |Value|_| ): FSharpExpr -> FSharpMemberOrFunctionOrValue option + val ( |Const|_| ): FSharpExpr -> (obj * FSharpType) option + val ( |TypeLambda|_| ): + FSharpExpr -> (FSharpGenericParameter list * FSharpExpr) option + val ( |Lambda|_| ): + FSharpExpr -> (FSharpMemberOrFunctionOrValue * FSharpExpr) option + val ( |Application|_| ): + FSharpExpr -> (FSharpExpr * FSharpType list * FSharpExpr list) option + val ( |IfThenElse|_| ): + FSharpExpr -> (FSharpExpr * FSharpExpr * FSharpExpr) option + val ( |Let|_| ): + FSharpExpr -> + ((FSharpMemberOrFunctionOrValue * FSharpExpr) * FSharpExpr) option + val ( |LetRec|_| ): + FSharpExpr -> + ((FSharpMemberOrFunctionOrValue * FSharpExpr) list * FSharpExpr) option + val ( |NewRecord|_| ): FSharpExpr -> (FSharpType * FSharpExpr list) option + val ( |NewAnonRecord|_| ): + FSharpExpr -> (FSharpType * FSharpExpr list) option + val ( |NewUnionCase|_| ): + FSharpExpr -> (FSharpType * FSharpUnionCase * FSharpExpr list) option + val ( |NewTuple|_| ): FSharpExpr -> (FSharpType * FSharpExpr list) option + val ( |TupleGet|_| ): FSharpExpr -> (FSharpType * int * FSharpExpr) option + val ( |Call|_| ): + FSharpExpr -> + (FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * + FSharpType list * FSharpExpr list) option + val ( |CallWithWitnesses|_| ): + FSharpExpr -> + (FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * + FSharpType list * FSharpExpr list * FSharpExpr list) option + val ( |NewObject|_| ): + FSharpExpr -> + (FSharpMemberOrFunctionOrValue * FSharpType list * FSharpExpr list) option + val ( |FSharpFieldGet|_| ): + FSharpExpr -> (FSharpExpr option * FSharpType * FSharpField) option + val ( |AnonRecordGet|_| ): + FSharpExpr -> (FSharpExpr * FSharpType * int) option + val ( |FSharpFieldSet|_| ): + FSharpExpr -> + (FSharpExpr option * FSharpType * FSharpField * FSharpExpr) option + val ( |UnionCaseGet|_| ): + FSharpExpr -> + (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField) option + val ( |UnionCaseTag|_| ): FSharpExpr -> (FSharpExpr * FSharpType) option + val ( |UnionCaseTest|_| ): + FSharpExpr -> (FSharpExpr * FSharpType * FSharpUnionCase) option + val ( |NewArray|_| ): FSharpExpr -> (FSharpType * FSharpExpr list) option + val ( |Coerce|_| ): FSharpExpr -> (FSharpType * FSharpExpr) option + val ( |Quote|_| ): FSharpExpr -> FSharpExpr option + val ( |TypeTest|_| ): FSharpExpr -> (FSharpType * FSharpExpr) option + val ( |Sequential|_| ): FSharpExpr -> (FSharpExpr * FSharpExpr) option + val ( |FastIntegerForLoop|_| ): + FSharpExpr -> (FSharpExpr * FSharpExpr * FSharpExpr * bool) option + val ( |WhileLoop|_| ): FSharpExpr -> (FSharpExpr * FSharpExpr) option + val ( |TryFinally|_| ): FSharpExpr -> (FSharpExpr * FSharpExpr) option + val ( |TryWith|_| ): + FSharpExpr -> + (FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr * + FSharpMemberOrFunctionOrValue * FSharpExpr) option + val ( |NewDelegate|_| ): FSharpExpr -> (FSharpType * FSharpExpr) option + val ( |DefaultValue|_| ): FSharpExpr -> FSharpType option + val ( |AddressSet|_| ): FSharpExpr -> (FSharpExpr * FSharpExpr) option + val ( |ValueSet|_| ): + FSharpExpr -> (FSharpMemberOrFunctionOrValue * FSharpExpr) option + val ( |AddressOf|_| ): FSharpExpr -> FSharpExpr option + val ( |ThisValue|_| ): FSharpExpr -> FSharpType option + val ( |BaseValue|_| ): FSharpExpr -> FSharpType option + val ( |ILAsm|_| ): + FSharpExpr -> (string * FSharpType list * FSharpExpr list) option + val ( |ILFieldGet|_| ): + FSharpExpr -> (FSharpExpr option * FSharpType * string) option + val ( |ILFieldSet|_| ): + FSharpExpr -> + (FSharpExpr option * FSharpType * string * FSharpExpr) option + val ( |ObjectExpr|_| ): + FSharpExpr -> + (FSharpType * FSharpExpr * FSharpObjectExprOverride list * + (FSharpType * FSharpObjectExprOverride list) list) option + val ( |DecisionTree|_| ): + FSharpExpr -> + (FSharpExpr * (FSharpMemberOrFunctionOrValue list * FSharpExpr) list) option + val ( |DecisionTreeSuccess|_| ): + FSharpExpr -> (int * FSharpExpr list) option + val ( |UnionCaseSet|_| ): + FSharpExpr -> + (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField * FSharpExpr) option + val ( |TraitCall|_| ): + FSharpExpr -> + (FSharpType list * string * SyntaxTree.MemberFlags * FSharpType list * + FSharpType list * FSharpExpr list) option + val ( |WitnessArg|_| ): FSharpExpr -> int option + + +namespace FSharp.Compiler.SourceCodeServices + module Symbol = + val isAttribute<'T>: FSharpAttribute -> bool + val tryGetAttribute<'T>: seq -> FSharpAttribute option + module Option = + val attempt: f:(unit -> 'a) -> 'a option + + val hasModuleSuffixAttribute: FSharpEntity -> bool + val isOperator: name:string -> bool + val UnnamedUnionFieldRegex: System.Text.RegularExpressions.Regex + val isUnnamedUnionCaseField: FSharpField -> bool + val ( |AbbreviatedType|_| ): FSharpEntity -> FSharpType option + val ( |TypeWithDefinition|_| ): FSharpType -> FSharpEntity option + val getEntityAbbreviatedType: + FSharpEntity -> FSharpEntity * FSharpType option + val getAbbreviatedType: FSharpType -> FSharpType + val ( |Attribute|_| ): FSharpEntity -> unit option + val hasAttribute<'T>: seq -> bool + val ( |ValueType|_| ): FSharpEntity -> unit option + val ( |Class|_| ): + original:FSharpEntity * abbreviated:FSharpEntity * 'a -> unit option + val ( |Record|_| ): FSharpEntity -> unit option + val ( |UnionType|_| ): FSharpEntity -> unit option + val ( |Delegate|_| ): FSharpEntity -> unit option + val ( |FSharpException|_| ): FSharpEntity -> unit option + val ( |Interface|_| ): FSharpEntity -> unit option + val ( |AbstractClass|_| ): FSharpEntity -> unit option + val ( |FSharpType|_| ): FSharpEntity -> unit option + val ( |ProvidedType|_| ): FSharpEntity -> unit option + val ( |ByRef|_| ): FSharpEntity -> unit option + val ( |Array|_| ): FSharpEntity -> unit option + val ( |FSharpModule|_| ): FSharpEntity -> unit option + val ( |Namespace|_| ): FSharpEntity -> unit option + val ( |ProvidedAndErasedType|_| ): FSharpEntity -> unit option + val ( |Enum|_| ): FSharpEntity -> unit option + val ( |Tuple|_| ): FSharpType -> unit option + val ( |RefCell|_| ): FSharpType -> unit option + val ( |FunctionType|_| ): FSharpType -> unit option + val ( |Pattern|_| ): FSharpSymbol -> unit option + val ( |Field|_| ): FSharpSymbol -> (FSharpField * FSharpType) option + val ( |MutableVar|_| ): FSharpSymbol -> unit option + val ( |FSharpEntity|_| ): + FSharpSymbol -> (FSharpEntity * FSharpEntity * FSharpType option) option + val ( |Parameter|_| ): FSharpSymbol -> unit option + val ( |UnionCase|_| ): FSharpSymbol -> FSharpUnionCase option + val ( |RecordField|_| ): FSharpSymbol -> FSharpField option + val ( |ActivePatternCase|_| ): + FSharpSymbol -> FSharpActivePatternCase option + val ( |MemberFunctionOrValue|_| ): + FSharpSymbol -> FSharpMemberOrFunctionOrValue option + val ( |Constructor|_| ): + FSharpMemberOrFunctionOrValue -> FSharpEntity option + val ( |Function|_| ): + excluded:bool -> FSharpMemberOrFunctionOrValue -> unit option + val ( |ExtensionMember|_| ): FSharpMemberOrFunctionOrValue -> unit option + val ( |Event|_| ): FSharpMemberOrFunctionOrValue -> unit option + + +namespace FSharp.Compiler.SourceCodeServices + type internal IReactorOperations = + interface + abstract member + EnqueueAndAwaitOpAsync: userOpName:string * opName:string * + opArg:string * + action:(AbstractIL.Internal.Library.CompilationThreadToken -> + AbstractIL.Internal.Library.Cancellable<'T>) -> + Async<'T> + abstract member + EnqueueOp: userOpName:string * opName:string * opArg:string * + action:(AbstractIL.Internal.Library.CompilationThreadToken -> + unit) -> unit + + [] + type internal ReactorCommands = + | SetBackgroundOp of + (string * string * string * + (AbstractIL.Internal.Library.CompilationThreadToken -> + System.Threading.CancellationToken -> bool)) option + | Op of + userOpName: string * opName: string * opArg: string * + System.Threading.CancellationToken * + (AbstractIL.Internal.Library.CompilationThreadToken -> unit) * + (unit -> unit) + | WaitForBackgroundOpCompletion of AsyncReplyChannel + | CompleteAllQueuedOps of AsyncReplyChannel + [] + type Reactor = + + new: unit -> Reactor + member CancelBackgroundOp: unit -> unit + member CompleteAllQueuedOps: unit -> unit + member + EnqueueAndAwaitOpAsync: userOpName:string * opName:string * + opArg:string * + (AbstractIL.Internal.Library.CompilationThreadToken -> + AbstractIL.Internal.Library.Cancellable<'T>) -> + Async<'T> + member + EnqueueOp: userOpName:string * opName:string * opArg:string * + op:(AbstractIL.Internal.Library.CompilationThreadToken -> + unit) -> unit + member + EnqueueOpPrim: userOpName:string * opName:string * opArg:string * + ct:System.Threading.CancellationToken * + op:(AbstractIL.Internal.Library.CompilationThreadToken -> + unit) * ccont:(unit -> unit) -> unit + member + SetBackgroundOp: (string * string * string * + (AbstractIL.Internal.Library.CompilationThreadToken -> + System.Threading.CancellationToken -> bool)) option -> + unit + member SetPreferredUILang: string option -> unit + member WaitForBackgroundOpCompletion: unit -> unit + member CurrentQueueLength: int + member PauseBeforeBackgroundWork: int + static member Singleton: Reactor + + +namespace FSharp.Compiler.SourceCodeServices + [] + type SemanticClassificationType = + | ReferenceType + | ValueType + | UnionCase + | UnionCaseField + | Function + | Property + | MutableVar + | Module + | Namespace + | Printf + | ComputationExpression + | IntrinsicFunction + | Enumeration + | Interface + | TypeArgument + | Operator + | DisposableType + | DisposableTopLevelValue + | DisposableLocalValue + | Method + | ExtensionMethod + | ConstructorForReferenceType + | ConstructorForValueType + | Literal + | RecordField + | MutableRecordField + | RecordFieldAsFunction + | Exception + | Field + | Event + | Delegate + | NamedArgument + | Value + | LocalValue + | Type + | TypeDef + | Plaintext + module TcResolutionsExtensions = + val ( |CNR| ): + cnr:NameResolution.CapturedNameResolution -> + NameResolution.Item * NameResolution.ItemOccurence * + TypedTreeOps.DisplayEnv * NameResolution.NameResolutionEnv * + AccessibilityLogic.AccessorDomain * Range.range + type internal TcResolutions with + member + GetSemanticClassification: g:TcGlobals.TcGlobals * + amap:Import.ImportMap * + formatSpecifierLocations:(Range.range * int) [] * + range:Range.range option -> + + (Range.range * + SemanticClassificationType) [] + + +namespace FSharp.Compiler.SourceCodeServices + module ItemKeyTags = + [] + val entityRef: string = "#E#" + [] + val typeTuple: string = "#T#" + [] + val typeAnonymousRecord: string = "#N#" + [] + val typeFunction: string = "#F#" + [] + val typeMeasure: string = "#M#" + [] + val typeUnionCase: string = "#U#" + [] + val typeMeasureVar: string = "#p#" + [] + val typeMeasureCon: string = "#c#" + [] + val itemValueMember: string = "m$" + [] + val itemValue: string = "v$" + [] + val itemUnionCase: string = "u$" + [] + val itemActivePattern: string = "r$" + [] + val itemExnCase: string = "e$" + [] + val itemRecordField: string = "d$" + [] + val itemAnonymousRecordField: string = "a$" + [] + val itemNewDef: string = "n$" + [] + val itemILField: string = "l$" + [] + val itemEvent: string = "t$" + [] + val itemProperty: string = "p$" + [] + val itemTypeVar: string = "y$" + [] + val itemModuleOrNamespace: string = "o$" + [] + val itemDelegateCtor: string = "g$" + [] + val parameters: string = "p$p$" + + [] + type ItemKeyStore = + + interface System.IDisposable + new: mmf:System.IO.MemoryMappedFiles.MemoryMappedFile * length:int64 -> + ItemKeyStore + member FindAll: NameResolution.Item -> seq + member ReadFirstKeyString: unit -> System.ReadOnlySpan + member + ReadKeyString: reader:byref -> + System.ReadOnlySpan + member + ReadRange: reader:byref -> + Range.range + + [] + and ItemKeyStoreBuilder = + + new: unit -> ItemKeyStoreBuilder + member TryBuildAndReset: unit -> ItemKeyStore option + member Write: Range.range * NameResolution.Item -> unit + + +namespace FSharp.Compiler + module internal IncrementalBuild = + val mutable injectCancellationFault: bool + val LocallyInjectCancellationFault: unit -> System.IDisposable + + module IncrementalBuilderEventTesting = + type internal FixedLengthMRU<'T> = + + new: unit -> FixedLengthMRU<'T> + member Add: filename:'T -> unit + member MostRecentList: n:int -> 'T list + member CurrentEventNum: int + + type IBEvent = + | IBEParsed of string + | IBETypechecked of string + | IBECreated + val MRU: FixedLengthMRU + val GetMostRecentIncrementalBuildEvents: int -> IBEvent list + val GetCurrentIncrementalBuildEventNum: unit -> int + + module IncrementalBuildSyntaxTree = + [] + type SyntaxTree = + + new: tcConfig:CompilerConfig.TcConfig * fileParsed:Event * + lexResourceManager:Lexhelp.LexResourceManager * + sourceRange:Range.range * filename:string * + isLastCompiland:(bool * bool) -> SyntaxTree + member Invalidate: unit -> unit + member + Parse: sigNameOpt:SyntaxTree.QualifiedNameOfFile option -> + SyntaxTree.ParsedInput option * Range.range * string * + (ErrorLogger.PhasedDiagnostic * + SourceCodeServices.FSharpErrorSeverity) [] + member FileName: string + + + [] + type TcInfo = + { tcState: ParseAndCheckInputs.TcState + tcEnvAtEndOfFile: CheckExpressions.TcEnv + moduleNamesDict: ParseAndCheckInputs.ModuleNamesDict + topAttribs: CheckDeclarations.TopAttribs option + latestCcuSigForFile: TypedTree.ModuleOrNamespaceType option + tcErrorsRev: + (ErrorLogger.PhasedDiagnostic * SourceCodeServices.FSharpErrorSeverity) [] list + tcDependencyFiles: string list + sigNameOpt: (string * SyntaxTree.QualifiedNameOfFile) option } + with + member + TcErrors: (ErrorLogger.PhasedDiagnostic * + SourceCodeServices.FSharpErrorSeverity) [] + + [] + type TcInfoOptional = + { tcResolutionsRev: NameResolution.TcResolutions list + tcSymbolUsesRev: NameResolution.TcSymbolUses list + tcOpenDeclarationsRev: NameResolution.OpenDeclaration [] list + latestImplFile: TypedTree.TypedImplFile option + itemKeyStore: SourceCodeServices.ItemKeyStore option + semanticClassification: + (Range.range * SourceCodeServices.SemanticClassificationType) [] } + with + member TcSymbolUses: NameResolution.TcSymbolUses list + + [] + type TcInfoState = + | PartialState of TcInfo + | FullState of TcInfo * TcInfoOptional + with + member Partial: TcInfo + + [] + type SemanticModel = + + private new: tcConfig:CompilerConfig.TcConfig * + tcGlobals:TcGlobals.TcGlobals * + tcImports:CompilerImports.TcImports * + keepAssemblyContents:bool * + keepAllBackgroundResolutions:bool * + maxTimeShareMilliseconds:int64 * + keepAllBackgroundSymbolUses:bool * + enableBackgroundItemKeyStoreAndSemanticClassification:bool * + enablePartialTypeChecking:bool * + beforeFileChecked:Event * fileChecked:Event * + prevTcInfo:TcInfo * + prevTcInfoOptional:AbstractIL.Internal.Library.Eventually * + syntaxTreeOpt:IncrementalBuildSyntaxTree.SyntaxTree option * + lazyTcInfoState:TcInfoState option ref -> SemanticModel + static member + Create: tcConfig:CompilerConfig.TcConfig * + tcGlobals:TcGlobals.TcGlobals * + tcImports:CompilerImports.TcImports * keepAssemblyContents:bool * + keepAllBackgroundResolutions:bool * + maxTimeShareMilliseconds:int64 * + keepAllBackgroundSymbolUses:bool * + enableBackgroundItemKeyStoreAndSemanticClassification:bool * + enablePartialTypeChecking:bool * + beforeFileChecked:Event * fileChecked:Event * + prevTcInfo:TcInfo * + prevTcInfoOptional:AbstractIL.Internal.Library.Eventually * + syntaxTreeOpt:IncrementalBuildSyntaxTree.SyntaxTree option -> + SemanticModel + member + Finish: finalTcErrorsRev:(ErrorLogger.PhasedDiagnostic * + SourceCodeServices.FSharpErrorSeverity) [] list * + finalTopAttribs:CheckDeclarations.TopAttribs option -> + AbstractIL.Internal.Library.Eventually + member + GetState: partialCheck:bool -> + AbstractIL.Internal.Library.Eventually + member Invalidate: unit -> unit + member + Next: syntaxTree:IncrementalBuildSyntaxTree.SyntaxTree -> + AbstractIL.Internal.Library.Eventually + member + private TypeCheck: partialCheck:bool -> + AbstractIL.Internal.Library.Eventually + member BackingSignature: SyntaxTree.QualifiedNameOfFile option + member TcConfig: CompilerConfig.TcConfig + member TcGlobals: TcGlobals.TcGlobals + member TcImports: CompilerImports.TcImports + member TcInfo: AbstractIL.Internal.Library.Eventually + member + TcInfoWithOptional: AbstractIL.Internal.Library.Eventually + + type FrameworkImportsCacheKey = + string list * string * string list * string * decimal + type FrameworkImportsCache = + + new: size:int -> FrameworkImportsCache + member Clear: AbstractIL.Internal.Library.CompilationThreadToken -> unit + member + Downsize: AbstractIL.Internal.Library.CompilationThreadToken -> unit + member + Get: AbstractIL.Internal.Library.CompilationThreadToken * + CompilerConfig.TcConfig -> + AbstractIL.Internal.Library.Cancellable + + [] + type PartialCheckResults = + + private new: semanticModel:SemanticModel * timeStamp:System.DateTime -> + PartialCheckResults + static member + Create: semanticModel:SemanticModel * timestamp:System.DateTime -> + PartialCheckResults + member + GetSemanticClassification: AbstractIL.Internal.Library.CompilationThreadToken -> + + (Range.range * + SourceCodeServices.SemanticClassificationType) [] + member + TcInfo: AbstractIL.Internal.Library.CompilationThreadToken -> TcInfo + member + TcInfoWithOptional: AbstractIL.Internal.Library.CompilationThreadToken -> + TcInfo * TcInfoOptional + member + TryGetItemKeyStore: AbstractIL.Internal.Library.CompilationThreadToken -> + SourceCodeServices.ItemKeyStore option + member TcConfig: CompilerConfig.TcConfig + member TcGlobals: TcGlobals.TcGlobals + member TcImports: CompilerImports.TcImports + member TimeStamp: System.DateTime + + module Utilities = + val TryFindFSharpStringAttribute: + tcGlobals:TcGlobals.TcGlobals -> + attribSpec:TcGlobals.BuiltinAttribInfo -> + attribs:TypedTree.Attribs -> string option + + type RawFSharpAssemblyDataBackedByLanguageService = + + interface CompilerConfig.IRawFSharpAssemblyData + new: tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * + tcState:ParseAndCheckInputs.TcState * outfile:string * + topAttrs:CheckDeclarations.TopAttribs * assemblyName:string * + ilAssemRef:AbstractIL.IL.ILAssemblyRef -> + RawFSharpAssemblyDataBackedByLanguageService + + [] + type IncrementalBuilder = + + new: tcGlobals:TcGlobals.TcGlobals * + frameworkTcImports:CompilerImports.TcImports * + nonFrameworkAssemblyInputs:(Choice * + (CompilerConfig.TimeStampCache -> + AbstractIL.Internal.Library.CompilationThreadToken -> + System.DateTime)) list * + nonFrameworkResolutions:CompilerImports.AssemblyResolution list * + unresolvedReferences:CompilerConfig.UnresolvedAssemblyReference list * + tcConfig:CompilerConfig.TcConfig * projectDirectory:string * + outfile:string * assemblyName:string * + niceNameGen:CompilerGlobalState.NiceNameGenerator * + lexResourceManager:Lexhelp.LexResourceManager * + sourceFiles:string list * + loadClosureOpt:ScriptClosure.LoadClosure option * + keepAssemblyContents:bool * keepAllBackgroundResolutions:bool * + maxTimeShareMilliseconds:int64 * keepAllBackgroundSymbolUses:bool * + enableBackgroundItemKeyStoreAndSemanticClassification:bool * + enablePartialTypeChecking:bool * + dependencyProviderOpt:Microsoft.DotNet.DependencyManager.DependencyProvider option -> + IncrementalBuilder + static member + TryCreateIncrementalBuilderForProjectOptions: AbstractIL.Internal.Library.CompilationThreadToken * + ReferenceResolver.Resolver * + defaultFSharpBinariesDir:string * + FrameworkImportsCache * + loadClosureOpt:ScriptClosure.LoadClosure option * + sourceFiles:string list * + commandLineArgs:string list * + projectReferences:CompilerConfig.IProjectReference list * + projectDirectory:string * + useScriptResolutionRules:bool * + keepAssemblyContents:bool * + keepAllBackgroundResolutions:bool * + maxTimeShareMilliseconds:int64 * + tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * + suggestNamesForErrors:bool * + keepAllBackgroundSymbolUses:bool * + enableBackgroundItemKeyStoreAndSemanticClassification:bool * + enablePartialTypeChecking:bool * + dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider option -> + AbstractIL.Internal.Library.Cancellable + member AreCheckResultsBeforeFileInProjectReady: filename:string -> bool + member ContainsFile: filename:string -> bool + member + GetCheckResultsAfterFileInProject: AbstractIL.Internal.Library.CompilationThreadToken * + filename:string -> + AbstractIL.Internal.Library.Cancellable + member + GetCheckResultsAfterLastFileInProject: AbstractIL.Internal.Library.CompilationThreadToken -> + AbstractIL.Internal.Library.Cancellable + member + GetCheckResultsAndImplementationsForProject: AbstractIL.Internal.Library.CompilationThreadToken -> + AbstractIL.Internal.Library.Cancellable + member + GetCheckResultsBeforeFileInProject: AbstractIL.Internal.Library.CompilationThreadToken * + filename:string -> + AbstractIL.Internal.Library.Cancellable + member + GetCheckResultsBeforeFileInProjectEvenIfStale: filename:string -> + PartialCheckResults option + member + GetCheckResultsBeforeSlotInProject: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + slotOfFile:int -> + AbstractIL.Internal.Library.Cancellable + member + GetFullCheckResultsAfterFileInProject: AbstractIL.Internal.Library.CompilationThreadToken * + filename:string -> + AbstractIL.Internal.Library.Cancellable + member + GetFullCheckResultsAndImplementationsForProject: AbstractIL.Internal.Library.CompilationThreadToken -> + AbstractIL.Internal.Library.Cancellable + member + GetLogicalTimeStampForProject: CompilerConfig.TimeStampCache * + AbstractIL.Internal.Library.CompilationThreadToken -> + System.DateTime + member + GetParseResultsForFile: AbstractIL.Internal.Library.CompilationThreadToken * + filename:string -> + AbstractIL.Internal.Library.Cancellable + member GetSlotOfFileName: filename:string -> int + member GetSlotsCount: unit -> int + member + Step: AbstractIL.Internal.Library.CompilationThreadToken -> + AbstractIL.Internal.Library.Cancellable + member TryGetCurrentTcImports: unit -> CompilerImports.TcImports option + member TryGetSlotOfFileName: filename:string -> int option + member AllDependenciesDeprecated: string [] + member BeforeFileChecked: IEvent + member FileChecked: IEvent + member FileParsed: IEvent + member ImportsInvalidatedByTypeProvider: IEvent + member ProjectChecked: IEvent + member SourceFiles: string list + member TcConfig: CompilerConfig.TcConfig + + +namespace FSharp.Compiler.SourceCodeServices + [] + type FSharpGlyph = + | Class + | Constant + | Delegate + | Enum + | EnumMember + | Event + | Exception + | Field + | Interface + | Method + | OverridenMethod + | Module + | NameSpace + | Property + | Struct + | Typedef + | Type + | Union + | Variable + | ExtensionMethod + | Error + +namespace FSharp.Compiler.SourceCodeServices + [] + type FSharpMethodGroupItemParameter = + + new: name:string * canonicalTypeTextForSorting:string * + display:Layout.layout * isOptional:bool -> + FSharpMethodGroupItemParameter + member CanonicalTypeTextForSorting: string + member Display: string + member IsOptional: bool + member ParameterName: string + member StructuredDisplay: Layout.layout + + module internal DescriptionListsImpl = + val isFunction: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val printCanonicalizedTypeName: + g:TcGlobals.TcGlobals -> + denv:TypedTreeOps.DisplayEnv -> tau:TypedTree.TType -> string + val PrettyParamOfRecdField: + g:TcGlobals.TcGlobals -> + denv:TypedTreeOps.DisplayEnv -> + f:TypedTree.RecdField -> FSharpMethodGroupItemParameter + val PrettyParamOfUnionCaseField: + g:TcGlobals.TcGlobals -> + denv:TypedTreeOps.DisplayEnv -> + isGenerated:(int -> TypedTree.RecdField -> bool) -> + i:int -> f:TypedTree.RecdField -> FSharpMethodGroupItemParameter + val ParamOfParamData: + g:TcGlobals.TcGlobals -> + denv:TypedTreeOps.DisplayEnv -> + Infos.ParamData -> FSharpMethodGroupItemParameter + val PrettyParamsOfParamDatas: + g:TcGlobals.TcGlobals -> + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst -> + paramDatas:Infos.ParamData list -> + rty:TypedTree.TType -> + TypedTreeOps.TyparInst * FSharpMethodGroupItemParameter list * + Internal.Utilities.StructuredFormat.Layout * + Internal.Utilities.StructuredFormat.Layout + val PrettyParamsOfTypes: + g:TcGlobals.TcGlobals -> + denv:TypedTreeOps.DisplayEnv -> + typarInst:TypedTreeOps.TyparInst -> + paramTys:TypedTree.TTypes -> + retTy:TypedTree.TType -> + TypedTreeOps.TyparInst * FSharpMethodGroupItemParameter list * + Internal.Utilities.StructuredFormat.Layout * + Internal.Utilities.StructuredFormat.Layout + val StaticParamsOfItem: + infoReader:InfoReader.InfoReader -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + item:NameResolution.Item -> FSharpMethodGroupItemParameter [] + val PrettyParamsAndReturnTypeOfItem: + infoReader:InfoReader.InfoReader -> + m:Range.range -> + denv:TypedTreeOps.DisplayEnv -> + item:NameResolution.ItemWithInst -> + FSharpMethodGroupItemParameter list * + Internal.Utilities.StructuredFormat.Layout + val GlyphOfItem: + denv:TypedTreeOps.DisplayEnv * item:NameResolution.Item -> FSharpGlyph + val AnotherFlattenItems: + g:TcGlobals.TcGlobals -> + m:Range.range -> item:NameResolution.Item -> NameResolution.Item list + + [] + type FSharpDeclarationListItem = + + new: name:string * nameInCode:string * fullName:string * + glyph:FSharpGlyph * + info:Choice<(CompletionItem list * InfoReader.InfoReader * + Range.range * TypedTreeOps.DisplayEnv), + FSharpToolTipText> * + accessibility:FSharpAccessibility option * kind:CompletionItemKind * + isOwnMember:bool * priority:int * isResolved:bool * + namespaceToOpen:string option -> FSharpDeclarationListItem + member Accessibility: FSharpAccessibility option + member DescriptionText: FSharpToolTipText + [] + member DescriptionTextAsync: Async + member FullName: string + member Glyph: FSharpGlyph + member IsOwnMember: bool + member IsResolved: bool + member Kind: CompletionItemKind + member MinorPriority: int + member Name: string + member NameInCode: string + member NamespaceToOpen: string option + member StructuredDescriptionText: FSharpToolTipText + [] + member StructuredDescriptionTextAsync: Async> + + [] + type FSharpDeclarationListInfo = + + new: declarations:FSharpDeclarationListItem [] * isForType:bool * + isError:bool -> FSharpDeclarationListInfo + static member + Create: infoReader:InfoReader.InfoReader * m:Range.range * + denv:TypedTreeOps.DisplayEnv * + getAccessibility:(NameResolution.Item -> + FSharpAccessibility option) * + items:CompletionItem list * currentNamespace:string [] option * + isAttributeApplicationContext:bool -> FSharpDeclarationListInfo + static member Error: message:string -> FSharpDeclarationListInfo + member IsError: bool + member IsForType: bool + member Items: FSharpDeclarationListItem [] + static member Empty: FSharpDeclarationListInfo + + [] + type FSharpMethodGroupItem = + + new: description:FSharpToolTipText * xmlDoc:FSharpXmlDoc * + returnType:Layout.layout * + parameters:FSharpMethodGroupItemParameter [] * hasParameters:bool * + hasParamArrayArg:bool * + staticParameters:FSharpMethodGroupItemParameter [] -> + FSharpMethodGroupItem + member Description: FSharpToolTipText + member HasParamArrayArg: bool + member HasParameters: bool + member Parameters: FSharpMethodGroupItemParameter [] + member ReturnTypeText: string + member StaticParameters: FSharpMethodGroupItemParameter [] + member StructuredDescription: FSharpToolTipText + member StructuredReturnTypeText: Layout.layout + member XmlDoc: FSharpXmlDoc + + [] + type FSharpMethodGroup = + + new: string * FSharpMethodGroupItem [] -> FSharpMethodGroup + static member + Create: InfoReader.InfoReader * Range.range * TypedTreeOps.DisplayEnv * + NameResolution.ItemWithInst list -> FSharpMethodGroup + member MethodName: string + member Methods: FSharpMethodGroupItem [] + + +namespace FSharp.Compiler.SourceCodeServices + type Position = int * int + type Range = Position * Position + module FSharpTokenTag = + val Identifier: int + val String: int + val IDENT: int + val STRING: int + val INTERP_STRING_BEGIN_END: int + val INTERP_STRING_BEGIN_PART: int + val INTERP_STRING_PART: int + val INTERP_STRING_END: int + val LPAREN: int + val RPAREN: int + val LBRACK: int + val RBRACK: int + val LBRACE: int + val RBRACE: int + val LBRACK_LESS: int + val GREATER_RBRACK: int + val LESS: int + val GREATER: int + val LBRACK_BAR: int + val BAR_RBRACK: int + val PLUS_MINUS_OP: int + val MINUS: int + val STAR: int + val INFIX_STAR_DIV_MOD_OP: int + val PERCENT_OP: int + val INFIX_AT_HAT_OP: int + val QMARK: int + val COLON: int + val EQUALS: int + val SEMICOLON: int + val COMMA: int + val DOT: int + val DOT_DOT: int + val DOT_DOT_HAT: int + val INT32_DOT_DOT: int + val UNDERSCORE: int + val BAR: int + val COLON_GREATER: int + val COLON_QMARK_GREATER: int + val COLON_QMARK: int + val INFIX_BAR_OP: int + val INFIX_COMPARE_OP: int + val COLON_COLON: int + val AMP_AMP: int + val PREFIX_OP: int + val COLON_EQUALS: int + val BAR_BAR: int + val RARROW: int + val LARROW: int + val QUOTE: int + val WHITESPACE: int + val COMMENT: int + val LINE_COMMENT: int + val BEGIN: int + val DO: int + val FUNCTION: int + val THEN: int + val ELSE: int + val STRUCT: int + val CLASS: int + val TRY: int + val NEW: int + val WITH: int + val OWITH: int + + type FSharpTokenColorKind = + | Default = 0 + | Text = 0 + | Keyword = 1 + | Comment = 2 + | Identifier = 3 + | String = 4 + | UpperIdentifier = 5 + | InactiveCode = 7 + | PreprocessorKeyword = 8 + | Number = 9 + | Operator = 10 + | Punctuation = 11 + type FSharpTokenTriggerClass = + | None = 0 + | MemberSelect = 1 + | MatchBraces = 2 + | ChoiceSelect = 4 + | MethodTip = 240 + | ParamStart = 16 + | ParamNext = 32 + | ParamEnd = 64 + type FSharpTokenCharKind = + | Default = 0 + | Text = 0 + | Keyword = 1 + | Identifier = 2 + | String = 3 + | Literal = 4 + | Operator = 5 + | Delimiter = 6 + | WhiteSpace = 8 + | LineComment = 9 + | Comment = 10 + type FSharpTokenInfo = + { LeftColumn: int + RightColumn: int + ColorClass: FSharpTokenColorKind + CharClass: FSharpTokenCharKind + FSharpTokenTriggerClass: FSharpTokenTriggerClass + Tag: int + TokenName: string + FullMatchedLength: int } + module internal TokenClassifications = + val tokenInfo: + token:Parser.token -> + FSharpTokenColorKind * FSharpTokenCharKind * FSharpTokenTriggerClass + + module internal TestExpose = + val TokenInfo: + Parser.token -> + FSharpTokenColorKind * FSharpTokenCharKind * FSharpTokenTriggerClass + + [] + type FSharpTokenizerLexState = + { PosBits: int64 + OtherBits: int64 } + with + override Equals: obj:obj -> bool + member Equals: FSharpTokenizerLexState -> bool + override GetHashCode: unit -> int + static member Initial: FSharpTokenizerLexState + + type FSharpTokenizerColorState = + | Token = 1 + | IfDefSkip = 3 + | String = 4 + | Comment = 5 + | StringInComment = 6 + | VerbatimStringInComment = 7 + | CamlOnly = 8 + | VerbatimString = 9 + | SingleLineComment = 10 + | EndLineThenSkip = 11 + | EndLineThenToken = 12 + | TripleQuoteString = 13 + | TripleQuoteStringInComment = 14 + | InitialState = 0 + module internal LexerStateEncoding = + val computeNextLexState: + token:Parser.token -> + prevLexcont:ParseHelpers.LexerContinuation -> + ParseHelpers.LexerContinuation + val revertToDefaultLexCont: ParseHelpers.LexerContinuation + val lexstateNumBits: int + val ncommentsNumBits: int + val hardwhiteNumBits: int + val ifdefstackCountNumBits: int + val ifdefstackNumBits: int + val stringKindBits: int + val nestingBits: int + val lexstateStart: int + val ncommentsStart: int + val hardwhitePosStart: int + val ifdefstackCountStart: int + val ifdefstackStart: int + val stringKindStart: int + val nestingStart: int + val lexstateMask: int64 + val ncommentsMask: int64 + val hardwhitePosMask: int64 + val ifdefstackCountMask: int64 + val ifdefstackMask: int64 + val stringKindMask: int64 + val nestingMask: int64 + val bitOfBool: b:bool -> int + val boolOfBit: n:int64 -> bool + val colorStateOfLexState: + state:FSharpTokenizerLexState -> FSharpTokenizerColorState + val lexStateOfColorState: state:FSharpTokenizerColorState -> int64 + val encodeStringStyle: kind:ParseHelpers.LexerStringStyle -> int + val decodeStringStyle: kind:int -> ParseHelpers.LexerStringStyle + val encodeLexCont: + colorState:FSharpTokenizerColorState * numComments:int64 * b:Range.pos * + ifdefStack:seq * light:bool * + stringKind:ParseHelpers.LexerStringKind * + stringNest:(int * ParseHelpers.LexerStringStyle * 'b) list -> + FSharpTokenizerLexState + val decodeLexCont: + state:FSharpTokenizerLexState -> + FSharpTokenizerColorState * int32 * Range.pos * + (ParseHelpers.LexerIfdefStackEntry * Range.range) list * bool * + ParseHelpers.LexerStringKind * + ParseHelpers.LexerInterpolatedStringNesting + val encodeLexInt: + lightStatus:bool -> + lexcont:ParseHelpers.LexerContinuation -> FSharpTokenizerLexState + val decodeLexInt: + state:FSharpTokenizerLexState -> bool * ParseHelpers.LexerContinuation + + type SingleLineTokenState = + | BeforeHash = 0 + | NoFurtherMatchPossible = 1 + [] + type FSharpLineTokenizer = + + new: lexbuf:UnicodeLexing.Lexbuf * maxLength:int option * + filename:string option * lexargs:Lexhelp.LexArgs -> + FSharpLineTokenizer + static member + ColorStateOfLexState: FSharpTokenizerLexState -> + FSharpTokenizerColorState + static member + LexStateOfColorState: FSharpTokenizerColorState -> + FSharpTokenizerLexState + member + ScanToken: lexState:FSharpTokenizerLexState -> + FSharpTokenInfo option * FSharpTokenizerLexState + + [] + type FSharpSourceTokenizer = + + new: conditionalDefines:string list * filename:string option -> + FSharpSourceTokenizer + member + CreateBufferTokenizer: bufferFiller:(char [] * int * int -> int) -> + FSharpLineTokenizer + member CreateLineTokenizer: lineText:string -> FSharpLineTokenizer + + module Keywords = + val DoesIdentifierNeedQuotation: string -> bool + val QuoteIdentifierIfNeeded: string -> string + val NormalizeIdentifierBackticks: string -> string + val KeywordsWithDescription: (string * string) list + + module Lexer = + [] + type FSharpLexerFlags = + | Default = 69649 + | LightSyntaxOn = 1 + | Compiling = 16 + | CompilingFSharpCore = 272 + | SkipTrivia = 4096 + | UseLexFilter = 65536 + [] + type FSharpSyntaxTokenKind = + | None + | HashIf + | HashElse + | HashEndIf + | CommentTrivia + | WhitespaceTrivia + | HashLine + | HashLight + | InactiveCode + | LineCommentTrivia + | StringText + | Fixed + | OffsideInterfaceMember + | OffsideBlockEnd + | OffsideRightBlockEnd + | OffsideDeclEnd + | OffsideEnd + | OffsideBlockSep + | OffsideBlockBegin + | OffsideReset + | OffsideFun + | OffsideFunction + | OffsideWith + | OffsideElse + | OffsideThen + | OffsideDoBang + | OffsideDo + | OffsideBinder + | OffsideLet + | HighPrecedenceTypeApp + | HighPrecedenceParenthesisApp + | HighPrecedenceBracketApp + | Extern + | Void + | Public + | Private + | Internal + | Global + | Static + | Member + | Class + | Abstract + | Override + | Default + | Constructor + | Inherit + | GreaterRightBracket + | Struct + | Sig + | Bar + | RightBracket + | RightBrace + | Minus + | Dollar + | BarRightBracket + | BarRightBrace + | Underscore + | Semicolon + | SemicolonSemicolon + | LeftArrow + | Equals + | LeftBracket + | LeftBracketBar + | LeftBraceBar + | LeftBracketLess + | LeftBrace + | QuestionMark + | QuestionMarkQuestionMark + | Dot + | Colon + | ColonColon + | ColonGreater + | ColonQuestionMark + | ColonQuestionMarkGreater + | ColonEquals + | When + | While + | With + | Hash + | Ampersand + | AmpersandAmpersand + | Quote + | LeftParenthesis + | RightParenthesis + | Star + | Comma + | RightArrow + | GreaterBarRightBracket + | LeftParenthesisStarRightParenthesis + | Open + | Or + | Rec + | Then + | To + | True + | Try + | Type + | Val + | Inline + | Interface + | Instance + | Const + | Lazy + | OffsideLazy + | Match + | MatchBang + | Mutable + | New + | Of + | Exception + | False + | For + | Fun + | Function + | If + | In + | JoinIn + | Finally + | DoBang + | And + | As + | Assert + | OffsideAssert + | Begin + | Do + | Done + | DownTo + | Else + | Elif + | End + | DotDot + | DotDotHat + | BarBar + | Upcast + | Downcast + | Null + | Reserved + | Module + | Namespace + | Delegate + | Constraint + | Base + | LeftQuote + | RightQuote + | RightQuoteDot + | PercentOperator + | Binder + | Less + | Greater + | Let + | Yield + | YieldBang + | BigNumber + | Decimal + | Char + | Ieee64 + | Ieee32 + | NativeInt + | UNativeInt + | UInt64 + | UInt32 + | UInt16 + | UInt8 + | Int64 + | Int32 + | Int32DotDot + | Int16 + | Int8 + | FunkyOperatorName + | AdjacentPrefixOperator + | PlusMinusOperator + | InfixAmpersandOperator + | InfixStarDivideModuloOperator + | PrefixOperator + | InfixBarOperator + | InfixAtHatOperator + | InfixCompareOperator + | InfixStarStarOperator + | Identifier + | KeywordString + | String + | ByteArray + | Asr + | InfixAsr + | InfixLand + | InfixLor + | InfixLsl + | InfixLsr + | InfixLxor + | InfixMod + [] + type FSharpSyntaxToken = + + new: tok:Parser.token * tokRange:Range.range -> FSharpSyntaxToken + val private tok: Parser.token + val private tokRange: Range.range + member IsCommentTrivia: bool + member IsIdentifier: bool + member IsKeyword: bool + member IsNumericLiteral: bool + member IsStringLiteral: bool + member Kind: FSharpSyntaxTokenKind + member Range: Range.range + + val lexWithErrorLogger: + text:Text.ISourceText -> + conditionalCompilationDefines:string list -> + flags:FSharpLexerFlags -> + supportsFeature:(Features.LanguageFeature -> bool) -> + errorLogger:ErrorLogger.ErrorLogger -> + onToken:(Parser.token -> Range.range -> unit) -> + pathMap:Internal.Utilities.PathMap -> + ct:System.Threading.CancellationToken -> unit + val lex: + text:Text.ISourceText -> + conditionalCompilationDefines:string list -> + flags:FSharpLexerFlags -> + supportsFeature:(Features.LanguageFeature -> bool) -> + lexCallback:(Parser.token -> Range.range -> unit) -> + pathMap:Internal.Utilities.PathMap -> + ct:System.Threading.CancellationToken -> unit + [] + type FSharpLexer = + + [] + static member + Lex: text:Text.ISourceText * + tokenCallback:(FSharpSyntaxToken -> unit) * ?langVersion:string * + ?filePath:string * ?conditionalCompilationDefines:string list * + ?flags:FSharpLexerFlags * ?pathMap:Map * + ?ct:System.Threading.CancellationToken -> unit + + + +namespace FSharp.Compiler.SourceCodeServices + module AstTraversal = + val rangeContainsPosLeftEdgeInclusive: + m1:Range.range -> p:Range.pos -> bool + val rangeContainsPosEdgesExclusive: m1:Range.range -> p:Range.pos -> bool + val rangeContainsPosLeftEdgeExclusiveAndRightEdgeInclusive: + m1:Range.range -> p:Range.pos -> bool + [] + type TraverseStep = + | Expr of SyntaxTree.SynExpr + | Module of SyntaxTree.SynModuleDecl + | ModuleOrNamespace of SyntaxTree.SynModuleOrNamespace + | TypeDefn of SyntaxTree.SynTypeDefn + | MemberDefn of SyntaxTree.SynMemberDefn + | MatchClause of SyntaxTree.SynMatchClause + | Binding of SyntaxTree.SynBinding + type TraversePath = TraverseStep list + [] + type AstVisitorBase<'T> = + + new: unit -> AstVisitorBase<'T> + override + VisitBinding: defaultTraverse:(SyntaxTree.SynBinding -> 'T option) * + binding:SyntaxTree.SynBinding -> 'T option + abstract member + VisitBinding: (SyntaxTree.SynBinding -> 'T option) * + SyntaxTree.SynBinding -> 'T option + override VisitComponentInfo: SyntaxTree.SynComponentInfo -> 'T option + abstract member + VisitComponentInfo: SyntaxTree.SynComponentInfo -> 'T option + abstract member + VisitExpr: TraversePath * (SyntaxTree.SynExpr -> 'T option) * + (SyntaxTree.SynExpr -> 'T option) * SyntaxTree.SynExpr -> + 'T option + override VisitHashDirective: Range.range -> 'T option + abstract member VisitHashDirective: Range.range -> 'T option + override + VisitImplicitInherit: defaultTraverse:(SyntaxTree.SynExpr -> + 'T option) * + _ty:SyntaxTree.SynType * + expr:SyntaxTree.SynExpr * _m:Range.range -> + 'T option + abstract member + VisitImplicitInherit: (SyntaxTree.SynExpr -> 'T option) * + SyntaxTree.SynType * SyntaxTree.SynExpr * + Range.range -> 'T option + override + VisitInheritSynMemberDefn: _componentInfo:SyntaxTree.SynComponentInfo * + _typeDefnKind:SyntaxTree.SynTypeDefnKind * + _synType:SyntaxTree.SynType * + _members:SyntaxTree.SynMemberDefns * + _range:Range.range -> 'T option + abstract member + VisitInheritSynMemberDefn: SyntaxTree.SynComponentInfo * + SyntaxTree.SynTypeDefnKind * + SyntaxTree.SynType * + SyntaxTree.SynMemberDefns * Range.range -> + 'T option + override + VisitInterfaceSynMemberDefnType: _synType:SyntaxTree.SynType -> + 'T option + abstract member + VisitInterfaceSynMemberDefnType: SyntaxTree.SynType -> 'T option + override + VisitLetOrUse: TraversePath * (SyntaxTree.SynBinding -> 'T option) * + SyntaxTree.SynBinding list * Range.range -> 'T option + abstract member + VisitLetOrUse: TraversePath * (SyntaxTree.SynBinding -> 'T option) * + SyntaxTree.SynBinding list * Range.range -> 'T option + override + VisitMatchClause: defaultTraverse:(SyntaxTree.SynMatchClause -> + 'T option) * + mc:SyntaxTree.SynMatchClause -> 'T option + abstract member + VisitMatchClause: (SyntaxTree.SynMatchClause -> 'T option) * + SyntaxTree.SynMatchClause -> 'T option + override + VisitModuleDecl: defaultTraverse:(SyntaxTree.SynModuleDecl -> + 'T option) * + decl:SyntaxTree.SynModuleDecl -> 'T option + abstract member + VisitModuleDecl: (SyntaxTree.SynModuleDecl -> 'T option) * + SyntaxTree.SynModuleDecl -> 'T option + override + VisitModuleOrNamespace: SyntaxTree.SynModuleOrNamespace -> 'T option + abstract member + VisitModuleOrNamespace: SyntaxTree.SynModuleOrNamespace -> 'T option + override + VisitPat: defaultTraverse:(SyntaxTree.SynPat -> 'T option) * + pat:SyntaxTree.SynPat -> 'T option + abstract member + VisitPat: (SyntaxTree.SynPat -> 'T option) * SyntaxTree.SynPat -> + 'T option + override + VisitRecordField: _path:TraversePath * + _copyOpt:SyntaxTree.SynExpr option * + _recordField:SyntaxTree.LongIdentWithDots option -> + 'T option + abstract member + VisitRecordField: TraversePath * SyntaxTree.SynExpr option * + SyntaxTree.LongIdentWithDots option -> 'T option + override VisitSimplePats: SyntaxTree.SynSimplePat list -> 'T option + abstract member + VisitSimplePats: SyntaxTree.SynSimplePat list -> 'T option + override + VisitType: defaultTraverse:(SyntaxTree.SynType -> 'T option) * + ty:SyntaxTree.SynType -> 'T option + abstract member + VisitType: (SyntaxTree.SynType -> 'T option) * SyntaxTree.SynType -> + 'T option + override + VisitTypeAbbrev: _ty:SyntaxTree.SynType * _m:Range.range -> 'T option + abstract member + VisitTypeAbbrev: SyntaxTree.SynType * Range.range -> 'T option + + val dive: node:'a -> range:'b -> project:('a -> 'c) -> 'b * (unit -> 'c) + val pick: + pos:Range.pos -> + outerRange:Range.range -> + _debugObj:obj -> + diveResults:(Range.range * (unit -> 'a option)) list -> 'a option + val Traverse: + pos:Range.pos * parseTree:SyntaxTree.ParsedInput * + visitor:AstVisitorBase<'T> -> 'T option + + +namespace FSharp.Compiler.SourceCodeServices + type FSharpNavigationDeclarationItemKind = + | NamespaceDecl + | ModuleFileDecl + | ExnDecl + | ModuleDecl + | TypeDecl + | MethodDecl + | PropertyDecl + | FieldDecl + | OtherDecl + [] + type FSharpEnclosingEntityKind = + | Namespace + | Module + | Class + | Exception + | Interface + | Record + | Enum + | DU + [] + type FSharpNavigationDeclarationItem = + + new: uniqueName:string * name:string * + kind:FSharpNavigationDeclarationItemKind * glyph:FSharpGlyph * + range:Range.range * bodyRange:Range.range * singleTopLevel:bool * + enclosingEntityKind:FSharpEnclosingEntityKind * isAbstract:bool * + access:SyntaxTree.SynAccess option -> + FSharpNavigationDeclarationItem + static member + Create: name:string * kind:FSharpNavigationDeclarationItemKind * + glyph:FSharpGlyph * range:Range.range * bodyRange:Range.range * + singleTopLevel:bool * + enclosingEntityKind:FSharpEnclosingEntityKind * isAbstract:bool * + access:SyntaxTree.SynAccess option -> + FSharpNavigationDeclarationItem + member + WithUniqueName: uniqueName:string -> FSharpNavigationDeclarationItem + member Access: SyntaxTree.SynAccess option + member BodyRange: Range.range + member EnclosingEntityKind: FSharpEnclosingEntityKind + member Glyph: FSharpGlyph + member IsAbstract: bool + member IsSingleTopLevel: bool + member Kind: FSharpNavigationDeclarationItemKind + member Name: string + member Range: Range.range + member UniqueName: string + member bodyRange: Range.range + + [] + type FSharpNavigationTopLevelDeclaration = + { Declaration: FSharpNavigationDeclarationItem + Nested: FSharpNavigationDeclarationItem [] } + [] + type FSharpNavigationItems = + + new: declarations:FSharpNavigationTopLevelDeclaration [] -> + FSharpNavigationItems + member Declarations: FSharpNavigationTopLevelDeclaration [] + + module NavigationImpl = + val unionRangesChecked: r1:Range.range -> r2:Range.range -> Range.range + val rangeOfDecls2: + f:('a -> FSharpNavigationDeclarationItem) -> decls:'a list -> Range.range + val rangeOfDecls: + ((FSharpNavigationDeclarationItem * int) list -> Range.range) + val moduleRange: + idm:Range.range -> + others:(FSharpNavigationDeclarationItem * 'a * 'b) list -> Range.range + val fldspecRange: fldspec:SyntaxTree.SynUnionCaseType -> Range.range + val bodyRange: + mb:Range.range -> + decls:(FSharpNavigationDeclarationItem * int) list -> Range.range + val getNavigationFromImplFile: + modules:SyntaxTree.SynModuleOrNamespace list -> FSharpNavigationItems + val getNavigationFromSigFile: + modules:SyntaxTree.SynModuleOrNamespaceSig list -> FSharpNavigationItems + + module FSharpNavigation = + val getNavigation: SyntaxTree.ParsedInput -> FSharpNavigationItems + val empty: FSharpNavigationItems + + module NavigateTo = + [] + type NavigableItemKind = + | Module + | ModuleAbbreviation + | Exception + | Type + | ModuleValue + | Field + | Property + | Constructor + | Member + | EnumCase + | UnionCase + with + override ToString: unit -> string + + [] + type ContainerType = + | File + | Namespace + | Module + | Type + | Exception + type Container = + { Type: ContainerType + Name: string } + type NavigableItem = + { Name: string + Range: Range.range + IsSignature: bool + Kind: NavigableItemKind + Container: Container } + val getNavigableItems: SyntaxTree.ParsedInput -> NavigableItem [] + + +namespace FSharp.Compiler.SourceCodeServices + [] + type FSharpNoteworthyParamInfoLocations = + + new: longId:string list * longIdRange:Range.range * + openParenLocation:Range.pos * tupleEndLocations:Range.pos list * + isThereACloseParen:bool * namedParamNames:string option list -> + FSharpNoteworthyParamInfoLocations + static member + Find: Range.pos * SyntaxTree.ParsedInput -> + FSharpNoteworthyParamInfoLocations option + member IsThereACloseParen: bool + member LongId: string list + member LongIdEndLocation: Range.pos + member LongIdStartLocation: Range.pos + member NamedParamNames: string option [] + member OpenParenLocation: Range.pos + member TupleEndLocations: Range.pos [] + + module internal NoteworthyParamInfoLocationsImpl = + val isStaticArg: SyntaxTree.SynType -> bool + val digOutIdentFromFuncExpr: + synExpr:SyntaxTree.SynExpr -> (string list * Range.range) option + type FindResult = + | Found of + openParen: Range.pos * + commasAndCloseParen: (Range.pos * string option) list * + hasClosedParen: bool + | NotFound + val digOutIdentFromStaticArg: SyntaxTree.SynType -> string option + val getNamedParamName: e:SyntaxTree.SynExpr -> string option + val getTypeName: synType:SyntaxTree.SynType -> string list + val handleSingleArg: + traverseSynExpr:(SyntaxTree.SynExpr -> 'a option) -> + pos:Range.pos * synExpr:SyntaxTree.SynExpr * parenRange:Range.range * + rpRangeOpt:'b option -> FindResult * 'c option + val searchSynArgExpr: + traverseSynExpr:(SyntaxTree.SynExpr -> 'a option) -> + pos:Range.pos -> + expr:SyntaxTree.SynExpr -> FindResult * 'a option option + val ( |StaticParameters|_| ): + pos:Range.pos -> + SyntaxTree.SynType -> FSharpNoteworthyParamInfoLocations option + val traverseInput: + pos:Range.pos * parseTree:SyntaxTree.ParsedInput -> + FSharpNoteworthyParamInfoLocations option + + module internal SynExprAppLocationsImpl = + val private searchSynArgExpr: + traverseSynExpr:(SyntaxTree.SynExpr -> 'a option) -> + expr:SyntaxTree.SynExpr -> + ranges:Range.range list -> Range.range list option * 'a option option + val getAllCurriedArgsAtPosition: + pos:Range.pos -> + parseTree:SyntaxTree.ParsedInput -> Range.range list option + + +namespace FSharp.Compiler.SourceCodeServices + module SourceFile = + val private compilableExtensions: string list + val private singleFileProjectExtensions: string list + val IsCompilable: string -> bool + val MustBeSingleFileProject: string -> bool + + module SourceFileImpl = + val IsInterfaceFile: string -> bool + val AdditionalDefinesForUseInEditor: isInteractive:bool -> string list + + type CompletionPath = string list * string option + [] + type InheritanceOrigin = + | Class + | Interface + | Unknown + [] + type InheritanceContext = + | Class + | Interface + | Unknown + [] + type RecordContext = + | CopyOnUpdate of Range.range * CompletionPath + | Constructor of string + | New of CompletionPath + [] + type CompletionContext = + | Invalid + | Inherit of InheritanceContext * CompletionPath + | RecordField of RecordContext + | RangeOperator + | ParameterList of Range.pos * System.Collections.Generic.HashSet + | AttributeApplication + | OpenDeclaration of isOpenType: bool + | PatternType + [] + type FSharpParseFileResults = + + new: errors:FSharpErrorInfo [] * input:SyntaxTree.ParsedInput option * + parseHadErrors:bool * dependencyFiles:string [] -> + FSharpParseFileResults + member + FindNoteworthyParamInfoLocations: pos:Range.pos -> + FSharpNoteworthyParamInfoLocations option + member + GetAllArgumentsForFunctionApplicationAtPostion: pos:Range.pos -> + Range.range list option + member GetNavigationItems: unit -> FSharpNavigationItems + member private GetNavigationItemsImpl: unit -> FSharpNavigationItems + member IsPosContainedInApplication: pos:Range.pos -> bool + member IsPositionContainedInACurriedParameter: pos:Range.pos -> bool + member + TryIdentOfPipelineContainingPosAndNumArgsApplied: pos:Range.pos -> + (SyntaxTree.Ident * + int) option + member TryRangeOfExprInYieldOrReturn: pos:Range.pos -> Range.range option + member + TryRangeOfFunctionOrMethodBeingApplied: pos:Range.pos -> + Range.range option + member + TryRangeOfParenEnclosingOpEqualsGreaterUsage: opGreaterEqualPos:Range.pos -> + (Range.range * + Range.range * + Range.range) option + member + TryRangeOfRecordExpressionContainingPos: pos:Range.pos -> + Range.range option + member + TryRangeOfRefCellDereferenceContainingPos: expressionPos:Range.pos -> + Range.range option + member ValidateBreakpointLocation: pos:Range.pos -> Range.range option + member + private ValidateBreakpointLocationImpl: pos:Range.pos -> + Range.range option + member DependencyFiles: string [] + member Errors: FSharpErrorInfo [] + member FileName: string + member ParseHadErrors: bool + member ParseTree: SyntaxTree.ParsedInput option + + type ModuleKind = + { IsAutoOpen: bool + HasModuleSuffix: bool } + [] + type EntityKind = + | Attribute + | Type + | FunctionOrValue of isActivePattern: bool + | Module of ModuleKind + with + override ToString: unit -> string + + module UntypedParseImpl = + val emptyStringSet: System.Collections.Generic.HashSet + val GetRangeOfExprLeftOfDot: + Range.pos * SyntaxTree.ParsedInput option -> Range.range option + val TryFindExpressionIslandInPosition: + Range.pos * SyntaxTree.ParsedInput option -> string option + val TryFindExpressionASTLeftOfDotLeftOfCursor: + Range.pos * SyntaxTree.ParsedInput option -> (Range.pos * bool) option + val GetEntityKind: Range.pos * SyntaxTree.ParsedInput -> EntityKind option + type internal TS = AstTraversal.TraverseStep + val insideAttributeApplicationRegex: System.Text.RegularExpressions.Regex + val TryGetCompletionContext: + Range.pos * SyntaxTree.ParsedInput * lineStr:string -> + CompletionContext option + val GetFullNameOfSmallestModuleOrNamespaceAtPoint: + SyntaxTree.ParsedInput * Range.pos -> string [] + + +namespace FSharp.Compiler.SourceCodeServices + type ShortIdent = string + type Idents = ShortIdent [] + type MaybeUnresolvedIdent = + { Ident: ShortIdent + Resolved: bool } + type MaybeUnresolvedIdents = MaybeUnresolvedIdent [] + type IsAutoOpen = bool + module Extensions = + type FSharpEntity with + member TryGetFullName: unit -> string option + type FSharpEntity with + member TryGetFullDisplayName: unit -> string option + type FSharpEntity with + member TryGetFullCompiledName: unit -> string option + type FSharpEntity with + member PublicNestedEntities: seq + type FSharpEntity with + member + TryGetMembersFunctionsAndValues: System.Collections.Generic.IList + type FSharpMemberOrFunctionOrValue with + member FullTypeSafe: FSharpType option + type FSharpMemberOrFunctionOrValue with + member TryGetFullDisplayName: unit -> string option + type FSharpMemberOrFunctionOrValue with + member TryGetFullCompiledOperatorNameIdents: unit -> Idents option + type FSharpAssemblySignature with + member TryGetEntities: unit -> seq + + [] + type LookupType = + | Fuzzy + | Precise + [] + type AssemblySymbol = + { FullName: string + CleanedIdents: Idents + Namespace: Idents option + NearestRequireQualifiedAccessParent: Idents option + TopRequireQualifiedAccessParent: Idents option + AutoOpenParent: Idents option + Symbol: FSharpSymbol + Kind: LookupType -> EntityKind + UnresolvedSymbol: UnresolvedSymbol } + with + override ToString: unit -> string + + type AssemblyPath = string + type AssemblyContentType = + | Public + | Full + type Parent = + { Namespace: Idents option + ThisRequiresQualifiedAccess: bool -> Idents option + TopRequiresQualifiedAccess: bool -> Idents option + AutoOpen: Idents option + WithModuleSuffix: Idents option + IsModule: bool } + with + static member + RewriteParentIdents: parentIdents:Idents option -> + idents:Idents -> Idents + member FixParentModuleSuffix: idents:Idents -> Idents + member + FormatEntityFullName: entity:FSharpEntity -> + (string * ShortIdent []) option + static member Empty: Parent + + type AssemblyContentCacheEntry = + { FileWriteTime: System.DateTime + ContentType: AssemblyContentType + Symbols: AssemblySymbol list } + [] + type IAssemblyContentCache = + interface + abstract member Set: AssemblyPath -> AssemblyContentCacheEntry -> unit + abstract member TryGet: AssemblyPath -> AssemblyContentCacheEntry option + + module AssemblyContentProvider = + val unresolvedSymbol: + topRequireQualifiedAccessParent:Idents option -> + cleanedIdents:Idents -> fullName:string -> UnresolvedSymbol + val createEntity: + ns:Idents option -> + parent:Parent -> entity:FSharpEntity -> AssemblySymbol option + val traverseMemberFunctionAndValues: + ns:Idents option -> + parent:Parent -> + membersFunctionsAndValues:seq -> + seq + val traverseEntity: + contentType:AssemblyContentType -> + parent:Parent -> entity:FSharpEntity -> seq + val getAssemblySignatureContent: + AssemblyContentType -> FSharpAssemblySignature -> AssemblySymbol list + val getAssemblySignaturesContent: + contentType:AssemblyContentType -> + assemblies:FSharpAssembly list -> AssemblySymbol list + val getAssemblyContent: + withCache:((IAssemblyContentCache -> AssemblySymbol list) -> + AssemblySymbol list) -> + contentType:AssemblyContentType -> + fileName:string option -> + assemblies:FSharpAssembly list -> AssemblySymbol list + + type EntityCache = + + interface IAssemblyContentCache + new: unit -> EntityCache + member Clear: unit -> unit + member Locking: (IAssemblyContentCache -> 'T) -> 'T + + type StringLongIdent = string + type Entity = + { FullRelativeName: StringLongIdent + Qualifier: StringLongIdent + Namespace: StringLongIdent option + Name: StringLongIdent + LastIdent: string } + with + override ToString: unit -> string + + module Entity = + val getRelativeNamespace: targetNs:Idents -> sourceNs:Idents -> Idents + val cutAutoOpenModules: + autoOpenParent:Idents option -> candidateNs:Idents -> ShortIdent [] + val tryCreate: + targetNamespace:Idents option * targetScope:Idents * + partiallyQualifiedName:MaybeUnresolvedIdents * + requiresQualifiedAccessParent:Idents option * autoOpenParent:Idents option * + candidateNamespace:Idents option * candidate:Idents -> Entity [] + + type ScopeKind = + | Namespace + | TopModule + | NestedModule + | OpenDeclaration + | HashDirective + with + override ToString: unit -> string + + type InsertContext = + { ScopeKind: ScopeKind + Pos: Range.pos } + type Module = + { Idents: Idents + Range: Range.range } + type OpenStatementInsertionPoint = + | TopLevel + | Nearest + module ParsedInput = + val ( |Sequentials|_| ): + _arg1:SyntaxTree.SynExpr -> SyntaxTree.SynExpr list option + val ( |ConstructorPats| ): + _arg1:SyntaxTree.SynArgPats -> SyntaxTree.SynPat list + val getLongIdents: + input:SyntaxTree.ParsedInput option -> + System.Collections.Generic.IDictionary + val getLongIdentAt: + ast:SyntaxTree.ParsedInput -> pos:Range.pos -> SyntaxTree.LongIdent option + type Scope = + { Idents: Idents + Kind: ScopeKind } + val tryFindNearestPointAndModules: + currentLine:int -> + ast:SyntaxTree.ParsedInput -> + insertionPoint:OpenStatementInsertionPoint -> + (Scope * string [] option * Range.pos) option * Module list + val findBestPositionToInsertOpenDeclaration: + modules:Module list -> + scope:Scope -> pos:Range.pos -> entity:Idents -> InsertContext + val tryFindInsertionContext: + currentLine:int -> + ast:SyntaxTree.ParsedInput -> + MaybeUnresolvedIdents -> + insertionPoint:OpenStatementInsertionPoint -> + (Idents option * Idents option * Idents option * Idents -> + (Entity * InsertContext) []) + val adjustInsertionPoint: + getLineStr:(int -> string) -> ctx:InsertContext -> Range.pos + val findNearestPointToInsertOpenDeclaration: + currentLine:int -> + ast:SyntaxTree.ParsedInput -> + entity:Idents -> + insertionPoint:OpenStatementInsertionPoint -> InsertContext + + +namespace FSharp.Compiler.SourceCodeServices + type XmlDocable = + | XmlDocable of line: int * indent: int * paramNames: string list + module XmlDocParsing = + val ( |ConstructorPats| ): + _arg1:SyntaxTree.SynArgPats -> SyntaxTree.SynPat list + val digNamesFrom: pat:SyntaxTree.SynPat -> string list + val getXmlDocablesImpl: + sourceText:Text.ISourceText * input:SyntaxTree.ParsedInput option -> + XmlDocable list + + module XmlDocComment = + val private ws: s:string * pos:int -> (string * int) option + val private str: + prefix:string -> s:string * pos:int -> (string * int) option + val private eol: s:string * pos:'a -> (string * 'a) option + val inline private ( >=> ): + f:('a -> 'b option) -> g:('b -> 'c option) -> ('a -> 'c option) + val isBlank: string -> int option + + module XmlDocParser = + val getXmlDocables: + Text.ISourceText * input:SyntaxTree.ParsedInput option -> XmlDocable list + + +namespace FSharp.Compiler.SourceCodeServices + module private Option = + val ofOptionList: xs:'a option list -> 'a list option + + [] + type ExternalType = + | Type of fullName: string * genericArgs: ExternalType list + | Array of inner: ExternalType + | Pointer of inner: ExternalType + | TypeVar of typeName: string + with + override ToString: unit -> string + + module ExternalType = + val internal tryOfILType: + string array -> AbstractIL.IL.ILType -> ExternalType option + + [] + type ParamTypeSymbol = + | Param of ExternalType + | Byref of ExternalType + with + override ToString: unit -> string + + module ParamTypeSymbol = + val internal tryOfILType: + string array -> AbstractIL.IL.ILType -> ParamTypeSymbol option + val internal tryOfILTypes: + string array -> AbstractIL.IL.ILType list -> ParamTypeSymbol list option + + [] + type ExternalSymbol = + | Type of fullName: string + | Constructor of typeName: string * args: ParamTypeSymbol list + | Method of + typeName: string * name: string * paramSyms: ParamTypeSymbol list * + genericArity: int + | Field of typeName: string * name: string + | Event of typeName: string * name: string + | Property of typeName: string * name: string + with + member internal ToDebuggerDisplay: unit -> string + override ToString: unit -> string + + +namespace FSharp.Compiler + type PartialLongName = + { QualifyingIdents: string list + PartialIdent: string + EndColumn: int + LastDotPos: int option } + with + static member Empty: endColumn:int -> PartialLongName + + module QuickParse = + val MagicalAdjustmentConstant: int + val CorrectIdentifierToken: tokenText:string -> tokenTag:int -> int + val isValidStrippedName: name:System.ReadOnlySpan -> idx:int -> bool + val private isValidActivePatternName: name:string -> bool + val GetCompleteIdentifierIslandImpl: + lineStr:string -> index:int -> (string * int * bool) option + val GetCompleteIdentifierIsland: + tolerateJustAfter:bool -> + tokenText:string -> index:int -> (string * int * bool) option + val private defaultName: 'a list * string + val GetPartialLongName: lineStr:string * index:int -> string list * string + type private EatCommentCallContext = + | SkipWhiteSpaces of + ident: string * current: string list * throwAwayNext: bool + | StartIdentifier of current: string list * throwAway: bool + val GetPartialLongNameEx: lineStr:string * index:int -> PartialLongName + val TokenNameEquals: + tokenInfo:SourceCodeServices.FSharpTokenInfo -> token2:string -> bool + val private expected: string [] list + val TestMemberOrOverrideDeclaration: + tokens:SourceCodeServices.FSharpTokenInfo [] -> bool + + +namespace FSharp.Compiler.SourceCodeServices + module internal FSharpCheckerResultsSettings = + val getToolTipTextSize: int + val maxTypeCheckErrorsOutOfProjectContext: int + val maxTimeShareMilliseconds: int64 + val defaultFSharpBinariesDir: string + + [] + type FSharpFindDeclFailureReason = + | Unknown of message: string + | NoSourceCode + | ProvidedType of string + | ProvidedMember of string + [] + type FSharpFindDeclResult = + | DeclNotFound of FSharpFindDeclFailureReason + | DeclFound of Range.range + | ExternalDecl of assembly: string * externalSym: ExternalSymbol + [] + type internal NameResResult = + | Members of + (NameResolution.ItemWithInst list * TypedTreeOps.DisplayEnv * Range.range) + | Cancel of TypedTreeOps.DisplayEnv * Range.range + | Empty + [] + type ResolveOverloads = + | Yes + | No + [] + type GetPreciseCompletionListFromExprTypingsResult = + | NoneBecauseTypecheckIsStaleAndTextChanged + | NoneBecauseThereWereTypeErrors + | None + | Some of + (NameResolution.ItemWithInst list * TypedTreeOps.DisplayEnv * Range.range) * + TypedTree.TType + type Names = string list + [] + type internal TypeCheckInfo = + + new: _sTcConfig:CompilerConfig.TcConfig * g:TcGlobals.TcGlobals * + ccuSigForFile:TypedTree.ModuleOrNamespaceType * + thisCcu:TypedTree.CcuThunk * tcImports:CompilerImports.TcImports * + tcAccessRights:AccessibilityLogic.AccessorDomain * + projectFileName:string * mainInputFileName:string * + sResolutions:NameResolution.TcResolutions * + sSymbolUses:NameResolution.TcSymbolUses * + sFallback:NameResolution.NameResolutionEnv * + loadClosure:ScriptClosure.LoadClosure option * + implFileOpt:TypedTree.TypedImplFile option * + openDeclarations:NameResolution.OpenDeclaration [] -> TypeCheckInfo + member + GetBestDisplayEnvForPos: cursorPos:Range.pos -> + (NameResolution.NameResolutionEnv * + AccessibilityLogic.AccessorDomain) * + Range.range + member + GetDeclarationListSymbols: parseResultsOpt:FSharpParseFileResults option * + line:int * lineStr:string * + partialName:PartialLongName * + getAllEntities:(unit -> AssemblySymbol list) -> + FSharpSymbolUse list list + member + GetDeclarationLocation: line:int * lineStr:string * colAtEndOfNames:int * + names:string list * preferFlag:bool option -> + FSharpFindDeclResult + member + GetDeclarations: parseResultsOpt:FSharpParseFileResults option * + line:int * lineStr:string * + partialName:PartialLongName * + getAllEntities:(unit -> AssemblySymbol list) -> + FSharpDeclarationListInfo + member + GetF1Keyword: line:int * lineStr:string * colAtEndOfNames:int * + names:string list -> string option + member + GetFormatSpecifierLocationsAndArity: unit -> (Range.range * int) [] + member + GetMethods: line:int * lineStr:string * colAtEndOfNames:int * + namesOpt:string list option -> FSharpMethodGroup + member + GetMethodsAsSymbols: line:int * lineStr:string * colAtEndOfNames:int * + names:string list -> + (FSharpSymbol list * TypedTreeOps.DisplayEnv * + Range.range) option + member + GetReferenceResolutionStructuredToolTipText: line:int * col:int -> + FSharpToolTipText + member GetReferencedAssemblies: unit -> FSharpAssembly list + member + GetSemanticClassification: range:Range.range option -> + + (Range.range * + SemanticClassificationType) [] + member + GetStructuredToolTipText: line:int * lineStr:string * + colAtEndOfNames:int * names:string list -> + FSharpToolTipText + member + GetSymbolUseAtLocation: line:int * lineStr:string * colAtEndOfNames:int * + names:string list -> + (FSharpSymbol * TypedTreeOps.DisplayEnv * + Range.range) option + member + GetVisibleNamespacesAndModulesAtPosition: cursorPos:Range.pos -> + TypedTree.ModuleOrNamespaceRef list + member + IsRelativeNameResolvable: cursorPos:Range.pos * plid:string list * + item:NameResolution.Item -> bool + member + IsRelativeNameResolvableFromSymbol: cursorPos:Range.pos * + plid:string list * + symbol:FSharpSymbol -> bool + override ToString: unit -> string + member AccessRights: AccessibilityLogic.AccessorDomain + member CcuSigForFile: TypedTree.ModuleOrNamespaceType + member ImplementationFile: TypedTree.TypedImplFile option + member OpenDeclarations: NameResolution.OpenDeclaration [] + member PartialAssemblySignatureForFile: FSharpAssemblySignature + member ScopeResolutions: NameResolution.TcResolutions + member ScopeSymbolUses: NameResolution.TcSymbolUses + member SymbolEnv: SymbolEnv + member TcGlobals: TcGlobals.TcGlobals + member TcImports: CompilerImports.TcImports + member ThisCcu: TypedTree.CcuThunk + + type FSharpParsingOptions = + { SourceFiles: string [] + ConditionalCompilationDefines: string list + ErrorSeverityOptions: ErrorLogger.FSharpErrorSeverityOptions + IsInteractive: bool + LightSyntax: bool option + CompilingFsLib: bool + IsExe: bool } + with + static member + FromTcConfig: tcConfig:CompilerConfig.TcConfig * sourceFiles:string [] * + isInteractive:bool -> FSharpParsingOptions + static member + FromTcConfigBuilder: tcConfigB:CompilerConfig.TcConfigBuilder * + sourceFiles:string [] * isInteractive:bool -> + FSharpParsingOptions + member LastFileName: string + static member Default: FSharpParsingOptions + + module internal ParseAndCheckFile = + type ErrorHandler = + + new: reportErrors:bool * mainInputFileName:string * + errorSeverityOptions:ErrorLogger.FSharpErrorSeverityOptions * + sourceText:Text.ISourceText * suggestNamesForErrors:bool -> + ErrorHandler + member AnyErrors: bool + member CollectedDiagnostics: FSharpErrorInfo [] + member ErrorCount: int + member ErrorLogger: ErrorLogger.ErrorLogger + member + ErrorSeverityOptions: ErrorLogger.FSharpErrorSeverityOptions with set + + val getLightSyntaxStatus: + fileName:string -> + options:FSharpParsingOptions -> Lexhelp.LightSyntaxStatus + val createLexerFunction: + fileName:string -> + options:FSharpParsingOptions -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + errHandler:ErrorHandler -> ('a -> Parser.token) + val isFeatureSupported: _featureId:Features.LanguageFeature -> bool + val createLexbuf: sourceText:Text.ISourceText -> UnicodeLexing.Lexbuf + val matchBraces: + sourceText:Text.ISourceText * fileName:string * + options:FSharpParsingOptions * userOpName:string * + suggestNamesForErrors:bool -> (Range.range * Range.range) [] + val parseFile: + sourceText:Text.ISourceText * fileName:string * + options:FSharpParsingOptions * userOpName:string * + suggestNamesForErrors:bool -> + FSharpErrorInfo [] * SyntaxTree.ParsedInput option * bool + val ApplyLoadClosure: + tcConfig:CompilerConfig.TcConfig * parsedMainInput:SyntaxTree.ParsedInput * + mainInputFileName:string * loadClosure:ScriptClosure.LoadClosure option * + tcImports:CompilerImports.TcImports * + backgroundDiagnostics:(ErrorLogger.PhasedDiagnostic * FSharpErrorSeverity) [] -> + unit + val CheckOneFile: + parseResults:FSharpParseFileResults * sourceText:Text.ISourceText * + mainInputFileName:string * projectFileName:string * + tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * + tcImports:CompilerImports.TcImports * tcState:ParseAndCheckInputs.TcState * + moduleNamesDict:ParseAndCheckInputs.ModuleNamesDict * + loadClosure:ScriptClosure.LoadClosure option * + backgroundDiagnostics:(ErrorLogger.PhasedDiagnostic * FSharpErrorSeverity) [] * + reactorOps:IReactorOperations * userOpName:string * + suggestNamesForErrors:bool -> + Async> + + [] + type FSharpProjectContext = + + new: thisCcu:TypedTree.CcuThunk * assemblies:FSharpAssembly list * + ad:AccessibilityLogic.AccessorDomain -> FSharpProjectContext + member GetReferencedAssemblies: unit -> FSharpAssembly list + member AccessibilityRights: FSharpAccessibilityRights + + [] + type FSharpCheckFileResults = + + new: filename:string * errors:FSharpErrorInfo [] * + scopeOptX:TypeCheckInfo option * dependencyFiles:string [] * + builderX:IncrementalBuilder option * keepAssemblyContents:bool -> + FSharpCheckFileResults + static member + CheckOneFile: parseResults:FSharpParseFileResults * + sourceText:Text.ISourceText * mainInputFileName:string * + projectFileName:string * tcConfig:CompilerConfig.TcConfig * + tcGlobals:TcGlobals.TcGlobals * + tcImports:CompilerImports.TcImports * + tcState:ParseAndCheckInputs.TcState * + moduleNamesDict:ParseAndCheckInputs.ModuleNamesDict * + loadClosure:ScriptClosure.LoadClosure option * + backgroundDiagnostics:(ErrorLogger.PhasedDiagnostic * + FSharpErrorSeverity) [] * + reactorOps:IReactorOperations * userOpName:string * + isIncompleteTypeCheckEnvironment:bool * + builder:IncrementalBuilder * dependencyFiles:string [] * + creationErrors:FSharpErrorInfo [] * + parseErrors:FSharpErrorInfo [] * + keepAssemblyContents:bool * suggestNamesForErrors:bool -> + Async + static member + JoinErrors: isIncompleteTypeCheckEnvironment:bool * + creationErrors:FSharpErrorInfo [] * + parseErrors:FSharpErrorInfo [] * + tcErrors:FSharpErrorInfo [] -> FSharpErrorInfo [] + static member + Make: mainInputFileName:string * projectFileName:string * + tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * + isIncompleteTypeCheckEnvironment:bool * + builder:IncrementalBuilder * dependencyFiles:string [] * + creationErrors:FSharpErrorInfo [] * + parseErrors:FSharpErrorInfo [] * tcErrors:FSharpErrorInfo [] * + keepAssemblyContents:bool * + ccuSigForFile:TypedTree.ModuleOrNamespaceType * + thisCcu:TypedTree.CcuThunk * tcImports:CompilerImports.TcImports * + tcAccessRights:AccessibilityLogic.AccessorDomain * + sResolutions:NameResolution.TcResolutions * + sSymbolUses:NameResolution.TcSymbolUses * + sFallback:NameResolution.NameResolutionEnv * + loadClosure:ScriptClosure.LoadClosure option * + implFileOpt:TypedTree.TypedImplFile option * + openDeclarations:NameResolution.OpenDeclaration [] -> + FSharpCheckFileResults + static member + MakeEmpty: filename:string * creationErrors:FSharpErrorInfo [] * + keepAssemblyContents:bool -> FSharpCheckFileResults + member + GetAllUsesOfAllSymbolsInFile: ?cancellationToken:System.Threading.CancellationToken -> + seq + member + GetDeclarationListInfo: parsedFileResults:FSharpParseFileResults option * + line:int * lineText:string * + partialName:PartialLongName * + ?getAllEntities:(unit -> AssemblySymbol list) -> + FSharpDeclarationListInfo + member + GetDeclarationListSymbols: parsedFileResults:FSharpParseFileResults option * + line:int * lineText:string * + partialName:PartialLongName * + ?getAllEntities:(unit -> AssemblySymbol list) -> + FSharpSymbolUse list list + member + GetDeclarationLocation: line:int * colAtEndOfNames:int * + lineText:string * names:string list * + ?preferFlag:bool -> FSharpFindDeclResult + member + GetDisplayContextForPos: cursorPos:Range.pos -> + FSharpDisplayContext option + member + GetF1Keyword: line:int * colAtEndOfNames:int * lineText:string * + names:string list -> string option + [] + member GetFormatSpecifierLocations: unit -> Range.range [] + member + GetFormatSpecifierLocationsAndArity: unit -> (Range.range * int) [] + member + GetMethods: line:int * colAtEndOfNames:int * lineText:string * + names:string list option -> FSharpMethodGroup + member + GetMethodsAsSymbols: line:int * colAtEndOfNames:int * lineText:string * + names:string list -> FSharpSymbolUse list option + member + GetSemanticClassification: Range.range option -> + + (Range.range * + SemanticClassificationType) [] + member + GetStructuredToolTipText: line:int * colAtEndOfNames:int * + lineText:string * names:string list * + tokenTag:int -> FSharpToolTipText + member + GetSymbolAtLocation: line:int * colAtEndOfNames:int * lineStr:string * + names:string list -> FSharpSymbol option + member + GetSymbolUseAtLocation: line:int * colAtEndOfNames:int * + lineText:string * names:string list -> + FSharpSymbolUse option + member + GetToolTipText: line:int * colAtEndOfNames:int * lineText:string * + names:string list * tokenTag:int -> FSharpToolTipText + member + GetUsesOfSymbolInFile: symbol:FSharpSymbol * + ?cancellationToken:System.Threading.CancellationToken -> + FSharpSymbolUse [] + member + GetVisibleNamespacesAndModulesAtPoint: Range.pos -> + TypedTree.ModuleOrNamespaceRef [] + member + IsRelativeNameResolvable: cursorPos:Range.pos * plid:string list * + item:NameResolution.Item -> bool + member + IsRelativeNameResolvableFromSymbol: cursorPos:Range.pos * + plid:string list * + symbol:FSharpSymbol -> bool + override ToString: unit -> string + member TryGetCurrentTcImports: unit -> CompilerImports.TcImports option + member DependencyFiles: string [] + member Errors: FSharpErrorInfo [] + member HasFullTypeCheckInfo: bool + member ImplementationFile: FSharpImplementationFileContents option + member OpenDeclarations: FSharpOpenDeclaration [] + member PartialAssemblySignature: FSharpAssemblySignature + member ProjectContext: FSharpProjectContext + + [] + and FSharpCheckFileAnswer = + | Aborted + | Succeeded of FSharpCheckFileResults + [] + type FSharpCheckProjectResults = + + new: projectFileName:string * + tcConfigOption:CompilerConfig.TcConfig option * + keepAssemblyContents:bool * errors:FSharpErrorInfo [] * + details:(TcGlobals.TcGlobals * CompilerImports.TcImports * + TypedTree.CcuThunk * TypedTree.ModuleOrNamespaceType * + NameResolution.TcSymbolUses list * + CheckDeclarations.TopAttribs option * + CompilerConfig.IRawFSharpAssemblyData option * + AbstractIL.IL.ILAssemblyRef * + AccessibilityLogic.AccessorDomain * + TypedTree.TypedImplFile list option * string []) option -> + FSharpCheckProjectResults + member + GetAllUsesOfAllSymbols: ?cancellationToken:System.Threading.CancellationToken -> + FSharpSymbolUse [] + member GetOptimizedAssemblyContents: unit -> FSharpAssemblyContents + member + GetUsesOfSymbol: symbol:FSharpSymbol * + ?cancellationToken:System.Threading.CancellationToken -> + FSharpSymbolUse [] + override ToString: unit -> string + member AssemblyContents: FSharpAssemblyContents + member AssemblyFullName: string + member AssemblySignature: FSharpAssemblySignature + member DependencyFiles: string [] + member Errors: FSharpErrorInfo [] + member HasCriticalErrors: bool + member ProjectContext: FSharpProjectContext + member + RawFSharpAssemblyData: CompilerConfig.IRawFSharpAssemblyData option + member + TypedImplementationFiles: TcGlobals.TcGlobals * TypedTree.CcuThunk * + CompilerImports.TcImports * + TypedTree.TypedImplFile list + + type FsiInteractiveChecker = + + new: ReferenceResolver.Resolver * ops:IReactorOperations * + tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * + tcImports:CompilerImports.TcImports * + tcState:ParseAndCheckInputs.TcState -> FsiInteractiveChecker + member + ParseAndCheckInteraction: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + sourceText:Text.ISourceText * + ?userOpName:string -> + Async + + +namespace FSharp.Compiler.SourceCodeServices + type internal Layout = Internal.Utilities.StructuredFormat.Layout + module EnvMisc = + val braceMatchCacheSize: int + val parseFileCacheSize: int + val checkFileInProjectCacheSize: int + val projectCacheSizeDefault: int + val frameworkTcImportsCacheStrongSize: int + val maxMBDefault: int + + type UnresolvedReferencesSet = + | UnresolvedReferencesSet of CompilerConfig.UnresolvedAssemblyReference list + type FSharpProjectOptions = + { ProjectFileName: string + ProjectId: string option + SourceFiles: string [] + OtherOptions: string [] + ReferencedProjects: (string * FSharpProjectOptions) [] + IsIncompleteTypeCheckEnvironment: bool + UseScriptResolutionRules: bool + LoadTime: System.DateTime + UnresolvedReferences: UnresolvedReferencesSet option + OriginalLoadReferences: (Range.range * string * string) list + ExtraProjectInfo: obj option + Stamp: int64 option } + with + static member + AreSameForChecking: options1:FSharpProjectOptions * + options2:FSharpProjectOptions -> bool + static member + UseSameProject: options1:FSharpProjectOptions * + options2:FSharpProjectOptions -> bool + override ToString: unit -> string + member ProjectDirectory: string + member ProjectOptions: string [] + + [] + type IsResultObsolete = | IsResultObsolete of (unit -> bool) + module Helpers = + val AreSameForChecking2: + (string * FSharpProjectOptions) * (string * FSharpProjectOptions) -> bool + val AreSubsumable2: + (string * FSharpProjectOptions) * (string * FSharpProjectOptions) -> bool + val AreSameForParsing: + (string * int * 'a) * (string * int * 'a) -> bool when 'a: equality + val AreSimilarForParsing: + ('a * 'b * 'c) * ('a * 'd * 'e) -> bool when 'a: equality + val AreSameForChecking3: + (string * int * FSharpProjectOptions) * + (string * int * FSharpProjectOptions) -> bool + val AreSubsumable3: + (string * 'a * FSharpProjectOptions) * + (string * 'b * FSharpProjectOptions) -> bool + + module CompileHelpers = + val mkCompilationErrorHandlers: + unit -> + ResizeArray * ErrorLogger.ErrorLogger * + Driver.ErrorLoggerProvider + val tryCompile: + errorLogger:ErrorLogger.ErrorLogger -> + f:(ErrorLogger.Exiter -> unit) -> int + val compileFromArgs: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * argv:string [] * + legacyReferenceResolver:ReferenceResolver.Resolver * + tcImportsCapture:(CompilerImports.TcImports -> unit) option * + dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * + AbstractIL.IL.ILModuleDef -> unit) option -> + FSharpErrorInfo [] * int + val compileFromAsts: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + legacyReferenceResolver:ReferenceResolver.Resolver * + asts:SyntaxTree.ParsedInput list * assemblyName:string * outFile:string * + dependencies:string list * noframework:bool * pdbFile:string option * + executable:bool option * + tcImportsCapture:(CompilerImports.TcImports -> unit) option * + dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * + AbstractIL.IL.ILModuleDef -> unit) option -> + FSharpErrorInfo [] * int + val createDynamicAssembly: + ctok:AbstractIL.Internal.Library.CompilationThreadToken * debugInfo:bool * + tcImportsRef:CompilerImports.TcImports option ref * execute:bool * + assemblyBuilderRef:System.Reflection.Emit.AssemblyBuilder option ref -> + tcGlobals:TcGlobals.TcGlobals * outfile:string * + ilxMainModule:AbstractIL.IL.ILModuleDef -> unit + val setOutputStreams: + execute:(#System.IO.TextWriter * #System.IO.TextWriter) option -> unit + + type SourceTextHash = int + type FileName = string + type FilePath = string + type ProjectPath = string + type FileVersion = int + type ParseCacheLockToken = + + interface AbstractIL.Internal.Library.LockToken + new: unit -> ParseCacheLockToken + + type ScriptClosureCacheToken = + + interface AbstractIL.Internal.Library.LockToken + new: unit -> ScriptClosureCacheToken + + type BackgroundCompiler = + + new: legacyReferenceResolver:ReferenceResolver.Resolver * + projectCacheSize:int * keepAssemblyContents:bool * + keepAllBackgroundResolutions:bool * + tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * + suggestNamesForErrors:bool * keepAllBackgroundSymbolUses:bool * + enableBackgroundItemKeyStoreAndSemanticClassification:bool * + enablePartialTypeChecking:bool -> BackgroundCompiler + member + CheckFileInProject: parseResults:FSharpParseFileResults * + filename:string * fileVersion:int * + sourceText:Text.ISourceText * + options:FSharpProjectOptions * userOpName:string -> + Async + member + CheckFileInProjectAllowingStaleCachedResults: parseResults:FSharpParseFileResults * + filename:string * + fileVersion:int * + sourceText:Text.ISourceText * + options:FSharpProjectOptions * + userOpName:string -> + Async + member + private CheckOneFileImpl: parseResults:FSharpParseFileResults * + sourceText:Text.ISourceText * fileName:string * + options:FSharpProjectOptions * + fileVersion:int * builder:IncrementalBuilder * + tcConfig:CompilerConfig.TcConfig * + tcGlobals:TcGlobals.TcGlobals * + tcImports:CompilerImports.TcImports * + tcDependencyFiles:string list * + timeStamp:System.DateTime * + prevTcState:ParseAndCheckInputs.TcState * + prevModuleNamesDict:ParseAndCheckInputs.ModuleNamesDict * + prevTcErrors:(ErrorLogger.PhasedDiagnostic * + FSharpErrorSeverity) [] * + creationErrors:FSharpErrorInfo [] * + userOpName:string -> + Async + member + CheckProjectInBackground: options:FSharpProjectOptions * + userOpName:string -> unit + member + ClearCache: options:seq * userOpName:string -> + unit + member ClearCachesAsync: userOpName:string -> Async + member CompleteAllQueuedOps: unit -> unit + member DownsizeCaches: userOpName:string -> Async + member + FindReferencesInFile: filename:string * options:FSharpProjectOptions * + symbol:FSharpSymbol * canInvalidateProject:bool * + userOpName:string -> Async> + member + GetAssemblyData: options:FSharpProjectOptions * + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + userOpName:string -> + AbstractIL.Internal.Library.Cancellable + member + GetBackgroundCheckResultsForFileInProject: filename:string * + options:FSharpProjectOptions * + userOpName:string -> + Async + member + GetBackgroundParseResultsForFileInProject: filename:string * + options:FSharpProjectOptions * + userOpName:string -> + Async + member + GetCachedCheckFileResult: builder:IncrementalBuilder * + filename:FileName * + sourceText:Text.ISourceText * + options:FSharpProjectOptions -> + (FSharpParseFileResults * + FSharpCheckFileResults) option + member + GetProjectOptionsFromScript: filename:string * + sourceText:Text.ISourceText * + previewEnabled:bool option * + loadedTimeStamp:System.DateTime option * + otherFlags:string [] option * + useFsiAuxLib:bool option * + useSdkRefs:bool option * + assumeDotNetFramework:bool option * + extraProjectInfo:obj option * + optionsStamp:int64 option * + userOpName:string -> + Async + member + GetSemanticClassificationForFile: filename:string * + options:FSharpProjectOptions * + userOpName:string -> + Async + member + ImplicitlyStartCheckProjectInBackground: options:FSharpProjectOptions * + userOpName:string -> unit + member + InvalidateConfiguration: options:FSharpProjectOptions * + startBackgroundCompileIfAlreadySeen:bool option * + userOpName:string -> unit + member + NotifyProjectCleaned: options:FSharpProjectOptions * userOpName:string -> + Async + member + ParseAndCheckFileInProject: filename:string * fileVersion:int * + sourceText:Text.ISourceText * + options:FSharpProjectOptions * + userOpName:string -> + Async + member + ParseAndCheckProject: options:FSharpProjectOptions * userOpName:string -> + Async + member + private ParseAndCheckProjectImpl: options:FSharpProjectOptions * + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + userOpName:string -> + AbstractIL.Internal.Library.Cancellable + member + ParseFile: filename:string * sourceText:Text.ISourceText * + options:FSharpParsingOptions * userOpName:string -> + Async + member + ParseFileNoCache: filename:string * sourceText:Text.ISourceText * + options:FSharpParsingOptions * userOpName:string -> + Async + member + RecordTypeCheckFileInProjectResults: filename:string * + options:FSharpProjectOptions * + parsingOptions:FSharpParsingOptions * + parseResults:FSharpParseFileResults * + fileVersion:int * + priorTimeStamp:System.DateTime * + checkAnswer:FSharpCheckFileAnswer option * + sourceText:SourceTextHash -> unit + member StopBackgroundCompile: unit -> unit + member + private TryGetLogicalTimeStampForProject: cache:CompilerConfig.TimeStampCache * + ctok:AbstractIL.Internal.Library.CompilationThreadToken * + options:FSharpProjectOptions * + userOpName:string -> + System.DateTime option + member + TryGetRecentCheckResultsForFile: filename:string * + options:FSharpProjectOptions * + sourceText:Text.ISourceText option * + _userOpName:string -> + (FSharpParseFileResults * + FSharpCheckFileResults * + FileVersion) option + member WaitForBackgroundCompile: unit -> unit + member BeforeBackgroundFileCheck: IEvent + member CurrentQueueLength: int + member FileChecked: IEvent + member FileParsed: IEvent + member FrameworkImportsCache: FrameworkImportsCache + member ImplicitlyStartBackgroundWork: bool + member ProjectChecked: IEvent + member Reactor: Reactor + member ReactorOps: IReactorOperations + static member GlobalForegroundParseCountStatistic: int + static member GlobalForegroundTypeCheckCountStatistic: int + + [] + type FSharpChecker = + + new: legacyReferenceResolver:ReferenceResolver.Resolver * + projectCacheSize:int * keepAssemblyContents:bool * + keepAllBackgroundResolutions:bool * + tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * + suggestNamesForErrors:bool * keepAllBackgroundSymbolUses:bool * + enableBackgroundItemKeyStoreAndSemanticClassification:bool * + enablePartialTypeChecking:bool -> FSharpChecker + static member + Create: ?projectCacheSize:int * ?keepAssemblyContents:bool * + ?keepAllBackgroundResolutions:bool * + ?legacyReferenceResolver:ReferenceResolver.Resolver * + ?tryGetMetadataSnapshot:(string * System.DateTime -> + AbstractIL.ILBinaryReader.ILReaderMetadataSnapshot option) * + ?suggestNamesForErrors:bool * ?keepAllBackgroundSymbolUses:bool * + ?enableBackgroundItemKeyStoreAndSemanticClassification:bool * + ?enablePartialTypeChecking:bool -> FSharpChecker + member + CheckFileInProject: parseResults:FSharpParseFileResults * + filename:string * fileVersion:int * + sourceText:Text.ISourceText * + options:FSharpProjectOptions * ?userOpName:string -> + Async + [] + member + CheckFileInProjectAllowingStaleCachedResults: parseResults:FSharpParseFileResults * + filename:string * + fileVersion:int * + source:string * + options:FSharpProjectOptions * + ?userOpName:string -> + Async + member CheckMaxMemoryReached: unit -> unit + member + CheckProjectInBackground: options:FSharpProjectOptions * + ?userOpName:string -> unit + member + ClearCache: options:seq * ?userOpName:string -> + unit + member ClearCaches: ?userOpName:string -> unit + member ClearCachesAsync: ?userOpName:string -> Async + member + ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients: unit -> + unit + member + Compile: argv:string [] * ?userOpName:string -> + Async + member + Compile: ast:SyntaxTree.ParsedInput list * assemblyName:string * + outFile:string * dependencies:string list * ?pdbFile:string * + ?executable:bool * ?noframework:bool * ?userOpName:string -> + Async + member + CompileToDynamicAssembly: otherFlags:string [] * + execute:(System.IO.TextWriter * + System.IO.TextWriter) option * + ?userOpName:string -> + Async + member + CompileToDynamicAssembly: ast:SyntaxTree.ParsedInput list * + assemblyName:string * + dependencies:string list * + execute:(System.IO.TextWriter * + System.IO.TextWriter) option * + ?debug:bool * ?noframework:bool * + ?userOpName:string -> + Async + member + FindBackgroundReferencesInFile: filename:string * + options:FSharpProjectOptions * + symbol:FSharpSymbol * + ?canInvalidateProject:bool * + ?userOpName:string -> + Async> + member + GetBackgroundCheckResultsForFileInProject: filename:string * + options:FSharpProjectOptions * + ?userOpName:string -> + Async + member + GetBackgroundParseResultsForFileInProject: filename:string * + options:FSharpProjectOptions * + ?userOpName:string -> + Async + member + GetBackgroundSemanticClassificationForFile: filename:string * + options:FSharpProjectOptions * + ?userOpName:string -> + Async + member + GetParsingOptionsFromCommandLineArgs: argv:string list * + ?isInteractive:bool -> + FSharpParsingOptions * + FSharpErrorInfo list + member + GetParsingOptionsFromCommandLineArgs: sourceFiles:string list * + argv:string list * + ?isInteractive:bool -> + FSharpParsingOptions * + FSharpErrorInfo list + member + GetParsingOptionsFromProjectOptions: options:FSharpProjectOptions -> + FSharpParsingOptions * + FSharpErrorInfo list + member + GetProjectOptionsFromCommandLineArgs: projectFileName:string * + argv:string [] * + ?loadedTimeStamp:System.DateTime * + ?extraProjectInfo:obj -> + FSharpProjectOptions + member + GetProjectOptionsFromScript: filename:string * source:Text.ISourceText * + ?previewEnabled:bool * + ?loadedTimeStamp:System.DateTime * + ?otherFlags:string [] * ?useFsiAuxLib:bool * + ?useSdkRefs:bool * + ?assumeDotNetFramework:bool * + ?extraProjectInfo:obj * + ?optionsStamp:int64 * ?userOpName:string -> + Async + member InvalidateAll: unit -> unit + member + InvalidateConfiguration: options:FSharpProjectOptions * + ?startBackgroundCompile:bool * + ?userOpName:string -> unit + [] + member + MatchBraces: filename:string * source:string * + options:FSharpProjectOptions * ?userOpName:string -> + Async<(Range.range * Range.range) []> + member + MatchBraces: filename:string * sourceText:Text.ISourceText * + options:FSharpParsingOptions * ?userOpName:string -> + Async<(Range.range * Range.range) []> + member + NotifyProjectCleaned: options:FSharpProjectOptions * ?userOpName:string -> + Async + member + ParseAndCheckFileInProject: filename:string * fileVersion:int * + sourceText:Text.ISourceText * + options:FSharpProjectOptions * + ?userOpName:string -> + Async + member + ParseAndCheckProject: options:FSharpProjectOptions * ?userOpName:string -> + Async + member + ParseFile: filename:string * sourceText:Text.ISourceText * + options:FSharpParsingOptions * ?userOpName:string -> + Async + [] + member + ParseFileInProject: filename:string * source:string * + options:FSharpProjectOptions * ?userOpName:string -> + Async + member + ParseFileNoCache: filename:string * sourceText:Text.ISourceText * + options:FSharpParsingOptions * ?userOpName:string -> + Async + member + StartBackgroundCompile: options:FSharpProjectOptions * + ?userOpName:string -> unit + member StopBackgroundCompile: unit -> unit + member TokenizeFile: source:string -> FSharpTokenInfo [] [] + member + TokenizeLine: line:string * state:FSharpTokenizerLexState -> + FSharpTokenInfo [] * FSharpTokenizerLexState + member + TryGetRecentCheckResultsForFile: filename:string * + options:FSharpProjectOptions * + ?sourceText:Text.ISourceText * + ?userOpName:string -> + (FSharpParseFileResults * + FSharpCheckFileResults * + FileVersion) option + member WaitForBackgroundCompile: unit -> unit + member BeforeBackgroundFileCheck: IEvent + member CurrentQueueLength: int + member FileChecked: IEvent + member FileParsed: IEvent + member internal FrameworkImportsCache: FrameworkImportsCache + member ImplicitlyStartBackgroundWork: bool + member MaxMemory: int + member MaxMemoryReached: IEvent + member PauseBeforeBackgroundWork: int + member ProjectChecked: IEvent + member ReactorOps: IReactorOperations + member ReferenceResolver: ReferenceResolver.Resolver + static member GlobalForegroundParseCountStatistic: int + static member GlobalForegroundTypeCheckCountStatistic: int + [] + static member Instance: FSharpChecker + + [] + type CompilerEnvironment = + + static member + BinFolderOfDefaultFSharpCompiler: ?probePoint:string -> string option + + module CompilerEnvironment = + val DefaultReferencesForOrphanSources: + assumeDotNetFramework:bool -> string list + val GetCompilationDefinesForEditing: + parsingOptions:FSharpParsingOptions -> string list + val IsCheckerSupportedSubcategory: string -> bool + + module DebuggerEnvironment = + val GetLanguageID: unit -> System.Guid + + module PrettyNaming = + val IsIdentifierPartCharacter: char -> bool + val IsLongIdentifierPartCharacter: char -> bool + val IsOperatorName: string -> bool + val GetLongNameFromString: string -> string list + val FormatAndOtherOverloadsString: System.Int32 -> string + val QuoteIdentifierIfNeeded: string -> string + val KeywordNames: string list + + module FSharpFileUtilities = + val isScriptFile: string -> bool + + + + +namespace FSharp.Compiler.SourceCodeServices + module Structure = + module Range = + val endToEnd: r1:Range.range -> r2:Range.range -> Range.range + val endToStart: r1:Range.range -> r2:Range.range -> Range.range + val startToEnd: r1:Range.range -> r2:Range.range -> Range.range + val startToStart: r1:Range.range -> r2:Range.range -> Range.range + val modStart: m:int -> r:Range.range -> Range.range + val modEnd: m:int -> r:Range.range -> Range.range + val modBoth: modStart:int -> modEnd:int -> r:Range.range -> Range.range + + val longIdentRange: longId:SyntaxTree.LongIdent -> Range.range + val rangeOfTypeArgsElse: + other:Range.range -> typeArgs:SyntaxTree.SynTyparDecl list -> Range.range + val rangeOfSynPatsElse: + other:Range.range -> synPats:SyntaxTree.SynSimplePat list -> Range.range + [] + type Collapse = + | Below + | Same + [] + type Scope = + | Open + | Namespace + | Module + | Type + | Member + | LetOrUse + | Val + | CompExpr + | IfThenElse + | ThenInIfThenElse + | ElseInIfThenElse + | TryWith + | TryInTryWith + | WithInTryWith + | TryFinally + | TryInTryFinally + | FinallyInTryFinally + | ArrayOrList + | ObjExpr + | For + | While + | Match + | MatchBang + | MatchLambda + | MatchClause + | Lambda + | CompExprInternal + | Quote + | Record + | SpecialFunc + | Do + | New + | Attribute + | Interface + | HashDirective + | LetOrUseBang + | TypeExtension + | YieldOrReturn + | YieldOrReturnBang + | Tuple + | UnionCase + | EnumCase + | RecordField + | RecordDefn + | UnionDefn + | Comment + | XmlDocComment + with + override ToString: unit -> string + + [] + type ScopeRange = + { Scope: Scope + Collapse: Collapse + Range: Range.range + CollapseRange: Range.range } + type LineNumber = int + type LineStr = string + type CommentType = + | SingleLine + | XmlDoc + [] + type CommentList = + { Lines: ResizeArray + Type: CommentType } + with + static member + New: ty:CommentType -> lineStr:(LineNumber * LineStr) -> CommentList + + val getOutliningRanges: + sourceLines:string [] -> + parsedInput:SyntaxTree.ParsedInput -> seq + + +namespace FSharp.Compiler.SourceCodeServices + module UnusedOpens = + val symbolHash: System.Collections.Generic.IEqualityComparer + type OpenedModule = + + new: entity:FSharpEntity * isNestedAutoOpen:bool -> OpenedModule + member RevealedSymbolsContains: symbol:FSharpSymbol -> bool + member Entity: FSharpEntity + member IsNestedAutoOpen: bool + + type OpenedModuleGroup = + { OpenedModules: OpenedModule [] } + with + static member Create: modul:FSharpEntity -> OpenedModuleGroup + + type OpenStatement = + { OpenedGroups: OpenedModuleGroup list + Range: Range.range + AppliedScope: Range.range } + val getOpenStatements: + openDeclarations:FSharpOpenDeclaration [] -> OpenStatement [] + val filterSymbolUses: + getSourceLineStr:(int -> string) -> + symbolUses:seq -> FSharpSymbolUse [] + val splitSymbolUses: + symbolUses:FSharpSymbolUse [] -> FSharpSymbolUse [] * FSharpSymbolUse [] + val isOpenStatementUsed: + symbolUses2:FSharpSymbolUse [] -> + symbolUsesRangesByDeclaringEntity:System.Collections.Generic.Dictionary -> + usedModules:System.Collections.Generic.Dictionary -> + openStatement:OpenStatement -> bool + val filterOpenStatementsIncremental: + symbolUses2:FSharpSymbolUse [] -> + symbolUsesRangesByDeclaringEntity:System.Collections.Generic.Dictionary -> + openStatements:OpenStatement list -> + usedModules:System.Collections.Generic.Dictionary -> + acc:OpenStatement list -> Async + val entityHash: System.Collections.Generic.IEqualityComparer + val filterOpenStatements: + symbolUses1:FSharpSymbolUse [] * symbolUses2:FSharpSymbolUse [] -> + openStatements:OpenStatement [] -> Async + val getUnusedOpens: + checkFileResults:FSharpCheckFileResults * getSourceLineStr:(int -> string) -> + Async + + module SimplifyNames = + type SimplifiableRange = + { Range: Range.range + RelativeName: string } + val getPlidLength: plid:string list -> int + val getSimplifiableNames: + checkFileResults:FSharpCheckFileResults * getSourceLineStr:(int -> string) -> + Async> + + module UnusedDeclarations = + val isPotentiallyUnusedDeclaration: symbol:FSharpSymbol -> bool + val getUnusedDeclarationRanges: + symbolsUses:seq -> isScript:bool -> seq + val getUnusedDeclarations: + checkFileResults:FSharpCheckFileResults * isScriptFile:bool -> + Async> + + +namespace FSharp.Compiler.Interactive + module Shell = + [] + type FsiValue = + + new: reflectionValue:obj * reflectionType:System.Type * + fsharpType:SourceCodeServices.FSharpType -> FsiValue + member FSharpType: SourceCodeServices.FSharpType + member ReflectionType: System.Type + member ReflectionValue: obj + + [] + type FsiBoundValue = + + new: name:string * value:FsiValue -> FsiBoundValue + member Name: string + member Value: FsiValue + + module internal Utilities = + type IAnyToLayoutCall = + interface + abstract member + AnyToLayout: Internal.Utilities.StructuredFormat.FormatOptions * + obj * System.Type -> + Internal.Utilities.StructuredFormat.Layout + abstract member + FsiAnyToLayout: Internal.Utilities.StructuredFormat.FormatOptions * + obj * System.Type -> + Internal.Utilities.StructuredFormat.Layout + + type private AnyToLayoutSpecialization<'T> = + + interface IAnyToLayoutCall + new: unit -> AnyToLayoutSpecialization<'T> + + val getAnyToLayoutCall: ty:System.Type -> IAnyToLayoutCall + val callStaticMethod: + ty:System.Type -> name:string -> args:obj list -> obj + val ignoreAllErrors: f:(unit -> unit) -> unit + val getMember: + name:string -> + memberType:System.Reflection.MemberTypes -> + attr:System.Reflection.BindingFlags -> + declaringType:System.Type -> System.Reflection.MemberInfo [] + val tryFindMember: + name:string -> + memberType:System.Reflection.MemberTypes -> + declaringType:System.Type -> System.Reflection.MemberInfo option + val getInstanceProperty: obj:obj -> nm:string -> 'a + val setInstanceProperty: obj:obj -> nm:string -> v:obj -> 'a + val callInstanceMethod0: + obj:obj -> typeArgs:System.Type [] -> nm:string -> 'a + val callInstanceMethod1: + obj:obj -> typeArgs:System.Type [] -> nm:string -> v:obj -> 'a + val callInstanceMethod3: + obj:obj -> + typeArgs:System.Type [] -> + nm:string -> v1:obj -> v2:obj -> v3:obj -> 'a + val colorPrintL: + outWriter:System.IO.TextWriter -> + opts:Internal.Utilities.StructuredFormat.FormatOptions -> + layout:Internal.Utilities.StructuredFormat.Layout -> unit + val reportError: + m:Range.range -> Microsoft.DotNet.DependencyManager.ResolvingErrorReport + val getOutputDir: tcConfigB:CompilerConfig.TcConfigBuilder -> string + + type internal FsiTimeReporter = + + new: outWriter:System.IO.TextWriter -> FsiTimeReporter + member TimeOp: f:(unit -> 'b) -> 'b + member TimeOpIf: flag:bool -> f:(unit -> 'a) -> 'a + + type internal FsiValuePrinterMode = + | PrintExpr + | PrintDecl + [] + type EvaluationEventArgs = + + inherit System.EventArgs + new: fsivalue:FsiValue option * + symbolUse:SourceCodeServices.FSharpSymbolUse * + decl:SourceCodeServices.FSharpImplementationFileDeclaration -> + EvaluationEventArgs + member FsiValue: FsiValue option + member + ImplementationDeclaration: SourceCodeServices.FSharpImplementationFileDeclaration + member Name: string + member Symbol: SourceCodeServices.FSharpSymbol + member SymbolUse: SourceCodeServices.FSharpSymbolUse + + [] + type FsiEvaluationSessionHostConfig = + + new: unit -> FsiEvaluationSessionHostConfig + abstract member EventLoopInvoke: codeToRun:(unit -> 'T) -> 'T + abstract member EventLoopRun: unit -> bool + abstract member EventLoopScheduleRestart: unit -> unit + abstract member + GetOptionalConsoleReadLine: probeToSeeIfConsoleWorks:bool -> + (unit -> string) option + abstract member ReportUserCommandLineArgs: string [] -> unit + abstract member StartServer: fsiServerName:string -> unit + member + internal TriggerEvaluation: value:FsiValue option * + symbolUse:SourceCodeServices.FSharpSymbolUse * + decl:SourceCodeServices.FSharpImplementationFileDeclaration -> + unit + abstract member + AddedPrinters: Choice<(System.Type * (obj -> string)), + (System.Type * (obj -> obj))> list + abstract member FloatingPointFormat: string + abstract member FormatProvider: System.IFormatProvider + member OnEvaluation: IEvent + abstract member PrintDepth: int + abstract member PrintLength: int + abstract member PrintSize: int + abstract member PrintWidth: int + abstract member ShowDeclarationValues: bool + abstract member ShowIEnumerable: bool + abstract member ShowProperties: bool + abstract member UseFsiAuxLib: bool + + type internal FsiValuePrinter = + + new: fsi:FsiEvaluationSessionHostConfig * g:TcGlobals.TcGlobals * + generateDebugInfo:bool * + resolveAssemblyRef:(AbstractIL.IL.ILAssemblyRef -> + Choice option) * + outWriter:System.IO.TextWriter -> FsiValuePrinter + member FormatValue: obj:obj * objTy:System.Type -> string + member + GetEvaluationContext: emEnv:AbstractIL.ILRuntimeWriter.emEnv -> + IlxGen.ExecutionContext + member + GetFsiPrintOptions: unit -> + Internal.Utilities.StructuredFormat.FormatOptions + member + InvokeDeclLayout: emEnv:AbstractIL.ILRuntimeWriter.emEnv * + ilxGenerator:IlxGen.IlxAssemblyGenerator * + v:TypedTree.Val -> + Internal.Utilities.StructuredFormat.Layout option + member + InvokeExprPrinter: denv:TypedTreeOps.DisplayEnv * + emEnv:AbstractIL.ILRuntimeWriter.emEnv * + ilxGenerator:IlxGen.IlxAssemblyGenerator * + vref:TypedTree.Val -> unit + member + PrintValue: printMode:FsiValuePrinterMode * + opts:Internal.Utilities.StructuredFormat.FormatOptions * + x:obj * ty:System.Type -> + Internal.Utilities.StructuredFormat.Layout + + type internal FsiStdinSyphon = + + new: errorWriter:System.IO.TextWriter -> FsiStdinSyphon + member Add: str:string -> unit + member GetLine: filename:string -> i:int -> string + member + PrintError: tcConfig:CompilerConfig.TcConfigBuilder * + err:ErrorLogger.PhasedDiagnostic -> unit + member Reset: unit -> unit + + type internal FsiConsoleOutput = + + new: tcConfigB:CompilerConfig.TcConfigBuilder * + outWriter:System.IO.TextWriter * errorWriter:System.IO.TextWriter -> + FsiConsoleOutput + member uprintf: fmt:Printf.TextWriterFormat<'f> -> 'f + member uprintfn: fmt:Printf.TextWriterFormat<'e> -> 'e + member uprintfnn: fmt:Printf.TextWriterFormat<'d,unit> -> 'd + member uprintnf: fmt:Printf.TextWriterFormat<'c> -> 'c + member uprintnfn: fmt:Printf.TextWriterFormat<'b> -> 'b + member uprintnfnn: fmt:Printf.TextWriterFormat<'a,unit> -> 'a + member Error: System.IO.TextWriter + member Out: System.IO.TextWriter + + type internal ErrorLoggerThatStopsOnFirstError = + + inherit ErrorLogger.ErrorLogger + new: tcConfigB:CompilerConfig.TcConfigBuilder * + fsiStdinSyphon:FsiStdinSyphon * fsiConsoleOutput:FsiConsoleOutput -> + ErrorLoggerThatStopsOnFirstError + override + DiagnosticSink: err:ErrorLogger.PhasedDiagnostic * isError:bool -> + unit + member ResetErrorCount: unit -> unit + member SetError: unit -> unit + override ErrorCount: int + + type ErrorLogger with + member CheckForErrors: unit -> bool + type ErrorLogger with + member AbortOnError: fsiConsoleOutput:FsiConsoleOutput -> unit + val internal directoryName: s:string -> string + type internal FsiCommandLineOptions = + + new: fsi:FsiEvaluationSessionHostConfig * argv:string [] * + tcConfigB:CompilerConfig.TcConfigBuilder * + fsiConsoleOutput:FsiConsoleOutput -> FsiCommandLineOptions + member ShowBanner: unit -> unit + member ShowHelp: m:Range.range -> unit + member + DependencyProvider: Microsoft.DotNet.DependencyManager.DependencyProvider + member EnableConsoleKeyProcessing: bool + member FsiLCID: int option + member FsiServerInputCodePage: int option + member FsiServerName: string + member FsiServerOutputCodePage: int option + member Gui: bool + member Interact: bool + member IsInteractiveServer: bool + member PeekAheadOnConsoleToPermitTyping: bool + member ProbeToSeeIfConsoleWorks: bool + member ShowILCode: bool + member ShowTypes: bool + member SourceFiles: (string * bool) list + + val internal SetCurrentUICultureForThread: + lcid:int option -> System.IDisposable + val internal InstallErrorLoggingOnThisThread: + errorLogger:ErrorLogger.ErrorLogger -> unit + val internal SetServerCodePages: fsiOptions:FsiCommandLineOptions -> unit + type internal FsiConsolePrompt = + + new: fsiOptions:FsiCommandLineOptions * + fsiConsoleOutput:FsiConsoleOutput -> FsiConsolePrompt + member Print: unit -> unit + member PrintAhead: unit -> unit + member SkipNext: unit -> unit + member FsiOptions: FsiCommandLineOptions + + type internal FsiConsoleInput = + + new: fsi:FsiEvaluationSessionHostConfig * + fsiOptions:FsiCommandLineOptions * inReader:System.IO.TextReader * + outWriter:System.IO.TextWriter -> FsiConsoleInput + member TryGetConsole: unit -> (unit -> string) option + member TryGetFirstLine: unit -> string option + member WaitForInitialConsoleInput: unit -> unit + member In: System.IO.TextReader + + type internal FsiInteractionStepStatus = + | CtrlC + | EndOfFile + | Completed of FsiValue option + | CompletedWithAlreadyReportedError + | CompletedWithReportedError of exn + [] + type internal FsiDynamicCompilerState = + { optEnv: Optimizer.IncrementalOptimizationEnv + emEnv: AbstractIL.ILRuntimeWriter.emEnv + tcGlobals: TcGlobals.TcGlobals + tcState: ParseAndCheckInputs.TcState + tcImports: CompilerImports.TcImports + ilxGenerator: IlxGen.IlxAssemblyGenerator + boundValues: AbstractIL.Internal.Library.NameMap + timing: bool + debugBreak: bool } + val internal WithImplicitHome: + tcConfigB:CompilerConfig.TcConfigBuilder * dir:string -> + f:(unit -> 'a) -> 'a + val internal convertReflectionTypeToILTypeRef: + reflectionTy:System.Type -> AbstractIL.IL.ILTypeRef + val internal convertReflectionTypeToILType: + reflectionTy:System.Type -> AbstractIL.IL.ILType + val internal mkBoundValueTypedImpl: + tcGlobals:TcGlobals.TcGlobals -> + m:Range.range -> + moduleName:string -> + name:string -> + ty:TypedTree.TType -> + TypedTree.ModuleOrNamespace * TypedTree.Val * + TypedTree.TypedImplFile + type internal FsiDynamicCompiler = + + new: fsi:FsiEvaluationSessionHostConfig * timeReporter:FsiTimeReporter * + tcConfigB:CompilerConfig.TcConfigBuilder * tcLockObject:obj * + outWriter:System.IO.TextWriter * + tcImports:CompilerImports.TcImports * + tcGlobals:TcGlobals.TcGlobals * fsiOptions:FsiCommandLineOptions * + fsiConsoleOutput:FsiConsoleOutput * fsiCollectible:bool * + niceNameGen:CompilerGlobalState.NiceNameGenerator * + resolveAssemblyRef:(AbstractIL.IL.ILAssemblyRef -> + Choice option) -> + FsiDynamicCompiler + member + AddBoundValue: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + errorLogger:ErrorLogger.ErrorLogger * + istate:FsiDynamicCompilerState * name:string * + value:obj -> + FsiDynamicCompilerState * FsiInteractionStepStatus + member + BuildItBinding: expr:SyntaxTree.SynExpr -> + SyntaxTree.SynModuleDecl list + member + CommitDependencyManagerText: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + istate:FsiDynamicCompilerState * + lexResourceManager:Lexhelp.LexResourceManager * + errorLogger:ErrorLogger.ErrorLogger -> + FsiDynamicCompilerState + member CreateDebuggerBreak: m:Range.range -> SyntaxTree.SynModuleDecl + member + CurrentPartialAssemblySignature: istate:FsiDynamicCompilerState -> + SourceCodeServices.FSharpAssemblySignature + member + EvalDependencyManagerTextFragment: packageManager:Microsoft.DotNet.DependencyManager.IDependencyManagerProvider * + lt:CompilerConfig.Directive * + m:Range.range * path:string -> + unit + member + EvalParsedDefinitions: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + errorLogger:ErrorLogger.ErrorLogger * + istate:FsiDynamicCompilerState * + showTypes:bool * isInteractiveItExpr:bool * + defs:SyntaxTree.SynModuleDecl list -> + FsiDynamicCompilerState * + FsiInteractionStepStatus + member + EvalParsedExpression: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + errorLogger:ErrorLogger.ErrorLogger * + istate:FsiDynamicCompilerState * + expr:SyntaxTree.SynExpr -> + FsiDynamicCompilerState * + FsiInteractionStepStatus + member + EvalParsedSourceFiles: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + errorLogger:ErrorLogger.ErrorLogger * + istate:FsiDynamicCompilerState * + inputs:SyntaxTree.ParsedInput list -> + FsiDynamicCompilerState + member + EvalRequireReference: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + istate:FsiDynamicCompilerState * m:Range.range * + path:string -> + CompilerImports.AssemblyResolution list * + FsiDynamicCompilerState + member + EvalSourceFiles: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + istate:FsiDynamicCompilerState * m:Range.range * + sourceFiles:string list * + lexResourceManager:Lexhelp.LexResourceManager * + errorLogger:ErrorLogger.ErrorLogger -> + FsiDynamicCompilerState + member FormatValue: obj:obj * objTy:System.Type -> string + member + GetBoundValues: istate:FsiDynamicCompilerState -> FsiBoundValue list + member GetInitialInteractiveState: unit -> FsiDynamicCompilerState + member + ProcessMetaCommandsFromInputAsInteractiveCommands: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + istate:FsiDynamicCompilerState * + sourceFile:string * + inp:SyntaxTree.ParsedInput -> + FsiDynamicCompilerState + member + TryFindBoundValue: istate:FsiDynamicCompilerState * nm:string -> + FsiBoundValue option + member DynamicAssembly: System.Reflection.Assembly + member DynamicAssemblyName: string + member ValueBound: IEvent + + type ControlEventHandler = + delegate of int -> bool + type internal FsiInterruptStdinState = + | StdinEOFPermittedBecauseCtrlCRecentlyPressed + | StdinNormal + type internal FsiInterruptControllerState = + | InterruptCanRaiseException + | InterruptIgnored + type internal FsiInterruptControllerKillerThreadRequest = + | ThreadAbortRequest + | NoRequest + | ExitRequest + | PrintInterruptRequest + type internal FsiInterruptController = + + new: fsiOptions:FsiCommandLineOptions * + fsiConsoleOutput:FsiConsoleOutput -> FsiInterruptController + member ClearInterruptRequest: unit -> unit + member Exit: unit -> 'a + member + InstallKillThread: threadToKill:System.Threading.Thread * + pauseMilliseconds:int -> unit + member Interrupt: unit -> unit + member PosixInvoke: n:int -> unit + member EventHandlers: ControlEventHandler list + member FsiInterruptStdinState: FsiInterruptStdinState + member InterruptAllowed: FsiInterruptControllerState with set + + module internal MagicAssemblyResolution = + val private assemblyLoadFrom: path:string -> System.Reflection.Assembly + val Install: + tcConfigB:CompilerConfig.TcConfigBuilder * + tcImports:CompilerImports.TcImports * + fsiDynamicCompiler:FsiDynamicCompiler * + fsiConsoleOutput:FsiConsoleOutput -> System.IDisposable + + type internal FsiStdinLexerProvider = + + new: tcConfigB:CompilerConfig.TcConfigBuilder * + fsiStdinSyphon:FsiStdinSyphon * fsiConsoleInput:FsiConsoleInput * + fsiConsoleOutput:FsiConsoleOutput * + fsiOptions:FsiCommandLineOptions * + lexResourceManager:Lexhelp.LexResourceManager -> + FsiStdinLexerProvider + member + CreateBufferLexer: sourceFileName:string * + lexbuf:UnicodeLexing.Lexbuf * + errorLogger:ErrorLogger.ErrorLogger -> + LexFilter.LexFilter + member + CreateIncludedScriptLexer: sourceFileName:string * + reader:System.IO.StreamReader * + errorLogger:ErrorLogger.ErrorLogger -> + LexFilter.LexFilter + member + CreateStdinLexer: errorLogger:ErrorLogger.ErrorLogger -> + LexFilter.LexFilter + member + CreateStringLexer: sourceFileName:string * source:string * + errorLogger:ErrorLogger.ErrorLogger -> + LexFilter.LexFilter + member ConsoleInput: FsiConsoleInput + + type internal FsiInteractionProcessor = + + new: fsi:FsiEvaluationSessionHostConfig * + tcConfigB:CompilerConfig.TcConfigBuilder * + fsiOptions:FsiCommandLineOptions * + fsiDynamicCompiler:FsiDynamicCompiler * + fsiConsolePrompt:FsiConsolePrompt * + fsiConsoleOutput:FsiConsoleOutput * + fsiInterruptController:FsiInterruptController * + fsiStdinLexerProvider:FsiStdinLexerProvider * + lexResourceManager:Lexhelp.LexResourceManager * + initialInteractiveState:FsiDynamicCompilerState -> + FsiInteractionProcessor + member + AddBoundValue: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + errorLogger:ErrorLogger.ErrorLogger * name:string * + value:obj -> Choice + member + CompletionsForPartialLID: istate:FsiDynamicCompilerState * + prefix:string -> string list + member + EvalExpression: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + sourceText:string * scriptFileName:string * + errorLogger:ErrorLogger.ErrorLogger -> + Choice + member + EvalIncludedScript: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + istate:FsiDynamicCompilerState * + sourceFile:string * m:Range.range * + errorLogger:ErrorLogger.ErrorLogger -> + FsiDynamicCompilerState * + FsiInteractionStepStatus + member + EvalIncludedScripts: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + istate:FsiDynamicCompilerState * + sourceFiles:string list * + errorLogger:ErrorLogger.ErrorLogger -> + FsiDynamicCompilerState + member + EvalInteraction: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + sourceText:string * scriptFileName:string * + errorLogger:ErrorLogger.ErrorLogger * + ?cancellationToken:System.Threading.CancellationToken -> + Choice + member + EvalScript: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + scriptPath:string * errorLogger:ErrorLogger.ErrorLogger -> + Choice + member + LoadDummyInteraction: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + errorLogger:ErrorLogger.ErrorLogger -> unit + member + LoadInitialFiles: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + errorLogger:ErrorLogger.ErrorLogger -> unit + member + ParseAndCheckInteraction: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + legacyReferenceResolver:ReferenceResolver.Resolver * + checker:SourceCodeServices.IReactorOperations * + istate:FsiDynamicCompilerState * + text:string -> + Async + member + ParseAndExecOneSetOfInteractionsFromLexbuf: runCodeOnMainThread:((#AbstractIL.Internal.Library.CompilationThreadToken -> + FsiDynamicCompilerState -> + FsiDynamicCompilerState * + FsiInteractionStepStatus) -> + FsiDynamicCompilerState -> + FsiDynamicCompilerState * + FsiInteractionStepStatus) * + istate:FsiDynamicCompilerState * + tokenizer:LexFilter.LexFilter * + errorLogger:ErrorLogger.ErrorLogger * + ?cancellationToken:System.Threading.CancellationToken -> + FsiDynamicCompilerState * + FsiInteractionStepStatus + member + StartStdinReadAndProcessThread: errorLogger:ErrorLogger.ErrorLogger -> + unit + member CurrentState: FsiDynamicCompilerState + member PartialAssemblySignatureUpdated: IEvent + + val internal SpawnThread: name:string -> f:(unit -> unit) -> unit + val internal SpawnInteractiveServer: + fsi:FsiEvaluationSessionHostConfig * fsiOptions:FsiCommandLineOptions * + fsiConsoleOutput:FsiConsoleOutput -> unit + val internal DriveFsiEventLoop: + fsi:FsiEvaluationSessionHostConfig * fsiConsoleOutput:FsiConsoleOutput -> + unit + [] + type FsiCompilationException = + + inherit System.Exception + new: string * SourceCodeServices.FSharpErrorInfo [] option -> + FsiCompilationException + member ErrorInfos: SourceCodeServices.FSharpErrorInfo [] option + + [] + type FsiEvaluationSession = + + interface System.IDisposable + new: fsi:FsiEvaluationSessionHostConfig * argv:string [] * + inReader:System.IO.TextReader * outWriter:System.IO.TextWriter * + errorWriter:System.IO.TextWriter * fsiCollectible:bool * + legacyReferenceResolver:ReferenceResolver.Resolver option -> + FsiEvaluationSession + static member + Create: fsiConfig:FsiEvaluationSessionHostConfig * argv:string [] * + inReader:System.IO.TextReader * + outWriter:System.IO.TextWriter * + errorWriter:System.IO.TextWriter * ?collectible:bool * + ?legacyReferenceResolver:ReferenceResolver.Resolver -> + FsiEvaluationSession + static member + GetDefaultConfiguration: unit -> FsiEvaluationSessionHostConfig + static member + GetDefaultConfiguration: fsiObj:obj -> FsiEvaluationSessionHostConfig + static member + GetDefaultConfiguration: fsiObj:obj * useFsiAuxLib:bool -> + FsiEvaluationSessionHostConfig + member AddBoundValue: name:string * value:obj -> unit + member EvalExpression: code:string -> FsiValue option + member + EvalExpressionNonThrowing: code:string -> + Choice * + SourceCodeServices.FSharpErrorInfo [] + member + EvalInteraction: code:string * + ?cancellationToken:System.Threading.CancellationToken -> + unit + member + EvalInteractionNonThrowing: code:string * + ?cancellationToken:System.Threading.CancellationToken -> + Choice * + SourceCodeServices.FSharpErrorInfo [] + member EvalScript: filePath:string -> unit + member + EvalScriptNonThrowing: filePath:string -> + Choice * + SourceCodeServices.FSharpErrorInfo [] + member + FormatValue: reflectionValue:obj * reflectionType:System.Type -> + string + member GetBoundValues: unit -> FsiBoundValue list + member GetCompletions: longIdent:string -> seq + member Interrupt: unit -> unit + member + ParseAndCheckInteraction: code:string -> + Async + member ReportUnhandledException: exn:exn -> unit + member Run: unit -> unit + member TryFindBoundValue: name:string -> FsiBoundValue option + member + CurrentPartialAssemblySignature: SourceCodeServices.FSharpAssemblySignature + member DynamicAssembly: System.Reflection.Assembly + member InteractiveChecker: SourceCodeServices.FSharpChecker + member IsGui: bool + member LCID: int option + member PartialAssemblySignatureUpdated: IEvent + member ValueBound: IEvent + + module Settings = + type IEventLoop = + interface + abstract member Invoke: (unit -> 'T) -> 'T + abstract member Run: unit -> bool + abstract member ScheduleRestart: unit -> unit + + type internal SimpleEventLoop = + + interface System.IDisposable + interface IEventLoop + new: unit -> SimpleEventLoop + + [] + type InteractiveSettings = + + new: unit -> InteractiveSettings + member AddPrintTransformer: ('T -> obj) -> unit + member AddPrinter: ('T -> string) -> unit + member + AddedPrinters: Choice<(System.Type * (obj -> string)), + (System.Type * (obj -> obj))> list + member CommandLineArgs: string [] + member EventLoop: IEventLoop + member FloatingPointFormat: string + member FormatProvider: System.IFormatProvider + member PrintDepth: int + member PrintLength: int + member PrintSize: int + member PrintWidth: int + member ShowDeclarationValues: bool + member ShowIDictionary: bool + member ShowIEnumerable: bool + member ShowProperties: bool + + val fsi: InteractiveSettings + + [] + type CompilerInputStream = + + inherit System.IO.Stream + new: unit -> CompilerInputStream + member Add: str:string -> unit + override Flush: unit -> unit + override Read: buffer:byte [] * offset:int * count:int -> int + override Seek: _offset:int64 * _origin:System.IO.SeekOrigin -> int64 + override SetLength: _value:int64 -> unit + override Write: _buffer:byte [] * _offset:int * _count:int -> unit + override CanRead: bool + override CanSeek: bool + override CanWrite: bool + override Length: int64 + override Position: int64 + + [] + type CompilerOutputStream = + + inherit System.IO.Stream + new: unit -> CompilerOutputStream + override Flush: unit -> unit + member Read: unit -> string + override Read: _buffer:byte [] * _offset:int * _count:int -> int + override Seek: _offset:int64 * _origin:System.IO.SeekOrigin -> int64 + override SetLength: _value:int64 -> unit + override Write: buffer:byte [] * offset:int * count:int -> unit + override CanRead: bool + override CanSeek: bool + override CanWrite: bool + override Length: int64 + override Position: int64 + + + diff --git a/src/fsharp/InfoReader.fsi b/src/fsharp/InfoReader.fsi new file mode 100644 index 00000000000..fd44eeb4b29 --- /dev/null +++ b/src/fsharp/InfoReader.fsi @@ -0,0 +1,931 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + + +/// Select members from a type by name, searching the type hierarchy if needed +module internal FSharp.Compiler.InfoReader + +open System +open System.Collections.Generic +open System.Collections.Concurrent + +open FSharp.Compiler +open FSharp.Compiler.AbstractIL.IL +open FSharp.Compiler.AbstractIL.Internal.Library +open FSharp.Compiler.AccessibilityLogic +open FSharp.Compiler.AttributeChecking +open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.Infos +open FSharp.Compiler.Range +open FSharp.Compiler.SyntaxTree +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeOps +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.Features +open FSharp.Compiler.TypeRelations + +/// Use the given function to select some of the member values from the members of an F# type +let SelectImmediateMemberVals g optFilter f (tcref: TyconRef) = + let chooser (vref: ValRef) = + match vref.MemberInfo with + // The 'when' condition is a workaround for the fact that values providing + // override and interface implementations are published in inferred module types + // These cannot be selected directly via the "." notation. + // However, it certainly is useful to be able to publish these values, as we can in theory + // optimize code to make direct calls to these methods. + | Some membInfo when not (ValRefIsExplicitImpl g vref) -> + f membInfo vref + | _ -> + None + + match optFilter with + | None -> tcref.MembersOfFSharpTyconByName |> NameMultiMap.chooseRange chooser + | Some nm -> tcref.MembersOfFSharpTyconByName |> NameMultiMap.find nm |> List.choose chooser + +/// Check whether a name matches an optional filter +let private checkFilter optFilter (nm: string) = match optFilter with None -> true | Some n2 -> nm = n2 + +/// Try to select an F# value when querying members, and if so return a MethInfo that wraps the F# value. +let TrySelectMemberVal g optFilter ty pri _membInfo (vref: ValRef) = + if checkFilter optFilter vref.LogicalName then + Some(FSMeth(g, ty, vref, pri)) + else + None + +let rec GetImmediateIntrinsicMethInfosOfTypeAux (optFilter, ad) g amap m origTy metadataTy = + + let minfos = + match metadataOfTy g metadataTy with +#if !NO_EXTENSIONTYPING + | ProvidedTypeMetadata info -> + let st = info.ProvidedType + let meths = + match optFilter with + | Some name -> st.PApplyArray ((fun st -> st.GetMethods() |> Array.filter (fun mi -> mi.Name = name) ), "GetMethods", m) + | None -> st.PApplyArray ((fun st -> st.GetMethods()), "GetMethods", m) + [ for mi in meths -> ProvidedMeth(amap, mi.Coerce(m), None, m) ] +#endif + | ILTypeMetadata _ -> + let tinfo = ILTypeInfo.FromType g origTy + let mdefs = tinfo.RawMetadata.Methods + let mdefs = match optFilter with None -> mdefs.AsList | Some nm -> mdefs.FindByName nm + mdefs |> List.map (fun mdef -> MethInfo.CreateILMeth(amap, m, origTy, mdef)) + + | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> + // Tuple types also support the methods get_Item1-8, get_Rest from the compiled tuple type. + // In this case convert to the .NET Tuple type that carries metadata and try again + if isAnyTupleTy g metadataTy then + let betterMetadataTy = convertToTypeWithMetadataIfPossible g metadataTy + GetImmediateIntrinsicMethInfosOfTypeAux (optFilter, ad) g amap m origTy betterMetadataTy + // Function types support methods FSharpFunc<_, _>.FromConverter and friends from .NET metadata, + // but not instance methods (you can't write "f.Invoke(x)", you have to write "f x") + elif isFunTy g metadataTy then + let betterMetadataTy = convertToTypeWithMetadataIfPossible g metadataTy + GetImmediateIntrinsicMethInfosOfTypeAux (optFilter, ad) g amap m origTy betterMetadataTy + |> List.filter (fun minfo -> not minfo.IsInstance) + else + match tryTcrefOfAppTy g metadataTy with + | ValueNone -> [] + | ValueSome tcref -> + SelectImmediateMemberVals g optFilter (TrySelectMemberVal g optFilter origTy None) tcref + let minfos = minfos |> List.filter (IsMethInfoAccessible amap m ad) + minfos + +/// Query the immediate methods of an F# type, not taking into account inherited methods. The optFilter +/// parameter is an optional name to restrict the set of properties returned. +let GetImmediateIntrinsicMethInfosOfType (optFilter, ad) g amap m ty = + GetImmediateIntrinsicMethInfosOfTypeAux (optFilter, ad) g amap m ty ty + +/// A helper type to help collect properties. +/// +/// Join up getters and setters which are not associated in the F# data structure +type PropertyCollector(g, amap, m, ty, optFilter, ad) = + + let hashIdentity = + HashIdentity.FromFunctions + (fun (pinfo: PropInfo) -> hash pinfo.PropertyName) + (fun pinfo1 pinfo2 -> + pinfo1.IsStatic = pinfo2.IsStatic && + PropInfosEquivByNameAndPartialSig EraseNone g amap m pinfo1 pinfo2 && + pinfo1.IsDefiniteFSharpOverride = pinfo2.IsDefiniteFSharpOverride ) + + let props = new ConcurrentDictionary(hashIdentity) + + let add pinfo = + match props.TryGetValue pinfo, pinfo with + | (true, FSProp (_, ty, Some vref1, _)), FSProp (_, _, _, Some vref2) + | (true, FSProp (_, ty, _, Some vref2)), FSProp (_, _, Some vref1, _) -> + let pinfo = FSProp (g, ty, Some vref1, Some vref2) + props.[pinfo] <- pinfo + | (true, _), _ -> + // This assert fires while editing bad code. We will give a warning later in check.fs + //assert ("unexpected case"= "") + () + | _ -> + props.[pinfo] <- pinfo + + member x.Collect(membInfo: ValMemberInfo, vref: ValRef) = + match membInfo.MemberFlags.MemberKind with + | MemberKind.PropertyGet -> + let pinfo = FSProp(g, ty, Some vref, None) + if checkFilter optFilter vref.PropertyName && IsPropInfoAccessible g amap m ad pinfo then + add pinfo + | MemberKind.PropertySet -> + let pinfo = FSProp(g, ty, None, Some vref) + if checkFilter optFilter vref.PropertyName && IsPropInfoAccessible g amap m ad pinfo then + add pinfo + | _ -> + () + + member x.Close() = [ for KeyValue(_, pinfo) in props -> pinfo ] + +let rec GetImmediateIntrinsicPropInfosOfTypeAux (optFilter, ad) g amap m origTy metadataTy = + + let pinfos = + match metadataOfTy g metadataTy with +#if !NO_EXTENSIONTYPING + | ProvidedTypeMetadata info -> + let st = info.ProvidedType + let matchingProps = + match optFilter with + | Some name -> + match st.PApply((fun st -> st.GetProperty name), m) with + | Tainted.Null -> [||] + | pi -> [|pi|] + | None -> + st.PApplyArray((fun st -> st.GetProperties()), "GetProperties", m) + matchingProps + |> Seq.map(fun pi -> ProvidedProp(amap, pi, m)) + |> List.ofSeq +#endif + + | ILTypeMetadata _ -> + let tinfo = ILTypeInfo.FromType g origTy + let pdefs = tinfo.RawMetadata.Properties + let pdefs = match optFilter with None -> pdefs.AsList | Some nm -> pdefs.LookupByName nm + pdefs |> List.map (fun pdef -> ILProp(ILPropInfo(tinfo, pdef))) + + | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> + // Tuple types also support the properties Item1-8, Rest from the compiled tuple type + // In this case convert to the .NET Tuple type that carries metadata and try again + if isAnyTupleTy g metadataTy || isFunTy g metadataTy then + let betterMetadataTy = convertToTypeWithMetadataIfPossible g metadataTy + GetImmediateIntrinsicPropInfosOfTypeAux (optFilter, ad) g amap m origTy betterMetadataTy + else + match tryTcrefOfAppTy g metadataTy with + | ValueNone -> [] + | ValueSome tcref -> + let propCollector = new PropertyCollector(g, amap, m, origTy, optFilter, ad) + SelectImmediateMemberVals g None (fun membInfo vref -> propCollector.Collect(membInfo, vref); None) tcref |> ignore + propCollector.Close() + + let pinfos = pinfos |> List.filter (IsPropInfoAccessible g amap m ad) + pinfos + +/// Query the immediate properties of an F# type, not taking into account inherited properties. The optFilter +/// parameter is an optional name to restrict the set of properties returned. +let rec GetImmediateIntrinsicPropInfosOfType (optFilter, ad) g amap m ty = + GetImmediateIntrinsicPropInfosOfTypeAux (optFilter, ad) g amap m ty ty + +// Checks whether the given type has an indexer property. +let IsIndexerType g amap ty = + isArray1DTy g ty || + isListTy g ty || + match tryTcrefOfAppTy g ty with + | ValueSome tcref -> + let _, entityTy = generalizeTyconRef tcref + let props = GetImmediateIntrinsicPropInfosOfType (None, AccessibleFromSomeFSharpCode) g amap range0 entityTy + props |> List.exists (fun x -> x.PropertyName = "Item") + | ValueNone -> false + +/// Get the items that are considered the most specific in the hierarchy out of the given items by type. +/// REVIEW: Note complexity O(N^2) +let GetMostSpecificItemsByType g amap f xs = + [ for x in xs do + match f x with + | None -> () + | Some (xTy, m) -> + let isEqual = + xs + |> List.forall (fun y -> + match f y with + | None -> true + | Some (yTy, _) -> + if typeEquiv g xTy yTy then true + else not (TypeFeasiblySubsumesType 0 g amap m xTy CanCoerce yTy)) + if isEqual then + yield x ] + +/// Finds the most specific methods from a method collection by a given method's signature. +let GetMostSpecificMethodInfosByMethInfoSig g amap m (ty, minfo) minfos = + minfos + |> GetMostSpecificItemsByType g amap (fun (ty2, minfo2) -> + let isEqual = + typeEquiv g ty ty2 && + MethInfosEquivByPartialSig EraseNone true g amap m minfo minfo2 + if isEqual then + Some(minfo2.ApparentEnclosingType, m) + else + None) + +/// From the given method sets, filter each set down to the most specific ones. +let FilterMostSpecificMethInfoSets g amap m (minfoSets: NameMultiMap<_>) : NameMultiMap<_> = + minfoSets + |> Map.map (fun _ minfos -> + ([], minfos) + ||> List.fold (fun minfoSpecifics (ty, minfo) -> + let alreadySeen = + minfoSpecifics + |> List.exists (fun (tySpecific, minfoSpecific) -> + typeEquiv g ty tySpecific && + MethInfosEquivByPartialSig EraseNone true g amap m minfo minfoSpecific) + if alreadySeen then + minfoSpecifics + else + GetMostSpecificMethodInfosByMethInfoSig g amap m (ty, minfo) minfos @ minfoSpecifics)) + +/// Sets of methods up the hierarchy, ignoring duplicates by name and sig. +/// Used to collect sets of virtual methods, protected methods, protected +/// properties etc. +type HierarchyItem = + | MethodItem of MethInfo list list + | PropertyItem of PropInfo list list + | RecdFieldItem of RecdFieldInfo + | EventItem of EventInfo list + | ILFieldItem of ILFieldInfo list + +/// An InfoReader is an object to help us read and cache infos. +/// We create one of these for each file we typecheck. +type InfoReader(g: TcGlobals, amap: Import.ImportMap) as this = + + /// Get the declared IL fields of a type, not including inherited fields + let GetImmediateIntrinsicILFieldsOfType (optFilter, ad) m ty = + let infos = + match metadataOfTy g ty with +#if !NO_EXTENSIONTYPING + | ProvidedTypeMetadata info -> + let st = info.ProvidedType + match optFilter with + | None -> + [ for fi in st.PApplyArray((fun st -> st.GetFields()), "GetFields", m) -> ProvidedField(amap, fi, m) ] + | Some name -> + match st.PApply ((fun st -> st.GetField name), m) with + | Tainted.Null -> [] + | fi -> [ ProvidedField(amap, fi, m) ] +#endif + | ILTypeMetadata _ -> + let tinfo = ILTypeInfo.FromType g ty + let fdefs = tinfo.RawMetadata.Fields + let fdefs = match optFilter with None -> fdefs.AsList | Some nm -> fdefs.LookupByName nm + fdefs |> List.map (fun pd -> ILFieldInfo(tinfo, pd)) + | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> + [] + let infos = infos |> List.filter (IsILFieldInfoAccessible g amap m ad) + infos + + /// Get the declared events of a type, not including inherited events, and not including F#-declared CLIEvents + let ComputeImmediateIntrinsicEventsOfType (optFilter, ad) m ty = + let infos = + match metadataOfTy g ty with +#if !NO_EXTENSIONTYPING + | ProvidedTypeMetadata info -> + let st = info.ProvidedType + match optFilter with + | None -> + [ for ei in st.PApplyArray((fun st -> st.GetEvents()), "GetEvents", m) -> ProvidedEvent(amap, ei, m) ] + | Some name -> + match st.PApply ((fun st -> st.GetEvent name), m) with + | Tainted.Null -> [] + | ei -> [ ProvidedEvent(amap, ei, m) ] +#endif + | ILTypeMetadata _ -> + let tinfo = ILTypeInfo.FromType g ty + let edefs = tinfo.RawMetadata.Events + let edefs = match optFilter with None -> edefs.AsList | Some nm -> edefs.LookupByName nm + [ for edef in edefs do + let ileinfo = ILEventInfo(tinfo, edef) + if IsILEventInfoAccessible g amap m ad ileinfo then + yield ILEvent ileinfo ] + | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> + [] + infos + + /// Make a reference to a record or class field + let MakeRecdFieldInfo g ty (tcref: TyconRef) fspec = + RecdFieldInfo(argsOfAppTy g ty, tcref.MakeNestedRecdFieldRef fspec) + + /// Get the F#-declared record fields or class 'val' fields of a type + let GetImmediateIntrinsicRecdOrClassFieldsOfType (optFilter, _ad) _m ty = + match tryTcrefOfAppTy g ty with + | ValueNone -> [] + | ValueSome tcref -> + // Note;secret fields are not allowed in lookups here, as we're only looking + // up user-visible fields in name resolution. + match optFilter with + | Some nm -> + match tcref.GetFieldByName nm with + | Some rfield when not rfield.IsCompilerGenerated -> [MakeRecdFieldInfo g ty tcref rfield] + | _ -> [] + | None -> + [ for fdef in tcref.AllFieldsArray do + if not fdef.IsCompilerGenerated then + yield MakeRecdFieldInfo g ty tcref fdef ] + + + /// The primitive reader for the method info sets up a hierarchy + let GetIntrinsicMethodSetsUncached ((optFilter, ad, allowMultiIntfInst), m, ty) = + FoldPrimaryHierarchyOfType (fun ty acc -> GetImmediateIntrinsicMethInfosOfType (optFilter, ad) g amap m ty :: acc) g amap m allowMultiIntfInst ty [] + + /// The primitive reader for the property info sets up a hierarchy + let GetIntrinsicPropertySetsUncached ((optFilter, ad, allowMultiIntfInst), m, ty) = + FoldPrimaryHierarchyOfType (fun ty acc -> GetImmediateIntrinsicPropInfosOfType (optFilter, ad) g amap m ty :: acc) g amap m allowMultiIntfInst ty [] + + let GetIntrinsicILFieldInfosUncached ((optFilter, ad), m, ty) = + FoldPrimaryHierarchyOfType (fun ty acc -> GetImmediateIntrinsicILFieldsOfType (optFilter, ad) m ty @ acc) g amap m AllowMultiIntfInstantiations.Yes ty [] + + let GetIntrinsicEventInfosUncached ((optFilter, ad), m, ty) = + FoldPrimaryHierarchyOfType (fun ty acc -> ComputeImmediateIntrinsicEventsOfType (optFilter, ad) m ty @ acc) g amap m AllowMultiIntfInstantiations.Yes ty [] + + let GetIntrinsicRecdOrClassFieldInfosUncached ((optFilter, ad), m, ty) = + FoldPrimaryHierarchyOfType (fun ty acc -> GetImmediateIntrinsicRecdOrClassFieldsOfType (optFilter, ad) m ty @ acc) g amap m AllowMultiIntfInstantiations.Yes ty [] + + let GetEntireTypeHierarchyUncached (allowMultiIntfInst, m, ty) = + FoldEntireHierarchyOfType (fun ty acc -> ty :: acc) g amap m allowMultiIntfInst ty [] + + let GetPrimaryTypeHierarchyUncached (allowMultiIntfInst, m, ty) = + FoldPrimaryHierarchyOfType (fun ty acc -> ty :: acc) g amap m allowMultiIntfInst ty [] + + /// The primitive reader for the named items up a hierarchy + let GetIntrinsicNamedItemsUncached ((nm, ad), m, ty) = + if nm = ".ctor" then None else // '.ctor' lookups only ever happen via constructor syntax + let optFilter = Some nm + FoldPrimaryHierarchyOfType (fun ty acc -> + let minfos = GetImmediateIntrinsicMethInfosOfType (optFilter, ad) g amap m ty + let pinfos = GetImmediateIntrinsicPropInfosOfType (optFilter, ad) g amap m ty + let finfos = GetImmediateIntrinsicILFieldsOfType (optFilter, ad) m ty + let einfos = ComputeImmediateIntrinsicEventsOfType (optFilter, ad) m ty + let rfinfos = GetImmediateIntrinsicRecdOrClassFieldsOfType (optFilter, ad) m ty + match acc with + | Some(MethodItem(inheritedMethSets)) when not (isNil minfos) -> Some(MethodItem (minfos :: inheritedMethSets)) + | _ when not (isNil minfos) -> Some(MethodItem ([minfos])) + | Some(PropertyItem(inheritedPropSets)) when not (isNil pinfos) -> Some(PropertyItem(pinfos :: inheritedPropSets)) + | _ when not (isNil pinfos) -> Some(PropertyItem([pinfos])) + | _ when not (isNil finfos) -> Some(ILFieldItem(finfos)) + | _ when not (isNil einfos) -> Some(EventItem(einfos)) + | _ when not (isNil rfinfos) -> + match rfinfos with + | [single] -> Some(RecdFieldItem(single)) + | _ -> failwith "Unexpected multiple fields with the same name" // Because an explicit name (i.e., nm) was supplied, there will be only one element at most. + | _ -> acc) + g amap m + AllowMultiIntfInstantiations.Yes + ty + None + + let GetImmediateIntrinsicOverrideMethodSetsOfType optFilter m (interfaceTys: TType list) ty acc = + match tryAppTy g ty with + | ValueSome (tcref, _) when tcref.IsILTycon && tcref.ILTyconRawMetadata.IsInterface -> + let mimpls = tcref.ILTyconRawMetadata.MethodImpls.AsList + let mdefs = tcref.ILTyconRawMetadata.Methods + + // MethodImpls contains a list of methods that override. + // OverrideBy is the method that does the overriding. + // Overrides is the method being overriden. + (acc, mimpls) + ||> List.fold (fun acc ilMethImpl -> + let overridesName = ilMethImpl.Overrides.MethodRef.Name + let overrideBy = ilMethImpl.OverrideBy + let canAccumulate = + match optFilter with + | None -> true + | Some name when name = overridesName -> true + | _ -> false + if canAccumulate then + match mdefs.TryFindInstanceByNameAndCallingSignature (overrideBy.Name, overrideBy.MethodRef.CallingSignature) with + | Some mdef -> + let overridesILTy = ilMethImpl.Overrides.DeclaringType + let overridesTyFullName = overridesILTy.TypeRef.FullName + let overridesTyOpt = + interfaceTys + |> List.tryPick (fun ty -> + match tryTcrefOfAppTy g ty with + | ValueSome tcref when tcref.IsILTycon && tcref.ILTyconRawMetadata.Name = overridesTyFullName -> + generalizedTyconRef tcref + |> Some + | _ -> + None) + match overridesTyOpt with + | Some overridesTy -> + NameMultiMap.add overridesName (overridesTy, MethInfo.CreateILMeth(amap, m, ty, mdef)) acc + | _ -> + acc + | _ -> + acc + else + acc) + | _ -> acc + + /// Visiting each type in the hierarchy and accumulate most specific methods that are the OverrideBy target from types. + let GetIntrinsicMostSpecificOverrideMethodSetsUncached ((optFilter, _ad, allowMultiIntfInst), m, ty) : NameMultiMap<_> = + let interfaceTys = + FoldPrimaryHierarchyOfType (fun ty acc -> + if isInterfaceTy g ty then ty :: acc + else acc) g amap m allowMultiIntfInst ty [] + + (NameMultiMap.Empty, interfaceTys) + ||> List.fold (fun acc ty -> GetImmediateIntrinsicOverrideMethodSetsOfType optFilter m interfaceTys ty acc) + |> FilterMostSpecificMethInfoSets g amap m + + /// Make a cache for function 'f' keyed by type (plus some additional 'flags') that only + /// caches computations for monomorphic types. + + let MakeInfoCache f (flagsEq : System.Collections.Generic.IEqualityComparer<_>) = + new MemoizationTable<_, _> + (compute=f, + // Only cache closed, monomorphic types (closed = all members for the type + // have been processed). Generic type instantiations could be processed if we had + // a decent hash function for these. + canMemoize=(fun (_flags, (_: range), ty) -> + match stripTyEqns g ty with + | TType_app(tcref, []) -> tcref.TypeContents.tcaug_closed + | _ -> false), + + keyComparer= + { new System.Collections.Generic.IEqualityComparer<_> with + member x.Equals((flags1, _, typ1), (flags2, _, typ2)) = + // Ignoring the ranges - that's OK. + flagsEq.Equals(flags1, flags2) && + match stripTyEqns g typ1, stripTyEqns g typ2 with + | TType_app(tcref1, []), TType_app(tcref2, []) -> tyconRefEq g tcref1 tcref2 + | _ -> false + member x.GetHashCode((flags, _, ty)) = + // Ignoring the ranges - that's OK. + flagsEq.GetHashCode flags + + (match stripTyEqns g ty with + | TType_app(tcref, []) -> hash tcref.LogicalName + | _ -> 0) }) + + let hashFlags0 = + { new System.Collections.Generic.IEqualityComparer<_> with + member x.GetHashCode((filter: string option, ad: AccessorDomain, _allowMultiIntfInst1)) = hash filter + AccessorDomain.CustomGetHashCode ad + member x.Equals((filter1, ad1, allowMultiIntfInst1), (filter2, ad2, allowMultiIntfInst2)) = + (filter1 = filter2) && AccessorDomain.CustomEquals(g, ad1, ad2) && allowMultiIntfInst1 = allowMultiIntfInst2 } + + let hashFlags1 = + { new System.Collections.Generic.IEqualityComparer<_> with + member x.GetHashCode((filter: string option, ad: AccessorDomain)) = hash filter + AccessorDomain.CustomGetHashCode ad + member x.Equals((filter1, ad1), (filter2, ad2)) = (filter1 = filter2) && AccessorDomain.CustomEquals(g, ad1, ad2) } + + let hashFlags2 = + { new System.Collections.Generic.IEqualityComparer<_> with + member x.GetHashCode((nm: string, ad: AccessorDomain)) = hash nm + AccessorDomain.CustomGetHashCode ad + member x.Equals((nm1, ad1), (nm2, ad2)) = (nm1 = nm2) && AccessorDomain.CustomEquals(g, ad1, ad2) } + + let methodInfoCache = MakeInfoCache GetIntrinsicMethodSetsUncached hashFlags0 + let propertyInfoCache = MakeInfoCache GetIntrinsicPropertySetsUncached hashFlags0 + let recdOrClassFieldInfoCache = MakeInfoCache GetIntrinsicRecdOrClassFieldInfosUncached hashFlags1 + let ilFieldInfoCache = MakeInfoCache GetIntrinsicILFieldInfosUncached hashFlags1 + let eventInfoCache = MakeInfoCache GetIntrinsicEventInfosUncached hashFlags1 + let namedItemsCache = MakeInfoCache GetIntrinsicNamedItemsUncached hashFlags2 + let mostSpecificOverrideMethodInfoCache = MakeInfoCache GetIntrinsicMostSpecificOverrideMethodSetsUncached hashFlags0 + + let entireTypeHierarchyCache = MakeInfoCache GetEntireTypeHierarchyUncached HashIdentity.Structural + let primaryTypeHierarchyCache = MakeInfoCache GetPrimaryTypeHierarchyUncached HashIdentity.Structural + + // Runtime feature support + + let isRuntimeFeatureSupported (infoReader: InfoReader) runtimeFeature = + match g.System_Runtime_CompilerServices_RuntimeFeature_ty with + | Some runtimeFeatureTy -> + infoReader.GetILFieldInfosOfType (None, AccessorDomain.AccessibleFromEverywhere, range0, runtimeFeatureTy) + |> List.exists (fun (ilFieldInfo: ILFieldInfo) -> ilFieldInfo.FieldName = runtimeFeature) + | _ -> + false + + let isRuntimeFeatureDefaultImplementationsOfInterfacesSupported = + lazy isRuntimeFeatureSupported this "DefaultImplementationsOfInterfaces" + + member x.g = g + member x.amap = amap + + /// Read the raw method sets of a type, including inherited ones. Cache the result for monomorphic types + member x.GetRawIntrinsicMethodSetsOfType (optFilter, ad, allowMultiIntfInst, m, ty) = + methodInfoCache.Apply(((optFilter, ad, allowMultiIntfInst), m, ty)) + + /// Read the raw property sets of a type, including inherited ones. Cache the result for monomorphic types + member x.GetRawIntrinsicPropertySetsOfType (optFilter, ad, allowMultiIntfInst, m, ty) = + propertyInfoCache.Apply(((optFilter, ad, allowMultiIntfInst), m, ty)) + + /// Read the record or class fields of a type, including inherited ones. Cache the result for monomorphic types. + member x.GetRecordOrClassFieldsOfType (optFilter, ad, m, ty) = + recdOrClassFieldInfoCache.Apply(((optFilter, ad), m, ty)) + + /// Read the IL fields of a type, including inherited ones. Cache the result for monomorphic types. + member x.GetILFieldInfosOfType (optFilter, ad, m, ty) = + ilFieldInfoCache.Apply(((optFilter, ad), m, ty)) + + member x.GetImmediateIntrinsicEventsOfType (optFilter, ad, m, ty) = ComputeImmediateIntrinsicEventsOfType (optFilter, ad) m ty + + /// Read the events of a type, including inherited ones. Cache the result for monomorphic types. + member x.GetEventInfosOfType (optFilter, ad, m, ty) = + eventInfoCache.Apply(((optFilter, ad), m, ty)) + + /// Try and find a record or class field for a type. + member x.TryFindRecdOrClassFieldInfoOfType (nm, m, ty) = + match recdOrClassFieldInfoCache.Apply((Some nm, AccessibleFromSomewhere), m, ty) with + | [] -> ValueNone + | [single] -> ValueSome single + | flds -> + // multiple fields with the same name can come from different classes, + // so filter them by the given type name + match tryTcrefOfAppTy g ty with + | ValueNone -> ValueNone + | ValueSome tcref -> + match flds |> List.filter (fun rfinfo -> tyconRefEq g tcref rfinfo.TyconRef) with + | [] -> ValueNone + | [single] -> ValueSome single + | _ -> failwith "unexpected multiple fields with same name" // Because it should have been already reported as duplicate fields + + /// Try and find an item with the given name in a type. + member x.TryFindNamedItemOfType (nm, ad, m, ty) = + namedItemsCache.Apply(((nm, ad), m, ty)) + + /// Read the raw method sets of a type that are the most specific overrides. Cache the result for monomorphic types + member x.GetIntrinsicMostSpecificOverrideMethodSetsOfType (optFilter, ad, allowMultiIntfInst, m, ty) = + mostSpecificOverrideMethodInfoCache.Apply(((optFilter, ad, allowMultiIntfInst), m, ty)) + + /// Get the super-types of a type, including interface types. + member x.GetEntireTypeHierarchy (allowMultiIntfInst, m, ty) = + entireTypeHierarchyCache.Apply((allowMultiIntfInst, m, ty)) + + /// Get the super-types of a type, excluding interface types. + member x.GetPrimaryTypeHierarchy (allowMultiIntfInst, m, ty) = + primaryTypeHierarchyCache.Apply((allowMultiIntfInst, m, ty)) + + /// Check if the given language feature is supported by the runtime. + member x.IsLanguageFeatureRuntimeSupported langFeature = + match langFeature with + // Both default and static interface method consumption features are tied to the runtime support of DIMs. + | LanguageFeature.DefaultInterfaceMemberConsumption -> isRuntimeFeatureDefaultImplementationsOfInterfacesSupported.Value + | _ -> true + +let private tryLanguageFeatureRuntimeErrorAux (infoReader: InfoReader) langFeature m error = + if not (infoReader.IsLanguageFeatureRuntimeSupported langFeature) then + let featureStr = infoReader.g.langVersion.GetFeatureString langFeature + error (Error(FSComp.SR.chkFeatureNotRuntimeSupported featureStr, m)) + false + else + true + +let checkLanguageFeatureRuntimeError infoReader langFeature m = + tryLanguageFeatureRuntimeErrorAux infoReader langFeature m error |> ignore + +let checkLanguageFeatureRuntimeErrorRecover infoReader langFeature m = + tryLanguageFeatureRuntimeErrorAux infoReader langFeature m errorR |> ignore + +let tryLanguageFeatureRuntimeErrorRecover infoReader langFeature m = + tryLanguageFeatureRuntimeErrorAux infoReader langFeature m errorR + +/// Get the declared constructors of any F# type +let rec GetIntrinsicConstructorInfosOfTypeAux (infoReader: InfoReader) m origTy metadataTy = + protectAssemblyExploration [] (fun () -> + let g = infoReader.g + let amap = infoReader.amap + match metadataOfTy g metadataTy with +#if !NO_EXTENSIONTYPING + | ProvidedTypeMetadata info -> + let st = info.ProvidedType + [ for ci in st.PApplyArray((fun st -> st.GetConstructors()), "GetConstructors", m) do + yield ProvidedMeth(amap, ci.Coerce(m), None, m) ] +#endif + | ILTypeMetadata _ -> + let tinfo = ILTypeInfo.FromType g origTy + tinfo.RawMetadata.Methods.FindByName ".ctor" + |> List.filter (fun md -> md.IsConstructor) + |> List.map (fun mdef -> MethInfo.CreateILMeth (amap, m, origTy, mdef)) + + | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> + // Tuple types also support constructors. In this case convert to the .NET Tuple type that carries metadata and try again + // Function types also support constructors. In this case convert to the FSharpFunc type that carries metadata and try again + if isAnyTupleTy g metadataTy || isFunTy g metadataTy then + let betterMetadataTy = convertToTypeWithMetadataIfPossible g metadataTy + GetIntrinsicConstructorInfosOfTypeAux infoReader m origTy betterMetadataTy + else + match tryTcrefOfAppTy g metadataTy with + | ValueNone -> [] + | ValueSome tcref -> + tcref.MembersOfFSharpTyconByName + |> NameMultiMap.find ".ctor" + |> List.choose(fun vref -> + match vref.MemberInfo with + | Some membInfo when (membInfo.MemberFlags.MemberKind = MemberKind.Constructor) -> Some vref + | _ -> None) + |> List.map (fun x -> FSMeth(g, origTy, x, None)) + ) + +let GetIntrinsicConstructorInfosOfType infoReader m ty = + GetIntrinsicConstructorInfosOfTypeAux infoReader m ty ty + + + +//------------------------------------------------------------------------- +// Collecting methods and properties taking into account hiding rules in the hierarchy + + +/// Indicates if we prefer overrides or abstract slots. +type FindMemberFlag = + /// Prefer items toward the top of the hierarchy, which we do if the items are virtual + /// but not when resolving base calls. + | IgnoreOverrides + /// Get overrides instead of abstract slots when measuring whether a class/interface implements all its required slots. + | PreferOverrides + +/// The input list is sorted from most-derived to least-derived type, so any System.Object methods +/// are at the end of the list. Return a filtered list where prior/subsequent members matching by name and +/// that are in the same equivalence class have been removed. We keep a name-indexed table to +/// be more efficient when we check to see if we've already seen a particular named method. +type private IndexedList<'T>(itemLists: 'T list list, itemsByName: NameMultiMap<'T>) = + + /// Get the item sets + member x.Items = itemLists + + /// Get the items with a particular name + member x.ItemsWithName(nm) = NameMultiMap.find nm itemsByName + + /// Add new items, extracting the names using the given function. + member x.AddItems(items, nmf) = IndexedList<'T>(items :: itemLists, List.foldBack (fun x acc -> NameMultiMap.add (nmf x) x acc) items itemsByName ) + + /// Get an empty set of items + static member Empty = IndexedList<'T>([], NameMultiMap.empty) + + /// Filter a set of new items to add according to the content of the list. Only keep an item + /// if it passes 'keepTest' for all matching items already in the list. + member x.FilterNewItems keepTest nmf itemsToAdd = + // Have we already seen an item with the same name and that is in the same equivalence class? + // If so, ignore this one. Note we can check against the original incoming 'ilist' because we are assuming that + // none the elements of 'itemsToAdd' are equivalent. + itemsToAdd |> List.filter (fun item -> List.forall (keepTest item) (x.ItemsWithName(nmf item))) + +/// Add all the items to the IndexedList, preferring the ones in the super-types. This is used to hide methods +/// in super classes and/or hide overrides of methods in subclasses. +/// +/// Assume no items in 'items' are equivalent according to 'equivTest'. This is valid because each step in a +/// .NET class hierarchy introduces a consistent set of methods, none of which hide each other within the +/// given set. This is an important optimization because it means we don't have filter for equivalence between the +/// large overload sets introduced by methods like System.WriteLine. +/// +/// Assume items can be given names by 'nmf', where two items with different names are +/// not equivalent. + +let private FilterItemsInSubTypesBasedOnItemsInSuperTypes nmf keepTest itemLists = + let rec loop itemLists = + match itemLists with + | [] -> IndexedList.Empty + | items :: itemsInSuperTypes -> + let ilist = loop itemsInSuperTypes + let itemsToAdd = ilist.FilterNewItems keepTest nmf items + ilist.AddItems(itemsToAdd, nmf) + (loop itemLists).Items + +/// Add all the items to the IndexedList, preferring the ones in the sub-types. +let private FilterItemsInSuperTypesBasedOnItemsInSubTypes nmf keepTest itemLists = + let rec loop itemLists (indexedItemsInSubTypes: IndexedList<_>) = + match itemLists with + | [] -> List.rev indexedItemsInSubTypes.Items + | items :: itemsInSuperTypes -> + let itemsToAdd = items |> List.filter (fun item -> keepTest item (indexedItemsInSubTypes.ItemsWithName(nmf item))) + let ilist = indexedItemsInSubTypes.AddItems(itemsToAdd, nmf) + loop itemsInSuperTypes ilist + + loop itemLists IndexedList.Empty + +let private ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes nmf equivTest itemLists = + FilterItemsInSuperTypesBasedOnItemsInSubTypes nmf (fun item1 items -> not (items |> List.exists (fun item2 -> equivTest item1 item2))) itemLists + +/// Filter the overrides of methods or properties, either keeping the overrides or keeping the dispatch slots. +let private FilterOverrides findFlag (isVirt:'a->bool, isNewSlot, isDefiniteOverride, isFinal, equivSigs, nmf:'a->string) items = + let equivVirts x y = isVirt x && isVirt y && equivSigs x y + + match findFlag with + | PreferOverrides -> + items + // For each F#-declared override, get rid of any equivalent abstract member in the same type + // This is because F# abstract members with default overrides give rise to two members with the + // same logical signature in the same type, e.g. + // type ClassType1() = + // abstract VirtualMethod1: string -> int + // default x.VirtualMethod1(s) = 3 + + |> List.map (fun items -> + let definiteOverrides = items |> List.filter isDefiniteOverride + items |> List.filter (fun item -> (isDefiniteOverride item || not (List.exists (equivVirts item) definiteOverrides)))) + + // only keep virtuals that are not signature-equivalent to virtuals in subtypes + |> ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes nmf equivVirts + | IgnoreOverrides -> + let equivNewSlots x y = isNewSlot x && isNewSlot y && equivSigs x y + items + // Remove any F#-declared overrides. These may occur in the same type as the abstract member (unlike with .NET metadata) + // Include any 'newslot' declared methods. + |> List.map (List.filter (fun x -> not (isDefiniteOverride x))) + + // Remove any virtuals that are signature-equivalent to virtuals in subtypes, except for newslots + // That is, keep if it's + /// (a) not virtual + // (b) is a new slot or + // (c) not equivalent + // We keep virtual finals around for error detection later on + |> FilterItemsInSubTypesBasedOnItemsInSuperTypes nmf (fun newItem priorItem -> + (isVirt newItem && isFinal newItem) || not (isVirt newItem) || isNewSlot newItem || not (equivVirts newItem priorItem) ) + + // Remove any abstract slots in supertypes that are (a) hidden by another newslot and (b) implemented + // We leave unimplemented ones around to give errors, e.g. for + // [] + // type PA() = + // abstract M : int -> unit + // + // [] + // type PB<'a>() = + // inherit PA() + // abstract M : 'a -> unit + // + // [] + // type PC() = + // inherit PB() + // // Here, PA.M and PB.M have the same signature, so PA.M is unimplementable. + // // REVIEW: in future we may give a friendly error at this point + // + // type PD() = + // inherit PC() + // override this.M(x: int) = () + + |> FilterItemsInSuperTypesBasedOnItemsInSubTypes nmf (fun item1 superTypeItems -> + not (isNewSlot item1 && + superTypeItems |> List.exists (equivNewSlots item1) && + superTypeItems |> List.exists (fun item2 -> isDefiniteOverride item1 && equivVirts item1 item2))) + + +/// Filter the overrides of methods, either keeping the overrides or keeping the dispatch slots. +let private FilterOverridesOfMethInfos findFlag g amap m minfos = + minfos + |> FilterOverrides findFlag + ((fun (minfo: MethInfo) -> minfo.IsVirtual), + (fun minfo -> minfo.IsNewSlot), + (fun minfo -> minfo.IsDefiniteFSharpOverride), + (fun minfo -> minfo.IsFinal), + MethInfosEquivByNameAndSig EraseNone true g amap m, + (fun minfo -> minfo.LogicalName)) + +/// Filter the overrides of properties, either keeping the overrides or keeping the dispatch slots. +let private FilterOverridesOfPropInfos findFlag g amap m props = + props + |> FilterOverrides findFlag + ((fun (pinfo: PropInfo) -> pinfo.IsVirtualProperty), + (fun pinfo -> pinfo.IsNewSlot), + (fun pinfo -> pinfo.IsDefiniteFSharpOverride), + (fun _ -> false), + PropInfosEquivByNameAndSig EraseNone g amap m, + (fun pinfo -> pinfo.PropertyName)) + +/// Exclude methods from super types which have the same signature as a method in a more specific type. +let ExcludeHiddenOfMethInfos g amap m (minfos: MethInfo list list) = + minfos + |> ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes + (fun minfo -> minfo.LogicalName) + (fun m1 m2 -> + // only hide those truly from super classes + not (tyconRefEq g m1.DeclaringTyconRef m2.DeclaringTyconRef) && + MethInfosEquivByNameAndPartialSig EraseNone true g amap m m1 m2) + + |> List.concat + +/// Exclude properties from super types which have the same name as a property in a more specific type. +let ExcludeHiddenOfPropInfos g amap m pinfos = + pinfos + |> ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes (fun (pinfo: PropInfo) -> pinfo.PropertyName) (PropInfosEquivByNameAndPartialSig EraseNone g amap m) + |> List.concat + +/// Get the sets of intrinsic methods in the hierarchy (not including extension methods) +let GetIntrinsicMethInfoSetsOfType (infoReader:InfoReader) optFilter ad allowMultiIntfInst findFlag m ty = + infoReader.GetRawIntrinsicMethodSetsOfType(optFilter, ad, allowMultiIntfInst, m, ty) + |> FilterOverridesOfMethInfos findFlag infoReader.g infoReader.amap m + +/// Get the sets intrinsic properties in the hierarchy (not including extension properties) +let GetIntrinsicPropInfoSetsOfType (infoReader:InfoReader) optFilter ad allowMultiIntfInst findFlag m ty = + infoReader.GetRawIntrinsicPropertySetsOfType(optFilter, ad, allowMultiIntfInst, m, ty) + |> FilterOverridesOfPropInfos findFlag infoReader.g infoReader.amap m + +/// Get the flattened list of intrinsic methods in the hierarchy +let GetIntrinsicMethInfosOfType infoReader optFilter ad allowMultiIntfInst findFlag m ty = + GetIntrinsicMethInfoSetsOfType infoReader optFilter ad allowMultiIntfInst findFlag m ty |> List.concat + +/// Get the flattened list of intrinsic properties in the hierarchy +let GetIntrinsicPropInfosOfType infoReader optFilter ad allowMultiIntfInst findFlag m ty = + GetIntrinsicPropInfoSetsOfType infoReader optFilter ad allowMultiIntfInst findFlag m ty |> List.concat + +/// Perform type-directed name resolution of a particular named member in an F# type +let TryFindIntrinsicNamedItemOfType (infoReader: InfoReader) (nm, ad) findFlag m ty = + match infoReader.TryFindNamedItemOfType(nm, ad, m, ty) with + | Some item -> + match item with + | PropertyItem psets -> Some(PropertyItem (psets |> FilterOverridesOfPropInfos findFlag infoReader.g infoReader.amap m)) + | MethodItem msets -> Some(MethodItem (msets |> FilterOverridesOfMethInfos findFlag infoReader.g infoReader.amap m)) + | _ -> Some(item) + | None -> None + +/// Try to detect the existence of a method on a type. +/// Used for +/// -- getting the GetEnumerator, get_Current, MoveNext methods for enumerable types +/// -- getting the Dispose method when resolving the 'use' construct +/// -- getting the various methods used to desugar the computation expression syntax +let TryFindIntrinsicMethInfo infoReader m ad nm ty = + GetIntrinsicMethInfosOfType infoReader (Some nm) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides m ty + +/// Try to find a particular named property on a type. Only used to ensure that local 'let' definitions and property names +/// are distinct, a somewhat adhoc check in tc.fs. +let TryFindPropInfo infoReader m ad nm ty = + GetIntrinsicPropInfosOfType infoReader (Some nm) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides m ty + +/// Get a set of most specific override methods. +let GetIntrinisicMostSpecificOverrideMethInfoSetsOfType (infoReader: InfoReader) m ty = + infoReader.GetIntrinsicMostSpecificOverrideMethodSetsOfType (None, AccessibleFromSomewhere, AllowMultiIntfInstantiations.Yes, m, ty) + +//------------------------------------------------------------------------- +// Helpers related to delegates and events - these use method searching hence are in this file +//------------------------------------------------------------------------- + +/// The Invoke MethInfo, the function argument types, the function return type +/// and the overall F# function type for the function type associated with a .NET delegate type +[] +type SigOfFunctionForDelegate = SigOfFunctionForDelegate of MethInfo * TType list * TType * TType + +/// Given a delegate type work out the minfo, argument types, return type +/// and F# function type by looking at the Invoke signature of the delegate. +let GetSigOfFunctionForDelegate (infoReader: InfoReader) delty m ad = + let g = infoReader.g + let amap = infoReader.amap + let invokeMethInfo = + match GetIntrinsicMethInfosOfType infoReader (Some "Invoke") ad AllowMultiIntfInstantiations.Yes IgnoreOverrides m delty with + | [h] -> h + | [] -> error(Error(FSComp.SR.noInvokeMethodsFound (), m)) + | h :: _ -> warning(InternalError(FSComp.SR.moreThanOneInvokeMethodFound (), m)); h + + let minst = [] // a delegate's Invoke method is never generic + let compiledViewOfDelArgTys = + match invokeMethInfo.GetParamTypes(amap, m, minst) with + | [args] -> args + | _ -> error(Error(FSComp.SR.delegatesNotAllowedToHaveCurriedSignatures (), m)) + let fsharpViewOfDelArgTys = + match compiledViewOfDelArgTys with + | [] -> [g.unit_ty] + | _ -> compiledViewOfDelArgTys + let delRetTy = invokeMethInfo.GetFSharpReturnTy(amap, m, minst) + CheckMethInfoAttributes g m None invokeMethInfo |> CommitOperationResult + let fty = mkIteratedFunTy fsharpViewOfDelArgTys delRetTy + SigOfFunctionForDelegate(invokeMethInfo, compiledViewOfDelArgTys, delRetTy, fty) + +/// Try and interpret a delegate type as a "standard" .NET delegate type associated with an event, with a "sender" parameter. +let TryDestStandardDelegateType (infoReader: InfoReader) m ad delTy = + let g = infoReader.g + let (SigOfFunctionForDelegate(_, compiledViewOfDelArgTys, delRetTy, _)) = GetSigOfFunctionForDelegate infoReader delTy m ad + match compiledViewOfDelArgTys with + | senderTy :: argTys when (isObjTy g senderTy) && not (List.exists (isByrefTy g) argTys) -> Some(mkRefTupledTy g argTys, delRetTy) + | _ -> None + + +/// Indicates if an event info is associated with a delegate type that is a "standard" .NET delegate type +/// with a sender parameter. +// +/// In the F# design, we take advantage of the following idiom to simplify away the bogus "object" parameter of the +/// of the "Add" methods associated with events. If you want to access it you +/// can use AddHandler instead. + +/// The .NET Framework guidelines indicate that the delegate type used for +/// an event should take two parameters, an "object source" parameter +/// indicating the source of the event, and an "e" parameter that +/// encapsulates any additional information about the event. The type of +/// the "e" parameter should derive from the EventArgs class. For events +/// that do not use any additional information, the .NET Framework has +/// already defined an appropriate delegate type: EventHandler. +/// (from http://msdn.microsoft.com/library/default.asp?url=/library/en-us/csref/html/vcwlkEventsTutorial.asp) +let IsStandardEventInfo (infoReader: InfoReader) m ad (einfo: EventInfo) = + let dty = einfo.GetDelegateType(infoReader.amap, m) + match TryDestStandardDelegateType infoReader m ad dty with + | Some _ -> true + | None -> false + +/// Get the (perhaps tupled) argument type accepted by an event +let ArgsTypOfEventInfo (infoReader: InfoReader) m ad (einfo: EventInfo) = + let amap = infoReader.amap + let dty = einfo.GetDelegateType(amap, m) + match TryDestStandardDelegateType infoReader m ad dty with + | Some(argtys, _) -> argtys + | None -> error(nonStandardEventError einfo.EventName m) + +/// Get the type of the event when looked at as if it is a property +/// Used when displaying the property in Intellisense +let PropTypOfEventInfo (infoReader: InfoReader) m ad (einfo: EventInfo) = + let g = infoReader.g + let amap = infoReader.amap + let delTy = einfo.GetDelegateType(amap, m) + let argsTy = ArgsTypOfEventInfo infoReader m ad einfo + mkIEventType g delTy argsTy diff --git a/src/fsharp/MethodCalls.fsi b/src/fsharp/MethodCalls.fsi new file mode 100644 index 00000000000..2c643411d90 --- /dev/null +++ b/src/fsharp/MethodCalls.fsi @@ -0,0 +1,1972 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +/// Logic associated with resolving method calls. +module internal FSharp.Compiler.MethodCalls + +open Internal.Utilities + +open FSharp.Compiler +open FSharp.Compiler.AbstractIL.IL +open FSharp.Compiler.AbstractIL.Internal.Library +open FSharp.Compiler.AccessibilityLogic +open FSharp.Compiler.AttributeChecking +open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.Features +open FSharp.Compiler.InfoReader +open FSharp.Compiler.Infos +open FSharp.Compiler.Lib +open FSharp.Compiler.NameResolution +open FSharp.Compiler.PrettyNaming +open FSharp.Compiler.Range +open FSharp.Compiler.SyntaxTree +open FSharp.Compiler.SyntaxTreeOps +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeBasics +open FSharp.Compiler.TypedTreeOps +open FSharp.Compiler.TypedTreeOps.DebugPrint +open FSharp.Compiler.TypeRelations + +#if !NO_EXTENSIONTYPING +open FSharp.Compiler.ExtensionTyping +#endif + +//------------------------------------------------------------------------- +// Sets of methods involved in overload resolution and trait constraint +// satisfaction. +//------------------------------------------------------------------------- + +/// In the following, 'T gets instantiated to: +/// 1. the expression being supplied for an argument +/// 2. "unit", when simply checking for the existence of an overload that satisfies +/// a signature, or when finding the corresponding witness. +/// Note the parametricity helps ensure that overload resolution doesn't depend on the +/// expression on the callside (though it is in some circumstances allowed +/// to depend on some type information inferred syntactically from that +/// expression, e.g. a lambda expression may be converted to a delegate as +/// an adhoc conversion. +/// +/// The bool indicates if named using a '?', making the caller argument explicit-optional +type CallerArg<'T> = + /// CallerArg(ty, range, isOpt, exprInfo) + | CallerArg of ty: TType * range: range * isOpt: bool * exprInfo: 'T + + member x.CallerArgumentType = (let (CallerArg(ty, _, _, _)) = x in ty) + + member x.Range = (let (CallerArg(_, m, _, _)) = x in m) + + member x.IsExplicitOptional = (let (CallerArg(_, _, isOpt, _)) = x in isOpt) + + member x.Expr = (let (CallerArg(_, _, _, expr)) = x in expr) + +/// Represents the information about an argument in the method being called +type CalledArg = + { Position: struct (int * int) + IsParamArray : bool + OptArgInfo : OptionalArgInfo + CallerInfo : CallerInfo + IsInArg: bool + IsOutArg: bool + ReflArgInfo: ReflectedArgInfo + NameOpt: Ident option + CalledArgumentType : TType } + +let CalledArg (pos, isParamArray, optArgInfo, callerInfo, isInArg, isOutArg, nameOpt, reflArgInfo, calledArgTy) = + { Position=pos + IsParamArray=isParamArray + OptArgInfo=optArgInfo + CallerInfo=callerInfo + IsInArg=isInArg + IsOutArg=isOutArg + ReflArgInfo=reflArgInfo + NameOpt=nameOpt + CalledArgumentType=calledArgTy } + +/// Represents a match between a caller argument and a called argument, arising from either +/// a named argument or an unnamed argument. +type AssignedCalledArg<'T> = + + { /// The identifier for a named argument, if any + NamedArgIdOpt : Ident option + + /// The called argument in the method + CalledArg: CalledArg + + /// The argument on the caller side + CallerArg: CallerArg<'T> } + + member x.Position = x.CalledArg.Position + +/// Represents the possibilities for a named-setter argument (a property, field, or a record field setter) +type AssignedItemSetterTarget = + | AssignedPropSetter of PropInfo * MethInfo * TypeInst (* the MethInfo is a non-indexer setter property *) + | AssignedILFieldSetter of ILFieldInfo + | AssignedRecdFieldSetter of RecdFieldInfo + +/// Represents the resolution of a caller argument as a named-setter argument +type AssignedItemSetter<'T> = AssignedItemSetter of Ident * AssignedItemSetterTarget * CallerArg<'T> + +type CallerNamedArg<'T> = + | CallerNamedArg of Ident * CallerArg<'T> + + member x.Ident = (let (CallerNamedArg(id, _)) = x in id) + + member x.Name = x.Ident.idText + + member x.CallerArg = (let (CallerNamedArg(_, a)) = x in a) + +/// Represents the list of unnamed / named arguments at method call site +/// remark: The usage of list list is due to tupling and currying of arguments, +/// stemming from SynValInfo in the AST. +[] +type CallerArgs<'T> = + { + Unnamed: CallerArg<'T> list list + Named: CallerNamedArg<'T> list list + } + static member Empty : CallerArgs<'T> = { Unnamed = []; Named = [] } + member x.CallerArgCounts = List.length x.Unnamed, List.length x.Named + member x.CurriedCallerArgs = List.zip x.Unnamed x.Named + member x.ArgumentNamesAndTypes = + let unnamed = x.Unnamed |> List.collect (List.map (fun i -> None, i.CallerArgumentType)) + let named = x.Named |> List.collect (List.map (fun i -> Some i.Name, i.CallerArg.CallerArgumentType)) + unnamed @ named + +//------------------------------------------------------------------------- +// Callsite conversions +//------------------------------------------------------------------------- + +// If the called method argument is a delegate type, and the caller is known to be a function type, then the caller may provide a function +// If the called method argument is an Expression type, and the caller is known to be a function type, then the caller may provide a T +// If the called method argument is an [] Quotations.Expr, and the caller is not known to be a quoted expression type, then the caller may provide a T +let AdjustCalledArgTypeForLinqExpressionsAndAutoQuote (infoReader: InfoReader) callerArgTy (calledArg: CalledArg) m = + let g = infoReader.g + let calledArgTy = calledArg.CalledArgumentType + + let adjustDelegateTy calledTy = + let (SigOfFunctionForDelegate(_, delArgTys, _, fty)) = GetSigOfFunctionForDelegate infoReader calledTy m AccessibleFromSomewhere + let delArgTys = if isNil delArgTys then [g.unit_ty] else delArgTys + if (fst (stripFunTy g callerArgTy)).Length = delArgTys.Length then + fty + else + calledArgTy + + if isDelegateTy g calledArgTy && isFunTy g callerArgTy then + adjustDelegateTy calledArgTy + + elif isLinqExpressionTy g calledArgTy && isFunTy g callerArgTy then + let calledArgTyNoExpr = destLinqExpressionTy g calledArgTy + if isDelegateTy g calledArgTyNoExpr then + adjustDelegateTy calledArgTyNoExpr + else + calledArgTy + + elif calledArg.ReflArgInfo.AutoQuote && isQuotedExprTy g calledArgTy && not (isQuotedExprTy g callerArgTy) then + destQuotedExprTy g calledArgTy + + else calledArgTy + +/// Adjust the called argument type to take into account whether the caller's argument is CSharpMethod(?arg=Some(3)) or CSharpMethod(arg=1) +let AdjustCalledArgTypeForOptionals (g: TcGlobals) enforceNullableOptionalsKnownTypes (calledArg: CalledArg) calledArgTy (callerArg: CallerArg<_>) = + + if callerArg.IsExplicitOptional then + match calledArg.OptArgInfo with + // CSharpMethod(?x = arg), optional C#-style argument, may have nullable type + | CallerSide _ -> + if g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop then + if isNullableTy g calledArgTy then + mkOptionTy g (destNullableTy g calledArgTy) + else + mkOptionTy g calledArgTy + else + calledArgTy + + // FSharpMethod(?x = arg), optional F#-style argument + | CalleeSide -> + // In this case, the called argument will already have option type + calledArgTy + + | NotOptional -> + // This condition represents an error but the error is raised in later processing + calledArgTy + else + match calledArg.OptArgInfo with + // CSharpMethod(x = arg), non-optional C#-style argument, may have type Nullable. + | NotOptional when not (g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop) -> + calledArgTy + + // The arg should have type ty. However for backwards compat, we also allow arg to have type Nullable + | NotOptional + // CSharpMethod(x = arg), optional C#-style argument, may have type Nullable. + | CallerSide _ -> + if isNullableTy g calledArgTy && g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop then + // If inference has worked out it's a nullable then use this + if isNullableTy g callerArg.CallerArgumentType then + calledArgTy + // If inference has worked out it's a struct (e.g. an int) then use this + elif isStructTy g callerArg.CallerArgumentType then + destNullableTy g calledArgTy + // If neither and we are at the end of overload resolution then use the Nullable + elif enforceNullableOptionalsKnownTypes then + calledArgTy + // If at the beginning of inference then use a type variable. + else + let destTy = destNullableTy g calledArgTy + match calledArg.OptArgInfo with + // Use the type variable from the Nullable if called arg is not optional. + | NotOptional when isTyparTy g destTy -> + destTy + | _ -> + let compgenId = mkSynId range0 unassignedTyparName + mkTyparTy (Construct.NewTypar (TyparKind.Type, TyparRigidity.Flexible, Typar(compgenId, NoStaticReq, true), false, TyparDynamicReq.No, [], false, false)) + else + calledArgTy + + // FSharpMethod(x = arg), optional F#-style argument, should have option type + | CalleeSide -> + if isOptionTy g calledArgTy then + destOptionTy g calledArgTy + else + calledArgTy + +// F# supports three adhoc conversions at method callsites (note C# supports more, though ones +// such as implicit conversions interact badly with type inference). +// +// 1. The use of "(fun x y -> ...)" when a delegate it expected. This is not part of +// the ":>" coercion relationship or inference constraint problem as +// such, but is a special rule applied only to method arguments. +// +// The function AdjustCalledArgType detects this case based on types and needs to know that the type being applied +// is a function type. +// +// 2. The use of "(fun x y -> ...)" when Expression it expected. This is similar to above. +// +// 3. Two ways to pass a value where a byref is expected. The first (default) +// is to use a reference cell, and the interior address is taken automatically +// The second is an explicit use of the "address-of" operator "&e". Here we detect the second case, +// and record the presence of the syntax "&e" in the pre-inferred actual type for the method argument. +// The function AdjustCalledArgType detects this and refuses to apply the default byref-to-ref transformation. +// +// The function AdjustCalledArgType also adjusts for optional arguments. +let AdjustCalledArgType (infoReader: InfoReader) isConstraint enforceNullableOptionalsKnownTypes (calledArg: CalledArg) (callerArg: CallerArg<_>) = + let g = infoReader.g + let m = callerArg.Range + // #424218 - when overload resolution is part of constraint solving - do not perform type-directed conversions + let calledArgTy = calledArg.CalledArgumentType + let callerArgTy = callerArg.CallerArgumentType + if isConstraint then + calledArgTy + else + + // If the called method argument is an inref type, then the caller may provide a byref or value + if isInByrefTy g calledArgTy then +#if IMPLICIT_ADDRESS_OF + if isByrefTy g callerArgTy then + calledArgTy + else + destByrefTy g calledArgTy +#else + calledArgTy +#endif + + // If the called method argument is a (non inref) byref type, then the caller may provide a byref or ref. + elif isByrefTy g calledArgTy then + if isByrefTy g callerArgTy then + calledArgTy + else + mkRefCellTy g (destByrefTy g calledArgTy) + + else + let calledArgTy2 = AdjustCalledArgTypeForLinqExpressionsAndAutoQuote infoReader callerArgTy calledArg m + let calledArgTy3 = AdjustCalledArgTypeForOptionals g enforceNullableOptionalsKnownTypes calledArg calledArgTy2 callerArg + calledArgTy3 + +//------------------------------------------------------------------------- +// CalledMeth +//------------------------------------------------------------------------- + +type CalledMethArgSet<'T> = + { /// The called arguments corresponding to "unnamed" arguments + UnnamedCalledArgs : CalledArg list + + /// Any unnamed caller arguments not otherwise assigned + UnnamedCallerArgs : CallerArg<'T> list + + /// The called "ParamArray" argument, if any + ParamArrayCalledArgOpt : CalledArg option + + /// Any unnamed caller arguments assigned to a "param array" argument + ParamArrayCallerArgs : CallerArg<'T> list + + /// Named args + AssignedNamedArgs: AssignedCalledArg<'T> list } + + member x.NumUnnamedCallerArgs = x.UnnamedCallerArgs.Length + + member x.NumAssignedNamedArgs = x.AssignedNamedArgs.Length + + member x.NumUnnamedCalledArgs = x.UnnamedCalledArgs.Length + +let MakeCalledArgs amap m (minfo: MethInfo) minst = + // Mark up the arguments with their position, so we can sort them back into order later + let paramDatas = minfo.GetParamDatas(amap, m, minst) + paramDatas |> List.mapiSquared (fun i j (ParamData(isParamArrayArg, isInArg, isOutArg, optArgInfo, callerInfoFlags, nmOpt, reflArgInfo, typeOfCalledArg)) -> + { Position=struct(i,j) + IsParamArray=isParamArrayArg + OptArgInfo=optArgInfo + CallerInfo = callerInfoFlags + IsInArg=isInArg + IsOutArg=isOutArg + ReflArgInfo=reflArgInfo + NameOpt=nmOpt + CalledArgumentType=typeOfCalledArg }) + +/// Represents the syntactic matching between a caller of a method and the called method. +/// +/// The constructor takes all the information about the caller and called side of a method, match up named arguments, property setters etc., +/// and returns a CalledMeth object for further analysis. +type CalledMeth<'T> + (infoReader: InfoReader, + nameEnv: NameResolutionEnv option, + isCheckingAttributeCall, + /// a function to help generate fresh type variables the property setters methods in generic classes + freshenMethInfo, + /// range + m, + /// the access domain of the place where the call is taking place + ad, + /// the method we're attempting to call + minfo: MethInfo, + /// the 'called type arguments', i.e. the fresh generic instantiation of the method we're attempting to call + calledTyArgs, + /// the 'caller type arguments', i.e. user-given generic instantiation of the method we're attempting to call + // todo: consider CallerTypeArgs record + callerTyArgs: TType list, + /// the property related to the method we're attempting to call, if any + pinfoOpt: PropInfo option, + /// the types of the actual object argument, if any + callerObjArgTys: TType list, + /// the 'caller method arguments', i.e. a list of user-given parameter expressions, split between unnamed and named arguments + callerArgs: CallerArgs<'T>, + /// do we allow the use of a param args method in its "expanded" form? + allowParamArgs: bool, + /// do we allow the use of the transformation that converts out arguments as tuple returns? + allowOutAndOptArgs: bool, + /// method parameters + tyargsOpt : TType option) + = + let g = infoReader.g + let methodRetTy = minfo.GetFSharpReturnTy(infoReader.amap, m, calledTyArgs) + + let fullCurriedCalledArgs = MakeCalledArgs infoReader.amap m minfo calledTyArgs + do assert (fullCurriedCalledArgs.Length = fullCurriedCalledArgs.Length) + + let argSetInfos = + (callerArgs.CurriedCallerArgs, fullCurriedCalledArgs) ||> List.map2 (fun (unnamedCallerArgs, namedCallerArgs) fullCalledArgs -> + // Find the arguments not given by name + let unnamedCalledArgs = + fullCalledArgs |> List.filter (fun calledArg -> + match calledArg.NameOpt with + | Some nm -> namedCallerArgs |> List.forall (fun (CallerNamedArg(nm2, _e)) -> nm.idText <> nm2.idText) + | None -> true) + + // See if any of them are 'out' arguments being returned as part of a return tuple + let minArgs, unnamedCalledArgs, unnamedCalledOptArgs, unnamedCalledOutArgs = + let nUnnamedCallerArgs = unnamedCallerArgs.Length + let nUnnamedCalledArgs = unnamedCalledArgs.Length + if allowOutAndOptArgs && nUnnamedCallerArgs < nUnnamedCalledArgs then + let unnamedCalledArgsTrimmed, unnamedCalledOptOrOutArgs = List.splitAt nUnnamedCallerArgs unnamedCalledArgs + + // Check if all optional/out arguments are byref-out args + if unnamedCalledOptOrOutArgs |> List.forall (fun x -> x.IsOutArg && isByrefTy g x.CalledArgumentType) then + nUnnamedCallerArgs - 1, unnamedCalledArgsTrimmed, [], unnamedCalledOptOrOutArgs + // Check if all optional/out arguments are optional args + elif unnamedCalledOptOrOutArgs |> List.forall (fun x -> x.OptArgInfo.IsOptional) then + nUnnamedCallerArgs - 1, unnamedCalledArgsTrimmed, unnamedCalledOptOrOutArgs, [] + // Otherwise drop them on the floor + else + nUnnamedCalledArgs - 1, unnamedCalledArgs, [], [] + else + nUnnamedCalledArgs - 1, unnamedCalledArgs, [], [] + + let (unnamedCallerArgs, paramArrayCallerArgs), unnamedCalledArgs, paramArrayCalledArgOpt = + let supportsParamArgs = + allowParamArgs && + minArgs >= 0 && + unnamedCalledArgs |> List.last |> (fun calledArg -> calledArg.IsParamArray && isArray1DTy g calledArg.CalledArgumentType) + + if supportsParamArgs && unnamedCallerArgs.Length >= minArgs then + let a, b = List.frontAndBack unnamedCalledArgs + List.splitAt minArgs unnamedCallerArgs, a, Some(b) + else + (unnamedCallerArgs, []), unnamedCalledArgs, None + + let assignedNamedArgs = + fullCalledArgs |> List.choose (fun calledArg -> + match calledArg.NameOpt with + | Some nm -> + namedCallerArgs |> List.tryPick (fun (CallerNamedArg(nm2, callerArg)) -> + if nm.idText = nm2.idText then Some { NamedArgIdOpt = Some nm2; CallerArg=callerArg; CalledArg=calledArg } + else None) + | _ -> None) + + let unassignedNamedItems = + namedCallerArgs |> List.filter (fun (CallerNamedArg(nm, _e)) -> + fullCalledArgs |> List.forall (fun calledArg -> + match calledArg.NameOpt with + | Some nm2 -> nm.idText <> nm2.idText + | None -> true)) + + let attributeAssignedNamedItems = + if isCheckingAttributeCall then + // The process for assigning names-->properties is substantially different for attribute specifications + // because it permits the bindings of names to immutable fields. So we use the old + // code for this. + unassignedNamedItems + else + [] + + let assignedNamedProps, unassignedNamedItems = + let returnedObjTy = if minfo.IsConstructor then minfo.ApparentEnclosingType else methodRetTy + unassignedNamedItems |> List.splitChoose (fun (CallerNamedArg(id, e) as arg) -> + let nm = id.idText + let pinfos = GetIntrinsicPropInfoSetsOfType infoReader (Some nm) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides id.idRange returnedObjTy + let pinfos = pinfos |> ExcludeHiddenOfPropInfos g infoReader.amap m + match pinfos with + | [pinfo] when pinfo.HasSetter && not pinfo.IsIndexer -> + let pminfo = pinfo.SetterMethod + let pminst = freshenMethInfo m pminfo + Choice1Of2(AssignedItemSetter(id, AssignedPropSetter(pinfo, pminfo, pminst), e)) + | _ -> + let epinfos = + match nameEnv with + | Some ne -> ExtensionPropInfosOfTypeInScope ResultCollectionSettings.AllResults infoReader ne (Some nm) ad m returnedObjTy + | _ -> [] + match epinfos with + | [pinfo] when pinfo.HasSetter && not pinfo.IsIndexer -> + let pminfo = pinfo.SetterMethod + let pminst = match minfo with + | MethInfo.FSMeth(_, TType.TType_app(_, types), _, _) -> types + | _ -> freshenMethInfo m pminfo + + let pminst = match tyargsOpt with + | Some(TType.TType_app(_, types)) -> types + | _ -> pminst + Choice1Of2(AssignedItemSetter(id, AssignedPropSetter(pinfo, pminfo, pminst), e)) + | _ -> + match infoReader.GetILFieldInfosOfType(Some(nm), ad, m, returnedObjTy) with + | finfo :: _ -> + Choice1Of2(AssignedItemSetter(id, AssignedILFieldSetter(finfo), e)) + | _ -> + match infoReader.TryFindRecdOrClassFieldInfoOfType(nm, m, returnedObjTy) with + | ValueSome rfinfo -> + Choice1Of2(AssignedItemSetter(id, AssignedRecdFieldSetter(rfinfo), e)) + | _ -> + Choice2Of2(arg)) + + let names = System.Collections.Generic.HashSet<_>() + for CallerNamedArg(nm, _) in namedCallerArgs do + if not (names.Add nm.idText) then + errorR(Error(FSComp.SR.typrelNamedArgumentHasBeenAssignedMoreThenOnce nm.idText, m)) + + let argSet = { UnnamedCalledArgs=unnamedCalledArgs; UnnamedCallerArgs=unnamedCallerArgs; ParamArrayCalledArgOpt=paramArrayCalledArgOpt; ParamArrayCallerArgs=paramArrayCallerArgs; AssignedNamedArgs=assignedNamedArgs } + + (argSet, assignedNamedProps, unassignedNamedItems, attributeAssignedNamedItems, unnamedCalledOptArgs, unnamedCalledOutArgs)) + + let argSets = argSetInfos |> List.map (fun (x, _, _, _, _, _) -> x) + let assignedNamedProps = argSetInfos |> List.collect (fun (_, x, _, _, _, _) -> x) + let unassignedNamedItems = argSetInfos |> List.collect (fun (_, _, x, _, _, _) -> x) + let attributeAssignedNamedItems = argSetInfos |> List.collect (fun (_, _, _, x, _, _) -> x) + let unnamedCalledOptArgs = argSetInfos |> List.collect (fun (_, _, _, _, x, _) -> x) + let unnamedCalledOutArgs = argSetInfos |> List.collect (fun (_, _, _, _, _, x) -> x) + + member x.infoReader = infoReader + + member x.amap = infoReader.amap + + /// the method we're attempting to call + member x.Method = minfo + + /// the instantiation of the method we're attempting to call + member x.CalledTyArgs = calledTyArgs + + member x.AllCalledArgs = fullCurriedCalledArgs + + /// the instantiation of the method we're attempting to call + member x.CalledTyparInst = + let tps = minfo.FormalMethodTypars + if tps.Length = calledTyArgs.Length then mkTyparInst tps calledTyArgs else [] + + /// the formal instantiation of the method we're attempting to call + member x.CallerTyArgs = callerTyArgs + + /// The types of the actual object arguments, if any + member x.CallerObjArgTys = callerObjArgTys + + /// The argument analysis for each set of curried arguments + member x.ArgSets = argSets + + /// return type after implicit deference of byref returns is taken into account + member x.CalledReturnTypeAfterByrefDeref = + let retTy = methodRetTy + if isByrefTy g retTy then destByrefTy g retTy else retTy + + /// return type after tupling of out args is taken into account + member x.CalledReturnTypeAfterOutArgTupling = + let retTy = x.CalledReturnTypeAfterByrefDeref + if isNil unnamedCalledOutArgs then + retTy + else + let outArgTys = unnamedCalledOutArgs |> List.map (fun calledArg -> destByrefTy g calledArg.CalledArgumentType) + if isUnitTy g retTy then mkRefTupledTy g outArgTys + else mkRefTupledTy g (retTy :: outArgTys) + + /// named setters + member x.AssignedItemSetters = assignedNamedProps + + /// the property related to the method we're attempting to call, if any + member x.AssociatedPropertyInfo = pinfoOpt + + /// unassigned args + member x.UnassignedNamedArgs = unassignedNamedItems + + /// args assigned to specify values for attribute fields and properties (these are not necessarily "property sets") + member x.AttributeAssignedNamedArgs = attributeAssignedNamedItems + + /// unnamed called optional args: pass defaults for these + member x.UnnamedCalledOptArgs = unnamedCalledOptArgs + + /// unnamed called out args: return these as part of the return tuple + member x.UnnamedCalledOutArgs = unnamedCalledOutArgs + + static member GetMethod (x: CalledMeth<'T>) = x.Method + + member x.NumArgSets = x.ArgSets.Length + + member x.HasOptArgs = not (isNil x.UnnamedCalledOptArgs) + + member x.HasOutArgs = not (isNil x.UnnamedCalledOutArgs) + + member x.UsesParamArrayConversion = x.ArgSets |> List.exists (fun argSet -> argSet.ParamArrayCalledArgOpt.IsSome) + + member x.ParamArrayCalledArgOpt = x.ArgSets |> List.tryPick (fun argSet -> argSet.ParamArrayCalledArgOpt) + + member x.ParamArrayCallerArgs = x.ArgSets |> List.tryPick (fun argSet -> if Option.isSome argSet.ParamArrayCalledArgOpt then Some argSet.ParamArrayCallerArgs else None ) + + member x.GetParamArrayElementType() = + // turned as a method to avoid assert in variable inspector + assert (x.UsesParamArrayConversion) + x.ParamArrayCalledArgOpt.Value.CalledArgumentType |> destArrayTy x.amap.g + + member x.NumAssignedProps = x.AssignedItemSetters.Length + + member x.CalledObjArgTys(m) = + match x.Method.GetObjArgTypes(x.amap, m, x.CalledTyArgs) with + | [ thisArgTy ] when isByrefTy g thisArgTy -> [ destByrefTy g thisArgTy ] + | res -> res + + member x.NumCalledTyArgs = x.CalledTyArgs.Length + + member x.NumCallerTyArgs = x.CallerTyArgs.Length + + member x.AssignsAllNamedArgs = isNil x.UnassignedNamedArgs + + member x.HasCorrectArity = + (x.NumCalledTyArgs = x.NumCallerTyArgs) && + x.ArgSets |> List.forall (fun argSet -> argSet.NumUnnamedCalledArgs = argSet.NumUnnamedCallerArgs) + + member x.HasCorrectGenericArity = + (x.NumCalledTyArgs = x.NumCallerTyArgs) + + member x.IsAccessible(m, ad) = + IsMethInfoAccessible x.amap m ad x.Method + + member x.HasCorrectObjArgs(m) = + x.CalledObjArgTys(m).Length = x.CallerObjArgTys.Length + + member x.IsCandidate(m, ad) = + x.IsAccessible(m, ad) && + x.HasCorrectArity && + x.HasCorrectObjArgs(m) && + x.AssignsAllNamedArgs + + member x.AssignedUnnamedArgs = + // We use Seq.map2 to tolerate there being mismatched caller/called args + x.ArgSets |> List.map (fun argSet -> + (argSet.UnnamedCalledArgs, argSet.UnnamedCallerArgs) ||> Seq.map2 (fun calledArg callerArg -> + { NamedArgIdOpt=None; CalledArg=calledArg; CallerArg=callerArg }) |> Seq.toList) + + member x.AssignedNamedArgs = + x.ArgSets |> List.map (fun argSet -> argSet.AssignedNamedArgs) + + member x.AllUnnamedCalledArgs = x.ArgSets |> List.collect (fun x -> x.UnnamedCalledArgs) + + member x.TotalNumUnnamedCalledArgs = x.ArgSets |> List.sumBy (fun x -> x.NumUnnamedCalledArgs) + + member x.TotalNumUnnamedCallerArgs = x.ArgSets |> List.sumBy (fun x -> x.NumUnnamedCallerArgs) + + member x.TotalNumAssignedNamedArgs = x.ArgSets |> List.sumBy (fun x -> x.NumAssignedNamedArgs) + + override x.ToString() = "call to " + minfo.ToString() + +let NamesOfCalledArgs (calledArgs: CalledArg list) = + calledArgs |> List.choose (fun x -> x.NameOpt) + +//------------------------------------------------------------------------- +// Helpers dealing with propagating type information in method overload resolution +//------------------------------------------------------------------------- + +type ArgumentAnalysis = + | NoInfo + | ArgDoesNotMatch + | CallerLambdaHasArgTypes of TType list + | CalledArgMatchesType of TType + +let InferLambdaArgsForLambdaPropagation origRhsExpr = + let rec loop e = + match e with + | SynExpr.Lambda (_, _, _, rest, _, _) -> 1 + loop rest + | SynExpr.MatchLambda _ -> 1 + | _ -> 0 + loop origRhsExpr + +let ExamineArgumentForLambdaPropagation (infoReader: InfoReader) (arg: AssignedCalledArg) = + let g = infoReader.g + + // Find the explicit lambda arguments of the caller. Ignore parentheses. + let argExpr = match arg.CallerArg.Expr with SynExpr.Paren (x, _, _, _) -> x | x -> x + let countOfCallerLambdaArg = InferLambdaArgsForLambdaPropagation argExpr + + // Adjust for Expression<_>, Func<_, _>, ... + let adjustedCalledArgTy = AdjustCalledArgType infoReader false false arg.CalledArg arg.CallerArg + if countOfCallerLambdaArg > 0 then + // Decompose the explicit function type of the target + let calledLambdaArgTys, _calledLambdaRetTy = stripFunTy g adjustedCalledArgTy + if calledLambdaArgTys.Length >= countOfCallerLambdaArg then + // success + CallerLambdaHasArgTypes calledLambdaArgTys + elif isDelegateTy g (if isLinqExpressionTy g adjustedCalledArgTy then destLinqExpressionTy g adjustedCalledArgTy else adjustedCalledArgTy) then + // delegate arity mismatch + ArgDoesNotMatch + else + // not a function type on the called side - no information + NoInfo + else + // not a lambda on the caller side - push information from caller to called + CalledArgMatchesType(adjustedCalledArgTy) + + +let ExamineMethodForLambdaPropagation (x: CalledMeth) = + let unnamedInfo = x.AssignedUnnamedArgs |> List.mapSquared (ExamineArgumentForLambdaPropagation x.infoReader) + let namedInfo = x.AssignedNamedArgs |> List.mapSquared (fun arg -> (arg.NamedArgIdOpt.Value, ExamineArgumentForLambdaPropagation x.infoReader arg)) + if unnamedInfo |> List.existsSquared (function CallerLambdaHasArgTypes _ -> true | _ -> false) || + namedInfo |> List.existsSquared (function (_, CallerLambdaHasArgTypes _) -> true | _ -> false) then + Some (unnamedInfo, namedInfo) + else + None + +//------------------------------------------------------------------------- +// Additional helpers for building method calls and doing TAST generation +//------------------------------------------------------------------------- + +/// Is this a 'base' call (in the sense of C#) +let IsBaseCall objArgs = + match objArgs with + | [Expr.Val (v, _, _)] when v.BaseOrThisInfo = BaseVal -> true + | _ -> false + +/// Compute whether we insert a 'coerce' on the 'this' pointer for an object model call +/// For example, when calling an interface method on a struct, or a method on a constrained +/// variable type. +let ComputeConstrainedCallInfo g amap m (objArgs, minfo: MethInfo) = + match objArgs with + | [objArgExpr] when not minfo.IsExtensionMember -> + let methObjTy = minfo.ApparentEnclosingType + let objArgTy = tyOfExpr g objArgExpr + if TypeDefinitelySubsumesTypeNoCoercion 0 g amap m methObjTy objArgTy + // Constrained calls to class types can only ever be needed for the three class types that + // are base types of value types + || (isClassTy g methObjTy && + (not (typeEquiv g methObjTy g.system_Object_ty || + typeEquiv g methObjTy g.system_Value_ty || + typeEquiv g methObjTy g.system_Enum_ty))) then + None + else + // The object argument is a value type or variable type and the target method is an interface or System.Object + // type. A .NET 2.0 generic constrained call is required + Some objArgTy + | _ -> + None + +/// Adjust the 'this' pointer before making a call +/// Take the address of a struct, and coerce to an interface/base/constraint type if necessary +let TakeObjAddrForMethodCall g amap (minfo: MethInfo) isMutable m objArgs f = + let ccallInfo = ComputeConstrainedCallInfo g amap m (objArgs, minfo) + + let wrap, objArgs = + + match objArgs with + | [objArgExpr] -> + + let hasCallInfo = ccallInfo.IsSome + let mustTakeAddress = hasCallInfo || minfo.ObjArgNeedsAddress(amap, m) + let objArgTy = tyOfExpr g objArgExpr + + let isMutable = + match isMutable with + | DefinitelyMutates + | NeverMutates + | AddressOfOp -> isMutable + | PossiblyMutates -> + // Check to see if the method is read-only. Perf optimization. + // If there is an extension member whose first arg is an inref, we must return NeverMutates. + if mustTakeAddress && (minfo.IsReadOnly || minfo.IsReadOnlyExtensionMember (amap, m)) then + NeverMutates + else + isMutable + + let wrap, objArgExprAddr, isReadOnly, _isWriteOnly = + mkExprAddrOfExpr g mustTakeAddress hasCallInfo isMutable objArgExpr None m + + // Extension members and calls to class constraints may need a coercion for their object argument + let objArgExprCoerced = + if not hasCallInfo && + not (TypeDefinitelySubsumesTypeNoCoercion 0 g amap m minfo.ApparentEnclosingType objArgTy) then + mkCoerceExpr(objArgExprAddr, minfo.ApparentEnclosingType, m, objArgTy) + else + objArgExprAddr + + // Check to see if the extension member uses the extending type as a byref. + // If so, make sure we don't allow readonly/immutable values to be passed byref from an extension member. + // An inref will work though. + if isReadOnly && mustTakeAddress && minfo.IsExtensionMember then + minfo.TryObjArgByrefType(amap, m, minfo.FormalMethodInst) + |> Option.iter (fun ty -> + if not (isInByrefTy g ty) then + errorR(Error(FSComp.SR.tcCannotCallExtensionMethodInrefToByref(minfo.DisplayName), m))) + + + wrap, [objArgExprCoerced] + + | _ -> + id, objArgs + let e, ety = f ccallInfo objArgs + wrap e, ety + +//------------------------------------------------------------------------- +// Build method calls. +//------------------------------------------------------------------------- + +/// Build an expression node that is a call to a .NET method. +let BuildILMethInfoCall g amap m isProp (minfo: ILMethInfo) valUseFlags minst direct args = + let valu = isStructTy g minfo.ApparentEnclosingType + let ctor = minfo.IsConstructor + if minfo.IsClassConstructor then + error (InternalError (minfo.ILName+": cannot call a class constructor", m)) + let useCallvirt = + not valu && not direct && minfo.IsVirtual + let isProtected = minfo.IsProtectedAccessibility + let ilMethRef = minfo.ILMethodRef + let newobj = ctor && (match valUseFlags with NormalValUse -> true | _ -> false) + let exprTy = if ctor then minfo.ApparentEnclosingType else minfo.GetFSharpReturnTy(amap, m, minst) + let retTy = if not ctor && ilMethRef.ReturnType = ILType.Void then [] else [exprTy] + let isDllImport = minfo.IsDllImport g + Expr.Op (TOp.ILCall (useCallvirt, isProtected, valu, newobj, valUseFlags, isProp, isDllImport, ilMethRef, minfo.DeclaringTypeInst, minst, retTy), [], args, m), + exprTy + + +/// Build a call to an F# method. +/// +/// Consume the arguments in chunks and build applications. This copes with various F# calling signatures +/// all of which ultimately become 'methods'. +/// +/// QUERY: this looks overly complex considering that we are doing a fundamentally simple +/// thing here. +let BuildFSharpMethodApp g m (vref: ValRef) vexp vexprty (args: Exprs) = + let arities = (arityOfVal vref.Deref).AritiesOfArgs + + let args3, (leftover, retTy) = + let exprL expr = exprL g expr + ((args, vexprty), arities) ||> List.mapFold (fun (args, fty) arity -> + match arity, args with + | (0|1), [] when typeEquiv g (domainOfFunTy g fty) g.unit_ty -> mkUnit g m, (args, rangeOfFunTy g fty) + | 0, (arg :: argst) -> + let msg = Layout.showL (Layout.sepListL (Layout.rightL (Layout.TaggedTextOps.tagText ";")) (List.map exprL args)) + warning(InternalError(sprintf "Unexpected zero arity, args = %s" msg, m)) + arg, (argst, rangeOfFunTy g fty) + | 1, (arg :: argst) -> arg, (argst, rangeOfFunTy g fty) + | 1, [] -> error(InternalError("expected additional arguments here", m)) + | _ -> + if args.Length < arity then + error(InternalError("internal error in getting arguments, n = "+string arity+", #args = "+string args.Length, m)) + let tupargs, argst = List.splitAt arity args + let tuptys = tupargs |> List.map (tyOfExpr g) + (mkRefTupled g m tupargs tuptys), + (argst, rangeOfFunTy g fty) ) + if not leftover.IsEmpty then error(InternalError("Unexpected "+string(leftover.Length)+" remaining arguments in method application", m)) + mkApps g ((vexp, vexprty), [], args3, m), + retTy + +/// Build a call to an F# method. +let BuildFSharpMethodCall g m (ty, vref: ValRef) valUseFlags minst args = + let vexp = Expr.Val (vref, valUseFlags, m) + let vexpty = vref.Type + let tpsorig, tau = vref.TypeScheme + let vtinst = argsOfAppTy g ty @ minst + if tpsorig.Length <> vtinst.Length then error(InternalError("BuildFSharpMethodCall: unexpected List.length mismatch", m)) + let expr = mkTyAppExpr m (vexp, vexpty) vtinst + let exprty = instType (mkTyparInst tpsorig vtinst) tau + BuildFSharpMethodApp g m vref expr exprty args + + +/// Make a call to a method info. Used by the optimizer and code generator to build +/// calls to the type-directed solutions to member constraints. +let MakeMethInfoCall amap m minfo minst args = + let valUseFlags = NormalValUse // correct unless if we allow wild trait constraints like "T has a ctor and can be used as a parent class" + + match minfo with + + | ILMeth(g, ilminfo, _) -> + let direct = not minfo.IsVirtual + let isProp = false // not necessarily correct, but this is only used post-creflect where this flag is irrelevant + BuildILMethInfoCall g amap m isProp ilminfo valUseFlags minst direct args |> fst + + | FSMeth(g, ty, vref, _) -> + BuildFSharpMethodCall g m (ty, vref) valUseFlags minst args |> fst + + | DefaultStructCtor(_, ty) -> + mkDefault (m, ty) + +#if !NO_EXTENSIONTYPING + | ProvidedMeth(amap, mi, _, m) -> + let isProp = false // not necessarily correct, but this is only used post-creflect where this flag is irrelevant + let ilMethodRef = Import.ImportProvidedMethodBaseAsILMethodRef amap m mi + let isConstructor = mi.PUntaint((fun c -> c.IsConstructor), m) + let valu = mi.PUntaint((fun c -> c.DeclaringType.IsValueType), m) + let actualTypeInst = [] // GENERIC TYPE PROVIDERS: for generics, we would have something here + let actualMethInst = [] // GENERIC TYPE PROVIDERS: for generics, we would have something here + let ilReturnTys = Option.toList (minfo.GetCompiledReturnTy(amap, m, [])) // GENERIC TYPE PROVIDERS: for generics, we would have more here + // REVIEW: Should we allow protected calls? + Expr.Op (TOp.ILCall (false, false, valu, isConstructor, valUseFlags, isProp, false, ilMethodRef, actualTypeInst, actualMethInst, ilReturnTys), [], args, m) + +#endif + +#if !NO_EXTENSIONTYPING +// This imports a provided method, and checks if it is a known compiler intrinsic like "1 + 2" +let TryImportProvidedMethodBaseAsLibraryIntrinsic (amap: Import.ImportMap, m: range, mbase: Tainted) = + let methodName = mbase.PUntaint((fun x -> x.Name), m) + let declaringType = Import.ImportProvidedType amap m (mbase.PApply((fun x -> x.DeclaringType), m)) + match tryTcrefOfAppTy amap.g declaringType with + | ValueSome declaringEntity -> + if not declaringEntity.IsLocalRef && ccuEq declaringEntity.nlr.Ccu amap.g.fslibCcu then + let n = mbase.PUntaint((fun x -> x.GetParameters().Length), m) + match amap.g.knownIntrinsics.TryGetValue ((declaringEntity.LogicalName, None, methodName, n)) with + | true, vref -> Some vref + | _ -> + match amap.g.knownFSharpCoreModules.TryGetValue declaringEntity.LogicalName with + | true, modRef -> + modRef.ModuleOrNamespaceType.AllValsByLogicalName + |> Seq.tryPick (fun (KeyValue(_, v)) -> if (v.CompiledName amap.g.CompilerGlobalState) = methodName then Some (mkNestedValRef modRef v) else None) + | _ -> None + else + None + | _ -> + None +#endif + + +/// Build an expression that calls a given method info. +/// This is called after overload resolution, and also to call other +/// methods such as 'setters' for properties. +// tcVal: used to convert an F# value into an expression. See tc.fs. +// isProp: is it a property get? +// minst: the instantiation to apply for a generic method +// objArgs: the 'this' argument, if any +// args: the arguments, if any +let BuildMethodCall tcVal g amap isMutable m isProp minfo valUseFlags minst objArgs args = + let direct = IsBaseCall objArgs + + TakeObjAddrForMethodCall g amap minfo isMutable m objArgs (fun ccallInfo objArgs -> + let allArgs = objArgs @ args + let valUseFlags = + if direct && (match valUseFlags with NormalValUse -> true | _ -> false) then + VSlotDirectCall + else + match ccallInfo with + | Some ty -> + // printfn "possible constrained call to '%s' at %A" minfo.LogicalName m + PossibleConstrainedCall ty + | None -> + valUseFlags + + match minfo with +#if !NO_EXTENSIONTYPING + // By this time this is an erased method info, e.g. one returned from an expression + // REVIEW: copied from tastops, which doesn't allow protected methods + | ProvidedMeth (amap, providedMeth, _, _) -> + // TODO: there is a fair bit of duplication here with mk_il_minfo_call. We should be able to merge these + + /// Build an expression node that is a call to a extension method in a generated assembly + let enclTy = minfo.ApparentEnclosingType + // prohibit calls to methods that are declared in specific array types (Get, Set, Address) + // these calls are provided by the runtime and should not be called from the user code + if isArrayTy g enclTy then + let tpe = TypeProviderError(FSComp.SR.tcRuntimeSuppliedMethodCannotBeUsedInUserCode(minfo.DisplayName), providedMeth.TypeProviderDesignation, m) + error tpe + let valu = isStructTy g enclTy + let isCtor = minfo.IsConstructor + if minfo.IsClassConstructor then + error (InternalError (minfo.LogicalName + ": cannot call a class constructor", m)) + let useCallvirt = not valu && not direct && minfo.IsVirtual + let isProtected = minfo.IsProtectedAccessibility + let exprTy = if isCtor then enclTy else minfo.GetFSharpReturnTy(amap, m, minst) + match TryImportProvidedMethodBaseAsLibraryIntrinsic (amap, m, providedMeth) with + | Some fsValRef -> + //reraise() calls are converted to TOp.Reraise in the type checker. So if a provided expression includes a reraise call + // we must put it in that form here. + if valRefEq amap.g fsValRef amap.g.reraise_vref then + mkReraise m exprTy, exprTy + else + let vexp, vexpty = tcVal fsValRef valUseFlags (minfo.DeclaringTypeInst @ minst) m + BuildFSharpMethodApp g m fsValRef vexp vexpty allArgs + | None -> + let ilMethRef = Import.ImportProvidedMethodBaseAsILMethodRef amap m providedMeth + let isNewObj = isCtor && (match valUseFlags with NormalValUse -> true | _ -> false) + let actualTypeInst = + if isRefTupleTy g enclTy then argsOfAppTy g (mkCompiledTupleTy g false (destRefTupleTy g enclTy)) // provided expressions can include method calls that get properties of tuple types + elif isFunTy g enclTy then [ domainOfFunTy g enclTy; rangeOfFunTy g enclTy ] // provided expressions can call Invoke + else minfo.DeclaringTypeInst + let actualMethInst = minst + let retTy = if not isCtor && (ilMethRef.ReturnType = ILType.Void) then [] else [exprTy] + let noTailCall = false + let expr = Expr.Op (TOp.ILCall (useCallvirt, isProtected, valu, isNewObj, valUseFlags, isProp, noTailCall, ilMethRef, actualTypeInst, actualMethInst, retTy), [], allArgs, m) + expr, exprTy + +#endif + + // Build a call to a .NET method + | ILMeth(_, ilMethInfo, _) -> + BuildILMethInfoCall g amap m isProp ilMethInfo valUseFlags minst direct allArgs + + // Build a call to an F# method + | FSMeth(_, _, vref, _) -> + + // Go see if this is a use of a recursive definition... Note we know the value instantiation + // we want to use so we pass that in order not to create a new one. + let vexp, vexpty = tcVal vref valUseFlags (minfo.DeclaringTypeInst @ minst) m + BuildFSharpMethodApp g m vref vexp vexpty allArgs + + // Build a 'call' to a struct default constructor + | DefaultStructCtor (g, ty) -> + if not (TypeHasDefaultValue g m ty) then + errorR(Error(FSComp.SR.tcDefaultStructConstructorCall(), m)) + mkDefault (m, ty), ty) + +//------------------------------------------------------------------------- +// Adjust caller arguments as part of building a method call +//------------------------------------------------------------------------- + +/// Build a call to the System.Object constructor taking no arguments, +let BuildObjCtorCall (g: TcGlobals) m = + let ilMethRef = (mkILCtorMethSpecForTy(g.ilg.typ_Object, [])).MethodRef + Expr.Op (TOp.ILCall (false, false, false, false, CtorValUsedAsSuperInit, false, true, ilMethRef, [], [], [g.obj_ty]), [], [], m) + +/// Implements the elaborated form of adhoc conversions from functions to delegates at member callsites +let BuildNewDelegateExpr (eventInfoOpt: EventInfo option, g, amap, delegateTy, invokeMethInfo: MethInfo, delArgTys, f, fty, m) = + let slotsig = invokeMethInfo.GetSlotSig(amap, m) + let delArgVals, expr = + let topValInfo = ValReprInfo([], List.replicate (max 1 (List.length delArgTys)) ValReprInfo.unnamedTopArg, ValReprInfo.unnamedRetVal) + + // Try to pull apart an explicit lambda and use it directly + // Don't do this in the case where we're adjusting the arguments of a function used to build a .NET-compatible event handler + let lambdaContents = + if Option.isSome eventInfoOpt then + None + else + tryDestTopLambda g amap topValInfo (f, fty) + + match lambdaContents with + | None -> + + if List.exists (isByrefTy g) delArgTys then + error(Error(FSComp.SR.tcFunctionRequiresExplicitLambda(List.length delArgTys), m)) + + let delArgVals = delArgTys |> List.mapi (fun i argty -> fst (mkCompGenLocal m ("delegateArg" + string i) argty)) + let expr = + let args = + match eventInfoOpt with + | Some einfo -> + match delArgVals with + | [] -> error(nonStandardEventError einfo.EventName m) + | h :: _ when not (isObjTy g h.Type) -> error(nonStandardEventError einfo.EventName m) + | h :: t -> [exprForVal m h; mkRefTupledVars g m t] + | None -> + if isNil delArgTys then [mkUnit g m] else List.map (exprForVal m) delArgVals + mkApps g ((f, fty), [], args, m) + delArgVals, expr + + | Some _ -> + let _, _, _, vsl, body, _ = IteratedAdjustArityOfLambda g amap topValInfo f + List.concat vsl, body + + let meth = TObjExprMethod(slotsig, [], [], [delArgVals], expr, m) + mkObjExpr(delegateTy, None, BuildObjCtorCall g m, [meth], [], m) + +let CoerceFromFSharpFuncToDelegate g amap infoReader ad callerArgTy m callerArgExpr delegateTy = + let (SigOfFunctionForDelegate(invokeMethInfo, delArgTys, _, _)) = GetSigOfFunctionForDelegate infoReader delegateTy m ad + BuildNewDelegateExpr (None, g, amap, delegateTy, invokeMethInfo, delArgTys, callerArgExpr, callerArgTy, m) + +// Handle adhoc argument conversions +let AdjustCallerArgExprForCoercions (g: TcGlobals) amap infoReader ad isOutArg calledArgTy (reflArgInfo: ReflectedArgInfo) callerArgTy m callerArgExpr = + if isByrefTy g calledArgTy && isRefCellTy g callerArgTy then + None, Expr.Op (TOp.RefAddrGet false, [destRefCellTy g callerArgTy], [callerArgExpr], m) + +#if IMPLICIT_ADDRESS_OF + elif isInByrefTy g calledArgTy && not (isByrefTy g callerArgTy) then + let wrap, callerArgExprAddress, _readonly, _writeonly = mkExprAddrOfExpr g true false NeverMutates callerArgExpr None m + Some wrap, callerArgExprAddress +#endif + + elif isDelegateTy g calledArgTy && isFunTy g callerArgTy then + None, CoerceFromFSharpFuncToDelegate g amap infoReader ad callerArgTy m callerArgExpr calledArgTy + + elif isLinqExpressionTy g calledArgTy && isDelegateTy g (destLinqExpressionTy g calledArgTy) && isFunTy g callerArgTy then + let delegateTy = destLinqExpressionTy g calledArgTy + let expr = CoerceFromFSharpFuncToDelegate g amap infoReader ad callerArgTy m callerArgExpr delegateTy + None, mkCallQuoteToLinqLambdaExpression g m delegateTy (Expr.Quote (expr, ref None, false, m, mkQuotedExprTy g delegateTy)) + + // auto conversions to quotations (to match auto conversions to LINQ expressions) + elif reflArgInfo.AutoQuote && isQuotedExprTy g calledArgTy && not (isQuotedExprTy g callerArgTy) then + match reflArgInfo with + | ReflectedArgInfo.Quote true -> + None, mkCallLiftValueWithDefn g m calledArgTy callerArgExpr + | ReflectedArgInfo.Quote false -> + None, Expr.Quote (callerArgExpr, ref None, false, m, calledArgTy) + | ReflectedArgInfo.None -> failwith "unreachable" // unreachable due to reflArgInfo.AutoQuote condition + + // Note: out args do not need to be coerced + elif isOutArg then + None, callerArgExpr + + // Note: not all these casts are reported in quotations + else + None, mkCoerceIfNeeded g calledArgTy callerArgTy callerArgExpr + +/// Some of the code below must allocate temporary variables or bind other variables to particular values. +/// As usual we represent variable allocators by expr -> expr functions +/// which we then use to wrap the whole expression. These will either do nothing or pre-bind a variable. It doesn't +/// matter what order they are applied in as long as they are all composed together. +let emptyPreBinder (e: Expr) = e + +/// Get the expression that must be inserted on the caller side for a CallerSide optional arg, +/// i.e. one where there is no corresponding caller arg. +let rec GetDefaultExpressionForCallerSideOptionalArg tcFieldInit g (calledArg: CalledArg) currCalledArgTy currDfltVal eCallerMemberName mMethExpr = + match currDfltVal with + | MissingValue -> + // Add an I_nop if this is an initonly field to make sure we never recognize it as an lvalue. See mkExprAddrOfExpr. + emptyPreBinder, mkAsmExpr ([ mkNormalLdsfld (fspec_Missing_Value g); AI_nop ], [], [], [currCalledArgTy], mMethExpr) + + | DefaultValue -> + emptyPreBinder, mkDefault(mMethExpr, currCalledArgTy) + + | Constant fieldInit -> + match currCalledArgTy with + | NullableTy g inst when fieldInit <> ILFieldInit.Null -> + let nullableTy = mkILNonGenericBoxedTy(g.FindSysILTypeRef "System.Nullable`1") + let ctor = mkILCtorMethSpecForTy(nullableTy, [ILType.TypeVar 0us]).MethodRef + let ctorArgs = [Expr.Const (tcFieldInit mMethExpr fieldInit, mMethExpr, inst)] + emptyPreBinder, Expr.Op (TOp.ILCall (false, false, true, true, NormalValUse, false, false, ctor, [inst], [], [currCalledArgTy]), [], ctorArgs, mMethExpr) + | ByrefTy g inst -> + GetDefaultExpressionForCallerSideOptionalArg tcFieldInit g calledArg inst (PassByRef(inst, currDfltVal)) eCallerMemberName mMethExpr + | _ -> + match calledArg.CallerInfo, eCallerMemberName with + | CallerLineNumber, _ when typeEquiv g currCalledArgTy g.int_ty -> + emptyPreBinder, Expr.Const (Const.Int32(mMethExpr.StartLine), mMethExpr, currCalledArgTy) + | CallerFilePath, _ when typeEquiv g currCalledArgTy g.string_ty -> + let fileName = mMethExpr.FileName |> FileSystem.GetFullPathShim |> PathMap.apply g.pathMap + emptyPreBinder, Expr.Const (Const.String fileName, mMethExpr, currCalledArgTy) + | CallerMemberName, Some callerName when (typeEquiv g currCalledArgTy g.string_ty) -> + emptyPreBinder, Expr.Const (Const.String callerName, mMethExpr, currCalledArgTy) + | _ -> + emptyPreBinder, Expr.Const (tcFieldInit mMethExpr fieldInit, mMethExpr, currCalledArgTy) + + | WrapperForIDispatch -> + match g.TryFindSysILTypeRef "System.Runtime.InteropServices.DispatchWrapper" with + | None -> error(Error(FSComp.SR.fscSystemRuntimeInteropServicesIsRequired(), mMethExpr)) + | Some tref -> + let ty = mkILNonGenericBoxedTy tref + let mref = mkILCtorMethSpecForTy(ty, [g.ilg.typ_Object]).MethodRef + let expr = Expr.Op (TOp.ILCall (false, false, false, true, NormalValUse, false, false, mref, [], [], [g.obj_ty]), [], [mkDefault(mMethExpr, currCalledArgTy)], mMethExpr) + emptyPreBinder, expr + + | WrapperForIUnknown -> + match g.TryFindSysILTypeRef "System.Runtime.InteropServices.UnknownWrapper" with + | None -> error(Error(FSComp.SR.fscSystemRuntimeInteropServicesIsRequired(), mMethExpr)) + | Some tref -> + let ty = mkILNonGenericBoxedTy tref + let mref = mkILCtorMethSpecForTy(ty, [g.ilg.typ_Object]).MethodRef + let expr = Expr.Op (TOp.ILCall (false, false, false, true, NormalValUse, false, false, mref, [], [], [g.obj_ty]), [], [mkDefault(mMethExpr, currCalledArgTy)], mMethExpr) + emptyPreBinder, expr + + | PassByRef (ty, dfltVal2) -> + let v, _ = mkCompGenLocal mMethExpr "defaultByrefArg" ty + let wrapper2, rhs = GetDefaultExpressionForCallerSideOptionalArg tcFieldInit g calledArg currCalledArgTy dfltVal2 eCallerMemberName mMethExpr + (wrapper2 >> mkCompGenLet mMethExpr v rhs), mkValAddr mMethExpr false (mkLocalValRef v) + +/// Get the expression that must be inserted on the caller side for a CalleeSide optional arg where +/// no caller argument has been provided. Normally this is 'None', however CallerMemberName and friends +/// can be used with 'CalleeSide' optional arguments +let GetDefaultExpressionForCalleeSideOptionalArg g (calledArg: CalledArg) eCallerMemberName (mMethExpr: range) = + let calledArgTy = calledArg.CalledArgumentType + let calledNonOptTy = + if isOptionTy g calledArgTy then + destOptionTy g calledArgTy + else + calledArgTy // should be unreachable + + match calledArg.CallerInfo, eCallerMemberName with + | CallerLineNumber, _ when typeEquiv g calledNonOptTy g.int_ty -> + let lineExpr = Expr.Const(Const.Int32 mMethExpr.StartLine, mMethExpr, calledNonOptTy) + mkSome g calledNonOptTy lineExpr mMethExpr + | CallerFilePath, _ when typeEquiv g calledNonOptTy g.string_ty -> + let fileName = mMethExpr.FileName |> FileSystem.GetFullPathShim |> PathMap.apply g.pathMap + let filePathExpr = Expr.Const (Const.String(fileName), mMethExpr, calledNonOptTy) + mkSome g calledNonOptTy filePathExpr mMethExpr + | CallerMemberName, Some(callerName) when typeEquiv g calledNonOptTy g.string_ty -> + let memberNameExpr = Expr.Const (Const.String callerName, mMethExpr, calledNonOptTy) + mkSome g calledNonOptTy memberNameExpr mMethExpr + | _ -> + mkNone g calledNonOptTy mMethExpr + +/// Get the expression that must be inserted on the caller side for an optional arg where +/// no caller argument has been provided. +let GetDefaultExpressionForOptionalArg tcFieldInit g (calledArg: CalledArg) eCallerMemberName mItem (mMethExpr: range) = + let calledArgTy = calledArg.CalledArgumentType + let preBinder, expr = + match calledArg.OptArgInfo with + | NotOptional -> + error(InternalError("Unexpected NotOptional", mItem)) + + | CallerSide dfltVal -> + GetDefaultExpressionForCallerSideOptionalArg tcFieldInit g calledArg calledArgTy dfltVal eCallerMemberName mMethExpr + + | CalleeSide -> + emptyPreBinder, GetDefaultExpressionForCalleeSideOptionalArg g calledArg eCallerMemberName mMethExpr + + // Combine the variable allocators (if any) + let callerArg = CallerArg(calledArgTy, mMethExpr, false, expr) + preBinder, { NamedArgIdOpt = None; CalledArg = calledArg; CallerArg = callerArg } + +let MakeNullableExprIfNeeded (infoReader: InfoReader) calledArgTy callerArgTy callerArgExpr m = + let g = infoReader.g + let amap = infoReader.amap + if isNullableTy g callerArgTy then + callerArgExpr + else + let calledNonOptTy = destNullableTy g calledArgTy + let minfo = GetIntrinsicConstructorInfosOfType infoReader m calledArgTy |> List.head + let callerArgExprCoerced = mkCoerceIfNeeded g calledNonOptTy callerArgTy callerArgExpr + MakeMethInfoCall amap m minfo [] [callerArgExprCoerced] + +// Adjust all the optional arguments, filling in values for defaults, +let AdjustCallerArgForOptional tcFieldInit eCallerMemberName (infoReader: InfoReader) (assignedArg: AssignedCalledArg<_>) = + let g = infoReader.g + let callerArg = assignedArg.CallerArg + let (CallerArg(callerArgTy, m, isOptCallerArg, callerArgExpr)) = callerArg + let calledArg = assignedArg.CalledArg + let calledArgTy = calledArg.CalledArgumentType + match calledArg.OptArgInfo with + | NotOptional when not (g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop) -> + if isOptCallerArg then errorR(Error(FSComp.SR.tcFormalArgumentIsNotOptional(), m)) + assignedArg + + // For non-nullable, non-optional arguments no conversion is needed. + // We return precisely the assignedArg. This also covers the case where there + // can be a lingering permitted type mismatch between caller argument and called argument, + // specifically caller can by `byref` and called `outref`. No coercion is inserted in the + // expression tree in this case. + | NotOptional when not (isNullableTy g calledArgTy) -> + if isOptCallerArg then errorR(Error(FSComp.SR.tcFormalArgumentIsNotOptional(), m)) + assignedArg + + | _ -> + + let callerArgExpr2 = + match calledArg.OptArgInfo with + | NotOptional -> + // T --> Nullable widening at callsites + if isOptCallerArg then errorR(Error(FSComp.SR.tcFormalArgumentIsNotOptional(), m)) + if isNullableTy g calledArgTy then + MakeNullableExprIfNeeded infoReader calledArgTy callerArgTy callerArgExpr m + else + failwith "unreachable" // see case above + + | CallerSide dfltVal -> + let calledArgTy = calledArg.CalledArgumentType + + if isOptCallerArg then + // CSharpMethod(?x=b) + if isOptionTy g callerArgTy then + if isNullableTy g calledArgTy then + // CSharpMethod(?x=b) when 'b' has optional type and 'x' has nullable type --> CSharpMethod(x=Option.toNullable b) + mkOptionToNullable g m (destOptionTy g callerArgTy) callerArgExpr + else + // CSharpMethod(?x=b) when 'b' has optional type and 'x' has non-nullable type --> CSharpMethod(x=Option.defaultValue DEFAULT v) + let _wrapper, defaultExpr = GetDefaultExpressionForCallerSideOptionalArg tcFieldInit g calledArg calledArgTy dfltVal eCallerMemberName m + let ty = destOptionTy g callerArgTy + mkOptionDefaultValue g m ty defaultExpr callerArgExpr + else + // This should be unreachable but the error will be reported elsewhere + callerArgExpr + else + if isNullableTy g calledArgTy then + // CSharpMethod(x=b) when 'x' has nullable type + // CSharpMethod(x=b) when both 'x' and 'b' have nullable type --> CSharpMethod(x=b) + // CSharpMethod(x=b) when 'x' has nullable type and 'b' does not --> CSharpMethod(x=Nullable(b)) + MakeNullableExprIfNeeded infoReader calledArgTy callerArgTy callerArgExpr m + else + // CSharpMethod(x=b) --> CSharpMethod(?x=b) + callerArgExpr + + | CalleeSide -> + if isOptCallerArg then + // CSharpMethod(?x=b) --> CSharpMethod(?x=b) + callerArgExpr + else + // CSharpMethod(x=b) when CSharpMethod(A) --> CSharpMethod(?x=Some(b :> A)) + if isOptionTy g calledArgTy then + let calledNonOptTy = destOptionTy g calledArgTy + let callerArgExprCoerced = mkCoerceIfNeeded g calledNonOptTy callerArgTy callerArgExpr + mkSome g calledNonOptTy callerArgExprCoerced m + else + assert false + callerArgExpr // defensive code - this case is unreachable + + let callerArg2 = CallerArg(tyOfExpr g callerArgExpr2, m, isOptCallerArg, callerArgExpr2) + { assignedArg with CallerArg=callerArg2 } + +// Handle CallerSide optional arguments. +// +// CallerSide optional arguments are largely for COM interop, e.g. to PIA assemblies for Word etc. +// As a result we follow the VB and C# behavior here. +// +// "1. If the parameter is statically typed as System.Object and does not have a value, then there are four cases: +// a. The parameter is marked with MarshalAs(IUnknown), MarshalAs(Interface), or MarshalAs(IDispatch). In this case we pass null. +// b. Else if the parameter is marked with IUnknownConstantAttribute. In this case we pass new System.Runtime.InteropServices.UnknownWrapper(null) +// c. Else if the parameter is marked with IDispatchConstantAttribute. In this case we pass new System.Runtime.InteropServices.DispatchWrapper(null) +// d. Else, we will pass Missing.Value. +// 2. Otherwise, if there is a value attribute, then emit the default value. +// 3. Otherwise, we emit default(T). +// 4. Finally, we apply conversions from the value to the parameter type. This is where the nullable conversions take place for VB. +// - VB allows you to mark ref parameters as optional. The semantics of this is that we create a temporary +// with type = type of parameter, load the optional value to it, and call the method. +// - VB also allows you to mark arrays with Nothing as the optional value. +// - VB also allows you to pass intrinsic values as optional values to parameters +// typed as Object. What we do in this case is we box the intrinsic value." +// +let AdjustCallerArgsForOptionals tcFieldInit eCallerMemberName (infoReader: InfoReader) (calledMeth: CalledMeth<_>) mItem mMethExpr = + let g = infoReader.g + + let assignedNamedArgs = calledMeth.ArgSets |> List.collect (fun argSet -> argSet.AssignedNamedArgs) + let unnamedCalledArgs = calledMeth.ArgSets |> List.collect (fun argSet -> argSet.UnnamedCalledArgs) + let unnamedCallerArgs = calledMeth.ArgSets |> List.collect (fun argSet -> argSet.UnnamedCallerArgs) + let unnamedArgs = + (unnamedCalledArgs, unnamedCallerArgs) ||> List.map2 (fun called caller -> + { NamedArgIdOpt = None; CalledArg=called; CallerArg=caller }) + + // Adjust all the optional arguments that require a default value to be inserted into the call, + // i.e. there is no corresponding caller arg. + let optArgs, optArgPreBinder = + (emptyPreBinder, calledMeth.UnnamedCalledOptArgs) ||> List.mapFold (fun preBinder calledArg -> + let preBinder2, arg = GetDefaultExpressionForOptionalArg tcFieldInit g calledArg eCallerMemberName mItem mMethExpr + arg, (preBinder >> preBinder2)) + + let adjustedNormalUnnamedArgs = List.map (AdjustCallerArgForOptional tcFieldInit eCallerMemberName infoReader) unnamedArgs + let adjustedAssignedNamedArgs = List.map (AdjustCallerArgForOptional tcFieldInit eCallerMemberName infoReader) assignedNamedArgs + + optArgs, optArgPreBinder, adjustedNormalUnnamedArgs, adjustedAssignedNamedArgs + +/// Adjust any 'out' arguments, passing in the address of a mutable local +let AdjustOutCallerArgs g (calledMeth: CalledMeth<_>) mMethExpr = + calledMeth.UnnamedCalledOutArgs |> List.map (fun calledArg -> + let calledArgTy = calledArg.CalledArgumentType + let outArgTy = destByrefTy g calledArgTy + let outv, outArgExpr = mkMutableCompGenLocal mMethExpr PrettyNaming.outArgCompilerGeneratedName outArgTy // mutable! + let expr = mkDefault (mMethExpr, outArgTy) + let callerArg = CallerArg (calledArgTy, mMethExpr, false, mkValAddr mMethExpr false (mkLocalValRef outv)) + let outArg = { NamedArgIdOpt=None;CalledArg=calledArg;CallerArg=callerArg } + outArg, outArgExpr, mkCompGenBind outv expr) + |> List.unzip3 + +/// Adjust any '[]' arguments, converting to an array +let AdjustParamArrayCallerArgs g amap infoReader ad (calledMeth: CalledMeth<_>) mMethExpr = + let argSets = calledMeth.ArgSets + + let paramArrayCallerArgs = argSets |> List.collect (fun argSet -> argSet.ParamArrayCallerArgs) + + match calledMeth.ParamArrayCalledArgOpt with + | None -> + [], [] + + | Some paramArrayCalledArg -> + let paramArrayCalledArgElementType = destArrayTy g paramArrayCalledArg.CalledArgumentType + + let paramArrayPreBinders, paramArrayExprs = + paramArrayCallerArgs + |> List.map (fun callerArg -> + let (CallerArg(callerArgTy, m, isOutArg, callerArgExpr)) = callerArg + AdjustCallerArgExprForCoercions g amap infoReader ad isOutArg paramArrayCalledArgElementType paramArrayCalledArg.ReflArgInfo callerArgTy m callerArgExpr) + |> List.unzip + + let paramArrayExpr = Expr.Op (TOp.Array, [paramArrayCalledArgElementType], paramArrayExprs, mMethExpr) + + let paramArrayCallerArg = + [ { NamedArgIdOpt = None + CalledArg=paramArrayCalledArg + CallerArg=CallerArg(paramArrayCalledArg.CalledArgumentType, mMethExpr, false, paramArrayExpr) } ] + + paramArrayPreBinders, paramArrayCallerArg + +/// Build the argument list for a method call. Adjust for param array, optional arguments, byref arguments and coercions. +/// For example, if you pass an F# reference cell to a byref then we must get the address of the +/// contents of the ref. Likewise lots of adjustments are made for optional arguments etc. +let AdjustCallerArgs tcFieldInit eCallerMemberName (infoReader: InfoReader) ad (calledMeth: CalledMeth<_>) objArgs lambdaVars mItem mMethExpr = + let g = infoReader.g + let amap = infoReader.amap + let calledMethInfo = calledMeth.Method + + // For unapplied 'e.M' we first evaluate 'e' outside the lambda, i.e. 'let v = e in (fun arg -> v.CSharpMethod(arg))' + let objArgPreBinder, objArgs = + match objArgs, lambdaVars with + | [objArg], Some _ -> + if calledMethInfo.IsExtensionMember && calledMethInfo.ObjArgNeedsAddress(amap, mMethExpr) then + error(Error(FSComp.SR.tcCannotPartiallyApplyExtensionMethodForByref(calledMethInfo.DisplayName), mMethExpr)) + let objArgTy = tyOfExpr g objArg + let v, ve = mkCompGenLocal mMethExpr "objectArg" objArgTy + (fun body -> mkCompGenLet mMethExpr v objArg body), [ve] + | _ -> + emptyPreBinder, objArgs + + // Handle param array and optional arguments + let paramArrayPreBinders, paramArrayArgs = + AdjustParamArrayCallerArgs g amap infoReader ad calledMeth mMethExpr + + let optArgs, optArgPreBinder, adjustedNormalUnnamedArgs, adjustedFinalAssignedNamedArgs = + AdjustCallerArgsForOptionals tcFieldInit eCallerMemberName infoReader calledMeth mItem mMethExpr + + let outArgs, outArgExprs, outArgTmpBinds = + AdjustOutCallerArgs g calledMeth mMethExpr + + let allArgs = + adjustedNormalUnnamedArgs @ + adjustedFinalAssignedNamedArgs @ + paramArrayArgs @ + optArgs @ + outArgs + + let allArgs = + allArgs |> List.sortBy (fun x -> x.Position) + + let allArgsPreBinders, allArgsCoerced = + allArgs + |> List.map (fun assignedArg -> + let isOutArg = assignedArg.CalledArg.IsOutArg + let reflArgInfo = assignedArg.CalledArg.ReflArgInfo + let calledArgTy = assignedArg.CalledArg.CalledArgumentType + let (CallerArg(callerArgTy, m, _, e)) = assignedArg.CallerArg + + AdjustCallerArgExprForCoercions g amap infoReader ad isOutArg calledArgTy reflArgInfo callerArgTy m e) + |> List.unzip + + objArgPreBinder, objArgs, allArgsPreBinders, allArgs, allArgsCoerced, optArgPreBinder, paramArrayPreBinders, outArgExprs, outArgTmpBinds + + +//------------------------------------------------------------------------- +// Import provided expressions +//------------------------------------------------------------------------- + + +#if !NO_EXTENSIONTYPING +// This file is not a great place for this functionality to sit, it's here because of BuildMethodCall +module ProvidedMethodCalls = + + let private convertConstExpr g amap m (constant : Tainted) = + let (obj, objTy) = constant.PApply2(id, m) + let ty = Import.ImportProvidedType amap m objTy + let normTy = normalizeEnumTy g ty + obj.PUntaint((fun v -> + let fail() = raise (TypeProviderError(FSComp.SR.etUnsupportedConstantType(v.GetType().ToString()), constant.TypeProviderDesignation, m)) + try + if isNull v then mkNull m ty else + let c = + match v with + | _ when typeEquiv g normTy g.bool_ty -> Const.Bool(v :?> bool) + | _ when typeEquiv g normTy g.sbyte_ty -> Const.SByte(v :?> sbyte) + | _ when typeEquiv g normTy g.byte_ty -> Const.Byte(v :?> byte) + | _ when typeEquiv g normTy g.int16_ty -> Const.Int16(v :?> int16) + | _ when typeEquiv g normTy g.uint16_ty -> Const.UInt16(v :?> uint16) + | _ when typeEquiv g normTy g.int32_ty -> Const.Int32(v :?> int32) + | _ when typeEquiv g normTy g.uint32_ty -> Const.UInt32(v :?> uint32) + | _ when typeEquiv g normTy g.int64_ty -> Const.Int64(v :?> int64) + | _ when typeEquiv g normTy g.uint64_ty -> Const.UInt64(v :?> uint64) + | _ when typeEquiv g normTy g.nativeint_ty -> Const.IntPtr(v :?> int64) + | _ when typeEquiv g normTy g.unativeint_ty -> Const.UIntPtr(v :?> uint64) + | _ when typeEquiv g normTy g.float32_ty -> Const.Single(v :?> float32) + | _ when typeEquiv g normTy g.float_ty -> Const.Double(v :?> float) + | _ when typeEquiv g normTy g.char_ty -> Const.Char(v :?> char) + | _ when typeEquiv g normTy g.string_ty -> Const.String(v :?> string) + | _ when typeEquiv g normTy g.decimal_ty -> Const.Decimal(v :?> decimal) + | _ when typeEquiv g normTy g.unit_ty -> Const.Unit + | _ -> fail() + Expr.Const (c, m, ty) + with _ -> fail() + ), range=m) + + /// Erasure over System.Type. + /// + /// This is a reimplementation of the logic of provided-type erasure, working entirely over (tainted, provided) System.Type + /// values. This is used when preparing ParameterInfo objects to give to the provider in GetInvokerExpression. + /// These ParameterInfo have erased ParameterType - giving the provider an erased type makes it considerably easier + /// to implement a correct GetInvokerExpression. + /// + /// Ideally we would implement this operation by converting to an F# TType using ImportSystemType, and then erasing, and then converting + /// back to System.Type. However, there is currently no way to get from an arbitrary F# TType (even the TType for + /// System.Object) to a System.Type to give to the type provider. + let eraseSystemType (amap, m, inputType) = + let rec loop (st: Tainted) = + if st.PUntaint((fun st -> st.IsGenericParameter), m) then st + elif st.PUntaint((fun st -> st.IsArray), m) then + let et = st.PApply((fun st -> st.GetElementType()), m) + let rank = st.PUntaint((fun st -> st.GetArrayRank()), m) + (loop et).PApply((fun st -> if rank = 1 then st.MakeArrayType() else st.MakeArrayType(rank)), m) + elif st.PUntaint((fun st -> st.IsByRef), m) then + let et = st.PApply((fun st -> st.GetElementType()), m) + (loop et).PApply((fun st -> st.MakeByRefType()), m) + elif st.PUntaint((fun st -> st.IsPointer), m) then + let et = st.PApply((fun st -> st.GetElementType()), m) + (loop et).PApply((fun st -> st.MakePointerType()), m) + else + let isGeneric = st.PUntaint((fun st -> st.IsGenericType), m) + let headType = if isGeneric then st.PApply((fun st -> st.GetGenericTypeDefinition()), m) else st + // We import in order to use IsProvidedErasedTycon, to make sure we at least don't reinvent that + let headTypeAsFSharpType = Import.ImportProvidedNamedType amap m headType + if headTypeAsFSharpType.IsProvidedErasedTycon then + let baseType = + st.PApply((fun st -> + match st.BaseType with + | null -> ProvidedType.CreateNoContext(typeof) // it might be an interface + | st -> st), m) + loop baseType + else + if isGeneric then + let genericArgs = st.PApplyArray((fun st -> st.GetGenericArguments()), "GetGenericArguments", m) + let typars = headTypeAsFSharpType.Typars(m) + // Drop the generic arguments that don't correspond to type arguments, i.e. are units-of-measure + let genericArgs = + [| for (genericArg, tp) in Seq.zip genericArgs typars do + if tp.Kind = TyparKind.Type then + yield genericArg |] + + if genericArgs.Length = 0 then + headType + else + let erasedArgTys = genericArgs |> Array.map loop + headType.PApply((fun st -> + let erasedArgTys = erasedArgTys |> Array.map (fun a -> a.PUntaintNoFailure(id)) + st.MakeGenericType erasedArgTys), m) + else + st + loop inputType + + let convertProvidedExpressionToExprAndWitness + tcVal + (thisArg: Expr option, + allArgs: Exprs, + paramVars: Tainted[], + g, amap, mut, isProp, isSuperInit, m, + expr: Tainted) = + + let varConv = + // note: using paramVars.Length as assumed initial size, but this might not + // be the optimal value; this wasn't checked before obsoleting Dictionary.ofList + let dict = Dictionary.newWithSize paramVars.Length + for v, e in Seq.zip (paramVars |> Seq.map (fun x -> x.PUntaint(id, m))) (Option.toList thisArg @ allArgs) do + dict.Add(v, (None, e)) + dict + let rec exprToExprAndWitness top (ea: Tainted) = + let fail() = error(Error(FSComp.SR.etUnsupportedProvidedExpression(ea.PUntaint((fun etree -> etree.UnderlyingExpressionString), m)), m)) + match ea with + | Tainted.Null -> error(Error(FSComp.SR.etNullProvidedExpression(ea.TypeProviderDesignation), m)) + | _ -> + let exprType = ea.PApplyOption((fun x -> x.GetExprType()), m) + let exprType = match exprType with | Some exprType -> exprType | None -> fail() + match exprType.PUntaint(id, m) with + | ProvidedTypeAsExpr (expr, targetTy) -> + let (expr, targetTy) = exprType.PApply2((fun _ -> (expr, targetTy)), m) + let srcExpr = exprToExpr expr + let targetTy = Import.ImportProvidedType amap m (targetTy.PApply(id, m)) + let sourceTy = Import.ImportProvidedType amap m (expr.PApply ((fun e -> e.Type), m)) + let te = mkCoerceIfNeeded g targetTy sourceTy srcExpr + None, (te, tyOfExpr g te) + | ProvidedTypeTestExpr (expr, targetTy) -> + let (expr, targetTy) = exprType.PApply2((fun _ -> (expr, targetTy)), m) + let srcExpr = exprToExpr expr + let targetTy = Import.ImportProvidedType amap m (targetTy.PApply(id, m)) + let te = mkCallTypeTest g m targetTy srcExpr + None, (te, tyOfExpr g te) + | ProvidedIfThenElseExpr (test, thenBranch, elseBranch) -> + let test, thenBranch, elseBranch = exprType.PApply3((fun _ -> (test, thenBranch, elseBranch)), m) + let testExpr = exprToExpr test + let ifTrueExpr = exprToExpr thenBranch + let ifFalseExpr = exprToExpr elseBranch + let te = mkCond NoDebugPointAtStickyBinding DebugPointForTarget.No m (tyOfExpr g ifTrueExpr) testExpr ifTrueExpr ifFalseExpr + None, (te, tyOfExpr g te) + | ProvidedVarExpr providedVar -> + let _, vTe = varToExpr (exprType.PApply((fun _ -> providedVar), m)) + None, (vTe, tyOfExpr g vTe) + | ProvidedConstantExpr (obj, prType) -> + let ce = convertConstExpr g amap m (exprType.PApply((fun _ -> (obj, prType)), m)) + None, (ce, tyOfExpr g ce) + | ProvidedNewTupleExpr info -> + let elems = exprType.PApplyArray((fun _ -> info), "GetInvokerExpression", m) + let elemsT = elems |> Array.map exprToExpr |> Array.toList + let exprT = mkRefTupledNoTypes g m elemsT + None, (exprT, tyOfExpr g exprT) + | ProvidedNewArrayExpr (ty, elems) -> + let ty, elems = exprType.PApply2((fun _ -> (ty, elems)), m) + let tyT = Import.ImportProvidedType amap m ty + let elems = elems.PApplyArray(id, "GetInvokerExpression", m) + let elemsT = elems |> Array.map exprToExpr |> Array.toList + let exprT = Expr.Op (TOp.Array, [tyT], elemsT, m) + None, (exprT, tyOfExpr g exprT) + | ProvidedTupleGetExpr (inp, n) -> + let inp, n = exprType.PApply2((fun _ -> (inp, n)), m) + let inpT = inp |> exprToExpr + // if type of expression is erased type then we need convert it to the underlying base type + let typeOfExpr = + let t = tyOfExpr g inpT + stripTyEqnsWrtErasure EraseMeasures g t + let tupInfo, tysT = tryDestAnyTupleTy g typeOfExpr + let exprT = mkTupleFieldGet g (tupInfo, inpT, tysT, n.PUntaint(id, m), m) + None, (exprT, tyOfExpr g exprT) + | ProvidedLambdaExpr (v, b) -> + let v, b = exprType.PApply2((fun _ -> (v, b)), m) + let vT = addVar v + let bT = exprToExpr b + removeVar v + let exprT = mkLambda m vT (bT, tyOfExpr g bT) + None, (exprT, tyOfExpr g exprT) + | ProvidedLetExpr (v, e, b) -> + let v, e, b = exprType.PApply3((fun _ -> (v, e, b)), m) + let eT = exprToExpr e + let vT = addVar v + let bT = exprToExpr b + removeVar v + let exprT = mkCompGenLet m vT eT bT + None, (exprT, tyOfExpr g exprT) + | ProvidedVarSetExpr (v, e) -> + let v, e = exprType.PApply2((fun _ -> (v, e)), m) + let eT = exprToExpr e + let vTopt, _ = varToExpr v + match vTopt with + | None -> + fail() + | Some vT -> + let exprT = mkValSet m (mkLocalValRef vT) eT + None, (exprT, tyOfExpr g exprT) + | ProvidedWhileLoopExpr (guardExpr, bodyExpr) -> + let guardExpr, bodyExpr = (exprType.PApply2((fun _ -> (guardExpr, bodyExpr)), m)) + let guardExprT = exprToExpr guardExpr + let bodyExprT = exprToExpr bodyExpr + let exprT = mkWhile g (DebugPointAtWhile.No, SpecialWhileLoopMarker.NoSpecialWhileLoopMarker, guardExprT, bodyExprT, m) + None, (exprT, tyOfExpr g exprT) + | ProvidedForIntegerRangeLoopExpr (v, e1, e2, e3) -> + let v, e1, e2, e3 = exprType.PApply4((fun _ -> (v, e1, e2, e3)), m) + let e1T = exprToExpr e1 + let e2T = exprToExpr e2 + let vT = addVar v + let e3T = exprToExpr e3 + removeVar v + let exprT = mkFastForLoop g (DebugPointAtFor.No, m, vT, e1T, true, e2T, e3T) + None, (exprT, tyOfExpr g exprT) + | ProvidedNewDelegateExpr (delegateTy, boundVars, delegateBodyExpr) -> + let delegateTy, boundVars, delegateBodyExpr = exprType.PApply3((fun _ -> (delegateTy, boundVars, delegateBodyExpr)), m) + let delegateTyT = Import.ImportProvidedType amap m delegateTy + let vs = boundVars.PApplyArray(id, "GetInvokerExpression", m) |> Array.toList + let vsT = List.map addVar vs + let delegateBodyExprT = exprToExpr delegateBodyExpr + List.iter removeVar vs + let lambdaExpr = mkLambdas m [] vsT (delegateBodyExprT, tyOfExpr g delegateBodyExprT) + let lambdaExprTy = tyOfExpr g lambdaExpr + let infoReader = InfoReader(g, amap) + let exprT = CoerceFromFSharpFuncToDelegate g amap infoReader AccessorDomain.AccessibleFromSomewhere lambdaExprTy m lambdaExpr delegateTyT + None, (exprT, tyOfExpr g exprT) +#if PROVIDED_ADDRESS_OF + | ProvidedAddressOfExpr e -> + let eT = exprToExpr (exprType.PApply((fun _ -> e), m)) + let wrap,ce, _readonly, _writeonly = mkExprAddrOfExpr g true false DefinitelyMutates eT None m + let ce = wrap ce + None, (ce, tyOfExpr g ce) +#endif + | ProvidedDefaultExpr pty -> + let ty = Import.ImportProvidedType amap m (exprType.PApply((fun _ -> pty), m)) + let ce = mkDefault (m, ty) + None, (ce, tyOfExpr g ce) + | ProvidedCallExpr (e1, e2, e3) -> + methodCallToExpr top ea (exprType.PApply((fun _ -> (e1, e2, e3)), m)) + | ProvidedSequentialExpr (e1, e2) -> + let e1, e2 = exprType.PApply2((fun _ -> (e1, e2)), m) + let e1T = exprToExpr e1 + let e2T = exprToExpr e2 + let ce = mkCompGenSequential m e1T e2T + None, (ce, tyOfExpr g ce) + | ProvidedTryFinallyExpr (e1, e2) -> + let e1, e2 = exprType.PApply2((fun _ -> (e1, e2)), m) + let e1T = exprToExpr e1 + let e2T = exprToExpr e2 + let ce = mkTryFinally g (e1T, e2T, m, tyOfExpr g e1T, DebugPointAtTry.No, DebugPointAtFinally.No) + None, (ce, tyOfExpr g ce) + | ProvidedTryWithExpr (e1, e2, e3, e4, e5) -> + let info = exprType.PApply((fun _ -> (e1, e2, e3, e4, e5)), m) + let bT = exprToExpr (info.PApply((fun (x, _, _, _, _) -> x), m)) + let v1 = info.PApply((fun (_, x, _, _, _) -> x), m) + let v1T = addVar v1 + let e1T = exprToExpr (info.PApply((fun (_, _, x, _, _) -> x), m)) + removeVar v1 + let v2 = info.PApply((fun (_, _, _, x, _) -> x), m) + let v2T = addVar v2 + let e2T = exprToExpr (info.PApply((fun (_, _, _, _, x) -> x), m)) + removeVar v2 + let ce = mkTryWith g (bT, v1T, e1T, v2T, e2T, m, tyOfExpr g bT, DebugPointAtTry.No, DebugPointAtWith.No) + None, (ce, tyOfExpr g ce) + | ProvidedNewObjectExpr (e1, e2) -> + None, ctorCallToExpr (exprType.PApply((fun _ -> (e1, e2)), m)) + + + and ctorCallToExpr (ne: Tainted<_>) = + let (ctor, args) = ne.PApply2(id, m) + let targetMethInfo = ProvidedMeth(amap, ctor.PApply((fun ne -> upcast ne), m), None, m) + let objArgs = [] + let arguments = [ for ea in args.PApplyArray(id, "GetInvokerExpression", m) -> exprToExpr ea ] + let callExpr = BuildMethodCall tcVal g amap Mutates.PossiblyMutates m false targetMethInfo isSuperInit [] objArgs arguments + callExpr + + and addVar (v: Tainted) = + let nm = v.PUntaint ((fun v -> v.Name), m) + let mut = v.PUntaint ((fun v -> v.IsMutable), m) + let vRaw = v.PUntaint (id, m) + let tyT = Import.ImportProvidedType amap m (v.PApply ((fun v -> v.Type), m)) + let vT, vTe = if mut then mkMutableCompGenLocal m nm tyT else mkCompGenLocal m nm tyT + varConv.[vRaw] <- (Some vT, vTe) + vT + + and removeVar (v: Tainted) = + let vRaw = v.PUntaint (id, m) + varConv.Remove vRaw |> ignore + + and methodCallToExpr top _origExpr (mce: Tainted<_>) = + let (objOpt, meth, args) = mce.PApply3(id, m) + let targetMethInfo = ProvidedMeth(amap, meth.PApply((fun mce -> upcast mce), m), None, m) + let objArgs = + match objOpt.PApplyOption(id, m) with + | None -> [] + | Some objExpr -> [exprToExpr objExpr] + + let arguments = [ for ea in args.PApplyArray(id, "GetInvokerExpression", m) -> exprToExpr ea ] + let genericArguments = + if meth.PUntaint((fun m -> m.IsGenericMethod), m) then + meth.PApplyArray((fun m -> m.GetGenericArguments()), "GetGenericArguments", m) + else + [| |] + let replacementGenericArguments = genericArguments |> Array.map (fun t->Import.ImportProvidedType amap m t) |> List.ofArray + + let mut = if top then mut else PossiblyMutates + let isSuperInit = if top then isSuperInit else ValUseFlag.NormalValUse + let isProp = if top then isProp else false + let callExpr = BuildMethodCall tcVal g amap mut m isProp targetMethInfo isSuperInit replacementGenericArguments objArgs arguments + Some meth, callExpr + + and varToExpr (pe: Tainted) = + // sub in the appropriate argument + // REVIEW: "thisArg" pointer should be first, if present + let vRaw = pe.PUntaint(id, m) + match varConv.TryGetValue vRaw with + | true, v -> v + | _ -> + let typeProviderDesignation = ExtensionTyping.DisplayNameOfTypeProvider (pe.TypeProvider, m) + error(NumberedError(FSComp.SR.etIncorrectParameterExpression(typeProviderDesignation, vRaw.Name), m)) + + and exprToExpr expr = + let _, (resExpr, _) = exprToExprAndWitness false expr + resExpr + + exprToExprAndWitness true expr + + + // fill in parameter holes in the expression + let TranslateInvokerExpressionForProvidedMethodCall tcVal (g, amap, mut, isProp, isSuperInit, mi: Tainted, objArgs, allArgs, m) = + let parameters = + mi.PApplyArray((fun mi -> mi.GetParameters()), "GetParameters", m) + let paramTys = + parameters + |> Array.map (fun p -> p.PApply((fun st -> st.ParameterType), m)) + let erasedParamTys = + paramTys + |> Array.map (fun pty -> eraseSystemType (amap, m, pty)) + let paramVars = + erasedParamTys + |> Array.mapi (fun i erasedParamTy -> erasedParamTy.PApply((fun ty -> ty.AsProvidedVar("arg" + i.ToString())), m)) + + + // encode "this" as the first ParameterExpression, if applicable + let thisArg, paramVars = + match objArgs with + | [objArg] -> + let erasedThisTy = eraseSystemType (amap, m, mi.PApply((fun mi -> mi.DeclaringType), m)) + let thisVar = erasedThisTy.PApply((fun ty -> ty.AsProvidedVar("this")), m) + Some objArg, Array.append [| thisVar |] paramVars + | [] -> None, paramVars + | _ -> failwith "multiple objArgs?" + + let ea = mi.PApplyWithProvider((fun (methodInfo, provider) -> ExtensionTyping.GetInvokerExpression(provider, methodInfo, [| for p in paramVars -> p.PUntaintNoFailure id |])), m) + + convertProvidedExpressionToExprAndWitness tcVal (thisArg, allArgs, paramVars, g, amap, mut, isProp, isSuperInit, m, ea) + + + let BuildInvokerExpressionForProvidedMethodCall tcVal (g, amap, mi: Tainted, objArgs, mut, isProp, isSuperInit, allArgs, m) = + try + let methInfoOpt, (expr, retTy) = TranslateInvokerExpressionForProvidedMethodCall tcVal (g, amap, mut, isProp, isSuperInit, mi, objArgs, allArgs, m) + + let exprty = GetCompiledReturnTyOfProvidedMethodInfo amap m mi |> GetFSharpViewOfReturnType g + let expr = mkCoerceIfNeeded g exprty retTy expr + methInfoOpt, expr, exprty + with + | :? TypeProviderError as tpe -> + let typeName = mi.PUntaint((fun mb -> mb.DeclaringType.FullName), m) + let methName = mi.PUntaint((fun mb -> mb.Name), m) + raise( tpe.WithContext(typeName, methName) ) // loses original stack trace +#endif + +let RecdFieldInstanceChecks g amap ad m (rfinfo: RecdFieldInfo) = + if rfinfo.IsStatic then error (Error (FSComp.SR.tcStaticFieldUsedWhenInstanceFieldExpected(), m)) + CheckRecdFieldInfoAttributes g rfinfo m |> CommitOperationResult + CheckRecdFieldInfoAccessible amap m ad rfinfo + +let ILFieldStaticChecks g amap infoReader ad m (finfo : ILFieldInfo) = + CheckILFieldInfoAccessible g amap m ad finfo + if not finfo.IsStatic then error (Error (FSComp.SR.tcFieldIsNotStatic(finfo.FieldName), m)) + + // Static IL interfaces fields are not supported in lower F# versions. + if isInterfaceTy g finfo.ApparentEnclosingType then + checkLanguageFeatureRuntimeErrorRecover infoReader LanguageFeature.DefaultInterfaceMemberConsumption m + checkLanguageFeatureErrorRecover g.langVersion LanguageFeature.DefaultInterfaceMemberConsumption m + + CheckILFieldAttributes g finfo m + +let ILFieldInstanceChecks g amap ad m (finfo : ILFieldInfo) = + if finfo.IsStatic then error (Error (FSComp.SR.tcStaticFieldUsedWhenInstanceFieldExpected(), m)) + CheckILFieldInfoAccessible g amap m ad finfo + CheckILFieldAttributes g finfo m + +let MethInfoChecks g amap isInstance tyargsOpt objArgs ad m (minfo: MethInfo) = + if minfo.IsInstance <> isInstance then + if isInstance then + error (Error (FSComp.SR.csMethodIsNotAnInstanceMethod(minfo.LogicalName), m)) + else + error (Error (FSComp.SR.csMethodIsNotAStaticMethod(minfo.LogicalName), m)) + + // keep the original accessibility domain to determine type accessibility + let adOriginal = ad + // Eliminate the 'protected' portion of the accessibility domain for instance accesses + let ad = + match objArgs, ad with + | [objArg], AccessibleFrom(paths, Some tcref) -> + let objArgTy = tyOfExpr g objArg + let ty = generalizedTyconRef tcref + // We get to keep our rights if the type we're in subsumes the object argument type + if TypeFeasiblySubsumesType 0 g amap m ty CanCoerce objArgTy then + ad + // We get to keep our rights if this is a base call + elif IsBaseCall objArgs then + ad + else + AccessibleFrom(paths, None) + | _ -> ad + + if not (IsTypeAndMethInfoAccessible amap m adOriginal ad minfo) then + error (Error (FSComp.SR.tcMethodNotAccessible(minfo.LogicalName), m)) + + if isAnyTupleTy g minfo.ApparentEnclosingType && not minfo.IsExtensionMember && + (minfo.LogicalName.StartsWithOrdinal("get_Item") || minfo.LogicalName.StartsWithOrdinal("get_Rest")) then + warning (Error (FSComp.SR.tcTupleMemberNotNormallyUsed(), m)) + + CheckMethInfoAttributes g m tyargsOpt minfo |> CommitOperationResult + +exception FieldNotMutable of DisplayEnv * RecdFieldRef * range + +let CheckRecdFieldMutation m denv (rfinfo: RecdFieldInfo) = + if not rfinfo.RecdField.IsMutable then + errorR (FieldNotMutable (denv, rfinfo.RecdFieldRef, m)) + +/// Generate a witness for the given (solved) constraint. Five possiblilities are taken +/// into account. +/// 1. The constraint is solved by a .NET-declared method or an F#-declared method +/// 2. The constraint is solved by an F# record field +/// 3. The constraint is solved by an F# anonymous record field +/// 4. The constraint is considered solved by a "built in" solution +/// 5. The constraint is solved by a closed expression given by a provided method from a type provider +/// +/// In each case an expression is returned where the method is applied to the given arguments, or the +/// field is dereferenced. +/// +/// None is returned in the cases where the trait has not been solved (e.g. is part of generic code) +/// or there is an unexpected mismatch of some kind. +let GenWitnessExpr amap g m (traitInfo: TraitConstraintInfo) argExprs = + + let sln = + match traitInfo.Solution with + | None -> Choice5Of5() + | Some sln -> + + // Given the solution information, reconstruct the MethInfo for the solution + match sln with + | ILMethSln(origTy, extOpt, mref, minst) -> + let metadataTy = convertToTypeWithMetadataIfPossible g origTy + let tcref = tcrefOfAppTy g metadataTy + let mdef = resolveILMethodRef tcref.ILTyconRawMetadata mref + let ilMethInfo = + match extOpt with + | None -> MethInfo.CreateILMeth(amap, m, origTy, mdef) + | Some ilActualTypeRef -> + let actualTyconRef = Import.ImportILTypeRef amap m ilActualTypeRef + MethInfo.CreateILExtensionMeth(amap, m, origTy, actualTyconRef, None, mdef) + Choice1Of5 (ilMethInfo, minst) + + | FSMethSln(ty, vref, minst) -> + Choice1Of5 (FSMeth(g, ty, vref, None), minst) + + | FSRecdFieldSln(tinst, rfref, isSetProp) -> + Choice2Of5 (tinst, rfref, isSetProp) + + | FSAnonRecdFieldSln(anonInfo, tinst, i) -> + Choice3Of5 (anonInfo, tinst, i) + + | ClosedExprSln expr -> + Choice4Of5 expr + + | BuiltInSln -> + Choice5Of5 () + + match sln with + | Choice1Of5(minfo, methArgTys) -> + let argExprs = + // FIX for #421894 - typechecker assumes that coercion can be applied for the trait + // calls arguments but codegen doesn't emit coercion operations + // result - generation of non-verifiable code + // fix - apply coercion for the arguments (excluding 'receiver' argument in instance calls) + + // flatten list of argument types (looks like trait calls with curried arguments are not supported so + // we can just convert argument list in straight-forward way) + let argTypes = + minfo.GetParamTypes(amap, m, methArgTys) + |> List.concat + + // do not apply coercion to the 'receiver' argument + let receiverArgOpt, argExprs = + if minfo.IsInstance then + match argExprs with + | h :: t -> Some h, t + | argExprs -> None, argExprs + else None, argExprs + + // For methods taking no arguments, 'argExprs' will be a single unit expression here + let argExprs = + match argTypes, argExprs with + | [], [_] -> [] + | _ -> argExprs + + let convertedArgs = (argExprs, argTypes) ||> List.map2 (fun expr expectedTy -> mkCoerceIfNeeded g expectedTy (tyOfExpr g expr) expr) + match receiverArgOpt with + | Some r -> r :: convertedArgs + | None -> convertedArgs + + // Fix bug 1281: If we resolve to an instance method on a struct and we haven't yet taken + // the address of the object then go do that + if minfo.IsStruct && minfo.IsInstance then + match argExprs with + | h :: t when not (isByrefTy g (tyOfExpr g h)) -> + let wrap, h', _readonly, _writeonly = mkExprAddrOfExpr g true false PossiblyMutates h None m + Some (wrap (Expr.Op (TOp.TraitCall traitInfo, [], (h' :: t), m))) + | _ -> + Some (MakeMethInfoCall amap m minfo methArgTys argExprs) + else + Some (MakeMethInfoCall amap m minfo methArgTys argExprs) + + | Choice2Of5 (tinst, rfref, isSet) -> + match isSet, rfref.RecdField.IsStatic, argExprs.Length with + // static setter + | true, true, 1 -> + Some (mkStaticRecdFieldSet (rfref, tinst, argExprs.[0], m)) + + // instance setter + | true, false, 2 -> + // If we resolve to an instance field on a struct and we haven't yet taken + // the address of the object then go do that + if rfref.Tycon.IsStructOrEnumTycon && not (isByrefTy g (tyOfExpr g argExprs.[0])) then + let h = List.head argExprs + let wrap, h', _readonly, _writeonly = mkExprAddrOfExpr g true false DefinitelyMutates h None m + Some (wrap (mkRecdFieldSetViaExprAddr (h', rfref, tinst, argExprs.[1], m))) + else + Some (mkRecdFieldSetViaExprAddr (argExprs.[0], rfref, tinst, argExprs.[1], m)) + + // static getter + | false, true, 0 -> + Some (mkStaticRecdFieldGet (rfref, tinst, m)) + + // instance getter + | false, false, 1 -> + if rfref.Tycon.IsStructOrEnumTycon && isByrefTy g (tyOfExpr g argExprs.[0]) then + Some (mkRecdFieldGetViaExprAddr (argExprs.[0], rfref, tinst, m)) + else + Some (mkRecdFieldGet g (argExprs.[0], rfref, tinst, m)) + + | _ -> None + + | Choice3Of5 (anonInfo, tinst, i) -> + let tupInfo = anonInfo.TupInfo + if evalTupInfoIsStruct tupInfo && isByrefTy g (tyOfExpr g argExprs.[0]) then + Some (mkAnonRecdFieldGetViaExprAddr (anonInfo, argExprs.[0], tinst, i, m)) + else + Some (mkAnonRecdFieldGet g (anonInfo, argExprs.[0], tinst, i, m)) + + | Choice4Of5 expr -> + Some (MakeApplicationAndBetaReduce g (expr, tyOfExpr g expr, [], argExprs, m)) + + | Choice5Of5 () -> + match traitInfo.Solution with + | None -> None // the trait has been generalized + | Some _-> + // For these operators, the witness is just a call to the coresponding FSharp.Core operator + match g.TryMakeOperatorAsBuiltInWitnessInfo isStringTy isArrayTy traitInfo argExprs with + | Some (info, tyargs, actualArgExprs) -> + tryMkCallCoreFunctionAsBuiltInWitness g info tyargs actualArgExprs m + | None -> + // For all other built-in operators, the witness is a call to the coresponding BuiltInWitnesses operator + // These are called as F# methods not F# functions + tryMkCallBuiltInWitness g traitInfo argExprs m + +/// Generate a lambda expression for the given solved trait. +let GenWitnessExprLambda amap g m (traitInfo: TraitConstraintInfo) = + let witnessInfo = traitInfo.TraitKey + let argtysl = GenWitnessArgTys g witnessInfo + let vse = argtysl |> List.mapiSquared (fun i j ty -> mkCompGenLocal m ("arg" + string i + "_" + string j) ty) + let vsl = List.mapSquared fst vse + match GenWitnessExpr amap g m traitInfo (List.concat (List.mapSquared snd vse)) with + | Some expr -> + Choice2Of2 (mkMemberLambdas m [] None None vsl (expr, tyOfExpr g expr)) + | None -> + Choice1Of2 traitInfo + +/// Generate the arguments passed for a set of (solved) traits in non-generic code +let GenWitnessArgs amap g m (traitInfos: TraitConstraintInfo list) = + [ for traitInfo in traitInfos -> GenWitnessExprLambda amap g m traitInfo ] diff --git a/src/fsharp/MethodOverrides.fsi b/src/fsharp/MethodOverrides.fsi new file mode 100644 index 00000000000..d5105e649dc --- /dev/null +++ b/src/fsharp/MethodOverrides.fsi @@ -0,0 +1,911 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +/// Primary logic related to method overrides. +module internal FSharp.Compiler.MethodOverrides + +open FSharp.Compiler +open FSharp.Compiler.AbstractIL.Internal.Library +open FSharp.Compiler.AccessibilityLogic +open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.InfoReader +open FSharp.Compiler.Lib +open FSharp.Compiler.Infos +open FSharp.Compiler.Features +open FSharp.Compiler.NameResolution +open FSharp.Compiler.Range +open FSharp.Compiler.SyntaxTree +open FSharp.Compiler.SyntaxTreeOps +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeBasics +open FSharp.Compiler.TypedTreeOps +open FSharp.Compiler.TypeRelations + +//------------------------------------------------------------------------- +// Completeness of classes +//------------------------------------------------------------------------- + +type OverrideCanImplement = + | CanImplementAnyInterfaceSlot + | CanImplementAnyClassHierarchySlot + | CanImplementAnySlot + | CanImplementNoSlots + +/// The overall information about a method implementation in a class or object expression +type OverrideInfo = + | Override of OverrideCanImplement * TyconRef * Ident * (Typars * TyparInst) * TType list list * TType option * bool * bool + member x.CanImplement = let (Override(a, _, _, _, _, _, _, _)) = x in a + member x.BoundingTyconRef = let (Override(_, ty, _, _, _, _, _, _)) = x in ty + member x.LogicalName = let (Override(_, _, id, _, _, _, _, _)) = x in id.idText + member x.Range = let (Override(_, _, id, _, _, _, _, _)) = x in id.idRange + member x.IsFakeEventProperty = let (Override(_, _, _, _, _, _, b, _)) = x in b + member x.ArgTypes = let (Override(_, _, _, _, b, _, _, _)) = x in b + member x.ReturnType = let (Override(_, _, _, _, _, b, _, _)) = x in b + member x.IsCompilerGenerated = let (Override(_, _, _, _, _, _, _, b)) = x in b + +type RequiredSlot = + | RequiredSlot of MethInfo * isOptional: bool + | DefaultInterfaceImplementationSlot of MethInfo * isOptional: bool * possiblyNoMostSpecific: bool + + /// A slot which does not have to be implemented, because an inherited implementation is available. + member this.IsOptional = + match this with + | RequiredSlot(_, isOptional) + | DefaultInterfaceImplementationSlot(_, isOptional, _) -> isOptional + + /// A slot which has a default interface implementation. + /// A combination of this flag and the lack of IsOptional means the slot may have been reabstracted. + member this.HasDefaultInterfaceImplementation = + match this with + | DefaultInterfaceImplementationSlot _ -> true + | _ -> false + + /// A slot that *might* have ambiguity due to multiple inheritance; happens with default interface implementations. + member this.PossiblyNoMostSpecificImplementation = + match this with + | DefaultInterfaceImplementationSlot(_, _, possiblyNoMostSpecific) -> possiblyNoMostSpecific + | _ -> false + + /// Gets the method info. + member this.MethodInfo = + match this with + | RequiredSlot(methInfo, _) + | DefaultInterfaceImplementationSlot(methInfo, _, _) -> methInfo + +type SlotImplSet = SlotImplSet of RequiredSlot list * NameMultiMap * OverrideInfo list * PropInfo list + +exception TypeIsImplicitlyAbstract of range +exception OverrideDoesntOverride of DisplayEnv * OverrideInfo * MethInfo option * TcGlobals * Import.ImportMap * range + +module DispatchSlotChecking = + + /// Print the signature of an override to a buffer as part of an error message + let PrintOverrideToBuffer denv os (Override(_, _, id, (mtps, memberToParentInst), argTys, retTy, _, _)) = + let denv = { denv with showTyparBinding = true } + let retTy = (retTy |> GetFSharpViewOfReturnType denv.g) + let argInfos = + match argTys with + | [] -> [[(denv.g.unit_ty, ValReprInfo.unnamedTopArg1)]] + | _ -> argTys |> List.mapSquared (fun ty -> (ty, ValReprInfo.unnamedTopArg1)) + Layout.bufferL os (NicePrint.prettyLayoutOfMemberSig denv (memberToParentInst, id.idText, mtps, argInfos, retTy)) + + /// Print the signature of a MethInfo to a buffer as part of an error message + let PrintMethInfoSigToBuffer g amap m denv os minfo = + let denv = { denv with showTyparBinding = true } + let (CompiledSig(argTys, retTy, fmtps, ttpinst)) = CompiledSigOfMeth g amap m minfo + let retTy = (retTy |> GetFSharpViewOfReturnType g) + let argInfos = argTys |> List.mapSquared (fun ty -> (ty, ValReprInfo.unnamedTopArg1)) + let nm = minfo.LogicalName + Layout.bufferL os (NicePrint.prettyLayoutOfMemberSig denv (ttpinst, nm, fmtps, argInfos, retTy)) + + /// Format the signature of an override as a string as part of an error message + let FormatOverride denv d = bufs (fun buf -> PrintOverrideToBuffer denv buf d) + + /// Format the signature of a MethInfo as a string as part of an error message + let FormatMethInfoSig g amap m denv d = bufs (fun buf -> PrintMethInfoSigToBuffer g amap m denv buf d) + + /// Get the override info for an existing (inherited) method being used to implement a dispatch slot. + let GetInheritedMemberOverrideInfo g amap m parentType (minfo: MethInfo) = + let nm = minfo.LogicalName + let (CompiledSig (argTys, retTy, fmtps, ttpinst)) = CompiledSigOfMeth g amap m minfo + + let isFakeEventProperty = minfo.IsFSharpEventPropertyMethod + Override(parentType, minfo.ApparentEnclosingTyconRef, mkSynId m nm, (fmtps, ttpinst), argTys, retTy, isFakeEventProperty, false) + + /// Get the override info for a value being used to implement a dispatch slot. + let GetTypeMemberOverrideInfo g reqdTy (overrideBy: ValRef) = + let _, _, argInfos, retTy, _ = GetTypeOfMemberInMemberForm g overrideBy + let nm = overrideBy.LogicalName + + let argTys = argInfos |> List.mapSquared fst + + let memberMethodTypars, memberToParentInst, argTys, retTy = + match PartitionValRefTypars g overrideBy with + | Some(_, _, memberMethodTypars, memberToParentInst, _tinst) -> + let argTys = argTys |> List.mapSquared (instType memberToParentInst) + let retTy = retTy |> Option.map (instType memberToParentInst) + memberMethodTypars, memberToParentInst, argTys, retTy + | None -> + error(Error(FSComp.SR.typrelMethodIsOverconstrained(), overrideBy.Range)) + let implKind = + if ValRefIsExplicitImpl g overrideBy then + + let belongsToReqdTy = + match overrideBy.MemberInfo.Value.ImplementedSlotSigs with + | [] -> false + | ss :: _ -> isInterfaceTy g ss.ImplementedType && typeEquiv g reqdTy ss.ImplementedType + if belongsToReqdTy then + CanImplementAnyInterfaceSlot + else + CanImplementNoSlots + else if overrideBy.IsDispatchSlotMember then + CanImplementNoSlots + // abstract slots can only implement interface slots + //CanImplementAnyInterfaceSlot <<----- Change to this to enable implicit interface implementation + + else + CanImplementAnyClassHierarchySlot + //CanImplementAnySlot <<----- Change to this to enable implicit interface implementation + + let isFakeEventProperty = overrideBy.IsFSharpEventProperty(g) + Override(implKind, overrideBy.MemberApparentEntity, mkSynId overrideBy.Range nm, (memberMethodTypars, memberToParentInst), argTys, retTy, isFakeEventProperty, overrideBy.IsCompilerGenerated) + + /// Get the override information for an object expression method being used to implement dispatch slots + let GetObjectExprOverrideInfo g amap (implty, id: Ident, memberFlags, ty, arityInfo, bindingAttribs, rhsExpr) = + // Dissect the type. The '0' indicates there are no enclosing generic class type parameters relevant here. + let tps, _, argInfos, retTy, _ = GetMemberTypeInMemberForm g memberFlags arityInfo 0 ty id.idRange + let argTys = argInfos |> List.mapSquared fst + // Dissect the implementation + let _, ctorThisValOpt, baseValOpt, vsl, rhsExpr, _ = destTopLambda g amap arityInfo (rhsExpr, ty) + assert ctorThisValOpt.IsNone + + // Drop 'this' + match vsl with + | [thisv] :: vs -> + // Check for empty variable list from a () arg + let vs = if vs.Length = 1 && argInfos.IsEmpty then [] else vs + let implKind = + if isInterfaceTy g implty then + CanImplementAnyInterfaceSlot + else + CanImplementAnyClassHierarchySlot + //CanImplementAnySlot <<----- Change to this to enable implicit interface implementation + let isFakeEventProperty = CompileAsEvent g bindingAttribs + let overrideByInfo = Override(implKind, tcrefOfAppTy g implty, id, (tps, []), argTys, retTy, isFakeEventProperty, false) + overrideByInfo, (baseValOpt, thisv, vs, bindingAttribs, rhsExpr) + | _ -> + error(InternalError("Unexpected shape for object expression override", id.idRange)) + + /// Check if an override matches a dispatch slot by name + let IsNameMatch (dispatchSlot: MethInfo) (overrideBy: OverrideInfo) = + (overrideBy.LogicalName = dispatchSlot.LogicalName) + + /// Check if an override matches a dispatch slot by name + let IsImplMatch g (dispatchSlot: MethInfo) (overrideBy: OverrideInfo) = + // If the override is listed as only relevant to one type, and we're matching it against an abstract slot of an interface type, + // then check that interface type is the right type. + match overrideBy.CanImplement with + | CanImplementNoSlots -> false + | CanImplementAnySlot -> true + | CanImplementAnyClassHierarchySlot -> not (isInterfaceTy g dispatchSlot.ApparentEnclosingType) + | CanImplementAnyInterfaceSlot -> isInterfaceTy g dispatchSlot.ApparentEnclosingType + + /// Check if the kinds of type parameters match between a dispatch slot and an override. + let IsTyparKindMatch (CompiledSig(_, _, fvmtps, _)) (Override(_, _, _, (mtps, _), _, _, _, _)) = + List.lengthsEqAndForall2 (fun (tp1: Typar) (tp2: Typar) -> tp1.Kind = tp2.Kind) mtps fvmtps + + /// Check if an override is a partial match for the requirements for a dispatch slot except for the name. + let IsSigPartialMatch g (dispatchSlot: MethInfo) compiledSig (Override(_, _, _, (mtps, _), argTys, _retTy, _, _) as overrideBy) = + let (CompiledSig (vargtys, _, fvmtps, _)) = compiledSig + mtps.Length = fvmtps.Length && + IsTyparKindMatch compiledSig overrideBy && + argTys.Length = vargtys.Length && + IsImplMatch g dispatchSlot overrideBy + + /// Check if an override is a partial match for the requirements for a dispatch slot. + let IsPartialMatch g dispatchSlot compiledSig overrideBy = + IsNameMatch dispatchSlot overrideBy && + IsSigPartialMatch g dispatchSlot compiledSig overrideBy + + /// Compute the reverse of a type parameter renaming. + let ReverseTyparRenaming g tinst = + tinst |> List.map (fun (tp, ty) -> (destTyparTy g ty, mkTyparTy tp)) + + /// Compose two instantiations of type parameters. + let ComposeTyparInsts inst1 inst2 = + inst1 |> List.map (map2Of2 (instType inst2)) + + /// Check if an override exactly matches the requirements for a dispatch slot except for the name. + let IsSigExactMatch g amap m dispatchSlot (Override(_, _, _, (mtps, mtpinst), argTys, retTy, _, _) as overrideBy) = + let compiledSig = CompiledSigOfMeth g amap m dispatchSlot + IsSigPartialMatch g dispatchSlot compiledSig overrideBy && + let (CompiledSig (vargtys, vrty, fvmtps, ttpinst)) = compiledSig + + // Compare the types. CompiledSigOfMeth, GetObjectExprOverrideInfo and GetTypeMemberOverrideInfo have already + // applied all relevant substitutions except the renamings from fvtmps <-> mtps + + let aenv = TypeEquivEnv.FromEquivTypars fvmtps mtps + + List.forall2 (List.lengthsEqAndForall2 (typeAEquiv g aenv)) vargtys argTys && + returnTypesAEquiv g aenv vrty retTy && + + // Comparing the method typars and their constraints is much trickier since the substitutions have not been applied + // to the constraints of these babies. This is partly because constraints are directly attached to typars so it's + // difficult to apply substitutions to them unless we separate them off at some point, which we don't as yet. + // + // Given C + // D + // dispatchSlot : C.M(...) + // overrideBy: parent: D value: ! (...) + // + // where X[dtps] indicates that X may involve free type variables dtps + // + // we have + // ttpinst maps ctps --> ctys[dtps] + // mtpinst maps ttps --> dtps + // + // compare fvtmps[ctps] and mtps[ttps] by + // fvtmps[ctps] @ ttpinst -- gives fvtmps[dtps] + // fvtmps[dtps] @ rev(mtpinst) -- gives fvtmps[ttps] + // + // Now fvtmps[ttps] and mtpinst[ttps] are comparable, i.e. have constraints w.r.t. the same set of type variables + // + // i.e. Compose the substitutions ttpinst and rev(mtpinst) + + let ttpinst = + // check we can reverse - in some error recovery situations we can't + if mtpinst |> List.exists (snd >> isTyparTy g >> not) then ttpinst + else ComposeTyparInsts ttpinst (ReverseTyparRenaming g mtpinst) + + // Compare under the composed substitutions + let aenv = TypeEquivEnv.FromTyparInst ttpinst + + typarsAEquiv g aenv fvmtps mtps + + /// Check if an override exactly matches the requirements for a dispatch slot. + let IsExactMatch g amap m dispatchSlot overrideBy = + IsNameMatch dispatchSlot overrideBy && + IsSigExactMatch g amap m dispatchSlot overrideBy + + /// Check if an override implements a dispatch slot + let OverrideImplementsDispatchSlot g amap m dispatchSlot availPriorOverride = + IsExactMatch g amap m dispatchSlot availPriorOverride && + // The override has to actually be in some subtype of the dispatch slot + ExistsHeadTypeInEntireHierarchy g amap m (generalizedTyconRef availPriorOverride.BoundingTyconRef) dispatchSlot.DeclaringTyconRef + + /// Check if a dispatch slot is already implemented + let DispatchSlotIsAlreadyImplemented g amap m availPriorOverridesKeyed (dispatchSlot: MethInfo) = + availPriorOverridesKeyed + |> NameMultiMap.find dispatchSlot.LogicalName + |> List.exists (OverrideImplementsDispatchSlot g amap m dispatchSlot) + + /// Check all dispatch slots are implemented by some override. + let CheckDispatchSlotsAreImplemented (denv, infoReader: InfoReader, m, + nenv, sink: TcResultsSink, + isOverallTyAbstract, + reqdTy, + dispatchSlots: RequiredSlot list, + availPriorOverrides: OverrideInfo list, + overrides: OverrideInfo list) = + let g = infoReader.g + let amap = infoReader.amap + + let isReqdTyInterface = isInterfaceTy g reqdTy + let showMissingMethodsAndRaiseErrors = (isReqdTyInterface || not isOverallTyAbstract) + + let mutable res = true + let fail exn = + res <- false + if showMissingMethodsAndRaiseErrors then + errorR exn + + // Index the availPriorOverrides and overrides by name + let availPriorOverridesKeyed = availPriorOverrides |> NameMultiMap.initBy (fun ov -> ov.LogicalName) + let overridesKeyed = overrides |> NameMultiMap.initBy (fun ov -> ov.LogicalName) + + // we accumulate those to compose a more complete error message, see noimpl() bellow. + let missingOverloadImplementation = ResizeArray() + + for reqdSlot in dispatchSlots do + let dispatchSlot = reqdSlot.MethodInfo + + // Always try to raise a target runtime error if we have a DIM. + if reqdSlot.HasDefaultInterfaceImplementation then + checkLanguageFeatureRuntimeErrorRecover infoReader LanguageFeature.DefaultInterfaceMemberConsumption m + + let maybeResolvedSlot = + NameMultiMap.find dispatchSlot.LogicalName overridesKeyed + |> List.filter (OverrideImplementsDispatchSlot g amap m dispatchSlot) + + match maybeResolvedSlot with + | [ovd] -> + if not ovd.IsCompilerGenerated then + let item = Item.MethodGroup(ovd.LogicalName, [dispatchSlot],None) + CallNameResolutionSink sink (ovd.Range, nenv, item, dispatchSlot.FormalMethodTyparInst, ItemOccurence.Implemented, AccessorDomain.AccessibleFromSomewhere) + | [] -> + if not reqdSlot.IsOptional && + // Check that no available prior override implements this dispatch slot + not (DispatchSlotIsAlreadyImplemented g amap m availPriorOverridesKeyed dispatchSlot) + then + // Always try to raise a language version error if we have a DIM that is not explicitly implemented. + if reqdSlot.HasDefaultInterfaceImplementation then + checkLanguageFeatureErrorRecover g.langVersion LanguageFeature.DefaultInterfaceMemberConsumption m + + if reqdSlot.PossiblyNoMostSpecificImplementation then + errorR(Error(FSComp.SR.typrelInterfaceMemberNoMostSpecificImplementation(NicePrint.stringOfMethInfo amap m denv dispatchSlot), m)) + + // error reporting path + let compiledSig = CompiledSigOfMeth g amap m dispatchSlot + + let noimpl() = + missingOverloadImplementation.Add((isReqdTyInterface, lazy NicePrint.stringOfMethInfo amap m denv dispatchSlot)) + + match overrides |> List.filter (IsPartialMatch g dispatchSlot compiledSig) with + | [] -> + let possibleOverrides = + overrides + |> List.filter (fun overrideBy -> IsNameMatch dispatchSlot overrideBy && IsImplMatch g dispatchSlot overrideBy) + + match possibleOverrides with + | [] -> + noimpl() + | [ Override(_, _, _, (mtps, _), argTys, _, _, _) as overrideBy ] -> + let moreThanOnePossibleDispatchSlot = + dispatchSlots + |> List.filter (fun reqdSlot-> IsNameMatch reqdSlot.MethodInfo overrideBy && IsImplMatch g reqdSlot.MethodInfo overrideBy) + |> isNilOrSingleton + |> not + + let (CompiledSig (vargtys, _, fvmtps, _)) = compiledSig + + if moreThanOnePossibleDispatchSlot then + noimpl() + + elif argTys.Length <> vargtys.Length then + fail(Error(FSComp.SR.typrelMemberDoesNotHaveCorrectNumberOfArguments(FormatOverride denv overrideBy, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range)) + elif mtps.Length <> fvmtps.Length then + fail(Error(FSComp.SR.typrelMemberDoesNotHaveCorrectNumberOfTypeParameters(FormatOverride denv overrideBy, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range)) + elif not (IsTyparKindMatch compiledSig overrideBy) then + fail(Error(FSComp.SR.typrelMemberDoesNotHaveCorrectKindsOfGenericParameters(FormatOverride denv overrideBy, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range)) + else + fail(Error(FSComp.SR.typrelMemberCannotImplement(FormatOverride denv overrideBy, NicePrint.stringOfMethInfo amap m denv dispatchSlot, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range)) + | overrideBy :: _ -> + errorR(Error(FSComp.SR.typrelOverloadNotFound(FormatMethInfoSig g amap m denv dispatchSlot, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range)) + + | [ overrideBy ] -> + if dispatchSlots |> List.exists (fun reqdSlot -> OverrideImplementsDispatchSlot g amap m reqdSlot.MethodInfo overrideBy) then + noimpl() + else + // Error will be reported below in CheckOverridesAreAllUsedOnce + () + | _ -> + fail(Error(FSComp.SR.typrelOverrideWasAmbiguous(FormatMethInfoSig g amap m denv dispatchSlot), m)) + | _ -> fail(Error(FSComp.SR.typrelMoreThenOneOverride(FormatMethInfoSig g amap m denv dispatchSlot), m)) + + if missingOverloadImplementation.Count > 0 then + // compose message listing missing override implementation + let maxDisplayedOverrides = 10 + let shouldTruncate = missingOverloadImplementation.Count > maxDisplayedOverrides + let messageWithInterfaceSuggestion = + // check any of the missing overrides has isReqdTyInterface flag set + // in which case we use the message "with suggestion" + missingOverloadImplementation + |> Seq.map fst + |> Seq.filter id + |> Seq.isEmpty + |> not + + if missingOverloadImplementation.Count = 1 then + // only one missing override, we have specific message for that + let signature = (snd missingOverloadImplementation.[0]).Value + if messageWithInterfaceSuggestion then + fail(Error(FSComp.SR.typrelNoImplementationGivenWithSuggestion(signature), m)) + else + fail(Error(FSComp.SR.typrelNoImplementationGiven(signature), m)) + else + let signatures = + (missingOverloadImplementation + |> Seq.truncate maxDisplayedOverrides + |> Seq.map snd + |> Seq.map (fun signature -> System.Environment.NewLine + "\t'" + signature.Value + "'") + |> String.concat "") + System.Environment.NewLine + + // we have specific message if the list is truncated + let messageFunction = + match shouldTruncate, messageWithInterfaceSuggestion with + | false, true -> FSComp.SR.typrelNoImplementationGivenSeveralWithSuggestion + | false, false -> FSComp.SR.typrelNoImplementationGivenSeveral + | true , true -> FSComp.SR.typrelNoImplementationGivenSeveralTruncatedWithSuggestion + | true , false -> FSComp.SR.typrelNoImplementationGivenSeveralTruncated + fail(Error(messageFunction(signatures), m)) + + res + + /// This is to find override methods that are at the most specific in the hierarchy of interface types. + let GetMostSpecificOverrideInterfaceMethodSets (infoReader: InfoReader) allReqdTys = + let g = infoReader.g + let amap = infoReader.amap + + let multipleSets = + allReqdTys + // Widdle down to the most specific interfaces. + |> GetMostSpecificItemsByType g amap (fun (ty, m) -> + if isInterfaceTy g ty then + Some(ty, m) + else + None) + + // Get the most specific method overrides for each interface type. + |> List.choose (fun (ty, m) -> + let mostSpecificOverrides = GetIntrinisicMostSpecificOverrideMethInfoSetsOfType infoReader m ty + if mostSpecificOverrides.IsEmpty then None + else Some mostSpecificOverrides) + + match multipleSets with + | [] -> NameMultiMap.Empty + | [set] -> set + | _ -> + multipleSets + // Merge method sets together. + |> List.reduce (fun final minfoSets -> + Map.fold (fun acc key minfos -> + match acc.TryGetValue key with + | true, minfos2 -> Map.add key (minfos @ minfos2) acc + | _ -> Map.add key minfos acc) final minfoSets) + + // Filter for most specifics when the sets have merged together. + |> FilterMostSpecificMethInfoSets g amap range0 + + /// Finds the override interface methods from the most specific overrides by the given method. + let GetMostSpecificOverrideInterfaceMethodsByMethod g amap m (mostSpecificOverrides: NameMultiMap) (minfo: MethInfo) = + let overrideBy = GetInheritedMemberOverrideInfo g amap m OverrideCanImplement.CanImplementAnyInterfaceSlot minfo + let minfoTy = generalizedTyconRef minfo.ApparentEnclosingTyconRef + NameMultiMap.find minfo.LogicalName mostSpecificOverrides + |> List.filter (fun (overridenTy, minfo2) -> + typeEquiv g overridenTy minfoTy && + IsSigExactMatch g amap m minfo2 overrideBy) + + /// Get a collection of slots for the given interface type. + let GetInterfaceDispatchSlots (infoReader: InfoReader) ad m availImpliedInterfaces mostSpecificOverrides interfaceTy = + let g = infoReader.g + let amap = infoReader.amap + + if isInterfaceTy g interfaceTy then + // Check if the interface has an inherited implementation + // If so, you do not have to implement all the methods - each + // specific method is "optionally" implemented. + let isInterfaceOptional = ListSet.contains (typeEquiv g) interfaceTy availImpliedInterfaces + [ for minfo in GetImmediateIntrinsicMethInfosOfType (None, ad) g amap m interfaceTy do + if minfo.IsNewSlot then + // If the interface itself is considered optional, then we are finished and do not need anymore context. + // Even if the method is actually not abstract. + if isInterfaceOptional then + yield RequiredSlot (minfo, true) + + // F# defined interface methods have no notion of optional/abstract or DIMs. + elif not minfo.IsILMethod then + yield RequiredSlot (minfo, false) + + // IL methods might have default implementations. + else + let isMethodOptional (minfo: MethInfo) = + // A DIM is considered *not* 'optional' if it is not language supported. + g.langVersion.SupportsFeature LanguageFeature.DefaultInterfaceMemberConsumption && + not minfo.IsAbstract + + match GetMostSpecificOverrideInterfaceMethodsByMethod g amap m mostSpecificOverrides minfo with + // No override. + | [] -> + if minfo.IsAbstract then + // Regular interface methods are never optional. + yield RequiredSlot (minfo, false) + else + yield DefaultInterfaceImplementationSlot (minfo, isMethodOptional minfo, false) + + // One override, one default implementation. + | [ (_, minfo2) ] -> + yield DefaultInterfaceImplementationSlot (minfo, isMethodOptional minfo2, false) + + // We found multiple override methods, means we might have ambiguity. + | _ -> + // If DIMs are not language supported, then do not consider a slot to have a specific implementation. + let possiblyNoMostSpecific = + g.langVersion.SupportsFeature LanguageFeature.DefaultInterfaceMemberConsumption + + yield DefaultInterfaceImplementationSlot (minfo, false, possiblyNoMostSpecific) ] + else + [] + + /// Get a collection of slots for the given class type. + let GetClassDispatchSlots (infoReader: InfoReader) ad m reqdTy = + [ if not (isInterfaceTy infoReader.g reqdTy) then + // In the normal case, the requirements for a class are precisely all the abstract slots up the whole hierarchy. + // So here we get and yield all of those. + for minfo in reqdTy |> GetIntrinsicMethInfosOfType infoReader None ad AllowMultiIntfInstantiations.Yes IgnoreOverrides m do + if minfo.IsDispatchSlot then + yield RequiredSlot(minfo, not minfo.IsAbstract) ] + + /// Get a collection of slots for the given type and implied types. + let GetDispatchSlotSet (infoReader: InfoReader) ad m availImpliedInterfaces mostSpecificOverrides reqdTy impliedTys = + let g = infoReader.g + + if isInterfaceTy g reqdTy then + [ for impliedTy in impliedTys do + yield (impliedTy, GetInterfaceDispatchSlots infoReader ad m availImpliedInterfaces mostSpecificOverrides impliedTy) ] + else + [ (reqdTy, GetClassDispatchSlots infoReader ad m reqdTy) ] + + /// Check all implementations implement some dispatch slot. + let CheckOverridesAreAllUsedOnce(denv, g, amap, isObjExpr, reqdTy, + dispatchSlotsKeyed: NameMultiMap, + availPriorOverrides: OverrideInfo list, + overrides: OverrideInfo list) = + let availPriorOverridesKeyed = availPriorOverrides |> NameMultiMap.initBy (fun ov -> ov.LogicalName) + for overrideBy in overrides do + if not overrideBy.IsFakeEventProperty then + let m = overrideBy.Range + let relevantVirts = NameMultiMap.find overrideBy.LogicalName dispatchSlotsKeyed + let relevantVirts = relevantVirts |> List.map (fun reqdSlot -> reqdSlot.MethodInfo) + + match relevantVirts |> List.filter (fun dispatchSlot -> OverrideImplementsDispatchSlot g amap m dispatchSlot overrideBy) with + | [] -> + // This is all error reporting + match relevantVirts |> List.filter (fun dispatchSlot -> IsPartialMatch g dispatchSlot (CompiledSigOfMeth g amap m dispatchSlot) overrideBy) with + | [dispatchSlot] -> + errorR(OverrideDoesntOverride(denv, overrideBy, Some dispatchSlot, g, amap, m)) + | _ -> + match relevantVirts |> List.filter (fun dispatchSlot -> IsNameMatch dispatchSlot overrideBy) with + | [] -> errorR(OverrideDoesntOverride(denv, overrideBy, None, g, amap, m)) + | [dispatchSlot] -> + errorR(OverrideDoesntOverride(denv, overrideBy, Some dispatchSlot, g, amap, m)) + | possibleDispatchSlots -> + let details = + possibleDispatchSlots + |> List.map (fun dispatchSlot -> FormatMethInfoSig g amap m denv dispatchSlot) + |> Seq.map (sprintf "%s %s" System.Environment.NewLine) + |> String.concat "" + + errorR(Error(FSComp.SR.typrelMemberHasMultiplePossibleDispatchSlots(FormatOverride denv overrideBy, details), overrideBy.Range)) + + + | [dispatchSlot] -> + if dispatchSlot.IsFinal && (isObjExpr || not (typeEquiv g reqdTy dispatchSlot.ApparentEnclosingType)) then + errorR(Error(FSComp.SR.typrelMethodIsSealed(NicePrint.stringOfMethInfo amap m denv dispatchSlot), m)) + | dispatchSlots -> + match dispatchSlots |> List.filter (fun dispatchSlot -> + isInterfaceTy g dispatchSlot.ApparentEnclosingType || + not (DispatchSlotIsAlreadyImplemented g amap m availPriorOverridesKeyed dispatchSlot)) with + | h1 :: h2 :: _ -> + errorR(Error(FSComp.SR.typrelOverrideImplementsMoreThenOneSlot((FormatOverride denv overrideBy), (NicePrint.stringOfMethInfo amap m denv h1), (NicePrint.stringOfMethInfo amap m denv h2)), m)) + | _ -> + // dispatch slots are ordered from the derived classes to base + // so we can check the topmost dispatch slot if it is final + match dispatchSlots with + | meth :: _ when meth.IsFinal -> errorR(Error(FSComp.SR.tcCannotOverrideSealedMethod((sprintf "%s::%s" (meth.ApparentEnclosingType.ToString()) (meth.LogicalName))), m)) + | _ -> () + + + + /// Get the slots of a type that can or must be implemented. This depends + /// partly on the full set of interface types that are being implemented + /// simultaneously, e.g. + /// { new C with interface I2 = ... interface I3 = ... } + /// allReqdTys = {C;I2;I3} + /// + /// allReqdTys can include one class/record/union type. + let GetSlotImplSets (infoReader: InfoReader) denv ad isObjExpr allReqdTys = + + let g = infoReader.g + let amap = infoReader.amap + + let availImpliedInterfaces : TType list = + [ for (reqdTy, m) in allReqdTys do + if not (isInterfaceTy g reqdTy) then + let baseTyOpt = if isObjExpr then Some reqdTy else GetSuperTypeOfType g amap m reqdTy + match baseTyOpt with + | None -> () + | Some baseTy -> yield! AllInterfacesOfType g amap m AllowMultiIntfInstantiations.Yes baseTy ] + + // For each implemented type, get a list containing the transitive closure of + // interface types implied by the type. This includes the implemented type itself if the implemented type + // is an interface type. + let intfSets = + allReqdTys |> List.mapi (fun i (reqdTy, m) -> + let interfaces = AllInterfacesOfType g amap m AllowMultiIntfInstantiations.Yes reqdTy + let impliedTys = (if isInterfaceTy g reqdTy then interfaces else reqdTy :: interfaces) + (i, reqdTy, impliedTys, m)) + + // For each implemented type, reduce its list of implied interfaces by subtracting out those implied + // by another implemented interface type. + // + // REVIEW: Note complexity O(N^2) + let reqdTyInfos = + intfSets |> List.map (fun (i, reqdTy, impliedTys, m) -> + let reduced = + (impliedTys, intfSets) ||> List.fold (fun acc (j, jty, impliedTys2, m) -> + if i <> j && TypeFeasiblySubsumesType 0 g amap m jty CanCoerce reqdTy + then ListSet.subtract (TypesFeasiblyEquiv 0 g amap m) acc impliedTys2 + else acc ) + (i, reqdTy, m, reduced)) + + // Find the full set of most derived interfaces, used roots to search for default interface implementations of interface methods. + let mostSpecificOverrides = GetMostSpecificOverrideInterfaceMethodSets infoReader allReqdTys + + // Get the SlotImplSet for each implemented type + // This contains the list of required members and the list of available members + [ for (i, reqdTy, reqdTyRange, impliedTys) in reqdTyInfos do + + // Check that, for each implemented type, at least one implemented type is implied. This is enough to capture + // duplicates. + if isInterfaceTy g reqdTy && isNil impliedTys then + errorR(Error(FSComp.SR.typrelDuplicateInterface(), reqdTyRange)) + + // Build a set of the implied interface types, for quicker lookup, by nominal type + let isImpliedInterfaceTable = + impliedTys + |> List.filter (isInterfaceTy g) + |> List.map (fun ty -> tcrefOfAppTy g ty, ()) + |> TyconRefMap.OfList + + // Is a member an abstract slot of one of the implied interface types? + let isImpliedInterfaceType ty = + isAppTy g ty && + isImpliedInterfaceTable.ContainsKey (tcrefOfAppTy g ty) && + impliedTys |> List.exists (TypesFeasiblyEquiv 0 g amap reqdTyRange ty) + + let dispatchSlotSet = GetDispatchSlotSet infoReader ad reqdTyRange availImpliedInterfaces mostSpecificOverrides reqdTy impliedTys + + // Compute the methods that are available to implement abstract slots from the base class + // + // This is used in CheckDispatchSlotsAreImplemented when we think a dispatch slot may not + // have been implemented. + let availPriorOverrides : OverrideInfo list = + if isInterfaceTy g reqdTy then + [] + else + let reqdTy = + let baseTyOpt = if isObjExpr then Some reqdTy else GetSuperTypeOfType g amap reqdTyRange reqdTy + match baseTyOpt with + | None -> reqdTy + | Some baseTy -> baseTy + [ // Get any class hierarchy methods or default interface methods on this type on this type + // + // NOTE: What we have below is an over-approximation that will get too many methods + // and not always correctly relate them to the slots they implement. For example, + // we may get an override from a base class and believe it implements a fresh, new abstract + // slot in a subclass. + for minfos in infoReader.GetRawIntrinsicMethodSetsOfType(None, ad, AllowMultiIntfInstantiations.Yes, reqdTyRange, reqdTy) do + for minfo in minfos do + if not minfo.IsAbstract then + yield GetInheritedMemberOverrideInfo g amap reqdTyRange CanImplementAnyClassHierarchySlot minfo ] + + /// Check that no interface type is implied twice + for (j, _, _, impliedTys2) in reqdTyInfos do + if i > j then + for (ty, dispatchSlots) in dispatchSlotSet do + if impliedTys2 |> List.exists (TypesFeasiblyEquiv 0 g amap reqdTyRange ty) then + if dispatchSlots + |> List.exists (fun reqdSlot -> + let minfo = reqdSlot.MethodInfo + // If the slot is optional, then we do not need an explicit implementation. + minfo.IsNewSlot && not reqdSlot.IsOptional) then + errorR(Error(FSComp.SR.typrelNeedExplicitImplementation(NicePrint.minimalStringOfType denv ty), reqdTyRange)) + + // We also collect up the properties. This is used for abstract slot inference when overriding properties + let isRelevantRequiredProperty (x: PropInfo) = + (x.IsVirtualProperty && not (isInterfaceTy g reqdTy)) || + isImpliedInterfaceType x.ApparentEnclosingType + + let reqdProperties = + GetIntrinsicPropInfosOfType infoReader None ad AllowMultiIntfInstantiations.Yes IgnoreOverrides reqdTyRange reqdTy + |> List.filter isRelevantRequiredProperty + + let dispatchSlots = dispatchSlotSet |> List.map snd |> List.concat + let dispatchSlotsKeyed = dispatchSlots |> NameMultiMap.initBy (fun reqdSlot -> reqdSlot.MethodInfo.LogicalName) + yield SlotImplSet(dispatchSlots, dispatchSlotsKeyed, availPriorOverrides, reqdProperties) ] + + + /// Check that a type definition implements all its required interfaces after processing all declarations + /// within a file. + let CheckImplementationRelationAtEndOfInferenceScope (infoReader : InfoReader, denv, nenv, sink, tycon: Tycon, isImplementation) = + + let g = infoReader.g + let amap = infoReader.amap + + let tcaug = tycon.TypeContents + let interfaces = tycon.ImmediateInterfacesOfFSharpTycon |> List.map (fun (ity, _compgen, m) -> (ity, m)) + + let overallTy = generalizedTyconRef (mkLocalTyconRef tycon) + + let allReqdTys = (overallTy, tycon.Range) :: interfaces + + // Get all the members that are immediately part of this type + // Include the auto-generated members + let allImmediateMembers = tycon.MembersOfFSharpTyconSorted @ tycon.AllGeneratedValues + + // Get all the members we have to implement, organized by each type we explicitly implement + let slotImplSets = GetSlotImplSets infoReader denv AccessibleFromSomewhere false allReqdTys + + let allImpls = List.zip allReqdTys slotImplSets + + // Find the methods relevant to implementing the abstract slots listed under the reqdType being checked. + let allImmediateMembersThatMightImplementDispatchSlots = + allImmediateMembers |> List.filter (fun overrideBy -> + overrideBy.IsInstanceMember && // exclude static + overrideBy.IsVirtualMember && // exclude non virtual (e.g. keep override/default). [4469] + not overrideBy.IsDispatchSlotMember) + + let mustOverrideSomething reqdTy (overrideBy: ValRef) = + let memberInfo = overrideBy.MemberInfo.Value + not (overrideBy.IsFSharpEventProperty(g)) && + memberInfo.MemberFlags.IsOverrideOrExplicitImpl && + + match memberInfo.ImplementedSlotSigs with + | [] -> + // Are we looking at the implementation of the class hierarchy? If so include all the override members + not (isInterfaceTy g reqdTy) + | ss -> + ss |> List.forall (fun ss -> + let ty = ss.ImplementedType + if isInterfaceTy g ty then + // Is this a method impl listed under the reqdTy? + typeEquiv g ty reqdTy + else + not (isInterfaceTy g reqdTy) ) + + + // We check all the abstracts related to the class hierarchy and then check each interface implementation + for ((reqdTy, m), slotImplSet) in allImpls do + let (SlotImplSet(dispatchSlots, dispatchSlotsKeyed, availPriorOverrides, _)) = slotImplSet + try + + // Now extract the information about each overriding method relevant to this SlotImplSet + let allImmediateMembersThatMightImplementDispatchSlots = + allImmediateMembersThatMightImplementDispatchSlots + |> List.map (fun overrideBy -> overrideBy, GetTypeMemberOverrideInfo g reqdTy overrideBy) + + // Now check the implementation + // We don't give missing method errors for abstract classes + + if isImplementation && not (isInterfaceTy g overallTy) then + let overrides = allImmediateMembersThatMightImplementDispatchSlots |> List.map snd + let allCorrect = CheckDispatchSlotsAreImplemented (denv, infoReader, m, nenv, sink, tcaug.tcaug_abstract, reqdTy, dispatchSlots, availPriorOverrides, overrides) + + // Tell the user to mark the thing abstract if it was missing implementations + if not allCorrect && not tcaug.tcaug_abstract && not (isInterfaceTy g reqdTy) then + errorR(TypeIsImplicitlyAbstract(m)) + + let overridesToCheck = + allImmediateMembersThatMightImplementDispatchSlots + |> List.filter (fst >> mustOverrideSomething reqdTy) + |> List.map snd + + CheckOverridesAreAllUsedOnce (denv, g, amap, false, reqdTy, dispatchSlotsKeyed, availPriorOverrides, overridesToCheck) + + with e -> errorRecovery e m + + // Now record the full slotsigs of the abstract members implemented by each override. + // This is used to generate IL MethodImpls in the code generator. + allImmediateMembersThatMightImplementDispatchSlots |> List.iter (fun overrideBy -> + + let isFakeEventProperty = overrideBy.IsFSharpEventProperty(g) + let overriden = + if isFakeEventProperty then + let slotsigs = overrideBy.MemberInfo.Value.ImplementedSlotSigs + slotsigs |> List.map (ReparentSlotSigToUseMethodTypars g overrideBy.Range overrideBy) + else + [ for ((reqdTy, m), (SlotImplSet(_dispatchSlots, dispatchSlotsKeyed, _, _))) in allImpls do + let overrideByInfo = GetTypeMemberOverrideInfo g reqdTy overrideBy + let overridenForThisSlotImplSet = + [ for reqdSlot in NameMultiMap.find overrideByInfo.LogicalName dispatchSlotsKeyed do + let dispatchSlot = reqdSlot.MethodInfo + if OverrideImplementsDispatchSlot g amap m dispatchSlot overrideByInfo then + if tyconRefEq g overrideByInfo.BoundingTyconRef dispatchSlot.DeclaringTyconRef then + match dispatchSlot.ArbitraryValRef with + | Some virtMember -> + if virtMember.MemberInfo.Value.IsImplemented then errorR(Error(FSComp.SR.tcDefaultImplementationAlreadyExists(), overrideByInfo.Range)) + virtMember.MemberInfo.Value.IsImplemented <- true + | None -> () // not an F# slot + + // Get the slotsig of the overridden method + let slotsig = dispatchSlot.GetSlotSig(amap, m) + + // The slotsig from the overridden method is in terms of the type parameters on the parent type of the overriding method, + // Modify map the slotsig so it is in terms of the type parameters for the overriding method + let slotsig = ReparentSlotSigToUseMethodTypars g m overrideBy slotsig + + // Record the slotsig via mutation + yield slotsig ] + //if mustOverrideSomething reqdTy overrideBy then + // assert nonNil overridenForThisSlotImplSet + yield! overridenForThisSlotImplSet ] + + overrideBy.MemberInfo.Value.ImplementedSlotSigs <- overriden) + +/// "Type Completion" inference and a few other checks at the end of the inference scope +let FinalTypeDefinitionChecksAtEndOfInferenceScope (infoReader: InfoReader, nenv, sink, isImplementation, denv) (tycon: Tycon) = + + let g = infoReader.g + let amap = infoReader.amap + + let tcaug = tycon.TypeContents + tcaug.tcaug_closed <- true + + // Note you only have to explicitly implement 'System.IComparable' to customize structural comparison AND equality on F# types + if isImplementation && +#if !NO_EXTENSIONTYPING + not tycon.IsProvidedGeneratedTycon && +#endif + Option.isNone tycon.GeneratedCompareToValues && + tycon.HasInterface g g.mk_IComparable_ty && + not (tycon.HasOverride g "Equals" [g.obj_ty]) && + not tycon.IsFSharpInterfaceTycon + then + (* Warn when we're doing this for class types *) + if AugmentWithHashCompare.TyconIsCandidateForAugmentationWithEquals g tycon then + warning(Error(FSComp.SR.typrelTypeImplementsIComparableShouldOverrideObjectEquals(tycon.DisplayName), tycon.Range)) + else + warning(Error(FSComp.SR.typrelTypeImplementsIComparableDefaultObjectEqualsProvided(tycon.DisplayName), tycon.Range)) + + AugmentWithHashCompare.CheckAugmentationAttribs isImplementation g amap tycon + // Check some conditions about generic comparison and hashing. We can only check this condition after we've done the augmentation + if isImplementation +#if !NO_EXTENSIONTYPING + && not tycon.IsProvidedGeneratedTycon +#endif + then + let tcaug = tycon.TypeContents + let m = tycon.Range + let hasExplicitObjectGetHashCode = tycon.HasOverride g "GetHashCode" [] + let hasExplicitObjectEqualsOverride = tycon.HasOverride g "Equals" [g.obj_ty] + + if (Option.isSome tycon.GeneratedHashAndEqualsWithComparerValues) && + (hasExplicitObjectGetHashCode || hasExplicitObjectEqualsOverride) then + errorR(Error(FSComp.SR.typrelExplicitImplementationOfGetHashCodeOrEquals(tycon.DisplayName), m)) + + if not hasExplicitObjectEqualsOverride && hasExplicitObjectGetHashCode then + warning(Error(FSComp.SR.typrelExplicitImplementationOfGetHashCode(tycon.DisplayName), m)) + + if hasExplicitObjectEqualsOverride && not hasExplicitObjectGetHashCode then + warning(Error(FSComp.SR.typrelExplicitImplementationOfEquals(tycon.DisplayName), m)) + + // remember these values to ensure we don't generate these methods during codegen + tcaug.SetHasObjectGetHashCode hasExplicitObjectGetHashCode + + if not tycon.IsHiddenReprTycon + && not tycon.IsTypeAbbrev + && not tycon.IsMeasureableReprTycon + && not tycon.IsAsmReprTycon + && not tycon.IsFSharpInterfaceTycon + && not tycon.IsFSharpDelegateTycon then + + DispatchSlotChecking.CheckImplementationRelationAtEndOfInferenceScope (infoReader, denv, nenv, sink, tycon, isImplementation) + +/// Get the methods relevant to determining if a uniquely-identified-override exists based on the syntactic information +/// at the member signature prior to type inference. This is used to pre-assign type information if it does +let GetAbstractMethInfosForSynMethodDecl(infoReader: InfoReader, ad, memberName: Ident, bindm, typToSearchForAbstractMembers, valSynData) = + let minfos = + match typToSearchForAbstractMembers with + | _, Some(SlotImplSet(_, dispatchSlotsKeyed, _, _)) -> + NameMultiMap.find memberName.idText dispatchSlotsKeyed |> List.map (fun reqdSlot -> reqdSlot.MethodInfo) + | ty, None -> + GetIntrinsicMethInfosOfType infoReader (Some memberName.idText) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides bindm ty + let dispatchSlots = minfos |> List.filter (fun minfo -> minfo.IsDispatchSlot) + let topValSynArities = SynInfo.AritiesOfArgs valSynData + let topValSynArities = if List.isEmpty topValSynArities then topValSynArities else topValSynArities.Tail + let dispatchSlotsArityMatch = dispatchSlots |> List.filter (fun minfo -> minfo.NumArgs = topValSynArities) + dispatchSlots, dispatchSlotsArityMatch + +/// Get the properties relevant to determining if a uniquely-identified-override exists based on the syntactic information +/// at the member signature prior to type inference. This is used to pre-assign type information if it does +let GetAbstractPropInfosForSynPropertyDecl(infoReader: InfoReader, ad, memberName: Ident, bindm, typToSearchForAbstractMembers, _k, _valSynData) = + let pinfos = + match typToSearchForAbstractMembers with + | _, Some(SlotImplSet(_, _, _, reqdProps)) -> + reqdProps |> List.filter (fun pinfo -> pinfo.PropertyName = memberName.idText) + | ty, None -> + GetIntrinsicPropInfosOfType infoReader (Some memberName.idText) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides bindm ty + + let dispatchSlots = pinfos |> List.filter (fun pinfo -> pinfo.IsVirtualProperty) + dispatchSlots + diff --git a/src/fsharp/ParseHelpers.fs b/src/fsharp/ParseHelpers.fs index 3ff8ed46e17..0d283e7f957 100644 --- a/src/fsharp/ParseHelpers.fs +++ b/src/fsharp/ParseHelpers.fs @@ -218,7 +218,7 @@ and LexCont = LexerContinuation // Parse IL assembly code //------------------------------------------------------------------------ -let internal internalParseAssemblyCodeInstructions s isFeatureSupported m = +let internal internalParseAssemblyCodeInstructions s (isFeatureSupported: LanguageFeature -> bool) m : IL.ILInstr[] = #if NO_INLINE_IL_PARSER ignore s ignore isFeatureSupported @@ -234,12 +234,12 @@ let internal internalParseAssemblyCodeInstructions s isFeatureSupported m = errorR(Error(FSComp.SR.astParseEmbeddedILError(), m)); [||] #endif -let ParseAssemblyCodeInstructions s m = +let ParseAssemblyCodeInstructions s m : IL.ILInstr[] = // Public API can not answer the isFeatureSupported questions, so here we support everything let isFeatureSupported (_featureId:LanguageFeature) = true internalParseAssemblyCodeInstructions s isFeatureSupported m -let internal internalParseAssemblyCodeType s isFeatureSupported m = +let internal internalParseAssemblyCodeType s (isFeatureSupported: Features.LanguageFeature -> bool) m = ignore s ignore isFeatureSupported diff --git a/src/fsharp/ParseHelpers.fsi b/src/fsharp/ParseHelpers.fsi new file mode 100644 index 00000000000..b2fd5fb832c --- /dev/null +++ b/src/fsharp/ParseHelpers.fsi @@ -0,0 +1,109 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module public FSharp.Compiler.ParseHelpers + +open FSharp.Compiler.AbstractIL +open FSharp.Compiler.AbstractIL.IL +open FSharp.Compiler.Range +open Internal.Utilities.Text.Lexing +open Internal.Utilities.Text.Parsing + +/// The error raised by the parse_error_rich function, which is called by the parser engine +/// when a syntax error occurs. The first object is the ParseErrorContext which contains a dump of +/// information about the grammar at the point where the error occurred, e.g. what tokens +/// are valid to shift next at that point in the grammar. This information is processed in CompileOps.fs. +[] +exception SyntaxError of obj * range: range + +exception IndentationProblem of string * range + +val warningStringOfCoords: line:int -> column:int -> string + +val warningStringOfPos: p:pos -> string + +val internal posOfLexPosition: p:Position -> pos + +val internal mkSynRange: p1:Position -> p2:Position -> range + +type internal LexBuffer<'Char> with + member internal LexemeRange: range + +val internal lhs: parseState:IParseState -> range + +val internal rhs2: parseState:IParseState -> i:int -> j:int -> range + +val internal rhs: parseState:IParseState -> i:int -> range + +type internal IParseState with + member internal SynArgNameGenerator: SyntaxTreeOps.SynArgNameGenerator + member internal ResetSynArgNameGenerator: unit -> unit + +module LexbufLocalXmlDocStore = + val private xmlDocKey: string + val internal ClearXmlDoc: lexbuf:UnicodeLexing.Lexbuf -> unit + val internal SaveXmlDocLine: lexbuf:UnicodeLexing.Lexbuf * lineText:string * range:range -> unit + val internal GrabXmlDocBeforeMarker: lexbuf:UnicodeLexing.Lexbuf * markerRange:range -> XmlDoc.PreXmlDoc + +type LexerIfdefStackEntry = + | IfDefIf + | IfDefElse + +type LexerIfdefStackEntries = (LexerIfdefStackEntry * range) list + +type LexerIfdefStack = LexerIfdefStackEntries + +type LexerEndlineContinuation = + | Token + | Skip of int * range: range + +type LexerIfdefExpression = + | IfdefAnd of LexerIfdefExpression * LexerIfdefExpression + | IfdefOr of LexerIfdefExpression * LexerIfdefExpression + | IfdefNot of LexerIfdefExpression + | IfdefId of string + +val LexerIfdefEval: lookup:(string -> bool) -> _arg1:LexerIfdefExpression -> bool + +[] +type LexerStringStyle = + | Verbatim + | TripleQuote + | SingleQuote + +[] +type LexerStringKind = + { IsByteString: bool + IsInterpolated: bool + IsInterpolatedFirst: bool } + static member ByteString: LexerStringKind + static member InterpolatedStringFirst: LexerStringKind + static member InterpolatedStringPart: LexerStringKind + static member String: LexerStringKind + +type LexerInterpolatedStringNesting = + (int * LexerStringStyle * range) list + +[] +type LexerContinuation = + | Token of ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting + | IfDefSkip of ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * int * range: range + | String of ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * style: LexerStringStyle * kind: LexerStringKind * range: range + | Comment of ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * int * range: range + | SingleLineComment of ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * int * range: range + | StringInComment of ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * style: LexerStringStyle * int * range: range + | MLOnly of ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * range: range + | EndLine of ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * LexerEndlineContinuation + + member LexerIfdefStack: LexerIfdefStackEntries + + member LexerInterpStringNesting: LexerInterpolatedStringNesting + + static member Default: LexerContinuation + +and LexCont = LexerContinuation + +val internal internalParseAssemblyCodeInstructions: s:string -> isFeatureSupported:(Features.LanguageFeature -> bool) -> m:range -> ILInstr[] + +val ParseAssemblyCodeInstructions: s:string -> m:range -> ILInstr array val internal internalParseAssemblyCodeType: s:string -> isFeatureSupported:(Features.LanguageFeature -> bool) -> m:range -> ILType + +val ParseAssemblyCodeType: s:string -> m:range -> ILType diff --git a/src/fsharp/PrettyNaming.fs b/src/fsharp/PrettyNaming.fs index 2a6d0a64d89..5d649efbb13 100755 --- a/src/fsharp/PrettyNaming.fs +++ b/src/fsharp/PrettyNaming.fs @@ -489,7 +489,6 @@ let GetBasicNameOfPossibleCompilerGeneratedName (name: string) = let CompilerGeneratedNameSuffix (basicName: string) suffix = basicName+compilerGeneratedMarker+suffix - //------------------------------------------------------------------------- // Handle mangled .NET generic type names //------------------------------------------------------------------------- @@ -703,7 +702,6 @@ let mangleProvidedTypeName (typeLogicalName, nonDefaultArgs) = else typeLogicalName + "," + nonDefaultArgsText - /// Mangle the static parameters for a provided type or method let computeMangledNameWithoutDefaultArgValues(nm, staticArgs, defaultArgValues) = let nonDefaultArgs = @@ -762,10 +760,13 @@ let unassignedTyparName = "?" //-------------------------------------------------------------------------- let FSharpOptimizationDataResourceName = "FSharpOptimizationData." + let FSharpSignatureDataResourceName = "FSharpSignatureData." + // For historical reasons, we use a different resource name for FSharp.Core, so older F# compilers // don't complain when they see the resource. The prefix of these names must not be 'FSharpOptimizationData' // or 'FSharpSignatureData' let FSharpOptimizationDataResourceName2 = "FSharpOptimizationInfo." + let FSharpSignatureDataResourceName2 = "FSharpSignatureInfo." diff --git a/src/fsharp/PrettyNaming.fsi b/src/fsharp/PrettyNaming.fsi new file mode 100644 index 00000000000..40f7b750358 --- /dev/null +++ b/src/fsharp/PrettyNaming.fsi @@ -0,0 +1,178 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +/// Some general F# utilities for mangling / unmangling / manipulating names. +/// Anything to do with special names of identifiers and other lexical rules +module public FSharp.Compiler.PrettyNaming + +open FSharp.Compiler +open FSharp.Compiler.AbstractIL +open Internal.Utilities.StructuredFormat + +[] +val parenGet: string = ".()" + +[] +val parenSet: string = ".()<-" + +[] +val qmark: string = "?" + +[] +val qmarkSet: string = "?<-" + +/// Prefix for compiled (mangled) operator names. +[] +val opNamePrefix: string = "op_" + +/// Returns `true` if given string is an operator or double backticked name, e.g. ( |>> ) or ( long identifier ). +/// (where ( long identifier ) is the display name for ``long identifier``). +val IsOperatorOrBacktickedName: name:string -> bool + +/// Returns `true` if given string is an operator display name, e.g. ( |>> ) +val IsOperatorName: name:string -> bool + +val IsMangledOpName: n:string -> bool + +/// Compiles an operator into a mangled operator name. +/// For example, "!%" becomes "op_DereferencePercent". +/// This function accepts both built-in and custom operators. +val CompileOpName: (string -> string) + +/// Decompiles a mangled operator name back into an operator. +/// For example, "op_DereferencePercent" becomes "!%". +/// This function accepts mangled names for both built-in and custom operators. +val DecompileOpName: (string -> string) + +val DemangleOperatorName: nm:string -> string + +val DemangleOperatorNameAsLayout: nonOpTagged:(string -> #TaggedText) -> nm:string -> Layout + +val opNameCons: string + +val opNameNil: string + +val opNameEquals: string + +val opNameEqualsNullable: string + +val opNameNullableEquals: string + +val opNameNullableEqualsNullable: string + +/// The characters that are allowed to be the first character of an identifier. +val IsIdentifierFirstCharacter: c:char -> bool + +/// The characters that are allowed to be in an identifier. +val IsIdentifierPartCharacter: c:char -> bool + +/// Is this character a part of a long identifier? +val IsLongIdentifierPartCharacter: c:char -> bool + +val isTildeOnlyString: s:string -> bool + +val IsValidPrefixOperatorUse: s:string -> bool + +val IsValidPrefixOperatorDefinitionName: s:string -> bool + +val IsPrefixOperator: s:string -> bool + +val IsPunctuation: s:string -> bool + +val IsTernaryOperator: s:string -> bool + +val IsInfixOperator: (string -> bool) + +val ( |Control|Equality|Relational|Indexer|FixedTypes|Other| ): + opName:string -> Choice + +val IsCompilerGeneratedName: nm:string -> bool + +val CompilerGeneratedName: nm:string -> string + +val GetBasicNameOfPossibleCompilerGeneratedName: name:string -> string + +val CompilerGeneratedNameSuffix: basicName:string -> suffix:string -> string + +val TryDemangleGenericNameAndPos: n:string -> int voption + +type NameArityPair = | NameArityPair of string * int + +val DemangleGenericTypeNameWithPos: pos:int -> mangledName:string -> string + +val DecodeGenericTypeNameWithPos: pos:int -> mangledName:string -> NameArityPair + +val DemangleGenericTypeName: mangledName:string -> string + +val DecodeGenericTypeName: mangledName:string -> NameArityPair + +/// Try to chop "get_" or "set_" from a string +val TryChopPropertyName: s:string -> string option + +/// Try to chop "get_" or "set_" from a string. +/// If the string does not start with "get_" or "set_", this function raises an exception. +val ChopPropertyName: s:string -> string + +val SplitNamesForILPath: s:string -> string list + +[] +val FSharpModuleSuffix: string = "Module" + +[] +val MangledGlobalName: string = "`global`" + +val IllegalCharactersInTypeAndNamespaceNames: char [] + +/// Determines if the specified name is a valid name for an active pattern. +val IsActivePatternName: name:string -> bool + +type ActivePatternInfo = + | APInfo of bool * (string * Range.range) list * Range.range + member ActiveTags: string list + member ActiveTagsWithRanges: (string * Range.range) list + member IsTotal: bool + member Range: Range.range + +val ActivePatternInfoOfValName: nm:string -> m:Range.range -> ActivePatternInfo option + +exception InvalidMangledStaticArg of string + +val demangleProvidedTypeName: typeLogicalName:string -> string * (string * string) [] + +/// Mangle the static parameters for a provided type or method +val mangleProvidedTypeName: typeLogicalName:string * nonDefaultArgs:(string * string) [] -> string + +/// Mangle the static parameters for a provided type or method +val computeMangledNameWithoutDefaultArgValues: nm:string * staticArgs:'a [] * defaultArgValues:(string * string option) [] -> string + +val outArgCompilerGeneratedName: string + +val ExtraWitnessMethodName: nm:string -> string + +/// Reuses generated union case field name objects for common field numbers +val mkUnionCaseFieldName: (int -> int -> string) + +/// Reuses generated exception field name objects for common field numbers +val mkExceptionFieldName: (int -> string) + +/// The prefix of the names used for the fake namespace path added to all dynamic code entries in FSI.EXE +val FsiDynamicModulePrefix: string + +module FSharpLib = + val Root: string + val RootPath: string list + val Core: string + val CorePath: string list + +module CustomOperations = + [] + val Into: string = "into" + +val unassignedTyparName: string + +val FSharpOptimizationDataResourceName: string + +val FSharpSignatureDataResourceName: string + +val FSharpOptimizationDataResourceName2: string + +val FSharpSignatureDataResourceName2: string diff --git a/src/fsharp/QueueList.fs b/src/fsharp/QueueList.fs index be38afa9ac0..4914e3d2062 100644 --- a/src/fsharp/QueueList.fs +++ b/src/fsharp/QueueList.fs @@ -24,16 +24,20 @@ type internal QueueList<'T>(firstElementsIn:'T list, lastElementsRevIn: 'T list, let lastElements() = if push then [] else List.rev lastElementsRev static let empty = QueueList<'T>([], [], 0) + static member Empty : QueueList<'T> = empty + new (xs:'T list) = QueueList(xs,[],0) member x.ToList() = if push then firstElements else List.append firstElements (lastElements()) - member internal x.FirstElements = firstElements - member internal x.LastElements = lastElements() + member x.FirstElements = firstElements + + member x.LastElements = lastElements() /// This operation is O(1), unless a push happens, which is rare. member x.AppendOne(y) = QueueList(firstElements, y :: lastElementsRev, numLastElements+1) + member x.Append(ys:seq<_>) = let newElements = Seq.toList ys let newLength = List.length newElements @@ -43,24 +47,37 @@ type internal QueueList<'T>(firstElementsIn:'T list, lastElementsRevIn: 'T list, /// This operation is O(n) anyway, so executing ToList() here is OK interface IEnumerable<'T> with member x.GetEnumerator() : IEnumerator<'T> = (x.ToList() :> IEnumerable<_>).GetEnumerator() + interface IEnumerable with member x.GetEnumerator() : IEnumerator = ((x :> IEnumerable<'T>).GetEnumerator() :> IEnumerator) -[] module internal QueueList = let empty<'T> : QueueList<'T> = QueueList<'T>.Empty + let ofSeq (x:seq<_>) = QueueList(List.ofSeq x) + let rec iter f (x:QueueList<_>) = Seq.iter f x + let rec map f (x:QueueList<_>) = ofSeq (Seq.map f x) + let rec exists f (x:QueueList<_>) = Seq.exists f x + let rec filter f (x:QueueList<_>) = ofSeq (Seq.filter f x) + let rec foldBack f (x:QueueList<_>) acc = List.foldBack f x.FirstElements (List.foldBack f x.LastElements acc) + let forall f (x:QueueList<_>) = Seq.forall f x + let ofList (x:list<_>) = QueueList(x) + let toList (x:QueueList<_>) = Seq.toList x + let tryFind f (x:QueueList<_>) = Seq.tryFind f x + let one(x) = QueueList [x] + let appendOne (x:QueueList<_>) y = x.AppendOne(y) + let append (x:QueueList<_>) (ys:QueueList<_>) = x.Append(ys) #if QUEUE_LIST_UNITTESTS diff --git a/src/fsharp/QueueList.fsi b/src/fsharp/QueueList.fsi new file mode 100644 index 00000000000..af57486a7ea --- /dev/null +++ b/src/fsharp/QueueList.fsi @@ -0,0 +1,58 @@ +namespace Internal.Utilities + +/// Iterable functional collection with O(1) append-1 time. Useful for data structures where elements get added at the +/// end but the collection must occasionally be iterated. Iteration is slower and may allocate because +/// a suffix of elements is stored in reverse order. +/// +/// The type doesn't support structural hashing or comparison. +type internal QueueList<'T> = + + interface System.Collections.IEnumerable + + interface System.Collections.Generic.IEnumerable<'T> + + new: xs:'T list -> QueueList<'T> + + new: firstElementsIn:'T list * lastElementsRevIn:'T list * numLastElementsIn:int -> QueueList<'T> + + member Append: ys:seq<'T> -> QueueList<'T> + + member AppendOne: y:'T -> QueueList<'T> + + member ToList: unit -> 'T list + + member FirstElements: 'T list + + member LastElements: 'T list + + static member Empty: QueueList<'T> + +module internal QueueList = + + val empty<'T> : QueueList<'T> + + val ofSeq: x:seq<'a> -> QueueList<'a> + + val iter: f:('a -> unit) -> x:QueueList<'a> -> unit + + val map: f:('a -> 'b) -> x:QueueList<'a> -> QueueList<'b> + + val exists: f:('a -> bool) -> x:QueueList<'a> -> bool + + val filter: f:('a -> bool) -> x:QueueList<'a> -> QueueList<'a> + + val foldBack: f:('a -> 'b -> 'b) -> x:QueueList<'a> -> acc:'b -> 'b + + val forall: f:('a -> bool) -> x:QueueList<'a> -> bool + + val ofList: x:'a list -> QueueList<'a> + + val toList: x:QueueList<'a> -> 'a list + + val tryFind: f:('a -> bool) -> x:QueueList<'a> -> 'a option + + val one: x:'a -> QueueList<'a> + + val appendOne: x:QueueList<'a> -> y:'a -> QueueList<'a> + + val append: x:QueueList<'a> -> ys:QueueList<'a> -> QueueList<'a> diff --git a/src/fsharp/ReferenceResolver.fs b/src/fsharp/ReferenceResolver.fs index d9a23ecb2a1..23f68bf0029 100644 --- a/src/fsharp/ReferenceResolver.fs +++ b/src/fsharp/ReferenceResolver.fs @@ -10,17 +10,21 @@ module public ReferenceResolver = type ResolutionEnvironment = /// Indicates a script or source being edited or compiled. Uses reference assemblies (not implementation assemblies). | EditingOrCompilation of isEditing: bool + /// Indicates a script or source being dynamically compiled and executed. Uses implementation assemblies. | CompilationAndEvaluation type ResolvedFile = - { /// Item specification. + { + /// Item specification. itemSpec:string + /// Prepare textual information about where the assembly was resolved from, used for tooltip output prepareToolTip: string * string -> string + /// Round-tripped baggage baggage:string - } + } override this.ToString() = sprintf "ResolvedFile(%s)" this.itemSpec diff --git a/src/fsharp/ReferenceResolver.fsi b/src/fsharp/ReferenceResolver.fsi new file mode 100644 index 00000000000..33af4dfad7f --- /dev/null +++ b/src/fsharp/ReferenceResolver.fsi @@ -0,0 +1,56 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module FSharp.Compiler.ReferenceResolver + +exception internal ResolutionFailure + +[] +type ResolutionEnvironment = + /// Indicates a script or source being edited or compiled. Uses reference assemblies (not implementation assemblies). + | EditingOrCompilation of isEditing: bool + + /// Indicates a script or source being dynamically compiled and executed. Uses implementation assemblies. + | CompilationAndEvaluation + +type ResolvedFile = + { + /// Item specification. + itemSpec:string + + /// Prepare textual information about where the assembly was resolved from, used for tooltip output + prepareToolTip: string * string -> string + + /// Round-tripped baggage + baggage:string + } + +[] +type Resolver = + /// Get the "v4.5.1"-style moniker for the highest installed .NET Framework version. + /// This is the value passed back to Resolve if no explicit "mscorlib" has been given. + /// + /// Note: If an explicit "mscorlib" is given, then --noframework is being used, and the whole ReferenceResolver logic is essentially + /// unused. However in the future an option may be added to allow an explicit specification of + /// a .NET Framework version to use for scripts. + abstract member HighestInstalledNetFrameworkVersion: unit -> string + + /// Perform assembly resolution on the given references under the given conditions + abstract member Resolve: + resolutionEnvironment:ResolutionEnvironment * + references:(string * string) [] * + targetFrameworkVersion:string * + targetFrameworkDirectories:string list * + targetProcessorArchitecture:string * + fsharpCoreDir:string * + explicitIncludeDirs:string list * + implicitIncludeDir:string * + logMessage:(string -> unit) * + logDiagnostic:(bool -> string -> string -> unit) -> + ResolvedFile [] + + /// Get the Reference Assemblies directory for the .NET Framework (on Windows) + /// This is added to the default resolution path for + /// design-time compilations. + abstract member DotNetFrameworkReferenceAssembliesRootDirectory: string + + diff --git a/src/fsharp/SignatureConformance.fsi b/src/fsharp/SignatureConformance.fsi new file mode 100644 index 00000000000..b1bd00345e9 --- /dev/null +++ b/src/fsharp/SignatureConformance.fsi @@ -0,0 +1,675 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +/// Primary relations on types and signatures, with the exception of +/// constraint solving and method overload resolution. +module internal FSharp.Compiler.SignatureConformance + +open System.Text + +open FSharp.Compiler +open FSharp.Compiler.AbstractIL.Internal +open FSharp.Compiler.AbstractIL.Internal.Library +open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.Lib +open FSharp.Compiler.Infos +open FSharp.Compiler.Range +open FSharp.Compiler.SyntaxTree +open FSharp.Compiler.SyntaxTreeOps +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeBasics +open FSharp.Compiler.TypedTreeOps + +#if !NO_EXTENSIONTYPING +open FSharp.Compiler.ExtensionTyping +#endif + + +exception RequiredButNotSpecified of DisplayEnv * ModuleOrNamespaceRef * string * (StringBuilder -> unit) * range + +exception ValueNotContained of DisplayEnv * ModuleOrNamespaceRef * Val * Val * (string * string * string -> string) + +exception ConstrNotContained of DisplayEnv * UnionCase * UnionCase * (string * string -> string) + +exception ExnconstrNotContained of DisplayEnv * Tycon * Tycon * (string * string -> string) + +exception FieldNotContained of DisplayEnv * RecdField * RecdField * (string * string -> string) + +exception InterfaceNotRevealed of DisplayEnv * TType * range + +// Use a type to capture the constant, common parameters +type Checker(g, amap, denv, remapInfo: SignatureRepackageInfo, checkingSig) = + + // Build a remap that maps tcrefs in the signature to tcrefs in the implementation + // Used when checking attributes. + let sigToImplRemap = + let remap = Remap.Empty + let remap = (remapInfo.RepackagedEntities, remap) ||> List.foldBack (fun (implTcref, signTcref) acc -> addTyconRefRemap signTcref implTcref acc) + let remap = (remapInfo.RepackagedVals, remap) ||> List.foldBack (fun (implValRef, signValRef) acc -> addValRemap signValRef.Deref implValRef.Deref acc) + remap + + // For all attributable elements (types, modules, exceptions, record fields, unions, parameters, generic type parameters) + // + // (a) Start with lists AImpl and ASig containing the attributes in the implementation and signature, in declaration order + // (b) Each attribute in AImpl is checked against the available attributes in ASig. + // a. If an attribute is found in ASig which is an exact match (after evaluating attribute arguments), then the attribute in the implementation is ignored, the attribute is removed from ASig, and checking continues + // b. If an attribute is found in ASig that has the same attribute type, then a warning is given and the attribute in the implementation is ignored + // c. Otherwise, the attribute in the implementation is kept + // (c) The attributes appearing in the compiled element are the compiled forms of the attributes from the signature and the kept attributes from the implementation + let checkAttribs _aenv (implAttribs: Attribs) (sigAttribs: Attribs) fixup = + + // Remap the signature attributes to make them look as if they were declared in + // the implementation. This allows us to compare them and propagate them to the implementation + // if needed. + let sigAttribs = sigAttribs |> List.map (remapAttrib g sigToImplRemap) + + // Helper to check for equality of evaluated attribute expressions + let attribExprEq (AttribExpr(_, e1)) (AttribExpr(_, e2)) = EvaledAttribExprEquality g e1 e2 + + // Helper to check for equality of evaluated named attribute arguments + let attribNamedArgEq (AttribNamedArg(nm1, ty1, isProp1, e1)) (AttribNamedArg(nm2, ty2, isProp2, e2)) = + (nm1 = nm2) && + typeEquiv g ty1 ty2 && + (isProp1 = isProp2) && + attribExprEq e1 e2 + + let attribsEq attrib1 attrib2 = + let (Attrib(implTcref, _, implArgs, implNamedArgs, _, _, _implRange)) = attrib1 + let (Attrib(signTcref, _, signArgs, signNamedArgs, _, _, _signRange)) = attrib2 + tyconRefEq g signTcref implTcref && + (implArgs, signArgs) ||> List.lengthsEqAndForall2 attribExprEq && + (implNamedArgs, signNamedArgs) ||> List.lengthsEqAndForall2 attribNamedArgEq + + let attribsHaveSameTycon attrib1 attrib2 = + let (Attrib(implTcref, _, _, _, _, _, _)) = attrib1 + let (Attrib(signTcref, _, _, _, _, _, _)) = attrib2 + tyconRefEq g signTcref implTcref + + // For each implementation attribute, only keep if it is not mentioned in the signature. + // Emit a warning if it is mentioned in the signature and the arguments to the attributes are + // not identical. + let rec check keptImplAttribsRev implAttribs sigAttribs = + match implAttribs with + | [] -> keptImplAttribsRev |> List.rev + | implAttrib :: remainingImplAttribs -> + + // Look for an attribute in the signature that matches precisely. If so, remove it + let lookForMatchingAttrib = sigAttribs |> List.tryRemove (attribsEq implAttrib) + match lookForMatchingAttrib with + | Some (_, remainingSigAttribs) -> check keptImplAttribsRev remainingImplAttribs remainingSigAttribs + | None -> + + // Look for an attribute in the signature that has the same type. If so, give a warning + let existsSimilarAttrib = sigAttribs |> List.exists (attribsHaveSameTycon implAttrib) + + if existsSimilarAttrib then + let (Attrib(implTcref, _, _, _, _, _, implRange)) = implAttrib + warning(Error(FSComp.SR.tcAttribArgsDiffer(implTcref.DisplayName), implRange)) + check keptImplAttribsRev remainingImplAttribs sigAttribs + else + check (implAttrib :: keptImplAttribsRev) remainingImplAttribs sigAttribs + + let keptImplAttribs = check [] implAttribs sigAttribs + + fixup (sigAttribs @ keptImplAttribs) + true + + let rec checkTypars m (aenv: TypeEquivEnv) (implTypars: Typars) (sigTypars: Typars) = + if implTypars.Length <> sigTypars.Length then + errorR (Error(FSComp.SR.typrelSigImplNotCompatibleParamCountsDiffer(), m)) + false + else + let aenv = aenv.BindEquivTypars implTypars sigTypars + (implTypars, sigTypars) ||> List.forall2 (fun implTypar sigTypar -> + let m = sigTypar.Range + if implTypar.StaticReq <> sigTypar.StaticReq then + errorR (Error(FSComp.SR.typrelSigImplNotCompatibleCompileTimeRequirementsDiffer(), m)) + + // Adjust the actual type parameter name to look like the signature + implTypar.SetIdent (mkSynId implTypar.Range sigTypar.Id.idText) + + // Mark it as "not compiler generated", now that we've got a good name for it + implTypar.SetCompilerGenerated false + + // Check the constraints in the implementation are present in the signature + implTypar.Constraints |> List.forall (fun implTyparCx -> + match implTyparCx with + // defaults can be dropped in the signature + | TyparConstraint.DefaultsTo(_, _acty, _) -> true + | _ -> + if not (List.exists (typarConstraintsAEquiv g aenv implTyparCx) sigTypar.Constraints) + then (errorR(Error(FSComp.SR.typrelSigImplNotCompatibleConstraintsDiffer(sigTypar.Name, Layout.showL(NicePrint.layoutTyparConstraint denv (implTypar, implTyparCx))), m)); false) + else true) && + + // Check the constraints in the signature are present in the implementation + sigTypar.Constraints |> List.forall (fun sigTyparCx -> + match sigTyparCx with + // defaults can be present in the signature and not in the implementation because they are erased + | TyparConstraint.DefaultsTo(_, _acty, _) -> true + // 'comparison' and 'equality' constraints can be present in the signature and not in the implementation because they are erased + | TyparConstraint.SupportsComparison _ -> true + | TyparConstraint.SupportsEquality _ -> true + | _ -> + if not (List.exists (fun implTyparCx -> typarConstraintsAEquiv g aenv implTyparCx sigTyparCx) implTypar.Constraints) then + (errorR(Error(FSComp.SR.typrelSigImplNotCompatibleConstraintsDifferRemove(sigTypar.Name, Layout.showL(NicePrint.layoutTyparConstraint denv (sigTypar, sigTyparCx))), m)); false) + else + true) && + (not checkingSig || checkAttribs aenv implTypar.Attribs sigTypar.Attribs (fun attribs -> implTypar.SetAttribs attribs))) + + and checkTypeDef (aenv: TypeEquivEnv) (implTycon: Tycon) (sigTycon: Tycon) = + let m = implTycon.Range + + // Propagate defn location information from implementation to signature . + sigTycon.SetOtherRange (implTycon.Range, true) + implTycon.SetOtherRange (sigTycon.Range, false) + + if implTycon.LogicalName <> sigTycon.LogicalName then + errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleNamesDiffer(implTycon.TypeOrMeasureKind.ToString(), sigTycon.LogicalName, implTycon.LogicalName), m)) + false + else + + if implTycon.CompiledName <> sigTycon.CompiledName then + errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleNamesDiffer(implTycon.TypeOrMeasureKind.ToString(), sigTycon.CompiledName, implTycon.CompiledName), m)) + false + else + + checkExnInfo (fun f -> ExnconstrNotContained(denv, implTycon, sigTycon, f)) aenv implTycon.ExceptionInfo sigTycon.ExceptionInfo && + + let implTypars = implTycon.Typars m + let sigTypars = sigTycon.Typars m + + if implTypars.Length <> sigTypars.Length then + errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleParameterCountsDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) + false + elif isLessAccessible implTycon.Accessibility sigTycon.Accessibility then + errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleAccessibilityDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) + false + else + let aenv = aenv.BindEquivTypars implTypars sigTypars + + let aintfs = implTycon.ImmediateInterfaceTypesOfFSharpTycon + let fintfs = sigTycon.ImmediateInterfaceTypesOfFSharpTycon + let aintfsUser = implTycon.TypeContents.tcaug_interfaces |> List.filter (fun (_, compgen, _) -> not compgen) |> List.map p13 + let flatten tys = + tys + |> List.collect (AllSuperTypesOfType g amap m AllowMultiIntfInstantiations.Yes) + |> ListSet.setify (typeEquiv g) + |> List.filter (isInterfaceTy g) + let aintfs = flatten aintfs + let fintfs = flatten fintfs + + let unimpl = ListSet.subtract (fun fity aity -> typeAEquiv g aenv aity fity) fintfs aintfs + (unimpl + |> List.forall (fun ity -> + let errorMessage = FSComp.SR.DefinitionsInSigAndImplNotCompatibleMissingInterface(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, NicePrint.minimalStringOfType denv ity) + errorR (Error(errorMessage, m)); false)) && + + let aintfsUser = flatten aintfsUser + + let hidden = ListSet.subtract (typeAEquiv g aenv) aintfsUser fintfs + let continueChecks, warningOrError = if implTycon.IsFSharpInterfaceTycon then false, errorR else true, warning + (hidden |> List.forall (fun ity -> warningOrError (InterfaceNotRevealed(denv, ity, implTycon.Range)); continueChecks)) && + + let aNull = IsUnionTypeWithNullAsTrueValue g implTycon + let fNull = IsUnionTypeWithNullAsTrueValue g sigTycon + if aNull && not fNull then + errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplementationSaysNull(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) + false + elif fNull && not aNull then + errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleSignatureSaysNull(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) + false + else + + let aNull2 = TypeNullIsExtraValue g m (generalizedTyconRef (mkLocalTyconRef implTycon)) + let fNull2 = TypeNullIsExtraValue g m (generalizedTyconRef (mkLocalTyconRef implTycon)) + if aNull2 && not fNull2 then + errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplementationSaysNull2(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) + false + elif fNull2 && not aNull2 then + errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleSignatureSaysNull2(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) + false + else + + let aSealed = isSealedTy g (generalizedTyconRef (mkLocalTyconRef implTycon)) + let fSealed = isSealedTy g (generalizedTyconRef (mkLocalTyconRef sigTycon)) + if aSealed && not fSealed then + errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplementationSealed(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) + false + elif not aSealed && fSealed then + errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplementationIsNotSealed(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) + false + else + + let aPartial = isAbstractTycon implTycon + let fPartial = isAbstractTycon sigTycon + if aPartial && not fPartial then + errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplementationIsAbstract(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) + false + elif not aPartial && fPartial then + errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleSignatureIsAbstract(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) + false + elif not (typeAEquiv g aenv (superOfTycon g implTycon) (superOfTycon g sigTycon)) then + errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleTypesHaveDifferentBaseTypes(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) + false + else + + checkTypars m aenv implTypars sigTypars && + checkTypeRepr m aenv implTycon sigTycon.TypeReprInfo && + checkTypeAbbrev m aenv implTycon sigTycon && + checkAttribs aenv implTycon.Attribs sigTycon.Attribs (fun attribs -> implTycon.entity_attribs <- attribs) && + checkModuleOrNamespaceContents implTycon.Range aenv (mkLocalEntityRef implTycon) sigTycon.ModuleOrNamespaceType + + and checkValInfo aenv err (implVal : Val) (sigVal : Val) = + let id = implVal.Id + match implVal.ValReprInfo, sigVal.ValReprInfo with + | _, None -> true + | None, Some _ -> err(FSComp.SR.ValueNotContainedMutabilityArityNotInferred) + | Some (ValReprInfo (implTyparNames, implArgInfos, implRetInfo) as implValInfo), Some (ValReprInfo (sigTyparNames, sigArgInfos, sigRetInfo) as sigValInfo) -> + let ntps = implTyparNames.Length + let mtps = sigTyparNames.Length + let nSigArgInfos = sigArgInfos.Length + if ntps <> mtps then + err(fun(x, y, z) -> FSComp.SR.ValueNotContainedMutabilityGenericParametersDiffer(x, y, z, string mtps, string ntps)) + elif implValInfo.KindsOfTypars <> sigValInfo.KindsOfTypars then + err(FSComp.SR.ValueNotContainedMutabilityGenericParametersAreDifferentKinds) + elif not (nSigArgInfos <= implArgInfos.Length && List.forall2 (fun x y -> List.length x <= List.length y) sigArgInfos (fst (List.splitAt nSigArgInfos implArgInfos))) then + err(fun(x, y, z) -> FSComp.SR.ValueNotContainedMutabilityAritiesDiffer(x, y, z, id.idText, string nSigArgInfos, id.idText, id.idText)) + else + let implArgInfos = implArgInfos |> List.truncate nSigArgInfos + let implArgInfos = (implArgInfos, sigArgInfos) ||> List.map2 (fun l1 l2 -> l1 |> List.take l2.Length) + // Propagate some information signature to implementation. + + // Check the attributes on each argument, and update the ValReprInfo for + // the value to reflect the information in the signature. + // This ensures that the compiled form of the value matches the signature rather than + // the implementation. This also propagates argument names from signature to implementation + let res = + (implArgInfos, sigArgInfos) ||> List.forall2 (List.forall2 (fun implArgInfo sigArgInfo -> + checkAttribs aenv implArgInfo.Attribs sigArgInfo.Attribs (fun attribs -> + match implArgInfo.Name, sigArgInfo.Name with + | Some iname, Some sname when sname.idText <> iname.idText -> + warning(Error (FSComp.SR.ArgumentsInSigAndImplMismatch(sname.idText, iname.idText), iname.idRange)) + | _ -> () + + implArgInfo.Name <- sigArgInfo.Name + implArgInfo.Attribs <- attribs))) && + + checkAttribs aenv implRetInfo.Attribs sigRetInfo.Attribs (fun attribs -> + implRetInfo.Name <- sigRetInfo.Name + implRetInfo.Attribs <- attribs) + + implVal.SetValReprInfo (Some (ValReprInfo (sigTyparNames, implArgInfos, implRetInfo))) + res + + and checkVal implModRef (aenv: TypeEquivEnv) (implVal: Val) (sigVal: Val) = + + // Propagate defn location information from implementation to signature . + sigVal.SetOtherRange (implVal.Range, true) + implVal.SetOtherRange (sigVal.Range, false) + + let mk_err denv f = ValueNotContained(denv, implModRef, implVal, sigVal, f) + let err denv f = errorR(mk_err denv f); false + let m = implVal.Range + if implVal.IsMutable <> sigVal.IsMutable then (err denv FSComp.SR.ValueNotContainedMutabilityAttributesDiffer) + elif implVal.LogicalName <> sigVal.LogicalName then (err denv FSComp.SR.ValueNotContainedMutabilityNamesDiffer) + elif (implVal.CompiledName g.CompilerGlobalState) <> (sigVal.CompiledName g.CompilerGlobalState) then (err denv FSComp.SR.ValueNotContainedMutabilityCompiledNamesDiffer) + elif implVal.DisplayName <> sigVal.DisplayName then (err denv FSComp.SR.ValueNotContainedMutabilityDisplayNamesDiffer) + elif isLessAccessible implVal.Accessibility sigVal.Accessibility then (err denv FSComp.SR.ValueNotContainedMutabilityAccessibilityMore) + elif implVal.MustInline <> sigVal.MustInline then (err denv FSComp.SR.ValueNotContainedMutabilityInlineFlagsDiffer) + elif implVal.LiteralValue <> sigVal.LiteralValue then (err denv FSComp.SR.ValueNotContainedMutabilityLiteralConstantValuesDiffer) + elif implVal.IsTypeFunction <> sigVal.IsTypeFunction then (err denv FSComp.SR.ValueNotContainedMutabilityOneIsTypeFunction) + else + let implTypars, atau = implVal.TypeScheme + let sigTypars, ftau = sigVal.TypeScheme + if implTypars.Length <> sigTypars.Length then (err {denv with showTyparBinding=true} FSComp.SR.ValueNotContainedMutabilityParameterCountsDiffer) else + let aenv = aenv.BindEquivTypars implTypars sigTypars + checkTypars m aenv implTypars sigTypars && + if not (typeAEquiv g aenv atau ftau) then err denv (FSComp.SR.ValueNotContainedMutabilityTypesDiffer) + elif not (checkValInfo aenv (err denv) implVal sigVal) then false + elif not (implVal.IsExtensionMember = sigVal.IsExtensionMember) then err denv (FSComp.SR.ValueNotContainedMutabilityExtensionsDiffer) + elif not (checkMemberDatasConform (err denv) (implVal.Attribs, implVal, implVal.MemberInfo) (sigVal.Attribs, sigVal, sigVal.MemberInfo)) then false + else checkAttribs aenv implVal.Attribs sigVal.Attribs (fun attribs -> implVal.SetAttribs attribs) + + + and checkExnInfo err aenv implTypeRepr sigTypeRepr = + match implTypeRepr, sigTypeRepr with + | TExnAsmRepr _, TExnFresh _ -> + (errorR (err FSComp.SR.ExceptionDefsNotCompatibleHiddenBySignature); false) + | TExnAsmRepr tcr1, TExnAsmRepr tcr2 -> + if tcr1 <> tcr2 then (errorR (err FSComp.SR.ExceptionDefsNotCompatibleDotNetRepresentationsDiffer); false) else true + | TExnAbbrevRepr _, TExnFresh _ -> + (errorR (err FSComp.SR.ExceptionDefsNotCompatibleAbbreviationHiddenBySignature); false) + | TExnAbbrevRepr ecr1, TExnAbbrevRepr ecr2 -> + if not (tcrefAEquiv g aenv ecr1 ecr2) then + (errorR (err FSComp.SR.ExceptionDefsNotCompatibleSignaturesDiffer); false) + else true + | TExnFresh r1, TExnFresh r2-> checkRecordFieldsForExn g denv err aenv r1 r2 + | TExnNone, TExnNone -> true + | _ -> + (errorR (err FSComp.SR.ExceptionDefsNotCompatibleExceptionDeclarationsDiffer); false) + + and checkUnionCase aenv implUnionCase sigUnionCase = + let err f = errorR(ConstrNotContained(denv, implUnionCase, sigUnionCase, f));false + sigUnionCase.OtherRangeOpt <- Some (implUnionCase.Range, true) + implUnionCase.OtherRangeOpt <- Some (sigUnionCase.Range, false) + if implUnionCase.Id.idText <> sigUnionCase.Id.idText then err FSComp.SR.ModuleContainsConstructorButNamesDiffer + elif implUnionCase.RecdFieldsArray.Length <> sigUnionCase.RecdFieldsArray.Length then err FSComp.SR.ModuleContainsConstructorButDataFieldsDiffer + elif not (Array.forall2 (checkField aenv) implUnionCase.RecdFieldsArray sigUnionCase.RecdFieldsArray) then err FSComp.SR.ModuleContainsConstructorButTypesOfFieldsDiffer + elif isLessAccessible implUnionCase.Accessibility sigUnionCase.Accessibility then err FSComp.SR.ModuleContainsConstructorButAccessibilityDiffers + else checkAttribs aenv implUnionCase.Attribs sigUnionCase.Attribs (fun attribs -> implUnionCase.Attribs <- attribs) + + and checkField aenv implField sigField = + let err f = errorR(FieldNotContained(denv, implField, sigField, f)); false + sigField.rfield_other_range <- Some (implField.Range, true) + implField.rfield_other_range <- Some (sigField.Range, false) + if implField.rfield_id.idText <> sigField.rfield_id.idText then err FSComp.SR.FieldNotContainedNamesDiffer + elif isLessAccessible implField.Accessibility sigField.Accessibility then err FSComp.SR.FieldNotContainedAccessibilitiesDiffer + elif implField.IsStatic <> sigField.IsStatic then err FSComp.SR.FieldNotContainedStaticsDiffer + elif implField.IsMutable <> sigField.IsMutable then err FSComp.SR.FieldNotContainedMutablesDiffer + elif implField.LiteralValue <> sigField.LiteralValue then err FSComp.SR.FieldNotContainedLiteralsDiffer + elif not (typeAEquiv g aenv implField.FormalType sigField.FormalType) then err FSComp.SR.FieldNotContainedTypesDiffer + else + checkAttribs aenv implField.FieldAttribs sigField.FieldAttribs (fun attribs -> implField.rfield_fattribs <- attribs) && + checkAttribs aenv implField.PropertyAttribs sigField.PropertyAttribs (fun attribs -> implField.rfield_pattribs <- attribs) + + and checkMemberDatasConform err (_implAttrs, implVal, implMemberInfo) (_sigAttrs, sigVal, sigMemberInfo) = + match implMemberInfo, sigMemberInfo with + | None, None -> true + | Some implMembInfo, Some sigMembInfo -> + if not ((implVal.CompiledName g.CompilerGlobalState) = (sigVal.CompiledName g.CompilerGlobalState)) then + err(FSComp.SR.ValueNotContainedMutabilityDotNetNamesDiffer) + elif not (implMembInfo.MemberFlags.IsInstance = sigMembInfo.MemberFlags.IsInstance) then + err(FSComp.SR.ValueNotContainedMutabilityStaticsDiffer) + elif false then + err(FSComp.SR.ValueNotContainedMutabilityVirtualsDiffer) + elif not (implMembInfo.MemberFlags.IsDispatchSlot = sigMembInfo.MemberFlags.IsDispatchSlot) then + err(FSComp.SR.ValueNotContainedMutabilityAbstractsDiffer) + // The final check is an implication: + // classes have non-final CompareTo/Hash methods + // abstract have non-final CompareTo/Hash methods + // records have final CompareTo/Hash methods + // unions have final CompareTo/Hash methods + // This is an example where it is OK for the signature to say 'non-final' when the implementation says 'final' + elif not implMembInfo.MemberFlags.IsFinal && sigMembInfo.MemberFlags.IsFinal then + err(FSComp.SR.ValueNotContainedMutabilityFinalsDiffer) + elif not (implMembInfo.MemberFlags.IsOverrideOrExplicitImpl = sigMembInfo.MemberFlags.IsOverrideOrExplicitImpl) then + err(FSComp.SR.ValueNotContainedMutabilityOverridesDiffer) + elif not (implMembInfo.MemberFlags.MemberKind = sigMembInfo.MemberFlags.MemberKind) then + err(FSComp.SR.ValueNotContainedMutabilityOneIsConstructor) + else + let finstance = ValSpecIsCompiledAsInstance g sigVal + let ainstance = ValSpecIsCompiledAsInstance g implVal + if finstance && not ainstance then + err(FSComp.SR.ValueNotContainedMutabilityStaticButInstance) + elif not finstance && ainstance then + err(FSComp.SR.ValueNotContainedMutabilityInstanceButStatic) + else true + + | _ -> false + + and checkRecordFields m aenv (implTycon: Tycon) (implFields: TyconRecdFields) (sigFields: TyconRecdFields) = + let implFields = implFields.TrueFieldsAsList + let sigFields = sigFields.TrueFieldsAsList + let m1 = implFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) + let m2 = sigFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) + NameMap.suball2 + (fun fieldName _ -> errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleFieldRequiredButNotSpecified(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, fieldName), m)); false) + (checkField aenv) m1 m2 && + NameMap.suball2 + (fun fieldName _ -> errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleFieldWasPresent(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, fieldName), m)); false) + (fun x y -> checkField aenv y x) m2 m1 && + + // This check is required because constructors etc. are externally visible + // and thus compiled representations do pick up dependencies on the field order + (if List.forall2 (checkField aenv) implFields sigFields + then true + else (errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleFieldOrderDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false)) + + and checkRecordFieldsForExn _g _denv err aenv (implFields: TyconRecdFields) (sigFields: TyconRecdFields) = + let implFields = implFields.TrueFieldsAsList + let sigFields = sigFields.TrueFieldsAsList + let m1 = implFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) + let m2 = sigFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) + NameMap.suball2 (fun s _ -> errorR(err (fun (x, y) -> FSComp.SR.ExceptionDefsNotCompatibleFieldInSigButNotImpl(s, x, y))); false) (checkField aenv) m1 m2 && + NameMap.suball2 (fun s _ -> errorR(err (fun (x, y) -> FSComp.SR.ExceptionDefsNotCompatibleFieldInImplButNotSig(s, x, y))); false) (fun x y -> checkField aenv y x) m2 m1 && + // This check is required because constructors etc. are externally visible + // and thus compiled representations do pick up dependencies on the field order + (if List.forall2 (checkField aenv) implFields sigFields + then true + else (errorR(err (FSComp.SR.ExceptionDefsNotCompatibleFieldOrderDiffers)); false)) + + and checkVirtualSlots denv m (implTycon: Tycon) implAbstractSlots sigAbstractSlots = + let m1 = NameMap.ofKeyedList (fun (v: ValRef) -> v.DisplayName) implAbstractSlots + let m2 = NameMap.ofKeyedList (fun (v: ValRef) -> v.DisplayName) sigAbstractSlots + (m1, m2) ||> NameMap.suball2 (fun _s vref -> + let kindText = implTycon.TypeOrMeasureKind.ToString() + let valText = NicePrint.stringValOrMember denv vref.Deref + errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleAbstractMemberMissingInImpl(kindText, implTycon.DisplayName, valText), m)); false) (fun _x _y -> true) && + + (m2, m1) ||> NameMap.suball2 (fun _s vref -> + let kindText = implTycon.TypeOrMeasureKind.ToString() + let valText = NicePrint.stringValOrMember denv vref.Deref + errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleAbstractMemberMissingInSig(kindText, implTycon.DisplayName, valText), m)); false) (fun _x _y -> true) + + and checkClassFields isStruct m aenv (implTycon: Tycon) (implFields: TyconRecdFields) (sigFields: TyconRecdFields) = + let implFields = implFields.TrueFieldsAsList + let sigFields = sigFields.TrueFieldsAsList + let m1 = implFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) + let m2 = sigFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) + NameMap.suball2 + (fun fieldName _ -> errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleFieldRequiredButNotSpecified(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, fieldName), m)); false) + (checkField aenv) m1 m2 && + (if isStruct then + NameMap.suball2 + (fun fieldName _ -> warning(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleFieldIsInImplButNotSig(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, fieldName), m)); true) + (fun x y -> checkField aenv y x) m2 m1 + else + true) + + + and checkTypeRepr m aenv (implTycon: Tycon) sigTypeRepr = + let reportNiceError k s1 s2 = + let aset = NameSet.ofList s1 + let fset = NameSet.ofList s2 + match Zset.elements (Zset.diff aset fset) with + | [] -> + match Zset.elements (Zset.diff fset aset) with + | [] -> (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleNumbersDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, k), m)); false) + | l -> (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleSignatureDefinesButImplDoesNot(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, k, String.concat ";" l), m)); false) + | l -> (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplDefinesButSignatureDoesNot(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, k, String.concat ";" l), m)); false) + + match implTycon.TypeReprInfo, sigTypeRepr with + | (TRecdRepr _ + | TUnionRepr _ + | TILObjectRepr _ +#if !NO_EXTENSIONTYPING + | TProvidedTypeExtensionPoint _ + | TProvidedNamespaceExtensionPoint _ +#endif + ), TNoRepr -> true + | (TFSharpObjectRepr r), TNoRepr -> + match r.fsobjmodel_kind with + | TTyconStruct | TTyconEnum -> + (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplDefinesStruct(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) + | _ -> + true + | (TAsmRepr _), TNoRepr -> + (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleDotNetTypeRepresentationIsHidden(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) + | (TMeasureableRepr _), TNoRepr -> + (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleTypeIsHidden(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) + | (TUnionRepr r1), (TUnionRepr r2) -> + let ucases1 = r1.UnionCasesAsList + let ucases2 = r2.UnionCasesAsList + if ucases1.Length <> ucases2.Length then + let names (l: UnionCase list) = l |> List.map (fun c -> c.Id.idText) + reportNiceError "union case" (names ucases1) (names ucases2) + else List.forall2 (checkUnionCase aenv) ucases1 ucases2 + | (TRecdRepr implFields), (TRecdRepr sigFields) -> + checkRecordFields m aenv implTycon implFields sigFields + | (TFSharpObjectRepr r1), (TFSharpObjectRepr r2) -> + if not (match r1.fsobjmodel_kind, r2.fsobjmodel_kind with + | TTyconClass, TTyconClass -> true + | TTyconInterface, TTyconInterface -> true + | TTyconStruct, TTyconStruct -> true + | TTyconEnum, TTyconEnum -> true + | TTyconDelegate (TSlotSig(_, typ1, ctps1, mtps1, ps1, rty1)), + TTyconDelegate (TSlotSig(_, typ2, ctps2, mtps2, ps2, rty2)) -> + (typeAEquiv g aenv typ1 typ2) && + (ctps1.Length = ctps2.Length) && + (let aenv = aenv.BindEquivTypars ctps1 ctps2 + (typarsAEquiv g aenv ctps1 ctps2) && + (mtps1.Length = mtps2.Length) && + (let aenv = aenv.BindEquivTypars mtps1 mtps2 + (typarsAEquiv g aenv mtps1 mtps2) && + ((ps1, ps2) ||> List.lengthsEqAndForall2 (List.lengthsEqAndForall2 (fun p1 p2 -> typeAEquiv g aenv p1.Type p2.Type))) && + (returnTypesAEquiv g aenv rty1 rty2))) + | _, _ -> false) then + (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleTypeIsDifferentKind(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) + else + let isStruct = (match r1.fsobjmodel_kind with TTyconStruct -> true | _ -> false) + checkClassFields isStruct m aenv implTycon r1.fsobjmodel_rfields r2.fsobjmodel_rfields && + checkVirtualSlots denv m implTycon r1.fsobjmodel_vslots r2.fsobjmodel_vslots + | (TAsmRepr tcr1), (TAsmRepr tcr2) -> + if tcr1 <> tcr2 then (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleILDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) else true + | (TMeasureableRepr ty1), (TMeasureableRepr ty2) -> + if typeAEquiv g aenv ty1 ty2 then true else (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleRepresentationsDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) + | TNoRepr, TNoRepr -> true +#if !NO_EXTENSIONTYPING + | TProvidedTypeExtensionPoint info1, TProvidedTypeExtensionPoint info2 -> + Tainted.EqTainted info1.ProvidedType.TypeProvider info2.ProvidedType.TypeProvider && ProvidedType.TaintedEquals(info1.ProvidedType, info2.ProvidedType) + | TProvidedNamespaceExtensionPoint _, TProvidedNamespaceExtensionPoint _ -> + System.Diagnostics.Debug.Assert(false, "unreachable: TProvidedNamespaceExtensionPoint only on namespaces, not types" ) + true +#endif + | TNoRepr, _ -> (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleRepresentationsDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) + | _, _ -> (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleRepresentationsDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) + + and checkTypeAbbrev m aenv (implTycon: Tycon) (sigTycon: Tycon) = + let kind1 = implTycon.TypeOrMeasureKind + let kind2 = sigTycon.TypeOrMeasureKind + if kind1 <> kind2 then (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleSignatureDeclaresDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, kind2.ToString(), kind1.ToString()), m)); false) + else + match implTycon.TypeAbbrev, sigTycon.TypeAbbrev with + | Some ty1, Some ty2 -> + if not (typeAEquiv g aenv ty1 ty2) then + let s1, s2, _ = NicePrint.minimalStringsOfTwoTypes denv ty1 ty2 + errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleAbbreviationsDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, s1, s2), m)) + false + else + true + | None, None -> true + | Some _, None -> (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleAbbreviationHiddenBySig(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) + | None, Some _ -> (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleSigHasAbbreviation(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) + + and checkModuleOrNamespaceContents m aenv (implModRef: ModuleOrNamespaceRef) (signModType: ModuleOrNamespaceType) = + let implModType = implModRef.ModuleOrNamespaceType + (if implModType.ModuleOrNamespaceKind <> signModType.ModuleOrNamespaceKind then errorR(Error(FSComp.SR.typrelModuleNamespaceAttributesDifferInSigAndImpl(), m))) + + + (implModType.TypesByMangledName, signModType.TypesByMangledName) + ||> NameMap.suball2 + (fun s _fx -> errorR(RequiredButNotSpecified(denv, implModRef, "type", (fun os -> Printf.bprintf os "%s" s), m)); false) + (checkTypeDef aenv) && + + + (implModType.ModulesAndNamespacesByDemangledName, signModType.ModulesAndNamespacesByDemangledName ) + ||> NameMap.suball2 + (fun s fx -> errorR(RequiredButNotSpecified(denv, implModRef, (if fx.IsModule then "module" else "namespace"), (fun os -> Printf.bprintf os "%s" s), m)); false) + (fun x1 x2 -> checkModuleOrNamespace aenv (mkLocalModRef x1) x2) && + + let sigValHadNoMatchingImplementation (fx: Val) (_closeActualVal: Val option) = + errorR(RequiredButNotSpecified(denv, implModRef, "value", (fun os -> + (* In the case of missing members show the full required enclosing type and signature *) + if fx.IsMember then + NicePrint.outputQualifiedValOrMember denv os fx + else + Printf.bprintf os "%s" fx.DisplayName), m)) + + let valuesPartiallyMatch (av: Val) (fv: Val) = + let akey = av.GetLinkagePartialKey() + let fkey = fv.GetLinkagePartialKey() + (akey.MemberParentMangledName = fkey.MemberParentMangledName) && + (akey.LogicalName = fkey.LogicalName) && + (akey.TotalArgCount = fkey.TotalArgCount) + + (implModType.AllValsAndMembersByLogicalNameUncached, signModType.AllValsAndMembersByLogicalNameUncached) + ||> NameMap.suball2 + (fun _s (fxs: Val list) -> sigValHadNoMatchingImplementation fxs.Head None; false) + (fun avs fvs -> + match avs, fvs with + | [], _ | _, [] -> failwith "unreachable" + | [av], [fv] -> + if valuesPartiallyMatch av fv then + checkVal implModRef aenv av fv + else + sigValHadNoMatchingImplementation fv None + false + | _ -> + // for each formal requirement, try to find a precisely matching actual requirement + let matchingPairs = + fvs |> List.choose (fun fv -> + match avs |> List.tryFind (fun av -> valLinkageAEquiv g aenv av fv) with + | None -> None + | Some av -> Some(fv, av)) + + // Check the ones with matching linkage + let allPairsOk = matchingPairs |> List.map (fun (fv, av) -> checkVal implModRef aenv av fv) |> List.forall id + let someNotOk = matchingPairs.Length < fvs.Length + // Report an error for those that don't. Try pairing up by enclosing-type/name + if someNotOk then + let noMatches, partialMatchingPairs = + fvs |> List.splitChoose (fun fv -> + match avs |> List.tryFind (fun av -> valuesPartiallyMatch av fv) with + | None -> Choice1Of2 fv + | Some av -> Choice2Of2(fv, av)) + for (fv, av) in partialMatchingPairs do + checkVal implModRef aenv av fv |> ignore + for fv in noMatches do + sigValHadNoMatchingImplementation fv None + allPairsOk && not someNotOk) + + + and checkModuleOrNamespace aenv implModRef sigModRef = + // Propagate defn location information from implementation to signature . + sigModRef.SetOtherRange (implModRef.Range, true) + implModRef.Deref.SetOtherRange (sigModRef.Range, false) + checkModuleOrNamespaceContents implModRef.Range aenv implModRef sigModRef.ModuleOrNamespaceType && + checkAttribs aenv implModRef.Attribs sigModRef.Attribs implModRef.Deref.SetAttribs + + member __.CheckSignature aenv (implModRef: ModuleOrNamespaceRef) (signModType: ModuleOrNamespaceType) = + checkModuleOrNamespaceContents implModRef.Range aenv implModRef signModType + + member __.CheckTypars m aenv (implTypars: Typars) (signTypars: Typars) = + checkTypars m aenv implTypars signTypars + + +/// Check the names add up between a signature and its implementation. We check this first. +let rec CheckNamesOfModuleOrNamespaceContents denv (implModRef: ModuleOrNamespaceRef) (signModType: ModuleOrNamespaceType) = + let m = implModRef.Range + let implModType = implModRef.ModuleOrNamespaceType + NameMap.suball2 + (fun s _fx -> errorR(RequiredButNotSpecified(denv, implModRef, "type", (fun os -> Printf.bprintf os "%s" s), m)); false) + (fun _ _ -> true) + implModType.TypesByMangledName + signModType.TypesByMangledName && + + (implModType.ModulesAndNamespacesByDemangledName, signModType.ModulesAndNamespacesByDemangledName ) + ||> NameMap.suball2 + (fun s fx -> errorR(RequiredButNotSpecified(denv, implModRef, (if fx.IsModule then "module" else "namespace"), (fun os -> Printf.bprintf os "%s" s), m)); false) + (fun x1 (x2: ModuleOrNamespace) -> CheckNamesOfModuleOrNamespace denv (mkLocalModRef x1) x2.ModuleOrNamespaceType) && + + (implModType.AllValsAndMembersByLogicalNameUncached, signModType.AllValsAndMembersByLogicalNameUncached) + ||> NameMap.suball2 + (fun _s (fxs: Val list) -> + let fx = fxs.Head + errorR(RequiredButNotSpecified(denv, implModRef, "value", (fun os -> + // In the case of missing members show the full required enclosing type and signature + if Option.isSome fx.MemberInfo then + NicePrint.outputQualifiedValOrMember denv os fx + else + Printf.bprintf os "%s" fx.DisplayName), m)); false) + (fun _ _ -> true) + + +and CheckNamesOfModuleOrNamespace denv (implModRef: ModuleOrNamespaceRef) signModType = + CheckNamesOfModuleOrNamespaceContents denv implModRef signModType + diff --git a/src/fsharp/SimulatedMSBuildReferenceResolver.fs b/src/fsharp/SimulatedMSBuildReferenceResolver.fs index 76d117db359..5d80c658d0d 100644 --- a/src/fsharp/SimulatedMSBuildReferenceResolver.fs +++ b/src/fsharp/SimulatedMSBuildReferenceResolver.fs @@ -1,10 +1,6 @@ // Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. -#if INTERACTIVE -#load "../utils/ResizeArray.fs" "absil/illib.fs" "../fsharp/ReferenceResolver.fs" -#else module internal FSharp.Compiler.SimulatedMSBuildReferenceResolver -#endif open System open System.IO diff --git a/src/fsharp/SimulatedMSBuildReferenceResolver.fsi b/src/fsharp/SimulatedMSBuildReferenceResolver.fsi new file mode 100644 index 00000000000..e96efa0849a --- /dev/null +++ b/src/fsharp/SimulatedMSBuildReferenceResolver.fsi @@ -0,0 +1,8 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module internal FSharp.Compiler.SimulatedMSBuildReferenceResolver + +open FSharp.Compiler.ReferenceResolver + +val getResolver: unit -> Resolver + diff --git a/src/fsharp/SyntaxTreeOps.fsi b/src/fsharp/SyntaxTreeOps.fsi new file mode 100644 index 00000000000..1bf34b2d936 --- /dev/null +++ b/src/fsharp/SyntaxTreeOps.fsi @@ -0,0 +1,265 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module public FSharp.Compiler.SyntaxTreeOps + + +open FSharp.Compiler +open FSharp.Compiler.Range +open FSharp.Compiler.SyntaxTree + +[] +type SynArgNameGenerator = + new: unit -> SynArgNameGenerator + member New: unit -> string + member Reset: unit -> unit + +val ident: s:string * r:range -> Ident + +val textOfId: id:Ident -> string + +val pathOfLid: lid:Ident list -> string list + +val arrPathOfLid: lid:Ident list -> string [] + +val textOfPath: path:seq -> string + +val textOfLid: lid:Ident list -> string + +val rangeOfLid: lid:Ident list -> range + +val mkSynId: m:range -> s:string -> Ident + +val pathToSynLid: m:range -> p:string list -> Ident list + +val mkSynIdGet: m:range -> n:string -> SynExpr + +val mkSynLidGet: m:range -> path:string list -> n:string -> SynExpr + +val mkSynIdGetWithAlt: m:range -> id:Ident -> altInfo:SynSimplePatAlternativeIdInfo ref option -> SynExpr + +val mkSynSimplePatVar: isOpt:bool -> id:Ident -> SynSimplePat + +val mkSynCompGenSimplePatVar: id:Ident -> SynSimplePat + +/// Match a long identifier, including the case for single identifiers which gets a more optimized node in the syntax tree. +val (|LongOrSingleIdent|_|): inp:SynExpr -> (bool * LongIdentWithDots * SynSimplePatAlternativeIdInfo ref option * range) option + +val (|SingleIdent|_|): inp:SynExpr -> Ident option + +/// This affects placement of sequence points +val IsControlFlowExpression: e:SynExpr -> bool + +val mkAnonField: ty:SynType -> SynField + +val mkNamedField: ident:Ident * ty:SynType * m:range -> SynField + +val mkSynPatVar: vis:SynAccess option -> id:Ident -> SynPat + +val mkSynThisPatVar: id:Ident -> SynPat + +val mkSynPatMaybeVar: lidwd:LongIdentWithDots -> vis:SynAccess option -> m:range -> SynPat + +val ( |SynPatForConstructorDecl|_| ): x:SynPat -> SynPat option + +/// Recognize the '()' in 'new()' +val (|SynPatForNullaryArgs|_|): x:SynPat -> unit option + +val ( |SynExprErrorSkip| ): p:SynExpr -> SynExpr + +val ( |SynExprParen|_| ): e:SynExpr -> (SynExpr * range * range option * range) option + +val ( |SynPatErrorSkip| ): p:SynPat -> SynPat + +/// Push non-simple parts of a patten match over onto the r.h.s. of a lambda. +/// Return a simple pattern and a function to build a match on the r.h.s. if the pattern is complex +val SimplePatOfPat: synArgNameGenerator:SynArgNameGenerator -> p:SynPat -> SynSimplePat * (SynExpr -> SynExpr) option + +val appFunOpt: funOpt:('a -> 'a) option -> x:'a -> 'a + +val composeFunOpt: funOpt1:('a -> 'a) option -> funOpt2:('a -> 'a) option -> ('a -> 'a) option + +val SimplePatsOfPat: synArgNameGenerator:SynArgNameGenerator -> p:SynPat -> SynSimplePats * (SynExpr -> SynExpr) option + +val PushPatternToExpr: synArgNameGenerator:SynArgNameGenerator -> isMember:bool -> pat:SynPat -> rhs:SynExpr -> SynSimplePats * SynExpr + +/// "fun (UnionCase x) (UnionCase y) -> body" +/// ==> +/// "fun tmp1 tmp2 -> +/// let (UnionCase x) = tmp1 in +/// let (UnionCase y) = tmp2 in +/// body" +val PushCurriedPatternsToExpr: synArgNameGenerator:SynArgNameGenerator -> wholem:range -> isMember:bool -> pats:SynPat list -> rhs:SynExpr -> SynSimplePats list * SynExpr + +val opNameParenGet: string + +val opNameQMark: string + +val mkSynOperator: opm:range -> oper:string -> SynExpr + +val mkSynInfix: opm:range -> l:SynExpr -> oper:string -> r:SynExpr -> SynExpr + +val mkSynBifix: m:range -> oper:string -> x1:SynExpr -> x2:SynExpr -> SynExpr + +val mkSynTrifix: m:range -> oper:string -> x1:SynExpr -> x2:SynExpr -> x3:SynExpr -> SynExpr + +val mkSynPrefixPrim: opm:range -> m:range -> oper:string -> x:SynExpr -> SynExpr + +val mkSynPrefix: opm:range -> m:range -> oper:string -> x:SynExpr -> SynExpr + +val mkSynCaseName: m:range -> n:string -> Ident list + +val mkSynApp1: f:SynExpr -> x1:SynExpr -> m:range -> SynExpr + +val mkSynApp2: f:SynExpr -> x1:SynExpr -> x2:SynExpr -> m:range -> SynExpr + +val mkSynApp3: f:SynExpr -> x1:SynExpr -> x2:SynExpr -> x3:SynExpr -> m:range -> SynExpr + +val mkSynApp4: f:SynExpr -> x1:SynExpr -> x2:SynExpr -> x3:SynExpr -> x4:SynExpr -> m:range -> SynExpr + +val mkSynApp5: f:SynExpr -> x1:SynExpr -> x2:SynExpr -> x3:SynExpr -> x4:SynExpr -> x5:SynExpr -> m:range -> SynExpr + +val mkSynDotParenSet: m:range -> a:SynExpr -> b:SynExpr -> c:SynExpr -> SynExpr + +val mkSynDotBrackGet: m:range -> mDot:range -> a:SynExpr -> b:SynExpr -> fromEnd:bool -> SynExpr + +val mkSynQMarkSet: m:range -> a:SynExpr -> b:SynExpr -> c:SynExpr -> SynExpr + +val mkSynDotBrackSliceGet: m:range -> mDot:range -> arr:SynExpr -> sliceArg:SynIndexerArg -> SynExpr + +val mkSynDotBrackSeqSliceGet: m:range -> mDot:range -> arr:SynExpr -> argsList:SynIndexerArg list -> SynExpr + +val mkSynDotParenGet: lhsm:range -> dotm:range -> a:SynExpr -> b:SynExpr -> SynExpr + +val mkSynUnit: m:range -> SynExpr + +val mkSynUnitPat: m:range -> SynPat + +val mkSynDelay: m:range -> e:SynExpr -> SynExpr + +val mkSynAssign: l:SynExpr -> r:SynExpr -> SynExpr + +val mkSynDot: dotm:range -> m:range -> l:SynExpr -> r:Ident -> SynExpr + +val mkSynDotMissing: dotm:range -> m:range -> l:SynExpr -> SynExpr + +val mkSynFunMatchLambdas: synArgNameGenerator:SynArgNameGenerator -> isMember:bool -> wholem:range -> ps:SynPat list -> e:SynExpr -> SynExpr + +val arbExpr: debugStr:string * range:range -> SynExpr + +val unionRangeWithListBy: projectRangeFromThing:('a -> range) -> m:range -> listOfThing:'a list -> range + +val mkAttributeList: attrs:SynAttribute list -> range:range -> SynAttributeList list + +val ConcatAttributesLists: attrsLists:SynAttributeList list -> SynAttribute list + +val ( |Attributes| ): synAttributes:SynAttributeList list -> SynAttribute list + +val rangeOfNonNilAttrs: attrs:SynAttributes -> range + +val stripParenTypes: synType:SynType -> SynType + +val ( |StripParenTypes| ): synType:SynType -> SynType + +/// Operations related to the syntactic analysis of arguments of value, function and member definitions and signatures. +module SynInfo = + /// The argument information for an argument without a name + val unnamedTopArg1: SynArgInfo + + /// The argument information for a curried argument without a name + val unnamedTopArg: SynArgInfo list + + /// The argument information for a '()' argument + val unitArgData: SynArgInfo list + + /// The 'argument' information for a return value where no attributes are given for the return value (the normal case) + val unnamedRetVal: SynArgInfo + + /// The 'argument' information for the 'this'/'self' parameter in the cases where it is not given explicitly + val selfMetadata: SynArgInfo list + + /// Determine if a syntactic information represents a member without arguments (which is implicitly a property getter) + val HasNoArgs: SynValInfo -> bool + + /// Check if one particular argument is an optional argument. Used when adjusting the + /// types of optional arguments for function and member signatures. + val IsOptionalArg: SynArgInfo -> bool + + /// Check if there are any optional arguments in the syntactic argument information. Used when adjusting the + /// types of optional arguments for function and member signatures. + val HasOptionalArgs: SynValInfo -> bool + + /// Add a parameter entry to the syntactic value information to represent the '()' argument to a property getter. This is + /// used for the implicit '()' argument in property getter signature specifications. + val IncorporateEmptyTupledArgForPropertyGetter: SynValInfo -> SynValInfo + + /// Add a parameter entry to the syntactic value information to represent the 'this' argument. This is + /// used for the implicit 'this' argument in member signature specifications. + val IncorporateSelfArg: SynValInfo -> SynValInfo + + /// Add a parameter entry to the syntactic value information to represent the value argument for a property setter. This is + /// used for the implicit value argument in property setter signature specifications. + val IncorporateSetterArg: SynValInfo -> SynValInfo + + /// Get the argument counts for each curried argument group. Used in some adhoc places in tc.fs. + val AritiesOfArgs: SynValInfo -> int list + + /// Get the argument attributes from the syntactic information for an argument. + val AttribsOfArgData: SynArgInfo -> SynAttribute list + + /// Infer the syntactic argument info for a single argument from a simple pattern. + val InferSynArgInfoFromSimplePat: attribs:SynAttributes -> p:SynSimplePat -> SynArgInfo + + /// Infer the syntactic argument info for one or more arguments one or more simple patterns. + val InferSynArgInfoFromSimplePats: x:SynSimplePats -> SynArgInfo list + + /// Infer the syntactic argument info for one or more arguments a pattern. + val InferSynArgInfoFromPat: p:SynPat -> SynArgInfo list + + /// Make sure only a solitary unit argument has unit elimination + val AdjustArgsForUnitElimination: infosForArgs:SynArgInfo list list -> SynArgInfo list list + + /// Transform a property declared using '[static] member P = expr' to a method taking a "unit" argument. + /// This is similar to IncorporateEmptyTupledArgForPropertyGetter, but applies to member definitions + /// rather than member signatures. + val AdjustMemberArgs: memFlags:MemberKind -> infosForArgs:'a list list -> 'a list list + + /// For 'let' definitions, we infer syntactic argument information from the r.h.s. of a definition, if it + /// is an immediate 'fun ... -> ...' or 'function ...' expression. This is noted in the F# language specification. + /// This does not apply to member definitions. + val InferLambdaArgs: origRhsExpr:SynExpr -> SynArgInfo list list + + val InferSynReturnData: retInfo:SynReturnInfo option -> SynArgInfo + + val emptySynValData: SynValData + + /// Infer the syntactic information for a 'let' or 'member' definition, based on the argument pattern, + /// any declared return information (e.g. .NET attributes on the return element), and the r.h.s. expression + /// in the case of 'let' definitions. + val InferSynValData: memberFlagsOpt:MemberFlags option * pat:SynPat option * retInfo:SynReturnInfo option * origRhsExpr:SynExpr -> SynValData + +val mkSynBindingRhs: staticOptimizations:(SynStaticOptimizationConstraint list * SynExpr) list -> rhsExpr:SynExpr -> mRhs:range -> retInfo:SynReturnInfo option -> SynExpr * SynBindingReturnInfo option + +val mkSynBinding: + xmlDoc:XmlDoc.PreXmlDoc * headPat:SynPat -> + vis:SynAccess option * isInline:bool * isMutable:bool * mBind:range * + spBind:DebugPointForBinding * retInfo:SynReturnInfo option * origRhsExpr:SynExpr * mRhs:range * + staticOptimizations:(SynStaticOptimizationConstraint list * SynExpr) list * attrs:SynAttributes * memberFlagsOpt:MemberFlags option + -> SynBinding + +val NonVirtualMemberFlags: k:MemberKind -> MemberFlags + +val CtorMemberFlags: MemberFlags + +val ClassCtorMemberFlags: MemberFlags + +val OverrideMemberFlags: k:MemberKind -> MemberFlags + +val AbstractMemberFlags: k:MemberKind -> MemberFlags + +val StaticMemberFlags: k:MemberKind -> MemberFlags + +val inferredTyparDecls: SynValTyparDecls + +val noInferredTypars: SynValTyparDecls + +val synExprContainsError: inpExpr:SynExpr -> bool diff --git a/src/fsharp/TypeRelations.fsi b/src/fsharp/TypeRelations.fsi new file mode 100644 index 00000000000..28352bea88a --- /dev/null +++ b/src/fsharp/TypeRelations.fsi @@ -0,0 +1,291 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +/// Primary relations on types and signatures, with the exception of +/// constraint solving and method overload resolution. +module internal FSharp.Compiler.TypeRelations + +open FSharp.Compiler.AbstractIL.Internal +open FSharp.Compiler.AbstractIL.Internal.Library +open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeBasics +open FSharp.Compiler.TypedTreeOps +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.Infos + +/// Implements a :> b without coercion based on finalized (no type variable) types +// Note: This relation is approximate and not part of the language specification. +// +// Some appropriate uses: +// patcompile.fs: IsDiscrimSubsumedBy (approximate warning for redundancy of 'isinst' patterns) +// tc.fs: TcRuntimeTypeTest (approximate warning for redundant runtime type tests) +// tc.fs: TcExnDefnCore (error for bad exception abbreviation) +// ilxgen.fs: GenCoerce (omit unnecessary castclass or isinst instruction) +// +let rec TypeDefinitelySubsumesTypeNoCoercion ndeep g amap m ty1 ty2 = + if ndeep > 100 then error(InternalError("recursive class hierarchy (detected in TypeDefinitelySubsumesTypeNoCoercion), ty1 = " + (DebugPrint.showType ty1), m)) + if ty1 === ty2 then true + elif typeEquiv g ty1 ty2 then true + else + let ty1 = stripTyEqns g ty1 + let ty2 = stripTyEqns g ty2 + // F# reference types are subtypes of type 'obj' + (typeEquiv g ty1 g.obj_ty && isRefTy g ty2) || + // Follow the supertype chain + (isAppTy g ty2 && + isRefTy g ty2 && + + ((match GetSuperTypeOfType g amap m ty2 with + | None -> false + | Some ty -> TypeDefinitelySubsumesTypeNoCoercion (ndeep+1) g amap m ty1 ty) || + + // Follow the interface hierarchy + (isInterfaceTy g ty1 && + ty2 |> GetImmediateInterfacesOfType SkipUnrefInterfaces.Yes g amap m + |> List.exists (TypeDefinitelySubsumesTypeNoCoercion (ndeep+1) g amap m ty1)))) + +type CanCoerce = CanCoerce | NoCoerce + +/// The feasible equivalence relation. Part of the language spec. +let rec TypesFeasiblyEquivalent stripMeasures ndeep g amap m ty1 ty2 = + + if ndeep > 100 then error(InternalError("recursive class hierarchy (detected in TypeFeasiblySubsumesType), ty1 = " + (DebugPrint.showType ty1), m)); + let stripAll ty = + if stripMeasures then + ty |> stripTyEqnsWrtErasure EraseAll g |> stripMeasuresFromTType g + else + ty |> stripTyEqns g + + let ty1str = stripAll ty1 + let ty2str = stripAll ty2 + + match ty1str, ty2str with + | TType_var _, _ + | _, TType_var _ -> true + + | TType_app (tc1, l1), TType_app (tc2, l2) when tyconRefEq g tc1 tc2 -> + List.lengthsEqAndForall2 (TypesFeasiblyEquivalent stripMeasures ndeep g amap m) l1 l2 + + | TType_anon (anonInfo1, l1),TType_anon (anonInfo2, l2) -> + (evalTupInfoIsStruct anonInfo1.TupInfo = evalTupInfoIsStruct anonInfo2.TupInfo) && + (match anonInfo1.Assembly, anonInfo2.Assembly with ccu1, ccu2 -> ccuEq ccu1 ccu2) && + (anonInfo1.SortedNames = anonInfo2.SortedNames) && + List.lengthsEqAndForall2 (TypesFeasiblyEquivalent stripMeasures ndeep g amap m) l1 l2 + + | TType_tuple (tupInfo1, l1), TType_tuple (tupInfo2, l2) -> + evalTupInfoIsStruct tupInfo1 = evalTupInfoIsStruct tupInfo2 && + List.lengthsEqAndForall2 (TypesFeasiblyEquivalent stripMeasures ndeep g amap m) l1 l2 + + | TType_fun (d1, r1), TType_fun (d2, r2) -> + (TypesFeasiblyEquivalent stripMeasures ndeep g amap m) d1 d2 && (TypesFeasiblyEquivalent stripMeasures ndeep g amap m) r1 r2 + + | TType_measure _, TType_measure _ -> + true + + | _ -> + false + +/// The feasible equivalence relation. Part of the language spec. +let rec TypesFeasiblyEquiv ndeep g amap m ty1 ty2 = + TypesFeasiblyEquivalent false ndeep g amap m ty1 ty2 + +/// The feasible equivalence relation after stripping Measures. +let TypesFeasiblyEquivStripMeasures g amap m ty1 ty2 = + TypesFeasiblyEquivalent true 0 g amap m ty1 ty2 + +/// The feasible coercion relation. Part of the language spec. +let rec TypeFeasiblySubsumesType ndeep g amap m ty1 canCoerce ty2 = + if ndeep > 100 then error(InternalError("recursive class hierarchy (detected in TypeFeasiblySubsumesType), ty1 = " + (DebugPrint.showType ty1), m)) + let ty1 = stripTyEqns g ty1 + let ty2 = stripTyEqns g ty2 + match ty1, ty2 with + | TType_var _, _ | _, TType_var _ -> true + + | TType_app (tc1, l1), TType_app (tc2, l2) when tyconRefEq g tc1 tc2 -> + List.lengthsEqAndForall2 (TypesFeasiblyEquiv ndeep g amap m) l1 l2 + + | TType_tuple _, TType_tuple _ + | TType_anon _, TType_anon _ + | TType_fun _, TType_fun _ -> TypesFeasiblyEquiv ndeep g amap m ty1 ty2 + + | TType_measure _, TType_measure _ -> + true + + | _ -> + // F# reference types are subtypes of type 'obj' + (isObjTy g ty1 && (canCoerce = CanCoerce || isRefTy g ty2)) + || + (isAppTy g ty2 && + (canCoerce = CanCoerce || isRefTy g ty2) && + begin match GetSuperTypeOfType g amap m ty2 with + | None -> false + | Some ty -> TypeFeasiblySubsumesType (ndeep+1) g amap m ty1 NoCoerce ty + end || + ty2 |> GetImmediateInterfacesOfType SkipUnrefInterfaces.Yes g amap m + |> List.exists (TypeFeasiblySubsumesType (ndeep+1) g amap m ty1 NoCoerce)) + + +/// Choose solutions for Expr.TyChoose type "hidden" variables introduced +/// by letrec nodes. Also used by the pattern match compiler to choose type +/// variables when compiling patterns at generalized bindings. +/// e.g. let ([], x) = ([], []) +/// Here x gets a generalized type "list<'T>". +let ChooseTyparSolutionAndRange (g: TcGlobals) amap (tp:Typar) = + let m = tp.Range + let max, m = + let initial = + match tp.Kind with + | TyparKind.Type -> g.obj_ty + | TyparKind.Measure -> TType_measure Measure.One + // Loop through the constraints computing the lub + ((initial, m), tp.Constraints) ||> List.fold (fun (maxSoFar, _) tpc -> + let join m x = + if TypeFeasiblySubsumesType 0 g amap m x CanCoerce maxSoFar then maxSoFar + elif TypeFeasiblySubsumesType 0 g amap m maxSoFar CanCoerce x then x + else errorR(Error(FSComp.SR.typrelCannotResolveImplicitGenericInstantiation((DebugPrint.showType x), (DebugPrint.showType maxSoFar)), m)); maxSoFar + // Don't continue if an error occurred and we set the value eagerly + if tp.IsSolved then maxSoFar, m else + match tpc with + | TyparConstraint.CoercesTo(x, m) -> + join m x, m + | TyparConstraint.MayResolveMember(_traitInfo, m) -> + maxSoFar, m + | TyparConstraint.SimpleChoice(_, m) -> + errorR(Error(FSComp.SR.typrelCannotResolveAmbiguityInPrintf(), m)) + maxSoFar, m + | TyparConstraint.SupportsNull m -> + maxSoFar, m + | TyparConstraint.SupportsComparison m -> + join m g.mk_IComparable_ty, m + | TyparConstraint.SupportsEquality m -> + maxSoFar, m + | TyparConstraint.IsEnum(_, m) -> + errorR(Error(FSComp.SR.typrelCannotResolveAmbiguityInEnum(), m)) + maxSoFar, m + | TyparConstraint.IsDelegate(_, _, m) -> + errorR(Error(FSComp.SR.typrelCannotResolveAmbiguityInDelegate(), m)) + maxSoFar, m + | TyparConstraint.IsNonNullableStruct m -> + join m g.int_ty, m + | TyparConstraint.IsUnmanaged m -> + errorR(Error(FSComp.SR.typrelCannotResolveAmbiguityInUnmanaged(), m)) + maxSoFar, m + | TyparConstraint.RequiresDefaultConstructor m -> + maxSoFar, m + | TyparConstraint.IsReferenceType m -> + maxSoFar, m + | TyparConstraint.DefaultsTo(_priority, _ty, m) -> + maxSoFar, m) + max, m + +let ChooseTyparSolution g amap tp = + let ty, _m = ChooseTyparSolutionAndRange g amap tp + if tp.Rigidity = TyparRigidity.Anon && typeEquiv g ty (TType_measure Measure.One) then + warning(Error(FSComp.SR.csCodeLessGeneric(), tp.Range)) + ty + +// Solutions can, in theory, refer to each other +// For example +// 'a = Expr<'b> +// 'b = int +// In this case the solutions are +// 'a = Expr +// 'b = int +// We ground out the solutions by repeatedly instantiating +let IterativelySubstituteTyparSolutions g tps solutions = + let tpenv = mkTyparInst tps solutions + let rec loop n curr = + let curr' = curr |> instTypes tpenv + // We cut out at n > 40 just in case this loops. It shouldn't, since there should be no cycles in the + // solution equations, and we've only ever seen one example where even n = 2 was required. + // Perhaps it's possible in error recovery some strange situations could occur where cycles + // arise, so it's better to be on the safe side. + // + // We don't give an error if we hit the limit since it's feasible that the solutions of unknowns + // is not actually relevant to the rest of type checking or compilation. + if n > 40 || List.forall2 (typeEquiv g) curr curr' then + curr + else + loop (n+1) curr' + + loop 0 solutions + +let ChooseTyparSolutionsForFreeChoiceTypars g amap e = + match e with + | Expr.TyChoose (tps, e1, _m) -> + + /// Only make choices for variables that are actually used in the expression + let ftvs = (freeInExpr CollectTyparsNoCaching e1).FreeTyvars.FreeTypars + let tps = tps |> List.filter (Zset.memberOf ftvs) + + let solutions = tps |> List.map (ChooseTyparSolution g amap) |> IterativelySubstituteTyparSolutions g tps + + let tpenv = mkTyparInst tps solutions + + instExpr g tpenv e1 + + | _ -> e + + +/// Break apart lambdas. Needs ChooseTyparSolutionsForFreeChoiceTypars because it's used in +/// PostTypeCheckSemanticChecks before we've eliminated these nodes. +let tryDestTopLambda g amap (ValReprInfo (tpNames, _, _) as tvd) (e, ty) = + let rec stripLambdaUpto n (e, ty) = + match e with + | Expr.Lambda (_, None, None, v, b, _, retTy) when n > 0 -> + let (vs', b', retTy') = stripLambdaUpto (n-1) (b, retTy) + (v :: vs', b', retTy') + | _ -> + ([], e, ty) + + let rec startStripLambdaUpto n (e, ty) = + match e with + | Expr.Lambda (_, ctorThisValOpt, baseValOpt, v, b, _, retTy) when n > 0 -> + let (vs', b', retTy') = stripLambdaUpto (n-1) (b, retTy) + (ctorThisValOpt, baseValOpt, (v :: vs'), b', retTy') + | Expr.TyChoose (_tps, _b, _) -> + startStripLambdaUpto n (ChooseTyparSolutionsForFreeChoiceTypars g amap e, ty) + | _ -> + (None, None, [], e, ty) + + let n = tvd.NumCurriedArgs + let tps, taue, tauty = + match e with + | Expr.TyLambda (_, tps, b, _, retTy) when not (isNil tpNames) -> tps, b, retTy + | _ -> [], e, ty + let ctorThisValOpt, baseValOpt, vsl, body, retTy = startStripLambdaUpto n (taue, tauty) + if vsl.Length <> n then + None + else + Some (tps, ctorThisValOpt, baseValOpt, vsl, body, retTy) + +let destTopLambda g amap topValInfo (e, ty) = + match tryDestTopLambda g amap topValInfo (e, ty) with + | None -> error(Error(FSComp.SR.typrelInvalidValue(), e.Range)) + | Some res -> res + +let IteratedAdjustArityOfLambdaBody g arities vsl body = + (arities, vsl, ([], body)) |||> List.foldBack2 (fun arities vs (allvs, body) -> + let vs, body = AdjustArityOfLambdaBody g arities vs body + vs :: allvs, body) + +/// Do AdjustArityOfLambdaBody for a series of +/// iterated lambdas, producing one method. +/// The required iterated function arity (List.length topValInfo) must be identical +/// to the iterated function arity of the input lambda (List.length vsl) +let IteratedAdjustArityOfLambda g amap topValInfo e = + let tps, ctorThisValOpt, baseValOpt, vsl, body, bodyty = destTopLambda g amap topValInfo (e, tyOfExpr g e) + let arities = topValInfo.AritiesOfArgs + if arities.Length <> vsl.Length then + errorR(InternalError(sprintf "IteratedAdjustArityOfLambda, List.length arities = %d, List.length vsl = %d" arities.Length vsl.Length, body.Range)) + let vsl, body = IteratedAdjustArityOfLambdaBody g arities vsl body + tps, ctorThisValOpt, baseValOpt, vsl, body, bodyty + + +/// "Single Feasible Type" inference +/// Look for the unique supertype of ty2 for which ty2 :> ty1 might feasibly hold +let FindUniqueFeasibleSupertype g amap m ty1 ty2 = + let supertypes = Option.toList (GetSuperTypeOfType g amap m ty2) @ (GetImmediateInterfacesOfType SkipUnrefInterfaces.Yes g amap m ty2) + supertypes |> List.tryFind (TypeFeasiblySubsumesType 0 g amap m ty1 NoCoerce) + + diff --git a/src/fsharp/TypedTreeBasics.fsi b/src/fsharp/TypedTreeBasics.fsi new file mode 100644 index 00000000000..1a79098d0a8 --- /dev/null +++ b/src/fsharp/TypedTreeBasics.fsi @@ -0,0 +1,228 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +//------------------------------------------------------------------------- +// Defines the typed abstract syntax trees used throughout the F# compiler. +//------------------------------------------------------------------------- + +module internal FSharp.Compiler.TypedTreeBasics + +open FSharp.Compiler.AbstractIL.IL +open FSharp.Compiler.Range +open FSharp.Compiler.TypedTree + +val getNameOfScopeRef: sref:ILScopeRef -> string + +/// Metadata on values (names of arguments etc. +module ValReprInfo = + + val unnamedTopArg1: ArgReprInfo + + val unnamedTopArg: ArgReprInfo list + + val unitArgData: ArgReprInfo list list + + val unnamedRetVal: ArgReprInfo + + val selfMetadata: ArgReprInfo list + + val emptyValData: ValReprInfo + + val InferTyparInfo: tps:Typar list -> TyparReprInfo list + + val InferArgReprInfo: v:Val -> ArgReprInfo + + val InferArgReprInfos: vs:Val list list -> ValReprInfo + + val HasNoArgs: ValReprInfo -> bool + +val typeOfVal: v:Val -> TType + +val typesOfVals: v:Val list -> TType list + +val nameOfVal: v:Val -> string + +val arityOfVal: v:Val -> ValReprInfo + +val tupInfoRef: TupInfo + +val tupInfoStruct: TupInfo + +val mkTupInfo: b:bool -> TupInfo + +val structnessDefault: bool + +val mkRawRefTupleTy: tys:TTypes -> TType + +val mkRawStructTupleTy: tys:TTypes -> TType + +val mapTImplFile: f:(ModuleOrNamespaceExprWithSig -> ModuleOrNamespaceExprWithSig) -> TypedImplFile -> TypedImplFile + +val mapAccImplFile: f:('a -> ModuleOrNamespaceExprWithSig -> ModuleOrNamespaceExprWithSig * 'b) -> z:'a -> TypedImplFile -> TypedImplFile * 'b + +val foldTImplFile: f:('a -> ModuleOrNamespaceExprWithSig -> 'b) -> z:'a -> TypedImplFile -> 'b + +val typarEq: lv1:Typar -> lv2:Typar -> bool + +/// Equality on type variables, implemented as reference equality. This should be equivalent to using typarEq. +val typarRefEq: tp1:Typar -> tp2:Typar -> bool + +/// Equality on value specs, implemented as reference equality +val valEq: lv1:Val -> lv2:Val -> bool + +/// Equality on CCU references, implemented as reference equality except when unresolved +val ccuEq: mv1:CcuThunk -> mv2:CcuThunk -> bool + +/// For dereferencing in the middle of a pattern +val ( |ValDeref| ): vr:ValRef -> Val + +val mkRecdFieldRef: tcref:TyconRef -> f:string -> RecdFieldRef + +val mkUnionCaseRef: tcref:TyconRef -> c:string -> UnionCaseRef + +val ERefLocal: x:Lib.NonNullSlot -> EntityRef + +val ERefNonLocal: x:NonLocalEntityRef -> EntityRef + +val ERefNonLocalPreResolved: x:Lib.NonNullSlot -> xref:NonLocalEntityRef -> EntityRef + +val ( |ERefLocal|ERefNonLocal| ): x:EntityRef -> Choice,NonLocalEntityRef> + +val mkLocalTyconRef: x:Lib.NonNullSlot -> EntityRef + +val mkNonLocalEntityRef: ccu:CcuThunk -> mp:string [] -> NonLocalEntityRef + +val mkNestedNonLocalEntityRef: nleref:NonLocalEntityRef -> id:string -> NonLocalEntityRef + +val mkNonLocalTyconRef: nleref:NonLocalEntityRef -> id:string -> EntityRef + +val mkNonLocalTyconRefPreResolved: x:Lib.NonNullSlot -> nleref:NonLocalEntityRef -> id:string -> EntityRef + +type EntityRef with + member NestedTyconRef: x:Entity -> EntityRef + member RecdFieldRefInNestedTycon: tycon:Entity -> id:SyntaxTree.Ident -> RecdFieldRef + +/// Make a reference to a union case for type in a module or namespace +val mkModuleUnionCaseRef: modref:ModuleOrNamespaceRef -> tycon:Entity -> uc:UnionCase -> UnionCaseRef val VRefLocal: x:Lib.NonNullSlot -> ValRef + +val VRefNonLocal: x:NonLocalValOrMemberRef -> ValRef + +val VRefNonLocalPreResolved: x:Lib.NonNullSlot -> xref:NonLocalValOrMemberRef -> ValRef + +val ( |VRefLocal|VRefNonLocal| ): x:ValRef -> Choice,NonLocalValOrMemberRef> + +val mkNonLocalValRef: mp:NonLocalEntityRef -> id:ValLinkageFullKey -> ValRef + +val mkNonLocalValRefPreResolved: x:Lib.NonNullSlot -> mp:NonLocalEntityRef -> id:ValLinkageFullKey -> ValRef + +val ccuOfValRef: vref:ValRef -> CcuThunk option + +val ccuOfTyconRef: eref:EntityRef -> CcuThunk option + +val mkTyparTy: tp:Typar -> TType + +val copyTypar: tp:Typar -> Typar + +val copyTypars: tps:Typar list -> Typar list + +val tryShortcutSolvedUnitPar: canShortcut:bool -> r:Typar -> Measure + +val stripUnitEqnsAux: canShortcut:bool -> unt:Measure -> Measure + +val stripTyparEqnsAux: canShortcut:bool -> ty:TType -> TType + +val stripTyparEqns: ty:TType -> TType + +val stripUnitEqns: unt:Measure -> Measure + +val mkLocalValRef: v:Val -> ValRef + +val mkLocalModRef: v:ModuleOrNamespace -> EntityRef + +val mkLocalEntityRef: v:Entity -> EntityRef + +val mkNonLocalCcuRootEntityRef: ccu:CcuThunk -> x:Entity -> EntityRef + +val mkNestedValRef:cref:EntityRef -> v:Val -> ValRef + +/// From Ref_private to Ref_nonlocal when exporting data. +val rescopePubPathToParent:viewedCcu:CcuThunk -> PublicPath -> NonLocalEntityRef + +/// From Ref_private to Ref_nonlocal when exporting data. +val rescopePubPath: viewedCcu:CcuThunk -> PublicPath -> NonLocalEntityRef + +val valRefInThisAssembly: compilingFslib:bool -> x:ValRef -> bool + +val tyconRefUsesLocalXmlDoc: compilingFslib:bool -> x:TyconRef -> bool + +val entityRefInThisAssembly: compilingFslib:bool -> x:EntityRef -> bool + +val arrayPathEq: y1:string [] -> y2:string [] -> bool + +val nonLocalRefEq:NonLocalEntityRef -> NonLocalEntityRef -> bool + +/// This predicate tests if non-local resolution paths are definitely known to resolve +/// to different entities. All references with different named paths always resolve to +/// different entities. Two references with the same named paths may resolve to the same +/// entities even if they reference through different CCUs, because one reference +/// may be forwarded to another via a .NET TypeForwarder. +val nonLocalRefDefinitelyNotEq: NonLocalEntityRef -> NonLocalEntityRef -> bool + +val pubPathEq: PublicPath -> PublicPath -> bool + +val fslibRefEq: nlr1:NonLocalEntityRef -> PublicPath -> bool + +/// Compare two EntityRef's for equality when compiling fslib (FSharp.Core.dll) +val fslibEntityRefEq: fslibCcu:CcuThunk -> eref1:EntityRef -> eref2:EntityRef -> bool + +// Compare two ValRef's for equality when compiling fslib (FSharp.Core.dll) +val fslibValRefEq: fslibCcu:CcuThunk -> vref1:ValRef -> vref2:ValRef -> bool + +/// Primitive routine to compare two EntityRef's for equality +/// This takes into account the possibility that they may have type forwarders +val primEntityRefEq: compilingFslib:bool -> fslibCcu:CcuThunk -> x:EntityRef -> y:EntityRef -> bool + +/// Primitive routine to compare two UnionCaseRef's for equality +val primUnionCaseRefEq: compilingFslib:bool -> fslibCcu:CcuThunk -> UnionCaseRef -> UnionCaseRef -> bool + +/// Primitive routine to compare two ValRef's for equality. On the whole value identity is not particularly +/// significant in F#. However it is significant for +/// (a) Active Patterns +/// (b) detecting uses of "special known values" from FSharp.Core.dll, such as 'seq' +/// and quotation splicing +/// +/// Note this routine doesn't take type forwarding into account +val primValRefEq: compilingFslib:bool -> fslibCcu:CcuThunk -> x:ValRef -> y:ValRef -> bool + +val fullCompPathOfModuleOrNamespace: m:ModuleOrNamespace -> CompilationPath + +val inline canAccessCompPathFrom: CompilationPath -> CompilationPath -> bool + +val canAccessFromOneOf: cpaths:CompilationPath list -> cpathTest:CompilationPath -> bool + +val canAccessFrom: Accessibility -> cpath:CompilationPath -> bool + +val canAccessFromEverywhere: Accessibility -> bool + +val canAccessFromSomewhere: Accessibility -> bool + +val isLessAccessible: Accessibility -> Accessibility -> bool + +/// Given (newPath, oldPath) replace oldPath by newPath in the TAccess. +val accessSubstPaths: newPath:CompilationPath * oldPath:CompilationPath -> Accessibility -> Accessibility + +val compPathOfCcu: ccu:CcuThunk -> CompilationPath + +val taccessPublic: Accessibility + +val taccessPrivate: accessPath:CompilationPath -> Accessibility + +val compPathInternal: CompilationPath + +val taccessInternal: Accessibility + +val combineAccess: Accessibility -> Accessibility -> Accessibility + +exception Duplicate of string * string * Range.range + +exception NameClash of string * string * string * Range.range * string * string * Range.range + diff --git a/src/fsharp/XmlAdapters.fsi b/src/fsharp/XmlAdapters.fsi new file mode 100644 index 00000000000..9b2f4f68188 --- /dev/null +++ b/src/fsharp/XmlAdapters.fsi @@ -0,0 +1,9 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module internal FSharp.Compiler.XmlAdapters + + val s_escapeChars : char [] + + val getEscapeSequence : c:char -> string + + val escape : str:string -> string diff --git a/src/fsharp/XmlDoc.fs b/src/fsharp/XmlDoc.fs index 9f53e338f3a..f4404e66314 100644 --- a/src/fsharp/XmlDoc.fs +++ b/src/fsharp/XmlDoc.fs @@ -21,7 +21,7 @@ type XmlDoc(unprocessedLines: string[], range: range) = elif lineAT.StartsWithOrdinal("<") then lines else [""] @ - (lines |> List.map Microsoft.FSharp.Core.XmlAdapters.escape) @ + (lines |> List.map FSharp.Compiler.XmlAdapters.escape) @ [""] /// Get the lines before insertion of implicit summary tags and encoding diff --git a/src/fsharp/XmlDoc.fsi b/src/fsharp/XmlDoc.fsi new file mode 100644 index 00000000000..69f12953493 --- /dev/null +++ b/src/fsharp/XmlDoc.fsi @@ -0,0 +1,56 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module public FSharp.Compiler.XmlDoc + +open FSharp.Compiler.Range + +/// Represents collected XmlDoc lines +[] +type XmlDoc = + + new: unprocessedLines:string [] * range:range -> XmlDoc + + static member Merge: doc1:XmlDoc -> doc2:XmlDoc -> XmlDoc + + member Check: paramNamesOpt:string list option -> unit + + /// Get the lines after insertion of implicit summary tags and encoding + member GetElaboratedXmlLines: unit -> string [] + + member GetXmlText: unit -> string + + member IsEmpty: bool + + member NonEmpty: bool + + member Range: range + + /// Get the lines before insertion of implicit summary tags and encoding + member UnprocessedLines: string [] + + static member Empty: XmlDoc + +/// Used to collect XML documentation during lexing and parsing. +type XmlDocCollector = + + new: unit -> XmlDocCollector + + member AddGrabPoint: pos:pos -> unit + + member AddXmlDocLine: line:string * range:range -> unit + + member LinesBefore: grabPointPos:pos -> (string * range) [] + +/// Represents the XmlDoc fragments as collected from the lexer during parsing +type PreXmlDoc = + | PreXmlMerge of PreXmlDoc * PreXmlDoc + | PreXmlDoc of pos * XmlDocCollector + | PreXmlDocEmpty + + static member CreateFromGrabPoint: collector:XmlDocCollector * grabPointPos:pos -> PreXmlDoc + + static member Merge: a:PreXmlDoc -> b:PreXmlDoc -> PreXmlDoc + + member ToXmlDoc: check:bool * paramNamesOpt:string list option -> XmlDoc + + static member Empty: PreXmlDoc diff --git a/src/fsharp/absil/illib.fs b/src/fsharp/absil/illib.fs index 87f3afaba47..24c637c32c6 100644 --- a/src/fsharp/absil/illib.fs +++ b/src/fsharp/absil/illib.fs @@ -13,8 +13,8 @@ open System.Reflection open System.Threading open System.Runtime.CompilerServices -// Logical shift right treating int32 as unsigned integer. -// Code that uses this should probably be adjusted to use unsigned integer types. +/// Logical shift right treating int32 as unsigned integer. +/// Code that uses this should probably be adjusted to use unsigned integer types. let (>>>&) (x: int32) (n: int32) = int32 (uint32 x >>> n) let notlazy v = Lazy<_>.CreateFromValue v @@ -664,7 +664,6 @@ type ResultOrException<'TResult> = | Result of 'TResult | Exception of Exception -[] module ResultOrException = let success a = Result a @@ -696,9 +695,9 @@ type ValueOrCancelled<'TResult> = /// /// A cancellable computation is passed may be cancelled via a CancellationToken, which is propagated implicitly. /// If cancellation occurs, it is propagated as data rather than by raising an OperationCanceledException. +[] type Cancellable<'TResult> = Cancellable of (CancellationToken -> ValueOrCancelled<'TResult>) -[] module Cancellable = /// Run a cancellable computation using the given cancellation token @@ -843,7 +842,6 @@ type Eventually<'T> = | Done of 'T | NotYetDone of (CompilationThreadToken -> Eventually<'T>) -[] module Eventually = let rec box e = @@ -1123,7 +1121,6 @@ type NameMultiMap<'T> = NameMap<'T list> type MultiMap<'T, 'U when 'T : comparison> = Map<'T, 'U list> -[] module NameMap = let empty = Map.empty @@ -1196,7 +1193,6 @@ module NameMap = | None -> if p y then Some y else None | _ -> acc) m None -[] module NameMultiMap = let existsInRange f (m: NameMultiMap<'T>) = NameMap.exists (fun _ l -> List.exists f l) m @@ -1219,7 +1215,6 @@ module NameMultiMap = let ofList (xs: (string * 'T) list) : NameMultiMap<'T> = xs |> Seq.groupBy fst |> Seq.map (fun (k, v) -> (k, List.ofSeq (Seq.map snd v))) |> Map.ofSeq -[] module MultiMap = let existsInRange f (m: MultiMap<_, _>) = Map.exists (fun _ l -> List.exists f l) m diff --git a/src/fsharp/absil/illib.fsi b/src/fsharp/absil/illib.fsi new file mode 100644 index 00000000000..b2f49e0c250 --- /dev/null +++ b/src/fsharp/absil/illib.fsi @@ -0,0 +1,692 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module public FSharp.Compiler.AbstractIL.Internal.Library + +open System +open System.IO +open System.Threading +open System.Collections.Generic +open System.Runtime.CompilerServices + +/// Logical shift right treating int32 as unsigned integer. +/// Code that uses this should probably be adjusted to use unsigned integer types. +val ( >>>& ): x:int32 -> n:int32 -> int32 + +val notlazy: v:'a -> Lazy<'a> + +val inline isNil: l:'a list -> bool + +/// Returns true if the list has less than 2 elements. Otherwise false. +val inline isNilOrSingleton: l:'a list -> bool + +/// Returns true if the list contains exactly 1 element. Otherwise false. +val inline isSingleton: l:'a list -> bool + +val inline isNonNull: x:'a -> bool when 'a: null + +val inline nonNull: msg:string -> x:'a -> 'a when 'a: null + +val inline ( === ): x:'a -> y:'a -> bool when 'a: not struct + +/// Per the docs the threshold for the Large Object Heap is 85000 bytes: https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/large-object-heap#how-an-object-ends-up-on-the-large-object-heap-and-how-gc-handles-them +/// We set the limit to be 80k to account for larger pointer sizes for when F# is running 64-bit. +val LOH_SIZE_THRESHOLD_BYTES: int + +val reportTime: (bool -> string -> unit) + +[] +type InlineDelayInit<'T when 'T: not struct> = + + new: f:(unit -> 'T) -> InlineDelayInit<'T> + val mutable store: 'T + val mutable func: Func<'T> + member Value: 'T + +val foldOn: p:('a -> 'b) -> f:('c -> 'b -> 'd) -> z:'c -> x:'a -> 'd + +val notFound: unit -> 'a + +module Order = + + val orderBy: p:('T -> 'U) -> IComparer<'T> when 'U: comparison + + val orderOn: p:('T -> 'U) -> pxOrder:IComparer<'U> -> IComparer<'T> + + val toFunction: pxOrder:IComparer<'U> -> x:'U -> y:'U -> int + +module Array = + + val mapq: f:('a -> 'a) -> inp:'a [] -> 'a [] when 'a: not struct + + val lengthsEqAndForall2 : p:('a -> 'b -> bool) -> l1:'a [] -> l2:'b [] -> bool + + val order : eltOrder:IComparer<'T> -> IComparer<'T array> + + val existsOne: p:('a -> bool) -> l:'a [] -> bool + + val existsTrue: arr:bool [] -> bool + + val findFirstIndexWhereTrue: arr:'a [] -> p:('a -> bool) -> int + + /// pass an array byref to reverse it in place + val revInPlace: array:'T [] -> unit + + /// Async implementation of Array.map. + val mapAsync: mapping:('T -> Async<'U>) -> array:'T [] -> Async<'U []> + + /// Returns a new array with an element replaced with a given value. + val replace: index:int -> value:'a -> array:'a [] -> 'a [] + + /// Optimized arrays equality. ~100x faster than `array1 = array2` on strings. + /// ~2x faster for floats + /// ~0.8x slower for ints + val inline areEqual: xs:'T [] -> ys:'T [] -> bool when 'T: equality + + /// Returns all heads of a given array. + val heads: array:'T [] -> 'T [] [] + + /// Check if subArray is found in the wholeArray starting at the provided index + val inline isSubArray : subArray:'T [] -> wholeArray:'T [] -> index:int -> bool when 'T: equality + + /// Returns true if one array has another as its subset from index 0. + val startsWith: prefix:'a [] -> whole:'a [] -> bool when 'a: equality + + /// Returns true if one array has trailing elements equal to another's. + val endsWith: suffix:'a [] -> whole:'a [] -> bool when 'a: equality + +module Option = + + val mapFold: f:('a -> 'b -> 'c * 'a) -> s:'a -> opt:'b option -> 'c option * 'a + + val attempt: f:(unit -> 'T) -> 'T option + +module List = + + val sortWithOrder : c:IComparer<'T> -> elements:'T list -> 'T list + + val splitAfter: n:int -> l:'a list -> 'a list * 'a list + + val existsi: f:(int -> 'a -> bool) -> xs:'a list -> bool + + val lengthsEqAndForall2 : p:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool + + val findi: n:int -> f:('a -> bool) -> l:'a list -> ('a * int) option + + val splitChoose : select:('a -> Choice<'b,'c>) -> l:'a list -> 'b list * 'c list + + val checkq: l1:'a list -> l2:'a list -> bool when 'a: not struct + + val mapq: f:('T -> 'T) -> inp:'T list -> 'T list when 'T: not struct + + val frontAndBack: l:'a list -> 'a list * 'a + + val tryRemove: f:('a -> bool) -> inp:'a list -> ('a * 'a list) option + + val zip4 : l1:'a list -> l2:'b list -> l3:'c list -> l4:'d list -> ('a * 'b * 'c * 'd) list + + val unzip4 : l:('a * 'b * 'c * 'd) list -> 'a list * 'b list * 'c list * 'd list + + val iter3 : f:('a -> 'b -> 'c -> unit) -> l1:'a list -> l2:'b list -> l3:'c list -> unit + + val takeUntil: p:('a -> bool) -> l:'a list -> 'a list * 'a list + + val order : eltOrder:IComparer<'T> -> IComparer<'T list> + + val indexNotFound: unit -> 'a + + val assoc: x:'a -> l:('a * 'b) list -> 'b when 'a: equality + + val memAssoc: x:'a -> l:('a * 'b) list -> bool when 'a: equality + + val memq: x:'a -> l:'a list -> bool when 'a: not struct + + val mapNth: n:int -> f:('a -> 'a) -> xs:'a list -> 'a list + + val count: pred:('a -> bool) -> xs:'a list -> int + + val headAndTail: l:'a list -> 'a * 'a list + + // WARNING: not tail-recursive + val mapHeadTail : fhead:('a -> 'b) -> ftail:('a -> 'b) -> _arg1:'a list -> 'b list + + val collectFold : f:('a -> 'b -> 'c list * 'a) -> s:'a -> l:'b list -> 'c list * 'a + + val collect2 : f:('a -> 'b -> 'c list) -> xs:'a list -> ys:'b list -> 'c list + + val toArraySquared: xss:'a list list -> 'a [] [] + + val iterSquared: f:('a -> unit) -> xss:'a list list -> unit + + val collectSquared: f:('a -> 'b list) -> xss:'a list list -> 'b list + + val mapSquared: f:('a -> 'b) -> xss:'a list list -> 'b list list + + val mapFoldSquared : f:('a -> 'b -> 'c * 'a) -> z:'a -> xss:'b list list -> 'c list list * 'a + + val forallSquared: f:('a -> bool) -> xss:'a list list -> bool + + val mapiSquared : f:(int -> int -> 'a -> 'b) -> xss:'a list list -> 'b list list + + val existsSquared: f:('a -> bool) -> xss:'a list list -> bool + + val mapiFoldSquared : f:('a -> int * int * 'b -> 'c * 'a) -> z:'a -> xss:'b list list -> 'c list list * 'a + + val duplicates: xs:'T list -> 'T list when 'T: equality + + val internal allEqual: xs:'T list -> bool when 'T: equality + +module ResizeArray = + + /// Split a ResizeArray into an array of smaller chunks. + /// This requires `items/chunkSize` Array copies of length `chunkSize` if `items/chunkSize % 0 = 0`, + /// otherwise `items/chunkSize + 1` Array copies. + val chunkBySize : chunkSize:int -> f:('t -> 'a) -> items:ResizeArray<'t> -> 'a [] [] + + /// Split a large ResizeArray into a series of array chunks that are each under the Large Object Heap limit. + /// This is done to help prevent a stop-the-world collection of the single large array, instead allowing for a greater + /// probability of smaller collections. Stop-the-world is still possible, just less likely. + val mapToSmallArrayChunks : f:('t -> 'a) -> inp:ResizeArray<'t> -> 'a [] [] + +module ValueOptionInternal = + + val inline ofOption: x:'a option -> 'a voption + + val inline bind: f:('a -> 'b voption) -> x:'a voption -> 'b voption + +type String with + + member inline StartsWithOrdinal: value:string -> bool + + member inline EndsWithOrdinal: value:string -> bool + +module String = + + val make: n:int -> c:char -> string + + val get: str:string -> i:int -> char + + val sub: s:string -> start:int -> len:int -> string + + val contains: s:string -> c:char -> bool + + val order: IComparer + + val lowercase: s:string -> string + + val uppercase: s:string -> string + + val isLeadingIdentifierCharacterUpperCase: s:string -> bool + + val capitalize: s:string -> string + + val uncapitalize: s:string -> string + + val dropPrefix: s:string -> t:string -> string + + val dropSuffix: s:string -> t:string -> string + + val inline toCharArray: str:string -> char [] + + val lowerCaseFirstChar: str:string -> string + + val extractTrailingIndex: str:string -> string * int option + + /// Remove all trailing and leading whitespace from the string, return null if the string is null + val trim: value:string -> string + + /// Splits a string into substrings based on the strings in the array separators + val split : options:StringSplitOptions -> separator:string [] -> value:string -> string [] + + val (|StartsWith|_|): pattern:string -> value:string -> unit option + + val (|Contains|_|): pattern:string -> value:string -> unit option + + val getLines: str:string -> string [] + +module Dictionary = + val inline newWithSize : size:int -> Dictionary<'a,'b> when 'a: equality + +[] +type DictionaryExtensions = + + [] + static member inline BagAdd: dic:Dictionary<'key,'value list> * key:'key * value:'value -> unit + + [] + static member inline BagExistsValueForKey: dic:Dictionary<'key,'value list> * key:'key * f:('value -> bool) -> bool + +module Lazy = + val force: x:Lazy<'T> -> 'T + +/// Represents a permission active at this point in execution +type ExecutionToken = interface end + +/// Represents a token that indicates execution on the compilation thread, i.e. +/// - we have full access to the (partially mutable) TAST and TcImports data structures +/// - compiler execution may result in type provider invocations when resolving types and members +/// - we can access various caches in the SourceCodeServices +/// +/// Like other execution tokens this should be passed via argument passing and not captured/stored beyond +/// the lifetime of stack-based calls. This is not checked, it is a discipline within the compiler code. +type CompilationThreadToken = + + interface ExecutionToken + new: unit -> CompilationThreadToken + +/// Represents a place where we are stating that execution on the compilation thread is required. The +/// reason why will be documented in a comment in the code at the callsite. +val RequireCompilationThread: _ctok:CompilationThreadToken -> unit + +/// Represents a place in the compiler codebase where we are passed a CompilationThreadToken unnecessarily. +/// This represents code that may potentially not need to be executed on the compilation thread. +val DoesNotRequireCompilerThreadTokenAndCouldPossiblyBeMadeConcurrent : _ctok:CompilationThreadToken -> unit + +/// Represents a place in the compiler codebase where we assume we are executing on a compilation thread +val AssumeCompilationThreadWithoutEvidence: unit -> CompilationThreadToken + +/// Represents a token that indicates execution on any of several potential user threads calling the F# compiler services. +type AnyCallerThreadToken = + + interface ExecutionToken + new: unit -> AnyCallerThreadToken + +val AnyCallerThread: AnyCallerThreadToken + +/// A base type for various types of tokens that must be passed when a lock is taken. +/// Each different static lock should declare a new subtype of this type. +type LockToken = + interface + inherit ExecutionToken + end + +val AssumeLockWithoutEvidence: unit -> #LockToken + +/// Encapsulates a lock associated with a particular token-type representing the acquisition of that lock. +type Lock<'LockTokenType when 'LockTokenType :> LockToken> = + + new: unit -> Lock<'LockTokenType> + member AcquireLock: f:('LockTokenType -> 'a) -> 'a + +/// Get an initialization hole +val getHole: r:'a option ref -> 'a + +module Map = + val tryFindMulti : + k:'a -> map:Map<'a,'b list> -> 'b list when 'a: comparison + +type ResultOrException<'TResult> = + | Result of 'TResult + | Exception of Exception + +module ResultOrException = + val success: a:'a -> ResultOrException<'a> + val raze: b:exn -> ResultOrException<'a> + val ( |?> ) : res:ResultOrException<'a> -> f:('a -> 'b) -> ResultOrException<'b> + val ForceRaise: res:ResultOrException<'a> -> 'a + val otherwise : f:(unit -> ResultOrException<'a>) -> x:ResultOrException<'a> -> ResultOrException<'a> + +[] +type ValueOrCancelled<'TResult> = + | Value of 'TResult + | Cancelled of OperationCanceledException + +/// Represents a synchronous cancellable computation with explicit representation of a cancelled result. +/// +/// A cancellable computation is passed may be cancelled via a CancellationToken, which is propagated implicitly. +/// If cancellation occurs, it is propagated as data rather than by raising an OperationCanceledException. +[] +type Cancellable<'TResult> = + | Cancellable of (CancellationToken -> ValueOrCancelled<'TResult>) + +module Cancellable = + + /// Run a cancellable computation using the given cancellation token + val run : ct:CancellationToken -> Cancellable<'a> -> ValueOrCancelled<'a> + + /// Bind the result of a cancellable computation + val bind : f:('a -> Cancellable<'b>) -> comp1:Cancellable<'a> -> Cancellable<'b> + + /// Map the result of a cancellable computation + val map: f:('a -> 'b) -> oper:Cancellable<'a> -> Cancellable<'b> + + /// Return a simple value as the result of a cancellable computation + val ret: x:'a -> Cancellable<'a> + + /// Fold a cancellable computation along a sequence of inputs + val fold : f:('a -> 'b -> Cancellable<'a>) -> acc:'a -> seq:seq<'b> -> Cancellable<'a> + + /// Iterate a cancellable computation over a collection + val each : f:('a -> Cancellable<'b>) -> seq:seq<'a> -> Cancellable<'b list> + + /// Delay a cancellable computation + val delay: f:(unit -> Cancellable<'T>) -> Cancellable<'T> + + /// Run the computation in a mode where it may not be cancelled. The computation never results in a + /// ValueOrCancelled.Cancelled. + val runWithoutCancellation: comp:Cancellable<'a> -> 'a + + /// Bind the cancellation token associated with the computation + val token: unit -> Cancellable + + /// Represents a canceled computation + val canceled: unit -> Cancellable<'a> + + /// Implement try/finally for a cancellable computation + val tryFinally : e:Cancellable<'a> -> compensation:(unit -> unit) -> Cancellable<'a> + + /// Implement try/with for a cancellable computation + val tryWith : e:Cancellable<'a> -> handler:(exn -> Cancellable<'a>) -> Cancellable<'a> + +type CancellableBuilder = + + new: unit -> CancellableBuilder + member Bind: e:Cancellable<'k> * k:('k -> Cancellable<'l>) -> Cancellable<'l> + member Combine: e1:Cancellable * e2:Cancellable<'h> -> Cancellable<'h> + member Delay: f:(unit -> Cancellable<'a>) -> Cancellable<'a> + member For: es:seq<'f> * f:('f -> Cancellable<'g>) -> Cancellable<'g list> + member Return: v:'j -> Cancellable<'j> + member ReturnFrom: v:'i -> 'i + member TryFinally: e:Cancellable<'b> * compensation:(unit -> unit) -> Cancellable<'b> + member TryWith: e:Cancellable<'e> * handler:(exn -> Cancellable<'e>) -> Cancellable<'e> + member Using: resource:'c * e:('c -> Cancellable<'d>) -> Cancellable<'d> when 'c :> System.IDisposable + member Zero: unit -> Cancellable + +val cancellable: CancellableBuilder + +/// Computations that can cooperatively yield by returning a continuation +/// +/// - Any yield of a NotYetDone should typically be "abandonable" without adverse consequences. No resource release +/// will be called when the computation is abandoned. +/// +/// - Computations suspend via a NotYetDone may use local state (mutables), where these are +/// captured by the NotYetDone closure. Computations do not need to be restartable. +/// +/// - The key thing is that you can take an Eventually value and run it with +/// Eventually.repeatedlyProgressUntilDoneOrTimeShareOverOrCanceled +/// +/// - Cancellation results in a suspended computation rather than complete abandonment +type Eventually<'T> = + | Done of 'T + | NotYetDone of (CompilationThreadToken -> Eventually<'T>) + +module Eventually = + val box: e:Eventually<'a> -> Eventually + val forceWhile : ctok:CompilationThreadToken -> check:(unit -> bool) -> e:Eventually<'a> -> 'a option + val force: ctok:CompilationThreadToken -> e:Eventually<'a> -> 'a + +/// Keep running the computation bit by bit until a time limit is reached. +/// The runner gets called each time the computation is restarted +/// +/// If cancellation happens, the operation is left half-complete, ready to resume. + val repeatedlyProgressUntilDoneOrTimeShareOverOrCanceled : + timeShareInMilliseconds:int64 -> + ct:CancellationToken -> + runner:(CompilationThreadToken -> (#CompilationThreadToken -> Eventually<'b>) -> Eventually<'b>) -> + e:Eventually<'b> + -> Eventually<'b> + + /// Keep running the asynchronous computation bit by bit. The runner gets called each time the computation is restarted. + /// Can be cancelled as an Async in the normal way. + val forceAsync : runner:((CompilationThreadToken -> Eventually<'T>) -> Async>) -> e:Eventually<'T> -> Async<'T option> + + val bind: k:('a -> Eventually<'b>) -> e:Eventually<'a> -> Eventually<'b> + + val fold : f:('a -> 'b -> Eventually<'a>) -> acc:'a -> seq:seq<'b> -> Eventually<'a> + + val catch: e:Eventually<'a> -> Eventually> + + val delay: f:(unit -> Eventually<'T>) -> Eventually<'T> + + val tryFinally : e:Eventually<'a> -> compensation:(unit -> unit) -> Eventually<'a> + + val tryWith : e:Eventually<'a> -> handler:(System.Exception -> Eventually<'a>) -> Eventually<'a> + + // All eventually computations carry a CompilationThreadToken + val token: Eventually + +[] +type EventuallyBuilder = + member Bind: e:Eventually<'g> * k:('g -> Eventually<'h>) -> Eventually<'h> + member Combine: e1:Eventually * e2:Eventually<'d> -> Eventually<'d> + member Delay: f:(unit -> Eventually<'a>) -> Eventually<'a> + member Return: v:'f -> Eventually<'f> + member ReturnFrom: v:'e -> 'e + member TryFinally: e:Eventually<'b> * compensation:(unit -> unit) -> Eventually<'b> + member TryWith: e:Eventually<'c> * handler:(System.Exception -> Eventually<'c>) -> Eventually<'c> + member Zero: unit -> Eventually + +val eventually: EventuallyBuilder + +/// Generates unique stamps +type UniqueStampGenerator<'T when 'T: equality> = + new: unit -> UniqueStampGenerator<'T> + member Encode: str:'T -> int + member Table: ICollection<'T> + +/// Memoize tables (all entries cached, never collected unless whole table is collected) +type MemoizationTable<'T,'U> = + new: compute:('T -> 'U) * keyComparer:IEqualityComparer<'T> * ?canMemoize:('T -> bool) -> MemoizationTable<'T,'U> + member Apply: x:'T -> 'U + +exception UndefinedException + +type LazyWithContextFailure = + new: exn:exn -> LazyWithContextFailure + member Exception: exn + static member Undefined: LazyWithContextFailure + +/// Just like "Lazy" but EVERY forcer must provide an instance of "ctxt", e.g. to help track errors +/// on forcing back to at least one sensible user location +[] +type LazyWithContext<'T,'ctxt> = + static member Create: f:('ctxt -> 'T) * findOriginalException:(exn -> exn) -> LazyWithContext<'T,'ctxt> + static member NotLazy: x:'T -> LazyWithContext<'T,'ctxt> + member Force: ctxt:'ctxt -> 'T + member UnsynchronizedForce: ctxt:'ctxt -> 'T + member IsDelayed: bool + member IsForced: bool + +/// Intern tables to save space. +module Tables = + val memoize: f:('a -> 'b) -> ('a -> 'b) when 'a: equality + +/// Interface that defines methods for comparing objects using partial equality relation +type IPartialEqualityComparer<'T> = + inherit IEqualityComparer<'T> + abstract member InEqualityRelation: 'T -> bool + +/// Interface that defines methods for comparing objects using partial equality relation +module IPartialEqualityComparer = + val On : f:('a -> 'b) -> c:IPartialEqualityComparer<'b> -> IPartialEqualityComparer<'a> + + /// Like Seq.distinctBy but only filters out duplicates for some of the elements + val partialDistinctBy : per:IPartialEqualityComparer<'T> -> seq:'T list -> 'T list + +type NameMap<'T> = Map + +type NameMultiMap<'T> = NameMap<'T list> + +type MultiMap<'T,'U when 'T: comparison> = Map<'T,'U list> + +module NameMap = + + val empty: Map<'a,'b> when 'a: comparison + + val range: m:Map<'a,'b> -> 'b list when 'a: comparison + + val foldBack: f:(string -> 'T -> 'a -> 'a) -> m:NameMap<'T> -> z:'a -> 'a + + val forall : f:('a -> 'b -> bool) -> m:Map<'a,'b> -> bool when 'a: comparison + + val exists : f:('a -> 'b -> bool) -> m:Map<'a,'b> -> bool when 'a: comparison + + + val ofKeyedList : f:('a -> 'b) -> l:'a list -> Map<'b,'a> when 'b: comparison + + val ofList: l:(string * 'T) list -> NameMap<'T> + + val ofSeq: l:seq -> NameMap<'T> + + val toList: l:NameMap<'T> -> (string * 'T) list + + val layer: m1:NameMap<'T> -> m2:Map -> Map + + /// Not a very useful function - only called in one place - should be changed + val layerAdditive : addf:('a list -> 'b -> 'a list) -> m1:Map<'c,'b> -> m2:Map<'c,'a list> -> Map<'c,'a list> when 'c: comparison + + /// Union entries by identical key, using the provided function to union sets of values + val union : unionf:(seq<'a> -> 'b) -> ms:seq> -> Map + + /// For every entry in m2 find an entry in m1 and fold + val subfold2 : errf:('a -> 'b -> 'c) -> f:('a -> 'd -> 'b -> 'c -> 'c) -> m1:Map<'a,'d> -> m2:Map<'a,'b> -> acc:'c -> 'c when 'a: comparison + + val suball2 : errf:('a -> 'b -> bool) -> p:('c -> 'b -> bool) -> m1:Map<'a,'c> -> m2:Map<'a,'b> -> bool when 'a: comparison + + val mapFold : f:('a -> string -> 'T -> 'b * 'a) -> s:'a -> l:NameMap<'T> -> Map * 'a + + val foldBackRange: f:('T -> 'a -> 'a) -> l:NameMap<'T> -> acc:'a -> 'a + + val filterRange: f:('T -> bool) -> l:NameMap<'T> -> Map + + val mapFilter: f:('T -> 'a option) -> l:NameMap<'T> -> Map + + val map: f:('T -> 'a) -> l:NameMap<'T> -> Map + + val iter: f:('T -> unit) -> l:NameMap<'T> -> unit + + val partition : f:('T -> bool) -> l:NameMap<'T> -> Map * Map + + val mem: v:string -> m:NameMap<'T> -> bool + + val find: v:string -> m:NameMap<'T> -> 'T + + val tryFind: v:string -> m:NameMap<'T> -> 'T option + + val add: v:string -> x:'T -> m:NameMap<'T> -> Map + + val isEmpty: m:NameMap<'T> -> bool + + val existsInRange : p:('a -> bool) -> m:Map<'b,'a> -> bool when 'b: comparison + + val tryFindInRange : p:('a -> bool) -> m:Map<'b,'a> -> 'a option when 'b: comparison + +module NameMultiMap = + + val existsInRange: f:('T -> bool) -> m:NameMultiMap<'T> -> bool + + val find: v:string -> m:NameMultiMap<'T> -> 'T list + + val add: v:string -> x:'T -> m:NameMultiMap<'T> -> Map + + val range: m:NameMultiMap<'T> -> 'T list + + val rangeReversingEachBucket: m:NameMultiMap<'T> -> 'T list + + val chooseRange: f:('T -> 'a option) -> m:NameMultiMap<'T> -> 'a list + + val map: f:('T -> 'a) -> m:NameMultiMap<'T> -> Map + + val empty: NameMultiMap<'T> + + val initBy: f:('T -> string) -> xs:seq<'T> -> NameMultiMap<'T> + + val ofList: xs:(string * 'T) list -> NameMultiMap<'T> + +module MultiMap = + + val existsInRange : f:('a -> bool) -> m:MultiMap<'b,'a> -> bool when 'b: comparison + + val find: v:'a -> m:MultiMap<'a,'b> -> 'b list when 'a: comparison + + val add : v:'a -> x:'b -> m:MultiMap<'a,'b> -> Map<'a,'b list> when 'a: comparison + + val range: m:MultiMap<'a,'b> -> 'b list when 'a: comparison + + val empty: MultiMap<'a,'b> when 'a: comparison + + val initBy : f:('a -> 'b) -> xs:seq<'a> -> MultiMap<'b,'a> when 'b: comparison + +type LayeredMap<'Key,'Value when 'Key: comparison> = Map<'Key,'Value> + +type Map<'Key,'Value when 'Key: comparison> with + + static member Empty: Map<'Key,'Value> when 'Key: comparison + + member Values: 'Value list + + member AddAndMarkAsCollapsible: kvs:KeyValuePair<'Key,'Value> [] -> Map<'Key,'Value> when 'Key: comparison + + member LinearTryModifyThenLaterFlatten: key:'Key * f:('Value option -> 'Value) -> Map<'Key,'Value> when 'Key: comparison + +type Map<'Key,'Value when 'Key: comparison> with + member MarkAsCollapsible: unit -> Map<'Key,'Value> when 'Key: comparison + +/// Immutable map collection, with explicit flattening to a backing dictionary +[] +type LayeredMultiMap<'Key,'Value when 'Key: comparison> = + + new: contents:LayeredMap<'Key,'Value list> -> LayeredMultiMap<'Key,'Value> + member Add: k:'Key * v:'Value -> LayeredMultiMap<'Key,'Value> + member AddAndMarkAsCollapsible: kvs:KeyValuePair<'Key,'Value> [] -> LayeredMultiMap<'Key,'Value> + member MarkAsCollapsible: unit -> LayeredMultiMap<'Key,'Value> + member TryFind: k:'Key -> 'Value list option + member TryGetValue: k:'Key -> bool * 'Value list + member Item: k:'Key -> 'Value list with get + member Values: 'Value list + static member Empty: LayeredMultiMap<'Key,'Value> + +[] +module Shim = + type IFileSystem = + + /// Used to load a dependency for F# Interactive and in an unused corner-case of type provider loading + abstract member AssemblyLoad: assemblyName:System.Reflection.AssemblyName -> System.Reflection.Assembly + + /// Used to load type providers and located assemblies in F# Interactive + abstract member AssemblyLoadFrom: fileName:string -> System.Reflection.Assembly + + /// A shim over File.Delete + abstract member FileDelete: fileName:string -> unit + abstract member FileStreamCreateShim: fileName:string -> Stream + + /// A shim over FileStream with FileMode.Open, FileAccess.Read, FileShare.ReadWrite + abstract member FileStreamReadShim: fileName:string -> Stream + + /// A shim over FileStream with FileMode.Open, FileAccess.Write, FileShare.Read + abstract member FileStreamWriteExistingShim: fileName:string -> Stream + + /// Take in a filename with an absolute path, and return the same filename + /// but canonicalized with respect to extra path separators (e.g. C:\\\\foo.txt) + /// and '..' portions + abstract member GetFullPathShim: fileName:string -> string + + /// Utc time of the last modification + abstract member GetLastWriteTimeShim: fileName:string -> DateTime + + /// A shim over Path.GetTempPath + abstract member GetTempPathShim: unit -> string + + /// A shim over Path.IsInvalidPath + abstract member IsInvalidPathShim: filename:string -> bool + + /// A shim over Path.IsPathRooted + abstract member IsPathRootedShim: path:string -> bool + + /// Used to determine if a file will not be subject to deletion during the lifetime of a typical client process. + abstract member IsStableFileHeuristic: fileName:string -> bool + + /// A shim over File.ReadAllBytes + abstract member ReadAllBytesShim: fileName:string -> byte [] + + /// A shim over File.Exists + abstract member SafeExists: fileName:string -> bool + + /// The global hook into the file system + val mutable FileSystem: IFileSystem + + type System.IO.File with + static member ReadBinaryChunk: fileName:string * start:int * len:int -> byte [] + + static member OpenReaderAndRetry: filename:string * codepage:int option * retryLocked:bool -> System.IO.StreamReader + + diff --git a/src/fsharp/absil/ilreflect.fsi b/src/fsharp/absil/ilreflect.fsi new file mode 100644 index 00000000000..88a2103904e --- /dev/null +++ b/src/fsharp/absil/ilreflect.fsi @@ -0,0 +1,56 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +//---------------------------------------------------------------------------- +// Write Abstract IL structures at runtime using Reflection.Emit +//---------------------------------------------------------------------------- + + +module internal FSharp.Compiler.AbstractIL.ILRuntimeWriter + +open System +open System.IO +open System.Reflection +open System.Reflection.Emit +open System.Runtime.InteropServices +open System.Collections.Generic + +open FSharp.Compiler.AbstractIL +open FSharp.Compiler.AbstractIL.Internal +open FSharp.Compiler.AbstractIL.Internal.Library +open FSharp.Compiler.AbstractIL.Internal.Utils +open FSharp.Compiler.AbstractIL.Diagnostics +open FSharp.Compiler.AbstractIL.IL +open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.Range +open FSharp.Core.Printf + +val mkDynamicAssemblyAndModule: assemblyName:string * optimize:bool * debugInfo:'a * collectible:bool -> AssemblyBuilder * ModuleBuilder + +type cenv = + { ilg: ILGlobals + tryFindSysILTypeRef: string -> ILTypeRef option + generatePdb: bool + resolveAssemblyRef: (ILAssemblyRef -> Choice option) } + +type emEnv + +val emEnv0: emEnv + +val emitModuleFragment: + ilg:ILGlobals * + emEnv:emEnv * + asmB:AssemblyBuilder * + modB:ModuleBuilder * + modul:ILModuleDef * + debugInfo:bool * + resolveAssemblyRef:(ILAssemblyRef -> Choice option) * + tryFindSysILTypeRef:(string -> ILTypeRef option) -> + emEnv * (unit -> exn option) list + +val LookupTypeRef: cenv:cenv -> emEnv:emEnv -> tref:ILTypeRef -> System.Type + +val LookupType: cenv:cenv -> emEnv:emEnv -> ty:ILType -> System.Type + +val LookupFieldRef: emEnv:emEnv -> fref:ILFieldRef -> FieldInfo option + +val LookupMethodRef: emEnv:emEnv -> mref:ILMethodRef -> MethodInfo option diff --git a/src/fsharp/infos.fsi b/src/fsharp/infos.fsi new file mode 100644 index 00000000000..a314acbd673 --- /dev/null +++ b/src/fsharp/infos.fsi @@ -0,0 +1,2612 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module internal FSharp.Compiler.Infos + +open System +open FSharp.Compiler +open FSharp.Compiler.AbstractIL +open FSharp.Compiler.AbstractIL.IL +open FSharp.Compiler.AbstractIL.Internal.Library +open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.Lib +open FSharp.Compiler.Range +open FSharp.Compiler.SyntaxTree +open FSharp.Compiler.SyntaxTreeOps +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeBasics +open FSharp.Compiler.TypedTreeOps +open FSharp.Compiler.TypedTreeOps.DebugPrint +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.XmlDoc + +#if !NO_EXTENSIONTYPING +open FSharp.Compiler.ExtensionTyping +#endif + +//------------------------------------------------------------------------- +// From IL types to F# types +//------------------------------------------------------------------------- + +/// Import an IL type as an F# type. importInst gives the context for interpreting type variables. +let ImportILType scoref amap m importInst ilty = + ilty |> rescopeILType scoref |> Import.ImportILType amap m importInst + +let CanImportILType scoref amap m ilty = + ilty |> rescopeILType scoref |> Import.CanImportILType amap m + +//------------------------------------------------------------------------- +// Fold the hierarchy. +// REVIEW: this code generalizes the iteration used below for member lookup. +//------------------------------------------------------------------------- + +/// Indicates if an F# type is the type associated with an F# exception declaration +let isExnDeclTy g ty = + match tryTcrefOfAppTy g ty with + | ValueSome tcref -> tcref.IsExceptionDecl + | _ -> false + +/// Get the base type of a type, taking into account type instantiations. Return None if the +/// type has no base type. +let GetSuperTypeOfType g amap m ty = +#if !NO_EXTENSIONTYPING + let ty = + match tryTcrefOfAppTy g ty with + | ValueSome tcref when tcref.IsProvided -> stripTyEqns g ty + | _ -> stripTyEqnsAndMeasureEqns g ty +#else + let ty = stripTyEqnsAndMeasureEqns g ty +#endif + + match metadataOfTy g ty with +#if !NO_EXTENSIONTYPING + | ProvidedTypeMetadata info -> + let st = info.ProvidedType + let superOpt = st.PApplyOption((fun st -> match st.BaseType with null -> None | t -> Some t), m) + match superOpt with + | None -> None + | Some super -> Some(Import.ImportProvidedType amap m super) +#endif + | ILTypeMetadata (TILObjectReprData(scoref, _, tdef)) -> + let tinst = argsOfAppTy g ty + match tdef.Extends with + | None -> None + | Some ilty -> Some (ImportILType scoref amap m tinst ilty) + + | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> + if isFSharpObjModelTy g ty || isExnDeclTy g ty then + let tcref = tcrefOfAppTy g ty + Some (instType (mkInstForAppTy g ty) (superOfTycon g tcref.Deref)) + elif isArrayTy g ty then + Some g.system_Array_ty + elif isRefTy g ty && not (isObjTy g ty) then + Some g.obj_ty + elif isStructTupleTy g ty then + Some g.system_Value_ty + elif isFSharpStructOrEnumTy g ty then + if isFSharpEnumTy g ty then + Some g.system_Enum_ty + else + Some g.system_Value_ty + elif isStructAnonRecdTy g ty then + Some g.system_Value_ty + elif isAnonRecdTy g ty then + Some g.obj_ty + elif isRecdTy g ty || isUnionTy g ty then + Some g.obj_ty + else + None + +/// Make a type for System.Collections.Generic.IList +let mkSystemCollectionsGenericIListTy (g: TcGlobals) ty = TType_app(g.tcref_System_Collections_Generic_IList, [ty]) + +[] +/// Indicates whether we can skip interface types that lie outside the reference set +type SkipUnrefInterfaces = Yes | No + + +/// Collect the set of immediate declared interface types for an F# type, but do not +/// traverse the type hierarchy to collect further interfaces. +let rec GetImmediateInterfacesOfType skipUnref g amap m ty = + let itys = + match tryAppTy g ty with + | ValueSome(tcref, tinst) -> + if tcref.IsMeasureableReprTycon then + [ match tcref.TypeReprInfo with + | TMeasureableRepr reprTy -> + for ity in GetImmediateInterfacesOfType skipUnref g amap m reprTy do + match tryTcrefOfAppTy g ity with + | ValueNone -> () + | ValueSome itcref -> + if not (tyconRefEq g itcref g.system_GenericIComparable_tcref) && + not (tyconRefEq g itcref g.system_GenericIEquatable_tcref) then + yield ity + | _ -> () + yield mkAppTy g.system_GenericIComparable_tcref [ty] + yield mkAppTy g.system_GenericIEquatable_tcref [ty]] + else + match metadataOfTy g ty with +#if !NO_EXTENSIONTYPING + | ProvidedTypeMetadata info -> + [ for ity in info.ProvidedType.PApplyArray((fun st -> st.GetInterfaces()), "GetInterfaces", m) do + yield Import.ImportProvidedType amap m ity ] +#endif + | ILTypeMetadata (TILObjectReprData(scoref, _, tdef)) -> + + // ImportILType may fail for an interface if the assembly load set is incomplete and the interface + // comes from another assembly. In this case we simply skip the interface: + // if we don't skip it, then compilation will just fail here, and if type checking + // succeeds with fewer non-dereferencable interfaces reported then it would have + // succeeded with more reported. There are pathological corner cases where this + // doesn't apply: e.g. for mscorlib interfaces like IComparable, but we can always + // assume those are present. + tdef.Implements |> List.choose (fun ity -> + if skipUnref = SkipUnrefInterfaces.No || CanImportILType scoref amap m ity then + Some (ImportILType scoref amap m tinst ity) + else None) + + | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> + tcref.ImmediateInterfaceTypesOfFSharpTycon |> List.map (instType (mkInstForAppTy g ty)) + | _ -> [] + + + // NOTE: Anonymous record types are not directly considered to implement IComparable, + // IComparable or IEquatable. This is because whether they support these interfaces depend on their + // consitutent types, which may not yet be known in type inference. + // + // NOTE: Tuples could in theory always support IComparable etc. because this + // is in the .NET metadata for System.Tuple etc. However from the F# perspective tuple types don't + // always support the 'comparable' and 'equality' constraints (again, it depends on their constitutent types). + + // .NET array types are considered to implement IList + let itys = + if isArray1DTy g ty then + mkSystemCollectionsGenericIListTy g (destArrayTy g ty) :: itys + else + itys + + itys + +[] +/// Indicates whether we should visit multiple instantiations of the same generic interface or not +type AllowMultiIntfInstantiations = Yes | No + +/// Traverse the type hierarchy, e.g. f D (f C (f System.Object acc)). +/// Visit base types and interfaces first. +let private FoldHierarchyOfTypeAux followInterfaces allowMultiIntfInst skipUnref visitor g amap m ty acc = + let rec loop ndeep ty ((visitedTycon, visited: TyconRefMultiMap<_>, acc) as state) = + + let seenThisTycon = + match tryTcrefOfAppTy g ty with + | ValueSome tcref -> Set.contains tcref.Stamp visitedTycon + | _ -> false + + // Do not visit the same type twice. Could only be doing this if we've seen this tycon + if seenThisTycon && List.exists (typeEquiv g ty) (visited.Find (tcrefOfAppTy g ty)) then state else + + // Do not visit the same tycon twice, e.g. I and I, collect I only, unless directed to allow this + if seenThisTycon && allowMultiIntfInst = AllowMultiIntfInstantiations.No then state else + + let state = + match tryTcrefOfAppTy g ty with + | ValueSome tcref -> + let visitedTycon = Set.add tcref.Stamp visitedTycon + visitedTycon, visited.Add (tcref, ty), acc + | _ -> + state + + if ndeep > 100 then (errorR(Error((FSComp.SR.recursiveClassHierarchy (showType ty)), m)); (visitedTycon, visited, acc)) else + let visitedTycon, visited, acc = + if isInterfaceTy g ty then + List.foldBack + (loop (ndeep+1)) + (GetImmediateInterfacesOfType skipUnref g amap m ty) + (loop ndeep g.obj_ty state) + else + match tryDestTyparTy g ty with + | ValueSome tp -> + let state = loop (ndeep+1) g.obj_ty state + List.foldBack + (fun x vacc -> + match x with + | TyparConstraint.MayResolveMember _ + | TyparConstraint.DefaultsTo _ + | TyparConstraint.SupportsComparison _ + | TyparConstraint.SupportsEquality _ + | TyparConstraint.IsEnum _ + | TyparConstraint.IsDelegate _ + | TyparConstraint.SupportsNull _ + | TyparConstraint.IsNonNullableStruct _ + | TyparConstraint.IsUnmanaged _ + | TyparConstraint.IsReferenceType _ + | TyparConstraint.SimpleChoice _ + | TyparConstraint.RequiresDefaultConstructor _ -> vacc + | TyparConstraint.CoercesTo(cty, _) -> + loop (ndeep + 1) cty vacc) + tp.Constraints + state + | _ -> + let state = + if followInterfaces then + List.foldBack + (loop (ndeep+1)) + (GetImmediateInterfacesOfType skipUnref g amap m ty) + state + else + state + let state = + Option.foldBack + (loop (ndeep+1)) + (GetSuperTypeOfType g amap m ty) + state + state + let acc = visitor ty acc + (visitedTycon, visited, acc) + loop 0 ty (Set.empty, TyconRefMultiMap<_>.Empty, acc) |> p33 + +/// Fold, do not follow interfaces (unless the type is itself an interface) +let FoldPrimaryHierarchyOfType f g amap m allowMultiIntfInst ty acc = + FoldHierarchyOfTypeAux false allowMultiIntfInst SkipUnrefInterfaces.No f g amap m ty acc + +/// Fold, following interfaces. Skipping interfaces that lie outside the referenced assembly set is allowed. +let FoldEntireHierarchyOfType f g amap m allowMultiIntfInst ty acc = + FoldHierarchyOfTypeAux true allowMultiIntfInst SkipUnrefInterfaces.Yes f g amap m ty acc + +/// Iterate, following interfaces. Skipping interfaces that lie outside the referenced assembly set is allowed. +let IterateEntireHierarchyOfType f g amap m allowMultiIntfInst ty = + FoldHierarchyOfTypeAux true allowMultiIntfInst SkipUnrefInterfaces.Yes (fun ty () -> f ty) g amap m ty () + +/// Search for one element satisfying a predicate, following interfaces +let ExistsInEntireHierarchyOfType f g amap m allowMultiIntfInst ty = + FoldHierarchyOfTypeAux true allowMultiIntfInst SkipUnrefInterfaces.Yes (fun ty acc -> acc || f ty ) g amap m ty false + +/// Search for one element where a function returns a 'Some' result, following interfaces +let SearchEntireHierarchyOfType f g amap m ty = + FoldHierarchyOfTypeAux true AllowMultiIntfInstantiations.Yes SkipUnrefInterfaces.Yes + (fun ty acc -> + match acc with + | None -> if f ty then Some ty else None + | Some _ -> acc) + g amap m ty None + +/// Get all super types of the type, including the type itself +let AllSuperTypesOfType g amap m allowMultiIntfInst ty = + FoldHierarchyOfTypeAux true allowMultiIntfInst SkipUnrefInterfaces.No (ListSet.insert (typeEquiv g)) g amap m ty [] + +/// Get all interfaces of a type, including the type itself if it is an interface +let AllInterfacesOfType g amap m allowMultiIntfInst ty = + AllSuperTypesOfType g amap m allowMultiIntfInst ty |> List.filter (isInterfaceTy g) + +/// Check if two types have the same nominal head type +let HaveSameHeadType g ty1 ty2 = + match tryTcrefOfAppTy g ty1 with + | ValueSome tcref1 -> + match tryTcrefOfAppTy g ty2 with + | ValueSome tcref2 -> tyconRefEq g tcref1 tcref2 + | _ -> false + | _ -> false + +/// Check if a type has a particular head type +let HasHeadType g tcref ty2 = + match tryTcrefOfAppTy g ty2 with + | ValueSome tcref2 -> tyconRefEq g tcref tcref2 + | ValueNone -> false + +/// Check if a type exists somewhere in the hierarchy which has the same head type as the given type (note, the given type need not have a head type at all) +let ExistsSameHeadTypeInHierarchy g amap m typeToSearchFrom typeToLookFor = + ExistsInEntireHierarchyOfType (HaveSameHeadType g typeToLookFor) g amap m AllowMultiIntfInstantiations.Yes typeToSearchFrom + +/// Check if a type exists somewhere in the hierarchy which has the given head type. +let ExistsHeadTypeInEntireHierarchy g amap m typeToSearchFrom tcrefToLookFor = + ExistsInEntireHierarchyOfType (HasHeadType g tcrefToLookFor) g amap m AllowMultiIntfInstantiations.Yes typeToSearchFrom + + +/// Read an Abstract IL type from metadata and convert to an F# type. +let ImportILTypeFromMetadata amap m scoref tinst minst ilty = + ImportILType scoref amap m (tinst@minst) ilty + +/// Read an Abstract IL type from metadata, including any attributes that may affect the type itself, and convert to an F# type. +let ImportILTypeFromMetadataWithAttributes amap m scoref tinst minst ilty cattrs = + let ty = ImportILType scoref amap m (tinst@minst) ilty + // If the type is a byref and one of attributes from a return or parameter has IsReadOnly, then it's a inref. + if isByrefTy amap.g ty && TryFindILAttribute amap.g.attrib_IsReadOnlyAttribute cattrs then + mkInByrefTy amap.g (destByrefTy amap.g ty) + else + ty + +/// Get the parameter type of an IL method. +let ImportParameterTypeFromMetadata amap m ilty cattrs scoref tinst mist = + ImportILTypeFromMetadataWithAttributes amap m scoref tinst mist ilty cattrs + +/// Get the return type of an IL method, taking into account instantiations for type, return attributes and method generic parameters, and +/// translating 'void' to 'None'. +let ImportReturnTypeFromMetadata amap m ilty cattrs scoref tinst minst = + match ilty with + | ILType.Void -> None + | retTy -> Some(ImportILTypeFromMetadataWithAttributes amap m scoref tinst minst retTy cattrs) + + +/// Copy constraints. If the constraint comes from a type parameter associated +/// with a type constructor then we are simply renaming type variables. If it comes +/// from a generic method in a generic class (e.g. ty.M<_>) then we may be both substituting the +/// instantiation associated with 'ty' as well as copying the type parameters associated with +/// M and instantiating their constraints +/// +/// Note: this now looks identical to constraint instantiation. + +let CopyTyparConstraints m tprefInst (tporig: Typar) = + tporig.Constraints + |> List.map (fun tpc -> + match tpc with + | TyparConstraint.CoercesTo(ty, _) -> + TyparConstraint.CoercesTo (instType tprefInst ty, m) + | TyparConstraint.DefaultsTo(priority, ty, _) -> + TyparConstraint.DefaultsTo (priority, instType tprefInst ty, m) + | TyparConstraint.SupportsNull _ -> + TyparConstraint.SupportsNull m + | TyparConstraint.IsEnum (uty, _) -> + TyparConstraint.IsEnum (instType tprefInst uty, m) + | TyparConstraint.SupportsComparison _ -> + TyparConstraint.SupportsComparison m + | TyparConstraint.SupportsEquality _ -> + TyparConstraint.SupportsEquality m + | TyparConstraint.IsDelegate(aty, bty, _) -> + TyparConstraint.IsDelegate (instType tprefInst aty, instType tprefInst bty, m) + | TyparConstraint.IsNonNullableStruct _ -> + TyparConstraint.IsNonNullableStruct m + | TyparConstraint.IsUnmanaged _ -> + TyparConstraint.IsUnmanaged m + | TyparConstraint.IsReferenceType _ -> + TyparConstraint.IsReferenceType m + | TyparConstraint.SimpleChoice (tys, _) -> + TyparConstraint.SimpleChoice (List.map (instType tprefInst) tys, m) + | TyparConstraint.RequiresDefaultConstructor _ -> + TyparConstraint.RequiresDefaultConstructor m + | TyparConstraint.MayResolveMember(traitInfo, _) -> + TyparConstraint.MayResolveMember (instTrait tprefInst traitInfo, m)) + +/// The constraints for each typar copied from another typar can only be fixed up once +/// we have generated all the new constraints, e.g. f List, B :> List> ... +let FixupNewTypars m (formalEnclosingTypars: Typars) (tinst: TType list) (tpsorig: Typars) (tps: Typars) = + // Checks.. These are defensive programming against early reported errors. + let n0 = formalEnclosingTypars.Length + let n1 = tinst.Length + let n2 = tpsorig.Length + let n3 = tps.Length + if n0 <> n1 then error(Error((FSComp.SR.tcInvalidTypeArgumentCount(n0, n1)), m)) + if n2 <> n3 then error(Error((FSComp.SR.tcInvalidTypeArgumentCount(n2, n3)), m)) + + // The real code.. + let renaming, tptys = mkTyparToTyparRenaming tpsorig tps + let tprefInst = mkTyparInst formalEnclosingTypars tinst @ renaming + (tpsorig, tps) ||> List.iter2 (fun tporig tp -> tp.SetConstraints (CopyTyparConstraints m tprefInst tporig)) + renaming, tptys + + +//------------------------------------------------------------------------- +// Predicates and properties on values and members + + +type ValRef with + /// Indicates if an F#-declared function or member value is a CLIEvent property compiled as a .NET event + member x.IsFSharpEventProperty g = + x.IsMember && CompileAsEvent g x.Attribs && not x.IsExtensionMember + + /// Check if an F#-declared member value is a virtual method + member vref.IsVirtualMember = + let flags = vref.MemberInfo.Value.MemberFlags + flags.IsDispatchSlot || flags.IsOverrideOrExplicitImpl + + /// Check if an F#-declared member value is a dispatch slot + member vref.IsDispatchSlotMember = + let membInfo = vref.MemberInfo.Value + membInfo.MemberFlags.IsDispatchSlot + + /// Check if an F#-declared member value is an 'override' or explicit member implementation + member vref.IsDefiniteFSharpOverrideMember = + let membInfo = vref.MemberInfo.Value + let flags = membInfo.MemberFlags + not flags.IsDispatchSlot && (flags.IsOverrideOrExplicitImpl || not (isNil membInfo.ImplementedSlotSigs)) + + /// Check if an F#-declared member value is an explicit interface member implementation + member vref.IsFSharpExplicitInterfaceImplementation g = + match vref.MemberInfo with + | None -> false + | Some membInfo -> + not membInfo.MemberFlags.IsDispatchSlot && + (match membInfo.ImplementedSlotSigs with + | TSlotSig(_, oty, _, _, _, _) :: _ -> isInterfaceTy g oty + | [] -> false) + + member vref.ImplementedSlotSignatures = + match vref.MemberInfo with + | None -> [] + | Some membInfo -> membInfo.ImplementedSlotSigs + +//------------------------------------------------------------------------- +// Helper methods associated with using TAST metadata (F# members, values etc.) +// as backing data for MethInfo, PropInfo etc. + + +#if !NO_EXTENSIONTYPING +/// Get the return type of a provided method, where 'void' is returned as 'None' +let GetCompiledReturnTyOfProvidedMethodInfo amap m (mi: Tainted) = + let returnType = + if mi.PUntaint((fun mi -> mi.IsConstructor), m) then + mi.PApply((fun mi -> mi.DeclaringType), m) + else mi.Coerce(m).PApply((fun mi -> mi.ReturnType), m) + let ty = Import.ImportProvidedType amap m returnType + if isVoidTy amap.g ty then None else Some ty +#endif + +/// The slotsig returned by methInfo.GetSlotSig is in terms of the type parameters on the parent type of the overriding method. +/// Reverse-map the slotsig so it is in terms of the type parameters for the overriding method +let ReparentSlotSigToUseMethodTypars g m ovByMethValRef slotsig = + match PartitionValRefTypars g ovByMethValRef with + | Some(_, enclosingTypars, _, _, _) -> + let parentToMemberInst, _ = mkTyparToTyparRenaming (ovByMethValRef.MemberApparentEntity.Typars m) enclosingTypars + let res = instSlotSig parentToMemberInst slotsig + res + | None -> + // Note: it appears PartitionValRefTypars should never return 'None' + slotsig + + +/// Construct the data representing a parameter in the signature of an abstract method slot +let MakeSlotParam (ty, argInfo: ArgReprInfo) = TSlotParam(Option.map textOfId argInfo.Name, ty, false, false, false, argInfo.Attribs) + +/// Construct the data representing the signature of an abstract method slot +let MakeSlotSig (nm, ty, ctps, mtps, paraml, retTy) = copySlotSig (TSlotSig(nm, ty, ctps, mtps, paraml, retTy)) + + +/// Split the type of an F# member value into +/// - the type parameters associated with method but matching those of the enclosing type +/// - the type parameters associated with a generic method +/// - the return type of the method +/// - the actual type arguments of the enclosing type. +let private AnalyzeTypeOfMemberVal isCSharpExt g (ty, vref: ValRef) = + let memberAllTypars, _, _, retTy, _ = GetTypeOfMemberInMemberForm g vref + if isCSharpExt || vref.IsExtensionMember then + [], memberAllTypars, retTy, [] + else + let parentTyArgs = argsOfAppTy g ty + let memberParentTypars, memberMethodTypars = List.splitAt parentTyArgs.Length memberAllTypars + memberParentTypars, memberMethodTypars, retTy, parentTyArgs + +/// Get the object type for a member value which is an extension method (C#-style or F#-style) +let private GetObjTypeOfInstanceExtensionMethod g (vref: ValRef) = + let numEnclosingTypars = CountEnclosingTyparsOfActualParentOfVal vref.Deref + let _, _, curriedArgInfos, _, _ = GetTopValTypeInCompiledForm g vref.ValReprInfo.Value numEnclosingTypars vref.Type vref.Range + curriedArgInfos.Head.Head |> fst + +/// Get the object type for a member value, which might be a C#-style extension method +let private GetArgInfosOfMember isCSharpExt g (vref: ValRef) = + if isCSharpExt then + let numEnclosingTypars = CountEnclosingTyparsOfActualParentOfVal vref.Deref + let _, _, curriedArgInfos, _, _ = GetTopValTypeInCompiledForm g vref.ValReprInfo.Value numEnclosingTypars vref.Type vref.Range + [ curriedArgInfos.Head.Tail ] + else + ArgInfosOfMember g vref + +/// Combine the type instantiation and generic method instantiation +let private CombineMethInsts ttps mtps tinst minst = (mkTyparInst ttps tinst @ mkTyparInst mtps minst) + +/// Work out the instantiation relevant to interpret the backing metadata for a member. +/// +/// The 'methTyArgs' is the instantiation of any generic method type parameters (this instantiation is +/// not included in the MethInfo objects, but carried separately). +let private GetInstantiationForMemberVal g isCSharpExt (ty, vref, methTyArgs: TypeInst) = + let memberParentTypars, memberMethodTypars, _retTy, parentTyArgs = AnalyzeTypeOfMemberVal isCSharpExt g (ty, vref) + /// In some recursive inference cases involving constraints this may need to be + /// fixed up - we allow uniform generic recursion but nothing else. + /// See https://github.com/Microsoft/visualfsharp/issues/3038#issuecomment-309429410 + let methTyArgsFixedUp = + if methTyArgs.Length < memberMethodTypars.Length then + methTyArgs @ (List.skip methTyArgs.Length memberMethodTypars |> generalizeTypars) + else + methTyArgs + CombineMethInsts memberParentTypars memberMethodTypars parentTyArgs methTyArgsFixedUp + +/// Work out the instantiation relevant to interpret the backing metadata for a property. +let private GetInstantiationForPropertyVal g (ty, vref) = + let memberParentTypars, memberMethodTypars, _retTy, parentTyArgs = AnalyzeTypeOfMemberVal false g (ty, vref) + CombineMethInsts memberParentTypars memberMethodTypars parentTyArgs (generalizeTypars memberMethodTypars) + +/// Describes the sequence order of the introduction of an extension method. Extension methods that are introduced +/// later through 'open' get priority in overload resolution. +type ExtensionMethodPriority = uint64 + +//------------------------------------------------------------------------- +// OptionalArgCallerSideValue, OptionalArgInfo + +/// The caller-side value for the optional arg, if any +type OptionalArgCallerSideValue = + | Constant of IL.ILFieldInit + | DefaultValue + | MissingValue + | WrapperForIDispatch + | WrapperForIUnknown + | PassByRef of TType * OptionalArgCallerSideValue + +/// Represents information about a parameter indicating if it is optional. +type OptionalArgInfo = + /// The argument is not optional + | NotOptional + /// The argument is optional, and is an F# callee-side optional arg + | CalleeSide + /// The argument is optional, and is a caller-side .NET optional or default arg. + /// Note this is correctly termed caller side, even though the default value is optically specified on the callee: + /// in fact the default value is read from the metadata and passed explicitly to the callee on the caller side. + | CallerSide of OptionalArgCallerSideValue + member x.IsOptional = match x with CalleeSide | CallerSide _ -> true | NotOptional -> false + + /// Compute the OptionalArgInfo for an IL parameter + /// + /// This includes the Visual Basic rules for IDispatchConstant and IUnknownConstant and optional arguments. + static member FromILParameter g amap m ilScope ilTypeInst (ilParam: ILParameter) = + if ilParam.IsOptional then + match ilParam.Default with + | None -> + // Do a type-directed analysis of the IL type to determine the default value to pass. + // The same rules as Visual Basic are applied here. + let rec analyze ty = + if isByrefTy g ty then + let ty = destByrefTy g ty + PassByRef (ty, analyze ty) + elif isObjTy g ty then + match ilParam.Marshal with + | Some(ILNativeType.IUnknown | ILNativeType.IDispatch | ILNativeType.Interface) -> Constant ILFieldInit.Null + | _ -> + if TryFindILAttributeOpt g.attrib_IUnknownConstantAttribute ilParam.CustomAttrs then WrapperForIUnknown + elif TryFindILAttributeOpt g.attrib_IDispatchConstantAttribute ilParam.CustomAttrs then WrapperForIDispatch + else MissingValue + else + DefaultValue + CallerSide (analyze (ImportILTypeFromMetadata amap m ilScope ilTypeInst [] ilParam.Type)) + | Some v -> + CallerSide (Constant v) + else + NotOptional + + static member ValueOfDefaultParameterValueAttrib (Attrib (_, _, exprs, _, _, _, _)) = + let (AttribExpr (_, defaultValueExpr)) = List.head exprs + match defaultValueExpr with + | Expr.Const (_, _, _) -> Some defaultValueExpr + | _ -> None + static member FieldInitForDefaultParameterValueAttrib attrib = + match OptionalArgInfo.ValueOfDefaultParameterValueAttrib attrib with + | Some (Expr.Const (ConstToILFieldInit fi, _, _)) -> Some fi + | _ -> None + +type CallerInfo = + | NoCallerInfo + | CallerLineNumber + | CallerMemberName + | CallerFilePath + + override x.ToString() = sprintf "%+A" x + +[] +type ReflectedArgInfo = + | None + | Quote of bool + member x.AutoQuote = match x with None -> false | Quote _ -> true + +//------------------------------------------------------------------------- +// ParamNameAndType, ParamData + +[] +/// Partial information about a parameter returned for use by the Language Service +type ParamNameAndType = + | ParamNameAndType of Ident option * TType + + static member FromArgInfo (ty, argInfo : ArgReprInfo) = ParamNameAndType(argInfo.Name, ty) + static member FromMember isCSharpExtMem g vref = GetArgInfosOfMember isCSharpExtMem g vref |> List.mapSquared ParamNameAndType.FromArgInfo + static member Instantiate inst p = let (ParamNameAndType(nm, ty)) = p in ParamNameAndType(nm, instType inst ty) + static member InstantiateCurried inst paramTypes = paramTypes |> List.mapSquared (ParamNameAndType.Instantiate inst) + +[] +/// Full information about a parameter returned for use by the type checker and language service. +type ParamData = + ParamData of isParamArray: bool * isInArg: bool * isOut: bool * optArgInfo: OptionalArgInfo * callerInfo: CallerInfo * nameOpt: Ident option * reflArgInfo: ReflectedArgInfo * ttype: TType + + +//------------------------------------------------------------------------- +// Helper methods associated with type providers + +#if !NO_EXTENSIONTYPING + +type ILFieldInit with + /// Compute the ILFieldInit for the given provided constant value for a provided enum type. + static member FromProvidedObj m (v: obj) = + match v with + | null -> ILFieldInit.Null + | _ -> + let objTy = v.GetType() + let v = if objTy.IsEnum then objTy.GetField("value__").GetValue v else v + match v with + | :? single as i -> ILFieldInit.Single i + | :? double as i -> ILFieldInit.Double i + | :? bool as i -> ILFieldInit.Bool i + | :? char as i -> ILFieldInit.Char (uint16 i) + | :? string as i -> ILFieldInit.String i + | :? sbyte as i -> ILFieldInit.Int8 i + | :? byte as i -> ILFieldInit.UInt8 i + | :? int16 as i -> ILFieldInit.Int16 i + | :? uint16 as i -> ILFieldInit.UInt16 i + | :? int as i -> ILFieldInit.Int32 i + | :? uint32 as i -> ILFieldInit.UInt32 i + | :? int64 as i -> ILFieldInit.Int64 i + | :? uint64 as i -> ILFieldInit.UInt64 i + | _ -> error(Error(FSComp.SR.infosInvalidProvidedLiteralValue(try v.ToString() with _ -> "?"), m)) + + +/// Compute the OptionalArgInfo for a provided parameter. +/// +/// This is the same logic as OptionalArgInfoOfILParameter except we do not apply the +/// Visual Basic rules for IDispatchConstant and IUnknownConstant to optional +/// provided parameters. +let OptionalArgInfoOfProvidedParameter (amap: Import.ImportMap) m (provParam : Tainted) = + let g = amap.g + if provParam.PUntaint((fun p -> p.IsOptional), m) then + match provParam.PUntaint((fun p -> p.HasDefaultValue), m) with + | false -> + // Do a type-directed analysis of the IL type to determine the default value to pass. + let rec analyze ty = + if isByrefTy g ty then + let ty = destByrefTy g ty + PassByRef (ty, analyze ty) + elif isObjTy g ty then MissingValue + else DefaultValue + + let pty = Import.ImportProvidedType amap m (provParam.PApply((fun p -> p.ParameterType), m)) + CallerSide (analyze pty) + | _ -> + let v = provParam.PUntaint((fun p -> p.RawDefaultValue), m) + CallerSide (Constant (ILFieldInit.FromProvidedObj m v)) + else + NotOptional + +/// Compute the ILFieldInit for the given provided constant value for a provided enum type. +let GetAndSanityCheckProviderMethod m (mi: Tainted<'T :> ProvidedMemberInfo>) (get : 'T -> ProvidedMethodInfo) err = + match mi.PApply((fun mi -> (get mi :> ProvidedMethodBase)), m) with + | Tainted.Null -> error(Error(err(mi.PUntaint((fun mi -> mi.Name), m), mi.PUntaint((fun mi -> mi.DeclaringType.Name), m)), m)) + | meth -> meth + +/// Try to get an arbitrary ProvidedMethodInfo associated with a property. +let ArbitraryMethodInfoOfPropertyInfo (pi: Tainted) m = + if pi.PUntaint((fun pi -> pi.CanRead), m) then + GetAndSanityCheckProviderMethod m pi (fun pi -> pi.GetGetMethod()) FSComp.SR.etPropertyCanReadButHasNoGetter + elif pi.PUntaint((fun pi -> pi.CanWrite), m) then + GetAndSanityCheckProviderMethod m pi (fun pi -> pi.GetSetMethod()) FSComp.SR.etPropertyCanWriteButHasNoSetter + else + error(Error(FSComp.SR.etPropertyNeedsCanWriteOrCanRead(pi.PUntaint((fun mi -> mi.Name), m), pi.PUntaint((fun mi -> mi.DeclaringType.Name), m)), m)) + +#endif + + +//------------------------------------------------------------------------- +// ILTypeInfo + +/// Describes an F# use of an IL type, including the type instantiation associated with the type at a particular usage point. +/// +/// This is really just 1:1 with the subset ot TType which result from building types using IL type definitions. +[] +type ILTypeInfo = + /// ILTypeInfo (tyconRef, ilTypeRef, typeArgs, ilTypeDef). + | ILTypeInfo of TcGlobals * TType * ILTypeRef * ILTypeDef + + member x.TcGlobals = let (ILTypeInfo(g, _, _, _)) = x in g + + member x.ILTypeRef = let (ILTypeInfo(_, _, tref, _)) = x in tref + + member x.RawMetadata = let (ILTypeInfo(_, _, _, tdef)) = x in tdef + + member x.ToType = let (ILTypeInfo(_, ty, _, _)) = x in ty + + /// Get the compiled nominal type. In the case of tuple types, this is a .NET tuple type + member x.ToAppType = convertToTypeWithMetadataIfPossible x.TcGlobals x.ToType + + member x.TyconRefOfRawMetadata = tcrefOfAppTy x.TcGlobals x.ToAppType + + member x.TypeInstOfRawMetadata = argsOfAppTy x.TcGlobals x.ToAppType + + member x.ILScopeRef = x.ILTypeRef.Scope + + member x.Name = x.ILTypeRef.Name + + member x.IsValueType = x.RawMetadata.IsStructOrEnum + + member x.Instantiate inst = + let (ILTypeInfo(g, ty, tref, tdef)) = x + ILTypeInfo(g, instType inst ty, tref, tdef) + + static member FromType g ty = + if isAnyTupleTy g ty then + // When getting .NET metadata for the properties and methods + // of an F# tuple type, use the compiled nominal type, which is a .NET tuple type + let metadataTy = convertToTypeWithMetadataIfPossible g ty + assert (isILAppTy g metadataTy) + let metadataTyconRef = tcrefOfAppTy g metadataTy + let (TILObjectReprData(scoref, enc, tdef)) = metadataTyconRef.ILTyconInfo + let metadataILTypeRef = mkRefForNestedILTypeDef scoref (enc, tdef) + ILTypeInfo(g, ty, metadataILTypeRef, tdef) + elif isILAppTy g ty then + let tcref = tcrefOfAppTy g ty + let (TILObjectReprData(scoref, enc, tdef)) = tcref.ILTyconInfo + let tref = mkRefForNestedILTypeDef scoref (enc, tdef) + ILTypeInfo(g, ty, tref, tdef) + else + failwith "ILTypeInfo.FromType - no IL metadata for type" + +//------------------------------------------------------------------------- +// ILMethInfo + + +/// Describes an F# use of an IL method. +[] +type ILMethInfo = + /// ILMethInfo(g, ilApparentType, ilDeclaringTyconRefOpt, ilMethodDef, ilGenericMethodTyArgs) + /// + /// Describes an F# use of an IL method. + /// + /// If ilDeclaringTyconRefOpt is 'Some' then this is an F# use of an C#-style extension method. + /// If ilDeclaringTyconRefOpt is 'None' then ilApparentType is an IL type definition. + | ILMethInfo of TcGlobals * TType * TyconRef option * ILMethodDef * Typars + + member x.TcGlobals = match x with ILMethInfo(g, _, _, _, _) -> g + + /// Get the apparent declaring type of the method as an F# type. + /// If this is a C#-style extension method then this is the type which the method + /// appears to extend. This may be a variable type. + member x.ApparentEnclosingType = match x with ILMethInfo(_, ty, _, _, _) -> ty + + /// Like ApparentEnclosingType but use the compiled nominal type if this is a method on a tuple type + member x.ApparentEnclosingAppType = convertToTypeWithMetadataIfPossible x.TcGlobals x.ApparentEnclosingType + + /// Get the declaring type associated with an extension member, if any. + member x.ILExtensionMethodDeclaringTyconRef = match x with ILMethInfo(_, _, tcrefOpt, _, _) -> tcrefOpt + + /// Get the Abstract IL metadata associated with the method. + member x.RawMetadata = match x with ILMethInfo(_, _, _, md, _) -> md + + /// Get the formal method type parameters associated with a method. + member x.FormalMethodTypars = match x with ILMethInfo(_, _, _, _, fmtps) -> fmtps + + /// Get the IL name of the method + member x.ILName = x.RawMetadata.Name + + /// Indicates if the method is an extension method + member x.IsILExtensionMethod = x.ILExtensionMethodDeclaringTyconRef.IsSome + + /// Get the declaring type of the method. If this is an C#-style extension method then this is the IL type + /// holding the static member that is the extension method. + member x.DeclaringTyconRef = + match x.ILExtensionMethodDeclaringTyconRef with + | Some tcref -> tcref + | None -> tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + + /// Get the instantiation of the declaring type of the method. + /// If this is an C#-style extension method then this is empty because extension members + /// are never in generic classes. + member x.DeclaringTypeInst = + if x.IsILExtensionMethod then [] + else argsOfAppTy x.TcGlobals x.ApparentEnclosingAppType + + /// Get the Abstract IL scope information associated with interpreting the Abstract IL metadata that backs this method. + member x.MetadataScope = x.DeclaringTyconRef.CompiledRepresentationForNamedType.Scope + + /// Get the Abstract IL metadata corresponding to the parameters of the method. + /// If this is an C#-style extension method then drop the object argument. + member x.ParamMetadata = + let ps = x.RawMetadata.Parameters + if x.IsILExtensionMethod then List.tail ps else ps + + /// Get the number of parameters of the method + member x.NumParams = x.ParamMetadata.Length + + /// Indicates if the method is a constructor + member x.IsConstructor = x.RawMetadata.IsConstructor + + /// Indicates if the method is a class initializer. + member x.IsClassConstructor = x.RawMetadata.IsClassInitializer + + /// Indicates if the method has protected accessibility, + member x.IsProtectedAccessibility = + let md = x.RawMetadata + not md.IsConstructor && + not md.IsClassInitializer && + (md.Access = ILMemberAccess.Family || md.Access = ILMemberAccess.FamilyOrAssembly) + + /// Indicates if the IL method is marked virtual. + member x.IsVirtual = x.RawMetadata.IsVirtual + + /// Indicates if the IL method is marked final. + member x.IsFinal = x.RawMetadata.IsFinal + + /// Indicates if the IL method is marked abstract. + member x.IsAbstract = x.RawMetadata.IsAbstract + + /// Does it appear to the user as a static method? + member x.IsStatic = + not x.IsILExtensionMethod && // all C#-declared extension methods are instance + x.RawMetadata.CallingConv.IsStatic + + /// Does it have the .NET IL 'newslot' flag set, and is also a virtual? + member x.IsNewSlot = x.RawMetadata.IsNewSlot + + /// Does it appear to the user as an instance method? + member x.IsInstance = not x.IsConstructor && not x.IsStatic + + /// Get the argument types of the the IL method. If this is an C#-style extension method + /// then drop the object argument. + member x.GetParamTypes(amap, m, minst) = + x.ParamMetadata |> List.map (fun p -> ImportParameterTypeFromMetadata amap m p.Type p.CustomAttrs x.MetadataScope x.DeclaringTypeInst minst) + + /// Get all the argument types of the IL method. Include the object argument even if this is + /// an C#-style extension method. + member x.GetRawArgTypes(amap, m, minst) = + x.RawMetadata.Parameters |> List.map (fun p -> ImportParameterTypeFromMetadata amap m p.Type p.CustomAttrs x.MetadataScope x.DeclaringTypeInst minst) + + /// Get info about the arguments of the IL method. If this is an C#-style extension method then + /// drop the object argument. + /// + /// Any type parameters of the enclosing type are instantiated in the type returned. + member x.GetParamNamesAndTypes(amap, m, minst) = + x.ParamMetadata |> List.map (fun p -> ParamNameAndType(Option.map (mkSynId m) p.Name, ImportParameterTypeFromMetadata amap m p.Type p.CustomAttrs x.MetadataScope x.DeclaringTypeInst minst) ) + + /// Get a reference to the method (dropping all generic instantiations), as an Abstract IL ILMethodRef. + member x.ILMethodRef = + let mref = mkRefToILMethod (x.DeclaringTyconRef.CompiledRepresentationForNamedType, x.RawMetadata) + rescopeILMethodRef x.MetadataScope mref + + /// Indicates if the method is marked as a DllImport (a PInvoke). This is done by looking at the IL custom attributes on + /// the method. + member x.IsDllImport (g: TcGlobals) = + match g.attrib_DllImportAttribute with + | None -> false + | Some attr -> + x.RawMetadata.CustomAttrs + |> TryFindILAttribute attr + + /// Indicates if the method is marked with the [] attribute. This is done by looking at the IL custom attributes on + /// the method. + member x.IsReadOnly (g: TcGlobals) = + x.RawMetadata.CustomAttrs + |> TryFindILAttribute g.attrib_IsReadOnlyAttribute + + /// Get the (zero or one) 'self'/'this'/'object' arguments associated with an IL method. + /// An instance extension method returns one object argument. + member x.GetObjArgTypes(amap, m, minst) = + // All C#-style extension methods are instance. We have to re-read the 'obj' type w.r.t. the + // method instantiation. + if x.IsILExtensionMethod then + let p = x.RawMetadata.Parameters.Head + [ ImportParameterTypeFromMetadata amap m p.Type p.CustomAttrs x.MetadataScope x.DeclaringTypeInst minst ] + else if x.IsInstance then + [ x.ApparentEnclosingType ] + else + [] + + /// Get the compiled return type of the method, where 'void' is None. + member x.GetCompiledReturnTy (amap, m, minst) = + ImportReturnTypeFromMetadata amap m x.RawMetadata.Return.Type x.RawMetadata.Return.CustomAttrs x.MetadataScope x.DeclaringTypeInst minst + + /// Get the F# view of the return type of the method, where 'void' is 'unit'. + member x.GetFSharpReturnTy (amap, m, minst) = + x.GetCompiledReturnTy(amap, m, minst) + |> GetFSharpViewOfReturnType amap.g + +//------------------------------------------------------------------------- +// MethInfo + + +[] +/// Describes an F# use of a method +[] +type MethInfo = + /// FSMeth(tcGlobals, enclosingType, valRef, extensionMethodPriority). + /// + /// Describes a use of a method declared in F# code and backed by F# metadata. + | FSMeth of TcGlobals * TType * ValRef * ExtensionMethodPriority option + + /// ILMeth(tcGlobals, ilMethInfo, extensionMethodPriority). + /// + /// Describes a use of a method backed by Abstract IL # metadata + | ILMeth of TcGlobals * ILMethInfo * ExtensionMethodPriority option + + /// Describes a use of a pseudo-method corresponding to the default constructor for a .NET struct type + | DefaultStructCtor of TcGlobals * TType + +#if !NO_EXTENSIONTYPING + /// Describes a use of a method backed by provided metadata + | ProvidedMeth of Import.ImportMap * Tainted * ExtensionMethodPriority option * range +#endif + + /// Get the enclosing type of the method info. + /// + /// If this is an extension member, then this is the apparent parent, i.e. the type the method appears to extend. + /// This may be a variable type. + member x.ApparentEnclosingType = + match x with + | ILMeth(_, ilminfo, _) -> ilminfo.ApparentEnclosingType + | FSMeth(_, ty, _, _) -> ty + | DefaultStructCtor(_, ty) -> ty +#if !NO_EXTENSIONTYPING + | ProvidedMeth(amap, mi, _, m) -> + Import.ImportProvidedType amap m (mi.PApply((fun mi -> mi.DeclaringType), m)) +#endif + + /// Get the enclosing type of the method info, using a nominal type for tuple types + member x.ApparentEnclosingAppType = + convertToTypeWithMetadataIfPossible x.TcGlobals x.ApparentEnclosingType + + member x.ApparentEnclosingTyconRef = + tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + + /// Get the declaring type or module holding the method. If this is an C#-style extension method then this is the type + /// holding the static member that is the extension method. If this is an F#-style extension method it is the logical module + /// holding the value for the extension method. + member x.DeclaringTyconRef = + match x with + | ILMeth(_, ilminfo, _) when x.IsExtensionMember -> ilminfo.DeclaringTyconRef + | FSMeth(_, _, vref, _) when x.IsExtensionMember && vref.HasDeclaringEntity -> vref.TopValDeclaringEntity + | _ -> x.ApparentEnclosingTyconRef + + /// Get the information about provided static parameters, if any + member x.ProvidedStaticParameterInfo = + match x with + | ILMeth _ -> None + | FSMeth _ -> None +#if !NO_EXTENSIONTYPING + | ProvidedMeth (_, mb, _, m) -> + let staticParams = mb.PApplyWithProvider((fun (mb, provider) -> mb.GetStaticParametersForMethod provider), range=m) + let staticParams = staticParams.PApplyArray(id, "GetStaticParametersForMethod", m) + match staticParams with + | [| |] -> None + | _ -> Some (mb, staticParams) +#endif + | DefaultStructCtor _ -> None + + + /// Get the extension method priority of the method, if it has one. + member x.ExtensionMemberPriorityOption = + match x with + | ILMeth(_, _, pri) -> pri + | FSMeth(_, _, _, pri) -> pri +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, _, pri, _) -> pri +#endif + | DefaultStructCtor _ -> None + + /// Get the extension method priority of the method. If it is not an extension method + /// then use the highest possible value since non-extension methods always take priority + /// over extension members. + member x.ExtensionMemberPriority = defaultArg x.ExtensionMemberPriorityOption System.UInt64.MaxValue + + /// Get the method name in DebuggerDisplayForm + member x.DebuggerDisplayName = + match x with + | ILMeth(_, y, _) -> "ILMeth: " + y.ILName + | FSMeth(_, _, vref, _) -> "FSMeth: " + vref.LogicalName +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m) -> "ProvidedMeth: " + mi.PUntaint((fun mi -> mi.Name), m) +#endif + | DefaultStructCtor _ -> ".ctor" + + /// Get the method name in LogicalName form, i.e. the name as it would be stored in .NET metadata + member x.LogicalName = + match x with + | ILMeth(_, y, _) -> y.ILName + | FSMeth(_, _, vref, _) -> vref.LogicalName +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.Name), m) +#endif + | DefaultStructCtor _ -> ".ctor" + + /// Get the method name in DisplayName form + member x.DisplayName = + match x with + | FSMeth(_, _, vref, _) -> vref.DisplayName + | _ -> x.LogicalName + + /// Indicates if this is a method defined in this assembly with an internal XML comment + member x.HasDirectXmlComment = + match x with + | FSMeth(g, _, vref, _) -> valRefInThisAssembly g.compilingFslib vref +#if !NO_EXTENSIONTYPING + | ProvidedMeth _ -> true +#endif + | _ -> false + + override x.ToString() = x.ApparentEnclosingType.ToString() + x.LogicalName + + /// Get the actual type instantiation of the declaring type associated with this use of the method. + /// + /// For extension members this is empty (the instantiation of the declaring type). + member x.DeclaringTypeInst = + if x.IsExtensionMember then [] else argsOfAppTy x.TcGlobals x.ApparentEnclosingAppType + + /// Get the TcGlobals value that governs the method declaration + member x.TcGlobals = + match x with + | ILMeth(g, _, _) -> g + | FSMeth(g, _, _, _) -> g + | DefaultStructCtor (g, _) -> g +#if !NO_EXTENSIONTYPING + | ProvidedMeth(amap, _, _, _) -> amap.g +#endif + + /// Get the formal generic method parameters for the method as a list of type variables. + /// + /// For an extension method this includes all type parameters, even if it is extending a generic type. + member x.FormalMethodTypars = + match x with + | ILMeth(_, ilmeth, _) -> ilmeth.FormalMethodTypars + | FSMeth(g, _, vref, _) -> + let ty = x.ApparentEnclosingAppType + let _, memberMethodTypars, _, _ = AnalyzeTypeOfMemberVal x.IsCSharpStyleExtensionMember g (ty, vref) + memberMethodTypars + | DefaultStructCtor _ -> [] +#if !NO_EXTENSIONTYPING + | ProvidedMeth _ -> [] // There will already have been an error if there are generic parameters here. +#endif + + /// Get the formal generic method parameters for the method as a list of variable types. + member x.FormalMethodInst = generalizeTypars x.FormalMethodTypars + + member x.FormalMethodTyparInst = mkTyparInst x.FormalMethodTypars x.FormalMethodInst + + /// Get the XML documentation associated with the method + member x.XmlDoc = + match x with + | ILMeth(_, _, _) -> XmlDoc.Empty + | FSMeth(_, _, vref, _) -> vref.XmlDoc + | DefaultStructCtor _ -> XmlDoc.Empty +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m)-> + let lines = mi.PUntaint((fun mix -> (mix :> IProvidedCustomAttributeProvider).GetXmlDocAttributes(mi.TypeProvider.PUntaintNoFailure id)), m) + XmlDoc (lines, m) +#endif + + /// Try to get an arbitrary F# ValRef associated with the member. This is to determine if the member is virtual, amongst other things. + member x.ArbitraryValRef = + match x with + | FSMeth(_g, _, vref, _) -> Some vref + | _ -> None + + /// Get a list of argument-number counts, one count for each set of curried arguments. + /// + /// For an extension member, drop the 'this' argument. + member x.NumArgs = + match x with + | ILMeth(_, ilminfo, _) -> [ilminfo.NumParams] + | FSMeth(g, _, vref, _) -> GetArgInfosOfMember x.IsCSharpStyleExtensionMember g vref |> List.map List.length + | DefaultStructCtor _ -> [0] +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m) -> [mi.PUntaint((fun mi -> mi.GetParameters().Length), m)] // Why is this a list? Answer: because the method might be curried +#endif + + member x.IsCurried = x.NumArgs.Length > 1 + + /// Does the method appear to the user as an instance method? + member x.IsInstance = + match x with + | ILMeth(_, ilmeth, _) -> ilmeth.IsInstance + | FSMeth(_, _, vref, _) -> vref.IsInstanceMember || x.IsCSharpStyleExtensionMember + | DefaultStructCtor _ -> false +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> not mi.IsConstructor && not mi.IsStatic), m) +#endif + + + /// Get the number of generic method parameters for a method. + /// For an extension method this includes all type parameters, even if it is extending a generic type. + member x.GenericArity = x.FormalMethodTypars.Length + + member x.IsProtectedAccessibility = + match x with + | ILMeth(_, ilmeth, _) -> ilmeth.IsProtectedAccessibility + | FSMeth _ -> false + | DefaultStructCtor _ -> false +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsFamily), m) +#endif + + member x.IsVirtual = + match x with + | ILMeth(_, ilmeth, _) -> ilmeth.IsVirtual + | FSMeth(_, _, vref, _) -> vref.IsVirtualMember + | DefaultStructCtor _ -> false +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsVirtual), m) +#endif + + member x.IsConstructor = + match x with + | ILMeth(_, ilmeth, _) -> ilmeth.IsConstructor + | FSMeth(_g, _, vref, _) -> (vref.MemberInfo.Value.MemberFlags.MemberKind = MemberKind.Constructor) + | DefaultStructCtor _ -> true +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsConstructor), m) +#endif + + member x.IsClassConstructor = + match x with + | ILMeth(_, ilmeth, _) -> ilmeth.IsClassConstructor + | FSMeth(_, _, vref, _) -> + match vref.TryDeref with + | ValueSome x -> x.IsClassConstructor + | _ -> false + | DefaultStructCtor _ -> false +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsConstructor && mi.IsStatic), m) // Note: these are never public anyway +#endif + + member x.IsDispatchSlot = + match x with + | ILMeth(_g, ilmeth, _) -> ilmeth.IsVirtual + | FSMeth(g, _, vref, _) as x -> + isInterfaceTy g x.ApparentEnclosingType || + vref.MemberInfo.Value.MemberFlags.IsDispatchSlot + | DefaultStructCtor _ -> false +#if !NO_EXTENSIONTYPING + | ProvidedMeth _ -> x.IsVirtual // Note: follow same implementation as ILMeth +#endif + + + member x.IsFinal = + not x.IsVirtual || + match x with + | ILMeth(_, ilmeth, _) -> ilmeth.IsFinal + | FSMeth(_g, _, _vref, _) -> false + | DefaultStructCtor _ -> true +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsFinal), m) +#endif + + // This means 'is this particular MethInfo one that doesn't provide an implementation?'. + // For F# methods, this is 'true' for the MethInfos corresponding to 'abstract' declarations, + // and false for the (potentially) matching 'default' implementation MethInfos that eventually + // provide an implementation for the dispatch slot. + // + // For IL methods, this is 'true' for abstract methods, and 'false' for virtual methods + member minfo.IsAbstract = + match minfo with + | ILMeth(_, ilmeth, _) -> ilmeth.IsAbstract + | FSMeth(g, _, vref, _) -> isInterfaceTy g minfo.ApparentEnclosingType || vref.IsDispatchSlotMember + | DefaultStructCtor _ -> false +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsAbstract), m) +#endif + + member x.IsNewSlot = + (x.IsVirtual && + (match x with + | ILMeth(_, x, _) -> x.IsNewSlot + | FSMeth(_, _, vref, _) -> vref.IsDispatchSlotMember +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsHideBySig), m) // REVIEW: Check this is correct +#endif + | DefaultStructCtor _ -> false)) + + /// Indicates if this is an IL method. + member x.IsILMethod = + match x with + | ILMeth _ -> true + | _ -> false + + /// Check if this method is an explicit implementation of an interface member + member x.IsFSharpExplicitInterfaceImplementation = + match x with + | ILMeth _ -> false + | FSMeth(g, _, vref, _) -> vref.IsFSharpExplicitInterfaceImplementation g + | DefaultStructCtor _ -> false +#if !NO_EXTENSIONTYPING + | ProvidedMeth _ -> false +#endif + + /// Check if this method is marked 'override' and thus definitely overrides another method. + member x.IsDefiniteFSharpOverride = + match x with + | ILMeth _ -> false + | FSMeth(_, _, vref, _) -> vref.IsDefiniteFSharpOverrideMember + | DefaultStructCtor _ -> false +#if !NO_EXTENSIONTYPING + | ProvidedMeth _ -> false +#endif + + member x.ImplementedSlotSignatures = + match x with + | FSMeth(_, _, vref, _) -> vref.ImplementedSlotSignatures + | _ -> failwith "not supported" + + /// Indicates if this is an extension member. + member x.IsExtensionMember = + match x with + | FSMeth (_, _, vref, pri) -> pri.IsSome || vref.IsExtensionMember + | ILMeth (_, _, Some _) -> true + | _ -> false + + /// Indicates if this is an extension member (e.g. on a struct) that takes a byref arg + member x.ObjArgNeedsAddress (amap: Import.ImportMap, m) = + (x.IsStruct && not x.IsExtensionMember) || + match x.GetObjArgTypes (amap, m, x.FormalMethodInst) with + | [h] -> isByrefTy amap.g h + | _ -> false + + /// Indicates if this is an F# extension member. + member x.IsFSharpStyleExtensionMember = + match x with FSMeth (_, _, vref, _) -> vref.IsExtensionMember | _ -> false + + /// Indicates if this is an C#-style extension member. + member x.IsCSharpStyleExtensionMember = + match x with + | FSMeth (_, _, vref, Some _) -> not vref.IsExtensionMember + | ILMeth (_, _, Some _) -> true + | _ -> false + + /// Add the actual type instantiation of the apparent type of an F# extension method. + // + // When an explicit type instantiation is given for an F# extension members the type + // arguments implied by the object type are not given in source code. This means we must + // add them explicitly. For example + // type List<'T> with + // member xs.Map<'U>(f : 'T -> 'U) = .... + // is called as + // xs.Map + // but is compiled as a generic methods with two type arguments + // Map<'T, 'U>(this: List<'T>, f : 'T -> 'U) + member x.AdjustUserTypeInstForFSharpStyleIndexedExtensionMembers tyargs = + (if x.IsFSharpStyleExtensionMember then argsOfAppTy x.TcGlobals x.ApparentEnclosingAppType else []) @ tyargs + + /// Indicates if this method is a generated method associated with an F# CLIEvent property compiled as a .NET event + member x.IsFSharpEventPropertyMethod = + match x with + | FSMeth(g, _, vref, _) -> vref.IsFSharpEventProperty g +#if !NO_EXTENSIONTYPING + | ProvidedMeth _ -> false +#endif + | _ -> false + + /// Indicates if this method takes no arguments + member x.IsNullary = (x.NumArgs = [0]) + + /// Indicates if the enclosing type for the method is a value type. + /// + /// For an extension method, this indicates if the method extends a struct type. + member x.IsStruct = + isStructTy x.TcGlobals x.ApparentEnclosingType + + /// Indicates if this method is read-only; usually by the [] attribute. + /// Must be an instance method. + /// Receiver must be a struct type. + member x.IsReadOnly = + // Perf Review: Is there a way we can cache this result? + x.IsInstance && + x.IsStruct && + match x with + | ILMeth (g, ilMethInfo, _) -> ilMethInfo.IsReadOnly g + | FSMeth _ -> false // F# defined methods not supported yet. Must be a language feature. + | _ -> false + + /// Indicates if this method is an extension member that is read-only. + /// An extension member is considered read-only if the first argument is a read-only byref (inref) type. + member x.IsReadOnlyExtensionMember (amap: Import.ImportMap, m) = + x.IsExtensionMember && + x.TryObjArgByrefType(amap, m, x.FormalMethodInst) + |> Option.exists (isInByrefTy amap.g) + + /// Build IL method infos. + static member CreateILMeth (amap: Import.ImportMap, m, ty: TType, md: ILMethodDef) = + let tinfo = ILTypeInfo.FromType amap.g ty + let mtps = Import.ImportILGenericParameters (fun () -> amap) m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata md.GenericParams + ILMeth (amap.g, ILMethInfo(amap.g, ty, None, md, mtps), None) + + /// Build IL method infos for a C#-style extension method + static member CreateILExtensionMeth (amap, m, apparentTy: TType, declaringTyconRef: TyconRef, extMethPri, md: ILMethodDef) = + let scoref = declaringTyconRef.CompiledRepresentationForNamedType.Scope + let mtps = Import.ImportILGenericParameters (fun () -> amap) m scoref [] md.GenericParams + ILMeth (amap.g, ILMethInfo(amap.g, apparentTy, Some declaringTyconRef, md, mtps), extMethPri) + + /// Tests whether two method infos have the same underlying definition. + /// Used to merge operator overloads collected from left and right of an operator constraint. + /// Must be compatible with ItemsAreEffectivelyEqual relation. + static member MethInfosUseIdenticalDefinitions x1 x2 = + match x1, x2 with + | ILMeth(_, x1, _), ILMeth(_, x2, _) -> (x1.RawMetadata === x2.RawMetadata) + | FSMeth(g, _, vref1, _), FSMeth(_, _, vref2, _) -> valRefEq g vref1 vref2 + | DefaultStructCtor _, DefaultStructCtor _ -> tyconRefEq x1.TcGlobals x1.DeclaringTyconRef x2.DeclaringTyconRef +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi1, _, _), ProvidedMeth(_, mi2, _, _) -> ProvidedMethodBase.TaintedEquals (mi1, mi2) +#endif + | _ -> false + + /// Calculates a hash code of method info. Must be compatible with ItemsAreEffectivelyEqual relation. + member x.ComputeHashCode() = + match x with + | ILMeth(_, x1, _) -> hash x1.RawMetadata.Name + | FSMeth(_, _, vref, _) -> hash vref.LogicalName + | DefaultStructCtor(_, _ty) -> 34892 // "ty" doesn't support hashing. We could use "hash (tcrefOfAppTy g ty).CompiledName" or + // something but we don't have a "g" parameter here yet. But this hash need only be very approximate anyway +#if !NO_EXTENSIONTYPING + | ProvidedMeth(_, mi, _, _) -> ProvidedMethodInfo.TaintedGetHashCode mi +#endif + + /// Apply a type instantiation to a method info, i.e. apply the instantiation to the enclosing type. + member x.Instantiate(amap, m, inst) = + match x with + | ILMeth(_g, ilminfo, pri) -> + match ilminfo with + | ILMethInfo(_, ty, None, md, _) -> MethInfo.CreateILMeth(amap, m, instType inst ty, md) + | ILMethInfo(_, ty, Some declaringTyconRef, md, _) -> MethInfo.CreateILExtensionMeth(amap, m, instType inst ty, declaringTyconRef, pri, md) + | FSMeth(g, ty, vref, pri) -> FSMeth(g, instType inst ty, vref, pri) + | DefaultStructCtor(g, ty) -> DefaultStructCtor(g, instType inst ty) +#if !NO_EXTENSIONTYPING + | ProvidedMeth _ -> + match inst with + | [] -> x + | _ -> assert false; failwith "Not supported" +#endif + + /// Get the return type of a method info, where 'void' is returned as 'None' + member x.GetCompiledReturnTy (amap, m, minst) = + match x with + | ILMeth(_g, ilminfo, _) -> + ilminfo.GetCompiledReturnTy(amap, m, minst) + | FSMeth(g, _, vref, _) -> + let ty = x.ApparentEnclosingAppType + let inst = GetInstantiationForMemberVal g x.IsCSharpStyleExtensionMember (ty, vref, minst) + let _, _, retTy, _ = AnalyzeTypeOfMemberVal x.IsCSharpStyleExtensionMember g (ty, vref) + retTy |> Option.map (instType inst) + | DefaultStructCtor _ -> None +#if !NO_EXTENSIONTYPING + | ProvidedMeth(amap, mi, _, m) -> + GetCompiledReturnTyOfProvidedMethodInfo amap m mi +#endif + + /// Get the return type of a method info, where 'void' is returned as 'unit' + member x.GetFSharpReturnTy(amap, m, minst) = + x.GetCompiledReturnTy(amap, m, minst) |> GetFSharpViewOfReturnType amap.g + + /// Get the parameter types of a method info + member x.GetParamTypes(amap, m, minst) = + match x with + | ILMeth(_g, ilminfo, _) -> + // A single group of tupled arguments + [ ilminfo.GetParamTypes(amap, m, minst) ] + | FSMeth(g, ty, vref, _) -> + let paramTypes = ParamNameAndType.FromMember x.IsCSharpStyleExtensionMember g vref + let inst = GetInstantiationForMemberVal g x.IsCSharpStyleExtensionMember (ty, vref, minst) + paramTypes |> List.mapSquared (fun (ParamNameAndType(_, ty)) -> instType inst ty) + | DefaultStructCtor _ -> [] +#if !NO_EXTENSIONTYPING + | ProvidedMeth(amap, mi, _, m) -> + // A single group of tupled arguments + [ [ for p in mi.PApplyArray((fun mi -> mi.GetParameters()), "GetParameters", m) do + yield Import.ImportProvidedType amap m (p.PApply((fun p -> p.ParameterType), m)) ] ] +#endif + + /// Get the (zero or one) 'self'/'this'/'object' arguments associated with a method. + /// An instance method returns one object argument. + member x.GetObjArgTypes (amap, m, minst) = + match x with + | ILMeth(_, ilminfo, _) -> ilminfo.GetObjArgTypes(amap, m, minst) + | FSMeth(g, _, vref, _) -> + if x.IsInstance then + let ty = x.ApparentEnclosingAppType + // The 'this' pointer of an extension member can depend on the minst + if x.IsExtensionMember then + let inst = GetInstantiationForMemberVal g x.IsCSharpStyleExtensionMember (ty, vref, minst) + let rawObjTy = GetObjTypeOfInstanceExtensionMethod g vref + [ rawObjTy |> instType inst ] + else + [ ty ] + else [] + | DefaultStructCtor _ -> [] +#if !NO_EXTENSIONTYPING + | ProvidedMeth(amap, mi, _, m) -> + if x.IsInstance then [ Import.ImportProvidedType amap m (mi.PApply((fun mi -> mi.DeclaringType), m)) ] // find the type of the 'this' argument + else [] +#endif + + /// Get the parameter attributes of a method info, which get combined with the parameter names and types + member x.GetParamAttribs(amap, m) = + match x with + | ILMeth(g, ilMethInfo, _) -> + [ [ for p in ilMethInfo.ParamMetadata do + let isParamArrayArg = TryFindILAttribute g.attrib_ParamArrayAttribute p.CustomAttrs + let reflArgInfo = + match TryDecodeILAttribute g g.attrib_ReflectedDefinitionAttribute.TypeRef p.CustomAttrs with + | Some ([ILAttribElem.Bool b ], _) -> ReflectedArgInfo.Quote b + | Some _ -> ReflectedArgInfo.Quote false + | _ -> ReflectedArgInfo.None + let isOutArg = (p.IsOut && not p.IsIn) + let isInArg = (p.IsIn && not p.IsOut) + // Note: we get default argument values from VB and other .NET language metadata + let optArgInfo = OptionalArgInfo.FromILParameter g amap m ilMethInfo.MetadataScope ilMethInfo.DeclaringTypeInst p + + let isCallerLineNumberArg = TryFindILAttribute g.attrib_CallerLineNumberAttribute p.CustomAttrs + let isCallerFilePathArg = TryFindILAttribute g.attrib_CallerFilePathAttribute p.CustomAttrs + let isCallerMemberNameArg = TryFindILAttribute g.attrib_CallerMemberNameAttribute p.CustomAttrs + + let callerInfo = + match isCallerLineNumberArg, isCallerFilePathArg, isCallerMemberNameArg with + | false, false, false -> NoCallerInfo + | true, false, false -> CallerLineNumber + | false, true, false -> CallerFilePath + | false, false, true -> CallerMemberName + | _, _, _ -> + // if multiple caller info attributes are specified, pick the "wrong" one here + // so that we get an error later + if p.Type.TypeRef.FullName = "System.Int32" then CallerFilePath + else CallerLineNumber + + yield (isParamArrayArg, isInArg, isOutArg, optArgInfo, callerInfo, reflArgInfo) ] ] + + | FSMeth(g, _, vref, _) -> + GetArgInfosOfMember x.IsCSharpStyleExtensionMember g vref + |> List.mapSquared (fun (ty, argInfo) -> + let isParamArrayArg = HasFSharpAttribute g g.attrib_ParamArrayAttribute argInfo.Attribs + let reflArgInfo = + match TryFindFSharpBoolAttributeAssumeFalse g g.attrib_ReflectedDefinitionAttribute argInfo.Attribs with + | Some b -> ReflectedArgInfo.Quote b + | None -> ReflectedArgInfo.None + let isOutArg = (HasFSharpAttribute g g.attrib_OutAttribute argInfo.Attribs && isByrefTy g ty) || isOutByrefTy g ty + let isInArg = (HasFSharpAttribute g g.attrib_InAttribute argInfo.Attribs && isByrefTy g ty) || isInByrefTy g ty + let isCalleeSideOptArg = HasFSharpAttribute g g.attrib_OptionalArgumentAttribute argInfo.Attribs + let isCallerSideOptArg = HasFSharpAttributeOpt g g.attrib_OptionalAttribute argInfo.Attribs + let optArgInfo = + if isCalleeSideOptArg then + CalleeSide + elif isCallerSideOptArg then + let defaultParameterValueAttribute = TryFindFSharpAttributeOpt g g.attrib_DefaultParameterValueAttribute argInfo.Attribs + match defaultParameterValueAttribute with + | None -> + // Do a type-directed analysis of the type to determine the default value to pass. + // Similar rules as OptionalArgInfo.FromILParameter are applied here, except for the COM and byref-related stuff. + CallerSide (if isObjTy g ty then MissingValue else DefaultValue) + | Some attr -> + let defaultValue = OptionalArgInfo.ValueOfDefaultParameterValueAttrib attr + match defaultValue with + | Some (Expr.Const (_, m, ty2)) when not (typeEquiv g ty2 ty) -> + // the type of the default value does not match the type of the argument. + // Emit a warning, and ignore the DefaultParameterValue argument altogether. + warning(Error(FSComp.SR.DefaultParameterValueNotAppropriateForArgument(), m)) + NotOptional + | Some (Expr.Const ((ConstToILFieldInit fi), _, _)) -> + // Good case - all is well. + CallerSide (Constant fi) + | _ -> + // Default value is not appropriate, i.e. not a constant. + // Compiler already gives an error in that case, so just ignore here. + NotOptional + else NotOptional + + let isCallerLineNumberArg = HasFSharpAttribute g g.attrib_CallerLineNumberAttribute argInfo.Attribs + let isCallerFilePathArg = HasFSharpAttribute g g.attrib_CallerFilePathAttribute argInfo.Attribs + let isCallerMemberNameArg = HasFSharpAttribute g g.attrib_CallerMemberNameAttribute argInfo.Attribs + + let callerInfo = + match isCallerLineNumberArg, isCallerFilePathArg, isCallerMemberNameArg with + | false, false, false -> NoCallerInfo + | true, false, false -> CallerLineNumber + | false, true, false -> CallerFilePath + | false, false, true -> CallerMemberName + | false, true, true -> + match TryFindFSharpAttribute g g.attrib_CallerMemberNameAttribute argInfo.Attribs with + | Some(Attrib(_, _, _, _, _, _, callerMemberNameAttributeRange)) -> + warning(Error(FSComp.SR.CallerMemberNameIsOverriden(argInfo.Name.Value.idText), callerMemberNameAttributeRange)) + CallerFilePath + | _ -> failwith "Impossible" + | _, _, _ -> + // if multiple caller info attributes are specified, pick the "wrong" one here + // so that we get an error later + match tryDestOptionTy g ty with + | ValueSome optTy when typeEquiv g g.int32_ty optTy -> CallerFilePath + | _ -> CallerLineNumber + + (isParamArrayArg, isInArg, isOutArg, optArgInfo, callerInfo, reflArgInfo)) + + | DefaultStructCtor _ -> + [[]] + +#if !NO_EXTENSIONTYPING + | ProvidedMeth(amap, mi, _, _) -> + // A single group of tupled arguments + [ [for p in mi.PApplyArray((fun mi -> mi.GetParameters()), "GetParameters", m) do + let isParamArrayArg = p.PUntaint((fun px -> (px :> IProvidedCustomAttributeProvider).GetAttributeConstructorArgs(p.TypeProvider.PUntaintNoFailure id, typeof.FullName).IsSome), m) + let optArgInfo = OptionalArgInfoOfProvidedParameter amap m p + let reflArgInfo = + match p.PUntaint((fun px -> (px :> IProvidedCustomAttributeProvider).GetAttributeConstructorArgs(p.TypeProvider.PUntaintNoFailure id, typeof.FullName)), m) with + | Some ([ Some (:? bool as b) ], _) -> ReflectedArgInfo.Quote b + | Some _ -> ReflectedArgInfo.Quote false + | None -> ReflectedArgInfo.None + let isOutArg = p.PUntaint((fun p -> p.IsOut && not p.IsIn), m) + let isInArg = p.PUntaint((fun p -> p.IsIn && not p.IsOut), m) + yield (isParamArrayArg, isInArg, isOutArg, optArgInfo, NoCallerInfo, reflArgInfo)] ] +#endif + + + + /// Get the signature of an abstract method slot. + // + // This code has grown organically over time. We've managed to unify the ILMeth+ProvidedMeth paths. + // The FSMeth, ILMeth+ProvidedMeth paths can probably be unified too. + member x.GetSlotSig(amap, m) = + match x with + | FSMeth(g, _, vref, _) -> + match vref.RecursiveValInfo with + | ValInRecScope false -> error(Error((FSComp.SR.InvalidRecursiveReferenceToAbstractSlot()), m)) + | _ -> () + + let allTyparsFromMethod, _, _, retTy, _ = GetTypeOfMemberInMemberForm g vref + + // A slot signature is w.r.t. the type variables of the type it is associated with. + // So we have to rename from the member type variables to the type variables of the type. + let formalEnclosingTypars = x.ApparentEnclosingTyconRef.Typars m + let formalEnclosingTyparsFromMethod, formalMethTypars = List.splitAt formalEnclosingTypars.Length allTyparsFromMethod + let methodToParentRenaming, _ = mkTyparToTyparRenaming formalEnclosingTyparsFromMethod formalEnclosingTypars + let formalParams = + GetArgInfosOfMember x.IsCSharpStyleExtensionMember g vref + |> List.mapSquared (map1Of2 (instType methodToParentRenaming) >> MakeSlotParam ) + let formalRetTy = Option.map (instType methodToParentRenaming) retTy + MakeSlotSig(x.LogicalName, x.ApparentEnclosingType, formalEnclosingTypars, formalMethTypars, formalParams, formalRetTy) + | DefaultStructCtor _ -> error(InternalError("no slotsig for DefaultStructCtor", m)) + | _ -> + let g = x.TcGlobals + // slotsigs must contain the formal types for the arguments and return type + // a _formal_ 'void' return type is represented as a 'unit' type. + // slotsigs are independent of instantiation: if an instantiation + // happens to make the return type 'unit' (i.e. it was originally a variable type + // then that does not correspond to a slotsig compiled as a 'void' return type. + // REVIEW: should we copy down attributes to slot params? + let tcref = tcrefOfAppTy g x.ApparentEnclosingAppType + let formalEnclosingTyparsOrig = tcref.Typars m + let formalEnclosingTypars = copyTypars formalEnclosingTyparsOrig + let _, formalEnclosingTyparTys = FixupNewTypars m [] [] formalEnclosingTyparsOrig formalEnclosingTypars + let formalMethTypars = copyTypars x.FormalMethodTypars + let _, formalMethTyparTys = FixupNewTypars m formalEnclosingTypars formalEnclosingTyparTys x.FormalMethodTypars formalMethTypars + let formalRetTy, formalParams = + match x with + | ILMeth(_, ilminfo, _) -> + let ftinfo = ILTypeInfo.FromType g (TType_app(tcref, formalEnclosingTyparTys)) + let formalRetTy = ImportReturnTypeFromMetadata amap m ilminfo.RawMetadata.Return.Type ilminfo.RawMetadata.Return.CustomAttrs ftinfo.ILScopeRef ftinfo.TypeInstOfRawMetadata formalMethTyparTys + let formalParams = + [ [ for p in ilminfo.RawMetadata.Parameters do + let paramType = ImportILTypeFromMetadataWithAttributes amap m ftinfo.ILScopeRef ftinfo.TypeInstOfRawMetadata formalMethTyparTys p.Type p.CustomAttrs + yield TSlotParam(p.Name, paramType, p.IsIn, p.IsOut, p.IsOptional, []) ] ] + formalRetTy, formalParams +#if !NO_EXTENSIONTYPING + | ProvidedMeth (_, mi, _, _) -> + // GENERIC TYPE PROVIDERS: for generics, formal types should be generated here, not the actual types + // For non-generic type providers there is no difference + let formalRetTy = x.GetCompiledReturnTy(amap, m, formalMethTyparTys) + // GENERIC TYPE PROVIDERS: formal types should be generated here, not the actual types + // For non-generic type providers there is no difference + let formalParams = + [ [ for p in mi.PApplyArray((fun mi -> mi.GetParameters()), "GetParameters", m) do + let paramName = p.PUntaint((fun p -> match p.Name with null -> None | s -> Some s), m) + let paramType = Import.ImportProvidedType amap m (p.PApply((fun p -> p.ParameterType), m)) + let isIn, isOut, isOptional = p.PUntaint((fun p -> p.IsIn, p.IsOut, p.IsOptional), m) + yield TSlotParam(paramName, paramType, isIn, isOut, isOptional, []) ] ] + formalRetTy, formalParams +#endif + | _ -> failwith "unreachable" + MakeSlotSig(x.LogicalName, x.ApparentEnclosingType, formalEnclosingTypars, formalMethTypars, formalParams, formalRetTy) + + /// Get the ParamData objects for the parameters of a MethInfo + member x.GetParamDatas(amap, m, minst) = + let paramNamesAndTypes = + match x with + | ILMeth(_g, ilminfo, _) -> + [ ilminfo.GetParamNamesAndTypes(amap, m, minst) ] + | FSMeth(g, _, vref, _) -> + let ty = x.ApparentEnclosingAppType + let items = ParamNameAndType.FromMember x.IsCSharpStyleExtensionMember g vref + let inst = GetInstantiationForMemberVal g x.IsCSharpStyleExtensionMember (ty, vref, minst) + items |> ParamNameAndType.InstantiateCurried inst + | DefaultStructCtor _ -> + [[]] +#if !NO_EXTENSIONTYPING + | ProvidedMeth(amap, mi, _, _) -> + // A single set of tupled parameters + [ [for p in mi.PApplyArray((fun mi -> mi.GetParameters()), "GetParameters", m) do + let pname = + match p.PUntaint((fun p -> p.Name), m) with + | null -> None + | name -> Some (mkSynId m name) + let pty = + match p.PApply((fun p -> p.ParameterType), m) with + | Tainted.Null -> amap.g.unit_ty + | parameterType -> Import.ImportProvidedType amap m parameterType + yield ParamNameAndType(pname, pty) ] ] + +#endif + + let paramAttribs = x.GetParamAttribs(amap, m) + (paramAttribs, paramNamesAndTypes) ||> List.map2 (List.map2 (fun (isParamArrayArg, isInArg, isOutArg, optArgInfo, callerInfo, reflArgInfo) (ParamNameAndType(nmOpt, pty)) -> + ParamData(isParamArrayArg, isInArg, isOutArg, optArgInfo, callerInfo, nmOpt, reflArgInfo, pty))) + + /// Get the ParamData objects for the parameters of a MethInfo + member x.HasParamArrayArg(amap, m, minst) = + x.GetParamDatas(amap, m, minst) |> List.existsSquared (fun (ParamData(isParamArrayArg, _, _, _, _, _, _, _)) -> isParamArrayArg) + + + /// Select all the type parameters of the declaring type of a method. + /// + /// For extension methods, no type parameters are returned, because all the + /// type parameters are part of the apparent type, rather the + /// declaring type, even for extension methods extending generic types. + member x.GetFormalTyparsOfDeclaringType m = + if x.IsExtensionMember then [] + else + match x with + | FSMeth(g, _, vref, _) -> + let ty = x.ApparentEnclosingAppType + let memberParentTypars, _, _, _ = AnalyzeTypeOfMemberVal false g (ty, vref) + memberParentTypars + | _ -> + x.DeclaringTyconRef.Typars m + + /// Tries to get the object arg type if it's a byref type. + member x.TryObjArgByrefType(amap, m, minst) = + x.GetObjArgTypes(amap, m, minst) + |> List.tryHead + |> Option.bind (fun ty -> + if isByrefTy x.TcGlobals ty then Some ty + else None) + +//------------------------------------------------------------------------- +// ILFieldInfo + + +/// Represents a single use of a IL or provided field from one point in an F# program +[] +type ILFieldInfo = + /// Represents a single use of a field backed by Abstract IL metadata + | ILFieldInfo of ILTypeInfo * ILFieldDef // .NET IL fields +#if !NO_EXTENSIONTYPING + /// Represents a single use of a field backed by provided metadata + | ProvidedField of Import.ImportMap * Tainted * range +#endif + + /// Get the enclosing ("parent"/"declaring") type of the field. + member x.ApparentEnclosingType = + match x with + | ILFieldInfo(tinfo, _) -> tinfo.ToType +#if !NO_EXTENSIONTYPING + | ProvidedField(amap, fi, m) -> (Import.ImportProvidedType amap m (fi.PApply((fun fi -> fi.DeclaringType), m))) +#endif + + member x.ApparentEnclosingAppType = x.ApparentEnclosingType + + member x.ApparentEnclosingTyconRef = tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + + member x.DeclaringTyconRef = x.ApparentEnclosingTyconRef + + member x.TcGlobals = + match x with + | ILFieldInfo(tinfo, _) -> tinfo.TcGlobals +#if !NO_EXTENSIONTYPING + | ProvidedField(amap, _, _) -> amap.g +#endif + + /// Get a reference to the declaring type of the field as an ILTypeRef + member x.ILTypeRef = + match x with + | ILFieldInfo(tinfo, _) -> tinfo.ILTypeRef +#if !NO_EXTENSIONTYPING + | ProvidedField(amap, fi, m) -> (Import.ImportProvidedTypeAsILType amap m (fi.PApply((fun fi -> fi.DeclaringType), m))).TypeRef +#endif + + /// Get the scope used to interpret IL metadata + member x.ScopeRef = x.ILTypeRef.Scope + + /// Get the type instantiation of the declaring type of the field + member x.TypeInst = + match x with + | ILFieldInfo(tinfo, _) -> tinfo.TypeInstOfRawMetadata +#if !NO_EXTENSIONTYPING + | ProvidedField _ -> [] /// GENERIC TYPE PROVIDERS +#endif + + /// Get the name of the field + member x.FieldName = + match x with + | ILFieldInfo(_, pd) -> pd.Name +#if !NO_EXTENSIONTYPING + | ProvidedField(_, fi, m) -> fi.PUntaint((fun fi -> fi.Name), m) +#endif + + /// Indicates if the field is readonly (in the .NET/C# sense of readonly) + member x.IsInitOnly = + match x with + | ILFieldInfo(_, pd) -> pd.IsInitOnly +#if !NO_EXTENSIONTYPING + | ProvidedField(_, fi, m) -> fi.PUntaint((fun fi -> fi.IsInitOnly), m) +#endif + + /// Indicates if the field is a member of a struct or enum type + member x.IsValueType = + match x with + | ILFieldInfo(tinfo, _) -> tinfo.IsValueType +#if !NO_EXTENSIONTYPING + | ProvidedField(amap, _, _) -> isStructTy amap.g x.ApparentEnclosingType +#endif + + /// Indicates if the field is static + member x.IsStatic = + match x with + | ILFieldInfo(_, pd) -> pd.IsStatic +#if !NO_EXTENSIONTYPING + | ProvidedField(_, fi, m) -> fi.PUntaint((fun fi -> fi.IsStatic), m) +#endif + + /// Indicates if the field has the 'specialname' property in the .NET IL + member x.IsSpecialName = + match x with + | ILFieldInfo(_, pd) -> pd.IsSpecialName +#if !NO_EXTENSIONTYPING + | ProvidedField(_, fi, m) -> fi.PUntaint((fun fi -> fi.IsSpecialName), m) +#endif + + /// Indicates if the field is a literal field with an associated literal value + member x.LiteralValue = + match x with + | ILFieldInfo(_, pd) -> if pd.IsLiteral then pd.LiteralValue else None +#if !NO_EXTENSIONTYPING + | ProvidedField(_, fi, m) -> + if fi.PUntaint((fun fi -> fi.IsLiteral), m) then + Some (ILFieldInit.FromProvidedObj m (fi.PUntaint((fun fi -> fi.GetRawConstantValue()), m))) + else + None +#endif + + /// Get the type of the field as an IL type + member x.ILFieldType = + match x with + | ILFieldInfo (_, fdef) -> fdef.FieldType +#if !NO_EXTENSIONTYPING + | ProvidedField(amap, fi, m) -> Import.ImportProvidedTypeAsILType amap m (fi.PApply((fun fi -> fi.FieldType), m)) +#endif + + /// Get the type of the field as an F# type + member x.FieldType(amap, m) = + match x with + | ILFieldInfo (tinfo, fdef) -> ImportILTypeFromMetadata amap m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata [] fdef.FieldType +#if !NO_EXTENSIONTYPING + | ProvidedField(amap, fi, m) -> Import.ImportProvidedType amap m (fi.PApply((fun fi -> fi.FieldType), m)) +#endif + + /// Tests whether two infos have the same underlying definition. + /// Must be compatible with ItemsAreEffectivelyEqual relation. + static member ILFieldInfosUseIdenticalDefinitions x1 x2 = + match x1, x2 with + | ILFieldInfo(_, x1), ILFieldInfo(_, x2) -> (x1 === x2) +#if !NO_EXTENSIONTYPING + | ProvidedField(_, fi1, _), ProvidedField(_, fi2, _)-> ProvidedFieldInfo.TaintedEquals (fi1, fi2) + | _ -> false +#endif + /// Get an (uninstantiated) reference to the field as an Abstract IL ILFieldRef + member x.ILFieldRef = rescopeILFieldRef x.ScopeRef (mkILFieldRef(x.ILTypeRef, x.FieldName, x.ILFieldType)) + + /// Calculates a hash code of field info. Must be compatible with ItemsAreEffectivelyEqual relation. + member x.ComputeHashCode() = hash x.FieldName + + override x.ToString() = x.FieldName + + +/// Describes an F# use of a field in an F#-declared record, class or struct type +[] +type RecdFieldInfo = + | RecdFieldInfo of TypeInst * RecdFieldRef + + /// Get the generic instantiation of the declaring type of the field + member x.TypeInst = let (RecdFieldInfo(tinst, _)) = x in tinst + + /// Get a reference to the F# metadata for the uninstantiated field + member x.RecdFieldRef = let (RecdFieldInfo(_, rfref)) = x in rfref + + /// Get the F# metadata for the uninstantiated field + member x.RecdField = x.RecdFieldRef.RecdField + + /// Indicate if the field is a static field in an F#-declared record, class or struct type + member x.IsStatic = x.RecdField.IsStatic + + /// Indicate if the field is a literal field in an F#-declared record, class or struct type + member x.LiteralValue = x.RecdField.LiteralValue + + /// Get a reference to the F# metadata for the F#-declared record, class or struct type + member x.TyconRef = x.RecdFieldRef.TyconRef + + /// Get the F# metadata for the F#-declared record, class or struct type + member x.Tycon = x.RecdFieldRef.Tycon + + /// Get the name of the field in an F#-declared record, class or struct type + member x.Name = x.RecdField.Name + + /// Get the (instantiated) type of the field in an F#-declared record, class or struct type + member x.FieldType = actualTyOfRecdFieldRef x.RecdFieldRef x.TypeInst + + /// Get the enclosing (declaring) type of the field in an F#-declared record, class or struct type + member x.DeclaringType = TType_app (x.RecdFieldRef.TyconRef, x.TypeInst) + override x.ToString() = x.TyconRef.ToString() + "::" + x.Name + + +/// Describes an F# use of a union case +[] +type UnionCaseInfo = + | UnionCaseInfo of TypeInst * UnionCaseRef + + /// Get the list of types for the instantiation of the type parameters of the declaring type of the union case + member x.TypeInst = let (UnionCaseInfo(tinst, _)) = x in tinst + + /// Get a reference to the F# metadata for the uninstantiated union case + member x.UnionCaseRef = let (UnionCaseInfo(_, ucref)) = x in ucref + + /// Get the F# metadata for the uninstantiated union case + member x.UnionCase = x.UnionCaseRef.UnionCase + + /// Get a reference to the F# metadata for the declaring union type + member x.TyconRef = x.UnionCaseRef.TyconRef + + /// Get the F# metadata for the declaring union type + member x.Tycon = x.UnionCaseRef.Tycon + + /// Get the name of the union case + member x.Name = x.UnionCase.DisplayName + + /// Get the instantiation of the type parameters of the declaring type of the union case + member x.GetTyparInst m = mkTyparInst (x.TyconRef.Typars m) x.TypeInst + + override x.ToString() = x.TyconRef.ToString() + "::" + x.Name + + +/// Describes an F# use of a property backed by Abstract IL metadata +[] +type ILPropInfo = + | ILPropInfo of ILTypeInfo * ILPropertyDef + + /// Get the TcGlobals governing this value + member x.TcGlobals = match x with ILPropInfo(tinfo, _) -> tinfo.TcGlobals + + /// Get the declaring IL type of the IL property, including any generic instantiation + member x.ILTypeInfo = match x with ILPropInfo(tinfo, _) -> tinfo + + /// Get the apparent declaring type of the method as an F# type. + /// If this is a C#-style extension method then this is the type which the method + /// appears to extend. This may be a variable type. + member x.ApparentEnclosingType = match x with ILPropInfo(tinfo, _) -> tinfo.ToType + + /// Like ApparentEnclosingType but use the compiled nominal type if this is a method on a tuple type + member x.ApparentEnclosingAppType = convertToTypeWithMetadataIfPossible x.TcGlobals x.ApparentEnclosingType + + /// Get the raw Abstract IL metadata for the IL property + member x.RawMetadata = match x with ILPropInfo(_, pd) -> pd + + /// Get the name of the IL property + member x.PropertyName = x.RawMetadata.Name + + /// Gets the ILMethInfo of the 'get' method for the IL property + member x.GetterMethod = + assert x.HasGetter + let mdef = resolveILMethodRef x.ILTypeInfo.RawMetadata x.RawMetadata.GetMethod.Value + ILMethInfo(x.TcGlobals, x.ILTypeInfo.ToType, None, mdef, []) + + /// Gets the ILMethInfo of the 'set' method for the IL property + member x.SetterMethod = + assert x.HasSetter + let mdef = resolveILMethodRef x.ILTypeInfo.RawMetadata x.RawMetadata.SetMethod.Value + ILMethInfo(x.TcGlobals, x.ILTypeInfo.ToType, None, mdef, []) + + /// Indicates if the IL property has a 'get' method + member x.HasGetter = Option.isSome x.RawMetadata.GetMethod + + /// Indicates if the IL property has a 'set' method + member x.HasSetter = Option.isSome x.RawMetadata.SetMethod + + /// Indicates if the IL property is static + member x.IsStatic = (x.RawMetadata.CallingConv = ILThisConvention.Static) + + /// Indicates if the IL property is virtual + member x.IsVirtual = + (x.HasGetter && x.GetterMethod.IsVirtual) || + (x.HasSetter && x.SetterMethod.IsVirtual) + + /// Indicates if the IL property is logically a 'newslot', i.e. hides any previous slots of the same name. + member x.IsNewSlot = + (x.HasGetter && x.GetterMethod.IsNewSlot) || + (x.HasSetter && x.SetterMethod.IsNewSlot) + + /// Get the names and types of the indexer arguments associated with the IL property. + /// + /// Any type parameters of the enclosing type are instantiated in the type returned. + member x.GetParamNamesAndTypes(amap, m) = + let (ILPropInfo (tinfo, pdef)) = x + pdef.Args |> List.map (fun ty -> ParamNameAndType(None, ImportILTypeFromMetadata amap m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata [] ty) ) + + /// Get the types of the indexer arguments associated with the IL property. + /// + /// Any type parameters of the enclosing type are instantiated in the type returned. + member x.GetParamTypes(amap, m) = + let (ILPropInfo (tinfo, pdef)) = x + pdef.Args |> List.map (fun ty -> ImportILTypeFromMetadata amap m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata [] ty) + + /// Get the return type of the IL property. + /// + /// Any type parameters of the enclosing type are instantiated in the type returned. + member x.GetPropertyType (amap, m) = + let (ILPropInfo (tinfo, pdef)) = x + ImportILTypeFromMetadata amap m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata [] pdef.PropertyType + + override x.ToString() = x.ILTypeInfo.ToString() + "::" + x.PropertyName + + + +/// Describes an F# use of a property +[] +type PropInfo = + /// An F# use of a property backed by F#-declared metadata + | FSProp of TcGlobals * TType * ValRef option * ValRef option + /// An F# use of a property backed by Abstract IL metadata + | ILProp of ILPropInfo +#if !NO_EXTENSIONTYPING + /// An F# use of a property backed by provided metadata + | ProvidedProp of Import.ImportMap * Tainted * range +#endif + + /// Get the enclosing type of the property. + /// + /// If this is an extension member, then this is the apparent parent, i.e. the type the property appears to extend. + member x.ApparentEnclosingType = + match x with + | ILProp ilpinfo -> ilpinfo.ILTypeInfo.ToType + | FSProp(_, ty, _, _) -> ty +#if !NO_EXTENSIONTYPING + | ProvidedProp(amap, pi, m) -> + Import.ImportProvidedType amap m (pi.PApply((fun pi -> pi.DeclaringType), m)) +#endif + + /// Get the enclosing type of the method info, using a nominal type for tuple types + member x.ApparentEnclosingAppType = + match x with + | ILProp ilpinfo -> ilpinfo.ApparentEnclosingAppType + | _ -> x.ApparentEnclosingType + + member x.ApparentEnclosingTyconRef = tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + + /// Get the declaring type or module holding the method. + /// Note that C#-style extension properties don't exist in the C# design as yet. + /// If this is an F#-style extension method it is the logical module + /// holding the value for the extension method. + member x.DeclaringTyconRef = + match x.ArbitraryValRef with + | Some vref when x.IsExtensionMember && vref.HasDeclaringEntity -> vref.TopValDeclaringEntity + | _ -> x.ApparentEnclosingTyconRef + + /// Try to get an arbitrary F# ValRef associated with the member. This is to determine if the member is virtual, amongst other things. + member x.ArbitraryValRef : ValRef option = + match x with + | FSProp(_, _, Some vref, _) + | FSProp(_, _, _, Some vref) -> Some vref + | FSProp(_, _, None, None) -> failwith "unreachable" + | _ -> None + + /// Indicates if this property has an associated XML comment authored in this assembly. + member x.HasDirectXmlComment = + match x with + | FSProp(g, _, Some vref, _) + | FSProp(g, _, _, Some vref) -> valRefInThisAssembly g.compilingFslib vref +#if !NO_EXTENSIONTYPING + | ProvidedProp _ -> true +#endif + | _ -> false + + /// Get the logical name of the property. + member x.PropertyName = + match x with + | ILProp ilpinfo -> ilpinfo.PropertyName + | FSProp(_, _, Some vref, _) + | FSProp(_, _, _, Some vref) -> vref.PropertyName +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi, m) -> pi.PUntaint((fun pi -> pi.Name), m) +#endif + | FSProp _ -> failwith "unreachable" + + /// Indicates if this property has an associated getter method. + member x.HasGetter = + match x with + | ILProp ilpinfo-> ilpinfo.HasGetter + | FSProp(_, _, x, _) -> Option.isSome x +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi, m) -> pi.PUntaint((fun pi -> pi.CanRead), m) +#endif + + /// Indicates if this property has an associated setter method. + member x.HasSetter = + match x with + | ILProp ilpinfo -> ilpinfo.HasSetter + | FSProp(_, _, _, x) -> Option.isSome x +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi, m) -> pi.PUntaint((fun pi -> pi.CanWrite), m) +#endif + + + /// Indicates if this is an extension member + member x.IsExtensionMember = + match x.ArbitraryValRef with + | Some vref -> vref.IsExtensionMember + | _ -> false + + /// True if the getter (or, if absent, the setter) is a virtual method + // REVIEW: for IL properties this is getter OR setter. For F# properties it is getter ELSE setter + member x.IsVirtualProperty = + match x with + | ILProp ilpinfo -> ilpinfo.IsVirtual + | FSProp(_, _, Some vref, _) + | FSProp(_, _, _, Some vref) -> vref.IsVirtualMember + | FSProp _-> failwith "unreachable" +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi, m) -> + let mi = ArbitraryMethodInfoOfPropertyInfo pi m + mi.PUntaint((fun mi -> mi.IsVirtual), m) +#endif + + /// Indicates if the property is logically a 'newslot', i.e. hides any previous slots of the same name. + member x.IsNewSlot = + match x with + | ILProp ilpinfo -> ilpinfo.IsNewSlot + | FSProp(_, _, Some vref, _) + | FSProp(_, _, _, Some vref) -> vref.IsDispatchSlotMember + | FSProp(_, _, None, None) -> failwith "unreachable" +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi, m) -> + let mi = ArbitraryMethodInfoOfPropertyInfo pi m + mi.PUntaint((fun mi -> mi.IsHideBySig), m) +#endif + + + /// Indicates if the getter (or, if absent, the setter) for the property is a dispatch slot. + // REVIEW: for IL properties this is getter OR setter. For F# properties it is getter ELSE setter + member x.IsDispatchSlot = + match x with + | ILProp ilpinfo -> ilpinfo.IsVirtual + | FSProp(g, ty, Some vref, _) + | FSProp(g, ty, _, Some vref) -> + isInterfaceTy g ty || (vref.MemberInfo.Value.MemberFlags.IsDispatchSlot) + | FSProp _ -> failwith "unreachable" +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi, m) -> + let mi = ArbitraryMethodInfoOfPropertyInfo pi m + mi.PUntaint((fun mi -> mi.IsVirtual), m) +#endif + + /// Indicates if this property is static. + member x.IsStatic = + match x with + | ILProp ilpinfo -> ilpinfo.IsStatic + | FSProp(_, _, Some vref, _) + | FSProp(_, _, _, Some vref) -> not vref.IsInstanceMember + | FSProp(_, _, None, None) -> failwith "unreachable" +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi, m) -> + (ArbitraryMethodInfoOfPropertyInfo pi m).PUntaint((fun mi -> mi.IsStatic), m) +#endif + + /// Indicates if this property is marked 'override' and thus definitely overrides another property. + member x.IsDefiniteFSharpOverride = + match x.ArbitraryValRef with + | Some vref -> vref.IsDefiniteFSharpOverrideMember + | None -> false + + member x.ImplementedSlotSignatures = + x.ArbitraryValRef.Value.ImplementedSlotSignatures + + member x.IsFSharpExplicitInterfaceImplementation = + match x.ArbitraryValRef with + | Some vref -> vref.IsFSharpExplicitInterfaceImplementation x.TcGlobals + | None -> false + + + /// Indicates if this property is an indexer property, i.e. a property with arguments. + member x.IsIndexer = + match x with + | ILProp(ILPropInfo(_, pdef)) -> pdef.Args.Length <> 0 + | FSProp(g, _, Some vref, _) -> + // A getter has signature { OptionalObjectType } -> Unit -> PropertyType + // A getter indexer has signature { OptionalObjectType } -> TupledIndexerArguments -> PropertyType + let arginfos = ArgInfosOfMember g vref + arginfos.Length = 1 && arginfos.Head.Length >= 1 + | FSProp(g, _, _, Some vref) -> + // A setter has signature { OptionalObjectType } -> PropertyType -> Void + // A setter indexer has signature { OptionalObjectType } -> TupledIndexerArguments -> PropertyType -> Void + let arginfos = ArgInfosOfMember g vref + arginfos.Length = 1 && arginfos.Head.Length >= 2 + | FSProp(_, _, None, None) -> + failwith "unreachable" +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi, m) -> + pi.PUntaint((fun pi -> pi.GetIndexParameters().Length), m)>0 +#endif + + /// Indicates if this is an F# property compiled as a CLI event, e.g. a [] property. + member x.IsFSharpEventProperty = + match x with + | FSProp(g, _, Some vref, None) -> vref.IsFSharpEventProperty g +#if !NO_EXTENSIONTYPING + | ProvidedProp _ -> false +#endif + | _ -> false + + /// Return a new property info where there is no associated setter, only an associated getter. + /// + /// Property infos can combine getters and setters, assuming they are consistent w.r.t. 'virtual', indexer argument types etc. + /// When checking consistency we split these apart + member x.DropSetter = + match x with + | FSProp(g, ty, Some vref, _) -> FSProp(g, ty, Some vref, None) + | _ -> x + + + /// Return a new property info where there is no associated getter, only an associated setter. + member x.DropGetter = + match x with + | FSProp(g, ty, _, Some vref) -> FSProp(g, ty, None, Some vref) + | _ -> x + + /// Get the intra-assembly XML documentation for the property. + member x.XmlDoc = + match x with + | ILProp _ -> XmlDoc.Empty + | FSProp(_, _, Some vref, _) + | FSProp(_, _, _, Some vref) -> vref.XmlDoc + | FSProp(_, _, None, None) -> failwith "unreachable" +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi, m) -> + let lines = pi.PUntaint((fun pix -> (pix :> IProvidedCustomAttributeProvider).GetXmlDocAttributes(pi.TypeProvider.PUntaintNoFailure id)), m) + XmlDoc (lines, m) +#endif + + /// Get the TcGlobals associated with the object + member x.TcGlobals = + match x with + | ILProp ilpinfo -> ilpinfo.TcGlobals + | FSProp(g, _, _, _) -> g +#if !NO_EXTENSIONTYPING + | ProvidedProp(amap, _, _) -> amap.g +#endif + + /// Indicates if the enclosing type for the property is a value type. + /// + /// For an extension property, this indicates if the property extends a struct type. + member x.IsValueType = isStructTy x.TcGlobals x.ApparentEnclosingType + + + /// Get the result type of the property + member x.GetPropertyType (amap, m) = + match x with + | ILProp ilpinfo -> ilpinfo.GetPropertyType (amap, m) + | FSProp (g, _, Some vref, _) + | FSProp (g, _, _, Some vref) -> + let ty = x.ApparentEnclosingAppType + let inst = GetInstantiationForPropertyVal g (ty, vref) + ReturnTypeOfPropertyVal g vref.Deref |> instType inst + + | FSProp _ -> failwith "unreachable" +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi, m) -> + Import.ImportProvidedType amap m (pi.PApply((fun pi -> pi.PropertyType), m)) +#endif + + + /// Get the names and types of the indexer parameters associated with the property + /// + /// If the property is in a generic type, then the type parameters are instantiated in the types returned. + member x.GetParamNamesAndTypes(amap, m) = + match x with + | ILProp ilpinfo -> ilpinfo.GetParamNamesAndTypes(amap, m) + | FSProp (g, ty, Some vref, _) + | FSProp (g, ty, _, Some vref) -> + let inst = GetInstantiationForPropertyVal g (ty, vref) + ArgInfosOfPropertyVal g vref.Deref |> List.map (ParamNameAndType.FromArgInfo >> ParamNameAndType.Instantiate inst) + | FSProp _ -> failwith "unreachable" +#if !NO_EXTENSIONTYPING + | ProvidedProp (_, pi, m) -> + [ for p in pi.PApplyArray((fun pi -> pi.GetIndexParameters()), "GetIndexParameters", m) do + let paramName = p.PUntaint((fun p -> match p.Name with null -> None | s -> Some (mkSynId m s)), m) + let paramType = Import.ImportProvidedType amap m (p.PApply((fun p -> p.ParameterType), m)) + yield ParamNameAndType(paramName, paramType) ] +#endif + + /// Get the details of the indexer parameters associated with the property + member x.GetParamDatas(amap, m) = + x.GetParamNamesAndTypes(amap, m) + |> List.map (fun (ParamNameAndType(nmOpt, pty)) -> ParamData(false, false, false, NotOptional, NoCallerInfo, nmOpt, ReflectedArgInfo.None, pty)) + + /// Get the types of the indexer parameters associated with the property + member x.GetParamTypes(amap, m) = + x.GetParamNamesAndTypes(amap, m) |> List.map (fun (ParamNameAndType(_, ty)) -> ty) + + /// Get a MethInfo for the 'getter' method associated with the property + member x.GetterMethod = + match x with + | ILProp ilpinfo -> ILMeth(x.TcGlobals, ilpinfo.GetterMethod, None) + | FSProp(g, ty, Some vref, _) -> FSMeth(g, ty, vref, None) +#if !NO_EXTENSIONTYPING + | ProvidedProp(amap, pi, m) -> + let meth = GetAndSanityCheckProviderMethod m pi (fun pi -> pi.GetGetMethod()) FSComp.SR.etPropertyCanReadButHasNoGetter + ProvidedMeth(amap, meth, None, m) + +#endif + | FSProp _ -> failwith "no getter method" + + /// Get a MethInfo for the 'setter' method associated with the property + member x.SetterMethod = + match x with + | ILProp ilpinfo -> ILMeth(x.TcGlobals, ilpinfo.SetterMethod, None) + | FSProp(g, ty, _, Some vref) -> FSMeth(g, ty, vref, None) +#if !NO_EXTENSIONTYPING + | ProvidedProp(amap, pi, m) -> + let meth = GetAndSanityCheckProviderMethod m pi (fun pi -> pi.GetSetMethod()) FSComp.SR.etPropertyCanWriteButHasNoSetter + ProvidedMeth(amap, meth, None, m) +#endif + | FSProp _ -> failwith "no setter method" + + /// Test whether two property infos have the same underlying definition. + /// Uses the same techniques as 'MethInfosUseIdenticalDefinitions'. + /// Must be compatible with ItemsAreEffectivelyEqual relation. + static member PropInfosUseIdenticalDefinitions x1 x2 = + let optVrefEq g = function + | Some v1, Some v2 -> valRefEq g v1 v2 + | None, None -> true + | _ -> false + match x1, x2 with + | ILProp ilpinfo1, ILProp ilpinfo2 -> (ilpinfo1.RawMetadata === ilpinfo2.RawMetadata) + | FSProp(g, _, vrefa1, vrefb1), FSProp(_, _, vrefa2, vrefb2) -> + (optVrefEq g (vrefa1, vrefa2)) && (optVrefEq g (vrefb1, vrefb2)) +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi1, _), ProvidedProp(_, pi2, _) -> ProvidedPropertyInfo.TaintedEquals (pi1, pi2) +#endif + | _ -> false + + /// Calculates a hash code of property info. Must be compatible with ItemsAreEffectivelyEqual relation. + member pi.ComputeHashCode() = + match pi with + | ILProp ilpinfo -> hash ilpinfo.RawMetadata.Name + | FSProp(_, _, vrefOpt1, vrefOpt2) -> + // Hash on option*option + let vth = (vrefOpt1 |> Option.map (fun vr -> vr.LogicalName), (vrefOpt2 |> Option.map (fun vr -> vr.LogicalName))) + hash vth +#if !NO_EXTENSIONTYPING + | ProvidedProp(_, pi, _) -> ProvidedPropertyInfo.TaintedGetHashCode pi +#endif + + override x.ToString() = "property " + x.PropertyName + +//------------------------------------------------------------------------- +// ILEventInfo + + +/// Describes an F# use of an event backed by Abstract IL metadata +[] +type ILEventInfo = + | ILEventInfo of ILTypeInfo * ILEventDef + + /// Get the enclosing ("parent"/"declaring") type of the field. + member x.ApparentEnclosingType = match x with ILEventInfo(tinfo, _) -> tinfo.ToType + + // Note: events are always associated with nominal types + member x.ApparentEnclosingAppType = x.ApparentEnclosingType + + // Note: IL Events are never extension members as C# has no notion of extension events as yet + member x.DeclaringTyconRef = tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + + member x.TcGlobals = match x with ILEventInfo(tinfo, _) -> tinfo.TcGlobals + + /// Get the raw Abstract IL metadata for the event + member x.RawMetadata = match x with ILEventInfo(_, ed) -> ed + + /// Get the declaring IL type of the event as an ILTypeInfo + member x.ILTypeInfo = match x with ILEventInfo(tinfo, _) -> tinfo + + /// Get the ILMethInfo describing the 'add' method associated with the event + member x.AddMethod = + let mdef = resolveILMethodRef x.ILTypeInfo.RawMetadata x.RawMetadata.AddMethod + ILMethInfo(x.TcGlobals, x.ILTypeInfo.ToType, None, mdef, []) + + /// Get the ILMethInfo describing the 'remove' method associated with the event + member x.RemoveMethod = + let mdef = resolveILMethodRef x.ILTypeInfo.RawMetadata x.RawMetadata.RemoveMethod + ILMethInfo(x.TcGlobals, x.ILTypeInfo.ToType, None, mdef, []) + + /// Get the declaring type of the event as an ILTypeRef + member x.TypeRef = x.ILTypeInfo.ILTypeRef + + /// Get the name of the event + member x.Name = x.RawMetadata.Name + + /// Indicates if the property is static + member x.IsStatic = x.AddMethod.IsStatic + override x.ToString() = x.ILTypeInfo.ToString() + "::" + x.Name + +//------------------------------------------------------------------------- +// Helpers for EventInfo + +/// An exception type used to raise an error using the old error system. +/// +/// Error text: "A definition to be compiled as a .NET event does not have the expected form. Only property members can be compiled as .NET events." +exception BadEventTransformation of range + +/// Properties compatible with type IDelegateEvent and attributed with CLIEvent are special: +/// we generate metadata and add/remove methods +/// to make them into a .NET event, and mangle the name of a property. +/// We don't handle static, indexer or abstract properties correctly. +/// Note the name mangling doesn't affect the name of the get/set methods for the property +/// and so doesn't affect how we compile F# accesses to the property. +let private tyConformsToIDelegateEvent g ty = + isIDelegateEventType g ty && isDelegateTy g (destIDelegateEventType g ty) + + +/// Create an error object to raise should an event not have the shape expected by the .NET idiom described further below +let nonStandardEventError nm m = + Error ((FSComp.SR.eventHasNonStandardType(nm, ("add_"+nm), ("remove_"+nm))), m) + +/// Find the delegate type that an F# event property implements by looking through the type hierarchy of the type of the property +/// for the first instantiation of IDelegateEvent. +let FindDelegateTypeOfPropertyEvent g amap nm m ty = + match SearchEntireHierarchyOfType (tyConformsToIDelegateEvent g) g amap m ty with + | None -> error(nonStandardEventError nm m) + | Some ty -> destIDelegateEventType g ty + + +//------------------------------------------------------------------------- +// EventInfo + +/// Describes an F# use of an event +[] +type EventInfo = + /// An F# use of an event backed by F#-declared metadata + | FSEvent of TcGlobals * PropInfo * ValRef * ValRef + /// An F# use of an event backed by .NET metadata + | ILEvent of ILEventInfo +#if !NO_EXTENSIONTYPING + /// An F# use of an event backed by provided metadata + | ProvidedEvent of Import.ImportMap * Tainted * range +#endif + + /// Get the enclosing type of the event. + /// + /// If this is an extension member, then this is the apparent parent, i.e. the type the event appears to extend. + member x.ApparentEnclosingType = + match x with + | ILEvent ileinfo -> ileinfo.ApparentEnclosingType + | FSEvent (_, p, _, _) -> p.ApparentEnclosingType +#if !NO_EXTENSIONTYPING + | ProvidedEvent (amap, ei, m) -> Import.ImportProvidedType amap m (ei.PApply((fun ei -> ei.DeclaringType), m)) +#endif + /// Get the enclosing type of the method info, using a nominal type for tuple types + member x.ApparentEnclosingAppType = + match x with + | ILEvent ileinfo -> ileinfo.ApparentEnclosingAppType + | _ -> x.ApparentEnclosingType + + member x.ApparentEnclosingTyconRef = tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + + /// Get the declaring type or module holding the method. + /// Note that C#-style extension properties don't exist in the C# design as yet. + /// If this is an F#-style extension method it is the logical module + /// holding the value for the extension method. + member x.DeclaringTyconRef = + match x.ArbitraryValRef with + | Some vref when x.IsExtensionMember && vref.HasDeclaringEntity -> vref.TopValDeclaringEntity + | _ -> x.ApparentEnclosingTyconRef + + + /// Indicates if this event has an associated XML comment authored in this assembly. + member x.HasDirectXmlComment = + match x with + | FSEvent (_, p, _, _) -> p.HasDirectXmlComment +#if !NO_EXTENSIONTYPING + | ProvidedEvent _ -> true +#endif + | _ -> false + + /// Get the intra-assembly XML documentation for the property. + member x.XmlDoc = + match x with + | ILEvent _ -> XmlDoc.Empty + | FSEvent (_, p, _, _) -> p.XmlDoc +#if !NO_EXTENSIONTYPING + | ProvidedEvent (_, ei, m) -> + let lines = ei.PUntaint((fun eix -> (eix :> IProvidedCustomAttributeProvider).GetXmlDocAttributes(ei.TypeProvider.PUntaintNoFailure id)), m) + XmlDoc (lines, m) +#endif + + /// Get the logical name of the event. + member x.EventName = + match x with + | ILEvent ileinfo -> ileinfo.Name + | FSEvent (_, p, _, _) -> p.PropertyName +#if !NO_EXTENSIONTYPING + | ProvidedEvent (_, ei, m) -> ei.PUntaint((fun ei -> ei.Name), m) +#endif + + /// Indicates if this property is static. + member x.IsStatic = + match x with + | ILEvent ileinfo -> ileinfo.IsStatic + | FSEvent (_, p, _, _) -> p.IsStatic +#if !NO_EXTENSIONTYPING + | ProvidedEvent (_, ei, m) -> + let meth = GetAndSanityCheckProviderMethod m ei (fun ei -> ei.GetAddMethod()) FSComp.SR.etEventNoAdd + meth.PUntaint((fun mi -> mi.IsStatic), m) +#endif + + /// Indicates if this is an extension member + member x.IsExtensionMember = + match x with + | ILEvent _ -> false + | FSEvent (_, p, _, _) -> p.IsExtensionMember +#if !NO_EXTENSIONTYPING + | ProvidedEvent _ -> false +#endif + + /// Get the TcGlobals associated with the object + member x.TcGlobals = + match x with + | ILEvent ileinfo -> ileinfo.TcGlobals + | FSEvent(g, _, _, _) -> g +#if !NO_EXTENSIONTYPING + | ProvidedEvent (amap, _, _) -> amap.g +#endif + + /// Indicates if the enclosing type for the event is a value type. + /// + /// For an extension event, this indicates if the event extends a struct type. + member x.IsValueType = isStructTy x.TcGlobals x.ApparentEnclosingType + + /// Get the 'add' method associated with an event + member x.AddMethod = + match x with + | ILEvent ileinfo -> ILMeth(ileinfo.TcGlobals, ileinfo.AddMethod, None) + | FSEvent(g, p, addValRef, _) -> FSMeth(g, p.ApparentEnclosingType, addValRef, None) +#if !NO_EXTENSIONTYPING + | ProvidedEvent (amap, ei, m) -> + let meth = GetAndSanityCheckProviderMethod m ei (fun ei -> ei.GetAddMethod()) FSComp.SR.etEventNoAdd + ProvidedMeth(amap, meth, None, m) +#endif + + /// Get the 'remove' method associated with an event + member x.RemoveMethod = + match x with + | ILEvent ileinfo -> ILMeth(x.TcGlobals, ileinfo.RemoveMethod, None) + | FSEvent(g, p, _, removeValRef) -> FSMeth(g, p.ApparentEnclosingType, removeValRef, None) +#if !NO_EXTENSIONTYPING + | ProvidedEvent (amap, ei, m) -> + let meth = GetAndSanityCheckProviderMethod m ei (fun ei -> ei.GetRemoveMethod()) FSComp.SR.etEventNoRemove + ProvidedMeth(amap, meth, None, m) +#endif + + /// Try to get an arbitrary F# ValRef associated with the member. This is to determine if the member is virtual, amongst other things. + member x.ArbitraryValRef: ValRef option = + match x with + | FSEvent(_, _, addValRef, _) -> Some addValRef + | _ -> None + + /// Get the delegate type associated with the event. + member x.GetDelegateType(amap, m) = + match x with + | ILEvent(ILEventInfo(tinfo, edef)) -> + // Get the delegate type associated with an IL event, taking into account the instantiation of the + // declaring type. + if Option.isNone edef.EventType then error (nonStandardEventError x.EventName m) + ImportILTypeFromMetadata amap m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata [] edef.EventType.Value + + | FSEvent(g, p, _, _) -> + FindDelegateTypeOfPropertyEvent g amap x.EventName m (p.GetPropertyType(amap, m)) +#if !NO_EXTENSIONTYPING + | ProvidedEvent (_, ei, _) -> + Import.ImportProvidedType amap m (ei.PApply((fun ei -> ei.EventHandlerType), m)) +#endif + + + /// Test whether two event infos have the same underlying definition. + /// Must be compatible with ItemsAreEffectivelyEqual relation. + static member EventInfosUseIdenticalDefinitions x1 x2 = + match x1, x2 with + | FSEvent(g, pi1, vrefa1, vrefb1), FSEvent(_, pi2, vrefa2, vrefb2) -> + PropInfo.PropInfosUseIdenticalDefinitions pi1 pi2 && valRefEq g vrefa1 vrefa2 && valRefEq g vrefb1 vrefb2 + | ILEvent ileinfo1, ILEvent ileinfo2 -> (ileinfo1.RawMetadata === ileinfo2.RawMetadata) +#if !NO_EXTENSIONTYPING + | ProvidedEvent (_, ei1, _), ProvidedEvent (_, ei2, _) -> ProvidedEventInfo.TaintedEquals (ei1, ei2) +#endif + | _ -> false + + /// Calculates a hash code of event info (similar as previous) + /// Must be compatible with ItemsAreEffectivelyEqual relation. + member ei.ComputeHashCode() = + match ei with + | ILEvent ileinfo -> hash ileinfo.RawMetadata.Name + | FSEvent(_, pi, vref1, vref2) -> hash ( pi.ComputeHashCode(), vref1.LogicalName, vref2.LogicalName) +#if !NO_EXTENSIONTYPING + | ProvidedEvent (_, ei, _) -> ProvidedEventInfo.TaintedGetHashCode ei +#endif + override x.ToString() = "event " + x.EventName + +//------------------------------------------------------------------------- +// Helpers associated with getting and comparing method signatures + +/// Strips inref and outref to be a byref. +let stripByrefTy g ty = + if isByrefTy g ty then mkByrefTy g (destByrefTy g ty) + else ty + +/// Represents the information about the compiled form of a method signature. Used when analyzing implementation +/// relations between members and abstract slots. +type CompiledSig = CompiledSig of TType list list * TType option * Typars * TyparInst + +/// Get the information about the compiled form of a method signature. Used when analyzing implementation +/// relations between members and abstract slots. +let CompiledSigOfMeth g amap m (minfo: MethInfo) = + let formalMethTypars = minfo.FormalMethodTypars + let fminst = generalizeTypars formalMethTypars + let vargtys = minfo.GetParamTypes(amap, m, fminst) + let vrty = minfo.GetCompiledReturnTy(amap, m, fminst) + + // The formal method typars returned are completely formal - they don't take into account the instantiation + // of the enclosing type. For example, they may have constraints involving the _formal_ type parameters + // of the enclosing type. This instantiations can be used to interpret those type parameters + let fmtpinst = + let parentTyArgs = argsOfAppTy g minfo.ApparentEnclosingAppType + let memberParentTypars = minfo.GetFormalTyparsOfDeclaringType m + mkTyparInst memberParentTypars parentTyArgs + + CompiledSig(vargtys, vrty, formalMethTypars, fmtpinst) + + +/// Inref and outref parameter types will be treated as a byref type for equivalency. +let MethInfosEquivByPartialSig erasureFlag ignoreFinal g amap m (minfo: MethInfo) (minfo2: MethInfo) = + (minfo.GenericArity = minfo2.GenericArity) && + (ignoreFinal || minfo.IsFinal = minfo2.IsFinal) && + let formalMethTypars = minfo.FormalMethodTypars + let fminst = generalizeTypars formalMethTypars + let formalMethTypars2 = minfo2.FormalMethodTypars + let fminst2 = generalizeTypars formalMethTypars2 + let argtys = minfo.GetParamTypes(amap, m, fminst) + let argtys2 = minfo2.GetParamTypes(amap, m, fminst2) + (argtys, argtys2) ||> List.lengthsEqAndForall2 (List.lengthsEqAndForall2 (fun ty1 ty2 -> + typeAEquivAux erasureFlag g (TypeEquivEnv.FromEquivTypars formalMethTypars formalMethTypars2) (stripByrefTy g ty1) (stripByrefTy g ty2))) + +/// Used to hide/filter members from super classes based on signature +/// Inref and outref parameter types will be treated as a byref type for equivalency. +let MethInfosEquivByNameAndPartialSig erasureFlag ignoreFinal g amap m (minfo: MethInfo) (minfo2: MethInfo) = + (minfo.LogicalName = minfo2.LogicalName) && + MethInfosEquivByPartialSig erasureFlag ignoreFinal g amap m minfo minfo2 + +/// Used to hide/filter members from super classes based on signature +let PropInfosEquivByNameAndPartialSig erasureFlag g amap m (pinfo: PropInfo) (pinfo2: PropInfo) = + pinfo.PropertyName = pinfo2.PropertyName && + let argtys = pinfo.GetParamTypes(amap, m) + let argtys2 = pinfo2.GetParamTypes(amap, m) + List.lengthsEqAndForall2 (typeEquivAux erasureFlag g) argtys argtys2 + +/// Used to hide/filter members from super classes based on signature +let MethInfosEquivByNameAndSig erasureFlag ignoreFinal g amap m minfo minfo2 = + MethInfosEquivByNameAndPartialSig erasureFlag ignoreFinal g amap m minfo minfo2 && + let (CompiledSig(_, retTy, formalMethTypars, _)) = CompiledSigOfMeth g amap m minfo + let (CompiledSig(_, retTy2, formalMethTypars2, _)) = CompiledSigOfMeth g amap m minfo2 + match retTy, retTy2 with + | None, None -> true + | Some retTy, Some retTy2 -> typeAEquivAux erasureFlag g (TypeEquivEnv.FromEquivTypars formalMethTypars formalMethTypars2) retTy retTy2 + | _ -> false + +/// Used to hide/filter members from super classes based on signature +let PropInfosEquivByNameAndSig erasureFlag g amap m (pinfo: PropInfo) (pinfo2: PropInfo) = + PropInfosEquivByNameAndPartialSig erasureFlag g amap m pinfo pinfo2 && + let retTy = pinfo.GetPropertyType(amap, m) + let retTy2 = pinfo2.GetPropertyType(amap, m) + typeEquivAux erasureFlag g retTy retTy2 + +let SettersOfPropInfos (pinfos: PropInfo list) = pinfos |> List.choose (fun pinfo -> if pinfo.HasSetter then Some(pinfo.SetterMethod, Some pinfo) else None) +let GettersOfPropInfos (pinfos: PropInfo list) = pinfos |> List.choose (fun pinfo -> if pinfo.HasGetter then Some(pinfo.GetterMethod, Some pinfo) else None) + diff --git a/src/fsharp/lib.fs b/src/fsharp/lib.fs index a1d30cecabf..f3f82adba57 100755 --- a/src/fsharp/lib.fs +++ b/src/fsharp/lib.fs @@ -10,11 +10,14 @@ open Internal.Utilities open FSharp.Compiler.AbstractIL.Internal open FSharp.Compiler.AbstractIL.Internal.Library -/// is this the developer-debug build? let debug = false + let verbose = false + let mutable progress = false -let mutable tracking = false // intended to be a general hook to control diagnostic output when tracking down bugs + +// Intended to be a general hook to control diagnostic output when tracking down bugs +let mutable tracking = false let condition s = try (System.Environment.GetEnvironmentVariable(s) <> null) with _ -> false @@ -80,18 +83,14 @@ module Pair = type NameSet = Zset -[] + module NameSet = let ofList l : NameSet = List.foldBack Zset.add l (Zset.empty String.order) -[] module NameMap = let domain m = Map.foldBack (fun x _ acc -> Zset.add x acc) m (Zset.empty String.order) let domainL m = Zset.elements (domain m) - - -//--------------------------------------------------------------------------- // Library: Pre\Post checks //------------------------------------------------------------------------- module Check = @@ -109,7 +108,6 @@ module Check = | null -> raise (new System.ArgumentNullException(argName)) | _ -> () - /// Throw System.ArgumentNullException if array argument is null. /// Throw System.ArgumentOutOfRangeException is array argument is empty. let ArrayArgumentNotNullOrEmpty (arr:'T[]) argName = @@ -171,7 +169,7 @@ module ListAssoc = module ListSet = let inline contains f x l = List.exists (f x) l - (* NOTE: O(n)! *) + /// NOTE: O(n)! let insert f x l = if contains f x l then l else x :: l let unionFavourRight f l1 l2 = @@ -180,12 +178,13 @@ module ListSet = | [], _ -> l2 | _ -> List.foldBack (insert f) l1 l2 (* nb. foldBack to preserve natural orders *) - (* NOTE: O(n)! *) + /// NOTE: O(n)! let rec private findIndexAux eq x l n = match l with | [] -> notFound() | (h :: t) -> if eq h x then n else findIndexAux eq x t (n+1) + /// NOTE: O(n)! let findIndex eq x l = findIndexAux eq x l 0 let rec remove f x l = @@ -193,15 +192,17 @@ module ListSet = | (h :: t) -> if f x h then t else h :: remove f x t | [] -> [] - (* NOTE: quadratic! *) + /// NOTE: quadratic! let rec subtract f l1 l2 = match l2 with | (h :: t) -> subtract f (remove (fun y2 y1 -> f y1 y2) h l1) t | [] -> l1 let isSubsetOf f l1 l2 = List.forall (fun x1 -> contains f x1 l2) l1 - (* nb. preserve orders here: f must be applied to elements of l1 then elements of l2*) + + /// nb. preserve orders here: f must be applied to elements of l1 then elements of l2 let isSupersetOf f l1 l2 = List.forall (fun x2 -> contains (fun y2 y1 -> f y1 y2) x2 l1) l2 + let equals f l1 l2 = isSubsetOf f l1 l2 && isSupersetOf f l1 l2 let unionFavourLeft f l1 l2 = @@ -210,14 +211,13 @@ module ListSet = | [], _ -> l2 | _ -> l1 @ (subtract f l2 l1) - - (* NOTE: not tail recursive! *) + /// NOTE: not tail recursive! let rec intersect f l1 l2 = match l2 with | (h :: t) -> if contains f h l1 then h :: intersect f l1 t else intersect f l1 t | [] -> [] - // Note: if duplicates appear, keep the ones toward the _front_ of the list + /// Note: if duplicates appear, keep the ones toward the _front_ of the list let setify f l = List.fold (fun acc x -> insert f x acc) [] l |> List.rev let hasDuplicates f l = @@ -242,29 +242,49 @@ module ListSet = //------------------------------------------------------------------------ let mapFoldFst f s (x, y) = let x2, s = f s x in (x2, y), s + let mapFoldSnd f s (x, y) = let y2, s = f s y in (x, y2), s + let pair a b = a, b let p13 (x, _y, _z) = x + let p23 (_x, y, _z) = y + let p33 (_x, _y, z) = z let map1Of2 f (a1, a2) = (f a1, a2) + let map2Of2 f (a1, a2) = (a1, f a2) + let map1Of3 f (a1, a2, a3) = (f a1, a2, a3) + let map2Of3 f (a1, a2, a3) = (a1, f a2, a3) + let map3Of3 f (a1, a2, a3) = (a1, a2, f a3) + let map3Of4 f (a1, a2, a3, a4) = (a1, a2, f a3, a4) + let map4Of4 f (a1, a2, a3, a4) = (a1, a2, a3, f a4) + let map5Of5 f (a1, a2, a3, a4, a5) = (a1, a2, a3, a4, f a5) + let map6Of6 f (a1, a2, a3, a4, a5, a6) = (a1, a2, a3, a4, a5, f a6) + let foldPair (f1, f2) acc (a1, a2) = f2 (f1 acc a1) a2 + let fold1Of2 f1 acc (a1, _a2) = f1 acc a1 + let foldTriple (f1, f2, f3) acc (a1, a2, a3) = f3 (f2 (f1 acc a1) a2) a3 + let foldQuadruple (f1, f2, f3, f4) acc (a1, a2, a3, a4) = f4 (f3 (f2 (f1 acc a1) a2) a3) a4 + let mapPair (f1, f2) (a1, a2) = (f1 a1, f2 a2) + let mapTriple (f1, f2, f3) (a1, a2, a3) = (f1 a1, f2 a2, f3 a3) + let mapQuadruple (f1, f2, f3, f4) (a1, a2, a3, a4) = (f1 a1, f2 a2, f3 a3, f4 a4) + let fmap2Of2 f z (a1, a2) = let z, a2 = f z a2 in z, (a1, a2) //--------------------------------------------------------------------------- @@ -292,23 +312,15 @@ module Zset = if Zset.equal s s0 then s0 (* fixed *) else fixpoint f s (* iterate *) -//--------------------------------------------------------------------------- -// Misc -//------------------------------------------------------------------------- - let equalOn f x y = (f x) = (f y) - -//--------------------------------------------------------------------------- -// Buffer printing utilities -//--------------------------------------------------------------------------- - +/// Buffer printing utility let bufs f = let buf = System.Text.StringBuilder 100 f buf buf.ToString() -// writing to output stream via a string buffer. +/// Writing to output stream via a string buffer. let writeViaBuffer (os: TextWriter) f x = let buf = System.Text.StringBuilder 100 f buf x @@ -571,7 +583,7 @@ type DisposablesTracker() = let items = Stack() - /// Regsiter some items to dispose + /// Register some items to dispose member _.Register i = items.Push i interface IDisposable with diff --git a/src/fsharp/lib.fsi b/src/fsharp/lib.fsi new file mode 100644 index 00000000000..d7957a1a304 --- /dev/null +++ b/src/fsharp/lib.fsi @@ -0,0 +1,274 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module internal FSharp.Compiler.Lib + +open System.Collections.Generic +open System.IO +open System.Text +open FSharp.Compiler.AbstractIL.Internal + +val debug: bool + +val verbose: bool + +val mutable progress: bool + +val mutable tracking: bool + +val condition: s:string -> bool + +val GetEnvInteger: e:string -> dflt:int -> int + +val dispose: x:System.IDisposable -> unit + +module Bits = + val b0: n:int -> int + val b1: n:int -> int + val b2: n:int -> int + val b3: n:int -> int + val pown32: n:int -> int + val pown64: n:int -> int64 + val mask32: m:int32 -> n:int -> int + val mask64: m:int32 -> n:int -> int64 + +module Filename = + val fullpath: cwd:string -> nm:string -> string + val hasSuffixCaseInsensitive: suffix:string -> filename:string -> bool + val isDll: file:string -> bool + +module Bool = + val order: IComparer + +module Int32 = + val order: IComparer + +module Int64 = + val order: IComparer + +module Pair = + val order : + compare1:IComparer<'T1> * + compare2:IComparer<'T2> -> + IComparer<'T1 * 'T2> + +type NameSet = Zset +module NameSet = + val ofList: l:string list -> NameSet + +module NameMap = + val domain: m:Map -> Zset + val domainL: m:Map -> string list + +module Check = + /// Throw System.InvalidOperationException if argument is None. + /// If there is a value (e.g. Some(value)) then value is returned. + val NotNone: argName:string -> arg:'T option -> 'T + + /// Throw System.ArgumentNullException if argument is null. + val ArgumentNotNull: arg:'a -> argName:string -> unit + + /// Throw System.ArgumentNullException if array argument is null. + /// Throw System.ArgumentOutOfRangeException is array argument is empty. + val ArrayArgumentNotNullOrEmpty: arr:'T [] -> argName:string -> unit + + /// Throw System.ArgumentNullException if string argument is null. + /// Throw System.ArgumentOutOfRangeException is string argument is empty. + val StringArgumentNotNullOrEmpty: s:string -> argName:string -> unit + +type IntMap<'T> = Zmap + +module IntMap = + val empty: unit -> Zmap + + val add : k:int -> v:'T -> t:IntMap<'T> -> Zmap + + val find: k:int -> t:IntMap<'T> -> 'T + + val tryFind: k:int -> t:IntMap<'T> -> 'T option + + val remove: k:int -> t:IntMap<'T> -> Zmap + + val mem: k:int -> t:IntMap<'T> -> bool + + val iter: f:(int -> 'T -> unit) -> t:IntMap<'T> -> unit + + val map: f:('T -> 'a) -> t:IntMap<'T> -> Zmap + + val fold: f:(int -> 'T -> 'a -> 'a) -> t:IntMap<'T> -> z:'a -> 'a + +module ListAssoc = + + /// Treat a list of key-value pairs as a lookup collection. + /// This function looks up a value based on a match from the supplied predicate function. + val find: f:('a -> 'b -> bool) -> x:'a -> l:('b * 'c) list -> 'c + + /// Treat a list of key-value pairs as a lookup collection. + /// This function looks up a value based on a match from the supplied + /// predicate function and returns None if value does not exist. + val tryFind : f:('key -> 'key -> bool) -> x:'key -> l:('key * 'value) list -> 'value option + +module ListSet = + val inline contains: f:('a -> 'b -> bool) -> x:'a -> l:'b list -> bool + + /// NOTE: O(n)! + val insert: f:('a -> 'a -> bool) -> x:'a -> l:'a list -> 'a list + + val unionFavourRight : f:('a -> 'a -> bool) -> l1:'a list -> l2:'a list -> 'a list + + /// NOTE: O(n)! + val findIndex: eq:('a -> 'b -> bool) -> x:'b -> l:'a list -> int + + val remove: f:('a -> 'b -> bool) -> x:'a -> l:'b list -> 'b list + + /// NOTE: quadratic! + val subtract: f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> 'a list + + val isSubsetOf: f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool + + val isSupersetOf : f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool + + val equals: f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool + + val unionFavourLeft : f:('a -> 'a -> bool) -> l1:'a list -> l2:'a list -> 'a list + + /// NOTE: not tail recursive! + val intersect : f:('a -> 'b -> bool) -> l1:'b list -> l2:'a list -> 'a list + + /// Note: if duplicates appear, keep the ones toward the _front_ of the list + val setify: f:('a -> 'a -> bool) -> l:'a list -> 'a list + + val hasDuplicates: f:('a -> 'a -> bool) -> l:'a list -> bool + +val mapFoldFst : f:('a -> 'b -> 'c * 'd) -> s:'a -> x:'b * y:'e -> ('c * 'e) * 'd + +val mapFoldSnd : f:('a -> 'b -> 'c * 'd) -> s:'a -> x:'e * y:'b -> ('e * 'c) * 'd + +val pair: a:'a -> b:'b -> 'a * 'b + +val p13: x:'a * _y:'b * _z:'c -> 'a + +val p23: _x:'a * y:'b * _z:'c -> 'b + +val p33: _x:'a * _y:'b * z:'c -> 'c + +val map1Of2: f:('a -> 'b) -> a1:'a * a2:'c -> 'b * 'c + +val map2Of2: f:('a -> 'b) -> a1:'c * a2:'a -> 'c * 'b + +val map1Of3: f:('a -> 'b) -> a1:'a * a2:'c * a3:'d -> 'b * 'c * 'd + +val map2Of3: f:('a -> 'b) -> a1:'c * a2:'a * a3:'d -> 'c * 'b * 'd + +val map3Of3: f:('a -> 'b) -> a1:'c * a2:'d * a3:'a -> 'c * 'd * 'b + +val map3Of4 : f:('a -> 'b) -> a1:'c * a2:'d * a3:'a * a4:'e -> 'c * 'd * 'b * 'e + +val map4Of4 : f:('a -> 'b) -> a1:'c * a2:'d * a3:'e * a4:'a -> 'c * 'd * 'e * 'b + +val map5Of5 : f:('a -> 'b) -> a1:'c * a2:'d * a3:'e * a4:'f * a5:'a -> 'c * 'd * 'e * 'f * 'b + +val map6Of6 : f:('a -> 'b) -> a1:'c * a2:'d * a3:'e * a4:'f * a5:'g * a6:'a -> 'c * 'd * 'e * 'f * 'g * 'b + +val foldPair : f1:('a -> 'b -> 'c) * f2:('c -> 'd -> 'e) -> acc:'a -> a1:'b * a2:'d -> 'e + +val fold1Of2: f1:('a -> 'b -> 'c) -> acc:'a -> a1:'b * _a2:'d -> 'c + +val foldTriple : f1:('a -> 'b -> 'c) * f2:('c -> 'd -> 'e) * f3:('e -> 'f -> 'g) -> acc:'a -> a1:'b * a2:'d * a3:'f -> 'g + +val foldQuadruple : f1:('a -> 'b -> 'c) * f2:('c -> 'd -> 'e) * f3:('e -> 'f -> 'g) * f4:('g -> 'h -> 'i) -> acc:'a -> a1:'b * a2:'d * a3:'f * a4:'h -> 'i val mapPair: f1:('a -> 'b) * f2:('c -> 'd) -> a1:'a * a2:'c -> 'b * 'd + +val mapTriple : f1:('a -> 'b) * f2:('c -> 'd) * f3:('e -> 'f) -> a1:'a * a2:'c * a3:'e -> 'b * 'd * 'f + +val mapQuadruple : f1:('a -> 'b) * f2:('c -> 'd) * f3:('e -> 'f) * f4:('g -> 'h) -> a1:'a * a2:'c * a3:'e * a4:'g -> 'b * 'd * 'f * 'h + +val fmap2Of2 : f:('a -> 'b -> 'c * 'd) -> z:'a -> a1:'e * a2:'b -> 'c * ('e * 'd) + +module Zmap = + val force: k:'a -> mp:Zmap<'a,'b> -> 'b + val mapKey :key:'a -> f:('b option -> 'b option) -> mp:Zmap<'a,'b> -> Zmap<'a,'b> + +module Zset = + val ofList : order:IComparer<'a> -> xs:'a list -> Zset<'a> + val fixpoint : f:(Zset<'a> -> Zset<'a>) -> Zset<'a> -> Zset<'a> + +val equalOn: f:('a -> 'b) -> x:'a -> y:'a -> bool when 'b: equality + +/// Buffer printing utility +val bufs: f:(StringBuilder -> unit) -> string + +/// Writing to output stream via a string buffer. +val writeViaBuffer : os:TextWriter -> f:(StringBuilder -> 'a -> unit) -> x:'a -> unit + +type Graph<'Data,'Id when 'Id: comparison> = + + new: nodeIdentity:('Data -> 'Id) * nodes:'Data list * + edges:('Data * 'Data) list -> Graph<'Data,'Id> + member GetNodeData: nodeId:'Id -> 'Data + member IterateCycles: f:('Data list -> unit) -> unit + +/// In some cases we play games where we use 'null' as a more efficient representation +/// in F#. The functions below are used to give initial values to mutable fields. +/// This is an unsafe trick, as it relies on the fact that the type of values +/// being placed into the slot never utilizes "null" as a representation. To be used with +/// with care. +type NonNullSlot<'T> = 'T + +val nullableSlotEmpty: unit -> 'T + +val nullableSlotFull: x:'a -> 'a + +/// Caches, mainly for free variables +type cache<'T> = { mutable cacheVal: NonNullSlot<'T> } + +val newCache: unit -> cache<'a> + +val inline cached: cache:cache<'a> -> resF:(unit -> 'a) -> 'a + +val inline cacheOptByref: cache:byref<'T option> -> f:(unit -> 'T) -> 'T + +val inline cacheOptRef: cache:'a option ref -> f:(unit -> 'a) -> 'a + +val inline tryGetCacheValue: cache:cache<'a> -> NonNullSlot<'a> voption + +module AsyncUtil = + + /// Represents the reified result of an asynchronous computation. + [] + type AsyncResult<'T> = + | AsyncOk of 'T + | AsyncException of exn + | AsyncCanceled of System.OperationCanceledException + static member Commit: res:AsyncResult<'T> -> Async<'T> + + /// When using .NET 4.0 you can replace this type by + [] + type AsyncResultCell<'T> = + + new: unit -> AsyncResultCell<'T> + member RegisterResult: res:AsyncResult<'T> -> unit + member AsyncResult: Async<'T> + +module UnmanagedProcessExecutionOptions = + val EnableHeapTerminationOnCorruption: unit -> unit + +module StackGuard = + val EnsureSufficientExecutionStack: recursionDepth:int -> unit + +[] +type MaybeLazy<'T> = + | Strict of 'T + | Lazy of System.Lazy<'T> + member Force: unit -> 'T + member Value: 'T + +val inline vsnd: struct ('T * 'T) -> 'T + +/// Track a set of resources to cleanup +type DisposablesTracker = + + new: unit -> DisposablesTracker + + /// Register some items to dispose + member Register: i:System.IDisposable -> unit + + interface System.IDisposable diff --git a/src/fsharp/utils/CompilerLocationUtils.fs b/src/fsharp/utils/CompilerLocationUtils.fs index 58f9a03d1fb..5bff0b5930d 100644 --- a/src/fsharp/utils/CompilerLocationUtils.fs +++ b/src/fsharp/utils/CompilerLocationUtils.fs @@ -38,8 +38,7 @@ module internal FSharpEnvironment = let isRunningOnCoreClr = (typeof.Assembly).FullName.StartsWith("System.Private.CoreLib", StringComparison.InvariantCultureIgnoreCase) -#if FX_NO_WIN_REGISTRY -#else +#if !FX_NO_WIN_REGISTRY [] extern uint32 RegOpenKeyExW(UIntPtr _hKey, string _lpSubKey, uint32 _ulOptions, int _samDesired, UIntPtr & _phkResult); @@ -60,8 +59,7 @@ module internal FSharpEnvironment = let maxPath = 260; let maxDataLength = (new System.Text.UTF32Encoding()).GetMaxByteCount(maxPath) -#if FX_NO_WIN_REGISTRY -#else +#if !FX_NO_WIN_REGISTRY let KEY_WOW64_DEFAULT = 0x0000 let KEY_WOW64_32KEY = 0x0200 let HKEY_LOCAL_MACHINE = UIntPtr(0x80000002u) diff --git a/src/fsharp/utils/CompilerLocationUtils.fsi b/src/fsharp/utils/CompilerLocationUtils.fsi new file mode 100644 index 00000000000..15cf7ab934b --- /dev/null +++ b/src/fsharp/utils/CompilerLocationUtils.fsi @@ -0,0 +1,43 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +namespace Internal.Utilities + +open Microsoft.FSharp.Core + +module internal FSharpEnvironment = + + module internal FSharpEnvironment = + val FSharpBannerVersion: string + + val FSharpProductName: string + + val FSharpCoreLibRunningVersion: string option + + val FSharpBinaryMetadataFormatRevision: string + + val isRunningOnCoreClr: bool + + val tryCurrentDomain: unit -> string option + + // The default location of FSharp.Core.dll and fsc.exe based on the version of fsc.exe that is running + // Used for + // - location of design-time copies of FSharp.Core.dll and FSharp.Compiler.Interactive.Settings.dll for the default assumed environment for scripts + // - default ToolPath in tasks in FSharp.Build.dll (for Fsc tasks, but note a probe location is given) + // - default F# binaries directory in service.fs (REVIEW: check this) + // - default location of fsi.exe in FSharp.VS.FSI.dll (REVIEW: check this) + // - default F# binaries directory in (project system) Project.fs + val BinFolderOfDefaultFSharpCompiler: probePoint:string option -> string option + + val toolingCompatiblePaths: unit -> string list + + val searchToolPaths: + path:string option -> compilerToolPaths:seq -> seq + + val getTypeProviderAssembly: + runTimeAssemblyFileName:string * + designTimeAssemblyName:string * + compilerToolPaths:string list * + raiseError:(string option -> exn -> System.Reflection.Assembly option) + -> System.Reflection.Assembly option + + val getCompilerToolsDesignTimeAssemblyPaths: compilerToolPaths:seq -> seq \ No newline at end of file diff --git a/src/fsharp/utils/EditDistance.fsi b/src/fsharp/utils/EditDistance.fsi new file mode 100644 index 00000000000..83f9c650973 --- /dev/null +++ b/src/fsharp/utils/EditDistance.fsi @@ -0,0 +1,12 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +module internal Internal.Utilities.EditDistance + +/// Calculates the Jaro-Winkler edit distance between two strings. +/// The edit distance is a metric that allows to measure the amount of similarity between two strings. +val JaroWinklerDistance : s1:string -> s2:string -> float + +/// Calculates the edit distance between two strings. +/// The edit distance is a metric that allows to measure the amount of difference between two strings +/// and shows how many edit operations (insert, delete, substitution) are needed to transform one string into the other. +val CalcEditDistance : a:string * b:string -> int diff --git a/tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs b/tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs index 1ad05aff27b..4df1e4a2ac5 100644 --- a/tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs +++ b/tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs @@ -20021,7 +20021,6 @@ FSharp.Compiler.ParseHelpers: FSharp.Compiler.ParseHelpers+LexerIfdefStackEntry FSharp.Compiler.ParseHelpers: FSharp.Compiler.ParseHelpers+LexerStringKind FSharp.Compiler.ParseHelpers: FSharp.Compiler.ParseHelpers+LexerStringStyle FSharp.Compiler.ParseHelpers: FSharp.Compiler.ParseHelpers+SyntaxError -FSharp.Compiler.ParseHelpers: ILInstr[] ParseAssemblyCodeInstructions(System.String, range) FSharp.Compiler.ParseHelpers: ILType ParseAssemblyCodeType(System.String, range) FSharp.Compiler.ParseHelpers+IndentationProblem: Boolean Equals(System.Exception) FSharp.Compiler.ParseHelpers+IndentationProblem: Boolean Equals(System.Object) From 47f7943b10777082467573fcc925ec3af6661b9a Mon Sep 17 00:00:00 2001 From: Don Syme Date: Fri, 11 Dec 2020 18:46:27 +0000 Subject: [PATCH 2/8] add signatures --- src/fsharp/AccessibilityLogic.fs | 6 +- src/fsharp/AccessibilityLogic.fsi | 401 +- src/fsharp/AttributeChecking.fsi | 533 +- src/fsharp/FSharp.Compiler.Service/all.fsi | 8602 +------------------- src/fsharp/InfoReader.fs | 2 - src/fsharp/InfoReader.fsi | 902 +- src/fsharp/PostInferenceChecks.fs | 8 +- src/fsharp/TypeRelations.fs | 2 - src/fsharp/TypeRelations.fsi | 274 +- src/fsharp/TypedTreeBasics.fs | 2 +- src/fsharp/TypedTreeOps.fsi | 3 + src/fsharp/infos.fs | 124 +- src/fsharp/infos.fsi | 2619 ++---- 13 files changed, 788 insertions(+), 12690 deletions(-) diff --git a/src/fsharp/AccessibilityLogic.fs b/src/fsharp/AccessibilityLogic.fs index 3d5aadc98cc..2a031949e7d 100644 --- a/src/fsharp/AccessibilityLogic.fs +++ b/src/fsharp/AccessibilityLogic.fs @@ -19,11 +19,9 @@ open FSharp.Compiler.ExtensionTyping /// Represents the 'keys' a particular piece of code can use to access other constructs?. [] type AccessorDomain = - /// AccessibleFrom(cpaths, tyconRefOpt) - /// /// cpaths: indicates we have the keys to access any members private to the given paths /// tyconRefOpt: indicates we have the keys to access any protected members of the super types of 'TyconRef' - | AccessibleFrom of CompilationPath list * TyconRef option + | AccessibleFrom of cpaths: CompilationPath list * tyconRefOpt: TyconRef option /// An AccessorDomain which returns public items | AccessibleFromEverywhere @@ -46,6 +44,7 @@ type AccessorDomain = | AccessibleFromEverywhere -> 2 | AccessibleFromSomeFSharpCode -> 3 | AccessibleFromSomewhere -> 4 + static member CustomEquals(g:TcGlobals, ad1:AccessorDomain, ad2:AccessorDomain) = match ad1, ad2 with | AccessibleFrom(cs1, tc1), AccessibleFrom(cs2, tc2) -> (cs1 = cs2) && (match tc1, tc2 with None, None -> true | Some tc1, Some tc2 -> tyconRefEq g tc1 tc2 | _ -> false) @@ -224,7 +223,6 @@ let ComputeILAccess isPublic isFamily isFamilyOrAssembly isFamilyAndAssembly = elif isFamilyAndAssembly then ILMemberAccess.FamilyAndAssembly else ILMemberAccess.Private -/// IndiCompute the accessibility of a provided member let IsILFieldInfoAccessible g amap m ad x = match x with | ILFieldInfo (tinfo, fd) -> IsILTypeAndMemberAccessible g amap m ad ad tinfo fd.Access diff --git a/src/fsharp/AccessibilityLogic.fsi b/src/fsharp/AccessibilityLogic.fsi index 3d5aadc98cc..55fa500f1b2 100644 --- a/src/fsharp/AccessibilityLogic.fsi +++ b/src/fsharp/AccessibilityLogic.fsi @@ -5,25 +5,18 @@ module internal FSharp.Compiler.AccessibilityLogic open FSharp.Compiler.AbstractIL.IL open FSharp.Compiler -open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.Import open FSharp.Compiler.Infos open FSharp.Compiler.TypedTree -open FSharp.Compiler.TypedTreeBasics -open FSharp.Compiler.TypedTreeOps +open FSharp.Compiler.Range open FSharp.Compiler.TcGlobals -#if !NO_EXTENSIONTYPING -open FSharp.Compiler.ExtensionTyping -#endif - /// Represents the 'keys' a particular piece of code can use to access other constructs?. [] -type AccessorDomain = - /// AccessibleFrom(cpaths, tyconRefOpt) - /// +type AccessorDomain = /// cpaths: indicates we have the keys to access any members private to the given paths /// tyconRefOpt: indicates we have the keys to access any protected members of the super types of 'TyconRef' - | AccessibleFrom of CompilationPath list * TyconRef option + | AccessibleFrom of cpaths: CompilationPath list * tyconRefOpt: TyconRef option /// An AccessorDomain which returns public items | AccessibleFromEverywhere @@ -33,357 +26,75 @@ type AccessorDomain = /// - when solving member trait constraints, which are solved independently of accessibility /// - for failure paths in error reporting, e.g. to produce an error that an F# item is not accessible /// - an adhoc use in service.fs to look up a delegate signature - | AccessibleFromSomeFSharpCode + | AccessibleFromSomeFSharpCode /// An AccessorDomain which returns all items - | AccessibleFromSomewhere + | AccessibleFromSomewhere // Hashing and comparison is used for the memoization tables keyed by an accessor domain. // It is dependent on a TcGlobals because of the TyconRef in the data structure - static member CustomGetHashCode(ad:AccessorDomain) = - match ad with - | AccessibleFrom _ -> 1 - | AccessibleFromEverywhere -> 2 - | AccessibleFromSomeFSharpCode -> 3 - | AccessibleFromSomewhere -> 4 - static member CustomEquals(g:TcGlobals, ad1:AccessorDomain, ad2:AccessorDomain) = - match ad1, ad2 with - | AccessibleFrom(cs1, tc1), AccessibleFrom(cs2, tc2) -> (cs1 = cs2) && (match tc1, tc2 with None, None -> true | Some tc1, Some tc2 -> tyconRefEq g tc1 tc2 | _ -> false) - | AccessibleFromEverywhere, AccessibleFromEverywhere -> true - | AccessibleFromSomeFSharpCode, AccessibleFromSomeFSharpCode -> true - | AccessibleFromSomewhere, AccessibleFromSomewhere -> true - | _ -> false + static member CustomEquals: g:TcGlobals * ad1:AccessorDomain * ad2:AccessorDomain -> bool + // Hashing and comparison is used for the memoization tables keyed by an accessor domain. + // It is dependent on a TcGlobals because of the TyconRef in the data structure + static member CustomGetHashCode: ad:AccessorDomain -> int + /// Indicates if an F# item is accessible -let IsAccessible ad taccess = - match ad with - | AccessibleFromEverywhere -> canAccessFromEverywhere taccess - | AccessibleFromSomeFSharpCode -> canAccessFromSomewhere taccess - | AccessibleFromSomewhere -> true - | AccessibleFrom (cpaths, _tcrefViewedFromOption) -> - List.exists (canAccessFrom taccess) cpaths - -/// Indicates if an IL member is accessible (ignoring its enclosing type) -let private IsILMemberAccessible g amap m (tcrefOfViewedItem : TyconRef) ad access = - match ad with - | AccessibleFromEverywhere -> - access = ILMemberAccess.Public - - | AccessibleFromSomeFSharpCode -> - (access = ILMemberAccess.Public || - access = ILMemberAccess.Family || - access = ILMemberAccess.FamilyOrAssembly) - - | AccessibleFrom (cpaths, tcrefViewedFromOption) -> - - let accessibleByFamily = - ((access = ILMemberAccess.Family || - access = ILMemberAccess.FamilyOrAssembly) && - match tcrefViewedFromOption with - | None -> false - | Some tcrefViewedFrom -> - ExistsHeadTypeInEntireHierarchy g amap m (generalizedTyconRef tcrefViewedFrom) tcrefOfViewedItem) - - let accessibleByInternalsVisibleTo = - (access = ILMemberAccess.Assembly || access = ILMemberAccess.FamilyOrAssembly) && - canAccessFromOneOf cpaths tcrefOfViewedItem.CompilationPath - - let accessibleByFamilyAndAssembly = - access = ILMemberAccess.FamilyAndAssembly && - canAccessFromOneOf cpaths tcrefOfViewedItem.CompilationPath && - match tcrefViewedFromOption with - | None -> false - | Some tcrefViewedFrom -> - ExistsHeadTypeInEntireHierarchy g amap m (generalizedTyconRef tcrefViewedFrom) tcrefOfViewedItem - - (access = ILMemberAccess.Public) || accessibleByFamily || accessibleByInternalsVisibleTo || accessibleByFamilyAndAssembly - - | AccessibleFromSomewhere -> - true - -/// Indicates if tdef is accessible. If tdef.Access = ILTypeDefAccess.Nested then encTyconRefOpt s TyconRef of enclosing type -/// and visibility of tdef is obtained using member access rules -let private IsILTypeDefAccessible (amap : Import.ImportMap) m ad encTyconRefOpt (tdef: ILTypeDef) = - match tdef.Access with - | ILTypeDefAccess.Nested nestedAccess -> - match encTyconRefOpt with - | None -> assert false; true - | Some encTyconRef -> IsILMemberAccessible amap.g amap m encTyconRef ad nestedAccess - | _ -> - match ad with - | AccessibleFromSomewhere -> true - | AccessibleFromEverywhere - | AccessibleFromSomeFSharpCode - | AccessibleFrom _ -> tdef.Access = ILTypeDefAccess.Public - -/// Indicates if a TyconRef is visible through the AccessibleFrom(cpaths, _). -/// Note that InternalsVisibleTo extends those cpaths. -let private IsTyconAccessibleViaVisibleTo ad (tcrefOfViewedItem:TyconRef) = - match ad with - | AccessibleFromEverywhere - | AccessibleFromSomewhere - | AccessibleFromSomeFSharpCode -> false - | AccessibleFrom (cpaths, _tcrefViewedFromOption) -> - canAccessFromOneOf cpaths tcrefOfViewedItem.CompilationPath - -/// Indicates if given IL based TyconRef is accessible. If TyconRef is nested then we'll -/// walk though the list of enclosing types and test if all of them are accessible -let private IsILTypeInfoAccessible amap m ad (tcrefOfViewedItem : TyconRef) = - let (TILObjectReprData(scoref, enc, tdef)) = tcrefOfViewedItem.ILTyconInfo - let rec check parentTycon path = - let ilTypeDefAccessible = - match parentTycon with - | None -> - match path with - | [] -> assert false; true // in this case path should have at least one element - | [x] -> IsILTypeDefAccessible amap m ad None x // shortcut for non-nested types - | x :: xs -> - // check if enclosing type x is accessible. - // if yes - create parent tycon for type 'x' and continue with the rest of the path - IsILTypeDefAccessible amap m ad None x && - ( - let parentILTyRef = mkRefForNestedILTypeDef scoref ([], x) - let parentTycon = Import.ImportILTypeRef amap m parentILTyRef - check (Some (parentTycon, [x])) xs - ) - | (Some (parentTycon, parentPath)) -> - match path with - | [] -> true // end of path is reached - success - | x :: xs -> - // check if x is accessible from the parent tycon - // if yes - create parent tycon for type 'x' and continue with the rest of the path - IsILTypeDefAccessible amap m ad (Some parentTycon) x && - ( - let parentILTyRef = mkRefForNestedILTypeDef scoref (parentPath, x) - let parentTycon = Import.ImportILTypeRef amap m parentILTyRef - check (Some (parentTycon, parentPath @ [x])) xs - ) - ilTypeDefAccessible || IsTyconAccessibleViaVisibleTo ad tcrefOfViewedItem - - check None (enc @ [tdef]) - -/// Indicates if an IL member associated with the given ILType is accessible -let private IsILTypeAndMemberAccessible g amap m adType ad (ty: ILTypeInfo) access = - IsILTypeInfoAccessible amap m adType ty.TyconRefOfRawMetadata && IsILMemberAccessible g amap m ty.TyconRefOfRawMetadata ad access +val IsAccessible: ad:AccessorDomain -> taccess:TypedTree.Accessibility -> bool /// Indicates if an entity is accessible -let IsEntityAccessible amap m ad (tcref:TyconRef) = - if tcref.IsILTycon then - IsILTypeInfoAccessible amap m ad tcref - else - tcref.Accessibility |> IsAccessible ad +val IsEntityAccessible: amap:ImportMap -> m:range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool /// Check that an entity is accessible -let CheckTyconAccessible amap m ad tcref = - let res = IsEntityAccessible amap m ad tcref - if not res then - errorR(Error(FSComp.SR.typeIsNotAccessible tcref.DisplayName, m)) - res +val CheckTyconAccessible: amap:ImportMap -> m:range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool /// Indicates if a type definition and its representation contents are accessible -let IsTyconReprAccessible amap m ad tcref = - IsEntityAccessible amap m ad tcref && - IsAccessible ad tcref.TypeReprAccessibility - +val IsTyconReprAccessible: amap:ImportMap -> m:range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool + /// Check that a type definition and its representation contents are accessible -let CheckTyconReprAccessible amap m ad tcref = - CheckTyconAccessible amap m ad tcref && - (let res = IsAccessible ad tcref.TypeReprAccessibility - if not res then - errorR (Error (FSComp.SR.unionCasesAreNotAccessible tcref.DisplayName, m)) - res) - +val CheckTyconReprAccessible: amap:ImportMap -> m:range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool + /// Indicates if a type is accessible (both definition and instantiation) -let rec IsTypeAccessible g amap m ad ty = - match tryAppTy g ty with - | ValueNone -> true - | ValueSome(tcref, tinst) -> - IsEntityAccessible amap m ad tcref && IsTypeInstAccessible g amap m ad tinst +val IsTypeAccessible: g:TcGlobals -> amap:ImportMap -> m:range -> ad:AccessorDomain -> ty:TypedTree.TType -> bool -and IsTypeInstAccessible g amap m ad tinst = - match tinst with - | [] -> true - | _ -> List.forall (IsTypeAccessible g amap m ad) tinst +val IsTypeInstAccessible: g:TcGlobals -> amap:ImportMap -> m:range -> ad:AccessorDomain -> tinst:TypedTree.TypeInst -> bool /// Indicate if a provided member is accessible -let IsProvidedMemberAccessible (amap:Import.ImportMap) m ad ty access = - let g = amap.g - if IsTypeAccessible g amap m ad ty then - match tryTcrefOfAppTy g ty with - | ValueNone -> true - | ValueSome tcrefOfViewedItem -> - IsILMemberAccessible g amap m tcrefOfViewedItem ad access - else - false +val IsProvidedMemberAccessible: amap:ImportMap -> m:range -> ad:AccessorDomain -> ty:TypedTree.TType -> access:ILMemberAccess -> bool /// Compute the accessibility of a provided member -let ComputeILAccess isPublic isFamily isFamilyOrAssembly isFamilyAndAssembly = - if isPublic then ILMemberAccess.Public - elif isFamily then ILMemberAccess.Family - elif isFamilyOrAssembly then ILMemberAccess.FamilyOrAssembly - elif isFamilyAndAssembly then ILMemberAccess.FamilyAndAssembly - else ILMemberAccess.Private - -/// IndiCompute the accessibility of a provided member -let IsILFieldInfoAccessible g amap m ad x = - match x with - | ILFieldInfo (tinfo, fd) -> IsILTypeAndMemberAccessible g amap m ad ad tinfo fd.Access -#if !NO_EXTENSIONTYPING - | ProvidedField (amap, tpfi, m) -> - let access = tpfi.PUntaint((fun fi -> ComputeILAccess fi.IsPublic fi.IsFamily fi.IsFamilyOrAssembly fi.IsFamilyAndAssembly), m) - IsProvidedMemberAccessible amap m ad x.ApparentEnclosingType access -#endif - -let GetILAccessOfILEventInfo (ILEventInfo (tinfo, edef)) = - (resolveILMethodRef tinfo.RawMetadata edef.AddMethod).Access - -let IsILEventInfoAccessible g amap m ad einfo = - let access = GetILAccessOfILEventInfo einfo - IsILTypeAndMemberAccessible g amap m ad ad einfo.ILTypeInfo access - -let private IsILMethInfoAccessible g amap m adType ad ilminfo = - match ilminfo with - | ILMethInfo (_, ty, None, mdef, _) -> IsILTypeAndMemberAccessible g amap m adType ad (ILTypeInfo.FromType g ty) mdef.Access - | ILMethInfo (_, _, Some declaringTyconRef, mdef, _) -> IsILMemberAccessible g amap m declaringTyconRef ad mdef.Access - -let GetILAccessOfILPropInfo (ILPropInfo(tinfo, pdef)) = - let tdef = tinfo.RawMetadata - let ilAccess = - match pdef.GetMethod, pdef.SetMethod with - | Some mref, None - | None, Some mref -> (resolveILMethodRef tdef mref).Access - - | Some mrefGet, Some mrefSet -> - // - // Dotnet properties have a getter and a setter method, each of which can have a separate visibility public, protected, private etc ... - // This code computes the visibility for the property by choosing the most visible method. This approximation is usefull for cases - // where the compiler needs to know the visibility of the property. - // The specific ordering for choosing the most visible is: - // ILMemberAccess.Public, - // ILMemberAccess.FamilyOrAssembly - // ILMemberAccess.Assembly - // ILMemberAccess.Family - // ILMemberAccess.FamilyAndAssembly - // ILMemberAccess.Private - // ILMemberAccess.CompilerControlled - // - let getA = (resolveILMethodRef tdef mrefGet).Access - let setA = (resolveILMethodRef tdef mrefSet).Access - - // Use the accessors to determine the visibility of the property. - // N.B. It is critical to keep the ordering in decreasing visibility order in the following match expression - match getA, setA with - | ILMemberAccess.Public, _ - | _, ILMemberAccess.Public -> ILMemberAccess.Public - - | ILMemberAccess.FamilyOrAssembly, _ - | _, ILMemberAccess.FamilyOrAssembly -> ILMemberAccess.FamilyOrAssembly - - | ILMemberAccess.Assembly, _ - | _, ILMemberAccess.Assembly -> ILMemberAccess.Assembly - - | ILMemberAccess.Family, _ - | _, ILMemberAccess.Family -> ILMemberAccess.Family - - | ILMemberAccess.FamilyAndAssembly, _ - | _, ILMemberAccess.FamilyAndAssembly -> ILMemberAccess.FamilyAndAssembly - - | ILMemberAccess.Private, _ - | _, ILMemberAccess.Private -> ILMemberAccess.Private - - | ILMemberAccess.CompilerControlled, _ - | _, ILMemberAccess.CompilerControlled -> ILMemberAccess.CompilerControlled - - | None, None -> ILMemberAccess.Public - - ilAccess - -let IsILPropInfoAccessible g amap m ad pinfo = - let ilAccess = GetILAccessOfILPropInfo pinfo - IsILTypeAndMemberAccessible g amap m ad ad pinfo.ILTypeInfo ilAccess - -let IsValAccessible ad (vref:ValRef) = - vref.Accessibility |> IsAccessible ad - -let CheckValAccessible m ad (vref:ValRef) = - if not (IsValAccessible ad vref) then - errorR (Error (FSComp.SR.valueIsNotAccessible vref.DisplayName, m)) - -let IsUnionCaseAccessible amap m ad (ucref:UnionCaseRef) = - IsTyconReprAccessible amap m ad ucref.TyconRef && - IsAccessible ad ucref.UnionCase.Accessibility - -let CheckUnionCaseAccessible amap m ad (ucref:UnionCaseRef) = - CheckTyconReprAccessible amap m ad ucref.TyconRef && - (let res = IsAccessible ad ucref.UnionCase.Accessibility - if not res then - errorR (Error (FSComp.SR.unionCaseIsNotAccessible ucref.CaseName, m)) - res) - -let IsRecdFieldAccessible amap m ad (rfref:RecdFieldRef) = - IsTyconReprAccessible amap m ad rfref.TyconRef && - IsAccessible ad rfref.RecdField.Accessibility - -let CheckRecdFieldAccessible amap m ad (rfref:RecdFieldRef) = - CheckTyconReprAccessible amap m ad rfref.TyconRef && - (let res = IsAccessible ad rfref.RecdField.Accessibility - if not res then - errorR (Error (FSComp.SR.fieldIsNotAccessible rfref.FieldName, m)) - res) - -let CheckRecdFieldInfoAccessible amap m ad (rfinfo:RecdFieldInfo) = - CheckRecdFieldAccessible amap m ad rfinfo.RecdFieldRef |> ignore - -let CheckILFieldInfoAccessible g amap m ad finfo = - if not (IsILFieldInfoAccessible g amap m ad finfo) then - errorR (Error (FSComp.SR.structOrClassFieldIsNotAccessible finfo.FieldName, m)) - -/// Uses a separate accessibility domains for containing type and method itself -/// This makes sense cases like -/// type A() = -/// type protected B() = -/// member this.Public() = () -/// member protected this.Protected() = () -/// type C() = -/// inherit A() -/// let x = A.B() -/// do x.Public() -/// when calling x.SomeMethod() we need to use 'adTyp' do verify that type of x is accessible from C -/// and 'ad' to determine accessibility of SomeMethod. -/// I.e when calling x.Public() and x.Protected() -in both cases first check should succeed and second - should fail in the latter one. -let IsTypeAndMethInfoAccessible amap m accessDomainTy ad = function - | ILMeth (g, x, _) -> IsILMethInfoAccessible g amap m accessDomainTy ad x - | FSMeth (_, _, vref, _) -> IsValAccessible ad vref - | DefaultStructCtor(g, ty) -> IsTypeAccessible g amap m ad ty -#if !NO_EXTENSIONTYPING - | ProvidedMeth(amap, tpmb, _, m) as etmi -> - let access = tpmb.PUntaint((fun mi -> ComputeILAccess mi.IsPublic mi.IsFamily mi.IsFamilyOrAssembly mi.IsFamilyAndAssembly), m) - IsProvidedMemberAccessible amap m ad etmi.ApparentEnclosingType access -#endif -let IsMethInfoAccessible amap m ad minfo = IsTypeAndMethInfoAccessible amap m ad ad minfo - -let IsPropInfoAccessible g amap m ad = function - | ILProp ilpinfo -> IsILPropInfoAccessible g amap m ad ilpinfo - | FSProp (_, _, Some vref, None) - | FSProp (_, _, None, Some vref) -> IsValAccessible ad vref - | FSProp (_, _, Some vrefGet, Some vrefSet) -> - // pick most accessible - IsValAccessible ad vrefGet || IsValAccessible ad vrefSet -#if !NO_EXTENSIONTYPING - | ProvidedProp (amap, tppi, m) as pp-> - let access = - let a = tppi.PUntaint((fun ppi -> - let tryGetILAccessForProvidedMethodBase (mi : ProvidedMethodBase) = - match mi with - | null -> None - | mi -> Some(ComputeILAccess mi.IsPublic mi.IsFamily mi.IsFamilyOrAssembly mi.IsFamilyAndAssembly) - match tryGetILAccessForProvidedMethodBase(ppi.GetGetMethod()) with - | None -> tryGetILAccessForProvidedMethodBase(ppi.GetSetMethod()) - | x -> x), m) - defaultArg a ILMemberAccess.Public - IsProvidedMemberAccessible amap m ad pp.ApparentEnclosingType access -#endif - | _ -> false - -let IsFieldInfoAccessible ad (rfref:RecdFieldInfo) = - IsAccessible ad rfref.RecdField.Accessibility +val ComputeILAccess: isPublic:bool -> isFamily:bool -> isFamilyOrAssembly:bool -> isFamilyAndAssembly:bool -> ILMemberAccess + +val IsILFieldInfoAccessible: g:TcGlobals -> amap:ImportMap -> m:range -> ad:AccessorDomain -> x:ILFieldInfo -> bool + +val GetILAccessOfILEventInfo: ILEventInfo -> ILMemberAccess + +val IsILEventInfoAccessible: g:TcGlobals -> amap:ImportMap -> m:range -> ad:AccessorDomain -> einfo:ILEventInfo -> bool + +val GetILAccessOfILPropInfo: ILPropInfo -> ILMemberAccess + +val IsILPropInfoAccessible: g:TcGlobals -> amap:ImportMap -> m:range -> ad:AccessorDomain -> pinfo:ILPropInfo -> bool + +val IsValAccessible: ad:AccessorDomain -> vref:TypedTree.ValRef -> bool + +val CheckValAccessible: m:range -> ad:AccessorDomain -> vref:TypedTree.ValRef -> unit + +val IsUnionCaseAccessible: amap:ImportMap -> m:range -> ad:AccessorDomain -> ucref:TypedTree.UnionCaseRef -> bool + +val CheckUnionCaseAccessible: amap:ImportMap -> m:range -> ad:AccessorDomain -> ucref:TypedTree.UnionCaseRef -> bool + +val IsRecdFieldAccessible: amap:ImportMap -> m:range -> ad:AccessorDomain -> rfref:TypedTree.RecdFieldRef -> bool + +val CheckRecdFieldAccessible: amap:ImportMap -> m:range -> ad:AccessorDomain -> rfref:TypedTree.RecdFieldRef -> bool + +val CheckRecdFieldInfoAccessible: amap:ImportMap -> m:range -> ad:AccessorDomain -> rfinfo:RecdFieldInfo -> unit + +val CheckILFieldInfoAccessible: g:TcGlobals -> amap:ImportMap -> m:range -> ad:AccessorDomain -> finfo:ILFieldInfo -> unit + +val IsTypeAndMethInfoAccessible: amap:ImportMap -> m:range -> accessDomainTy:AccessorDomain -> ad:AccessorDomain -> _arg1:MethInfo -> bool + +val IsMethInfoAccessible: amap:ImportMap -> m:range -> ad:AccessorDomain -> minfo:MethInfo -> bool + +val IsPropInfoAccessible: g:TcGlobals ->amap:ImportMap -> m:range -> ad:AccessorDomain -> _arg1:PropInfo -> bool + +val IsFieldInfoAccessible: ad:AccessorDomain -> rfref:RecdFieldInfo -> bool diff --git a/src/fsharp/AttributeChecking.fsi b/src/fsharp/AttributeChecking.fsi index fc09a339c0f..7e9acc046e9 100644 --- a/src/fsharp/AttributeChecking.fsi +++ b/src/fsharp/AttributeChecking.fsi @@ -4,542 +4,73 @@ /// on items from name resolution module internal FSharp.Compiler.AttributeChecking -open System open System.Collections.Generic open FSharp.Compiler.AbstractIL.IL -open FSharp.Compiler.AbstractIL.Internal.Library - open FSharp.Compiler -open FSharp.Compiler.Range open FSharp.Compiler.ErrorLogger open FSharp.Compiler.Infos +open FSharp.Compiler.Range open FSharp.Compiler.TypedTree -open FSharp.Compiler.TypedTreeOps open FSharp.Compiler.TcGlobals -#if !NO_EXTENSIONTYPING -open FSharp.Compiler.ExtensionTyping -open Microsoft.FSharp.Core.CompilerServices -#endif - exception ObsoleteWarning of string * range exception ObsoleteError of string * range -let fail() = failwith "This custom attribute has an argument that can not yet be converted using this API" - -let rec private evalILAttribElem e = - match e with - | ILAttribElem.String (Some x) -> box x - | ILAttribElem.String None -> null - | ILAttribElem.Bool x -> box x - | ILAttribElem.Char x -> box x - | ILAttribElem.SByte x -> box x - | ILAttribElem.Int16 x -> box x - | ILAttribElem.Int32 x -> box x - | ILAttribElem.Int64 x -> box x - | ILAttribElem.Byte x -> box x - | ILAttribElem.UInt16 x -> box x - | ILAttribElem.UInt32 x -> box x - | ILAttribElem.UInt64 x -> box x - | ILAttribElem.Single x -> box x - | ILAttribElem.Double x -> box x - | ILAttribElem.Null -> null - | ILAttribElem.Array (_, a) -> box [| for i in a -> evalILAttribElem i |] - // TODO: typeof<..> in attribute values - | ILAttribElem.Type (Some _t) -> fail() - | ILAttribElem.Type None -> null - | ILAttribElem.TypeRef (Some _t) -> fail() - | ILAttribElem.TypeRef None -> null - -let rec private evalFSharpAttribArg g e = - match e with - | Expr.Const (c, _, _) -> - match c with - | Const.Bool b -> box b - | Const.SByte i -> box i - | Const.Int16 i -> box i - | Const.Int32 i -> box i - | Const.Int64 i -> box i - | Const.Byte i -> box i - | Const.UInt16 i -> box i - | Const.UInt32 i -> box i - | Const.UInt64 i -> box i - | Const.Single i -> box i - | Const.Double i -> box i - | Const.Char i -> box i - | Const.Zero -> null - | Const.String s -> box s - | _ -> fail() - | Expr.Op (TOp.Array, _, a, _) -> box [| for i in a -> evalFSharpAttribArg g i |] - | TypeOfExpr g ty -> box ty - // TODO: | TypeDefOfExpr g ty - | _ -> fail() - -type AttribInfo = +type AttribInfo = | FSAttribInfo of TcGlobals * Attrib | ILAttribInfo of TcGlobals * Import.ImportMap * ILScopeRef * ILAttribute * range + member ConstructorArguments: (TType * obj) list + member NamedArguments: (TType * string * bool * obj) list + member Range: range + member TyconRef: TyconRef + +val AttribInfosOfIL: g:TcGlobals -> amap:Import.ImportMap -> scoref:ILScopeRef -> m:range -> attribs:ILAttributes -> AttribInfo list - member x.Range = - match x with - | FSAttribInfo(_, attrib) -> attrib.Range - | ILAttribInfo (_, _, _, _, m) -> m - - member x.TyconRef = - match x with - | FSAttribInfo(_g, Attrib(tcref, _, _, _, _, _, _)) -> tcref - | ILAttribInfo (g, amap, scoref, a, m) -> - let ty = ImportILType scoref amap m [] a.Method.DeclaringType - tcrefOfAppTy g ty - - member x.ConstructorArguments = - match x with - | FSAttribInfo(g, Attrib(_, _, unnamedArgs, _, _, _, _)) -> - unnamedArgs - |> List.map (fun (AttribExpr(origExpr, evaluatedExpr)) -> - let ty = tyOfExpr g origExpr - let obj = evalFSharpAttribArg g evaluatedExpr - ty, obj) - | ILAttribInfo (g, amap, scoref, cattr, m) -> - let parms, _args = decodeILAttribData g.ilg cattr - [ for (argty, argval) in Seq.zip cattr.Method.FormalArgTypes parms -> - let ty = ImportILType scoref amap m [] argty - let obj = evalILAttribElem argval - ty, obj ] - - member x.NamedArguments = - match x with - | FSAttribInfo(g, Attrib(_, _, _, namedArgs, _, _, _)) -> - namedArgs - |> List.map (fun (AttribNamedArg(nm, _, isField, AttribExpr(origExpr, evaluatedExpr))) -> - let ty = tyOfExpr g origExpr - let obj = evalFSharpAttribArg g evaluatedExpr - ty, nm, isField, obj) - | ILAttribInfo (g, amap, scoref, cattr, m) -> - let _parms, namedArgs = decodeILAttribData g.ilg cattr - [ for (nm, argty, isProp, argval) in namedArgs -> - let ty = ImportILType scoref amap m [] argty - let obj = evalILAttribElem argval - let isField = not isProp - ty, nm, isField, obj ] - - -/// Check custom attributes. This is particularly messy because custom attributes come in in three different -/// formats. -let AttribInfosOfIL g amap scoref m (attribs: ILAttributes) = - attribs.AsList |> List.map (fun a -> ILAttribInfo (g, amap, scoref, a, m)) - -let AttribInfosOfFS g attribs = - attribs |> List.map (fun a -> FSAttribInfo (g, a)) - -let GetAttribInfosOfEntity g amap m (tcref:TyconRef) = - match metadataOfTycon tcref.Deref with -#if !NO_EXTENSIONTYPING - // TODO: provided attributes - | ProvidedTypeMetadata _info -> [] - //let provAttribs = info.ProvidedType.PApply((fun a -> (a :> IProvidedCustomAttributeProvider)), m) - //match provAttribs.PUntaint((fun a -> a. .GetAttributeConstructorArgs(provAttribs.TypeProvider.PUntaintNoFailure(id), atref.FullName)), m) with - //| Some args -> f3 args - //| None -> None -#endif - | ILTypeMetadata (TILObjectReprData(scoref, _, tdef)) -> - tdef.CustomAttrs |> AttribInfosOfIL g amap scoref m - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> - tcref.Attribs |> List.map (fun a -> FSAttribInfo (g, a)) - - -let GetAttribInfosOfMethod amap m minfo = - match minfo with - | ILMeth (g, ilminfo, _) -> ilminfo.RawMetadata.CustomAttrs |> AttribInfosOfIL g amap ilminfo.MetadataScope m - | FSMeth (g, _, vref, _) -> vref.Attribs |> AttribInfosOfFS g - | DefaultStructCtor _ -> [] -#if !NO_EXTENSIONTYPING - // TODO: provided attributes - | ProvidedMeth (_, _mi, _, _m) -> - [] - -#endif - -let GetAttribInfosOfProp amap m pinfo = - match pinfo with - | ILProp ilpinfo -> ilpinfo.RawMetadata.CustomAttrs |> AttribInfosOfIL ilpinfo.TcGlobals amap ilpinfo.ILTypeInfo.ILScopeRef m - | FSProp(g, _, Some vref, _) - | FSProp(g, _, _, Some vref) -> vref.Attribs |> AttribInfosOfFS g - | FSProp _ -> failwith "GetAttribInfosOfProp: unreachable" -#if !NO_EXTENSIONTYPING - // TODO: provided attributes - | ProvidedProp _ -> [] -#endif - -let GetAttribInfosOfEvent amap m einfo = - match einfo with - | ILEvent ileinfo -> ileinfo.RawMetadata.CustomAttrs |> AttribInfosOfIL einfo.TcGlobals amap ileinfo.ILTypeInfo.ILScopeRef m - | FSEvent(_, pi, _vref1, _vref2) -> GetAttribInfosOfProp amap m pi -#if !NO_EXTENSIONTYPING - // TODO: provided attributes - | ProvidedEvent _ -> [] -#endif - -/// Analyze three cases for attributes declared on type definitions: IL-declared attributes, F#-declared attributes and -/// provided attributes. -// -// This is used for AttributeUsageAttribute, DefaultMemberAttribute and ConditionalAttribute (on attribute types) -let TryBindTyconRefAttribute g m (AttribInfo (atref, _) as args) (tcref:TyconRef) f1 f2 f3 = - ignore m; ignore f3 - match metadataOfTycon tcref.Deref with -#if !NO_EXTENSIONTYPING - | ProvidedTypeMetadata info -> - let provAttribs = info.ProvidedType.PApply((fun a -> (a :> IProvidedCustomAttributeProvider)), m) - match provAttribs.PUntaint((fun a -> a.GetAttributeConstructorArgs(provAttribs.TypeProvider.PUntaintNoFailure(id), atref.FullName)), m) with - | Some args -> f3 args - | None -> None -#endif - | ILTypeMetadata (TILObjectReprData(_, _, tdef)) -> - match TryDecodeILAttribute g atref tdef.CustomAttrs with - | Some attr -> f1 attr - | _ -> None - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> - match TryFindFSharpAttribute g args tcref.Attribs with - | Some attr -> f2 attr - | _ -> None - -/// Analyze three cases for attributes declared on methods: IL-declared attributes, F#-declared attributes and -/// provided attributes. -let BindMethInfoAttributes m minfo f1 f2 f3 = - ignore m; ignore f3 - match minfo with - | ILMeth (_, x, _) -> f1 x.RawMetadata.CustomAttrs - | FSMeth (_, _, vref, _) -> f2 vref.Attribs - | DefaultStructCtor _ -> f2 [] -#if !NO_EXTENSIONTYPING - | ProvidedMeth (_, mi, _, _) -> f3 (mi.PApply((fun st -> (st :> IProvidedCustomAttributeProvider)), m)) -#endif - -/// Analyze three cases for attributes declared on methods: IL-declared attributes, F#-declared attributes and -/// provided attributes. -let TryBindMethInfoAttribute g m (AttribInfo(atref, _) as attribSpec) minfo f1 f2 f3 = -#if !NO_EXTENSIONTYPING -#else - // to prevent unused parameter warning - ignore f3 -#endif - BindMethInfoAttributes m minfo - (fun ilAttribs -> TryDecodeILAttribute g atref ilAttribs |> Option.bind f1) - (fun fsAttribs -> TryFindFSharpAttribute g attribSpec fsAttribs |> Option.bind f2) -#if !NO_EXTENSIONTYPING - (fun provAttribs -> - match provAttribs.PUntaint((fun a -> a.GetAttributeConstructorArgs(provAttribs.TypeProvider.PUntaintNoFailure(id), atref.FullName)), m) with - | Some args -> f3 args - | None -> None) -#else - (fun _provAttribs -> None) -#endif - -/// Try to find a specific attribute on a method, where the attribute accepts a string argument. -/// -/// This is just used for the 'ConditionalAttribute' attribute -let TryFindMethInfoStringAttribute g m attribSpec minfo = - TryBindMethInfoAttribute g m attribSpec minfo - (function ([ILAttribElem.String (Some msg) ], _) -> Some msg | _ -> None) - (function (Attrib(_, _, [ AttribStringArg msg ], _, _, _, _)) -> Some msg | _ -> None) - (function ([ Some ((:? string as msg) : obj) ], _) -> Some msg | _ -> None) - -/// Check if a method has a specific attribute. -let MethInfoHasAttribute g m attribSpec minfo = - TryBindMethInfoAttribute g m attribSpec minfo - (fun _ -> Some ()) - (fun _ -> Some ()) - (fun _ -> Some ()) - |> Option.isSome - - -/// Check IL attributes for 'ObsoleteAttribute', returning errors and warnings as data -let private CheckILAttributes (g: TcGlobals) isByrefLikeTyconRef cattrs m = - let (AttribInfo(tref,_)) = g.attrib_SystemObsolete - match TryDecodeILAttribute g tref cattrs with - | Some ([ILAttribElem.String (Some msg) ], _) when not isByrefLikeTyconRef -> - WarnD(ObsoleteWarning(msg, m)) - | Some ([ILAttribElem.String (Some msg); ILAttribElem.Bool isError ], _) when not isByrefLikeTyconRef -> - if isError then - ErrorD (ObsoleteError(msg, m)) - else - WarnD (ObsoleteWarning(msg, m)) - | Some ([ILAttribElem.String None ], _) when not isByrefLikeTyconRef -> - WarnD(ObsoleteWarning("", m)) - | Some _ when not isByrefLikeTyconRef -> - WarnD(ObsoleteWarning("", m)) - | _ -> - CompleteD - -let langVersionPrefix = "--langversion:preview" - -/// Check F# attributes for 'ObsoleteAttribute', 'CompilerMessageAttribute' and 'ExperimentalAttribute', -/// returning errors and warnings as data -let CheckFSharpAttributes (g:TcGlobals) attribs m = - let isExperimentalAttributeDisabled (s:string) = - if g.compilingFslib then - true - else - g.langVersion.IsPreviewEnabled && (s.IndexOf(langVersionPrefix, StringComparison.OrdinalIgnoreCase) >= 0) +val GetAttribInfosOfEntity: g:TcGlobals -> amap:Import.ImportMap -> m:range -> tcref:TyconRef -> AttribInfo list - if isNil attribs then CompleteD - else - (match TryFindFSharpAttribute g g.attrib_SystemObsolete attribs with - | Some(Attrib(_, _, [ AttribStringArg s ], _, _, _, _)) -> - WarnD(ObsoleteWarning(s, m)) - | Some(Attrib(_, _, [ AttribStringArg s; AttribBoolArg(isError) ], _, _, _, _)) -> - if isError then - ErrorD (ObsoleteError(s, m)) - else - WarnD (ObsoleteWarning(s, m)) - | Some _ -> - WarnD(ObsoleteWarning("", m)) - | None -> - CompleteD - ) ++ (fun () -> +val GetAttribInfosOfMethod: amap:Import.ImportMap -> m:range -> minfo:MethInfo -> AttribInfo list - match TryFindFSharpAttribute g g.attrib_CompilerMessageAttribute attribs with - | Some(Attrib(_, _, [ AttribStringArg s ; AttribInt32Arg n ], namedArgs, _, _, _)) -> - let msg = UserCompilerMessage(s, n, m) - let isError = - match namedArgs with - | ExtractAttribNamedArg "IsError" (AttribBoolArg v) -> v - | _ -> false - // If we are using a compiler that supports nameof then error 3501 is always suppressed. - // See attribute on FSharp.Core 'nameof' - if n = 3501 then CompleteD - elif isError && (not g.compilingFslib || n <> 1204) then ErrorD msg - else WarnD msg - | _ -> - CompleteD - ) ++ (fun () -> +val GetAttribInfosOfProp: amap:Import.ImportMap -> m:range -> pinfo:PropInfo -> AttribInfo list - match TryFindFSharpAttribute g g.attrib_ExperimentalAttribute attribs with - | Some(Attrib(_, _, [ AttribStringArg(s) ], _, _, _, _)) -> - if isExperimentalAttributeDisabled s then - CompleteD - else - WarnD(Experimental(s, m)) - | Some _ -> - WarnD(Experimental(FSComp.SR.experimentalConstruct (), m)) - | _ -> - CompleteD - ) ++ (fun () -> +val GetAttribInfosOfEvent: amap:Import.ImportMap -> m:range -> einfo:EventInfo -> AttribInfo list - match TryFindFSharpAttribute g g.attrib_UnverifiableAttribute attribs with - | Some _ -> - WarnD(PossibleUnverifiableCode(m)) - | _ -> - CompleteD - ) +val TryBindMethInfoAttribute: g:TcGlobals -> m:range -> BuiltinAttribInfo -> minfo:MethInfo -> f1:(ILAttribElem list * ILAttributeNamedArg list -> 'a option) -> f2:(Attrib -> 'a option) -> f3:(obj option list * (string * obj option) list -> 'a option) -> 'a option -#if !NO_EXTENSIONTYPING -/// Check a list of provided attributes for 'ObsoleteAttribute', returning errors and warnings as data -let private CheckProvidedAttributes (g: TcGlobals) m (provAttribs: Tainted) = - let (AttribInfo(tref, _)) = g.attrib_SystemObsolete - match provAttribs.PUntaint((fun a -> a.GetAttributeConstructorArgs(provAttribs.TypeProvider.PUntaintNoFailure(id), tref.FullName)), m) with - | Some ([ Some (:? string as msg) ], _) -> WarnD(ObsoleteWarning(msg, m)) - | Some ([ Some (:? string as msg); Some (:?bool as isError) ], _) -> - if isError then - ErrorD (ObsoleteError(msg, m)) - else - WarnD (ObsoleteWarning(msg, m)) - | Some ([ None ], _) -> - WarnD(ObsoleteWarning("", m)) - | Some _ -> - WarnD(ObsoleteWarning("", m)) - | None -> - CompleteD -#endif +val TryFindMethInfoStringAttribute: g:TcGlobals -> m:range -> attribSpec:BuiltinAttribInfo -> minfo:MethInfo -> string option -/// Indicate if a list of IL attributes contains 'ObsoleteAttribute'. Used to suppress the item in intellisense. -let CheckILAttributesForUnseen (g: TcGlobals) cattrs _m = - let (AttribInfo(tref, _)) = g.attrib_SystemObsolete - Option.isSome (TryDecodeILAttribute g tref cattrs) +val MethInfoHasAttribute: g:TcGlobals -> m:range -> attribSpec:BuiltinAttribInfo -> minfo:MethInfo -> bool -/// Checks the attributes for CompilerMessageAttribute, which has an IsHidden argument that allows -/// items to be suppressed from intellisense. -let CheckFSharpAttributesForHidden g attribs = - not (isNil attribs) && - (match TryFindFSharpAttribute g g.attrib_CompilerMessageAttribute attribs with - | Some(Attrib(_, _, [AttribStringArg _; AttribInt32Arg messageNumber], - ExtractAttribNamedArg "IsHidden" (AttribBoolArg v), _, _, _)) -> - // Message number 62 is for "ML Compatibility". Items labelled with this are visible in intellisense - // when mlCompatibility is set. - v && not (messageNumber = 62 && g.mlCompatibility) - | _ -> false) - || - (match TryFindFSharpAttribute g g.attrib_ComponentModelEditorBrowsableAttribute attribs with - | Some(Attrib(_, _, [AttribInt32Arg state], _, _, _, _)) -> state = int System.ComponentModel.EditorBrowsableState.Never - | _ -> false) +val CheckFSharpAttributes: g:TcGlobals -> attribs:Attrib list -> m:range -> OperationResult -/// Indicate if a list of F# attributes contains 'ObsoleteAttribute'. Used to suppress the item in intellisense. -let CheckFSharpAttributesForObsolete g attribs = - not (isNil attribs) && (HasFSharpAttribute g g.attrib_SystemObsolete attribs) +val CheckILAttributesForUnseen: g:TcGlobals -> cattrs:ILAttributes -> _m:'a -> bool -/// Indicate if a list of F# attributes contains 'ObsoleteAttribute'. Used to suppress the item in intellisense. -/// Also check the attributes for CompilerMessageAttribute, which has an IsHidden argument that allows -/// items to be suppressed from intellisense. -let CheckFSharpAttributesForUnseen g attribs _m = - not (isNil attribs) && - (CheckFSharpAttributesForObsolete g attribs || - CheckFSharpAttributesForHidden g attribs) - -#if !NO_EXTENSIONTYPING -/// Indicate if a list of provided attributes contains 'ObsoleteAttribute'. Used to suppress the item in intellisense. -let CheckProvidedAttributesForUnseen (provAttribs: Tainted) m = - provAttribs.PUntaint((fun a -> a.GetAttributeConstructorArgs(provAttribs.TypeProvider.PUntaintNoFailure(id), typeof.FullName).IsSome), m) -#endif +val CheckFSharpAttributesForHidden: g:TcGlobals -> attribs:Attrib list -> bool -/// Check the attributes associated with a property, returning warnings and errors as data. -let CheckPropInfoAttributes pinfo m = - match pinfo with - | ILProp(ILPropInfo(_, pdef)) -> CheckILAttributes pinfo.TcGlobals false pdef.CustomAttrs m - | FSProp(g, _, Some vref, _) - | FSProp(g, _, _, Some vref) -> CheckFSharpAttributes g vref.Attribs m - | FSProp _ -> failwith "CheckPropInfoAttributes: unreachable" -#if !NO_EXTENSIONTYPING - | ProvidedProp (amap, pi, m) -> - CheckProvidedAttributes amap.g m (pi.PApply((fun st -> (st :> IProvidedCustomAttributeProvider)), m)) - -#endif +val CheckFSharpAttributesForObsolete: g:TcGlobals -> attribs:Attrib list -> bool - -/// Check the attributes associated with a IL field, returning warnings and errors as data. -let CheckILFieldAttributes g (finfo:ILFieldInfo) m = - match finfo with - | ILFieldInfo(_, pd) -> - CheckILAttributes g false pd.CustomAttrs m |> CommitOperationResult -#if !NO_EXTENSIONTYPING - | ProvidedField (amap, fi, m) -> - CheckProvidedAttributes amap.g m (fi.PApply((fun st -> (st :> IProvidedCustomAttributeProvider)), m)) |> CommitOperationResult -#endif +val CheckFSharpAttributesForUnseen: g:TcGlobals -> attribs:Attrib list -> _m:'a -> bool -/// Check the attributes associated with a method, returning warnings and errors as data. -let CheckMethInfoAttributes g m tyargsOpt minfo = - let search = - BindMethInfoAttributes m minfo - (fun ilAttribs -> Some(CheckILAttributes g false ilAttribs m)) - (fun fsAttribs -> - let res = - CheckFSharpAttributes g fsAttribs m ++ (fun () -> - if Option.isNone tyargsOpt && HasFSharpAttribute g g.attrib_RequiresExplicitTypeArgumentsAttribute fsAttribs then - ErrorD(Error(FSComp.SR.tcFunctionRequiresExplicitTypeArguments(minfo.LogicalName), m)) - else - CompleteD) - Some res) -#if !NO_EXTENSIONTYPING - (fun provAttribs -> Some (CheckProvidedAttributes g m provAttribs)) -#else - (fun _provAttribs -> None) -#endif - match search with - | Some res -> res - | None -> CompleteD // no attribute = no errors +val CheckPropInfoAttributes: pinfo:PropInfo -> m:range -> OperationResult -/// Indicate if a method has 'Obsolete', 'CompilerMessageAttribute' or 'TypeProviderEditorHideMethodsAttribute'. -/// Used to suppress the item in intellisense. -let MethInfoIsUnseen g m ty minfo = - let isUnseenByObsoleteAttrib () = - match BindMethInfoAttributes m minfo - (fun ilAttribs -> Some(CheckILAttributesForUnseen g ilAttribs m)) - (fun fsAttribs -> Some(CheckFSharpAttributesForUnseen g fsAttribs m)) -#if !NO_EXTENSIONTYPING - (fun provAttribs -> Some(CheckProvidedAttributesForUnseen provAttribs m)) -#else - (fun _provAttribs -> None) -#endif - with - | Some res -> res - | None -> false +val CheckILFieldAttributes: g:TcGlobals -> finfo:ILFieldInfo -> m:range -> unit - let isUnseenByHidingAttribute () = -#if !NO_EXTENSIONTYPING - not (isObjTy g ty) && - isAppTy g ty && - isObjTy g minfo.ApparentEnclosingType && - let tcref = tcrefOfAppTy g ty - match tcref.TypeReprInfo with - | TProvidedTypeExtensionPoint info -> - info.ProvidedType.PUntaint((fun st -> (st :> IProvidedCustomAttributeProvider).GetHasTypeProviderEditorHideMethodsAttribute(info.ProvidedType.TypeProvider.PUntaintNoFailure(id))), m) - | _ -> - // This attribute check is done by name to ensure compilation doesn't take a dependency - // on Microsoft.FSharp.Core.CompilerServices.TypeProviderEditorHideMethodsAttribute. - // - // We are only interested in filtering out the method on System.Object, so it is sufficient - // just to look at the attributes on IL methods. - if tcref.IsILTycon then - tcref.ILTyconRawMetadata.CustomAttrs.AsArray - |> Array.exists (fun attr -> attr.Method.DeclaringType.TypeSpec.Name = typeof.FullName) - else - false -#else - ty |> ignore - false -#endif +val CheckMethInfoAttributes: g:TcGlobals -> m:range -> tyargsOpt:'a option -> minfo:MethInfo -> OperationResult - //let isUnseenByBeingTupleMethod () = isAnyTupleTy g ty +val MethInfoIsUnseen: g:TcGlobals -> m:range -> ty:TType -> minfo:MethInfo -> bool - isUnseenByObsoleteAttrib () || isUnseenByHidingAttribute () //|| isUnseenByBeingTupleMethod () +val PropInfoIsUnseen: m:'a -> pinfo:PropInfo -> bool -/// Indicate if a property has 'Obsolete' or 'CompilerMessageAttribute'. -/// Used to suppress the item in intellisense. -let PropInfoIsUnseen m pinfo = - match pinfo with - | ILProp (ILPropInfo(_, pdef) as ilpinfo) -> - // Properties on .NET tuple types are resolvable but unseen - isAnyTupleTy pinfo.TcGlobals ilpinfo.ILTypeInfo.ToType || - CheckILAttributesForUnseen pinfo.TcGlobals pdef.CustomAttrs m - | FSProp (g, _, Some vref, _) - | FSProp (g, _, _, Some vref) -> CheckFSharpAttributesForUnseen g vref.Attribs m - | FSProp _ -> failwith "CheckPropInfoAttributes: unreachable" -#if !NO_EXTENSIONTYPING - | ProvidedProp (_amap, pi, m) -> - CheckProvidedAttributesForUnseen (pi.PApply((fun st -> (st :> IProvidedCustomAttributeProvider)), m)) m -#endif - -/// Check the attributes on an entity, returning errors and warnings as data. -let CheckEntityAttributes g (x:TyconRef) m = - if x.IsILTycon then - CheckILAttributes g (isByrefLikeTyconRef g m x) x.ILTyconRawMetadata.CustomAttrs m - else - CheckFSharpAttributes g x.Attribs m +val CheckEntityAttributes: g:TcGlobals -> x:TyconRef -> m:range -> OperationResult -/// Check the attributes on a union case, returning errors and warnings as data. -let CheckUnionCaseAttributes g (x:UnionCaseRef) m = - CheckEntityAttributes g x.TyconRef m ++ (fun () -> - CheckFSharpAttributes g x.Attribs m) +val CheckUnionCaseAttributes: g:TcGlobals -> x:UnionCaseRef -> m:range -> OperationResult -/// Check the attributes on a record field, returning errors and warnings as data. -let CheckRecdFieldAttributes g (x:RecdFieldRef) m = - CheckEntityAttributes g x.TyconRef m ++ (fun () -> - CheckFSharpAttributes g x.PropertyAttribs m) +val CheckRecdFieldAttributes: g:TcGlobals -> x:RecdFieldRef -> m:range -> OperationResult -/// Check the attributes on an F# value, returning errors and warnings as data. -let CheckValAttributes g (x:ValRef) m = - CheckFSharpAttributes g x.Attribs m +val CheckValAttributes: g:TcGlobals -> x:ValRef -> m:range -> OperationResult -/// Check the attributes on a record field, returning errors and warnings as data. -let CheckRecdFieldInfoAttributes g (x:RecdFieldInfo) m = - CheckRecdFieldAttributes g x.RecdFieldRef m +val CheckRecdFieldInfoAttributes: g:TcGlobals -> x:RecdFieldInfo -> m:range -> OperationResult - -// Identify any security attributes -let IsSecurityAttribute (g: TcGlobals) amap (casmap : Dictionary) (Attrib(tcref, _, _, _, _, _, _)) m = - // There's no CAS on Silverlight, so we have to be careful here - match g.attrib_SecurityAttribute with - | None -> false - | Some attr -> - match attr.TyconRef.TryDeref with - | ValueSome _ -> - let tcs = tcref.Stamp - match casmap.TryGetValue tcs with - | true, c -> c - | _ -> - let exists = ExistsInEntireHierarchyOfType (fun t -> typeEquiv g t (mkAppTy attr.TyconRef [])) g amap m AllowMultiIntfInstantiations.Yes (mkAppTy tcref []) - casmap.[tcs] <- exists - exists - | ValueNone -> false +val IsSecurityAttribute: g:TcGlobals -> amap:Import.ImportMap -> casmap:Dictionary -> Attrib -> m:range -> bool -let IsSecurityCriticalAttribute g (Attrib(tcref, _, _, _, _, _, _)) = - (tyconRefEq g tcref g.attrib_SecurityCriticalAttribute.TyconRef || tyconRefEq g tcref g.attrib_SecuritySafeCriticalAttribute.TyconRef) +val IsSecurityCriticalAttribute: g:TcGlobals -> Attrib -> bool diff --git a/src/fsharp/FSharp.Compiler.Service/all.fsi b/src/fsharp/FSharp.Compiler.Service/all.fsi index 8f0f272fada..88407d67588 100644 --- a/src/fsharp/FSharp.Compiler.Service/all.fsi +++ b/src/fsharp/FSharp.Compiler.Service/all.fsi @@ -1,8524 +1,6 @@ -namespace FSharp.Compiler - module CompilerGlobalState = - type NiceNameGenerator = - - new: unit -> NiceNameGenerator - member - FreshCompilerGeneratedName: name:string * m:Range.range -> string - member Reset: unit -> unit - - type StableNiceNameGenerator = - - new: unit -> StableNiceNameGenerator - member - GetUniqueCompilerGeneratedName: name:string * m:Range.range * - uniq:int64 -> string - member Reset: unit -> unit - - type internal CompilerGlobalState = - - new: unit -> CompilerGlobalState - member IlxGenNiceNameGenerator: NiceNameGenerator - member NiceNameGenerator: NiceNameGenerator - member StableNameGenerator: StableNiceNameGenerator - - type Unique = int64 - val newUnique: (unit -> int64) - val newStamp: (unit -> int64) - - -namespace FSharp.Compiler - module internal TypedTree = - type Stamp = int64 - and StampMap<'T> = Map - [] - and ValInline = - | PseudoVal - | Always - | Optional - | Never - with - member MustInline: bool - - and ValRecursiveScopeInfo = - | ValInRecScope of bool - | ValNotInRecScope - and ValMutability = - | Immutable - | Mutable - [] - and TyparDynamicReq = - | No - | Yes - and ValBaseOrThisInfo = - | CtorThisVal - | BaseVal - | NormalVal - | MemberThisVal - [] - and ValFlags = - - new: recValInfo:ValRecursiveScopeInfo * baseOrThis:ValBaseOrThisInfo * - isCompGen:bool * inlineInfo:ValInline * isMutable:ValMutability * - isModuleOrMemberBinding:bool * isExtensionMember:bool * - isIncrClassSpecialMember:bool * isTyFunc:bool * allowTypeInst:bool * - isGeneratedEventVal:bool -> ValFlags - new: flags:int64 -> ValFlags - member SetIsCompilerGenerated: isCompGen:bool -> ValFlags - member - WithRecursiveValInfo: recValInfo:ValRecursiveScopeInfo -> ValFlags - member BaseOrThisInfo: ValBaseOrThisInfo - member HasBeenReferenced: bool - member IgnoresByrefScope: bool - member InlineInfo: ValInline - member IsCompiledAsStaticPropertyWithoutField: bool - member IsCompilerGenerated: bool - member IsExtensionMember: bool - member IsFixed: bool - member IsGeneratedEventVal: bool - member IsIncrClassSpecialMember: bool - member IsMemberOrModuleBinding: bool - member IsTypeFunction: bool - member MakesNoCriticalTailcalls: bool - member MutabilityInfo: ValMutability - member PermitsExplicitTypeInstantiation: bool - member PickledBits: int64 - member RecursiveValInfo: ValRecursiveScopeInfo - member WithHasBeenReferenced: ValFlags - member WithIgnoresByrefScope: ValFlags - member WithIsCompiledAsStaticPropertyWithoutField: ValFlags - member WithIsFixed: ValFlags - member WithIsMemberOrModuleBinding: ValFlags - member WithMakesNoCriticalTailcalls: ValFlags - - [] - and TyparKind = - | Type - | Measure - with - override ToString: unit -> string - member AttrName: string voption - - [] - and TyparRigidity = - | Rigid - | WillBeRigid - | WarnIfNotRigid - | Flexible - | Anon - with - member ErrorIfUnified: bool - member WarnIfMissingConstraint: bool - member WarnIfUnified: bool - - [] - and TyparFlags = - - new: kind:TyparKind * rigidity:TyparRigidity * isFromError:bool * - isCompGen:bool * staticReq:SyntaxTree.TyparStaticReq * - dynamicReq:TyparDynamicReq * equalityDependsOn:bool * - comparisonDependsOn:bool -> TyparFlags - new: flags:int32 -> TyparFlags - member WithCompatFlex: b:bool -> TyparFlags - member ComparisonConditionalOn: bool - member DynamicReq: TyparDynamicReq - member EqualityConditionalOn: bool - member IsCompatFlex: bool - member IsCompilerGenerated: bool - member IsFromError: bool - member Kind: TyparKind - member PickledBits: int32 - member Rigidity: TyparRigidity - member StaticReq: SyntaxTree.TyparStaticReq - - [] - and EntityFlags = - - new: usesPrefixDisplay:bool * isModuleOrNamespace:bool * - preEstablishedHasDefaultCtor:bool * hasSelfReferentialCtor:bool * - isStructRecordOrUnionType:bool -> EntityFlags - new: flags:int64 -> EntityFlags - member WithIsAssumedReadOnly: flag:bool -> EntityFlags - member WithIsByRefLike: flag:bool -> EntityFlags - member WithIsReadOnly: flag:bool -> EntityFlags - member HasSelfReferentialConstructor: bool - member IsModuleOrNamespace: bool - member IsPrefixDisplay: bool - member IsStructRecordOrUnionType: bool - member PickledBits: int64 - member PreEstablishedHasDefaultConstructor: bool - member TryIsAssumedReadOnly: bool voption - member TryIsByRefLike: bool voption - member TryIsReadOnly: bool voption - static member ReservedBitForPickleFormatTyconReprFlag: int64 - - and UndefinedName = - with - inherit exn - interface System.Collections.IStructuralEquatable - val Data0: int - val Data1: string -> string - val Data2: SyntaxTree.Ident - val Data3: ErrorLogger.Suggestions - - and InternalUndefinedItemRef = - with - inherit exn - interface System.Collections.IStructuralEquatable - val Data0: string * string * string -> int * string - val Data1: string - val Data2: string - val Data3: string - - and ModuleOrNamespaceKind = - | FSharpModuleWithSuffix - | ModuleOrType - | Namespace - and PublicPath = - | PubPath of string [] - with - member EnclosingPath: string [] - - and CompilationPath = - | CompPath of - AbstractIL.IL.ILScopeRef * (string * ModuleOrNamespaceKind) list - with - static member - DemangleEntityName: nm:string -> k:ModuleOrNamespaceKind -> string - member - NestedCompPath: n:string -> - modKind:ModuleOrNamespaceKind -> CompilationPath - member NestedPublicPath: id:SyntaxTree.Ident -> PublicPath - member AccessPath: (string * ModuleOrNamespaceKind) list - member DemangledPath: string list - member ILScopeRef: AbstractIL.IL.ILScopeRef - member MangledPath: string list - member ParentCompPath: CompilationPath - - [] - and EntityOptionalData = - { mutable entity_compiled_name: string option - mutable entity_other_range: (Range.range * bool) option - mutable entity_kind: TyparKind - mutable entity_xmldoc: XmlDoc.XmlDoc - mutable entity_xmldocsig: string - mutable entity_tycon_abbrev: TType option - mutable entity_tycon_repr_accessibility: Accessibility - mutable entity_accessibility: Accessibility - mutable entity_exn_info: ExceptionInfo } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and Entity = - { mutable entity_typars: - AbstractIL.Internal.Library.LazyWithContext - mutable entity_flags: EntityFlags - mutable entity_stamp: Stamp - mutable entity_logical_name: string - mutable entity_range: Range.range - mutable entity_attribs: Attribs - mutable entity_tycon_repr: TyconRepresentation - mutable entity_tycon_tcaug: TyconAugmentation - mutable entity_modul_contents: Lib.MaybeLazy - mutable entity_pubpath: PublicPath option - mutable entity_cpath: CompilationPath option - mutable entity_il_repr_cache: Lib.cache - mutable entity_opt_data: EntityOptionalData option } - with - static member New: _reason:'b -> data:Entity -> Entity - static member NewEmptyEntityOptData: unit -> EntityOptionalData - static member NewUnlinked: unit -> Entity - member - GetDisplayName: ?withStaticParameters:bool * ?withTypars:bool * - ?withUnderscoreTypars:bool -> string - member GetFieldByIndex: n:int -> RecdField - member GetFieldByName: n:string -> RecdField option - member GetUnionCaseByName: n:string -> UnionCase option - member Link: tg:EntityData -> unit - member SetAttribs: attribs:Attribs -> unit - member SetCompiledName: name:string option -> unit - member SetExceptionInfo: exn_info:ExceptionInfo -> unit - member SetIsAssumedReadOnly: b:bool -> unit - member SetIsByRefLike: b:bool -> unit - member SetIsReadOnly: b:bool -> unit - member SetIsStructRecordOrUnion: b:bool -> unit - member SetOtherRange: m:(Range.range * bool) -> unit - member SetTypeAbbrev: tycon_abbrev:TType option -> unit - member SetTypeOrMeasureKind: kind:TyparKind -> unit - override ToString: unit -> string - member Typars: m:Range.range -> Typars - member Accessibility: Accessibility - member AllFieldTable: TyconRecdFields - member AllFieldsArray: RecdField [] - member AllFieldsAsList: RecdField list - member AllGeneratedValues: ValRef list - member AllInstanceFieldsAsList: RecdField list - member Attribs: Attribs - member CompilationPath: CompilationPath - member CompilationPathOpt: CompilationPath option - member CompiledName: string - member CompiledReprCache: Lib.cache - member CompiledRepresentation: CompiledTypeRepr - member CompiledRepresentationForNamedType: AbstractIL.IL.ILTypeRef - [ (0))>] - member DebugText: string - member DefinitionRange: Range.range - member DemangledModuleOrNamespaceName: string - member DisplayName: string - member DisplayNameWithStaticParameters: string - member DisplayNameWithStaticParametersAndTypars: string - member DisplayNameWithStaticParametersAndUnderscoreTypars: string - member EntityCompiledName: string option - member ExceptionInfo: ExceptionInfo - member FSharpObjectModelTypeInfo: TyconObjModelData - member GeneratedCompareToValues: (ValRef * ValRef) option - member GeneratedCompareToWithComparerValues: ValRef option - member GeneratedHashAndEqualsValues: (ValRef * ValRef) option - member - GeneratedHashAndEqualsWithComparerValues: (ValRef * ValRef * ValRef) option - member HasSelfReferentialConstructor: bool - member ILTyconInfo: TILObjectReprData - member ILTyconRawMetadata: AbstractIL.IL.ILTypeDef - member Id: SyntaxTree.Ident - member ImmediateInterfaceTypesOfFSharpTycon: TType list - member - ImmediateInterfacesOfFSharpTycon: (TType * bool * Range.range) list - member IsAsmReprTycon: bool - member IsEnumTycon: bool - member IsErased: bool - member IsExceptionDecl: bool - member IsFSharpClassTycon: bool - member IsFSharpDelegateTycon: bool - member IsFSharpEnumTycon: bool - member IsFSharpInterfaceTycon: bool - member IsFSharpObjectModelTycon: bool - member IsFSharpStructOrEnumTycon: bool - member IsHiddenReprTycon: bool - member IsILEnumTycon: bool - member IsILStructOrEnumTycon: bool - member IsILTycon: bool - member IsLinked: bool - member IsMeasureableReprTycon: bool - member IsModule: bool - member IsModuleOrNamespace: bool - member IsNamespace: bool - member IsPrefixDisplay: bool - member IsProvided: bool - member IsProvidedErasedTycon: bool - member IsProvidedGeneratedTycon: bool - member IsProvidedNamespace: bool - member IsRecordTycon: bool - member IsStaticInstantiationTycon: bool - member IsStructOrEnumTycon: bool - member IsStructRecordOrUnionTycon: bool - member IsTypeAbbrev: bool - member IsUnionTycon: bool - member LogicalName: string - member - MembersOfFSharpTyconByName: AbstractIL.Internal.Library.NameMultiMap - member MembersOfFSharpTyconSorted: ValRef list - member ModuleOrNamespaceType: ModuleOrNamespaceType - member PreEstablishedHasDefaultConstructor: bool - member PublicPath: PublicPath option - member Range: Range.range - member SigRange: Range.range - member Stamp: Stamp - member TrueFieldsAsList: RecdField list - member TrueInstanceFieldsAsList: RecdField list - member TryIsAssumedReadOnly: bool voption - member TryIsByRefLike: bool voption - member TryIsReadOnly: bool voption - member TyparsNoRange: Typars - member TypeAbbrev: TType option - member TypeContents: TyconAugmentation - member TypeOrMeasureKind: TyparKind - member TypeReprAccessibility: Accessibility - member TypeReprInfo: TyconRepresentation - member UnionCasesArray: UnionCase [] - member UnionCasesAsList: UnionCase list - member UnionTypeInfo: TyconUnionData voption - member XmlDoc: XmlDoc.XmlDoc - member XmlDocSig: string - - and EntityData = Entity - and ParentRef = - | Parent of EntityRef - | ParentNone - [] - and CompiledTypeRepr = - | ILAsmNamed of - AbstractIL.IL.ILTypeRef * AbstractIL.IL.ILBoxity * - AbstractIL.IL.ILType option - | ILAsmOpen of AbstractIL.IL.ILType - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and TyconAugmentation = - { mutable tcaug_compare: (ValRef * ValRef) option - mutable tcaug_compare_withc: ValRef option - mutable tcaug_equals: (ValRef * ValRef) option - mutable tcaug_hash_and_equals_withc: (ValRef * ValRef * ValRef) option - mutable tcaug_hasObjectGetHashCode: bool - tcaug_adhoc_list: ResizeArray - mutable tcaug_adhoc: AbstractIL.Internal.Library.NameMultiMap - mutable tcaug_interfaces: (TType * bool * Range.range) list - mutable tcaug_super: TType option - mutable tcaug_closed: bool - mutable tcaug_abstract: bool } - with - static member Create: unit -> TyconAugmentation - member SetCompare: x:(ValRef * ValRef) -> unit - member SetCompareWith: x:ValRef -> unit - member SetEquals: x:(ValRef * ValRef) -> unit - member SetHasObjectGetHashCode: b:bool -> unit - member SetHashAndEqualsWith: x:(ValRef * ValRef * ValRef) -> unit - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and TyconRepresentation = - | TFSharpObjectRepr of TyconObjModelData - | TRecdRepr of TyconRecdFields - | TUnionRepr of TyconUnionData - | TILObjectRepr of TILObjectReprData - | TAsmRepr of AbstractIL.IL.ILType - | TMeasureableRepr of TType - | TProvidedTypeExtensionPoint of TProvidedTypeInfo - | TProvidedNamespaceExtensionPoint of - ExtensionTyping.ResolutionEnvironment * - Tainted list - | TNoRepr - with - override ToString: unit -> string - - [] - and TILObjectReprData = - | TILObjectReprData of - scope: AbstractIL.IL.ILScopeRef * nesting: AbstractIL.IL.ILTypeDef list * - definition: AbstractIL.IL.ILTypeDef - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and TProvidedTypeInfo = - { ResolutionEnvironment: ExtensionTyping.ResolutionEnvironment - ProvidedType: Tainted - LazyBaseType: - AbstractIL.Internal.Library.LazyWithContext - IsClass: bool - IsSealed: bool - IsAbstract: bool - IsInterface: bool - IsStructOrEnum: bool - IsEnum: bool - UnderlyingTypeOfEnum: unit -> TType - IsDelegate: unit -> bool - IsErased: bool - IsSuppressRelocate: bool } - with - member BaseTypeForErased: m:Range.range * objTy:TType -> TType - override ToString: unit -> string - [ (0))>] - member DebugText: string - member IsGenerated: bool - - and TyconObjModelKind = - | TTyconClass - | TTyconInterface - | TTyconStruct - | TTyconDelegate of SlotSig - | TTyconEnum - with - member IsValueType: bool - - [] - and TyconObjModelData = - { fsobjmodel_kind: TyconObjModelKind - fsobjmodel_vslots: ValRef list - fsobjmodel_rfields: TyconRecdFields } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and TyconRecdFields = - { FieldsByIndex: RecdField [] - FieldsByName: AbstractIL.Internal.Library.NameMap } - with - member FieldByIndex: n:int -> RecdField - member FieldByName: nm:string -> RecdField option - override ToString: unit -> string - member AllFieldsAsList: RecdField list - [ (0))>] - member DebugText: string - member TrueFieldsAsList: RecdField list - member TrueInstanceFieldsAsList: RecdField list - - [] - and TyconUnionCases = - { CasesByIndex: UnionCase [] - CasesByName: AbstractIL.Internal.Library.NameMap } - with - member GetUnionCaseByIndex: n:int -> UnionCase - override ToString: unit -> string - [ (0))>] - member DebugText: string - member UnionCasesAsList: UnionCase list - - [] - and TyconUnionData = - { CasesTable: TyconUnionCases - CompiledRepresentation: - Lib.cache } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - member UnionCasesAsList: UnionCase list - - [] - and UnionCase = - { FieldTable: TyconRecdFields - ReturnType: TType - XmlDoc: XmlDoc.XmlDoc - mutable XmlDocSig: string - Id: SyntaxTree.Ident - mutable OtherRangeOpt: (Range.range * bool) option - Accessibility: Accessibility - mutable Attribs: Attribs } - with - member GetFieldByIndex: n:int -> RecdField - member GetFieldByName: nm:string -> RecdField option - override ToString: unit -> string - member CompiledName: string - [ (0))>] - member DebugText: string - member DefinitionRange: Range.range - member DisplayName: string - member IsNullary: bool - member Range: Range.range - member RecdFields: RecdField list - member RecdFieldsArray: RecdField [] - member SigRange: Range.range - - [] - and RecdField = - { rfield_mutable: bool - rfield_xmldoc: XmlDoc.XmlDoc - mutable rfield_xmldocsig: string - rfield_type: TType - rfield_static: bool - rfield_volatile: bool - rfield_secret: bool - rfield_const: Const option - rfield_access: Accessibility - mutable rfield_pattribs: Attribs - mutable rfield_fattribs: Attribs - rfield_id: SyntaxTree.Ident - rfield_name_generated: bool - mutable rfield_other_range: (Range.range * bool) option } - with - override ToString: unit -> string - member Accessibility: Accessibility - [ (0))>] - member DebugText: string - member DefinitionRange: Range.range - member FieldAttribs: Attribs - member FormalType: TType - member Id: SyntaxTree.Ident - member IsCompilerGenerated: bool - member IsMutable: bool - member IsStatic: bool - member IsVolatile: bool - member IsZeroInit: bool - member LiteralValue: Const option - member Name: string - member PropertyAttribs: Attribs - member Range: Range.range - member SigRange: Range.range - member XmlDoc: XmlDoc.XmlDoc - member XmlDocSig: string - - [] - and ExceptionInfo = - | TExnAbbrevRepr of TyconRef - | TExnAsmRepr of AbstractIL.IL.ILTypeRef - | TExnFresh of TyconRecdFields - | TExnNone - with - override ToString: unit -> string - - [] - and ModuleOrNamespaceType = - - new: kind:ModuleOrNamespaceKind * - vals:Internal.Utilities.QueueList * - entities:Internal.Utilities.QueueList -> - ModuleOrNamespaceType - member AddEntity: tycon:Tycon -> ModuleOrNamespaceType - member AddModuleOrNamespaceByMutation: modul:ModuleOrNamespace -> unit - member AddProvidedTypeEntity: entity:Entity -> unit - member AddVal: vspec:Val -> ModuleOrNamespaceType - override ToString: unit -> string - member TryLinkVal: ccu:CcuThunk * key:ValLinkageFullKey -> Val voption - member - ActivePatternElemRefLookupTable: AbstractIL.Internal.Library.NameMap option ref - member AllEntities: Internal.Utilities.QueueList - member - AllEntitiesByCompiledAndLogicalMangledNames: AbstractIL.Internal.Library.NameMap - member - AllEntitiesByLogicalMangledName: AbstractIL.Internal.Library.NameMap - member AllValsAndMembers: Internal.Utilities.QueueList - member - AllValsAndMembersByLogicalNameUncached: AbstractIL.Internal.Library.MultiMap - member - AllValsAndMembersByPartialLinkageKey: AbstractIL.Internal.Library.MultiMap - member AllValsByLogicalName: AbstractIL.Internal.Library.NameMap - [ (0))>] - member DebugText: string - member ExceptionDefinitions: Entity list - member - ExceptionDefinitionsByDemangledName: AbstractIL.Internal.Library.NameMap - member ModuleAndNamespaceDefinitions: Entity list - member ModuleOrNamespaceKind: ModuleOrNamespaceKind - member - ModulesAndNamespacesByDemangledName: AbstractIL.Internal.Library.NameMap - member TypeAndExceptionDefinitions: Entity list - member TypeDefinitions: Entity list - member - TypesByAccessNames: AbstractIL.Internal.Library.LayeredMultiMap - member - TypesByDemangledNameAndArity: AbstractIL.Internal.Library.LayeredMap - member TypesByMangledName: AbstractIL.Internal.Library.NameMap - - and ModuleOrNamespace = Entity - and Tycon = Entity - [] - and Accessibility = - | TAccess of CompilationPath list - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and TyparOptionalData = - { mutable typar_il_name: string option - mutable typar_xmldoc: XmlDoc.XmlDoc - mutable typar_constraints: TyparConstraint list - mutable typar_attribs: Attribs } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - and TyparData = Typar - [] - and Typar = - { mutable typar_id: SyntaxTree.Ident - mutable typar_flags: TyparFlags - mutable typar_stamp: Stamp - mutable typar_solution: TType option - mutable typar_astype: TType - mutable typar_opt_data: TyparOptionalData option } - with - static member New: data:TyparData -> Typar - static member NewUnlinked: unit -> Typar - member Link: tg:TyparData -> unit - member SetAttribs: attribs:Attrib list -> unit - member SetComparisonDependsOn: b:bool -> unit - member SetCompilerGenerated: b:bool -> unit - member SetConstraints: cs:TyparConstraint list -> unit - member SetDynamicReq: b:TyparDynamicReq -> unit - member SetEqualityDependsOn: b:bool -> unit - member SetILName: il_name:string option -> unit - member SetIdent: id:SyntaxTree.Ident -> unit - member SetIsCompatFlex: b:bool -> unit - member SetRigidity: b:TyparRigidity -> unit - member SetStaticReq: b:SyntaxTree.TyparStaticReq -> unit - override ToString: unit -> string - member AsType: TType - member Attribs: Attribs - member ComparisonConditionalOn: bool - member Constraints: TyparConstraint list - [ (0))>] - member DebugText: string - member DisplayName: string - member DynamicReq: TyparDynamicReq - member EqualityConditionalOn: bool - member ILName: string option - member Id: SyntaxTree.Ident - member IsCompatFlex: bool - member IsCompilerGenerated: bool - member IsErased: bool - member IsFromError: bool - member IsLinked: bool - member IsSolved: bool - member Kind: TyparKind - member Name: string - member Range: Range.range - member Rigidity: TyparRigidity - member Solution: TType option - member Stamp: Stamp - member StaticReq: SyntaxTree.TyparStaticReq - member XmlDoc: XmlDoc.XmlDoc - - [] - and TyparConstraint = - | CoercesTo of TType * Range.range - | DefaultsTo of int * TType * Range.range - | SupportsNull of Range.range - | MayResolveMember of TraitConstraintInfo * Range.range - | IsNonNullableStruct of Range.range - | IsReferenceType of Range.range - | SimpleChoice of TTypes * Range.range - | RequiresDefaultConstructor of Range.range - | IsEnum of TType * Range.range - | SupportsComparison of Range.range - | SupportsEquality of Range.range - | IsDelegate of TType * TType * Range.range - | IsUnmanaged of Range.range - with - override ToString: unit -> string - - [] - and TraitWitnessInfo = - | TraitWitnessInfo of - TTypes * string * SyntaxTree.MemberFlags * TTypes * TType option - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - member MemberName: string - member ReturnType: TType option - - [] - and TraitConstraintInfo = - | TTrait of - tys: TTypes * memberName: string * _memFlags: SyntaxTree.MemberFlags * - argTys: TTypes * returnTy: TType option * - solution: TraitConstraintSln option ref - with - override ToString: unit -> string - member ArgumentTypes: TTypes - [ (0))>] - member DebugText: string - member MemberFlags: SyntaxTree.MemberFlags - member MemberName: string - member ReturnType: TType option - member Solution: TraitConstraintSln option - member TraitKey: TraitWitnessInfo - - [] - and TraitConstraintSln = - | FSMethSln of TType * ValRef * TypeInst - | FSRecdFieldSln of TypeInst * RecdFieldRef * bool - | FSAnonRecdFieldSln of AnonRecdTypeInfo * TypeInst * int - | ILMethSln of - TType * AbstractIL.IL.ILTypeRef option * AbstractIL.IL.ILMethodRef * - TypeInst - | ClosedExprSln of Expr - | BuiltInSln - with - override ToString: unit -> string - - [] - and ValLinkagePartialKey = - { MemberParentMangledName: string option - MemberIsOverride: bool - LogicalName: string - TotalArgCount: int } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and ValLinkageFullKey = - - new: partialKey:ValLinkagePartialKey * typeForLinkage:TType option -> - ValLinkageFullKey - override ToString: unit -> string - [ (0))>] - member DebugText: string - member PartialKey: ValLinkagePartialKey - member TypeForLinkage: TType option - - [] - and ValOptionalData = - { mutable val_compiled_name: string option - mutable val_other_range: (Range.range * bool) option - mutable val_const: Const option - mutable val_defn: Expr option - mutable val_repr_info: ValReprInfo option - mutable val_access: Accessibility - mutable val_xmldoc: XmlDoc.XmlDoc - mutable val_member_info: ValMemberInfo option - mutable val_declaring_entity: ParentRef - mutable val_xmldocsig: string - mutable val_attribs: Attribs } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - and ValData = Val - [] - and Val = - { mutable val_logical_name: string - mutable val_range: Range.range - mutable val_type: TType - mutable val_stamp: Stamp - mutable val_flags: ValFlags - mutable val_opt_data: ValOptionalData option } - with - static member New: data:Val -> Val - static member NewEmptyValOptData: unit -> ValOptionalData - static member NewUnlinked: unit -> Val - member - CompiledName: compilerGlobalState:CompilerGlobalState.CompilerGlobalState option -> - string - member GetLinkageFullKey: unit -> ValLinkageFullKey - member GetLinkagePartialKey: unit -> ValLinkagePartialKey - member Link: tg:ValData -> unit - member SetAttribs: attribs:Attribs -> unit - member SetData: tg:ValData -> unit - member SetDeclaringEntity: parent:ParentRef -> unit - member SetHasBeenReferenced: unit -> unit - member SetIgnoresByrefScope: unit -> unit - member SetIsCompiledAsStaticPropertyWithoutField: unit -> unit - member SetIsFixed: unit -> unit - member SetIsMemberOrModuleBinding: unit -> unit - member SetMakesNoCriticalTailcalls: unit -> unit - member SetMemberInfo: member_info:ValMemberInfo -> unit - member SetOtherRange: m:(Range.range * bool) -> unit - member SetType: ty:TType -> unit - member SetValDefn: val_defn:Expr -> unit - member SetValRec: b:ValRecursiveScopeInfo -> unit - member SetValReprInfo: info:ValReprInfo option -> unit - override ToString: unit -> string - member Accessibility: Accessibility - member ApparentEnclosingEntity: ParentRef - member Attribs: Attrib list - member BaseOrThisInfo: ValBaseOrThisInfo - member CoreDisplayName: string - [ (0))>] - member DebugText: string - member DeclaringEntity: ParentRef - member DefinitionRange: Range.range - member DisplayName: string - member HasBeenReferenced: bool - member HasDeclaringEntity: bool - member Id: SyntaxTree.Ident - member IgnoresByrefScope: bool - member InlineInfo: ValInline - member IsClassConstructor: bool - member IsCompiledAsStaticPropertyWithoutField: bool - member IsCompiledAsTopLevel: bool - member IsCompiledIntoModule: bool - member IsCompilerGenerated: bool - member IsConstructor: bool - member IsDispatchSlot: bool - member IsExtensionMember: bool - member IsFixed: bool - member IsIncrClassConstructor: bool - member IsIncrClassGeneratedMember: bool - member IsInstanceMember: bool - member IsIntrinsicMember: bool - member IsLinked: bool - member IsMember: bool - member IsMemberOrModuleBinding: bool - member IsModuleBinding: bool - member IsMutable: bool - member IsOverrideOrExplicitImpl: bool - member IsTypeFunction: bool - member LiteralValue: Const option - member LogicalName: string - member MakesNoCriticalTailcalls: bool - member MemberApparentEntity: TyconRef - member MemberInfo: ValMemberInfo option - member MustInline: bool - member NumObjArgs: int - member PermitsExplicitTypeInstantiation: bool - member PropertyName: string - member PublicPath: ValPublicPath option - member Range: Range.range - member RecursiveValInfo: ValRecursiveScopeInfo - member ReflectedDefinition: Expr option - member SigRange: Range.range - member Stamp: Stamp - member TauType: TType - member TopValDeclaringEntity: EntityRef - member Typars: Typars - member Type: TType - member TypeScheme: Typars * TType - member ValCompiledName: string option - member ValReprInfo: ValReprInfo option - member XmlDoc: XmlDoc.XmlDoc - member XmlDocSig: string - - [] - and ValMemberInfo = - { ApparentEnclosingEntity: TyconRef - mutable ImplementedSlotSigs: SlotSig list - mutable IsImplemented: bool - MemberFlags: SyntaxTree.MemberFlags } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and NonLocalValOrMemberRef = - { EnclosingEntity: EntityRef - ItemKey: ValLinkageFullKey } - with - override ToString: unit -> string - member AssemblyName: string - member Ccu: CcuThunk - [ (0))>] - member DebugText: string - - [] - and ValPublicPath = - | ValPubPath of PublicPath * ValLinkageFullKey - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and NonLocalEntityRef = - | NonLocalEntityRef of CcuThunk * string [] - with - static member - TryDerefEntityPath: ccu:CcuThunk * path:string [] * i:int * - entity:Entity -> Entity voption - static member - TryDerefEntityPathViaProvidedType: ccu:CcuThunk * path:string [] * - i:int * entity:Entity -> - Entity voption - override ToString: unit -> string - member TryDeref: canError:bool -> Entity voption - member AssemblyName: string - member Ccu: CcuThunk - [ (0))>] - member DebugText: string - member Deref: Entity - member DisplayName: string - member EnclosingMangledPath: string [] - member LastItemMangledName: string - member ModuleOrNamespaceType: ModuleOrNamespaceType - member Path: string [] - - [] - and EntityRef = - { mutable binding: Lib.NonNullSlot - nlr: NonLocalEntityRef } - with - member GetFieldByIndex: n:int -> RecdField - member GetFieldByName: n:string -> RecdField option - member GetUnionCaseByName: n:string -> UnionCase option - member MakeNestedRecdFieldRef: rf:RecdField -> RecdFieldRef - member MakeNestedUnionCaseRef: uc:UnionCase -> UnionCaseRef - member private Resolve: canError:bool -> unit - member SetIsAssumedReadOnly: b:bool -> unit - member SetIsByRefLike: b:bool -> unit - member SetIsReadOnly: b:bool -> unit - override ToString: unit -> string - member Typars: m:Range.range -> Typars - member Accessibility: Accessibility - member AllFieldAsRefList: RecdFieldRef list - member AllFieldTable: TyconRecdFields - member AllFieldsArray: RecdField [] - member AllFieldsAsList: RecdField list - member AllInstanceFieldsAsList: RecdField list - member Attribs: Attribs - member CanDeref: bool - member CompilationPath: CompilationPath - member CompilationPathOpt: CompilationPath option - member CompiledName: string - member CompiledReprCache: Lib.cache - member CompiledRepresentation: CompiledTypeRepr - member CompiledRepresentationForNamedType: AbstractIL.IL.ILTypeRef - [ (0))>] - member DebugText: string - member DefinitionRange: Range.range - member DemangledModuleOrNamespaceName: string - member Deref: Entity - member DisplayName: string - member DisplayNameWithStaticParameters: string - member DisplayNameWithStaticParametersAndTypars: string - member DisplayNameWithStaticParametersAndUnderscoreTypars: string - member ExceptionInfo: ExceptionInfo - member FSharpObjectModelTypeInfo: TyconObjModelData - member GeneratedCompareToValues: (ValRef * ValRef) option - member GeneratedCompareToWithComparerValues: ValRef option - member GeneratedHashAndEqualsValues: (ValRef * ValRef) option - member - GeneratedHashAndEqualsWithComparerValues: (ValRef * ValRef * ValRef) option - member HasSelfReferentialConstructor: bool - member ILTyconInfo: TILObjectReprData - member ILTyconRawMetadata: AbstractIL.IL.ILTypeDef - member Id: SyntaxTree.Ident - member ImmediateInterfaceTypesOfFSharpTycon: TType list - member - ImmediateInterfacesOfFSharpTycon: (TType * bool * Range.range) list - member IsAsmReprTycon: bool - member IsEnumTycon: bool - member IsErased: bool - member IsExceptionDecl: bool - member IsFSharpDelegateTycon: bool - member IsFSharpEnumTycon: bool - member IsFSharpInterfaceTycon: bool - member IsFSharpObjectModelTycon: bool - member IsFSharpStructOrEnumTycon: bool - member IsHiddenReprTycon: bool - member IsILEnumTycon: bool - member IsILStructOrEnumTycon: bool - member IsILTycon: bool - member IsLocalRef: bool - member IsMeasureableReprTycon: bool - member IsModule: bool - member IsModuleOrNamespace: bool - member IsNamespace: bool - member IsPrefixDisplay: bool - member IsProvided: bool - member IsProvidedErasedTycon: bool - member IsProvidedGeneratedTycon: bool - member IsProvidedNamespace: bool - member IsRecordTycon: bool - member IsResolved: bool - member IsStaticInstantiationTycon: bool - member IsStructOrEnumTycon: bool - member IsTypeAbbrev: bool - member IsUnionTycon: bool - member LogicalName: string - member - MembersOfFSharpTyconByName: AbstractIL.Internal.Library.NameMultiMap - member MembersOfFSharpTyconSorted: ValRef list - member ModuleOrNamespaceType: ModuleOrNamespaceType - member PreEstablishedHasDefaultConstructor: bool - member PublicPath: PublicPath option - member Range: Range.range - member ResolvedTarget: Lib.NonNullSlot - member SigRange: Range.range - member Stamp: Stamp - member TrueFieldsAsList: RecdField list - member TrueInstanceFieldsAsList: RecdField list - member TrueInstanceFieldsAsRefList: RecdFieldRef list - member TryDeref: Lib.NonNullSlot voption - member TryIsAssumedReadOnly: bool voption - member TryIsByRefLike: bool voption - member TryIsReadOnly: bool voption - member TyparsNoRange: Typars - member TypeAbbrev: TType option - member TypeContents: TyconAugmentation - member TypeOrMeasureKind: TyparKind - member TypeReprAccessibility: Accessibility - member TypeReprInfo: TyconRepresentation - member UnionCasesArray: UnionCase [] - member UnionCasesAsList: UnionCase list - member UnionCasesAsRefList: UnionCaseRef list - member UnionTypeInfo: TyconUnionData voption - member XmlDoc: XmlDoc.XmlDoc - member XmlDocSig: string - - and ModuleOrNamespaceRef = EntityRef - and TyconRef = EntityRef - [] - and ValRef = - { mutable binding: Lib.NonNullSlot - nlr: NonLocalValOrMemberRef } - with - override ToString: unit -> string - member Accessibility: Accessibility - member ApparentEnclosingEntity: ParentRef - member Attribs: Attrib list - member BaseOrThisInfo: ValBaseOrThisInfo - member - CompiledName: (CompilerGlobalState.CompilerGlobalState option -> - string) - member CoreDisplayName: string - [ (0))>] - member DebugText: string - member DeclaringEntity: ParentRef - member DefinitionRange: Range.range - member Deref: Val - member DisplayName: string - member HasDeclaringEntity: bool - member Id: SyntaxTree.Ident - member InlineInfo: ValInline - member IsCompiledAsTopLevel: bool - member IsCompilerGenerated: bool - member IsConstructor: bool - member IsDispatchSlot: bool - member IsExtensionMember: bool - member IsIncrClassConstructor: bool - member IsIncrClassGeneratedMember: bool - member IsInstanceMember: bool - member IsLocalRef: bool - member IsMember: bool - member IsMemberOrModuleBinding: bool - member IsModuleBinding: bool - member IsMutable: bool - member IsOverrideOrExplicitImpl: bool - member IsPropertyGetterMethod: bool - member IsPropertySetterMethod: bool - member IsResolved: bool - member IsTypeFunction: bool - member LiteralValue: Const option - member LogicalName: string - member MakesNoCriticalTailcalls: bool - member MemberApparentEntity: TyconRef - member MemberInfo: ValMemberInfo option - member MustInline: bool - member NumObjArgs: int - member PermitsExplicitTypeInstantiation: bool - member PropertyName: string - member PublicPath: ValPublicPath option - member Range: Range.range - member RecursiveValInfo: ValRecursiveScopeInfo - member ReflectedDefinition: Expr option - member ResolvedTarget: Lib.NonNullSlot - member SigRange: Range.range - member Stamp: Stamp - member TauType: TType - member TopValDeclaringEntity: EntityRef - member TryDeref: Val voption - member Typars: Typars - member Type: TType - member TypeScheme: Typars * TType - member ValReprInfo: ValReprInfo option - member XmlDoc: XmlDoc.XmlDoc - member XmlDocSig: string - - [] - and UnionCaseRef = - | UnionCaseRef of TyconRef * string - with - member FieldByIndex: n:int -> RecdField - override ToString: unit -> string - member AllFieldsAsList: RecdField list - member Attribs: Attribs - member CaseName: string - [ (0))>] - member DebugText: string - member DefinitionRange: Range.range - member Index: int - member Range: Range.range - member ReturnType: TType - member SigRange: Range.range - member TryUnionCase: UnionCase voption - member Tycon: Entity - member TyconRef: TyconRef - member UnionCase: UnionCase - - [] - and RecdFieldRef = - | RecdFieldRef of TyconRef * string - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - member DefinitionRange: Range.range - member FieldName: string - member Index: int - member PropertyAttribs: Attribs - member Range: Range.range - member RecdField: RecdField - member SigRange: Range.range - member TryRecdField: RecdField voption - member Tycon: Entity - member TyconRef: TyconRef - - [] - and TType = - | TType_forall of Typars * TType - | TType_app of TyconRef * TypeInst - | TType_anon of AnonRecdTypeInfo * TType list - | TType_tuple of TupInfo * TTypes - | TType_fun of TType * TType - | TType_ucase of UnionCaseRef * TypeInst - | TType_var of Typar - | TType_measure of Measure - with - member GetAssemblyName: unit -> string - override ToString: unit -> string - [ (0))>] - member DebugText: string - - and TypeInst = TType list - and TTypes = TType list - [] - and AnonRecdTypeInfo = - { mutable Assembly: CcuThunk - mutable TupInfo: TupInfo - mutable SortedIds: SyntaxTree.Ident [] - mutable Stamp: Stamp - mutable SortedNames: string [] } - with - static member - Create: ccu:CcuThunk * tupInfo:TupInfo * ids:SyntaxTree.Ident [] -> - AnonRecdTypeInfo - static member NewUnlinked: unit -> AnonRecdTypeInfo - member Link: d:AnonRecdTypeInfo -> unit - member ILTypeRef: AbstractIL.IL.ILTypeRef - member IsLinked: bool - - [] - and TupInfo = | Const of bool - [] - and Measure = - | Var of Typar - | Con of TyconRef - | Prod of Measure * Measure - | Inv of Measure - | One - | RationalPower of Measure * Rational.Rational - with - override ToString: unit -> string - - and Attribs = Attrib list - [] - and AttribKind = - | ILAttrib of AbstractIL.IL.ILMethodRef - | FSAttrib of ValRef - with - override ToString: unit -> string - - [] - and Attrib = - | Attrib of - TyconRef * AttribKind * AttribExpr list * AttribNamedArg list * bool * - System.AttributeTargets option * Range.range - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - member Range: Range.range - member TyconRef: TyconRef - - [] - and AttribExpr = - | AttribExpr of Expr * Expr - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and AttribNamedArg = - | AttribNamedArg of (string * TType * bool * AttribExpr) - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and Const = - | Bool of bool - | SByte of sbyte - | Byte of byte - | Int16 of int16 - | UInt16 of uint16 - | Int32 of int32 - | UInt32 of uint32 - | Int64 of int64 - | UInt64 of uint64 - | IntPtr of int64 - | UIntPtr of uint64 - | Single of single - | Double of double - | Char of char - | String of string - | Decimal of System.Decimal - | Unit - | Zero - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and DecisionTree = - | TDSwitch of - Expr * DecisionTreeCase list * DecisionTree option * Range.range - | TDSuccess of Exprs * int - | TDBind of Binding * DecisionTree - with - override ToString: unit -> string - - [] - and DecisionTreeCase = - | TCase of DecisionTreeTest * DecisionTree - with - override ToString: unit -> string - member CaseTree: DecisionTree - [ (0))>] - member DebugText: string - member Discriminator: DecisionTreeTest - - [] - and DecisionTreeTest = - | UnionCase of UnionCaseRef * TypeInst - | ArrayLength of int * TType - | Const of Const - | IsNull - | IsInst of TType * TType - | ActivePatternCase of - Expr * TTypes * (ValRef * TypeInst) option * int * - PrettyNaming.ActivePatternInfo - | Error of Range.range - with - override ToString: unit -> string - - [] - and DecisionTreeTarget = - | TTarget of Val list * Expr * SyntaxTree.DebugPointForTarget - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - and Bindings = Binding list - [] - and Binding = - | TBind of Val * Expr * SyntaxTree.DebugPointForBinding - with - override ToString: unit -> string - member DebugPoint: SyntaxTree.DebugPointForBinding - [ (0))>] - member DebugText: string - member Expr: Expr - member Var: Val - - [] - and ActivePatternElemRef = - | APElemRef of PrettyNaming.ActivePatternInfo * ValRef * int - with - override ToString: unit -> string - member ActivePatternInfo: PrettyNaming.ActivePatternInfo - member ActivePatternVal: ValRef - member CaseIndex: int - [ (0))>] - member DebugText: string - - [] - and ValReprInfo = - | ValReprInfo of TyparReprInfo list * ArgReprInfo list list * ArgReprInfo - with - override ToString: unit -> string - member ArgInfos: ArgReprInfo list list - member ArgNames: string list option - member AritiesOfArgs: int list - [ (0))>] - member DebugText: string - member HasNoArgs: bool - member KindsOfTypars: TyparKind list - member NumCurriedArgs: int - member NumTypars: int - member TotalArgCount: int - - [] - and ArgReprInfo = - { mutable Attribs: Attribs - mutable Name: SyntaxTree.Ident option } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - and TyparReprInfo = | TyparReprInfo of SyntaxTree.Ident * TyparKind - and Typars = Typar list - and Exprs = Expr list - and Vals = Val list - [] - and Expr = - | Const of value: Const * range: Range.range * constType: TType - | Val of valRef: ValRef * flags: ValUseFlag * range: Range.range - | Sequential of - expr1: Expr * expr2: Expr * kind: SequentialOpKind * - debugPoint: SyntaxTree.DebugPointAtSequential * range: Range.range - | Lambda of - unique: CompilerGlobalState.Unique * ctorThisValOpt: Val option * - baseValOpt: Val option * valParams: Val list * bodyExpr: Expr * - range: Range.range * overallType: TType - | TyLambda of - unique: CompilerGlobalState.Unique * typeParams: Typars * bodyExpr: Expr * - range: Range.range * overallType: TType - | App of - funcExpr: Expr * formalType: TType * typeArgs: TypeInst * args: Exprs * - range: Range.range - | LetRec of - bindings: Bindings * bodyExpr: Expr * range: Range.range * - frees: FreeVarsCache - | Let of - binding: Binding * bodyExpr: Expr * range: Range.range * - frees: FreeVarsCache - | Obj of - unique: CompilerGlobalState.Unique * objTy: TType * baseVal: Val option * - ctorCall: Expr * overrides: ObjExprMethod list * - interfaceImpls: (TType * ObjExprMethod list) list * range: Range.range - | Match of - debugPoint: SyntaxTree.DebugPointForBinding * inputRange: Range.range * - decision: DecisionTree * targets: DecisionTreeTarget array * - fullRange: Range.range * exprType: TType - | StaticOptimization of - conditions: StaticOptimization list * expr: Expr * alternativeExpr: Expr * - range: Range.range - | Op of op: TOp * typeArgs: TypeInst * args: Exprs * range: Range.range - | Quote of - quotedExpr: Expr * - quotationInfo: - ((AbstractIL.IL.ILTypeRef list * TTypes * Exprs * - QuotationPickler.ExprData) * - (AbstractIL.IL.ILTypeRef list * TTypes * Exprs * - QuotationPickler.ExprData)) option ref * isFromQueryExpression: bool * - range: Range.range * quotedType: TType - | WitnessArg of traitInfo: TraitConstraintInfo * range: Range.range - | TyChoose of typeParams: Typars * bodyExpr: Expr * range: Range.range - | Link of Expr ref - with - member ToDebugString: depth:int -> string - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and TOp = - | UnionCase of UnionCaseRef - | ExnConstr of TyconRef - | Tuple of TupInfo - | AnonRecd of AnonRecdTypeInfo - | AnonRecdGet of AnonRecdTypeInfo * int - | Array - | Bytes of byte [] - | UInt16s of uint16 [] - | While of SyntaxTree.DebugPointAtWhile * SpecialWhileLoopMarker - | For of SyntaxTree.DebugPointAtFor * ForLoopStyle - | TryWith of SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith - | TryFinally of - SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally - | Recd of RecordConstructionInfo * TyconRef - | ValFieldSet of RecdFieldRef - | ValFieldGet of RecdFieldRef - | ValFieldGetAddr of RecdFieldRef * readonly: bool - | UnionCaseTagGet of TyconRef - | UnionCaseProof of UnionCaseRef - | UnionCaseFieldGet of UnionCaseRef * int - | UnionCaseFieldGetAddr of UnionCaseRef * int * readonly: bool - | UnionCaseFieldSet of UnionCaseRef * int - | ExnFieldGet of TyconRef * int - | ExnFieldSet of TyconRef * int - | TupleFieldGet of TupInfo * int - | ILAsm of instrs: AbstractIL.IL.ILInstr list * retTypes: TTypes - | RefAddrGet of bool - | Coerce - | Reraise - | Return - | Goto of AbstractIL.IL.ILCodeLabel - | Label of AbstractIL.IL.ILCodeLabel - | TraitCall of TraitConstraintInfo - | LValueOp of LValueOperation * ValRef - | ILCall of - isVirtual: bool * isProtected: bool * isStruct: bool * isCtor: bool * - valUseFlag: ValUseFlag * isProperty: bool * noTailCall: bool * - ilMethRef: AbstractIL.IL.ILMethodRef * enclTypeInst: TypeInst * - methInst: TypeInst * retTypes: TTypes - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - and RecordConstructionInfo = - | RecdExprIsObjInit - | RecdExpr - and ConstrainedCallInfo = TType option - and SpecialWhileLoopMarker = - | NoSpecialWhileLoopMarker - | WhileLoopForCompiledForEachExprMarker - and ForLoopStyle = - | FSharpForLoopUp - | FSharpForLoopDown - | CSharpForLoopUp - and LValueOperation = - | LAddrOf of readonly: bool - | LByrefGet - | LSet - | LByrefSet - and SequentialOpKind = - | NormalSeq - | ThenDoSeq - and ValUseFlag = - | PossibleConstrainedCall of TType - | NormalValUse - | CtorValUsedAsSuperInit - | CtorValUsedAsSelfInit - | VSlotDirectCall - and StaticOptimization = - | TTyconEqualsTycon of TType * TType - | TTyconIsStruct of TType - [] - and ObjExprMethod = - | TObjExprMethod of - SlotSig * Attribs * Typars * Val list list * Expr * Range.range - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - member Id: SyntaxTree.Ident - - [] - and SlotSig = - | TSlotSig of - methodName: string * implementedType: TType * classTypars: Typars * - methodTypars: Typars * formalParams: SlotParam list list * - formalReturn: TType option - with - override ToString: unit -> string - member ClassTypars: Typars - [ (0))>] - member DebugText: string - member FormalParams: SlotParam list list - member FormalReturnType: TType option - member ImplementedType: TType - member MethodTypars: Typars - member Name: string - - [] - and SlotParam = - | TSlotParam of - paramName: string option * paramType: TType * isIn: bool * isOut: bool * - isOptional: bool * attributes: Attribs - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - member Type: TType - - [] - and ModuleOrNamespaceExprWithSig = - | ModuleOrNamespaceExprWithSig of - moduleType: ModuleOrNamespaceType * contents: ModuleOrNamespaceExpr * - range: Range.range - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - member Type: ModuleOrNamespaceType - - [] - and ModuleOrNamespaceExpr = - | TMAbstract of ModuleOrNamespaceExprWithSig - | TMDefs of ModuleOrNamespaceExpr list - | TMDefLet of Binding * Range.range - | TMDefDo of Expr * Range.range - | TMDefRec of - isRec: bool * Tycon list * ModuleOrNamespaceBinding list * Range.range - with - override ToString: unit -> string - member DebugText: string - - [] - and ModuleOrNamespaceBinding = - | Binding of Binding - | Module of ModuleOrNamespace * ModuleOrNamespaceExpr - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and TypedImplFile = - | TImplFile of - SyntaxTree.QualifiedNameOfFile * SyntaxTree.ScopedPragma list * - ModuleOrNamespaceExprWithSig * bool * bool * StampMap - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and TypedImplFileAfterOptimization = - { ImplFile: TypedImplFile - OptimizeDuringCodeGen: bool -> Expr -> Expr } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and TypedAssemblyAfterOptimization = - | TypedAssemblyAfterOptimization of TypedImplFileAfterOptimization list - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and CcuData = - { FileName: string option - ILScopeRef: AbstractIL.IL.ILScopeRef - Stamp: Stamp - QualifiedName: string option - SourceCodeDirectory: string - IsFSharp: bool - IsProviderGenerated: bool - InvalidateEvent: IEvent - ImportProvidedType: Tainted -> TType - mutable UsesFSharp20PlusQuotations: bool - mutable Contents: ModuleOrNamespace - TryGetILModuleDef: unit -> AbstractIL.IL.ILModuleDef option - MemberSignatureEquality: TType -> TType -> bool - TypeForwarders: CcuTypeForwarderTable } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - and CcuTypeForwarderTable = Map<(string [] * string),System.Lazy> - and CcuReference = string - [] - and CcuThunk = - { mutable target: CcuData - name: CcuReference } - with - static member Create: nm:CcuReference * x:CcuData -> CcuThunk - static member CreateDelayed: nm:CcuReference -> CcuThunk - member EnsureDerefable: requiringPath:string [] -> unit - member Fixup: avail:CcuThunk -> unit - member - ImportProvidedType: ty:Tainted -> TType - member MemberSignatureEquality: ty1:TType * ty2:TType -> bool - override ToString: unit -> string - member TryForward: nlpath:string [] * item:string -> EntityRef option - member TryGetILModuleDef: unit -> AbstractIL.IL.ILModuleDef option - member AssemblyName: string - member Contents: Entity - [ (0))>] - member DebugText: string - member Deref: CcuData - member FileName: string option - member ILScopeRef: AbstractIL.IL.ILScopeRef - member IsFSharp: bool - member IsProviderGenerated: bool - member IsUnresolvedReference: bool - member QualifiedName: string option - member RootModulesAndNamespaces: Entity list - member RootTypeAndExceptionDefinitions: Entity list - member SourceCodeDirectory: string - member Stamp: Stamp - member TypeForwarders: Map<(string [] * string),System.Lazy> - member UsesFSharp20PlusQuotations: bool - - [] - and CcuResolutionResult = - | ResolvedCcu of CcuThunk - | UnresolvedCcu of string - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - [] - and PickledCcuInfo = - { mspec: ModuleOrNamespace - compileTimeWorkingDir: string - usesQuotations: bool } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - and FreeLocals = AbstractIL.Internal.Zset - and FreeTypars = AbstractIL.Internal.Zset - and FreeTycons = AbstractIL.Internal.Zset - and FreeRecdFields = AbstractIL.Internal.Zset - and FreeUnionCases = AbstractIL.Internal.Zset - [] - and FreeTyvars = - { FreeTycons: FreeTycons - FreeTraitSolutions: FreeLocals - FreeTypars: FreeTypars } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - and FreeVarsCache = Lib.cache - [] - and FreeVars = - { FreeLocals: FreeLocals - UsesMethodLocalConstructs: bool - UsesUnboundRethrow: bool - FreeLocalTyconReprs: FreeTycons - FreeRecdFields: FreeRecdFields - FreeUnionCases: FreeUnionCases - FreeTyvars: FreeTyvars } - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - - and Construct = - - new: unit -> Construct - static member - ComputeDefinitionLocationOfProvidedItem: p:Tainted<#ExtensionTyping.IProvidedCustomAttributeProvider> -> - Range.range option - static member - KeyTyconByAccessNames: nm:string -> - x:'T -> - System.Collections.Generic.KeyValuePair [] - static member - KeyTyconByDecodedName: nm:string -> - x:'T -> - System.Collections.Generic.KeyValuePair - static member - MakeRecdFieldsTable: ucs:RecdField list -> TyconRecdFields - static member MakeUnionCases: ucs:UnionCase list -> TyconUnionData - static member MakeUnionRepr: ucs:UnionCase list -> TyconRepresentation - static member - NewCcuContents: sref:AbstractIL.IL.ILScopeRef -> - m:Range.range -> - nm:string -> - mty:ModuleOrNamespaceType -> ModuleOrNamespace - static member NewClonedModuleOrNamespace: orig:Tycon -> Entity - static member NewClonedTycon: orig:Tycon -> Entity - static member - NewEmptyModuleOrNamespaceType: mkind:ModuleOrNamespaceKind -> - ModuleOrNamespaceType - static member - NewExn: cpath:CompilationPath option -> - id:SyntaxTree.Ident -> - access:Accessibility -> - repr:ExceptionInfo -> - attribs:Attribs -> doc:XmlDoc.XmlDoc -> Entity - static member NewFreeVarsCache: unit -> Lib.cache<'a> - static member - NewILTycon: nlpath:CompilationPath option -> - nm:string * m:Range.range -> - tps:AbstractIL.Internal.Library.LazyWithContext -> - scoref:AbstractIL.IL.ILScopeRef * - enc:AbstractIL.IL.ILTypeDef list * - tdef:AbstractIL.IL.ILTypeDef -> - mtyp:Lib.MaybeLazy -> - Entity - static member - NewModifiedModuleOrNamespace: f:(ModuleOrNamespaceType -> - ModuleOrNamespaceType) -> - orig:Tycon -> Entity - static member - NewModifiedTycon: f:(Tycon -> Entity) -> orig:Tycon -> Entity - static member NewModifiedVal: f:(Val -> Val) -> orig:Val -> Val - static member - NewModuleOrNamespace: cpath:CompilationPath option -> - access:Accessibility -> - id:SyntaxTree.Ident -> - xml:XmlDoc.XmlDoc -> - attribs:Attrib list -> - mtype:Lib.MaybeLazy -> - ModuleOrNamespace - static member - NewModuleOrNamespaceType: mkind:ModuleOrNamespaceKind -> - tycons:Entity list -> - vals:Val list -> ModuleOrNamespaceType - static member - NewProvidedTycon: resolutionEnvironment:ExtensionTyping.ResolutionEnvironment * - st:Tainted * - importProvidedType:(Tainted -> - TType) * - isSuppressRelocate:bool * m:Range.range * - ?access:Accessibility * ?cpath:CompilationPath -> - Entity - static member - NewProvidedTyconRepr: resolutionEnvironment:ExtensionTyping.ResolutionEnvironment * - st:Tainted * - importProvidedType:(Tainted -> - TType) * - isSuppressRelocate:bool * m:Range.range -> - TyconRepresentation - static member - NewRecdField: stat:bool -> - konst:Const option -> - id:SyntaxTree.Ident -> - nameGenerated:bool -> - ty:TType -> - isMutable:bool -> - isVolatile:bool -> - pattribs:Attribs -> - fattribs:Attribs -> - docOption:XmlDoc.XmlDoc -> - access:Accessibility -> - secret:bool -> RecdField - static member NewRigidTypar: nm:string -> m:Range.range -> Typar - static member - NewTycon: cpath:CompilationPath option * nm:string * m:Range.range * - access:Accessibility * reprAccess:Accessibility * - kind:TyparKind * - typars:AbstractIL.Internal.Library.LazyWithContext * - doc:XmlDoc.XmlDoc * usesPrefixDisplay:bool * - preEstablishedHasDefaultCtor:bool * - hasSelfReferentialCtor:bool * - mtyp:Lib.MaybeLazy -> Entity - static member - NewTypar: kind:TyparKind * rigid:TyparRigidity * SyntaxTree.SynTypar * - isFromError:bool * dynamicReq:TyparDynamicReq * - attribs:Attrib list * eqDep:bool * compDep:bool -> Typar - static member - NewUnionCase: id:SyntaxTree.Ident -> - tys:RecdField list -> - rty:TType -> - attribs:Attribs -> - docOption:XmlDoc.XmlDoc -> - access:Accessibility -> UnionCase - static member - NewVal: logicalName:string * m:Range.range * - compiledName:string option * ty:TType * - isMutable:ValMutability * isCompGen:bool * - arity:ValReprInfo option * access:Accessibility * - recValInfo:ValRecursiveScopeInfo * - specialRepr:ValMemberInfo option * - baseOrThis:ValBaseOrThisInfo * attribs:Attrib list * - inlineInfo:ValInline * doc:XmlDoc.XmlDoc * - isModuleOrMemberBinding:bool * isExtensionMember:bool * - isIncrClassSpecialMember:bool * isTyFunc:bool * - allowTypeInst:bool * isGeneratedEventVal:bool * - konst:Const option * actualParent:ParentRef -> Val - - - -namespace FSharp.Compiler - module internal TypedTreeBasics = - val getNameOfScopeRef: sref:AbstractIL.IL.ILScopeRef -> string - module ValReprInfo = - val unnamedTopArg1: TypedTree.ArgReprInfo - val unnamedTopArg: TypedTree.ArgReprInfo list - val unitArgData: TypedTree.ArgReprInfo list list - val unnamedRetVal: TypedTree.ArgReprInfo - val selfMetadata: TypedTree.ArgReprInfo list - val emptyValData: TypedTree.ValReprInfo - val InferTyparInfo: - tps:TypedTree.Typar list -> TypedTree.TyparReprInfo list - val InferArgReprInfo: v:TypedTree.Val -> TypedTree.ArgReprInfo - val InferArgReprInfos: - vs:TypedTree.Val list list -> TypedTree.ValReprInfo - val HasNoArgs: TypedTree.ValReprInfo -> bool - - val typeOfVal: v:TypedTree.Val -> TypedTree.TType - val typesOfVals: v:TypedTree.Val list -> TypedTree.TType list - val nameOfVal: v:TypedTree.Val -> string - val arityOfVal: v:TypedTree.Val -> TypedTree.ValReprInfo - val tupInfoRef: TypedTree.TupInfo - val tupInfoStruct: TypedTree.TupInfo - val mkTupInfo: b:bool -> TypedTree.TupInfo - val structnessDefault: bool - val mkRawRefTupleTy: tys:TypedTree.TTypes -> TypedTree.TType - val mkRawStructTupleTy: tys:TypedTree.TTypes -> TypedTree.TType - val mapTImplFile: - f:(TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig) -> - TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val mapAccImplFile: - f:('a -> TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig * 'b) -> - z:'a -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile * 'b - val foldTImplFile: - f:('a -> TypedTree.ModuleOrNamespaceExprWithSig -> 'b) -> - z:'a -> TypedTree.TypedImplFile -> 'b - val typarEq: lv1:TypedTree.Typar -> lv2:TypedTree.Typar -> bool - val typarRefEq: tp1:TypedTree.Typar -> tp2:TypedTree.Typar -> bool - val valEq: lv1:TypedTree.Val -> lv2:TypedTree.Val -> bool - val ccuEq: mv1:TypedTree.CcuThunk -> mv2:TypedTree.CcuThunk -> bool - val ( |ValDeref| ): vr:TypedTree.ValRef -> TypedTree.Val - val mkRecdFieldRef: - tcref:TypedTree.TyconRef -> f:string -> TypedTree.RecdFieldRef - val mkUnionCaseRef: - tcref:TypedTree.TyconRef -> c:string -> TypedTree.UnionCaseRef - val ERefLocal: x:Lib.NonNullSlot -> TypedTree.EntityRef - val ERefNonLocal: x:TypedTree.NonLocalEntityRef -> TypedTree.EntityRef - val ERefNonLocalPreResolved: - x:Lib.NonNullSlot -> - xref:TypedTree.NonLocalEntityRef -> TypedTree.EntityRef - val ( |ERefLocal|ERefNonLocal| ): - x:TypedTree.EntityRef -> - Choice,TypedTree.NonLocalEntityRef> - val mkLocalTyconRef: - x:Lib.NonNullSlot -> TypedTree.EntityRef - val mkNonLocalEntityRef: - ccu:TypedTree.CcuThunk -> mp:string [] -> TypedTree.NonLocalEntityRef - val mkNestedNonLocalEntityRef: - nleref:TypedTree.NonLocalEntityRef -> - id:string -> TypedTree.NonLocalEntityRef - val mkNonLocalTyconRef: - nleref:TypedTree.NonLocalEntityRef -> id:string -> TypedTree.EntityRef - val mkNonLocalTyconRefPreResolved: - x:Lib.NonNullSlot -> - nleref:TypedTree.NonLocalEntityRef -> id:string -> TypedTree.EntityRef - type EntityRef with - member NestedTyconRef: x:TypedTree.Entity -> TypedTree.EntityRef - type EntityRef with - member - RecdFieldRefInNestedTycon: tycon:TypedTree.Entity -> - id:SyntaxTree.Ident -> - TypedTree.RecdFieldRef - val mkModuleUnionCaseRef: - modref:TypedTree.ModuleOrNamespaceRef -> - tycon:TypedTree.Entity -> - uc:TypedTree.UnionCase -> TypedTree.UnionCaseRef - val VRefLocal: x:Lib.NonNullSlot -> TypedTree.ValRef - val VRefNonLocal: x:TypedTree.NonLocalValOrMemberRef -> TypedTree.ValRef - val VRefNonLocalPreResolved: - x:Lib.NonNullSlot -> - xref:TypedTree.NonLocalValOrMemberRef -> TypedTree.ValRef - val ( |VRefLocal|VRefNonLocal| ): - x:TypedTree.ValRef -> - Choice,TypedTree.NonLocalValOrMemberRef> - val mkNonLocalValRef: - mp:TypedTree.NonLocalEntityRef -> - id:TypedTree.ValLinkageFullKey -> TypedTree.ValRef - val mkNonLocalValRefPreResolved: - x:Lib.NonNullSlot -> - mp:TypedTree.NonLocalEntityRef -> - id:TypedTree.ValLinkageFullKey -> TypedTree.ValRef - val ccuOfValRef: vref:TypedTree.ValRef -> TypedTree.CcuThunk option - val ccuOfTyconRef: eref:TypedTree.EntityRef -> TypedTree.CcuThunk option - val mkTyparTy: tp:TypedTree.Typar -> TypedTree.TType - val copyTypar: tp:TypedTree.Typar -> TypedTree.Typar - val copyTypars: tps:TypedTree.Typar list -> TypedTree.Typar list - val tryShortcutSolvedUnitPar: - canShortcut:bool -> r:TypedTree.Typar -> TypedTree.Measure - val stripUnitEqnsAux: - canShortcut:bool -> unt:TypedTree.Measure -> TypedTree.Measure - val stripTyparEqnsAux: - canShortcut:bool -> ty:TypedTree.TType -> TypedTree.TType - val stripTyparEqns: ty:TypedTree.TType -> TypedTree.TType - val stripUnitEqns: unt:TypedTree.Measure -> TypedTree.Measure - val mkLocalValRef: v:TypedTree.Val -> TypedTree.ValRef - val mkLocalModRef: v:TypedTree.ModuleOrNamespace -> TypedTree.EntityRef - val mkLocalEntityRef: v:TypedTree.Entity -> TypedTree.EntityRef - val mkNonLocalCcuRootEntityRef: - ccu:TypedTree.CcuThunk -> x:TypedTree.Entity -> TypedTree.EntityRef - val mkNestedValRef: - cref:TypedTree.EntityRef -> v:TypedTree.Val -> TypedTree.ValRef - val rescopePubPathToParent: - viewedCcu:TypedTree.CcuThunk -> - TypedTree.PublicPath -> TypedTree.NonLocalEntityRef - val rescopePubPath: - viewedCcu:TypedTree.CcuThunk -> - TypedTree.PublicPath -> TypedTree.NonLocalEntityRef - val valRefInThisAssembly: compilingFslib:bool -> x:TypedTree.ValRef -> bool - val tyconRefUsesLocalXmlDoc: - compilingFslib:bool -> x:TypedTree.TyconRef -> bool - val entityRefInThisAssembly: - compilingFslib:bool -> x:TypedTree.EntityRef -> bool - val arrayPathEq: y1:string [] -> y2:string [] -> bool - val nonLocalRefEq: - TypedTree.NonLocalEntityRef -> TypedTree.NonLocalEntityRef -> bool - val nonLocalRefDefinitelyNotEq: - TypedTree.NonLocalEntityRef -> TypedTree.NonLocalEntityRef -> bool - val pubPathEq: TypedTree.PublicPath -> TypedTree.PublicPath -> bool - val fslibRefEq: - nlr1:TypedTree.NonLocalEntityRef -> TypedTree.PublicPath -> bool - val fslibEntityRefEq: - fslibCcu:TypedTree.CcuThunk -> - eref1:TypedTree.EntityRef -> eref2:TypedTree.EntityRef -> bool - val fslibValRefEq: - fslibCcu:TypedTree.CcuThunk -> - vref1:TypedTree.ValRef -> vref2:TypedTree.ValRef -> bool - val primEntityRefEq: - compilingFslib:bool -> - fslibCcu:TypedTree.CcuThunk -> - x:TypedTree.EntityRef -> y:TypedTree.EntityRef -> bool - val primUnionCaseRefEq: - compilingFslib:bool -> - fslibCcu:TypedTree.CcuThunk -> - TypedTree.UnionCaseRef -> TypedTree.UnionCaseRef -> bool - val primValRefEq: - compilingFslib:bool -> - fslibCcu:TypedTree.CcuThunk -> - x:TypedTree.ValRef -> y:TypedTree.ValRef -> bool - val fullCompPathOfModuleOrNamespace: - m:TypedTree.ModuleOrNamespace -> TypedTree.CompilationPath - val inline canAccessCompPathFrom: - TypedTree.CompilationPath -> TypedTree.CompilationPath -> bool - val canAccessFromOneOf: - cpaths:TypedTree.CompilationPath list -> - cpathTest:TypedTree.CompilationPath -> bool - val canAccessFrom: - TypedTree.Accessibility -> cpath:TypedTree.CompilationPath -> bool - val canAccessFromEverywhere: TypedTree.Accessibility -> bool - val canAccessFromSomewhere: TypedTree.Accessibility -> bool - val isLessAccessible: - TypedTree.Accessibility -> TypedTree.Accessibility -> bool - val accessSubstPaths: - newPath:TypedTree.CompilationPath * oldPath:TypedTree.CompilationPath -> - TypedTree.Accessibility -> TypedTree.Accessibility - val compPathOfCcu: ccu:TypedTree.CcuThunk -> TypedTree.CompilationPath - val taccessPublic: TypedTree.Accessibility - val taccessPrivate: - accessPath:TypedTree.CompilationPath -> TypedTree.Accessibility - val compPathInternal: TypedTree.CompilationPath - val taccessInternal: TypedTree.Accessibility - val combineAccess: - TypedTree.Accessibility -> - TypedTree.Accessibility -> TypedTree.Accessibility - exception Duplicate of string * string * Range.range - exception NameClash of - string * string * string * Range.range * string * - string * Range.range - - -namespace FSharp.Compiler - module internal TcGlobals = - val DummyFileNameForRangesWithoutASpecificLocation: string - val private envRange: Range.range - [] - type IntrinsicValRef = - | IntrinsicValRef of - TypedTree.NonLocalEntityRef * string * bool * TypedTree.TType * - TypedTree.ValLinkageFullKey - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - member Name: string - - val ValRefForIntrinsic: IntrinsicValRef -> TypedTree.ValRef - module FSharpLib = - val CoreOperatorsCheckedName: string - val ControlName: string - val LinqName: string - val CollectionsName: string - val LanguagePrimitivesName: string - val CompilerServicesName: string - val LinqRuntimeHelpersName: string - val RuntimeHelpersName: string - val ExtraTopLevelOperatorsName: string - val NativeInteropName: string - val QuotationsName: string - val ControlPath: string list - val LinqPath: string list - val CollectionsPath: string list - val NativeInteropPath: string [] - val CompilerServicesPath: string [] - val LinqRuntimeHelpersPath: string [] - val RuntimeHelpersPath: string [] - val QuotationsPath: string [] - val RootPathArray: string [] - val CorePathArray: string [] - val LinqPathArray: string [] - val ControlPathArray: string [] - val CollectionsPathArray: string [] - - val private mkNonGenericTy: tcref:TypedTree.TyconRef -> TypedTree.TType - val mkNonLocalTyconRef2: - ccu:TypedTree.CcuThunk -> - path:string [] -> n:string -> TypedTree.EntityRef - val mk_MFCore_tcref: - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFQuotations_tcref: - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFLinq_tcref: - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFCollections_tcref: - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFCompilerServices_tcref: - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFRuntimeHelpers_tcref: - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFControl_tcref: - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - [] - type BuiltinAttribInfo = - | AttribInfo of AbstractIL.IL.ILTypeRef * TypedTree.TyconRef - with - override ToString: unit -> string - [ (0))>] - member DebugText: string - member TyconRef: TypedTree.TyconRef - member TypeRef: AbstractIL.IL.ILTypeRef - - [] - val tname_DebuggerNonUserCodeAttribute: string - = "System.Diagnostics.DebuggerNonUserCodeAttribute" - [] - val tname_DebuggableAttribute_DebuggingModes: string = "DebuggingModes" - [] - val tname_DebuggerHiddenAttribute: string - = "System.Diagnostics.DebuggerHiddenAttribute" - [] - val tname_DebuggerDisplayAttribute: string - = "System.Diagnostics.DebuggerDisplayAttribute" - [] - val tname_DebuggerTypeProxyAttribute: string - = "System.Diagnostics.DebuggerTypeProxyAttribute" - [] - val tname_DebuggerStepThroughAttribute: string - = "System.Diagnostics.DebuggerStepThroughAttribute" - [] - val tname_DebuggerBrowsableAttribute: string - = "System.Diagnostics.DebuggerBrowsableAttribute" - [] - val tname_DebuggerBrowsableState: string - = "System.Diagnostics.DebuggerBrowsableState" - [] - val tname_StringBuilder: string = "System.Text.StringBuilder" - [] - val tname_IComparable: string = "System.IComparable" - [] - val tname_Exception: string = "System.Exception" - [] - val tname_Missing: string = "System.Reflection.Missing" - [] - val tname_FormattableString: string = "System.FormattableString" - [] - val tname_SerializationInfo: string - = "System.Runtime.Serialization.SerializationInfo" - [] - val tname_StreamingContext: string - = "System.Runtime.Serialization.StreamingContext" - [] - val tname_SecurityPermissionAttribute: string - = "System.Security.Permissions.SecurityPermissionAttribute" - [] - val tname_Delegate: string = "System.Delegate" - [] - val tname_ValueType: string = "System.ValueType" - [] - val tname_Enum: string = "System.Enum" - [] - val tname_Array: string = "System.Array" - [] - val tname_RuntimeArgumentHandle: string = "System.RuntimeArgumentHandle" - [] - val tname_RuntimeTypeHandle: string = "System.RuntimeTypeHandle" - [] - val tname_RuntimeMethodHandle: string = "System.RuntimeMethodHandle" - [] - val tname_RuntimeFieldHandle: string = "System.RuntimeFieldHandle" - [] - val tname_CompilerGeneratedAttribute: string - = "System.Runtime.CompilerServices.CompilerGeneratedAttribute" - [] - val tname_DebuggableAttribute: string - = "System.Diagnostics.DebuggableAttribute" - [] - val tname_AsyncCallback: string = "System.AsyncCallback" - [] - val tname_IAsyncResult: string = "System.IAsyncResult" - type TcGlobals = - - new: compilingFslib:bool * ilg:AbstractIL.IL.ILGlobals * - fslibCcu:TypedTree.CcuThunk * - directoryToResolveRelativePaths:string * mlCompatibility:bool * - isInteractive:bool * - tryFindSysTypeCcu:(string list -> string -> - TypedTree.CcuThunk option) * - emitDebugInfoInQuotations:bool * noDebugData:bool * - pathMap:Internal.Utilities.PathMap * - langVersion:Features.LanguageVersion -> TcGlobals - member - AddFieldGeneratedAttrs: mdef:AbstractIL.IL.ILFieldDef -> - AbstractIL.IL.ILFieldDef - member - AddFieldNeverAttrs: mdef:AbstractIL.IL.ILFieldDef -> - AbstractIL.IL.ILFieldDef - member - AddMethodGeneratedAttributes: mdef:AbstractIL.IL.ILMethodDef -> - AbstractIL.IL.ILMethodDef - member - EraseClassUnionDef: cud:AbstractIL.IL.ILTypeRef -> - (AbstractIL.IL.ILTypeDef -> - AbstractIL.Extensions.ILX.Types.IlxUnionInfo -> - AbstractIL.IL.ILTypeDef) - member FindSysAttrib: nm:string -> BuiltinAttribInfo - member FindSysILTypeRef: nm:string -> AbstractIL.IL.ILTypeRef - member - FindSysTyconRef: path:string list -> nm:string -> TypedTree.EntityRef - member - MakeBuiltInWitnessInfo: t:TypedTree.TraitConstraintInfo -> - IntrinsicValRef * TypedTree.TType list - override ToString: unit -> string - member TryFindSysAttrib: nm:string -> BuiltinAttribInfo option - member TryFindSysILTypeRef: nm:string -> AbstractIL.IL.ILTypeRef option - member - TryFindSysTyconRef: path:string list -> - nm:string -> TypedTree.EntityRef option - member - TryMakeOperatorAsBuiltInWitnessInfo: isStringTy:(TcGlobals -> - TypedTree.TType -> - bool) -> - isArrayTy:(TcGlobals -> - TypedTree.TType -> - bool) -> - t:TypedTree.TraitConstraintInfo -> - argExprs:'a list -> - (IntrinsicValRef * - TypedTree.TType list * - 'a list) option - member - decompileType: tcref:TypedTree.EntityRef -> - tinst:TypedTree.TypeInst -> TypedTree.TType - member - improveType: tcref:TypedTree.EntityRef -> - tinst:TypedTree.TType list -> TypedTree.TType - member memoize_file: x:int -> AbstractIL.IL.ILSourceDocument - member - mkDebuggableAttribute: jitOptimizerDisabled:bool -> - AbstractIL.IL.ILAttribute - member - mkDebuggableAttributeV2: jitTracking:bool * - ignoreSymbolStoreSequencePoints:bool * - jitOptimizerDisabled:bool * enableEnC:bool -> - AbstractIL.IL.ILAttribute - member - mkDebuggerDisplayAttribute: s:string -> AbstractIL.IL.ILAttribute - member mkDebuggerHiddenAttribute: unit -> AbstractIL.IL.ILAttribute - member - mkDebuggerStepThroughAttribute: unit -> AbstractIL.IL.ILAttribute - member - unionCaseRefEq: x:TypedTree.UnionCaseRef -> - y:TypedTree.UnionCaseRef -> bool - member valRefEq: x:TypedTree.ValRef -> y:TypedTree.ValRef -> bool - member CompilerGeneratedAttribute: AbstractIL.IL.ILAttribute - member - CompilerGlobalState: CompilerGlobalState.CompilerGlobalState option - member DebuggerBrowsableNeverAttribute: AbstractIL.IL.ILAttribute - member IComparer_ty: TypedTree.TType - member IEqualityComparer_ty: TypedTree.TType - member - System_Runtime_CompilerServices_RuntimeFeature_ty: TypedTree.TType option - member addrof2_vref: TypedTree.ValRef - member addrof_vref: TypedTree.ValRef - member and2_vref: TypedTree.ValRef - member and_vref: TypedTree.ValRef - member array2D_get_info: IntrinsicValRef - member array2D_get_vref: TypedTree.ValRef - member array2D_set_info: IntrinsicValRef - member array3D_get_info: IntrinsicValRef - member array3D_get_vref: TypedTree.ValRef - member array3D_set_info: IntrinsicValRef - member array4D_get_info: IntrinsicValRef - member array4D_get_vref: TypedTree.ValRef - member array4D_set_info: IntrinsicValRef - member array_get_info: IntrinsicValRef - member array_get_vref: TypedTree.ValRef - member array_length_info: IntrinsicValRef - member array_set_info: IntrinsicValRef - member array_tcr_nice: TypedTree.EntityRef - member attrib_AbstractClassAttribute: BuiltinAttribInfo - member attrib_AllowNullLiteralAttribute: BuiltinAttribInfo - member attrib_AttributeUsageAttribute: BuiltinAttribInfo - member attrib_AutoOpenAttribute: BuiltinAttribInfo - member attrib_AutoSerializableAttribute: BuiltinAttribInfo - member attrib_CLIEventAttribute: BuiltinAttribInfo - member attrib_CLIMutableAttribute: BuiltinAttribInfo - member attrib_CallerFilePathAttribute: BuiltinAttribInfo - member attrib_CallerLineNumberAttribute: BuiltinAttribInfo - member attrib_CallerMemberNameAttribute: BuiltinAttribInfo - member attrib_ClassAttribute: BuiltinAttribInfo - member attrib_ComImportAttribute: BuiltinAttribInfo option - member attrib_ComVisibleAttribute: BuiltinAttribInfo - member attrib_ComparisonConditionalOnAttribute: BuiltinAttribInfo - member attrib_CompilationArgumentCountsAttribute: BuiltinAttribInfo - member attrib_CompilationMappingAttribute: BuiltinAttribInfo - member attrib_CompilationRepresentationAttribute: BuiltinAttribInfo - member attrib_CompiledNameAttribute: BuiltinAttribInfo - member attrib_CompilerMessageAttribute: BuiltinAttribInfo - member attrib_ComponentModelEditorBrowsableAttribute: BuiltinAttribInfo - member attrib_ConditionalAttribute: BuiltinAttribInfo - member attrib_ContextStaticAttribute: BuiltinAttribInfo option - member attrib_CustomComparisonAttribute: BuiltinAttribInfo - member attrib_CustomEqualityAttribute: BuiltinAttribInfo - member attrib_CustomOperationAttribute: BuiltinAttribInfo - member attrib_DebuggerDisplayAttribute: BuiltinAttribInfo - member attrib_DebuggerTypeProxyAttribute: BuiltinAttribInfo - member attrib_DefaultAugmentationAttribute: BuiltinAttribInfo - member attrib_DefaultMemberAttribute: BuiltinAttribInfo - member attrib_DefaultParameterValueAttribute: BuiltinAttribInfo option - member attrib_DefaultValueAttribute: BuiltinAttribInfo - member attrib_DllImportAttribute: BuiltinAttribInfo option - member attrib_EntryPointAttribute: BuiltinAttribInfo - member attrib_EqualityConditionalOnAttribute: BuiltinAttribInfo - member attrib_ExperimentalAttribute: BuiltinAttribInfo - member attrib_ExtensionAttribute: BuiltinAttribInfo - member attrib_FieldOffsetAttribute: BuiltinAttribInfo - member attrib_FlagsAttribute: BuiltinAttribInfo - member attrib_GeneralizableValueAttribute: BuiltinAttribInfo - member attrib_IDispatchConstantAttribute: BuiltinAttribInfo option - member attrib_IUnknownConstantAttribute: BuiltinAttribInfo option - member attrib_InAttribute: BuiltinAttribInfo - member attrib_InterfaceAttribute: BuiltinAttribInfo - member attrib_InternalsVisibleToAttribute: BuiltinAttribInfo - member attrib_IsByRefLikeAttribute: BuiltinAttribInfo - member attrib_IsReadOnlyAttribute: BuiltinAttribInfo - member attrib_LiteralAttribute: BuiltinAttribInfo - member attrib_MarshalAsAttribute: BuiltinAttribInfo option - member attrib_MeasureAttribute: BuiltinAttribInfo - member attrib_MeasureableAttribute: BuiltinAttribInfo - member attrib_MethodImplAttribute: BuiltinAttribInfo - member attrib_NoComparisonAttribute: BuiltinAttribInfo - member attrib_NoDynamicInvocationAttribute: BuiltinAttribInfo - member attrib_NoEqualityAttribute: BuiltinAttribInfo - member attrib_NonSerializedAttribute: BuiltinAttribInfo option - member attrib_OptionalArgumentAttribute: BuiltinAttribInfo - member attrib_OptionalAttribute: BuiltinAttribInfo option - member attrib_OutAttribute: BuiltinAttribInfo - member attrib_ParamArrayAttribute: BuiltinAttribInfo - member attrib_PreserveSigAttribute: BuiltinAttribInfo option - member attrib_ProjectionParameterAttribute: BuiltinAttribInfo - member attrib_ReferenceEqualityAttribute: BuiltinAttribInfo - member attrib_ReflectedDefinitionAttribute: BuiltinAttribInfo - member attrib_RequireQualifiedAccessAttribute: BuiltinAttribInfo - member attrib_RequiresExplicitTypeArgumentsAttribute: BuiltinAttribInfo - member attrib_SealedAttribute: BuiltinAttribInfo - member attrib_SecurityAttribute: BuiltinAttribInfo option - member attrib_SecurityCriticalAttribute: BuiltinAttribInfo - member attrib_SecuritySafeCriticalAttribute: BuiltinAttribInfo - member attrib_SpecialNameAttribute: BuiltinAttribInfo option - member attrib_StructAttribute: BuiltinAttribInfo - member attrib_StructLayoutAttribute: BuiltinAttribInfo - member attrib_StructuralComparisonAttribute: BuiltinAttribInfo - member attrib_StructuralEqualityAttribute: BuiltinAttribInfo - member attrib_SystemObsolete: BuiltinAttribInfo - member attrib_ThreadStaticAttribute: BuiltinAttribInfo option - member attrib_TypeForwardedToAttribute: BuiltinAttribInfo - member attrib_UnverifiableAttribute: BuiltinAttribInfo - member attrib_VolatileFieldAttribute: BuiltinAttribInfo - member bitwise_and_info: IntrinsicValRef - member bitwise_and_vref: TypedTree.ValRef - member bitwise_or_info: IntrinsicValRef - member bitwise_or_vref: TypedTree.ValRef - member bitwise_shift_left_info: IntrinsicValRef - member bitwise_shift_left_vref: TypedTree.ValRef - member bitwise_shift_right_info: IntrinsicValRef - member bitwise_shift_right_vref: TypedTree.ValRef - member bitwise_unary_not_info: IntrinsicValRef - member bitwise_unary_not_vref: TypedTree.ValRef - member bitwise_xor_info: IntrinsicValRef - member bitwise_xor_vref: TypedTree.ValRef - member bool_tcr: TypedTree.EntityRef - member bool_ty: TypedTree.TType - member box_info: IntrinsicValRef - member byref2_tcr: TypedTree.EntityRef - member byref_tcr: TypedTree.EntityRef - member byrefkind_InOut_tcr: TypedTree.EntityRef - member byrefkind_In_tcr: TypedTree.EntityRef - member byrefkind_Out_tcr: TypedTree.EntityRef - member byte_checked_info: IntrinsicValRef - member byte_operator_info: IntrinsicValRef - member byte_tcr: TypedTree.EntityRef - member byte_ty: TypedTree.TType - member call_with_witnesses_info: IntrinsicValRef - member cast_quotation_info: IntrinsicValRef - member char_operator_info: IntrinsicValRef - member char_tcr: TypedTree.EntityRef - member char_ty: TypedTree.TType - member check_this_info: IntrinsicValRef - member checked_addition_info: IntrinsicValRef - member checked_multiply_info: IntrinsicValRef - member checked_subtraction_info: IntrinsicValRef - member checked_unary_minus_info: IntrinsicValRef - member choice2_tcr: TypedTree.EntityRef - member choice3_tcr: TypedTree.EntityRef - member choice4_tcr: TypedTree.EntityRef - member choice5_tcr: TypedTree.EntityRef - member choice6_tcr: TypedTree.EntityRef - member choice7_tcr: TypedTree.EntityRef - member compare_operator_vref: TypedTree.ValRef - member compilingFslib: bool - member cons_ucref: TypedTree.UnionCaseRef - member create_event_info: IntrinsicValRef - member create_instance_info: IntrinsicValRef - member date_tcr: TypedTree.EntityRef - member decimal_tcr: TypedTree.EntityRef - member decimal_ty: TypedTree.TType - member deserialize_quoted_FSharp_20_plus_info: IntrinsicValRef - member deserialize_quoted_FSharp_40_plus_info: IntrinsicValRef - member directoryToResolveRelativePaths: string - member dispose_info: IntrinsicValRef - member emitDebugInfoInQuotations: bool - member enumOfValue_vref: TypedTree.ValRef - member enum_operator_info: IntrinsicValRef - member enum_vref: TypedTree.ValRef - member equals_nullable_operator_vref: TypedTree.ValRef - member equals_operator_info: IntrinsicValRef - member equals_operator_vref: TypedTree.ValRef - member exn_tcr: TypedTree.EntityRef - member exn_ty: TypedTree.TType - member expr_tcr: TypedTree.EntityRef - member fail_init_info: IntrinsicValRef - member fail_static_init_info: IntrinsicValRef - member failwith_info: IntrinsicValRef - member failwith_vref: TypedTree.ValRef - member failwithf_info: IntrinsicValRef - member failwithf_vref: TypedTree.ValRef - member fastFunc_tcr: TypedTree.EntityRef - member float32_operator_info: IntrinsicValRef - member float32_tcr: TypedTree.EntityRef - member float32_ty: TypedTree.TType - member float_operator_info: IntrinsicValRef - member float_tcr: TypedTree.EntityRef - member float_ty: TypedTree.TType - member format_tcr: TypedTree.EntityRef - member fsharpref_vref: TypedTree.ValRef - member fslibCcu: TypedTree.CcuThunk - member fslib_IDelegateEvent_tcr: TypedTree.EntityRef - member fslib_IEvent2_tcr: TypedTree.EntityRef - member generateWitnesses: bool - member generic_compare_withc_tuple2_vref: TypedTree.ValRef - member generic_compare_withc_tuple3_vref: TypedTree.ValRef - member generic_compare_withc_tuple4_vref: TypedTree.ValRef - member generic_compare_withc_tuple5_vref: TypedTree.ValRef - member generic_comparison_inner_vref: TypedTree.ValRef - member generic_comparison_withc_inner_vref: TypedTree.ValRef - member generic_comparison_withc_outer_info: IntrinsicValRef - member generic_equality_er_inner_vref: TypedTree.ValRef - member generic_equality_er_outer_info: IntrinsicValRef - member generic_equality_per_inner_vref: TypedTree.ValRef - member generic_equality_withc_inner_vref: TypedTree.ValRef - member generic_equality_withc_outer_info: IntrinsicValRef - member generic_equality_withc_outer_vref: TypedTree.ValRef - member generic_equals_withc_tuple2_vref: TypedTree.ValRef - member generic_equals_withc_tuple3_vref: TypedTree.ValRef - member generic_equals_withc_tuple4_vref: TypedTree.ValRef - member generic_equals_withc_tuple5_vref: TypedTree.ValRef - member generic_hash_inner_vref: TypedTree.ValRef - member generic_hash_withc_inner_vref: TypedTree.ValRef - member generic_hash_withc_outer_info: IntrinsicValRef - member generic_hash_withc_tuple2_vref: TypedTree.ValRef - member generic_hash_withc_tuple3_vref: TypedTree.ValRef - member generic_hash_withc_tuple4_vref: TypedTree.ValRef - member generic_hash_withc_tuple5_vref: TypedTree.ValRef - member get_generic_comparer_info: IntrinsicValRef - member get_generic_er_equality_comparer_info: IntrinsicValRef - member get_generic_per_equality_comparer_info: IntrinsicValRef - member getstring_info: IntrinsicValRef - member greater_than_operator: IntrinsicValRef - member greater_than_operator_vref: TypedTree.ValRef - member greater_than_or_equals_operator: IntrinsicValRef - member greater_than_or_equals_operator_vref: TypedTree.ValRef - member hash_info: IntrinsicValRef - member il_arr_tcr_map: TypedTree.EntityRef [] - member ilg: AbstractIL.IL.ILGlobals - member ilsigptr_tcr: TypedTree.EntityRef - member iltyp_AsyncCallback: AbstractIL.IL.ILType - member iltyp_Exception: AbstractIL.IL.ILType - member iltyp_IAsyncResult: AbstractIL.IL.ILType - member iltyp_IComparable: AbstractIL.IL.ILType - member iltyp_Missing: AbstractIL.IL.ILType - member iltyp_RuntimeFieldHandle: AbstractIL.IL.ILType - member iltyp_RuntimeMethodHandle: AbstractIL.IL.ILType - member iltyp_RuntimeTypeHandle: AbstractIL.IL.ILType - member iltyp_SerializationInfo: AbstractIL.IL.ILType option - member iltyp_StreamingContext: AbstractIL.IL.ILType option - member iltyp_TypedReference: AbstractIL.IL.ILType option - member iltyp_ValueType: AbstractIL.IL.ILType - member ilxPubCloEnv: AbstractIL.Extensions.ILX.EraseClosures.cenv - member inref_tcr: TypedTree.EntityRef - member int16_checked_info: IntrinsicValRef - member int16_operator_info: IntrinsicValRef - member int16_tcr: TypedTree.EntityRef - member int16_ty: TypedTree.TType - member int32_checked_info: IntrinsicValRef - member int32_operator_info: IntrinsicValRef - member int32_tcr: TypedTree.EntityRef - member int32_ty: TypedTree.TType - member int64_checked_info: IntrinsicValRef - member int64_operator_info: IntrinsicValRef - member int64_tcr: TypedTree.EntityRef - member int64_ty: TypedTree.TType - member int_checked_info: IntrinsicValRef - member int_operator_info: IntrinsicValRef - member int_tcr: TypedTree.EntityRef - member int_ty: TypedTree.TType - member invalid_arg_info: IntrinsicValRef - member invalid_arg_vref: TypedTree.ValRef - member invalid_op_info: IntrinsicValRef - member invalid_op_vref: TypedTree.ValRef - member isInteractive: bool - member isnotnull_info: IntrinsicValRef - member isnull_info: IntrinsicValRef - member istype_fast_info: IntrinsicValRef - member istype_fast_vref: TypedTree.ValRef - member istype_info: IntrinsicValRef - member istype_vref: TypedTree.ValRef - member - knownFSharpCoreModules: System.Collections.Generic.IDictionary - member - knownIntrinsics: System.Collections.Concurrent.ConcurrentDictionary<(string * - string option * - string * - int), - TypedTree.ValRef> - member langVersion: Features.LanguageVersion - member lazy_create_info: IntrinsicValRef - member lazy_force_info: IntrinsicValRef - member lazy_tcr_canon: TypedTree.EntityRef - member lazy_tcr_nice: TypedTree.EntityRef - member less_than_operator: IntrinsicValRef - member less_than_operator_vref: TypedTree.ValRef - member less_than_or_equals_operator: IntrinsicValRef - member less_than_or_equals_operator_vref: TypedTree.ValRef - member lift_value_info: IntrinsicValRef - member lift_value_with_defn_info: IntrinsicValRef - member lift_value_with_name_info: IntrinsicValRef - member list_tcr_canon: TypedTree.EntityRef - member list_tcr_nice: TypedTree.EntityRef - member map_tcr_canon: TypedTree.EntityRef - member measureinverse_tcr: TypedTree.EntityRef - member measureone_tcr: TypedTree.EntityRef - member measureproduct_tcr: TypedTree.EntityRef - member methodhandleof_info: IntrinsicValRef - member methodhandleof_vref: TypedTree.ValRef - member mk_IComparable_ty: TypedTree.TType - member mk_IStructuralComparable_ty: TypedTree.TType - member mk_IStructuralEquatable_ty: TypedTree.TType - member mlCompatibility: bool - member nameof_vref: TypedTree.ValRef - member nativeint_checked_info: IntrinsicValRef - member nativeint_operator_info: IntrinsicValRef - member nativeint_tcr: TypedTree.EntityRef - member nativeint_ty: TypedTree.TType - member nativeptr_tcr: TypedTree.EntityRef - member nativeptr_tobyref_vref: TypedTree.ValRef - member new_decimal_info: IntrinsicValRef - member new_format_info: IntrinsicValRef - member new_format_vref: TypedTree.ValRef - member new_query_source_info: IntrinsicValRef - member nil_ucref: TypedTree.UnionCaseRef - member not_equals_operator: IntrinsicValRef - member not_equals_operator_vref: TypedTree.ValRef - member null_arg_info: IntrinsicValRef - member null_arg_vref: TypedTree.ValRef - member nullable_equals_nullable_operator_vref: TypedTree.ValRef - member nullable_equals_operator_vref: TypedTree.ValRef - member obj_ty: TypedTree.TType - member option_defaultValue_info: IntrinsicValRef - member option_tcr_canon: TypedTree.EntityRef - member option_tcr_nice: TypedTree.EntityRef - member option_toNullable_info: IntrinsicValRef - member or2_vref: TypedTree.ValRef - member or_vref: TypedTree.ValRef - member outref_tcr: TypedTree.EntityRef - member pathMap: Internal.Utilities.PathMap - member pdecimal_tcr: TypedTree.EntityRef - member pfloat32_tcr: TypedTree.EntityRef - member pfloat_tcr: TypedTree.EntityRef - member pint16_tcr: TypedTree.EntityRef - member pint64_tcr: TypedTree.EntityRef - member pint8_tcr: TypedTree.EntityRef - member pint_tcr: TypedTree.EntityRef - member pnativeint_tcr: TypedTree.EntityRef - member puint16_tcr: TypedTree.EntityRef - member puint64_tcr: TypedTree.EntityRef - member puint8_tcr: TypedTree.EntityRef - member puint_tcr: TypedTree.EntityRef - member punativeint_tcr: TypedTree.EntityRef - member query_builder_tcref: TypedTree.EntityRef - member query_for_vref: TypedTree.ValRef - member query_run_enumerable_vref: TypedTree.ValRef - member query_run_value_vref: TypedTree.ValRef - member query_select_vref: TypedTree.ValRef - member query_source_as_enum_info: IntrinsicValRef - member query_source_vref: TypedTree.ValRef - member query_value_vref: TypedTree.ValRef - member query_where_vref: TypedTree.ValRef - member query_yield_from_vref: TypedTree.ValRef - member query_yield_vref: TypedTree.ValRef - member query_zero_vref: TypedTree.ValRef - member quote_to_linq_lambda_info: IntrinsicValRef - member raise_info: IntrinsicValRef - member raise_vref: TypedTree.ValRef - member range_int32_op_vref: TypedTree.ValRef - member range_op_vref: TypedTree.ValRef - member range_step_op_vref: TypedTree.ValRef - member raw_expr_tcr: TypedTree.EntityRef - member ref_tuple1_tcr: TypedTree.EntityRef - member ref_tuple2_tcr: TypedTree.EntityRef - member ref_tuple3_tcr: TypedTree.EntityRef - member ref_tuple4_tcr: TypedTree.EntityRef - member ref_tuple5_tcr: TypedTree.EntityRef - member ref_tuple6_tcr: TypedTree.EntityRef - member ref_tuple7_tcr: TypedTree.EntityRef - member ref_tuple8_tcr: TypedTree.EntityRef - member refcell_tcr_canon: TypedTree.EntityRef - member refcell_tcr_nice: TypedTree.EntityRef - member reference_equality_inner_vref: TypedTree.ValRef - member reraise_info: IntrinsicValRef - member reraise_vref: TypedTree.ValRef - member sbyte_checked_info: IntrinsicValRef - member sbyte_operator_info: IntrinsicValRef - member sbyte_tcr: TypedTree.EntityRef - member sbyte_ty: TypedTree.TType - member seq_append_info: IntrinsicValRef - member seq_append_vref: TypedTree.ValRef - member seq_base_tcr: TypedTree.EntityRef - member seq_collect_info: IntrinsicValRef - member seq_collect_vref: TypedTree.ValRef - member seq_delay_info: IntrinsicValRef - member seq_delay_vref: TypedTree.ValRef - member seq_empty_info: IntrinsicValRef - member seq_empty_vref: TypedTree.ValRef - member seq_finally_info: IntrinsicValRef - member seq_finally_vref: TypedTree.ValRef - member seq_generated_info: IntrinsicValRef - member seq_generated_vref: TypedTree.ValRef - member seq_info: IntrinsicValRef - member seq_map_info: IntrinsicValRef - member seq_map_vref: TypedTree.ValRef - member seq_of_functions_info: IntrinsicValRef - member seq_of_functions_vref: TypedTree.ValRef - member seq_singleton_info: IntrinsicValRef - member seq_singleton_vref: TypedTree.ValRef - member seq_tcr: TypedTree.EntityRef - member seq_to_array_info: IntrinsicValRef - member seq_to_list_info: IntrinsicValRef - member seq_using_info: IntrinsicValRef - member seq_using_vref: TypedTree.ValRef - member seq_vref: TypedTree.ValRef - member set_tcr_canon: TypedTree.EntityRef - member sizeof_vref: TypedTree.ValRef - member splice_expr_vref: TypedTree.ValRef - member splice_raw_expr_vref: TypedTree.ValRef - member sprintf_info: IntrinsicValRef - member sprintf_vref: TypedTree.ValRef - member string_ty: TypedTree.TType - member struct_tuple1_tcr: TypedTree.EntityRef - member struct_tuple2_tcr: TypedTree.EntityRef - member struct_tuple3_tcr: TypedTree.EntityRef - member struct_tuple4_tcr: TypedTree.EntityRef - member struct_tuple5_tcr: TypedTree.EntityRef - member struct_tuple6_tcr: TypedTree.EntityRef - member struct_tuple7_tcr: TypedTree.EntityRef - member struct_tuple8_tcr: TypedTree.EntityRef - member suppressed_types: TypedTree.EntityRef list - member system_ArgIterator_tcref: TypedTree.EntityRef option - member system_Array_tcref: TypedTree.EntityRef - member system_Array_ty: TypedTree.TType - member system_Bool_tcref: TypedTree.EntityRef - member system_Byte_tcref: TypedTree.EntityRef - member system_Char_tcref: TypedTree.EntityRef - member system_Decimal_tcref: TypedTree.EntityRef - member system_Delegate_ty: TypedTree.TType - member system_Double_tcref: TypedTree.EntityRef - member system_Enum_ty: TypedTree.TType - member system_ExceptionDispatchInfo_ty: TypedTree.TType option - member system_Exception_ty: TypedTree.TType - member system_FormattableStringFactory_tcref: TypedTree.EntityRef - member system_FormattableStringFactory_ty: TypedTree.TType - member system_FormattableString_tcref: TypedTree.EntityRef - member system_FormattableString_ty: TypedTree.TType - member system_GenericIComparable_tcref: TypedTree.EntityRef - member system_GenericIEquatable_tcref: TypedTree.EntityRef - member system_IDisposable_ty: TypedTree.TType - member system_IFormattable_tcref: TypedTree.EntityRef - member system_IFormattable_ty: TypedTree.TType - member system_IndexOutOfRangeException_tcref: TypedTree.EntityRef - member system_Int16_tcref: TypedTree.EntityRef - member system_Int32_tcref: TypedTree.EntityRef - member system_Int32_ty: TypedTree.TType - member system_Int64_tcref: TypedTree.EntityRef - member system_IntPtr_tcref: TypedTree.EntityRef - member system_LinqExpression_tcref: TypedTree.EntityRef - member system_MarshalByRefObject_tcref: TypedTree.EntityRef option - member system_MarshalByRefObject_ty: TypedTree.TType option - member system_MulticastDelegate_ty: TypedTree.TType - member system_Nullable_tcref: TypedTree.EntityRef - member system_Object_tcref: TypedTree.EntityRef - member system_Object_ty: TypedTree.TType - member system_Reflection_MethodInfo_ty: TypedTree.TType - member system_RuntimeArgumentHandle_tcref: TypedTree.EntityRef option - member system_RuntimeHelpers_ty: TypedTree.TType - member system_RuntimeMethodHandle_ty: TypedTree.TType - member system_RuntimeTypeHandle_ty: TypedTree.TType - member system_SByte_tcref: TypedTree.EntityRef - member system_Single_tcref: TypedTree.EntityRef - member system_String_tcref: TypedTree.EntityRef - member system_String_typ: TypedTree.TType - member system_Type_ty: TypedTree.TType - member system_TypedReference_tcref: TypedTree.EntityRef option - member system_UInt16_tcref: TypedTree.EntityRef - member system_UInt32_tcref: TypedTree.EntityRef - member system_UInt64_tcref: TypedTree.EntityRef - member system_UIntPtr_tcref: TypedTree.EntityRef - member system_Value_tcref: TypedTree.EntityRef - member system_Value_ty: TypedTree.TType - member system_Void_tcref: TypedTree.EntityRef - member tcref_IObservable: TypedTree.EntityRef - member tcref_IObserver: TypedTree.EntityRef - member tcref_IQueryable: TypedTree.EntityRef - member tcref_LanguagePrimitives: TypedTree.EntityRef - member tcref_System_Attribute: TypedTree.EntityRef - member tcref_System_Collections_Generic_Dictionary: TypedTree.EntityRef - member - tcref_System_Collections_Generic_ICollection: TypedTree.EntityRef - member - tcref_System_Collections_Generic_IDictionary: TypedTree.EntityRef - member - tcref_System_Collections_Generic_IEnumerable: TypedTree.EntityRef - member - tcref_System_Collections_Generic_IEnumerator: TypedTree.EntityRef - member - tcref_System_Collections_Generic_IEqualityComparer: TypedTree.EntityRef - member tcref_System_Collections_Generic_IList: TypedTree.EntityRef - member - tcref_System_Collections_Generic_IReadOnlyCollection: TypedTree.EntityRef - member - tcref_System_Collections_Generic_IReadOnlyList: TypedTree.EntityRef - member tcref_System_Collections_Generic_List: TypedTree.EntityRef - member tcref_System_Collections_IComparer: TypedTree.EntityRef - member tcref_System_Collections_IEnumerable: TypedTree.EntityRef - member tcref_System_Collections_IEqualityComparer: TypedTree.EntityRef - member tcref_System_IComparable: TypedTree.EntityRef - member tcref_System_IDisposable: TypedTree.EntityRef - member tcref_System_IStructuralComparable: TypedTree.EntityRef - member tcref_System_IStructuralEquatable: TypedTree.EntityRef - member typedefof_info: IntrinsicValRef - member typedefof_vref: TypedTree.ValRef - member typeof_info: IntrinsicValRef - member typeof_vref: TypedTree.ValRef - member uint16_checked_info: IntrinsicValRef - member uint16_operator_info: IntrinsicValRef - member uint16_tcr: TypedTree.EntityRef - member uint16_ty: TypedTree.TType - member uint32_checked_info: IntrinsicValRef - member uint32_operator_info: IntrinsicValRef - member uint32_tcr: TypedTree.EntityRef - member uint32_ty: TypedTree.TType - member uint64_checked_info: IntrinsicValRef - member uint64_operator_info: IntrinsicValRef - member uint64_tcr: TypedTree.EntityRef - member uint64_ty: TypedTree.TType - member unativeint_checked_info: IntrinsicValRef - member unativeint_operator_info: IntrinsicValRef - member unativeint_tcr: TypedTree.EntityRef - member unativeint_ty: TypedTree.TType - member unbox_fast_info: IntrinsicValRef - member unbox_fast_vref: TypedTree.ValRef - member unbox_info: IntrinsicValRef - member unbox_vref: TypedTree.ValRef - member unchecked_addition_info: IntrinsicValRef - member unchecked_addition_vref: TypedTree.ValRef - member unchecked_defaultof_info: IntrinsicValRef - member unchecked_defaultof_vref: TypedTree.ValRef - member unchecked_division_info: IntrinsicValRef - member unchecked_modulus_info: IntrinsicValRef - member unchecked_multiply_info: IntrinsicValRef - member unchecked_multiply_vref: TypedTree.ValRef - member unchecked_subtraction_info: IntrinsicValRef - member unchecked_subtraction_vref: TypedTree.ValRef - member unchecked_unary_minus_info: IntrinsicValRef - member unchecked_unary_minus_vref: TypedTree.ValRef - member unchecked_unary_not_info: IntrinsicValRef - member unchecked_unary_not_vref: TypedTree.ValRef - member unchecked_unary_plus_info: IntrinsicValRef - member unchecked_unary_plus_vref: TypedTree.ValRef - member unit_tcr_canon: TypedTree.EntityRef - member unit_tcr_nice: TypedTree.EntityRef - member unit_ty: TypedTree.TType - member voidptr_tcr: TypedTree.EntityRef - - val mutable global_g: TcGlobals option - - -namespace FSharp.Compiler - module internal TypedTreeOps = - [] - type TyparMap<'T> = - | TPMap of TypedTree.StampMap<'T> - with - member Add: TypedTree.Typar * 'T -> TyparMap<'T> - member ContainsKey: TypedTree.Typar -> bool - member TryFind: TypedTree.Typar -> 'T option - member Item: TypedTree.Typar -> 'T with get - static member Empty: TyparMap<'T> - - [] - type TyconRefMap<'T> = - - new: imap:TypedTree.StampMap<'T> -> TyconRefMap<'T> - static member OfList: (TypedTree.TyconRef * 'T) list -> TyconRefMap<'T> - member Add: TypedTree.TyconRef -> 'T -> TyconRefMap<'T> - member ContainsKey: TypedTree.TyconRef -> bool - member Remove: TypedTree.TyconRef -> TyconRefMap<'T> - member TryFind: TypedTree.TyconRef -> 'T option - member IsEmpty: bool - member Item: TypedTree.TyconRef -> 'T with get - static member Empty: TyconRefMap<'T> - - [] - type ValMap<'T> = - - new: imap:TypedTree.StampMap<'T> -> ValMap<'T> - static member OfList: (TypedTree.Val * 'T) list -> ValMap<'T> - member Add: TypedTree.Val -> 'T -> ValMap<'T> - member ContainsVal: TypedTree.Val -> bool - member Remove: TypedTree.Val -> ValMap<'T> - member TryFind: TypedTree.Val -> 'T option - member Contents: TypedTree.StampMap<'T> - member IsEmpty: bool - member Item: TypedTree.Val -> 'T with get - static member Empty: ValMap<'T> - - type TyparInst = (TypedTree.Typar * TypedTree.TType) list - type TyconRefRemap = TyconRefMap - type ValRemap = ValMap - val emptyTyconRefRemap: TyconRefRemap - val emptyTyparInst: TyparInst - [] - type Remap = - { tpinst: TyparInst - valRemap: ValRemap - tyconRefRemap: TyconRefRemap - removeTraitSolutions: bool } - with - static member Empty: Remap - - val emptyRemap: Remap - val addTyconRefRemap: - TypedTree.TyconRef -> TypedTree.TyconRef -> Remap -> Remap - val isRemapEmpty: remap:Remap -> bool - val instTyparRef: - tpinst:(TypedTree.Typar * 'a) list -> ty:'a -> tp:TypedTree.Typar -> 'a - val instMeasureTyparRef: - tpinst:(TypedTree.Typar * TypedTree.TType) list -> - unt:TypedTree.Measure -> tp:TypedTree.Typar -> TypedTree.Measure - val remapTyconRef: - TyconRefMap -> - TypedTree.TyconRef -> TypedTree.TyconRef - val remapUnionCaseRef: - TyconRefMap -> - TypedTree.UnionCaseRef -> TypedTree.UnionCaseRef - val remapRecdFieldRef: - TyconRefMap -> - TypedTree.RecdFieldRef -> TypedTree.RecdFieldRef - val mkTyparInst: TypedTree.Typars -> TypedTree.TType list -> TyparInst - val generalizeTypar: tp:TypedTree.Typar -> TypedTree.TType - val generalizeTypars: TypedTree.Typar list -> TypedTree.TType list - val remapTypeAux: tyenv:Remap -> ty:TypedTree.TType -> TypedTree.TType - val remapMeasureAux: - tyenv:Remap -> unt:TypedTree.Measure -> TypedTree.Measure - val remapTupInfoAux: - _tyenv:Remap -> unt:TypedTree.TupInfo -> TypedTree.TupInfo - val remapTypesAux: - tyenv:Remap -> types:TypedTree.TypeInst -> TypedTree.TypeInst - val remapTyparConstraintsAux: - tyenv:Remap -> - cs:TypedTree.TyparConstraint list -> TypedTree.TyparConstraint list - val remapTraitWitnessInfo: - tyenv:Remap -> TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo - val remapTraitInfo: - tyenv:Remap -> - TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo - val bindTypars: - tps:'a list -> tyargs:'b list -> tpinst:('a * 'b) list -> ('a * 'b) list - val copyAndRemapAndBindTyparsFull: - remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> - tyenv:Remap -> tps:TypedTree.Typar list -> TypedTree.Typar list * Remap - val copyAndRemapAndBindTypars: - tyenv:Remap -> tps:TypedTree.Typars -> TypedTree.Typars * Remap - val remapValLinkage: - tyenv:Remap -> - vlink:TypedTree.ValLinkageFullKey -> TypedTree.ValLinkageFullKey - val remapNonLocalValRef: - tyenv:Remap -> - nlvref:TypedTree.NonLocalValOrMemberRef -> - TypedTree.NonLocalValOrMemberRef - val remapValRef: Remap -> TypedTree.ValRef -> TypedTree.ValRef - val remapType: tyenv:Remap -> x:TypedTree.TType -> TypedTree.TType - val remapTypes: tyenv:Remap -> x:TypedTree.TypeInst -> TypedTree.TypeInst - val remapTypeFull: - remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> - tyenv:Remap -> ty:TypedTree.TType -> TypedTree.TType - val remapParam: tyenv:Remap -> TypedTree.SlotParam -> TypedTree.SlotParam - val remapSlotSig: - remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> - tyenv:Remap -> TypedTree.SlotSig -> TypedTree.SlotSig - val mkInstRemap: tpinst:TyparInst -> Remap - val instType: - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.TType -> TypedTree.TType - val instTypes: - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.TypeInst -> TypedTree.TypeInst - val instTrait: - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo - val instTyparConstraints: - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.TyparConstraint list -> TypedTree.TyparConstraint list - val instSlotSig: TyparInst -> TypedTree.SlotSig -> TypedTree.SlotSig - val copySlotSig: TypedTree.SlotSig -> TypedTree.SlotSig - val mkTyparToTyparRenaming: - TypedTree.Typars -> - TypedTree.Typar list -> TyparInst * TypedTree.TType list - val mkTyconInst: - tycon:TypedTree.Tycon -> tinst:TypedTree.TType list -> TyparInst - val mkTyconRefInst: TypedTree.TyconRef -> TypedTree.TType list -> TyparInst - val tyconRefEq: - TcGlobals.TcGlobals -> TypedTree.EntityRef -> TypedTree.EntityRef -> bool - val valRefEq: - TcGlobals.TcGlobals -> TypedTree.ValRef -> TypedTree.ValRef -> bool - val reduceTyconRefAbbrevMeasureable: - TypedTree.TyconRef -> TypedTree.Measure - val stripUnitEqnsFromMeasureAux: - canShortcut:bool -> unt:TypedTree.Measure -> TypedTree.Measure - val stripUnitEqnsFromMeasure: m:TypedTree.Measure -> TypedTree.Measure - val MeasureExprConExponent: - TcGlobals.TcGlobals -> - bool -> TypedTree.EntityRef -> TypedTree.Measure -> Rational.Rational - val MeasureConExponentAfterRemapping: - g:TcGlobals.TcGlobals -> - r:(TypedTree.TyconRef -> TypedTree.EntityRef) -> - ucref:TypedTree.EntityRef -> - unt:TypedTree.Measure -> Rational.Rational - val MeasureVarExponent: - TypedTree.Typar -> TypedTree.Measure -> Rational.Rational - val ListMeasureVarOccs: unt:TypedTree.Measure -> TypedTree.Typar list - val ListMeasureVarOccsWithNonZeroExponents: - TypedTree.Measure -> (TypedTree.Typar * Rational.Rational) list - val ListMeasureConOccsWithNonZeroExponents: - TcGlobals.TcGlobals -> - bool -> - TypedTree.Measure -> (TypedTree.EntityRef * Rational.Rational) list - val ListMeasureConOccsAfterRemapping: - g:TcGlobals.TcGlobals -> - r:(TypedTree.TyconRef -> TypedTree.EntityRef) -> - unt:TypedTree.Measure -> TypedTree.EntityRef list - val MeasurePower: TypedTree.Measure -> int -> TypedTree.Measure - val MeasureProdOpt: - m1:TypedTree.Measure -> m2:TypedTree.Measure -> TypedTree.Measure - val ProdMeasures: TypedTree.Measure list -> TypedTree.Measure - val isDimensionless: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val destUnitParMeasure: - g:TcGlobals.TcGlobals -> unt:TypedTree.Measure -> TypedTree.Typar - val isUnitParMeasure: - g:TcGlobals.TcGlobals -> unt:TypedTree.Measure -> bool - val normalizeMeasure: - TcGlobals.TcGlobals -> TypedTree.Measure -> TypedTree.Measure - val tryNormalizeMeasureInType: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkNativePtrTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkInByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkOutByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkByrefTyWithFlag: - g:TcGlobals.TcGlobals -> - readonly:bool -> ty:TypedTree.TType -> TypedTree.TType - val mkByref2Ty: - g:TcGlobals.TcGlobals -> - ty1:TypedTree.TType -> ty2:TypedTree.TType -> TypedTree.TType - val mkVoidPtrTy: TcGlobals.TcGlobals -> TypedTree.TType - val mkByrefTyWithInference: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType -> TypedTree.TType - val mkArrayTy: - TcGlobals.TcGlobals -> - int -> TypedTree.TType -> Range.range -> TypedTree.TType - val maxTuple: int - val goodTupleFields: int - val isCompiledTupleTyconRef: - TcGlobals.TcGlobals -> TypedTree.EntityRef -> bool - val mkCompiledTupleTyconRef: - TcGlobals.TcGlobals -> bool -> int -> TypedTree.EntityRef - val mkCompiledTupleTy: - TcGlobals.TcGlobals -> bool -> TypedTree.TType list -> TypedTree.TType - val mkOuterCompiledTupleTy: - g:TcGlobals.TcGlobals -> - isStruct:bool -> tupElemTys:TypedTree.TType list -> TypedTree.TType - val applyTyconAbbrev: - abbrevTy:TypedTree.TType -> - tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType - val reduceTyconAbbrev: - tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType - val reduceTyconRefAbbrev: - TypedTree.TyconRef -> TypedTree.TType list -> TypedTree.TType - val reduceTyconMeasureableOrProvided: - g:TcGlobals.TcGlobals -> - tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType - val reduceTyconRefMeasureableOrProvided: - TcGlobals.TcGlobals -> - TypedTree.TyconRef -> TypedTree.TType list -> TypedTree.TType - val stripTyEqnsA: - TcGlobals.TcGlobals -> bool -> TypedTree.TType -> TypedTree.TType - val stripTyEqns: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val evalTupInfoIsStruct: TypedTree.TupInfo -> bool - val evalAnonInfoIsStruct: TypedTree.AnonRecdTypeInfo -> bool - val stripTyEqnsAndErase: - eraseFuncAndTuple:bool -> - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val stripTyEqnsAndMeasureEqns: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - type Erasure = - | EraseAll - | EraseMeasures - | EraseNone - val stripTyEqnsWrtErasure: - Erasure -> TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val stripExnEqns: TypedTree.TyconRef -> TypedTree.Entity - val primDestForallTy: - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> TypedTree.Typars * TypedTree.TType - val destFunTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType * TypedTree.TType - val destAnyTupleTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TupInfo * TypedTree.TTypes - val destRefTupleTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes - val destStructTupleTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes - val destTyparTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar - val destAnyParTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar - val destMeasureTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Measure - val isFunTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isForallTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isAnyTupleTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isRefTupleTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isStructTupleTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isAnonRecdTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isStructAnonRecdTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isUnionTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isReprHiddenTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isFSharpObjModelTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isRecdTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isFSharpStructOrEnumTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isFSharpEnumTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isTyparTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isAnyParTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isMeasureTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isProvenUnionCaseTy: TypedTree.TType -> bool - val mkAppTy: TypedTree.TyconRef -> TypedTree.TypeInst -> TypedTree.TType - val mkProvenUnionCaseTy: - TypedTree.UnionCaseRef -> TypedTree.TypeInst -> TypedTree.TType - val isAppTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val tryAppTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> (TypedTree.TyconRef * TypedTree.TypeInst) voption - val destAppTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TyconRef * TypedTree.TypeInst - val tcrefOfAppTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TyconRef - val argsOfAppTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TypeInst - val tryDestTyparTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar voption - val tryDestFunTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> (TypedTree.TType * TypedTree.TType) voption - val tryTcrefOfAppTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TyconRef voption - val tryDestAnonRecdTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> - (TypedTree.AnonRecdTypeInfo * TypedTree.TType list) voption - val tryAnyParTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar voption - val tryAnyParTyOption: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar option - val ( |AppTy|_| ): - TcGlobals.TcGlobals -> - TypedTree.TType -> (TypedTree.TyconRef * TypedTree.TypeInst) option - val ( |RefTupleTy|_| ): - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TTypes option - val ( |FunTy|_| ): - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> (TypedTree.TType * TypedTree.TType) option - val tryNiceEntityRefOfTy: TypedTree.TType -> TypedTree.TyconRef voption - val tryNiceEntityRefOfTyOption: - TypedTree.TType -> TypedTree.TyconRef option - val mkInstForAppTy: TcGlobals.TcGlobals -> TypedTree.TType -> TyparInst - val domainOfFunTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val rangeOfFunTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val convertToTypeWithMetadataIfPossible: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val stripMeasuresFromTType: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - [] - type TypeEquivEnv = - { EquivTypars: TyparMap - EquivTycons: TyconRefRemap } - with - static member - FromEquivTypars: TypedTree.Typar list -> - TypedTree.Typar list -> TypeEquivEnv - static member - FromTyparInst: (TypedTree.Typar * TypedTree.TType) list -> - TypeEquivEnv - member - BindEquivTypars: TypedTree.Typar list -> - TypedTree.Typar list -> TypeEquivEnv - member - BindTyparsToTypes: tps1:TypedTree.Typar list -> - tys2:TypedTree.TType list -> TypeEquivEnv - static member Empty: TypeEquivEnv - - val typeEquivEnvEmpty: TypeEquivEnv - val traitsAEquivAux: - Erasure -> - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TraitConstraintInfo -> - TypedTree.TraitConstraintInfo -> bool - val traitKeysAEquivAux: - Erasure -> - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo -> bool - val returnTypesAEquivAux: - Erasure -> - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TType option -> TypedTree.TType option -> bool - val typarConstraintsAEquivAux: - Erasure -> - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TyparConstraint -> TypedTree.TyparConstraint -> bool - val typarConstraintSetsAEquivAux: - erasureFlag:Erasure -> - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - tp1:TypedTree.Typar -> tp2:TypedTree.Typar -> bool - val typarsAEquivAux: - erasureFlag:Erasure -> - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - tps1:TypedTree.Typar list -> tps2:TypedTree.Typar list -> bool - val tcrefAEquiv: - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.EntityRef -> TypedTree.EntityRef -> bool - val typeAEquivAux: - Erasure -> - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.TType -> TypedTree.TType -> bool - val anonInfoEquiv: - TypedTree.AnonRecdTypeInfo -> TypedTree.AnonRecdTypeInfo -> bool - val structnessAEquiv: - un1:TypedTree.TupInfo -> un2:TypedTree.TupInfo -> bool - val measureAEquiv: - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - un1:TypedTree.Measure -> un2:TypedTree.Measure -> bool - val typesAEquivAux: - erasureFlag:Erasure -> - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - l1:TypedTree.TypeInst -> l2:TypedTree.TypeInst -> bool - val typeEquivAux: - Erasure -> - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType -> bool - val typeAEquiv: - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.TType -> TypedTree.TType -> bool - val typeEquiv: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType -> bool - val traitsAEquiv: - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo -> bool - val traitKeysAEquiv: - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo -> bool - val typarConstraintsAEquiv: - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TyparConstraint -> TypedTree.TyparConstraint -> bool - val typarsAEquiv: - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.Typar list -> TypedTree.Typar list -> bool - val returnTypesAEquiv: - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.TType option -> TypedTree.TType option -> bool - val measureEquiv: - TcGlobals.TcGlobals -> TypedTree.Measure -> TypedTree.Measure -> bool - val getMeasureOfType: - TcGlobals.TcGlobals -> - TypedTree.TType -> (TypedTree.TyconRef * TypedTree.Measure) option - val isErasedType: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val getErasedTypes: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType list - val valOrder: System.Collections.Generic.IComparer - val tyconOrder: System.Collections.Generic.IComparer - val recdFieldRefOrder: - System.Collections.Generic.IComparer - val unionCaseRefOrder: - System.Collections.Generic.IComparer - val mkFunTy: TypedTree.TType -> TypedTree.TType -> TypedTree.TType - val ( --> ): TypedTree.TType -> TypedTree.TType -> TypedTree.TType - val mkForallTy: d:TypedTree.Typars -> r:TypedTree.TType -> TypedTree.TType - val mkForallTyIfNeeded: - TypedTree.Typar list -> TypedTree.TType -> TypedTree.TType - val ( +-> ): TypedTree.Typar list -> TypedTree.TType -> TypedTree.TType - val mkIteratedFunTy: - TypedTree.TType list -> TypedTree.TType -> TypedTree.TType - val mkLambdaArgTy: - m:Range.range -> tys:TypedTree.TType list -> TypedTree.TType - val typeOfLambdaArg: Range.range -> TypedTree.Val list -> TypedTree.TType - val mkMultiLambdaTy: - Range.range -> TypedTree.Val list -> TypedTree.TType -> TypedTree.TType - val mkLambdaTy: - TypedTree.Typar list -> - TypedTree.TType list -> TypedTree.TType -> TypedTree.TType - val ensureCcuHasModuleOrNamespaceAtPath: - TypedTree.CcuThunk -> - SyntaxTree.Ident list -> - TypedTree.CompilationPath -> XmlDoc.XmlDoc -> unit - val stripExpr: TypedTree.Expr -> TypedTree.Expr - val mkCase: - TypedTree.DecisionTreeTest * TypedTree.DecisionTree -> - TypedTree.DecisionTreeCase - val isRefTupleExpr: TypedTree.Expr -> bool - val tryDestRefTupleExpr: TypedTree.Expr -> TypedTree.Exprs - val rangeOfExpr: x:TypedTree.Expr -> Range.range - type Expr with - member Range: Range.range - val primMkMatch: - SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * - TypedTree.DecisionTreeTarget array * Range.range * TypedTree.TType -> - TypedTree.Expr - type MatchBuilder = - - new: SyntaxTree.DebugPointForBinding * Range.range -> MatchBuilder - member - AddResultTarget: TypedTree.Expr * SyntaxTree.DebugPointForTarget -> - TypedTree.DecisionTree - member AddTarget: TypedTree.DecisionTreeTarget -> int - member - Close: TypedTree.DecisionTree * Range.range * TypedTree.TType -> - TypedTree.Expr - member CloseTargets: unit -> TypedTree.DecisionTreeTarget list - - val mkBoolSwitch: - Range.range -> - TypedTree.Expr -> - TypedTree.DecisionTree -> - TypedTree.DecisionTree -> TypedTree.DecisionTree - val primMkCond: - SyntaxTree.DebugPointForBinding -> - SyntaxTree.DebugPointForTarget -> - SyntaxTree.DebugPointForTarget -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCond: - SyntaxTree.DebugPointForBinding -> - SyntaxTree.DebugPointForTarget -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val exprForValRef: Range.range -> TypedTree.ValRef -> TypedTree.Expr - val exprForVal: Range.range -> TypedTree.Val -> TypedTree.Expr - val mkLocalAux: - m:Range.range -> - s:string -> - ty:TypedTree.TType -> - mut:TypedTree.ValMutability -> - compgen:bool -> TypedTree.Val * TypedTree.Expr - val mkLocal: - Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val mkCompGenLocal: - Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val mkMutableCompGenLocal: - Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val mkMultiLambda: - Range.range -> - TypedTree.Val list -> TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val rebuildLambda: - Range.range -> - TypedTree.Val option -> - TypedTree.Val option -> - TypedTree.Val list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkLambda: - Range.range -> - TypedTree.Val -> TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkTypeLambda: - Range.range -> - TypedTree.Typar list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkTypeChoose: - Range.range -> TypedTree.Typar list -> TypedTree.Expr -> TypedTree.Expr - val mkObjExpr: - TypedTree.TType * TypedTree.Val option * TypedTree.Expr * - TypedTree.ObjExprMethod list * - (TypedTree.TType * TypedTree.ObjExprMethod list) list * Range.range -> - TypedTree.Expr - val mkLambdas: - Range.range -> - TypedTree.Typar list -> - TypedTree.Val list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkMultiLambdasCore: - Range.range -> - TypedTree.Val list list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr * TypedTree.TType - val mkMultiLambdas: - Range.range -> - TypedTree.Typar list -> - TypedTree.Val list list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkMemberLambdas: - Range.range -> - TypedTree.Typar list -> - TypedTree.Val option -> - TypedTree.Val option -> - TypedTree.Val list list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkMultiLambdaBind: - TypedTree.Val -> - SyntaxTree.DebugPointForBinding -> - Range.range -> - TypedTree.Typar list -> - TypedTree.Val list list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Binding - val mkBind: - SyntaxTree.DebugPointForBinding -> - TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding - val mkLetBind: - Range.range -> TypedTree.Binding -> TypedTree.Expr -> TypedTree.Expr - val mkLetsBind: - Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr - val mkLetsFromBindings: - Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr - val mkLet: - SyntaxTree.DebugPointForBinding -> - Range.range -> - TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCompGenBind: TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding - val mkCompGenBinds: - TypedTree.Val list -> TypedTree.Expr list -> TypedTree.Binding list - val mkCompGenLet: - Range.range -> - TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCompGenLets: - m:Range.range -> - vs:TypedTree.Val list -> - xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr - val mkCompGenLetsFromBindings: - m:Range.range -> - vs:TypedTree.Val list -> - xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr - val mkInvisibleBind: TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding - val mkInvisibleBinds: - TypedTree.Val list -> TypedTree.Expr list -> TypedTree.Binding list - val mkInvisibleLet: - Range.range -> - TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkInvisibleLets: - m:Range.range -> - vs:TypedTree.Val list -> - xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr - val mkInvisibleLetsFromBindings: - m:Range.range -> - vs:TypedTree.Val list -> - xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr - val mkLetRecBinds: - Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr - val NormalizeDeclaredTyparsForEquiRecursiveInference: - TcGlobals.TcGlobals -> TypedTree.Typar list -> TypedTree.Typar list - type TypeScheme = | TypeScheme of TypedTree.Typars * TypedTree.TType - val mkGenericBindRhs: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Typar list -> TypeScheme -> TypedTree.Expr -> TypedTree.Expr - val isBeingGeneralized: TypedTree.Typar -> TypeScheme -> bool - val mkLazyAnd: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkLazyOr: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCoerceExpr: - TypedTree.Expr * TypedTree.TType * Range.range * TypedTree.TType -> - TypedTree.Expr - val mkAsmExpr: - AbstractIL.IL.ILInstr list * TypedTree.TypeInst * TypedTree.Exprs * - TypedTree.TTypes * Range.range -> TypedTree.Expr - val mkUnionCaseExpr: - TypedTree.UnionCaseRef * TypedTree.TypeInst * TypedTree.Exprs * - Range.range -> TypedTree.Expr - val mkExnExpr: - TypedTree.TyconRef * TypedTree.Exprs * Range.range -> TypedTree.Expr - val mkTupleFieldGetViaExprAddr: - tupInfo:TypedTree.TupInfo * e:TypedTree.Expr * tinst:TypedTree.TypeInst * - i:int * m:Range.range -> TypedTree.Expr - val mkAnonRecdFieldGetViaExprAddr: - TypedTree.AnonRecdTypeInfo * TypedTree.Expr * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkRecdFieldGetViaExprAddr: - TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> - TypedTree.Expr - val mkRecdFieldGetAddrViaExprAddr: - readonly:bool * TypedTree.Expr * TypedTree.RecdFieldRef * - TypedTree.TypeInst * Range.range -> TypedTree.Expr - val mkStaticRecdFieldGetAddr: - readonly:bool * TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> - TypedTree.Expr - val mkStaticRecdFieldGet: - TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> - TypedTree.Expr - val mkStaticRecdFieldSet: - TypedTree.RecdFieldRef * TypedTree.TypeInst * TypedTree.Expr * Range.range -> - TypedTree.Expr - val mkArrayElemAddress: - TcGlobals.TcGlobals -> - readonly:bool * AbstractIL.IL.ILReadonly * bool * - AbstractIL.IL.ILArrayShape * TypedTree.TType * TypedTree.Exprs * - Range.range -> TypedTree.Expr - val mkRecdFieldSetViaExprAddr: - TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * - TypedTree.Expr * Range.range -> TypedTree.Expr - val mkUnionCaseTagGetViaExprAddr: - TypedTree.Expr * TypedTree.TyconRef * TypedTree.TypeInst * Range.range -> - TypedTree.Expr - val mkUnionCaseProof: - TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * Range.range -> - TypedTree.Expr - val mkUnionCaseFieldGetProvenViaExprAddr: - TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkUnionCaseFieldGetAddrProvenViaExprAddr: - readonly:bool * TypedTree.Expr * TypedTree.UnionCaseRef * - TypedTree.TypeInst * int * Range.range -> TypedTree.Expr - val mkUnionCaseFieldGetUnprovenViaExprAddr: - TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkUnionCaseFieldSet: - TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * - TypedTree.Expr * Range.range -> TypedTree.Expr - val mkExnCaseFieldGet: - TypedTree.Expr * TypedTree.TyconRef * int * Range.range -> TypedTree.Expr - val mkExnCaseFieldSet: - TypedTree.Expr * TypedTree.TyconRef * int * TypedTree.Expr * Range.range -> - TypedTree.Expr - val mkDummyLambda: - g:TcGlobals.TcGlobals -> - e:TypedTree.Expr * ety:TypedTree.TType -> TypedTree.Expr - val mkWhile: - TcGlobals.TcGlobals -> - SyntaxTree.DebugPointAtWhile * TypedTree.SpecialWhileLoopMarker * - TypedTree.Expr * TypedTree.Expr * Range.range -> TypedTree.Expr - val mkFor: - TcGlobals.TcGlobals -> - SyntaxTree.DebugPointAtFor * TypedTree.Val * TypedTree.Expr * - TypedTree.ForLoopStyle * TypedTree.Expr * TypedTree.Expr * Range.range -> - TypedTree.Expr - val mkTryWith: - TcGlobals.TcGlobals -> - TypedTree.Expr * TypedTree.Val * TypedTree.Expr * TypedTree.Val * - TypedTree.Expr * Range.range * TypedTree.TType * - SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith -> - TypedTree.Expr - val mkTryFinally: - TcGlobals.TcGlobals -> - TypedTree.Expr * TypedTree.Expr * Range.range * TypedTree.TType * - SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally -> - TypedTree.Expr - val mkDefault: Range.range * TypedTree.TType -> TypedTree.Expr - val mkValSet: - Range.range -> TypedTree.ValRef -> TypedTree.Expr -> TypedTree.Expr - val mkAddrSet: - Range.range -> TypedTree.ValRef -> TypedTree.Expr -> TypedTree.Expr - val mkAddrGet: Range.range -> TypedTree.ValRef -> TypedTree.Expr - val mkValAddr: - Range.range -> readonly:bool -> TypedTree.ValRef -> TypedTree.Expr - [] - type ValHash<'T> = - | ValHash of System.Collections.Generic.Dictionary - with - static member Create: unit -> ValHash<'T> - member Add: TypedTree.Val * 'T -> unit - member TryFind: TypedTree.Val -> 'T option - member Values: seq<'T> - - [] - type ValMultiMap<'T> = - - new: contents:TypedTree.StampMap<'T list> -> ValMultiMap<'T> - member Add: TypedTree.Val * 'T -> ValMultiMap<'T> - member ContainsKey: TypedTree.Val -> bool - member Find: TypedTree.Val -> 'T list - member Remove: TypedTree.Val -> ValMultiMap<'T> - member Contents: TypedTree.StampMap<'T list> - static member Empty: ValMultiMap<'T> - - [] - type TyconRefMultiMap<'T> = - - new: contents:TyconRefMap<'T list> -> TyconRefMultiMap<'T> - static member - OfList: (TypedTree.TyconRef * 'T) list -> TyconRefMultiMap<'T> - member Add: TypedTree.TyconRef * 'T -> TyconRefMultiMap<'T> - member Find: TypedTree.TyconRef -> 'T list - static member Empty: TyconRefMultiMap<'T> - - val tryRescopeEntity: - TypedTree.CcuThunk -> TypedTree.Entity -> ValueOption - val tryRescopeVal: - TypedTree.CcuThunk -> - Remap -> TypedTree.Val -> ValueOption - val actualTyOfRecdField: - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.RecdField -> TypedTree.TType - val actualTysOfRecdFields: - inst:(TypedTree.Typar * TypedTree.TType) list -> - rfields:TypedTree.RecdField list -> TypedTree.TType list - val actualTysOfInstanceRecdFields: - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.TyconRef -> TypedTree.TType list - val actualTysOfUnionCaseFields: - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.UnionCaseRef -> TypedTree.TType list - val actualResultTyOfUnionCase: - TypedTree.TType list -> TypedTree.UnionCaseRef -> TypedTree.TType - val recdFieldsOfExnDefRef: TypedTree.TyconRef -> TypedTree.RecdField list - val recdFieldOfExnDefRefByIdx: - x:TypedTree.TyconRef -> n:int -> TypedTree.RecdField - val recdFieldTysOfExnDefRef: TypedTree.TyconRef -> TypedTree.TType list - val recdFieldTyOfExnDefRefByIdx: - x:TypedTree.TyconRef -> j:int -> TypedTree.TType - val actualTyOfRecdFieldForTycon: - TypedTree.Tycon -> - TypedTree.TType list -> TypedTree.RecdField -> TypedTree.TType - val actualTyOfRecdFieldRef: - TypedTree.RecdFieldRef -> TypedTree.TType list -> TypedTree.TType - val actualTyOfUnionFieldRef: - fref:TypedTree.UnionCaseRef -> - n:int -> tinst:TypedTree.TType list -> TypedTree.TType - val destForallTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.Typar list * TypedTree.TType - val tryDestForallTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.Typar list * TypedTree.TType - val stripFunTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType list * TypedTree.TType - val applyForallTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType list -> TypedTree.TType - val reduceIteratedFunTy: - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> args:'a list -> TypedTree.TType - val applyTyArgs: - g:TcGlobals.TcGlobals -> - functy:TypedTree.TType -> tyargs:TypedTree.TType list -> TypedTree.TType - val applyTys: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType list * 'T list -> TypedTree.TType - val formalApplyTys: - g:TcGlobals.TcGlobals -> - functy:TypedTree.TType -> - tyargs:'a list * args:'b list -> TypedTree.TType - val stripFunTyN: - TcGlobals.TcGlobals -> - int -> TypedTree.TType -> TypedTree.TType list * TypedTree.TType - val tryDestAnyTupleTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TupInfo * TypedTree.TTypes - val tryDestRefTupleTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes - type UncurriedArgInfos = (TypedTree.TType * TypedTree.ArgReprInfo) list - type CurriedArgInfos = (TypedTree.TType * TypedTree.ArgReprInfo) list list - type TraitWitnessInfos = TypedTree.TraitWitnessInfo list - val GetTopTauTypeInFSharpForm: - TcGlobals.TcGlobals -> - TypedTree.ArgReprInfo list list -> - TypedTree.TType -> - Range.range -> - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType - val destTopForallTy: - TcGlobals.TcGlobals -> - TypedTree.ValReprInfo -> - TypedTree.TType -> TypedTree.Typar list * TypedTree.TType - val GetTopValTypeInFSharpForm: - TcGlobals.TcGlobals -> - TypedTree.ValReprInfo -> - TypedTree.TType -> - Range.range -> - TypedTree.Typar list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType * TypedTree.ArgReprInfo - val IsCompiledAsStaticProperty: - TcGlobals.TcGlobals -> TypedTree.Val -> bool - val IsCompiledAsStaticPropertyWithField: - TcGlobals.TcGlobals -> TypedTree.Val -> bool - val isArrayTyconRef: TcGlobals.TcGlobals -> TypedTree.EntityRef -> bool - val rankOfArrayTyconRef: TcGlobals.TcGlobals -> TypedTree.EntityRef -> int - val destArrayTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val destListTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val tyconRefEqOpt: - g:TcGlobals.TcGlobals -> - tcOpt:TypedTree.EntityRef option -> tc:TypedTree.EntityRef -> bool - val isStringTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isListTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isArrayTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isArray1DTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isUnitTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isObjTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isValueTypeTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isVoidTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isILAppTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isNativePtrTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isInByrefTag: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isInByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isOutByrefTag: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isOutByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val extensionInfoOfTy: - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> TypedTree.TyconRepresentation - type TypeDefMetadata = - | ILTypeMetadata of TypedTree.TILObjectReprData - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata - | ProvidedTypeMetadata of TypedTree.TProvidedTypeInfo - val metadataOfTycon: TypedTree.Tycon -> TypeDefMetadata - val metadataOfTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypeDefMetadata - val isILReferenceTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isILInterfaceTycon: tycon:TypedTree.Tycon -> bool - val rankOfArrayTy: TcGlobals.TcGlobals -> TypedTree.TType -> int - val isFSharpObjModelRefTy: - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isFSharpClassTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isFSharpStructTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isFSharpInterfaceTy: - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isDelegateTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isInterfaceTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isClassTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isStructOrEnumTyconTy: - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isStructRecordOrUnionTyconTy: - TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isStructTyconRef: tcref:TypedTree.TyconRef -> bool - val isStructTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isRefTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isForallFunctionTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isUnmanagedTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isInterfaceTycon: x:TypedTree.Tycon -> bool - val isInterfaceTyconRef: TypedTree.TyconRef -> bool - val isEnumTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val actualReturnTyOfSlotSig: - TypedTree.TType list -> - TypedTree.TType list -> TypedTree.SlotSig -> TypedTree.TType option - val slotSigHasVoidReturnTy: TypedTree.SlotSig -> bool - val returnTyOfMethod: - TcGlobals.TcGlobals -> TypedTree.ObjExprMethod -> TypedTree.TType option - val isAbstractTycon: TypedTree.Tycon -> bool - val MemberIsExplicitImpl: - TcGlobals.TcGlobals -> TypedTree.ValMemberInfo -> bool - val ValIsExplicitImpl: TcGlobals.TcGlobals -> TypedTree.Val -> bool - val ValRefIsExplicitImpl: TcGlobals.TcGlobals -> TypedTree.ValRef -> bool - val emptyFreeLocals: AbstractIL.Internal.Zset - val unionFreeLocals: - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset - val emptyFreeRecdFields: AbstractIL.Internal.Zset - val unionFreeRecdFields: - s1:AbstractIL.Internal.Zset -> - s2:AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset - val emptyFreeUnionCases: AbstractIL.Internal.Zset - val unionFreeUnionCases: - s1:AbstractIL.Internal.Zset -> - s2:AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset - val emptyFreeTycons: AbstractIL.Internal.Zset - val unionFreeTycons: - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset - val typarOrder: System.Collections.Generic.IComparer - val emptyFreeTypars: AbstractIL.Internal.Zset - val unionFreeTypars: - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset - val emptyFreeTyvars: TypedTree.FreeTyvars - val isEmptyFreeTyvars: TypedTree.FreeTyvars -> bool - val unionFreeTyvars: - TypedTree.FreeTyvars -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars - type FreeVarOptions = - { canCache: bool - collectInTypes: bool - includeLocalTycons: bool - includeTypars: bool - includeLocalTyconReprs: bool - includeRecdFields: bool - includeUnionCases: bool - includeLocals: bool } - val CollectAllNoCaching: FreeVarOptions - val CollectTyparsNoCaching: FreeVarOptions - val CollectLocalsNoCaching: FreeVarOptions - val CollectTyparsAndLocalsNoCaching: FreeVarOptions - val CollectAll: FreeVarOptions - val CollectTyparsAndLocals: FreeVarOptions - val CollectTypars: FreeVarOptions - val CollectLocals: FreeVarOptions - val accFreeLocalTycon: - opts:FreeVarOptions -> - x:TypedTree.Tycon -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeTycon: - opts:FreeVarOptions -> - tcref:TypedTree.TyconRef -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val boundTypars: - opts:FreeVarOptions -> - tps:TypedTree.Typar list -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTyparConstraints: - opts:FreeVarOptions -> - cxs:TypedTree.TyparConstraint list -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTyparConstraint: - opts:FreeVarOptions -> - tpc:TypedTree.TyparConstraint -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTrait: - opts:FreeVarOptions -> - TypedTree.TraitConstraintInfo -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInWitnessArg: - opts:FreeVarOptions -> - TypedTree.TraitWitnessInfo -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTraitSln: - opts:FreeVarOptions -> - sln:TypedTree.TraitConstraintSln -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeLocalValInTraitSln: - _opts:'a -> - v:TypedTree.Val -> fvs:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeValRefInTraitSln: - opts:FreeVarOptions -> - vref:TypedTree.ValRef -> - fvs:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeTyparRef: - opts:FreeVarOptions -> - tp:TypedTree.Typar -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInType: - FreeVarOptions -> - TypedTree.TType -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTupInfo: - _opts:FreeVarOptions -> - unt:TypedTree.TupInfo -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInMeasure: - opts:FreeVarOptions -> - unt:TypedTree.Measure -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTypes: - FreeVarOptions -> - TypedTree.TTypes -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val freeInType: FreeVarOptions -> TypedTree.TType -> TypedTree.FreeTyvars - val accFreeInVal: - opts:FreeVarOptions -> - v:TypedTree.Val -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val freeInTypes: FreeVarOptions -> TypedTree.TTypes -> TypedTree.FreeTyvars - val freeInVal: FreeVarOptions -> TypedTree.Val -> TypedTree.FreeTyvars - val freeInTyparConstraints: - opts:FreeVarOptions -> - v:TypedTree.TyparConstraint list -> TypedTree.FreeTyvars - val accFreeInTypars: - FreeVarOptions -> - TypedTree.Typar list -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val addFreeInModuleTy: - mtyp:TypedTree.ModuleOrNamespaceType -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val freeInModuleTy: TypedTree.ModuleOrNamespaceType -> TypedTree.FreeTyvars - val emptyFreeTyparsLeftToRight: 'a list - val unionFreeTyparsLeftToRight: - fvs1:TypedTree.Typar list -> - fvs2:TypedTree.Typar list -> TypedTree.Typar list - val boundTyparsLeftToRight: - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - tps:TypedTree.Typar list -> TypedTree.Typar list - val accFreeInTyparConstraintsLeftToRight: - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - cxs:TypedTree.TyparConstraint list -> TypedTree.Typar list - val accFreeInTyparConstraintLeftToRight: - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - tpc:TypedTree.TyparConstraint -> TypedTree.Typar list - val accFreeInTraitLeftToRight: - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - TypedTree.TraitConstraintInfo -> TypedTree.Typar list - val accFreeTyparRefLeftToRight: - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - tp:TypedTree.Typar -> TypedTree.Typar list - val accFreeInTypeLeftToRight: - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - ty:TypedTree.TType -> TypedTree.Typar list - val accFreeInTupInfoLeftToRight: - _g:TcGlobals.TcGlobals -> - _cxFlag:bool -> - _thruFlag:bool -> - acc:TypedTree.Typar list -> - unt:TypedTree.TupInfo -> TypedTree.Typar list - val accFreeInTypesLeftToRight: - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - tys:TypedTree.TTypes -> TypedTree.Typar list - val freeInTypeLeftToRight: - TcGlobals.TcGlobals -> bool -> TypedTree.TType -> TypedTree.Typar list - val freeInTypesLeftToRight: - TcGlobals.TcGlobals -> bool -> TypedTree.TTypes -> TypedTree.Typar list - val freeInTypesLeftToRightSkippingConstraints: - TcGlobals.TcGlobals -> TypedTree.TTypes -> TypedTree.Typar list - val valOfBind: b:TypedTree.Binding -> TypedTree.Val - val valsOfBinds: TypedTree.Bindings -> TypedTree.Val list - val GetMemberTypeInFSharpForm: - g:TcGlobals.TcGlobals -> - memberFlags:SyntaxTree.MemberFlags -> - arities:TypedTree.ValReprInfo -> - ty:TypedTree.TType -> - m:Range.range -> - TypedTree.Typar list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType * TypedTree.ArgReprInfo - val checkMemberVal: - membInfo:'a option -> arity:'b option -> m:Range.range -> 'a * 'b - val checkMemberValRef: - vref:TypedTree.ValRef -> TypedTree.ValMemberInfo * TypedTree.ValReprInfo - val GetTraitConstraintInfosOfTypars: - TcGlobals.TcGlobals -> - TypedTree.Typars -> TypedTree.TraitConstraintInfo list - val GetTraitWitnessInfosOfTypars: - TcGlobals.TcGlobals -> - numParentTypars:int -> - typars:TypedTree.Typar list -> TypedTree.TraitWitnessInfo list - val CountEnclosingTyparsOfActualParentOfVal: TypedTree.Val -> int - val GetTopValTypeInCompiledForm: - TcGlobals.TcGlobals -> - TypedTree.ValReprInfo -> - int -> - TypedTree.TType -> - Range.range -> - TypedTree.Typar list * TypedTree.TraitWitnessInfo list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType option * TypedTree.ArgReprInfo - val GetMemberTypeInMemberForm: - TcGlobals.TcGlobals -> - SyntaxTree.MemberFlags -> - TypedTree.ValReprInfo -> - int -> - TypedTree.TType -> - Range.range -> - TypedTree.Typar list * TypedTree.TraitWitnessInfo list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType option * TypedTree.ArgReprInfo - val GetTypeOfMemberInMemberForm: - TcGlobals.TcGlobals -> - TypedTree.ValRef -> - TypedTree.Typar list * TypedTree.TraitWitnessInfo list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType option * TypedTree.ArgReprInfo - val GetTypeOfMemberInFSharpForm: - TcGlobals.TcGlobals -> - TypedTree.ValRef -> - TypedTree.Typar list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * TypedTree.TType * - TypedTree.ArgReprInfo - val PartitionValTyparsForApparentEnclosingType: - TcGlobals.TcGlobals -> - TypedTree.Val -> - (TypedTree.Typars * TypedTree.Typar list * TypedTree.Typar list * - TyparInst * TypedTree.TType list) option - val PartitionValTypars: - TcGlobals.TcGlobals -> - TypedTree.Val -> - (TypedTree.Typar list * TypedTree.Typar list * TypedTree.Typar list * - TyparInst * TypedTree.TType list) option - val PartitionValRefTypars: - TcGlobals.TcGlobals -> - TypedTree.ValRef -> - (TypedTree.Typar list * TypedTree.Typar list * TypedTree.Typar list * - TyparInst * TypedTree.TType list) option - val ArgInfosOfMemberVal: - g:TcGlobals.TcGlobals -> - v:TypedTree.Val -> (TypedTree.TType * TypedTree.ArgReprInfo) list list - val ArgInfosOfMember: - TcGlobals.TcGlobals -> - TypedTree.ValRef -> (TypedTree.TType * TypedTree.ArgReprInfo) list list - val GetFSharpViewOfReturnType: - TcGlobals.TcGlobals -> TypedTree.TType option -> TypedTree.TType - val ReturnTypeOfPropertyVal: - TcGlobals.TcGlobals -> TypedTree.Val -> TypedTree.TType - val ArgInfosOfPropertyVal: - TcGlobals.TcGlobals -> - TypedTree.Val -> (TypedTree.TType * TypedTree.ArgReprInfo) list - val generalTyconRefInst: tc:TypedTree.TyconRef -> TypedTree.TType list - val generalizeTyconRef: - TypedTree.TyconRef -> TypedTree.TType list * TypedTree.TType - val generalizedTyconRef: TypedTree.TyconRef -> TypedTree.TType - val isTTyparSupportsStaticMethod: _arg1:TypedTree.TyparConstraint -> bool - val isTTyparCoercesToType: _arg1:TypedTree.TyparConstraint -> bool - val prefixOfStaticReq: SyntaxTree.TyparStaticReq -> string - val prefixOfRigidTypar: TypedTree.Typar -> string - type TyparConstraintsWithTypars = - (TypedTree.Typar * TypedTree.TyparConstraint) list - module PrettyTypes = - val newPrettyTypar: tp:TypedTree.Typar -> nm:string -> TypedTree.Typar - val NewPrettyTypars: - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.Typar list -> - string list -> - TypedTree.Typar list * (TypedTree.Typar * TypedTree.TType) list - val NeedsPrettyTyparName: TypedTree.Typar -> bool - val PrettyTyparNames: - (TypedTree.Typar -> bool) -> - string list -> TypedTree.Typar list -> string list - val PrettifyThings: - g:TcGlobals.TcGlobals -> - foldTys:((TypedTree.Typar list -> TypedTree.TType -> - TypedTree.Typar list) -> 'a list -> 'b -> - TypedTree.Typar list) -> - mapTys:((TypedTree.TType -> TypedTree.TType) -> 'b -> 'b) -> - things:'b -> - 'b * (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyType: - TcGlobals.TcGlobals -> - TypedTree.TType -> - TypedTree.TType * (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyTypePair: - TcGlobals.TcGlobals -> - TypedTree.TType * TypedTree.TType -> - (TypedTree.TType * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyTypes: - TcGlobals.TcGlobals -> - TypedTree.TType list -> - TypedTree.TType list * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyDiscriminantAndTypePairs: - TcGlobals.TcGlobals -> - ('Discriminant * TypedTree.TType) list -> - ('Discriminant * TypedTree.TType) list * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyCurriedTypes: - TcGlobals.TcGlobals -> - TypedTree.TType list list -> - TypedTree.TType list list * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyCurriedSigTypes: - TcGlobals.TcGlobals -> - TypedTree.TType list list * TypedTree.TType -> - (TypedTree.TType list list * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val safeDestAnyParTy: - orig:TypedTree.Typar -> - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.Typar - val tee: f:('a -> 'a -> 'b) -> x:'a -> 'b - val foldUnurriedArgInfos: - f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:UncurriedArgInfos -> 'a - val mapUnurriedArgInfos: - f:(TypedTree.TType -> 'a) -> - x:UncurriedArgInfos -> ('a * TypedTree.ArgReprInfo) list - val foldTypar: - f:('a -> TypedTree.TType -> 'b) -> z:'a -> x:TypedTree.Typar -> 'b - val mapTypar: - g:TcGlobals.TcGlobals -> - f:(TypedTree.TType -> TypedTree.TType) -> - x:TypedTree.Typar -> TypedTree.Typar - val foldTypars: - f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:TypedTree.Typars -> 'a - val mapTypars: - g:TcGlobals.TcGlobals -> - f:(TypedTree.TType -> TypedTree.TType) -> - x:TypedTree.Typars -> TypedTree.Typars - val foldTyparInst: - f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:TyparInst -> 'a - val mapTyparInst: - g:TcGlobals.TcGlobals -> - f:(TypedTree.TType -> TypedTree.TType) -> x:TyparInst -> TyparInst - val PrettifyInstAndTyparsAndType: - TcGlobals.TcGlobals -> - TyparInst * TypedTree.Typars * TypedTree.TType -> - (TyparInst * TypedTree.Typars * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInstAndUncurriedSig: - TcGlobals.TcGlobals -> - TyparInst * UncurriedArgInfos * TypedTree.TType -> - (TyparInst * UncurriedArgInfos * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInstAndCurriedSig: - TcGlobals.TcGlobals -> - TyparInst * TypedTree.TTypes * CurriedArgInfos * TypedTree.TType -> - (TyparInst * TypedTree.TType list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInstAndSig: - TcGlobals.TcGlobals -> - TyparInst * TypedTree.TType list * TypedTree.TType -> - (TyparInst * TypedTree.TType list * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInstAndTypes: - TcGlobals.TcGlobals -> - TyparInst * TypedTree.TType list -> - (TyparInst * TypedTree.TType list) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInstAndType: - TcGlobals.TcGlobals -> - TyparInst * TypedTree.TType -> - (TyparInst * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInst: - TcGlobals.TcGlobals -> - TyparInst -> - TyparInst * (TypedTree.Typar * TypedTree.TyparConstraint) list - - module SimplifyTypes = - val foldTypeButNotConstraints: - f:('a -> TypedTree.TType -> 'a) -> z:'a -> ty:TypedTree.TType -> 'a - val incM: - x:'a -> - m:AbstractIL.Internal.Zmap<'a,int> -> AbstractIL.Internal.Zmap<'a,int> - val accTyparCounts: - z:AbstractIL.Internal.Zmap -> - ty:TypedTree.TType -> AbstractIL.Internal.Zmap - val emptyTyparCounts: AbstractIL.Internal.Zmap - val accTyparCountsMulti: - acc:AbstractIL.Internal.Zmap -> - l:TypedTree.TType list -> - AbstractIL.Internal.Zmap - type TypeSimplificationInfo = - { singletons: AbstractIL.Internal.Zset - inplaceConstraints: - AbstractIL.Internal.Zmap - postfixConstraints: (TypedTree.Typar * TypedTree.TyparConstraint) list } - val typeSimplificationInfo0: TypeSimplificationInfo - val categorizeConstraints: - simplify:bool -> - m:AbstractIL.Internal.Zmap -> - cxs:(TypedTree.Typar * TypedTree.TyparConstraint) list -> - TypeSimplificationInfo - val CollectInfo: - bool -> - TypedTree.TType list -> - (TypedTree.Typar * TypedTree.TyparConstraint) list -> - TypeSimplificationInfo - - [] - type DisplayEnv = - { includeStaticParametersInTypeNames: bool - openTopPathsSorted: Lazy - openTopPathsRaw: string list list - shortTypeNames: bool - suppressNestedTypes: bool - maxMembers: int option - showObsoleteMembers: bool - showHiddenMembers: bool - showTyparBinding: bool - showImperativeTyparAnnotations: bool - suppressInlineKeyword: bool - suppressMutableKeyword: bool - showMemberContainers: bool - shortConstraints: bool - useColonForReturnType: bool - showAttributes: bool - showOverrides: bool - showConstraintTyparAnnotations: bool - abbreviateAdditionalConstraints: bool - showTyparDefaultConstraints: bool - shrinkOverloads: bool - printVerboseSignatures: bool - g: TcGlobals.TcGlobals - contextAccessibility: TypedTree.Accessibility - generatedValueLayout: TypedTree.Val -> Layout.layout option } - with - static member Empty: TcGlobals.TcGlobals -> DisplayEnv - member AddAccessibility: TypedTree.Accessibility -> DisplayEnv - member - AddOpenModuleOrNamespace: TypedTree.ModuleOrNamespaceRef -> - DisplayEnv - member AddOpenPath: string list -> DisplayEnv - member SetOpenPaths: string list list -> DisplayEnv - - val ( +.+ ): s1:string -> s2:string -> string - val layoutOfPath: - p:string list -> Internal.Utilities.StructuredFormat.Layout - val fullNameOfParentOfPubPath: pp:TypedTree.PublicPath -> string voption - val fullNameOfParentOfPubPathAsLayout: - pp:TypedTree.PublicPath -> - Internal.Utilities.StructuredFormat.Layout voption - val fullNameOfPubPath: TypedTree.PublicPath -> string - val fullNameOfPubPathAsLayout: - TypedTree.PublicPath -> Internal.Utilities.StructuredFormat.Layout - val fullNameOfParentOfNonLocalEntityRef: - nlr:TypedTree.NonLocalEntityRef -> string voption - val fullNameOfParentOfNonLocalEntityRefAsLayout: - nlr:TypedTree.NonLocalEntityRef -> - Internal.Utilities.StructuredFormat.Layout voption - val fullNameOfParentOfEntityRef: eref:TypedTree.EntityRef -> string voption - val fullNameOfParentOfEntityRefAsLayout: - eref:TypedTree.EntityRef -> - Internal.Utilities.StructuredFormat.Layout voption - val fullNameOfEntityRef: - nmF:(TypedTree.EntityRef -> string) -> xref:TypedTree.EntityRef -> string - val tagEntityRefName: - xref:TypedTree.EntityRef -> name:string -> Layout.TaggedText - val fullDisplayTextOfTyconRef: TypedTree.TyconRef -> string - val fullNameOfEntityRefAsLayout: - nmF:(TypedTree.EntityRef -> string) -> - xref:TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout - val fullNameOfParentOfValRef: vref:TypedTree.ValRef -> string voption - val fullNameOfParentOfValRefAsLayout: - vref:TypedTree.ValRef -> - Internal.Utilities.StructuredFormat.Layout voption - val fullDisplayTextOfParentOfModRef: TypedTree.EntityRef -> string voption - val fullDisplayTextOfModRef: TypedTree.EntityRef -> string - val fullDisplayTextOfTyconRefAsLayout: - TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout - val fullDisplayTextOfExnRef: TypedTree.EntityRef -> string - val fullDisplayTextOfExnRefAsLayout: - TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout - val fullDisplayTextOfUnionCaseRef: TypedTree.UnionCaseRef -> string - val fullDisplayTextOfRecdFieldRef: TypedTree.RecdFieldRef -> string - val fullDisplayTextOfValRef: TypedTree.ValRef -> string - val fullDisplayTextOfValRefAsLayout: - TypedTree.ValRef -> Internal.Utilities.StructuredFormat.Layout - val fullMangledPathToTyconRef: tcref:TypedTree.TyconRef -> string [] - val tyconRefToFullName: tc:TypedTree.TyconRef -> string - val qualifiedInterfaceImplementationNameAux: - g:TcGlobals.TcGlobals -> x:TypedTree.TType -> string - val qualifiedInterfaceImplementationName: - TcGlobals.TcGlobals -> TypedTree.TType -> string -> string - val qualifiedMangledNameOfTyconRef: TypedTree.TyconRef -> string -> string - val firstEq: p1:'a list -> p2:'a list -> bool when 'a: equality - val firstRem: p1:'a list -> p2:'b list -> 'b list - val trimPathByDisplayEnv: DisplayEnv -> string list -> string - val superOfTycon: TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.TType - val isILAttribByName: - tencl:string list * tname:string -> attr:AbstractIL.IL.ILAttribute -> bool - val isILAttrib: - tref:AbstractIL.IL.ILTypeRef -> attr:AbstractIL.IL.ILAttribute -> bool - val HasILAttribute: - tref:AbstractIL.IL.ILTypeRef -> attrs:AbstractIL.IL.ILAttributes -> bool - val TryDecodeILAttribute: - TcGlobals.TcGlobals -> - AbstractIL.IL.ILTypeRef -> - AbstractIL.IL.ILAttributes -> - (AbstractIL.IL.ILAttribElem list * - AbstractIL.IL.ILAttributeNamedArg list) option - val IsMatchingFSharpAttribute: - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib -> bool - val HasFSharpAttribute: - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool - val findAttrib: - g:TcGlobals.TcGlobals -> - tref:TcGlobals.BuiltinAttribInfo -> - attrs:TypedTree.Attrib list -> TypedTree.Attrib - val TryFindFSharpAttribute: - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> - TypedTree.Attrib list -> TypedTree.Attrib option - val TryFindFSharpAttributeOpt: - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo option -> - TypedTree.Attrib list -> TypedTree.Attrib option - val HasFSharpAttributeOpt: - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo option -> TypedTree.Attrib list -> bool - val IsMatchingFSharpAttributeOpt: - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo option -> TypedTree.Attrib -> bool - val ( |ExtractAttribNamedArg|_| ): - string -> TypedTree.AttribNamedArg list -> TypedTree.AttribExpr option - val ( |AttribInt32Arg|_| ): TypedTree.AttribExpr -> int32 option - val ( |AttribInt16Arg|_| ): TypedTree.AttribExpr -> int16 option - val ( |AttribBoolArg|_| ): TypedTree.AttribExpr -> bool option - val ( |AttribStringArg|_| ): TypedTree.AttribExpr -> string option - val TryFindFSharpBoolAttributeWithDefault: - dflt:bool -> - g:TcGlobals.TcGlobals -> - nm:TcGlobals.BuiltinAttribInfo -> - attrs:TypedTree.Attrib list -> bool option - val TryFindFSharpBoolAttribute: - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool option - val TryFindFSharpBoolAttributeAssumeFalse: - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool option - val TryFindFSharpInt32Attribute: - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> int32 option - val TryFindFSharpStringAttribute: - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> string option - val TryFindILAttribute: - TcGlobals.BuiltinAttribInfo -> AbstractIL.IL.ILAttributes -> bool - val TryFindILAttributeOpt: - TcGlobals.BuiltinAttribInfo option -> AbstractIL.IL.ILAttributes -> bool - val TryBindTyconRefAttribute: - g:TcGlobals.TcGlobals -> - m:Range.range -> - TcGlobals.BuiltinAttribInfo -> - tcref:TypedTree.TyconRef -> - f1:(AbstractIL.IL.ILAttribElem list * - AbstractIL.IL.ILAttributeNamedArg list -> 'a option) -> - f2:(TypedTree.Attrib -> 'a option) -> - f3:(obj option list * (string * obj option) list -> 'a option) -> - 'a option - val TryFindTyconRefBoolAttribute: - TcGlobals.TcGlobals -> - Range.range -> - TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> bool option - val TryFindAttributeUsageAttribute: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool option - val TryFindTyconRefStringAttribute: - TcGlobals.TcGlobals -> - Range.range -> - TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> string option - val TyconRefHasAttribute: - TcGlobals.TcGlobals -> - Range.range -> TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> bool - val isByrefTyconRef: TcGlobals.TcGlobals -> TypedTree.TyconRef -> bool - val isByrefLikeTyconRef: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool - val isSpanLikeTyconRef: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool - val isByrefLikeTy: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val isSpanLikeTy: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val isSpanTyconRef: - g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool - val isSpanTy: TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val tryDestSpanTy: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - (TypedTree.TyconRef * TypedTree.TType) voption - val destSpanTy: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> struct (TypedTree.TyconRef * TypedTree.TType) - val isReadOnlySpanTyconRef: - g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool - val isReadOnlySpanTy: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val tryDestReadOnlySpanTy: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - (TypedTree.TyconRef * TypedTree.TType) voption - val destReadOnlySpanTy: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> struct (TypedTree.TyconRef * TypedTree.TType) - val destByrefTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val ( |ByrefTy|_| ): - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option - val destNativePtrTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val isRefCellTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val destRefCellTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val StripSelfRefCell: - TcGlobals.TcGlobals * TypedTree.ValBaseOrThisInfo * TypedTree.TType -> - TypedTree.TType - val mkRefCellTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkLazyTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkPrintfFormatTy: - TcGlobals.TcGlobals -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.TType -> TypedTree.TType -> TypedTree.TType - val mkOptionTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkNullableTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkListTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val isOptionTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val tryDestOptionTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType voption - val destOptionTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val isNullableTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val tryDestNullableTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType voption - val destNullableTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val ( |NullableTy|_| ): - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option - val ( |StripNullableTy| ): - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val isLinqExpressionTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val tryDestLinqExpressionTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option - val destLinqExpressionTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkNoneCase: TcGlobals.TcGlobals -> TypedTree.UnionCaseRef - val mkSomeCase: TcGlobals.TcGlobals -> TypedTree.UnionCaseRef - val mkSome: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr - val mkNone: - TcGlobals.TcGlobals -> TypedTree.TType -> Range.range -> TypedTree.Expr - val mkOptionGetValueUnprovenViaAddr: - TcGlobals.TcGlobals -> - TypedTree.Expr -> TypedTree.TType -> Range.range -> TypedTree.Expr - type ValRef with - member IsDispatchSlot: bool - val ( |UnopExpr|_| ): - _g:'a -> expr:TypedTree.Expr -> (TypedTree.ValRef * TypedTree.Expr) option - val ( |BinopExpr|_| ): - _g:'a -> - expr:TypedTree.Expr -> - (TypedTree.ValRef * TypedTree.Expr * TypedTree.Expr) option - val ( |SpecificUnopExpr|_| ): - g:TcGlobals.TcGlobals -> - vrefReqd:TypedTree.ValRef -> - expr:TypedTree.Expr -> TypedTree.Expr option - val ( |SpecificBinopExpr|_| ): - g:TcGlobals.TcGlobals -> - vrefReqd:TypedTree.ValRef -> - expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option - val ( |EnumExpr|_| ): - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr option - val ( |BitwiseOrExpr|_| ): - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option - val ( |AttribBitwiseOrExpr|_| ): - TcGlobals.TcGlobals -> - TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option - val isUncheckedDefaultOfValRef: - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val isTypeOfValRef: g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val isSizeOfValRef: g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val isNameOfValRef: TcGlobals.TcGlobals -> TypedTree.ValRef -> bool - val isTypeDefOfValRef: - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val ( |UncheckedDefaultOfExpr|_| ): - g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> TypedTree.TType option - val ( |TypeOfExpr|_| ): - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option - val ( |SizeOfExpr|_| ): - g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> TypedTree.TType option - val ( |TypeDefOfExpr|_| ): - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option - val ( |NameOfExpr|_| ): - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option - val ( |SeqExpr|_| ): TcGlobals.TcGlobals -> TypedTree.Expr -> unit option - module DebugPrint = - val layoutRanges: bool ref - val squareAngleL: - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val angleL: - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val braceL: - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val braceBarL: - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val boolL: _arg1:bool -> Internal.Utilities.StructuredFormat.Layout - val intL: int -> Internal.Utilities.StructuredFormat.Layout - val int64L: n:int64 -> Internal.Utilities.StructuredFormat.Layout - val jlistL: - xL:('a -> Internal.Utilities.StructuredFormat.Layout) -> - xmap:Internal.Utilities.QueueList<'a> -> - Internal.Utilities.StructuredFormat.Layout - val bracketIfL: - x:bool -> - lyt:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val lvalopL: - x:TypedTree.LValueOperation -> - Internal.Utilities.StructuredFormat.Layout - val angleBracketL: - l:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val angleBracketListL: - l:Internal.Utilities.StructuredFormat.Layout list -> - Internal.Utilities.StructuredFormat.Layout - val layoutMemberFlags: - memFlags:SyntaxTree.MemberFlags -> - Internal.Utilities.StructuredFormat.Layout - val stampL: _n:'a -> w:'b -> 'b - val layoutTyconRef: - tc:TypedTree.TyconRef -> Internal.Utilities.StructuredFormat.Layout - val auxTypeL: - env:SimplifyTypes.TypeSimplificationInfo -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val auxTypeAtomL: - env:SimplifyTypes.TypeSimplificationInfo -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val auxTyparsL: - env:SimplifyTypes.TypeSimplificationInfo -> - tcL:Internal.Utilities.StructuredFormat.Layout -> - prefix:bool -> - tinst:TypedTree.TType list -> - Internal.Utilities.StructuredFormat.Layout - val auxTypeWrapL: - env:SimplifyTypes.TypeSimplificationInfo -> - isAtomic:bool -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val auxTyparWrapL: - env:SimplifyTypes.TypeSimplificationInfo -> - isAtomic:bool -> - typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val auxTypar2L: - env:SimplifyTypes.TypeSimplificationInfo -> - typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val auxTyparAtomL: - env:SimplifyTypes.TypeSimplificationInfo -> - typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val auxTyparConstraintTypL: - env:SimplifyTypes.TypeSimplificationInfo -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val auxTraitL: - env:SimplifyTypes.TypeSimplificationInfo -> - ttrait:TypedTree.TraitConstraintInfo -> - Internal.Utilities.StructuredFormat.Layout - val auxTyparConstraintL: - env:SimplifyTypes.TypeSimplificationInfo -> - tp:TypedTree.Typar * tpc:TypedTree.TyparConstraint -> - Internal.Utilities.StructuredFormat.Layout - val auxTyparConstraintsL: - env:SimplifyTypes.TypeSimplificationInfo -> - x:(TypedTree.Typar * TypedTree.TyparConstraint) list -> - Internal.Utilities.StructuredFormat.Layout - val typarL: TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val typarAtomL: - tp:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val typeAtomL: - tau:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val typeL: TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val typarDeclL: - TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val layoutTyparDecls: - tps:TypedTree.Typars -> Internal.Utilities.StructuredFormat.Layout - val rangeL: m:Range.range -> Internal.Utilities.StructuredFormat.Layout - val instL: - tyL:('a -> Internal.Utilities.StructuredFormat.Layout) -> - tys:'a list -> Internal.Utilities.StructuredFormat.Layout - val valRefL: - TypedTree.ValRef -> Internal.Utilities.StructuredFormat.Layout - val layoutAttrib: - TypedTree.Attrib -> Internal.Utilities.StructuredFormat.Layout - val layoutAttribs: - attribs:TypedTree.Attrib list -> - Internal.Utilities.StructuredFormat.Layout - val arityInfoL: - TypedTree.ValReprInfo -> Internal.Utilities.StructuredFormat.Layout - val valL: TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val typeOfValL: - TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val tslotparamL: - TypedTree.SlotParam -> Internal.Utilities.StructuredFormat.Layout - val slotSigL: - TypedTree.SlotSig -> Internal.Utilities.StructuredFormat.Layout - val memberL: - g:TcGlobals.TcGlobals -> - v:TypedTree.Val -> - membInfo:TypedTree.ValMemberInfo -> - Internal.Utilities.StructuredFormat.Layout - val valAtBindL: - TcGlobals.TcGlobals -> - TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val unionCaseRefL: - TypedTree.UnionCaseRef -> Internal.Utilities.StructuredFormat.Layout - val recdFieldRefL: - TypedTree.RecdFieldRef -> Internal.Utilities.StructuredFormat.Layout - val identL: - id:SyntaxTree.Ident -> Internal.Utilities.StructuredFormat.Layout - val constL: - c:TypedTree.Const -> Internal.Utilities.StructuredFormat.Layout - val tyconL: - TcGlobals.TcGlobals -> - TypedTree.Tycon -> Internal.Utilities.StructuredFormat.Layout - val bindingL: - TcGlobals.TcGlobals -> - TypedTree.Binding -> Internal.Utilities.StructuredFormat.Layout - val exprL: - TcGlobals.TcGlobals -> - TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val atomL: - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val letRecL: - g:TcGlobals.TcGlobals -> - binds:TypedTree.Binding list -> - bodyL:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val letL: - g:TcGlobals.TcGlobals -> - bind:TypedTree.Binding -> - bodyL:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val exprWrapL: - g:TcGlobals.TcGlobals -> - isAtomic:bool -> - expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val implFilesL: - TcGlobals.TcGlobals -> - TypedTree.TypedImplFile list -> - Internal.Utilities.StructuredFormat.Layout - val appL: - g:TcGlobals.TcGlobals -> - flayout:Internal.Utilities.StructuredFormat.Layout -> - tys:TypedTree.TypeInst -> - args:TypedTree.Exprs -> Internal.Utilities.StructuredFormat.Layout - val implFileL: - TcGlobals.TcGlobals -> - TypedTree.TypedImplFile -> Internal.Utilities.StructuredFormat.Layout - val mexprL: - g:TcGlobals.TcGlobals -> - x:TypedTree.ModuleOrNamespaceExprWithSig -> - Internal.Utilities.StructuredFormat.Layout - val mdefsL: - g:TcGlobals.TcGlobals -> - defs:TypedTree.ModuleOrNamespaceExpr list -> - Internal.Utilities.StructuredFormat.Layout - val mdefL: - g:TcGlobals.TcGlobals -> - x:TypedTree.ModuleOrNamespaceExpr -> - Internal.Utilities.StructuredFormat.Layout - val mbindL: - g:TcGlobals.TcGlobals -> - x:TypedTree.ModuleOrNamespaceBinding -> - Internal.Utilities.StructuredFormat.Layout - val entityTypeL: - TcGlobals.TcGlobals -> - TypedTree.ModuleOrNamespaceType -> - Internal.Utilities.StructuredFormat.Layout - val entityL: - TcGlobals.TcGlobals -> - TypedTree.ModuleOrNamespace -> - Internal.Utilities.StructuredFormat.Layout - val ccuL: - g:TcGlobals.TcGlobals -> - ccu:TypedTree.CcuThunk -> Internal.Utilities.StructuredFormat.Layout - val decisionTreeL: - TcGlobals.TcGlobals -> - TypedTree.DecisionTree -> Internal.Utilities.StructuredFormat.Layout - val dcaseL: - g:TcGlobals.TcGlobals -> - TypedTree.DecisionTreeCase -> - Internal.Utilities.StructuredFormat.Layout - val dtestL: - g:TcGlobals.TcGlobals -> - x:TypedTree.DecisionTreeTest -> - Internal.Utilities.StructuredFormat.Layout - val targetL: - g:TcGlobals.TcGlobals -> - i:int -> - TypedTree.DecisionTreeTarget -> - Internal.Utilities.StructuredFormat.Layout - val flatValsL: - vs:TypedTree.Val list -> Internal.Utilities.StructuredFormat.Layout list - val tmethodL: - g:TcGlobals.TcGlobals -> - TypedTree.ObjExprMethod -> Internal.Utilities.StructuredFormat.Layout - val iimplL: - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType * tmeths:TypedTree.ObjExprMethod list -> - Internal.Utilities.StructuredFormat.Layout - val showType: TypedTree.TType -> string - val showExpr: TcGlobals.TcGlobals -> TypedTree.Expr -> string - val traitL: - TypedTree.TraitConstraintInfo -> - Internal.Utilities.StructuredFormat.Layout - val typarsL: - TypedTree.Typars -> Internal.Utilities.StructuredFormat.Layout - - val wrapModuleOrNamespaceType: - SyntaxTree.Ident -> - TypedTree.CompilationPath -> - TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespace - val wrapModuleOrNamespaceTypeInNamespace: - SyntaxTree.Ident -> - TypedTree.CompilationPath -> - TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType * TypedTree.ModuleOrNamespace - val wrapModuleOrNamespaceExprInNamespace: - SyntaxTree.Ident -> - TypedTree.CompilationPath -> - TypedTree.ModuleOrNamespaceExpr -> TypedTree.ModuleOrNamespaceExpr - val SigTypeOfImplFile: - TypedTree.TypedImplFile -> TypedTree.ModuleOrNamespaceType - type SignatureRepackageInfo = - { RepackagedVals: (TypedTree.ValRef * TypedTree.ValRef) list - RepackagedEntities: (TypedTree.TyconRef * TypedTree.TyconRef) list } - with - member ImplToSigMapping: TypeEquivEnv - static member Empty: SignatureRepackageInfo - - type SignatureHidingInfo = - { HiddenTycons: AbstractIL.Internal.Zset - HiddenTyconReprs: AbstractIL.Internal.Zset - HiddenVals: AbstractIL.Internal.Zset - HiddenRecdFields: AbstractIL.Internal.Zset - HiddenUnionCases: AbstractIL.Internal.Zset } - with - static member Empty: SignatureHidingInfo - - val addValRemap: TypedTree.Val -> TypedTree.Val -> Remap -> Remap - val mkRepackageRemapping: SignatureRepackageInfo -> Remap - val accEntityRemap: - msigty:TypedTree.ModuleOrNamespaceType -> - entity:TypedTree.Entity -> - mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accSubEntityRemap: - msigty:TypedTree.ModuleOrNamespaceType -> - entity:TypedTree.Entity -> - mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val valLinkageAEquiv: - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.Val -> TypedTree.Val -> bool - val accValRemap: - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - msigty:TypedTree.ModuleOrNamespaceType -> - implVal:TypedTree.Val -> - mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val getCorrespondingSigTy: - nm:string -> - msigty:TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType - val accEntityRemapFromModuleOrNamespaceType: - mty:TypedTree.ModuleOrNamespaceType -> - msigty:TypedTree.ModuleOrNamespaceType -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accValRemapFromModuleOrNamespaceType: - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - mty:TypedTree.ModuleOrNamespaceType -> - msigty:TypedTree.ModuleOrNamespaceType -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val ComputeRemappingFromInferredSignatureToExplicitSignature: - TcGlobals.TcGlobals -> - TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType -> - SignatureRepackageInfo * SignatureHidingInfo - val abstractSlotValRefsOfTycons: - TypedTree.Tycon list -> TypedTree.ValRef list - val abstractSlotValsOfTycons: TypedTree.Tycon list -> TypedTree.Val list - val accEntityRemapFromModuleOrNamespace: - msigty:TypedTree.ModuleOrNamespaceType -> - x:TypedTree.ModuleOrNamespaceExpr -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accEntityRemapFromModuleOrNamespaceDefs: - msigty:TypedTree.ModuleOrNamespaceType -> - mdefs:TypedTree.ModuleOrNamespaceExpr list -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accEntityRemapFromModuleOrNamespaceBind: - msigty:TypedTree.ModuleOrNamespaceType -> - x:TypedTree.ModuleOrNamespaceBinding -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accValRemapFromModuleOrNamespace: - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - msigty:TypedTree.ModuleOrNamespaceType -> - x:TypedTree.ModuleOrNamespaceExpr -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accValRemapFromModuleOrNamespaceBind: - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - msigty:TypedTree.ModuleOrNamespaceType -> - x:TypedTree.ModuleOrNamespaceBinding -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accValRemapFromModuleOrNamespaceDefs: - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - msigty:TypedTree.ModuleOrNamespaceType -> - mdefs:TypedTree.ModuleOrNamespaceExpr list -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val ComputeRemappingFromImplementationToSignature: - TcGlobals.TcGlobals -> - TypedTree.ModuleOrNamespaceExpr -> - TypedTree.ModuleOrNamespaceType -> - SignatureRepackageInfo * SignatureHidingInfo - val accTyconHidingInfoAtAssemblyBoundary: - tycon:TypedTree.Tycon -> mhi:SignatureHidingInfo -> SignatureHidingInfo - val accValHidingInfoAtAssemblyBoundary: - vspec:TypedTree.Val -> mhi:SignatureHidingInfo -> SignatureHidingInfo - val accModuleOrNamespaceHidingInfoAtAssemblyBoundary: - mty:TypedTree.ModuleOrNamespaceType -> - acc:SignatureHidingInfo -> SignatureHidingInfo - val ComputeHidingInfoAtAssemblyBoundary: - TypedTree.ModuleOrNamespaceType -> - SignatureHidingInfo -> SignatureHidingInfo - val IsHidden: - setF:('a -> AbstractIL.Internal.Zset<'b>) -> - accessF:('b -> TypedTree.Accessibility) -> - remapF:('c -> 'b -> 'b) -> (('c * 'a) list -> 'b -> bool) - val IsHiddenTycon: - (Remap * SignatureHidingInfo) list -> TypedTree.Tycon -> bool - val IsHiddenTyconRepr: - (Remap * SignatureHidingInfo) list -> TypedTree.Tycon -> bool - val IsHiddenVal: - (Remap * SignatureHidingInfo) list -> TypedTree.Val -> bool - val IsHiddenRecdField: - (Remap * SignatureHidingInfo) list -> TypedTree.RecdFieldRef -> bool - val foldModuleOrNamespaceTy: - ft:(TypedTree.Entity -> 'a -> 'a) -> - fv:(TypedTree.Val -> 'a -> 'a) -> - mty:TypedTree.ModuleOrNamespaceType -> acc:'a -> 'a - val allValsOfModuleOrNamespaceTy: - m:TypedTree.ModuleOrNamespaceType -> TypedTree.Val list - val allEntitiesOfModuleOrNamespaceTy: - m:TypedTree.ModuleOrNamespaceType -> TypedTree.Entity list - val isPublicVal: lv:TypedTree.Val -> bool - val isPublicUnionCase: ucr:TypedTree.UnionCaseRef -> bool - val isPublicRecdField: rfr:TypedTree.RecdFieldRef -> bool - val isPublicTycon: tcref:TypedTree.Tycon -> bool - val freeVarsAllPublic: TypedTree.FreeVars -> bool - val freeTyvarsAllPublic: TypedTree.FreeTyvars -> bool - val ( |LinearMatchExpr|_| ): - TypedTree.Expr -> - (SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * - TypedTree.DecisionTreeTarget * TypedTree.Expr * - SyntaxTree.DebugPointForTarget * Range.range * TypedTree.TType) option - val rebuildLinearMatchExpr: - (SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * - TypedTree.DecisionTreeTarget * TypedTree.Expr * - SyntaxTree.DebugPointForTarget * Range.range * TypedTree.TType) -> - TypedTree.Expr - val ( |LinearOpExpr|_| ): - TypedTree.Expr -> - (TypedTree.TOp * TypedTree.TypeInst * TypedTree.Expr list * - TypedTree.Expr * Range.range) option - val rebuildLinearOpExpr: - (TypedTree.TOp * TypedTree.TypeInst * TypedTree.Expr list * TypedTree.Expr * - Range.range) -> TypedTree.Expr - val emptyFreeVars: TypedTree.FreeVars - val unionFreeVars: - TypedTree.FreeVars -> TypedTree.FreeVars -> TypedTree.FreeVars - val inline accFreeTyvars: - opts:FreeVarOptions -> - f:(FreeVarOptions -> 'a -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars) -> - v:'a -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeVarsInTy: - opts:FreeVarOptions -> - ty:TypedTree.TType -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeVarsInTys: - opts:FreeVarOptions -> - tys:TypedTree.TType list -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreevarsInTycon: - opts:FreeVarOptions -> - tcref:TypedTree.TyconRef -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreevarsInVal: - opts:FreeVarOptions -> - v:TypedTree.Val -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeVarsInTraitSln: - opts:FreeVarOptions -> - tys:TypedTree.TraitConstraintSln -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeVarsInTraitInfo: - opts:FreeVarOptions -> - tys:TypedTree.TraitConstraintInfo -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val boundLocalVal: - opts:FreeVarOptions -> - v:TypedTree.Val -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val boundProtect: fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accUsesFunctionLocalConstructs: - flg:bool -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val bound_rethrow: fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accUsesRethrow: - flg:bool -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val boundLocalVals: - opts:FreeVarOptions -> - vs:TypedTree.Val list -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val bindLhs: - opts:FreeVarOptions -> - bind:TypedTree.Binding -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val freeVarsCacheCompute: - opts:FreeVarOptions -> cache:Lib.cache<'a> -> f:(unit -> 'a) -> 'a - val tryGetFreeVarsCacheValue: - opts:FreeVarOptions -> cache:Lib.cache<'a> -> Lib.NonNullSlot<'a> voption - val accBindRhs: - opts:FreeVarOptions -> - TypedTree.Binding -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInSwitchCases: - FreeVarOptions -> - TypedTree.DecisionTreeCase list -> - TypedTree.DecisionTree option -> - TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInSwitchCase: - opts:FreeVarOptions -> - TypedTree.DecisionTreeCase -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInTest: - opts:FreeVarOptions -> - discrim:TypedTree.DecisionTreeTest -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInDecisionTree: - FreeVarOptions -> - TypedTree.DecisionTree -> TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInValFlags: - opts:FreeVarOptions -> - flag:TypedTree.ValUseFlag -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeLocalVal: - opts:FreeVarOptions -> - v:TypedTree.Val -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accLocalTyconRepr: - opts:FreeVarOptions -> - b:TypedTree.Tycon -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accUsedRecdOrUnionTyconRepr: - opts:FreeVarOptions -> - tc:TypedTree.Tycon -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeUnionCaseRef: - opts:FreeVarOptions -> - ucref:TypedTree.UnionCaseRef -> - fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeRecdFieldRef: - opts:FreeVarOptions -> - rfref:TypedTree.RecdFieldRef -> - fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeExnRef: _exnc:'a -> fvs:'b -> 'b - val accFreeValRef: - opts:FreeVarOptions -> - vref:TypedTree.ValRef -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInMethod: - opts:FreeVarOptions -> - TypedTree.ObjExprMethod -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInMethods: - opts:FreeVarOptions -> - methods:TypedTree.ObjExprMethod list -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInInterfaceImpl: - opts:FreeVarOptions -> - ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInExpr: - opts:FreeVarOptions -> - x:TypedTree.Expr -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInExprLinear: - opts:FreeVarOptions -> - x:TypedTree.Expr -> - acc:TypedTree.FreeVars -> - contf:(TypedTree.FreeVars -> TypedTree.FreeVars) -> - TypedTree.FreeVars - val accFreeInExprNonLinear: - opts:FreeVarOptions -> - x:TypedTree.Expr -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInOp: - opts:FreeVarOptions -> - op:TypedTree.TOp -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInTargets: - FreeVarOptions -> - TypedTree.DecisionTreeTarget array -> - TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInTarget: - opts:FreeVarOptions -> - TypedTree.DecisionTreeTarget -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInFlatExprs: - opts:FreeVarOptions -> - exprs:TypedTree.Exprs -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInExprs: - FreeVarOptions -> - TypedTree.Exprs -> TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInSlotSig: - opts:FreeVarOptions -> - TypedTree.SlotSig -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val freeInDecisionTree: - opts:FreeVarOptions -> dtree:TypedTree.DecisionTree -> TypedTree.FreeVars - val freeInExpr: FreeVarOptions -> TypedTree.Expr -> TypedTree.FreeVars - val accFreeInModuleOrNamespace: - opts:FreeVarOptions -> - mexpr:TypedTree.ModuleOrNamespaceExpr -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInModuleOrNamespaceBind: - opts:FreeVarOptions -> - mbind:TypedTree.ModuleOrNamespaceBinding -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInModuleOrNamespaces: - opts:FreeVarOptions -> - mexprs:TypedTree.ModuleOrNamespaceExpr list -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val freeInBindingRhs: - FreeVarOptions -> TypedTree.Binding -> TypedTree.FreeVars - val freeInModuleOrNamespace: - FreeVarOptions -> TypedTree.ModuleOrNamespaceExpr -> TypedTree.FreeVars - val stripLambda: - expr:TypedTree.Expr * ty:TypedTree.TType -> - TypedTree.Val list list * TypedTree.Expr * TypedTree.TType - val stripLambdaN: - n:int -> - expr:TypedTree.Expr -> TypedTree.Val list list * TypedTree.Expr * int - val tryStripLambdaN: - n:int -> - expr:TypedTree.Expr -> (TypedTree.Val list list * TypedTree.Expr) option - val stripTopLambda: - TypedTree.Expr * TypedTree.TType -> - TypedTree.Typars * TypedTree.Val list list * TypedTree.Expr * - TypedTree.TType - [] - type AllowTypeDirectedDetupling = - | Yes - | No - val InferArityOfExpr: - TcGlobals.TcGlobals -> - AllowTypeDirectedDetupling -> - TypedTree.TType -> - TypedTree.Attrib list list list -> - TypedTree.Attribs -> TypedTree.Expr -> TypedTree.ValReprInfo - val InferArityOfExprBinding: - TcGlobals.TcGlobals -> - AllowTypeDirectedDetupling -> - TypedTree.Val -> TypedTree.Expr -> TypedTree.ValReprInfo - val underlyingTypeOfEnumTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val setValHasNoArity: TypedTree.Val -> TypedTree.Val - val normalizeEnumTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - type StaticOptimizationAnswer = - | Yes = 1y - | No = -1y - | Unknown = 0y - val decideStaticOptimizationConstraint: - g:TcGlobals.TcGlobals -> - c:TypedTree.StaticOptimization -> - haveWitnesses:bool -> StaticOptimizationAnswer - val DecideStaticOptimizations: - TcGlobals.TcGlobals -> - TypedTree.StaticOptimization list -> - haveWitnesses:bool -> StaticOptimizationAnswer - val mkStaticOptimizationExpr: - TcGlobals.TcGlobals -> - TypedTree.StaticOptimization list * TypedTree.Expr * TypedTree.Expr * - Range.range -> TypedTree.Expr - type ValCopyFlag = - | CloneAll - | CloneAllAndMarkExprValsAsCompilerGenerated - | OnlyCloneExprVals - val fixValCopyFlagForQuotations: _arg1:ValCopyFlag -> ValCopyFlag - val markAsCompGen: compgen:ValCopyFlag -> d:TypedTree.Val -> TypedTree.Val - val bindLocalVal: - v:TypedTree.Val -> v':TypedTree.Val -> tmenv:Remap -> Remap - val bindLocalVals: - vs:TypedTree.Val list -> vs':TypedTree.Val list -> tmenv:Remap -> Remap - val bindTycon: - tc:TypedTree.Tycon -> tc':TypedTree.Tycon -> tyenv:Remap -> Remap - val bindTycons: - tcs:Lib.NonNullSlot list -> - tcs':Lib.NonNullSlot list -> tyenv:Remap -> Remap - val remapAttribKind: - tmenv:Remap -> k:TypedTree.AttribKind -> TypedTree.AttribKind - val tmenvCopyRemapAndBindTypars: - remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> - tmenv:Remap -> tps:TypedTree.Typar list -> TypedTree.Typar list * Remap - val remapAttrib: - TcGlobals.TcGlobals -> Remap -> TypedTree.Attrib -> TypedTree.Attrib - val remapAttribExpr: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> TypedTree.AttribExpr -> TypedTree.AttribExpr - val remapAttribs: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> xs:TypedTree.Attrib list -> TypedTree.Attrib list - val remapPossibleForallTy: - TcGlobals.TcGlobals -> Remap -> TypedTree.TType -> TypedTree.TType - val remapArgData: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> argInfo:TypedTree.ArgReprInfo -> TypedTree.ArgReprInfo - val remapValReprInfo: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> TypedTree.ValReprInfo -> TypedTree.ValReprInfo - val remapValData: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> d:TypedTree.ValData -> TypedTree.ValData - val remapParentRef: - tyenv:Remap -> p:TypedTree.ParentRef -> TypedTree.ParentRef - val mapImmediateValsAndTycons: - ft:(TypedTree.Entity -> TypedTree.Entity) -> - fv:(TypedTree.Val -> TypedTree.Val) -> - x:TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespaceType - val copyVal: compgen:ValCopyFlag -> v:TypedTree.Val -> TypedTree.Val - val fixupValData: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> tmenv:Remap -> v2:TypedTree.Val -> unit - val copyAndRemapAndBindVals: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> vs:TypedTree.Val list -> TypedTree.Val list * Remap - val copyAndRemapAndBindVal: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> v:TypedTree.Val -> TypedTree.Val * Remap - val remapExpr: - TcGlobals.TcGlobals -> - ValCopyFlag -> Remap -> TypedTree.Expr -> TypedTree.Expr - val remapTarget: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - TypedTree.DecisionTreeTarget -> TypedTree.DecisionTreeTarget - val remapLinearExpr: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - expr:TypedTree.Expr -> - contf:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr - val remapConstraint: - tyenv:Remap -> - c:TypedTree.StaticOptimization -> TypedTree.StaticOptimization - val remapOp: tmenv:Remap -> op:TypedTree.TOp -> TypedTree.TOp - val remapValFlags: - tmenv:Remap -> x:TypedTree.ValUseFlag -> TypedTree.ValUseFlag - val remapExprs: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> es:TypedTree.Exprs -> TypedTree.Exprs - val remapFlatExprs: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> es:TypedTree.Expr list -> TypedTree.Expr list - val remapDecisionTree: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree - val copyAndRemapAndBindBinding: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> bind:TypedTree.Binding -> TypedTree.Binding * Remap - val copyAndRemapAndBindBindings: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> binds:TypedTree.Bindings -> TypedTree.Bindings * Remap - val remapAndRenameBinds: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenvinner:Remap -> - binds:TypedTree.Bindings -> - vs':TypedTree.Val list -> TypedTree.Bindings - val remapAndRenameBind: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenvinner:Remap -> - TypedTree.Binding -> v':TypedTree.Val -> TypedTree.Binding - val remapMethod: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod - val remapInterfaceImpl: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> - TypedTree.TType * TypedTree.ObjExprMethod list - val remapRecdField: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> x:TypedTree.RecdField -> TypedTree.RecdField - val remapRecdFields: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> x:TypedTree.TyconRecdFields -> TypedTree.TyconRecdFields - val remapUnionCase: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> x:TypedTree.UnionCase -> TypedTree.UnionCase - val remapUnionCases: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> x:TypedTree.TyconUnionData -> TypedTree.TyconUnionData - val remapFsObjData: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> - x:TypedTree.TyconObjModelData -> TypedTree.TyconObjModelData - val remapTyconRepr: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> - repr:TypedTree.TyconRepresentation -> TypedTree.TyconRepresentation - val remapTyconAug: - tmenv:Remap -> - x:TypedTree.TyconAugmentation -> TypedTree.TyconAugmentation - val remapTyconExnInfo: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> inp:TypedTree.ExceptionInfo -> TypedTree.ExceptionInfo - val remapMemberInfo: - g:TcGlobals.TcGlobals -> - m:Range.range -> - topValInfo:TypedTree.ValReprInfo option -> - ty:TypedTree.TType -> - ty':TypedTree.TType -> - tmenv:Remap -> - x:TypedTree.ValMemberInfo -> TypedTree.ValMemberInfo - val copyAndRemapAndBindModTy: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - mty:TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType * Remap - val remapModTy: - g:TcGlobals.TcGlobals -> - _compgen:ValCopyFlag -> - tmenv:Remap -> - mty:TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType - val renameTycon: - g:TcGlobals.TcGlobals -> - tyenv:Remap -> x:TypedTree.Entity -> TypedTree.Entity - val renameVal: tmenv:Remap -> x:TypedTree.Val -> TypedTree.Val - val copyTycon: - compgen:ValCopyFlag -> tycon:TypedTree.Tycon -> TypedTree.Tycon - val copyAndRemapAndBindTyconsAndVals: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - tycons:TypedTree.Entity list -> - vs:TypedTree.Val list -> - TypedTree.Tycon list * TypedTree.Val list * Remap - val allTyconsOfTycon: tycon:TypedTree.Tycon -> seq - val allEntitiesOfModDef: - mdef:TypedTree.ModuleOrNamespaceExpr -> seq - val allValsOfModDef: TypedTree.ModuleOrNamespaceExpr -> seq - val remapAndBindModuleOrNamespaceExprWithSig: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig * Remap - val remapModuleOrNamespaceExprWithSig: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig - val copyAndRemapModDef: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - mdef:TypedTree.ModuleOrNamespaceExpr -> - TypedTree.ModuleOrNamespaceExpr - val remapAndRenameModDefs: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - x:TypedTree.ModuleOrNamespaceExpr list -> - TypedTree.ModuleOrNamespaceExpr list - val remapAndRenameModDef: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - mdef:TypedTree.ModuleOrNamespaceExpr -> - TypedTree.ModuleOrNamespaceExpr - val remapAndRenameModBind: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - x:TypedTree.ModuleOrNamespaceBinding -> - TypedTree.ModuleOrNamespaceBinding - val remapImplFile: - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - mv:TypedTree.TypedImplFile -> TypedTree.TypedImplFile * Remap - val copyModuleOrNamespaceType: - TcGlobals.TcGlobals -> - ValCopyFlag -> - TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespaceType - val copyExpr: - TcGlobals.TcGlobals -> ValCopyFlag -> TypedTree.Expr -> TypedTree.Expr - val copyImplFile: - TcGlobals.TcGlobals -> - ValCopyFlag -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val instExpr: - TcGlobals.TcGlobals -> TyparInst -> TypedTree.Expr -> TypedTree.Expr - val remarkExpr: Range.range -> TypedTree.Expr -> TypedTree.Expr - val remarkObjExprMethod: - m:Range.range -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod - val remarkInterfaceImpl: - m:Range.range -> - ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> - TypedTree.TType * TypedTree.ObjExprMethod list - val remarkExprs: m:Range.range -> es:TypedTree.Exprs -> TypedTree.Exprs - val remarkFlatExprs: - m:Range.range -> es:TypedTree.Expr list -> TypedTree.Expr list - val remarkDecisionTree: - m:Range.range -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree - val remarkBinds: - m:Range.range -> binds:TypedTree.Bindings -> TypedTree.Bindings - val remarkBind: m:Range.range -> TypedTree.Binding -> TypedTree.Binding - val isRecdOrStructFieldDefinitelyMutable: f:TypedTree.RecdField -> bool - val isUnionCaseDefinitelyMutable: uc:TypedTree.UnionCase -> bool - val isUnionCaseRefDefinitelyMutable: TypedTree.UnionCaseRef -> bool - val isRecdOrUnionOrStructTyconRefDefinitelyMutable: - TypedTree.TyconRef -> bool - val isExnDefinitelyMutable: TypedTree.TyconRef -> bool - val isUnionCaseFieldMutable: - TcGlobals.TcGlobals -> TypedTree.UnionCaseRef -> int -> bool - val isExnFieldMutable: TypedTree.TyconRef -> int -> bool - val useGenuineField: TypedTree.Tycon -> TypedTree.RecdField -> bool - val ComputeFieldName: TypedTree.Tycon -> TypedTree.RecdField -> string - val isQuotedExprTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val destQuotedExprTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkQuotedExprTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkRawQuotedExprTy: TcGlobals.TcGlobals -> TypedTree.TType - val mkAnyTupledTy: - TcGlobals.TcGlobals -> - TypedTree.TupInfo -> TypedTree.TType list -> TypedTree.TType - val mkAnyAnonRecdTy: - TcGlobals.TcGlobals -> - TypedTree.AnonRecdTypeInfo -> TypedTree.TType list -> TypedTree.TType - val mkRefTupledTy: - TcGlobals.TcGlobals -> TypedTree.TType list -> TypedTree.TType - val mkRefTupledVarsTy: - TcGlobals.TcGlobals -> TypedTree.Val list -> TypedTree.TType - val mkMethodTy: - TcGlobals.TcGlobals -> - TypedTree.TType list list -> TypedTree.TType -> TypedTree.TType - val mkArrayType: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkByteArrayTy: TcGlobals.TcGlobals -> TypedTree.TType - val GenWitnessArgTys: - TcGlobals.TcGlobals -> - TypedTree.TraitWitnessInfo -> TypedTree.TType list list - val GenWitnessTy: - TcGlobals.TcGlobals -> TypedTree.TraitWitnessInfo -> TypedTree.TType - val GenWitnessTys: - TcGlobals.TcGlobals -> TraitWitnessInfos -> TypedTree.TType list - val tyOfExpr: TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType - val primMkApp: - (TypedTree.Expr * TypedTree.TType) -> - TypedTree.TypeInst -> TypedTree.Exprs -> Range.range -> TypedTree.Expr - val isExpansiveUnderInstantiation: - g:TcGlobals.TcGlobals -> - fty0:TypedTree.TType -> - tyargs:'a list -> pargs:'b list -> argsl:'c list -> bool - val mkExprAppAux: - g:TcGlobals.TcGlobals -> - f:TypedTree.Expr -> - fty:TypedTree.TType -> - argsl:TypedTree.Expr list -> m:Range.range -> TypedTree.Expr - val mkAppsAux: - g:TcGlobals.TcGlobals -> - f:TypedTree.Expr -> - fty:TypedTree.TType -> - tyargsl:TypedTree.TType list list -> - argsl:TypedTree.Expr list -> m:Range.range -> TypedTree.Expr - val mkApps: - TcGlobals.TcGlobals -> - (TypedTree.Expr * TypedTree.TType) * TypedTree.TType list list * - TypedTree.Expr list * Range.range -> TypedTree.Expr - val mkTyAppExpr: - Range.range -> - TypedTree.Expr * TypedTree.TType -> - TypedTree.TType list -> TypedTree.Expr - val accTargetsOfDecisionTree: - TypedTree.DecisionTree -> int list -> int list - val mapTargetsOfDecisionTree: - f:(int -> int) -> tree:TypedTree.DecisionTree -> TypedTree.DecisionTree - val mapTargetsOfDecisionTreeCase: - f:(int -> int) -> TypedTree.DecisionTreeCase -> TypedTree.DecisionTreeCase - val eliminateDeadTargetsFromMatch: - tree:TypedTree.DecisionTree -> - targets:'a [] -> TypedTree.DecisionTree * 'a [] - val targetOfSuccessDecisionTree: tree:TypedTree.DecisionTree -> int option - val decisionTreeHasNonTrivialBindings: tree:TypedTree.DecisionTree -> bool - val foldLinearBindingTargetsOfMatch: - tree:TypedTree.DecisionTree -> - targets:TypedTree.DecisionTreeTarget [] -> - TypedTree.DecisionTree * TypedTree.DecisionTreeTarget [] - val simplifyTrivialMatch: - spBind:SyntaxTree.DebugPointForBinding -> - exprm:Range.range -> - matchm:Range.range -> - ty:TypedTree.TType -> - tree:TypedTree.DecisionTree -> - targets:TypedTree.DecisionTreeTarget [] -> TypedTree.Expr - val mkAndSimplifyMatch: - SyntaxTree.DebugPointForBinding -> - Range.range -> - Range.range -> - TypedTree.TType -> - TypedTree.DecisionTree -> - TypedTree.DecisionTreeTarget list -> TypedTree.Expr - type Mutates = - | AddressOfOp - | DefinitelyMutates - | PossiblyMutates - | NeverMutates - exception DefensiveCopyWarning of string * Range.range - val isRecdOrStructTyconRefAssumedImmutable: - TcGlobals.TcGlobals -> TypedTree.TyconRef -> bool - val isTyconRefReadOnly: - g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool - val isTyconRefAssumedReadOnly: - g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> bool - val isRecdOrStructTyconRefReadOnlyAux: - g:TcGlobals.TcGlobals -> - m:Range.range -> isInref:bool -> tcref:TypedTree.TyconRef -> bool - val isRecdOrStructTyconRefReadOnly: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool - val isRecdOrStructTyReadOnlyAux: - g:TcGlobals.TcGlobals -> - m:Range.range -> isInref:bool -> ty:TypedTree.TType -> bool - val isRecdOrStructTyReadOnly: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val CanTakeAddressOf: - g:TcGlobals.TcGlobals -> - m:Range.range -> - isInref:bool -> ty:TypedTree.TType -> mut:Mutates -> bool - val CanTakeAddressOfImmutableVal: - g:TcGlobals.TcGlobals -> - m:Range.range -> vref:TypedTree.ValRef -> mut:Mutates -> bool - val MustTakeAddressOfVal: - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val MustTakeAddressOfByrefGet: - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val CanTakeAddressOfByrefGet: - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> mut:Mutates -> bool - val MustTakeAddressOfRecdField: rfref:TypedTree.RecdField -> bool - val MustTakeAddressOfRecdFieldRef: rfref:TypedTree.RecdFieldRef -> bool - val CanTakeAddressOfRecdFieldRef: - g:TcGlobals.TcGlobals -> - m:Range.range -> - rfref:TypedTree.RecdFieldRef -> - tinst:TypedTree.TType list -> mut:Mutates -> bool - val CanTakeAddressOfUnionFieldRef: - g:TcGlobals.TcGlobals -> - m:Range.range -> - uref:TypedTree.UnionCaseRef -> - cidx:int -> tinst:TypedTree.TType list -> mut:Mutates -> bool - val mkDerefAddrExpr: - mAddrGet:Range.range -> - expr:TypedTree.Expr -> - mExpr:Range.range -> exprTy:TypedTree.TType -> TypedTree.Expr - val mkExprAddrOfExprAux: - TcGlobals.TcGlobals -> - bool -> - bool -> - Mutates -> - TypedTree.Expr -> - TypedTree.ValRef option -> - Range.range -> - (TypedTree.Val * TypedTree.Expr) option * TypedTree.Expr * - bool * bool - val mkExprAddrOfExpr: - TcGlobals.TcGlobals -> - bool -> - bool -> - Mutates -> - TypedTree.Expr -> - TypedTree.ValRef option -> - Range.range -> - (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr * bool * - bool - val mkTupleFieldGet: - TcGlobals.TcGlobals -> - TypedTree.TupInfo * TypedTree.Expr * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkAnonRecdFieldGet: - TcGlobals.TcGlobals -> - TypedTree.AnonRecdTypeInfo * TypedTree.Expr * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkRecdFieldGet: - TcGlobals.TcGlobals -> - TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * - Range.range -> TypedTree.Expr - val mkUnionCaseFieldGetUnproven: - TcGlobals.TcGlobals -> - TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkArray: - TypedTree.TType * TypedTree.Exprs * Range.range -> TypedTree.Expr - val IterateRecursiveFixups: - TcGlobals.TcGlobals -> - TypedTree.Val option -> - (TypedTree.Val option -> TypedTree.Expr -> - (TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr -> unit) -> - TypedTree.Expr * (TypedTree.Expr -> TypedTree.Expr) -> - TypedTree.Expr -> unit - val JoinTyparStaticReq: - SyntaxTree.TyparStaticReq -> - SyntaxTree.TyparStaticReq -> SyntaxTree.TyparStaticReq - type ExprFolder<'State> = - { exprIntercept: - ('State -> TypedTree.Expr -> 'State) -> - ('State -> TypedTree.Expr -> 'State) -> 'State -> TypedTree.Expr -> - 'State - valBindingSiteIntercept: 'State -> bool * TypedTree.Val -> 'State - nonRecBindingsIntercept: 'State -> TypedTree.Binding -> 'State - recBindingsIntercept: 'State -> TypedTree.Bindings -> 'State - dtreeIntercept: 'State -> TypedTree.DecisionTree -> 'State - targetIntercept: - ('State -> TypedTree.Expr -> 'State) -> 'State -> - TypedTree.DecisionTreeTarget -> 'State option - tmethodIntercept: - ('State -> TypedTree.Expr -> 'State) -> 'State -> - TypedTree.ObjExprMethod -> 'State option } - val ExprFolder0: ExprFolder<'State> - type ExprFolders<'State> = - - new: folders:ExprFolder<'State> -> ExprFolders<'State> - member FoldExpr: ('State -> TypedTree.Expr -> 'State) - member FoldImplFile: ('State -> TypedTree.TypedImplFile -> 'State) - - val FoldExpr: ExprFolder<'State> -> ('State -> TypedTree.Expr -> 'State) - val FoldImplFile: - ExprFolder<'State> -> ('State -> TypedTree.TypedImplFile -> 'State) - val ExprStats: TypedTree.Expr -> string - val mkString: - TcGlobals.TcGlobals -> Range.range -> string -> TypedTree.Expr - val mkBool: TcGlobals.TcGlobals -> Range.range -> bool -> TypedTree.Expr - val mkByte: TcGlobals.TcGlobals -> Range.range -> byte -> TypedTree.Expr - val mkUInt16: - TcGlobals.TcGlobals -> Range.range -> uint16 -> TypedTree.Expr - val mkTrue: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkFalse: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkUnit: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkInt32: TcGlobals.TcGlobals -> Range.range -> int32 -> TypedTree.Expr - val mkInt: TcGlobals.TcGlobals -> Range.range -> int32 -> TypedTree.Expr - val mkZero: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkOne: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkTwo: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkMinusOne: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val destInt32: TypedTree.Expr -> int32 option - val isIDelegateEventType: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val destIDelegateEventType: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkIEventType: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType -> TypedTree.TType - val mkIObservableType: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkIObserverType: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkRefCellContentsRef: TcGlobals.TcGlobals -> TypedTree.RecdFieldRef - val mkSequential: - SyntaxTree.DebugPointAtSequential -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCompGenSequential: - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkSequentials: - SyntaxTree.DebugPointAtSequential -> - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr list -> TypedTree.Expr - val mkGetArg0: Range.range -> TypedTree.TType -> TypedTree.Expr - val mkAnyTupled: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TupInfo -> - TypedTree.Expr list -> TypedTree.TypeInst -> TypedTree.Expr - val mkRefTupled: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr list -> TypedTree.TypeInst -> TypedTree.Expr - val mkRefTupledNoTypes: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr list -> TypedTree.Expr - val mkRefTupledVars: - TcGlobals.TcGlobals -> Range.range -> TypedTree.Val list -> TypedTree.Expr - val inversePerm: sigma:int array -> int [] - val permute: sigma:int [] -> data:'T [] -> 'T [] - val existsR: a:int -> b:int -> pred:(int -> bool) -> bool - val liftAllBefore: sigma:int array -> int - val permuteExprList: - sigma:int [] -> - exprs:TypedTree.Expr list -> - ty:TypedTree.TType list -> - names:string list -> TypedTree.Binding list * TypedTree.Expr list - val mkRecordExpr: - TcGlobals.TcGlobals -> - TypedTree.RecordConstructionInfo * TypedTree.TyconRef * - TypedTree.TypeInst * TypedTree.RecdFieldRef list * TypedTree.Expr list * - Range.range -> TypedTree.Expr - val mkAnonRecd: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.AnonRecdTypeInfo -> - SyntaxTree.Ident [] -> - TypedTree.Expr list -> TypedTree.TType list -> TypedTree.Expr - val mkRefCell: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkRefCellGet: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkRefCellSet: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkNil: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCons: - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCompGenLocalAndInvisibleBind: - TcGlobals.TcGlobals -> - string -> - Range.range -> - TypedTree.Expr -> TypedTree.Val * TypedTree.Expr * TypedTree.Binding - val box: AbstractIL.IL.ILInstr - val isinst: AbstractIL.IL.ILInstr - val unbox: AbstractIL.IL.ILInstr - val mkUnbox: - TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr - val mkBox: - TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr - val mkIsInst: - TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr - val mspec_Type_GetTypeFromHandle: - TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mspec_String_Length: - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mspec_String_Concat2: - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mspec_String_Concat3: - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mspec_String_Concat4: - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mspec_String_Concat_Array: - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val fspec_Missing_Value: TcGlobals.TcGlobals -> AbstractIL.IL.ILFieldSpec - val mkInitializeArrayMethSpec: - TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mkInvalidCastExnNewobj: TcGlobals.TcGlobals -> AbstractIL.IL.ILInstr - val typedExprForIntrinsic: - _g:'a -> - m:Range.range -> - TcGlobals.IntrinsicValRef -> TypedTree.Expr * TypedTree.TType - val mkCallGetGenericComparer: - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkCallGetGenericEREqualityComparer: - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkCallGetGenericPEREqualityComparer: - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkCallUnbox: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallUnboxFast: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallTypeTest: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallTypeOf: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCallTypeDefOf: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCallDispose: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeq: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallCreateInstance: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCallGetQuerySourceAsEnumerable: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallNewQuerySource: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallCreateEvent: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGenericComparisonWithComparerOuter: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGenericEqualityEROuter: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGenericEqualityWithComparerOuter: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGenericHashWithComparerOuter: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallEqualsOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallNotEqualsOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallLessThanOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallLessThanOrEqualsOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGreaterThanOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGreaterThanOrEqualsOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallAdditionOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSubtractionOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallMultiplyOperator: - TcGlobals.TcGlobals -> - Range.range -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> - rty:TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallDivisionOperator: - TcGlobals.TcGlobals -> - Range.range -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> - rty:TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallModulusOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallDefaultOf: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCallBitwiseAndOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallBitwiseOrOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallBitwiseXorOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallShiftLeftOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallShiftRightOperator: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallUnaryNegOperator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallUnaryNotOperator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallAdditionChecked: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSubtractionChecked: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallMultiplyChecked: - TcGlobals.TcGlobals -> - Range.range -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> - rty:TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallUnaryNegChecked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToByteChecked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToSByteChecked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt16Checked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt16Checked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToIntChecked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt32Checked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt32Checked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt64Checked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt64Checked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToIntPtrChecked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUIntPtrChecked: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToByteOperator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToSByteOperator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt16Operator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt16Operator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToIntOperator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt32Operator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt32Operator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt64Operator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt64Operator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToSingleOperator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToDoubleOperator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToIntPtrOperator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUIntPtrOperator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToCharOperator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToEnumOperator: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallArrayLength: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallArrayGet: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray2DGet: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray3DGet: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray4DGet: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArraySet: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray2DSet: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray3DSet: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray4DSet: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallHash: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallBox: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallIsNull: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallIsNotNull: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallRaise: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallNewDecimal: - g:TcGlobals.TcGlobals -> - m:Range.range -> - e1:TypedTree.Expr * e2:TypedTree.Expr * e3:TypedTree.Expr * - e4:TypedTree.Expr * e5:TypedTree.Expr -> TypedTree.Expr - val mkCallNewFormat: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.TType -> - formatStringExpr:TypedTree.Expr -> TypedTree.Expr - val tryMkCallBuiltInWitness: - TcGlobals.TcGlobals -> - TypedTree.TraitConstraintInfo -> - TypedTree.Expr list -> Range.range -> TypedTree.Expr option - val tryMkCallCoreFunctionAsBuiltInWitness: - TcGlobals.TcGlobals -> - TcGlobals.IntrinsicValRef -> - TypedTree.TType list -> - TypedTree.Expr list -> Range.range -> TypedTree.Expr option - val TryEliminateDesugaredConstants: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Const -> TypedTree.Expr option - val mkSeqTy: TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkIEnumeratorTy: - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkCallSeqCollect: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqUsing: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqDelay: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqAppend: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqGenerated: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqFinally: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqOfFunctions: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqToArray: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqToList: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqMap: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqSingleton: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqEmpty: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCall_sprintf: - g:TcGlobals.TcGlobals -> - m:Range.range -> - funcTy:TypedTree.TType -> - fmtExpr:TypedTree.Expr -> - fillExprs:TypedTree.Expr list -> TypedTree.Expr - val mkCallDeserializeQuotationFSharp20Plus: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallDeserializeQuotationFSharp40Plus: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallCastQuotation: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallLiftValue: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallLiftValueWithName: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> string -> TypedTree.Expr -> TypedTree.Expr - val mkCallLiftValueWithDefn: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallCheckThis: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallFailInit: TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkCallFailStaticInit: - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkCallQuoteToLinqLambdaExpression: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkOptionToNullable: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkOptionDefaultValue: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkLazyDelayed: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkLazyForce: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkGetString: - g:TcGlobals.TcGlobals -> - m:Range.range -> - e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkGetStringChar: - (TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr -> - TypedTree.Expr) - val mkGetStringLength: - g:TcGlobals.TcGlobals -> - m:Range.range -> e:TypedTree.Expr -> TypedTree.Expr - val mkStaticCall_String_Concat2: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkStaticCall_String_Concat3: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkStaticCall_String_Concat4: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkStaticCall_String_Concat_Array: - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val mkDecr: - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val mkIncr: - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val mkLdlen: - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val mkLdelem: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkILAsmCeq: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkILAsmClt: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkNull: Range.range -> TypedTree.TType -> TypedTree.Expr - val mkThrow: - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val destThrow: - _arg1:TypedTree.Expr -> - (Range.range * TypedTree.TType * TypedTree.Expr) option - val isThrow: TypedTree.Expr -> bool - val mkReraiseLibCall: - TcGlobals.TcGlobals -> TypedTree.TType -> Range.range -> TypedTree.Expr - val mkReraise: Range.range -> TypedTree.TType -> TypedTree.Expr - val tnameCompilationSourceNameAttr: string - val tnameCompilationArgumentCountsAttr: string - val tnameCompilationMappingAttr: string - val tnameSourceConstructFlags: string - val tref_CompilationArgumentCountsAttr: - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef - val tref_CompilationMappingAttr: - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef - val tref_CompilationSourceNameAttr: - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef - val tref_SourceConstructFlags: - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef - val mkCompilationMappingAttrPrim: - g:TcGlobals.TcGlobals -> - k:int32 -> nums:int32 list -> AbstractIL.IL.ILAttribute - val mkCompilationMappingAttr: - TcGlobals.TcGlobals -> int32 -> AbstractIL.IL.ILAttribute - val mkCompilationMappingAttrWithSeqNum: - TcGlobals.TcGlobals -> int32 -> int32 -> AbstractIL.IL.ILAttribute - val mkCompilationMappingAttrWithVariantNumAndSeqNum: - TcGlobals.TcGlobals -> - int32 -> int32 -> int32 -> AbstractIL.IL.ILAttribute - val mkCompilationArgumentCountsAttr: - TcGlobals.TcGlobals -> int32 list -> AbstractIL.IL.ILAttribute - val mkCompilationSourceNameAttr: - TcGlobals.TcGlobals -> string -> AbstractIL.IL.ILAttribute - val mkCompilationMappingAttrForQuotationResource: - TcGlobals.TcGlobals -> - string * AbstractIL.IL.ILTypeRef list -> AbstractIL.IL.ILAttribute - val isTypeProviderAssemblyAttr: cattr:AbstractIL.IL.ILAttribute -> bool - val TryDecodeTypeProviderAssemblyAttr: - AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option - val tname_SignatureDataVersionAttr: string - val tnames_SignatureDataVersionAttr: string list * string - val tref_SignatureDataVersionAttr: unit -> AbstractIL.IL.ILTypeRef - val mkSignatureDataVersionAttr: - TcGlobals.TcGlobals -> - AbstractIL.IL.ILVersionInfo -> AbstractIL.IL.ILAttribute - val tname_AutoOpenAttr: string - val IsSignatureDataVersionAttr: AbstractIL.IL.ILAttribute -> bool - val TryFindAutoOpenAttr: - AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option - val tname_InternalsVisibleToAttr: string - val TryFindInternalsVisibleToAttr: - AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option - val IsMatchingSignatureDataVersionAttr: - AbstractIL.IL.ILGlobals -> - AbstractIL.IL.ILVersionInfo -> AbstractIL.IL.ILAttribute -> bool - val mkCompilerGeneratedAttr: - TcGlobals.TcGlobals -> int32 -> AbstractIL.IL.ILAttribute - val untupledToRefTupled: - g:TcGlobals.TcGlobals -> - vs:TypedTree.Val list -> - TypedTree.Val * (TypedTree.Expr -> TypedTree.Expr) - val AdjustArityOfLambdaBody: - TcGlobals.TcGlobals -> - int -> - TypedTree.Val list -> - TypedTree.Expr -> TypedTree.Val list * TypedTree.Expr - val MultiLambdaToTupledLambda: - TcGlobals.TcGlobals -> - TypedTree.Val list -> TypedTree.Expr -> TypedTree.Val * TypedTree.Expr - val ( |RefTuple|_| ): expr:TypedTree.Expr -> TypedTree.Exprs option - val MultiLambdaToTupledLambdaIfNeeded: - g:TcGlobals.TcGlobals -> - vs:TypedTree.Val list * arg:TypedTree.Expr -> - body:TypedTree.Expr -> - (TypedTree.Val * TypedTree.Expr) list * TypedTree.Expr - val MakeApplicationAndBetaReduceAux: - g:TcGlobals.TcGlobals -> - f:TypedTree.Expr * fty:TypedTree.TType * - tyargsl:TypedTree.TType list list * argsl:TypedTree.Expr list * - m:Range.range -> TypedTree.Expr - val MakeApplicationAndBetaReduce: - TcGlobals.TcGlobals -> - TypedTree.Expr * TypedTree.TType * TypedTree.TType list list * - TypedTree.Expr list * Range.range -> TypedTree.Expr - val MakeArgsForTopArgs: - _g:'a -> - m:Range.range -> - argtysl:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> - tpenv:(TypedTree.Typar * TypedTree.TType) list -> - TypedTree.Val list list - val AdjustValForExpectedArity: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.ValRef -> - TypedTree.ValUseFlag -> - TypedTree.ValReprInfo -> TypedTree.Expr * TypedTree.TType - val IsSubsumptionExpr: g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> bool - val stripTupledFunTy: - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> TypedTree.TTypes list * TypedTree.TType - val ( |ExprValWithPossibleTypeInst|_| ): - TypedTree.Expr -> - (TypedTree.ValRef * TypedTree.ValUseFlag * TypedTree.TypeInst * - Range.range) option - val mkCoerceIfNeeded: - TcGlobals.TcGlobals -> - tgtTy:TypedTree.TType -> - srcTy:TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCompGenLetIn: - Range.range -> - string -> - TypedTree.TType -> - TypedTree.Expr -> - (TypedTree.Val * TypedTree.Expr -> TypedTree.Expr) -> - TypedTree.Expr - val AdjustPossibleSubsumptionExpr: - TcGlobals.TcGlobals -> - TypedTree.Expr -> - TypedTree.Expr list -> (TypedTree.Expr * TypedTree.Expr list) option - val NormalizeAndAdjustPossibleSubsumptionExprs: - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr - val etaExpandTypeLambda: - g:TcGlobals.TcGlobals -> - m:Range.range -> - tps:TypedTree.Typar list -> - tm:TypedTree.Expr * ty:TypedTree.TType -> TypedTree.Expr - val AdjustValToTopVal: - TypedTree.Val -> TypedTree.ParentRef -> TypedTree.ValReprInfo -> unit - val LinearizeTopMatchAux: - g:TcGlobals.TcGlobals -> - parent:TypedTree.ParentRef -> - spBind:SyntaxTree.DebugPointForBinding * m:Range.range * - tree:TypedTree.DecisionTree * targets:TypedTree.DecisionTreeTarget [] * - m2:Range.range * ty:TypedTree.TType -> TypedTree.Expr - val LinearizeTopMatch: - TcGlobals.TcGlobals -> - TypedTree.ParentRef -> TypedTree.Expr -> TypedTree.Expr - val commaEncs: strs:seq -> string - val angleEnc: str:string -> string - val ticksAndArgCountTextOfTyconRef: TypedTree.TyconRef -> string - val typarEnc: - _g:'a -> - gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> - typar:TypedTree.Typar -> string - val typeEnc: - g:TcGlobals.TcGlobals -> - gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> - ty:TypedTree.TType -> string - val tyargsEnc: - g:TcGlobals.TcGlobals -> - gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> - args:TypedTree.TypeInst -> string - val XmlDocArgsEnc: - TcGlobals.TcGlobals -> - TypedTree.Typar list * TypedTree.Typar list -> - TypedTree.TType list -> string - val buildAccessPath: TypedTree.CompilationPath option -> string - val prependPath: path:string -> name:string -> string - val XmlDocSigOfVal: - TcGlobals.TcGlobals -> full:bool -> string -> TypedTree.Val -> string - val BuildXmlDocSig: prefix:string -> paths:string list -> string - val XmlDocSigOfUnionCase: (string list -> string) - val XmlDocSigOfField: (string list -> string) - val XmlDocSigOfProperty: (string list -> string) - val XmlDocSigOfTycon: (string list -> string) - val XmlDocSigOfSubModul: (string list -> string) - val XmlDocSigOfEntity: TypedTree.EntityRef -> string - val enum_CompilationRepresentationAttribute_Static: int - val enum_CompilationRepresentationAttribute_Instance: int - val enum_CompilationRepresentationAttribute_StaticInstanceMask: int - val enum_CompilationRepresentationAttribute_ModuleSuffix: int - val enum_CompilationRepresentationAttribute_PermitNull: int - val HasUseNullAsTrueValueAttribute: - g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> bool - val TyconHasUseNullAsTrueValueAttribute: - TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val CanHaveUseNullAsTrueValueAttribute: - TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val IsUnionTypeWithNullAsTrueValue: - TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val TyconCompilesInstanceMembersAsStatic: - g:TcGlobals.TcGlobals -> tycon:TypedTree.Tycon -> bool - val TcrefCompilesInstanceMembersAsStatic: - g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> bool - val isNonNullableStructTyparTy: - TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isReferenceTyparTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val TypeNullNever: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val TypeNullIsExtraValue: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val TypeNullIsTrueValue: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val TypeNullNotLiked: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val TypeSatisfiesNullConstraint: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val TypeHasDefaultValue: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val ( |SpecialComparableHeadType|_| ): - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes option - val ( |SpecialEquatableHeadType|_| ): - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes option - val ( |SpecialNotEquatableHeadType|_| ): - TcGlobals.TcGlobals -> TypedTree.TType -> unit option - val canUseTypeTestFast: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val canUseUnboxFast: - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val mkIsInstConditional: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Val -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkNullTest: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkNonNullTest: - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val mkNonNullCond: - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkIfThen: - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val ModuleNameIsMangled: - TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool - val CompileAsEvent: TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool - val MemberIsCompiledAsInstance: - TcGlobals.TcGlobals -> - TypedTree.TyconRef -> - bool -> TypedTree.ValMemberInfo -> TypedTree.Attrib list -> bool - val isSealedTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isComInteropTy: TcGlobals.TcGlobals -> TypedTree.TType -> bool - val ValSpecIsCompiledAsInstance: - TcGlobals.TcGlobals -> TypedTree.Val -> bool - val ValRefIsCompiledAsInstanceMember: - TcGlobals.TcGlobals -> TypedTree.ValRef -> bool - val GetMemberCallInfo: - TcGlobals.TcGlobals -> - TypedTree.ValRef * TypedTree.ValUseFlag -> - int * bool * bool * bool * bool * bool * bool * bool - val TryGetActivePatternInfo: - TypedTree.ValRef -> PrettyNaming.ActivePatternInfo option - type ActivePatternElemRef with - member Name: string - val mkChoiceTyconRef: - g:TcGlobals.TcGlobals -> m:Range.range -> n:int -> TypedTree.EntityRef - val mkChoiceTy: - g:TcGlobals.TcGlobals -> - m:Range.range -> tinst:TypedTree.TType list -> TypedTree.TType - val mkChoiceCaseRef: - TcGlobals.TcGlobals -> Range.range -> int -> int -> TypedTree.UnionCaseRef - type ActivePatternInfo with - member Names: string list - type ActivePatternInfo with - member - ResultType: TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType list -> TypedTree.TType - type ActivePatternInfo with - member - OverallType: TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType list -> TypedTree.TType - val doesActivePatternHaveFreeTypars: - TcGlobals.TcGlobals -> TypedTree.ValRef -> bool - [] - type ExprRewritingEnv = - { PreIntercept: - ((TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr -> - TypedTree.Expr option) option - PostTransform: TypedTree.Expr -> TypedTree.Expr option - PreInterceptBinding: - ((TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Binding -> - TypedTree.Binding option) option - IsUnderQuotations: bool } - val rewriteBind: - env:ExprRewritingEnv -> bind:TypedTree.Binding -> TypedTree.Binding - val rewriteBindStructure: - env:ExprRewritingEnv -> TypedTree.Binding -> TypedTree.Binding - val rewriteBinds: - env:ExprRewritingEnv -> - binds:TypedTree.Binding list -> TypedTree.Binding list - val RewriteExpr: ExprRewritingEnv -> TypedTree.Expr -> TypedTree.Expr - val preRewriteExpr: - env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr option - val postRewriteExpr: - env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr - val rewriteExprStructure: - env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr - val rewriteLinearExpr: - env:ExprRewritingEnv -> - expr:TypedTree.Expr -> - contf:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr - val rewriteExprs: - env:ExprRewritingEnv -> exprs:TypedTree.Exprs -> TypedTree.Exprs - val rewriteFlatExprs: - env:ExprRewritingEnv -> exprs:TypedTree.Expr list -> TypedTree.Expr list - val RewriteDecisionTree: - env:ExprRewritingEnv -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree - val rewriteTarget: - env:ExprRewritingEnv -> - TypedTree.DecisionTreeTarget -> TypedTree.DecisionTreeTarget - val rewriteTargets: - env:ExprRewritingEnv -> - targets:TypedTree.DecisionTreeTarget array -> - TypedTree.DecisionTreeTarget list - val rewriteObjExprOverride: - env:ExprRewritingEnv -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod - val rewriteObjExprInterfaceImpl: - env:ExprRewritingEnv -> - ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> - TypedTree.TType * TypedTree.ObjExprMethod list - val rewriteModuleOrNamespaceExpr: - env:ExprRewritingEnv -> - x:TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig - val rewriteModuleOrNamespaceDefs: - env:ExprRewritingEnv -> - x:TypedTree.ModuleOrNamespaceExpr list -> - TypedTree.ModuleOrNamespaceExpr list - val rewriteModuleOrNamespaceDef: - env:ExprRewritingEnv -> - x:TypedTree.ModuleOrNamespaceExpr -> TypedTree.ModuleOrNamespaceExpr - val rewriteModuleOrNamespaceBinding: - env:ExprRewritingEnv -> - x:TypedTree.ModuleOrNamespaceBinding -> - TypedTree.ModuleOrNamespaceBinding - val rewriteModuleOrNamespaceBindings: - env:ExprRewritingEnv -> - mbinds:TypedTree.ModuleOrNamespaceBinding list -> - TypedTree.ModuleOrNamespaceBinding list - val RewriteImplFile: - ExprRewritingEnv -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val MakeExportRemapping: - TypedTree.CcuThunk -> TypedTree.ModuleOrNamespace -> Remap - val remapEntityDataToNonLocal: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> d:TypedTree.Entity -> TypedTree.Entity - val remapTyconToNonLocal: - g:TcGlobals.TcGlobals -> - tmenv:Remap -> x:TypedTree.Entity -> TypedTree.Entity - val remapValToNonLocal: - g:TcGlobals.TcGlobals -> tmenv:Remap -> inp:TypedTree.Val -> TypedTree.Val - val ApplyExportRemappingToEntity: - TcGlobals.TcGlobals -> Remap -> TypedTree.Entity -> TypedTree.Entity - val isCompiledConstraint: cx:TypedTree.TyparConstraint -> bool - val IsGenericValWithGenericConstraints: - TcGlobals.TcGlobals -> TypedTree.Val -> bool - type Entity with - member HasInterface: TcGlobals.TcGlobals -> TypedTree.TType -> bool - type Entity with - member - HasOverride: TcGlobals.TcGlobals -> - string -> TypedTree.TType list -> bool - type Entity with - member - HasMember: TcGlobals.TcGlobals -> - string -> TypedTree.TType list -> bool - type EntityRef with - member HasInterface: TcGlobals.TcGlobals -> TypedTree.TType -> bool - type EntityRef with - member - HasOverride: TcGlobals.TcGlobals -> - string -> TypedTree.TType list -> bool - type EntityRef with - member - HasMember: TcGlobals.TcGlobals -> - string -> TypedTree.TType list -> bool - val mkFastForLoop: - TcGlobals.TcGlobals -> - SyntaxTree.DebugPointAtFor * Range.range * TypedTree.Val * - TypedTree.Expr * bool * TypedTree.Expr * TypedTree.Expr -> - TypedTree.Expr - val IsSimpleSyntacticConstantExpr: - TcGlobals.TcGlobals -> TypedTree.Expr -> bool - val EvalArithBinOp: - opInt8:(sbyte -> sbyte -> sbyte) * opInt16:(int16 -> int16 -> int16) * - opInt32:(int32 -> int32 -> int32) * opInt64:(int64 -> int64 -> int64) * - opUInt8:(byte -> byte -> byte) * opUInt16:(uint16 -> uint16 -> uint16) * - opUInt32:(uint32 -> uint32 -> uint32) * - opUInt64:(uint64 -> uint64 -> uint64) -> - arg1:TypedTree.Expr -> arg2:TypedTree.Expr -> TypedTree.Expr - val EvalAttribArgExpr: - g:TcGlobals.TcGlobals -> x:TypedTree.Expr -> TypedTree.Expr - val EvaledAttribExprEquality: - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr -> bool - val ( |ConstToILFieldInit|_| ): - TypedTree.Const -> AbstractIL.IL.ILFieldInit option - val EvalLiteralExprOrAttribArg: - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr - val GetTypeOfIntrinsicMemberInCompiledForm: - TcGlobals.TcGlobals -> - TypedTree.ValRef -> - TypedTree.Typar list * TypedTree.TraitWitnessInfo list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType option * TypedTree.ArgReprInfo - val mkCompiledTuple: - TcGlobals.TcGlobals -> - bool -> - TypedTree.TType list * TypedTree.Expr list * Range.range -> - TypedTree.EntityRef * TypedTree.TType list * TypedTree.Expr list * - Range.range - val mkILMethodSpecForTupleItem: - _g:TcGlobals.TcGlobals -> - ty:AbstractIL.IL.ILType -> n:int -> AbstractIL.IL.ILMethodSpec - val mkILFieldSpecForTupleItem: - ty:AbstractIL.IL.ILType -> n:int -> AbstractIL.IL.ILFieldSpec - val mkGetTupleItemN: - TcGlobals.TcGlobals -> - Range.range -> - int -> - AbstractIL.IL.ILType -> - bool -> TypedTree.Expr -> TypedTree.TType -> TypedTree.Expr - val ( |Int32Expr|_| ): TypedTree.Expr -> int32 option - val ( |TryFinally|_| ): - expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option - val ( |WhileLoopForCompiledForEachExpr|_| ): - expr:TypedTree.Expr -> - (TypedTree.Expr * TypedTree.Expr * Range.range) option - val ( |Let|_| ): - expr:TypedTree.Expr -> - (TypedTree.Val * TypedTree.Expr * SyntaxTree.DebugPointForBinding * - TypedTree.Expr) option - val ( |RangeInt32Step|_| ): - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> (TypedTree.Expr * int * TypedTree.Expr) option - val ( |GetEnumeratorCall|_| ): - expr:TypedTree.Expr -> TypedTree.ValRef option - val ( |CompiledForEachExpr|_| ): - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> - (TypedTree.TType * TypedTree.Expr * TypedTree.Val * TypedTree.Expr * - (Range.range * Range.range * SyntaxTree.DebugPointAtFor * Range.range * - SyntaxTree.DebugPointAtWhile * Range.range)) option - val ( |CompiledInt32RangeForEachExpr|_| ): - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> - (TypedTree.Expr * int * TypedTree.Expr * TypedTree.Val * - TypedTree.Expr * - (Range.range * Range.range * SyntaxTree.DebugPointAtFor * Range.range * - SyntaxTree.DebugPointAtWhile * Range.range)) option - type OptimizeForExpressionOptions = - | OptimizeIntRangesOnly - | OptimizeAllForExpressions - val DetectAndOptimizeForExpression: - TcGlobals.TcGlobals -> - OptimizeForExpressionOptions -> TypedTree.Expr -> TypedTree.Expr - val ( |InnerExprPat| ): TypedTree.Expr -> TypedTree.Expr - val BindUnitVars: - TcGlobals.TcGlobals -> - (TypedTree.Val list * TypedTree.ArgReprInfo list * TypedTree.Expr) -> - TypedTree.Val list * TypedTree.Expr - val isThreadOrContextStatic: - TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool - val mkUnitDelayLambda: - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val ( |ValApp|_| ): - TcGlobals.TcGlobals -> - TypedTree.ValRef -> - TypedTree.Expr -> - (TypedTree.TypeInst * TypedTree.Exprs * Range.range) option - val CombineCcuContentFragments: - Range.range -> - TypedTree.ModuleOrNamespaceType list -> TypedTree.ModuleOrNamespaceType - type TraitWitnessInfoHashMap<'T> = - System.Collections.Immutable.ImmutableDictionary - val EmptyTraitWitnessInfoHashMap: - TcGlobals.TcGlobals -> TraitWitnessInfoHashMap<'T> - val ( |WhileExpr|_| ): - TypedTree.Expr -> - (SyntaxTree.DebugPointAtWhile * TypedTree.SpecialWhileLoopMarker * - TypedTree.Expr * TypedTree.Expr * Range.range) option - val ( |TryFinallyExpr|_| ): - TypedTree.Expr -> - (SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally * - TypedTree.TType * TypedTree.Expr * TypedTree.Expr * Range.range) option - val ( |ForLoopExpr|_| ): - TypedTree.Expr -> - (SyntaxTree.DebugPointAtFor * TypedTree.ForLoopStyle * TypedTree.Expr * - TypedTree.Expr * TypedTree.Val * TypedTree.Expr * Range.range) option - val ( |TryWithExpr|_| ): - TypedTree.Expr -> - (SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith * - TypedTree.TType * TypedTree.Expr * TypedTree.Val * TypedTree.Expr * - TypedTree.Val * TypedTree.Expr * Range.range) option - val mkLabelled: - Range.range -> - AbstractIL.IL.ILCodeLabel -> TypedTree.Expr -> TypedTree.Expr - - -namespace FSharp.Compiler - module internal TypedTreePickle = - val verbose: bool - val ffailwith: fileName:System.String -> str:System.String -> 'a - [] - type PickledDataWithReferences<'RawData> = - { RawData: 'RawData - FixupThunks: TypedTree.CcuThunk [] } - with - member Fixup: (string -> TypedTree.CcuThunk) -> 'RawData - member OptionalFixup: (string -> TypedTree.CcuThunk option) -> 'RawData - - [] - type Table<'T> = - { name: string - tbl: System.Collections.Generic.Dictionary<'T,int> - mutable rows: ResizeArray<'T> - mutable count: int } - with - static member Create: n:string -> Table<'a> when 'a: equality - member Add: x:'T -> int - member FindOrAdd: x:'T -> int - member AsArray: 'T [] - member Size: int - - [] - type InputTable<'T> = - { itbl_name: string - itbl_rows: 'T array } - val new_itbl: n:string -> r:'a array -> InputTable<'a> - [] - type NodeOutTable<'Data,'Node> = - { NodeStamp: 'Node -> TypedTree.Stamp - NodeName: 'Node -> string - GetRange: 'Node -> Range.range - Deref: 'Node -> 'Data - Name: string - Table: Table } - with - static member - Create: stampF:('a -> TypedTree.Stamp) * nameF:('a -> string) * - rangeF:('a -> Range.range) * derefF:('a -> 'b) * nm:string -> - NodeOutTable<'b,'a> - member Size: int - - [] - type WriterState = - { os: AbstractIL.Internal.ByteBuffer - oscope: TypedTree.CcuThunk - occus: Table - oentities: NodeOutTable - otypars: NodeOutTable - ovals: NodeOutTable - oanoninfos: - NodeOutTable - ostrings: Table - opubpaths: Table - onlerefs: Table - osimpletys: Table - oglobals: TcGlobals.TcGlobals - mutable isStructThisArgPos: bool - ofile: string - oInMem: bool } - val pfailwith: st:WriterState -> str:System.String -> 'a - [] - type NodeInTable<'Data,'Node> = - { LinkNode: 'Node -> 'Data -> unit - IsLinked: 'Node -> bool - Name: string - Nodes: 'Node [] } - with - static member - Create: mkEmpty:(unit -> 'a) * lnk:('a -> 'b -> unit) * - isLinked:('a -> bool) * nm:string * n:int -> - NodeInTable<'b,'a> - member Get: n:int -> 'Node - member Count: int - - [] - type ReaderState = - { is: AbstractIL.Internal.ByteStream - iilscope: AbstractIL.IL.ILScopeRef - iccus: InputTable - ientities: NodeInTable - itypars: NodeInTable - ivals: NodeInTable - ianoninfos: - NodeInTable - istrings: InputTable - ipubpaths: InputTable - inlerefs: InputTable - isimpletys: InputTable - ifile: string - iILModule: AbstractIL.IL.ILModuleDef option } - val ufailwith: st:ReaderState -> str:System.String -> 'a - type 'T pickler = 'T -> WriterState -> unit - val p_byte: int -> WriterState -> unit - val p_bool: bool -> WriterState -> unit - val prim_p_int32: i:int -> st:WriterState -> unit - val p_int32: n:int -> st:WriterState -> unit - val space: unit - val p_space: n:int -> unit -> st:WriterState -> unit - val p_used_space1: f:(WriterState -> unit) -> st:WriterState -> unit - val p_bytes: s:byte [] -> st:WriterState -> unit - val p_prim_string: s:string -> st:WriterState -> unit - val p_int: int -> WriterState -> unit - val p_int8: i:sbyte -> st:WriterState -> unit - val p_uint8: i:byte -> st:WriterState -> unit - val p_int16: i:int16 -> st:WriterState -> unit - val p_uint16: x:uint16 -> st:WriterState -> unit - val p_uint32: x:uint32 -> st:WriterState -> unit - val p_int64: i:int64 -> st:WriterState -> unit - val p_uint64: x:uint64 -> st:WriterState -> unit - val bits_of_float32: x:float32 -> int - val bits_of_float: x:float -> int64 - val p_single: i:float32 -> st:WriterState -> unit - val p_double: i:float -> st:WriterState -> unit - val p_ieee64: i:float -> st:WriterState -> unit - val p_char: i:char -> st:WriterState -> unit - val inline p_tup2: - ('T1 -> WriterState -> unit) -> - ('T2 -> WriterState -> unit) -> ('T1 * 'T2 -> WriterState -> unit) - val inline p_tup3: - ('T1 -> WriterState -> unit) -> - ('T2 -> WriterState -> unit) -> - ('T3 -> WriterState -> unit) -> - ('T1 * 'T2 * 'T3 -> WriterState -> unit) - val inline p_tup4: - ('T1 -> WriterState -> unit) -> - ('T2 -> WriterState -> unit) -> - ('T3 -> WriterState -> unit) -> - ('T4 -> WriterState -> unit) -> - ('T1 * 'T2 * 'T3 * 'T4 -> WriterState -> unit) - val inline p_tup5: - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e -> st:WriterState -> unit - val inline p_tup6: - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f -> - st:WriterState -> unit - val inline p_tup7: - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - p7:('g -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g -> - st:WriterState -> unit - val inline p_tup8: - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - p7:('g -> WriterState -> unit) -> - p8:('h -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * x8:'h -> - st:WriterState -> unit - val inline p_tup9: - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - p7:('g -> WriterState -> unit) -> - p8:('h -> WriterState -> unit) -> - p9:('i -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * x8:'h * - x9:'i -> st:WriterState -> unit - val inline p_tup10: - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - p7:('g -> WriterState -> unit) -> - p8:('h -> WriterState -> unit) -> - p9:('i -> WriterState -> unit) -> - p10:('j -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * - x8:'h * x9:'i * x10:'j -> st:WriterState -> unit - val inline p_tup11: - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - p7:('g -> WriterState -> unit) -> - p8:('h -> WriterState -> unit) -> - p9:('i -> WriterState -> unit) -> - p10:('j -> WriterState -> unit) -> - p11:('k -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * - x8:'h * x9:'i * x10:'j * x11:'k -> - st:WriterState -> unit - val u_byte: ReaderState -> int - type unpickler<'T> = ReaderState -> 'T - val u_bool: ReaderState -> bool - val prim_u_int32: st:ReaderState -> int - val u_int32: st:ReaderState -> int - val u_byte_memory: st:ReaderState -> AbstractIL.Internal.ReadOnlyByteMemory - val u_bytes: st:ReaderState -> byte [] - val u_prim_string: st:ReaderState -> string - val u_int: ReaderState -> int - val u_int8: st:ReaderState -> sbyte - val u_uint8: st:ReaderState -> byte - val u_int16: st:ReaderState -> int16 - val u_uint16: st:ReaderState -> uint16 - val u_uint32: st:ReaderState -> uint32 - val u_int64: st:ReaderState -> int64 - val u_uint64: st:ReaderState -> uint64 - val float32_of_bits: x:int32 -> float32 - val float_of_bits: x:int64 -> float - val u_single: st:ReaderState -> float32 - val u_double: st:ReaderState -> float - val u_ieee64: st:ReaderState -> float - val u_char: st:ReaderState -> char - val u_space: n:int -> st:ReaderState -> unit - val u_used_space1: f:(ReaderState -> 'a) -> st:ReaderState -> 'a option - val inline u_tup2: - (ReaderState -> 'T2) -> (ReaderState -> 'T3) -> (ReaderState -> 'T2 * 'T3) - val inline u_tup3: - (ReaderState -> 'T2) -> - (ReaderState -> 'T3) -> - (ReaderState -> 'T4) -> (ReaderState -> 'T2 * 'T3 * 'T4) - val inline u_tup4: - (ReaderState -> 'T2) -> - (ReaderState -> 'T3) -> - (ReaderState -> 'T4) -> - (ReaderState -> 'T5) -> (ReaderState -> 'T2 * 'T3 * 'T4 * 'T5) - val inline u_tup5: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> st:ReaderState -> 'a * 'b * 'c * 'd * 'e - val inline u_tup6: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f - val inline u_tup7: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f * 'g - val inline u_tup8: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h - val inline u_tup9: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i - val inline u_tup10: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j - val inline u_tup11: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j * - 'k - val inline u_tup12: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j * - 'k * 'l - val inline u_tup13: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - p13:(ReaderState -> 'm) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * - 'j * 'k * 'l * 'm - val inline u_tup14: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - p13:(ReaderState -> 'm) -> - p14:(ReaderState -> 'n) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * - 'j * 'k * 'l * 'm * 'n - val inline u_tup15: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - p13:(ReaderState -> 'm) -> - p14:(ReaderState -> 'n) -> - p15:(ReaderState -> 'o) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * - 'j * 'k * 'l * 'm * 'n * 'o - val inline u_tup16: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - p13:(ReaderState -> 'm) -> - p14:(ReaderState -> 'n) -> - p15:(ReaderState -> 'o) -> - p16:(ReaderState -> 'p) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * - 'i * 'j * 'k * 'l * 'm * 'n * 'o * 'p - val inline u_tup17: - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - p13:(ReaderState -> 'm) -> - p14:(ReaderState -> 'n) -> - p15:(ReaderState -> 'o) -> - p16:(ReaderState -> 'p) -> - p17:(ReaderState -> 'q) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * - 'i * 'j * 'k * 'l * 'm * 'n * 'o * 'p * - 'q - val p_osgn_ref: - _ctxt:string -> - outMap:NodeOutTable<'a,'b> -> x:'b -> st:WriterState -> unit - val p_osgn_decl: - outMap:NodeOutTable<'a,'b> -> - p:('a -> WriterState -> unit) -> x:'b -> st:WriterState -> unit - val u_osgn_ref: inMap:NodeInTable<'a,'b> -> st:ReaderState -> 'b - val u_osgn_decl: - inMap:NodeInTable<'a,'b> -> u:(ReaderState -> 'a) -> st:ReaderState -> 'b - val encode_uniq: tbl:Table<'a> -> key:'a -> int - val lookup_uniq: st:ReaderState -> tbl:InputTable<'a> -> n:int -> 'a - val p_array_core: f:('T -> 'a -> unit) -> x:'T [] -> st:'a -> unit - val p_array: ('T -> WriterState -> unit) -> ('T [] -> WriterState -> unit) - val p_array_ext: - extraf:(WriterState -> unit) option -> - f:('T -> WriterState -> unit) -> x:'T [] -> st:WriterState -> unit - val p_list_core: f:('T -> 'a -> unit) -> xs:'T list -> st:'a -> unit - val p_list: - f:('a -> WriterState -> unit) -> x:'a list -> st:WriterState -> unit - val p_list_ext: - extraf:(WriterState -> unit) option -> - f:('a -> WriterState -> unit) -> x:'a list -> st:WriterState -> unit - val p_List: - f:('T -> WriterState -> unit) -> x:'T list -> st:WriterState -> unit - val p_wrap: f:('T -> 'U) -> p:'U pickler -> x:'T -> st:WriterState -> unit - val p_option: - f:('a -> WriterState -> unit) -> x:'a option -> st:WriterState -> unit - val private p_lazy_impl: - p:('a -> WriterState -> unit) -> v:'a -> st:WriterState -> unit - val p_lazy: - ('T -> WriterState -> unit) -> (System.Lazy<'T> -> WriterState -> unit) - val p_maybe_lazy: - p:('a -> WriterState -> unit) -> - x:Lib.MaybeLazy<'a> -> st:WriterState -> unit - val p_hole: - unit -> (('a -> WriterState -> 'b) -> unit) * ('a -> WriterState -> 'b) - val p_hole2: - unit -> - (('a -> 'b -> WriterState -> 'c) -> unit) * - ('a -> 'b -> WriterState -> 'c) - val u_array_core: f:('a -> 'b) -> n:int -> st:'a -> 'b [] - val u_array: (ReaderState -> 'T) -> (ReaderState -> 'T []) - val u_array_ext: - extraf:(ReaderState -> 'a) -> - f:(ReaderState -> 'b) -> st:ReaderState -> 'a option * 'b [] - val u_list_core: f:('a -> 'b) -> n:int -> st:'a -> 'b list - val u_list: f:(ReaderState -> 'a) -> st:ReaderState -> 'a list - val u_list_ext: - extra:(ReaderState -> 'a) -> - f:(ReaderState -> 'b) -> st:ReaderState -> 'a option * 'b list - val u_List: f:(ReaderState -> 'a) -> st:ReaderState -> 'a list - val u_array_revi: f:(ReaderState -> int -> 'a) -> st:ReaderState -> 'a [] - val u_list_revi: f:(ReaderState -> int -> 'a) -> st:ReaderState -> 'a list - val u_wrap: f:('U -> 'T) -> u:unpickler<'U> -> st:ReaderState -> 'T - val u_option: f:(ReaderState -> 'a) -> st:ReaderState -> 'a option - val u_lazy: (ReaderState -> 'T) -> (ReaderState -> System.Lazy<'T>) - val u_hole: unit -> ((ReaderState -> 'a) -> unit) * (ReaderState -> 'a) - val encode_string: stringTab:Table<'a> -> x:'a -> int - val decode_string: x:'a -> 'a - val lookup_string: - st:ReaderState -> stringTab:InputTable<'a> -> x:int -> 'a - val u_encoded_string: (ReaderState -> string) - val u_string: ReaderState -> string - val u_strings: (ReaderState -> string list) - val u_ints: (ReaderState -> int list) - val p_encoded_string: (string -> WriterState -> unit) - val p_string: string -> WriterState -> unit - val p_strings: (string list -> WriterState -> unit) - val p_ints: (int list -> WriterState -> unit) - val encode_ccuref: ccuTab:Table -> x:TypedTree.CcuThunk -> int - val decode_ccuref: x:'a -> 'a - val lookup_ccuref: st:ReaderState -> ccuTab:InputTable<'a> -> x:int -> 'a - val u_encoded_ccuref: st:ReaderState -> string - val u_ccuref: st:ReaderState -> TypedTree.CcuThunk - val p_encoded_ccuref: x:string -> st:WriterState -> unit - val p_ccuref: s:TypedTree.CcuThunk -> st:WriterState -> unit - val decode_pubpath: - st:ReaderState -> - stringTab:InputTable -> a:int [] -> TypedTree.PublicPath - val lookup_pubpath: - st:ReaderState -> pubpathTab:InputTable<'a> -> x:int -> 'a - val u_encoded_pubpath: (ReaderState -> int []) - val u_pubpath: st:ReaderState -> TypedTree.PublicPath - val encode_pubpath: - stringTab:Table -> - pubpathTab:Table -> TypedTree.PublicPath -> int - val p_encoded_pubpath: (int [] -> WriterState -> unit) - val p_pubpath: x:TypedTree.PublicPath -> st:WriterState -> unit - val decode_nleref: - st:ReaderState -> - ccuTab:InputTable -> - stringTab:InputTable -> - a:int * b:int [] -> TypedTree.NonLocalEntityRef - val lookup_nleref: - st:ReaderState -> nlerefTab:InputTable<'a> -> x:int -> 'a - val u_encoded_nleref: (ReaderState -> int * int []) - val u_nleref: st:ReaderState -> TypedTree.NonLocalEntityRef - val encode_nleref: - ccuTab:Table -> - stringTab:Table -> - nlerefTab:Table -> - thisCcu:TypedTree.CcuThunk -> - nleref:TypedTree.NonLocalEntityRef -> int - val p_encoded_nleref: (int * int [] -> WriterState -> unit) - val p_nleref: x:TypedTree.NonLocalEntityRef -> st:WriterState -> unit - val decode_simpletyp: - st:ReaderState -> - _ccuTab:'a -> - _stringTab:'b -> - nlerefTab:InputTable -> - a:int -> TypedTree.TType - val lookup_simpletyp: - st:ReaderState -> simpleTyTab:InputTable<'a> -> x:int -> 'a - val u_encoded_simpletyp: st:ReaderState -> int - val u_encoded_anoninfo: st:ReaderState -> int - val u_simpletyp: st:ReaderState -> TypedTree.TType - val encode_simpletyp: - ccuTab:Table -> - stringTab:Table -> - nlerefTab:Table -> - simpleTyTab:Table -> - thisCcu:TypedTree.CcuThunk -> a:TypedTree.NonLocalEntityRef -> int - val p_encoded_simpletyp: x:int -> st:WriterState -> unit - val p_encoded_anoninfo: x:int -> st:WriterState -> unit - val p_simpletyp: x:TypedTree.NonLocalEntityRef -> st:WriterState -> unit - val pickleObjWithDanglingCcus: - inMem:bool -> - file:string -> - TcGlobals.TcGlobals -> - scope:TypedTree.CcuThunk -> - ('T -> WriterState -> unit) -> 'T -> byte [] - val check: - ilscope:AbstractIL.IL.ILScopeRef -> inMap:NodeInTable<'a,'b> -> unit - val unpickleObjWithDanglingCcus: - file:string -> - viewedScope:AbstractIL.IL.ILScopeRef -> - ilModule:AbstractIL.IL.ILModuleDef option -> - (ReaderState -> 'T) -> - AbstractIL.Internal.ReadOnlyByteMemory -> - PickledDataWithReferences<'T> - val p_ILPublicKey: x:AbstractIL.IL.PublicKey -> st:WriterState -> unit - val p_ILVersion: x:AbstractIL.IL.ILVersionInfo -> st:WriterState -> unit - val p_ILModuleRef: x:AbstractIL.IL.ILModuleRef -> st:WriterState -> unit - val p_ILAssemblyRef: - x:AbstractIL.IL.ILAssemblyRef -> st:WriterState -> unit - val p_ILScopeRef: x:AbstractIL.IL.ILScopeRef -> st:WriterState -> unit - val u_ILPublicKey: st:ReaderState -> AbstractIL.IL.PublicKey - val u_ILVersion: st:ReaderState -> AbstractIL.IL.ILVersionInfo - val u_ILModuleRef: st:ReaderState -> AbstractIL.IL.ILModuleRef - val u_ILAssemblyRef: st:ReaderState -> AbstractIL.IL.ILAssemblyRef - val u_ILScopeRef: st:ReaderState -> AbstractIL.IL.ILScopeRef - val p_ILHasThis: x:AbstractIL.IL.ILThisConvention -> st:WriterState -> unit - val p_ILArrayShape: AbstractIL.IL.ILArrayShape pickler - val p_ILType: ty:AbstractIL.IL.ILType -> st:WriterState -> unit - val p_ILTypes: tys:AbstractIL.IL.ILType list -> (WriterState -> unit) - val p_ILBasicCallConv: - x:AbstractIL.IL.ILArgConvention -> st:WriterState -> unit - val p_ILCallConv: AbstractIL.IL.ILCallingConv -> st:WriterState -> unit - val p_ILCallSig: - x:AbstractIL.IL.ILCallingSignature -> st:WriterState -> unit - val p_ILTypeRef: x:AbstractIL.IL.ILTypeRef -> st:WriterState -> unit - val p_ILTypeSpec: a:AbstractIL.IL.ILTypeSpec -> st:WriterState -> unit - val u_ILBasicCallConv: st:ReaderState -> AbstractIL.IL.ILArgConvention - val u_ILHasThis: st:ReaderState -> AbstractIL.IL.ILThisConvention - val u_ILCallConv: st:ReaderState -> AbstractIL.IL.ILCallingConv - val u_ILTypeRef: st:ReaderState -> AbstractIL.IL.ILTypeRef - val u_ILArrayShape: unpickler - val u_ILType: st:ReaderState -> AbstractIL.IL.ILType - val u_ILTypes: st:ReaderState -> AbstractIL.IL.ILType list - val u_ILCallSig: (ReaderState -> AbstractIL.IL.ILCallingSignature) - val u_ILTypeSpec: st:ReaderState -> AbstractIL.IL.ILTypeSpec - val p_ILMethodRef: x:AbstractIL.IL.ILMethodRef -> st:WriterState -> unit - val p_ILFieldRef: x:AbstractIL.IL.ILFieldRef -> st:WriterState -> unit - val p_ILMethodSpec: x:AbstractIL.IL.ILMethodSpec -> st:WriterState -> unit - val p_ILFieldSpec: x:AbstractIL.IL.ILFieldSpec -> st:WriterState -> unit - val p_ILBasicType: x:AbstractIL.IL.ILBasicType -> st:WriterState -> unit - val p_ILVolatility: x:AbstractIL.IL.ILVolatility -> st:WriterState -> unit - val p_ILReadonly: x:AbstractIL.IL.ILReadonly -> st:WriterState -> unit - val u_ILMethodRef: st:ReaderState -> AbstractIL.IL.ILMethodRef - val u_ILFieldRef: st:ReaderState -> AbstractIL.IL.ILFieldRef - val u_ILMethodSpec: st:ReaderState -> AbstractIL.IL.ILMethodSpec - val u_ILFieldSpec: st:ReaderState -> AbstractIL.IL.ILFieldSpec - val u_ILBasicType: st:ReaderState -> AbstractIL.IL.ILBasicType - val u_ILVolatility: st:ReaderState -> AbstractIL.IL.ILVolatility - val u_ILReadonly: st:ReaderState -> AbstractIL.IL.ILReadonly - [] - val itag_nop: int = 0 - [] - val itag_ldarg: int = 1 - [] - val itag_ldnull: int = 2 - [] - val itag_ilzero: int = 3 - [] - val itag_call: int = 4 - [] - val itag_add: int = 5 - [] - val itag_sub: int = 6 - [] - val itag_mul: int = 7 - [] - val itag_div: int = 8 - [] - val itag_div_un: int = 9 - [] - val itag_rem: int = 10 - [] - val itag_rem_un: int = 11 - [] - val itag_and: int = 12 - [] - val itag_or: int = 13 - [] - val itag_xor: int = 14 - [] - val itag_shl: int = 15 - [] - val itag_shr: int = 16 - [] - val itag_shr_un: int = 17 - [] - val itag_neg: int = 18 - [] - val itag_not: int = 19 - [] - val itag_conv: int = 20 - [] - val itag_conv_un: int = 21 - [] - val itag_conv_ovf: int = 22 - [] - val itag_conv_ovf_un: int = 23 - [] - val itag_callvirt: int = 24 - [] - val itag_ldobj: int = 25 - [] - val itag_ldstr: int = 26 - [] - val itag_castclass: int = 27 - [] - val itag_isinst: int = 28 - [] - val itag_unbox: int = 29 - [] - val itag_throw: int = 30 - [] - val itag_ldfld: int = 31 - [] - val itag_ldflda: int = 32 - [] - val itag_stfld: int = 33 - [] - val itag_ldsfld: int = 34 - [] - val itag_ldsflda: int = 35 - [] - val itag_stsfld: int = 36 - [] - val itag_stobj: int = 37 - [] - val itag_box: int = 38 - [] - val itag_newarr: int = 39 - [] - val itag_ldlen: int = 40 - [] - val itag_ldelema: int = 41 - [] - val itag_ckfinite: int = 42 - [] - val itag_ldtoken: int = 43 - [] - val itag_add_ovf: int = 44 - [] - val itag_add_ovf_un: int = 45 - [] - val itag_mul_ovf: int = 46 - [] - val itag_mul_ovf_un: int = 47 - [] - val itag_sub_ovf: int = 48 - [] - val itag_sub_ovf_un: int = 49 - [] - val itag_ceq: int = 50 - [] - val itag_cgt: int = 51 - [] - val itag_cgt_un: int = 52 - [] - val itag_clt: int = 53 - [] - val itag_clt_un: int = 54 - [] - val itag_ldvirtftn: int = 55 - [] - val itag_localloc: int = 56 - [] - val itag_rethrow: int = 57 - [] - val itag_sizeof: int = 58 - [] - val itag_ldelem_any: int = 59 - [] - val itag_stelem_any: int = 60 - [] - val itag_unbox_any: int = 61 - [] - val itag_ldlen_multi: int = 62 - [] - val itag_initobj: int = 63 - [] - val itag_initblk: int = 64 - [] - val itag_cpobj: int = 65 - [] - val itag_cpblk: int = 66 - val simple_instrs: (int * AbstractIL.IL.ILInstr) list - val encode_table: - System.Collections.Generic.Dictionary - val encode_instr: si:AbstractIL.IL.ILInstr -> int - val isNoArgInstr: s:AbstractIL.IL.ILInstr -> bool - val decoders: (int * (ReaderState -> AbstractIL.IL.ILInstr)) list - val decode_tab: (ReaderState -> AbstractIL.IL.ILInstr) [] - val p_ILInstr: x:AbstractIL.IL.ILInstr -> st:WriterState -> unit - val u_ILInstr: st:ReaderState -> AbstractIL.IL.ILInstr - val p_Map_core: - pk:('a -> 'b -> unit) -> - pv:('c -> 'b -> unit) -> xs:Map<'a,'c> -> st:'b -> unit - when 'a: comparison - val p_Map: - pk:('a -> WriterState -> unit) -> - pv:('b -> WriterState -> unit) -> x:Map<'a,'b> -> st:WriterState -> unit - when 'a: comparison - val p_qlist: - pv:('a -> WriterState -> unit) -> Internal.Utilities.QueueList<'a> pickler - val p_namemap: - ('T -> WriterState -> unit) -> (Map -> WriterState -> unit) - val u_Map_core: - uk:('a -> 'b) -> uv:('a -> 'c) -> n:int -> st:'a -> Map<'b,'c> - when 'b: comparison - val u_Map: - uk:(ReaderState -> 'a) -> - uv:(ReaderState -> 'b) -> st:ReaderState -> Map<'a,'b> - when 'a: comparison - val u_qlist: - uv:(ReaderState -> 'a) -> unpickler> - val u_namemap: (ReaderState -> 'T) -> (ReaderState -> Map) - val p_pos: x:Range.pos -> st:WriterState -> unit - val p_range: x:Range.range -> st:WriterState -> unit - val p_dummy_range: _x:Range.range -> _st:WriterState -> unit - val p_ident: x:SyntaxTree.Ident -> st:WriterState -> unit - val p_xmldoc: doc:XmlDoc.XmlDoc -> st:WriterState -> unit - val u_pos: st:ReaderState -> Range.pos - val u_range: st:ReaderState -> Range.range - val u_dummy_range: _st:ReaderState -> Range.range - val u_ident: st:ReaderState -> SyntaxTree.Ident - val u_xmldoc: st:ReaderState -> XmlDoc.XmlDoc - val p_local_item_ref: - ctxt:string -> tab:NodeOutTable<'a,'b> -> st:'b -> (WriterState -> unit) - val p_tcref: string -> (TypedTree.EntityRef -> WriterState -> unit) - val p_ucref: (TypedTree.UnionCaseRef -> WriterState -> unit) - val p_rfref: TypedTree.RecdFieldRef -> st:WriterState -> unit - val p_tpref: x:TypedTree.Typar -> st:WriterState -> unit - val u_local_item_ref: tab:NodeInTable<'a,'b> -> st:ReaderState -> 'b - val u_tcref: (ReaderState -> TypedTree.EntityRef) - val u_ucref: (ReaderState -> TypedTree.UnionCaseRef) - val u_rfref: st:ReaderState -> TypedTree.RecdFieldRef - val u_tpref: st:ReaderState -> TypedTree.Typar - val p_ty2: (bool -> TypedTree.TType -> WriterState -> unit) - val fill_p_ty2: ((bool -> TypedTree.TType -> WriterState -> unit) -> unit) - val p_ty: (TypedTree.TType -> WriterState -> unit) - val p_tys: (TypedTree.TType list -> WriterState -> unit) - val p_attribs: (TypedTree.Attribs -> WriterState -> unit) - val fill_p_attribs: ((TypedTree.Attribs -> WriterState -> unit) -> unit) - val checkForInRefStructThisArg: - st:WriterState -> ty:TypedTree.TType -> bool - val p_nonlocal_val_ref: - nlv:TypedTree.NonLocalValOrMemberRef -> st:WriterState -> unit - val p_vref: string -> (TypedTree.ValRef -> WriterState -> unit) - val p_vrefs: ctxt:string -> (TypedTree.ValRef list -> WriterState -> unit) - val u_ty: (ReaderState -> TypedTree.TType) - val fill_u_ty: ((ReaderState -> TypedTree.TType) -> unit) - val u_tys: (ReaderState -> TypedTree.TType list) - val u_attribs: (ReaderState -> TypedTree.Attrib list) - val fill_u_attribs: ((ReaderState -> TypedTree.Attrib list) -> unit) - val u_nonlocal_val_ref: st:ReaderState -> TypedTree.NonLocalValOrMemberRef - val u_vref: (ReaderState -> TypedTree.ValRef) - val u_vrefs: (ReaderState -> TypedTree.ValRef list) - val p_kind: x:TypedTree.TyparKind -> st:WriterState -> unit - val p_member_kind: x:SyntaxTree.MemberKind -> st:WriterState -> unit - val u_kind: st:ReaderState -> TypedTree.TyparKind - val u_member_kind: st:ReaderState -> SyntaxTree.MemberKind - val p_MemberFlags: x:SyntaxTree.MemberFlags -> st:WriterState -> unit - val u_MemberFlags: st:ReaderState -> SyntaxTree.MemberFlags - val u_expr_fwd: (ReaderState -> TypedTree.Expr) - val fill_u_Expr_hole: ((ReaderState -> TypedTree.Expr) -> unit) - val p_expr_fwd: (TypedTree.Expr -> WriterState -> unit) - val fill_p_Expr_hole: ((TypedTree.Expr -> WriterState -> unit) -> unit) - val p_anonInfo_data: - anonInfo:TypedTree.AnonRecdTypeInfo -> st:WriterState -> unit - val p_anonInfo: x:TypedTree.AnonRecdTypeInfo -> st:WriterState -> unit - val p_trait_sln: sln:TypedTree.TraitConstraintSln -> st:WriterState -> unit - val p_trait: TypedTree.TraitConstraintInfo -> st:WriterState -> unit - val u_anonInfo_data: st:ReaderState -> TypedTree.AnonRecdTypeInfo - val u_anonInfo: st:ReaderState -> TypedTree.AnonRecdTypeInfo - val u_trait_sln: st:ReaderState -> TypedTree.TraitConstraintSln - val u_trait: st:ReaderState -> TypedTree.TraitConstraintInfo - val p_rational: q:Rational.Rational -> st:WriterState -> unit - val p_measure_con: tcref:TypedTree.EntityRef -> st:WriterState -> unit - val p_measure_var: v:TypedTree.Typar -> st:WriterState -> unit - val p_measure_one: (WriterState -> unit) - val p_measure_varcon: unt:TypedTree.Measure -> st:WriterState -> unit - val p_measure_pospower: - unt:TypedTree.Measure -> n:int -> st:WriterState -> unit - val p_measure_intpower: - unt:TypedTree.Measure -> n:int -> st:WriterState -> unit - val p_measure_power: - unt:TypedTree.Measure -> q:Rational.Rational -> st:WriterState -> unit - val p_normalized_measure: unt:TypedTree.Measure -> st:WriterState -> unit - val p_measure_expr: unt:TypedTree.Measure -> st:WriterState -> unit - val u_rational: st:ReaderState -> Rational.Rational - val u_measure_expr: st:ReaderState -> TypedTree.Measure - val p_tyar_constraint: - x:TypedTree.TyparConstraint -> st:WriterState -> unit - val p_tyar_constraints: - (TypedTree.TyparConstraint list -> WriterState -> unit) - val u_tyar_constraint: st:ReaderState -> (int -> TypedTree.TyparConstraint) - val u_tyar_constraints: (ReaderState -> TypedTree.TyparConstraint list) - val p_tyar_spec_data: x:TypedTree.Typar -> st:WriterState -> unit - val p_tyar_spec: x:TypedTree.Typar -> st:WriterState -> unit - val p_tyar_specs: (TypedTree.Typar list -> WriterState -> unit) - val u_tyar_spec_data: st:ReaderState -> TypedTree.Typar - val u_tyar_spec: st:ReaderState -> TypedTree.Typar - val u_tyar_specs: (ReaderState -> TypedTree.Typar list) - val p_binds: (TypedTree.Bindings -> WriterState -> unit) - val fill_p_binds: ((TypedTree.Bindings -> WriterState -> unit) -> unit) - val p_targets: (TypedTree.DecisionTreeTarget array -> WriterState -> unit) - val fill_p_targets: - ((TypedTree.DecisionTreeTarget array -> WriterState -> unit) -> unit) - val p_Exprs: (TypedTree.Exprs -> WriterState -> unit) - val fill_p_Exprs: ((TypedTree.Exprs -> WriterState -> unit) -> unit) - val p_constraints: - (TypedTree.StaticOptimization list -> WriterState -> unit) - val fill_p_constraints: - ((TypedTree.StaticOptimization list -> WriterState -> unit) -> unit) - val p_Vals: (TypedTree.Val list -> WriterState -> unit) - val fill_p_Vals: ((TypedTree.Val list -> WriterState -> unit) -> unit) - val u_binds: (ReaderState -> TypedTree.Bindings) - val fill_u_binds: ((ReaderState -> TypedTree.Bindings) -> unit) - val u_targets: (ReaderState -> TypedTree.DecisionTreeTarget array) - val fill_u_targets: - ((ReaderState -> TypedTree.DecisionTreeTarget array) -> unit) - val u_Exprs: (ReaderState -> TypedTree.Exprs) - val fill_u_Exprs: ((ReaderState -> TypedTree.Exprs) -> unit) - val u_constraints: (ReaderState -> TypedTree.StaticOptimization list) - val fill_u_constraints: - ((ReaderState -> TypedTree.StaticOptimization list) -> unit) - val u_Vals: (ReaderState -> TypedTree.Val list) - val fill_u_Vals: ((ReaderState -> TypedTree.Val list) -> unit) - val p_ArgReprInfo: x:TypedTree.ArgReprInfo -> st:WriterState -> unit - val p_TyparReprInfo: TypedTree.TyparReprInfo -> st:WriterState -> unit - val p_ValReprInfo: TypedTree.ValReprInfo -> st:WriterState -> unit - val u_ArgReprInfo: st:ReaderState -> TypedTree.ArgReprInfo - val u_TyparReprInfo: st:ReaderState -> TypedTree.TyparReprInfo - val u_ValReprInfo: st:ReaderState -> TypedTree.ValReprInfo - val p_ranges: - x:(Range.range * Range.range) option -> st:WriterState -> unit - val p_istype: x:TypedTree.ModuleOrNamespaceKind -> st:WriterState -> unit - val p_cpath: TypedTree.CompilationPath -> st:WriterState -> unit - val u_ranges: st:ReaderState -> (Range.range * Range.range) option - val u_istype: st:ReaderState -> TypedTree.ModuleOrNamespaceKind - val u_cpath: st:ReaderState -> TypedTree.CompilationPath - val dummy: x:'a -> 'a - val p_tycon_repr: x:TypedTree.TyconRepresentation -> st:WriterState -> bool - val p_tycon_objmodel_data: - x:TypedTree.TyconObjModelData -> st:WriterState -> unit - val p_attribs_ext: - f:(WriterState -> unit) option -> - x:TypedTree.Attrib list -> st:WriterState -> unit - val p_unioncase_spec: x:TypedTree.UnionCase -> st:WriterState -> unit - val p_exnc_spec_data: x:TypedTree.Entity -> st:WriterState -> unit - val p_exnc_repr: x:TypedTree.ExceptionInfo -> st:WriterState -> unit - val p_exnc_spec: x:TypedTree.Entity -> st:WriterState -> unit - val p_access: TypedTree.Accessibility -> st:WriterState -> unit - val p_recdfield_spec: x:TypedTree.RecdField -> st:WriterState -> unit - val p_rfield_table: x:TypedTree.TyconRecdFields -> st:WriterState -> unit - val p_entity_spec_data: x:TypedTree.Entity -> st:WriterState -> unit - val p_tcaug: p:TypedTree.TyconAugmentation -> st:WriterState -> unit - val p_entity_spec: x:TypedTree.Entity -> st:WriterState -> unit - val p_parentref: x:TypedTree.ParentRef -> st:WriterState -> unit - val p_attribkind: x:TypedTree.AttribKind -> st:WriterState -> unit - val p_attrib: TypedTree.Attrib -> st:WriterState -> unit - val p_attrib_expr: TypedTree.AttribExpr -> st:WriterState -> unit - val p_attrib_arg: TypedTree.AttribNamedArg -> st:WriterState -> unit - val p_member_info: x:TypedTree.ValMemberInfo -> st:WriterState -> unit - val p_tycon_objmodel_kind: - x:TypedTree.TyconObjModelKind -> st:WriterState -> unit - val p_mustinline: x:TypedTree.ValInline -> st:WriterState -> unit - val p_basethis: x:TypedTree.ValBaseOrThisInfo -> st:WriterState -> unit - val p_vrefFlags: x:TypedTree.ValUseFlag -> st:WriterState -> unit - val p_ValData: x:TypedTree.Val -> st:WriterState -> unit - val p_Val: x:TypedTree.Val -> st:WriterState -> unit - val p_modul_typ: - x:TypedTree.ModuleOrNamespaceType -> st:WriterState -> unit - val u_tycon_repr: st:ReaderState -> (bool -> TypedTree.TyconRepresentation) - val u_tycon_objmodel_data: st:ReaderState -> TypedTree.TyconObjModelData - val u_attribs_ext: - extraf:(ReaderState -> 'a) -> - st:ReaderState -> 'a option * TypedTree.Attrib list - val u_unioncase_spec: st:ReaderState -> TypedTree.UnionCase - val u_exnc_spec_data: st:ReaderState -> TypedTree.Entity - val u_exnc_repr: st:ReaderState -> TypedTree.ExceptionInfo - val u_exnc_spec: st:ReaderState -> TypedTree.Tycon - val u_access: st:ReaderState -> TypedTree.Accessibility - val u_recdfield_spec: st:ReaderState -> TypedTree.RecdField - val u_rfield_table: st:ReaderState -> TypedTree.TyconRecdFields - val u_entity_spec_data: st:ReaderState -> TypedTree.Entity - val u_tcaug: st:ReaderState -> TypedTree.TyconAugmentation - val u_entity_spec: st:ReaderState -> TypedTree.Tycon - val u_parentref: st:ReaderState -> TypedTree.ParentRef - val u_attribkind: st:ReaderState -> TypedTree.AttribKind - val u_attrib: st:ReaderState -> TypedTree.Attrib - val u_attrib_expr: st:ReaderState -> TypedTree.AttribExpr - val u_attrib_arg: st:ReaderState -> TypedTree.AttribNamedArg - val u_member_info: st:ReaderState -> TypedTree.ValMemberInfo - val u_tycon_objmodel_kind: st:ReaderState -> TypedTree.TyconObjModelKind - val u_mustinline: st:ReaderState -> TypedTree.ValInline - val u_basethis: st:ReaderState -> TypedTree.ValBaseOrThisInfo - val u_vrefFlags: st:ReaderState -> TypedTree.ValUseFlag - val u_ValData: st:ReaderState -> TypedTree.Val - val u_Val: st:ReaderState -> TypedTree.Val - val u_modul_typ: st:ReaderState -> TypedTree.ModuleOrNamespaceType - val p_const: (TypedTree.Const -> WriterState -> unit) - val u_const: (ReaderState -> TypedTree.Const) - val p_dtree: x:TypedTree.DecisionTree -> st:WriterState -> unit - val p_dtree_case: TypedTree.DecisionTreeCase -> st:WriterState -> unit - val p_dtree_discrim: x:TypedTree.DecisionTreeTest -> st:WriterState -> unit - val p_target: TypedTree.DecisionTreeTarget -> st:WriterState -> unit - val p_bind: TypedTree.Binding -> st:WriterState -> unit - val p_lval_op_kind: x:TypedTree.LValueOperation -> st:WriterState -> unit - val p_recdInfo: - x:TypedTree.RecordConstructionInfo -> st:WriterState -> unit - val u_dtree: st:ReaderState -> TypedTree.DecisionTree - val u_dtree_case: st:ReaderState -> TypedTree.DecisionTreeCase - val u_dtree_discrim: st:ReaderState -> TypedTree.DecisionTreeTest - val u_target: st:ReaderState -> TypedTree.DecisionTreeTarget - val u_bind: st:ReaderState -> TypedTree.Binding - val u_lval_op_kind: st:ReaderState -> TypedTree.LValueOperation - val p_op: x:TypedTree.TOp -> st:WriterState -> unit - val u_op: st:ReaderState -> TypedTree.TOp - val p_expr: (TypedTree.Expr -> WriterState -> unit) - val u_expr: (ReaderState -> TypedTree.Expr) - val p_static_optimization_constraint: - x:TypedTree.StaticOptimization -> st:WriterState -> unit - val p_slotparam: TypedTree.SlotParam -> st:WriterState -> unit - val p_slotsig: TypedTree.SlotSig -> st:WriterState -> unit - val p_method: TypedTree.ObjExprMethod -> st:WriterState -> unit - val p_methods: x:TypedTree.ObjExprMethod list -> st:WriterState -> unit - val p_intf: - TypedTree.TType * TypedTree.ObjExprMethod list -> st:WriterState -> unit - val p_intfs: - x:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> - st:WriterState -> unit - val u_static_optimization_constraint: - st:ReaderState -> TypedTree.StaticOptimization - val u_slotparam: st:ReaderState -> TypedTree.SlotParam - val u_slotsig: st:ReaderState -> TypedTree.SlotSig - val u_method: st:ReaderState -> TypedTree.ObjExprMethod - val u_methods: st:ReaderState -> TypedTree.ObjExprMethod list - val u_intf: - st:ReaderState -> TypedTree.TType * TypedTree.ObjExprMethod list - val u_intfs: - st:ReaderState -> (TypedTree.TType * TypedTree.ObjExprMethod list) list - val pickleModuleOrNamespace: - mspec:TypedTree.Entity -> st:WriterState -> unit - val pickleCcuInfo: (TypedTree.PickledCcuInfo -> WriterState -> unit) - val unpickleModuleOrNamespace: st:ReaderState -> TypedTree.Tycon - val unpickleCcuInfo: ReaderState -> TypedTree.PickledCcuInfo - - -namespace FSharp.Compiler - module internal Import = - type AssemblyLoader = - interface - abstract member - FindCcuFromAssemblyRef: AbstractIL.Internal.Library.CompilationThreadToken * - Range.range * AbstractIL.IL.ILAssemblyRef -> - TypedTree.CcuResolutionResult - abstract member - GetProvidedAssemblyInfo: AbstractIL.Internal.Library.CompilationThreadToken * - Range.range * - Tainted -> - bool * - ExtensionTyping.ProvidedAssemblyStaticLinkingMap option - abstract member - RecordGeneratedTypeRoot: ExtensionTyping.ProviderGeneratedType -> - unit - - [] - type ImportMap = - - new: g:TcGlobals.TcGlobals * assemblyLoader:AssemblyLoader -> ImportMap - member - ILTypeRefToTyconRefCache: System.Collections.Concurrent.ConcurrentDictionary - member assemblyLoader: AssemblyLoader - member g: TcGlobals.TcGlobals - - val CanImportILScopeRef: - env:ImportMap -> m:Range.range -> scoref:AbstractIL.IL.ILScopeRef -> bool - val ImportTypeRefData: - env:ImportMap -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef * path:string [] * - typeName:System.String -> TypedTree.EntityRef - val ImportILTypeRefUncached: - env:ImportMap -> - m:Range.range -> tref:AbstractIL.IL.ILTypeRef -> TypedTree.EntityRef - val ImportILTypeRef: - ImportMap -> Range.range -> AbstractIL.IL.ILTypeRef -> TypedTree.TyconRef - val CanImportILTypeRef: - ImportMap -> Range.range -> AbstractIL.IL.ILTypeRef -> bool - val ImportTyconRefApp: - env:ImportMap -> - tcref:TypedTree.EntityRef -> - tyargs:TypedTree.TType list -> TypedTree.TType - val ImportILType: - ImportMap -> - Range.range -> - TypedTree.TType list -> AbstractIL.IL.ILType -> TypedTree.TType - val CanImportILType: - ImportMap -> Range.range -> AbstractIL.IL.ILType -> bool - val ImportProvidedNamedType: - ImportMap -> - Range.range -> - Tainted -> TypedTree.TyconRef - val ImportProvidedTypeAsILType: - ImportMap -> - Range.range -> - Tainted -> AbstractIL.IL.ILType - val ImportProvidedType: - ImportMap -> - Range.range -> Tainted -> TypedTree.TType - val ImportProvidedMethodBaseAsILMethodRef: - ImportMap -> - Range.range -> - Tainted -> - AbstractIL.IL.ILMethodRef - val ImportILGenericParameters: - (unit -> ImportMap) -> - Range.range -> - AbstractIL.IL.ILScopeRef -> - TypedTree.TType list -> - AbstractIL.IL.ILGenericParameterDefs -> TypedTree.Typar list - val multisetDiscriminateAndMap: - nodef:('Key -> ('Key list * 'Value) list -> 'a) -> - tipf:('Value -> 'a) -> items:('Key list * 'Value) list -> 'a list - when 'Key: equality - val ImportILTypeDef: - amap:(unit -> ImportMap) -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef -> - cpath:TypedTree.CompilationPath -> - enc:AbstractIL.IL.ILTypeDef list -> - nm:string -> tdef:AbstractIL.IL.ILTypeDef -> TypedTree.Entity - val ImportILTypeDefList: - amap:(unit -> ImportMap) -> - m:Range.range -> - cpath:TypedTree.CompilationPath -> - enc:AbstractIL.IL.ILTypeDef list -> - items:(string list * - (string * - Lazy)) list -> - TypedTree.ModuleOrNamespaceType - val ImportILTypeDefs: - amap:(unit -> ImportMap) -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef -> - cpath:TypedTree.CompilationPath -> - enc:AbstractIL.IL.ILTypeDef list -> - tdefs:AbstractIL.IL.ILTypeDefs -> - TypedTree.ModuleOrNamespaceType - val ImportILAssemblyMainTypeDefs: - amap:(unit -> ImportMap) -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef -> - modul:AbstractIL.IL.ILModuleDef -> TypedTree.ModuleOrNamespaceType - val ImportILAssemblyExportedType: - amap:(unit -> ImportMap) -> - m:Range.range -> - auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) -> - scoref:AbstractIL.IL.ILScopeRef -> - exportedType:AbstractIL.IL.ILExportedTypeOrForwarder -> - TypedTree.ModuleOrNamespaceType list - val ImportILAssemblyExportedTypes: - amap:(unit -> ImportMap) -> - m:Range.range -> - auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) -> - scoref:AbstractIL.IL.ILScopeRef -> - exportedTypes:AbstractIL.IL.ILExportedTypesAndForwarders -> - TypedTree.ModuleOrNamespaceType list - val ImportILAssemblyTypeDefs: - amap:(unit -> ImportMap) * m:Range.range * - auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) * - aref:AbstractIL.IL.ILAssemblyRef * mainmod:AbstractIL.IL.ILModuleDef -> - TypedTree.ModuleOrNamespaceType - val ImportILAssemblyTypeForwarders: - (unit -> ImportMap) * Range.range * - AbstractIL.IL.ILExportedTypesAndForwarders -> - Map<(string [] * string),Lazy> - val ImportILAssembly: - (unit -> ImportMap) * Range.range * - (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) * - AbstractIL.IL.ILScopeRef * sourceDir:string * filename:string option * - AbstractIL.IL.ILModuleDef * IEvent -> TypedTree.CcuThunk - - -namespace FSharp.Compiler - module internal Infos = - val ImportILType: - scoref:AbstractIL.IL.ILScopeRef -> - amap:Import.ImportMap -> - m:Range.range -> - importInst:TypedTree.TType list -> - ilty:AbstractIL.IL.ILType -> TypedTree.TType - val CanImportILType: - scoref:AbstractIL.IL.ILScopeRef -> - amap:Import.ImportMap -> - m:Range.range -> ilty:AbstractIL.IL.ILType -> bool - val isExnDeclTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val GetSuperTypeOfType: - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ty:TypedTree.TType -> TypedTree.TType option - val mkSystemCollectionsGenericIListTy: - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - [] - type SkipUnrefInterfaces = - | Yes - | No - val GetImmediateInterfacesOfType: - skipUnref:SkipUnrefInterfaces -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ty:TypedTree.TType -> TypedTree.TType list - [] - type AllowMultiIntfInstantiations = - | Yes - | No - val private FoldHierarchyOfTypeAux: - followInterfaces:bool -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - skipUnref:SkipUnrefInterfaces -> - visitor:(TypedTree.TType -> 'a -> 'a) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ty:TypedTree.TType -> acc:'a -> 'a - val FoldPrimaryHierarchyOfType: - f:(TypedTree.TType -> 'a -> 'a) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> acc:'a -> 'a - val FoldEntireHierarchyOfType: - f:(TypedTree.TType -> 'a -> 'a) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> acc:'a -> 'a - val IterateEntireHierarchyOfType: - f:(TypedTree.TType -> unit) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> unit - val ExistsInEntireHierarchyOfType: - f:(TypedTree.TType -> bool) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> bool - val SearchEntireHierarchyOfType: - f:(TypedTree.TType -> bool) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ty:TypedTree.TType -> TypedTree.TType option - val AllSuperTypesOfType: - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> TypedTree.TType list - val AllInterfacesOfType: - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> TypedTree.TType list - val HaveSameHeadType: - g:TcGlobals.TcGlobals -> - ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool - val HasHeadType: - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> ty2:TypedTree.TType -> bool - val ExistsSameHeadTypeInHierarchy: - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - typeToSearchFrom:TypedTree.TType -> - typeToLookFor:TypedTree.TType -> bool - val ExistsHeadTypeInEntireHierarchy: - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - typeToSearchFrom:TypedTree.TType -> - tcrefToLookFor:TypedTree.TyconRef -> bool - val ImportILTypeFromMetadata: - amap:Import.ImportMap -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef -> - tinst:TypedTree.TType list -> - minst:TypedTree.TType list -> - ilty:AbstractIL.IL.ILType -> TypedTree.TType - val ImportILTypeFromMetadataWithAttributes: - amap:Import.ImportMap -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef -> - tinst:TypedTree.TType list -> - minst:TypedTree.TType list -> - ilty:AbstractIL.IL.ILType -> - cattrs:AbstractIL.IL.ILAttributes -> TypedTree.TType - val ImportParameterTypeFromMetadata: - amap:Import.ImportMap -> - m:Range.range -> - ilty:AbstractIL.IL.ILType -> - cattrs:AbstractIL.IL.ILAttributes -> - scoref:AbstractIL.IL.ILScopeRef -> - tinst:TypedTree.TType list -> - mist:TypedTree.TType list -> TypedTree.TType - val ImportReturnTypeFromMetadata: - amap:Import.ImportMap -> - m:Range.range -> - ilty:AbstractIL.IL.ILType -> - cattrs:AbstractIL.IL.ILAttributes -> - scoref:AbstractIL.IL.ILScopeRef -> - tinst:TypedTree.TType list -> - minst:TypedTree.TType list -> TypedTree.TType option - val CopyTyparConstraints: - m:Range.range -> - tprefInst:TypedTreeOps.TyparInst -> - tporig:TypedTree.Typar -> TypedTree.TyparConstraint list - val FixupNewTypars: - m:Range.range -> - formalEnclosingTypars:TypedTree.Typars -> - tinst:TypedTree.TType list -> - tpsorig:TypedTree.Typars -> - tps:TypedTree.Typars -> TypedTreeOps.TyparInst * TypedTree.TTypes - type ValRef with - member IsFSharpEventProperty: g:TcGlobals.TcGlobals -> bool - type ValRef with - member IsVirtualMember: bool - type ValRef with - member IsDispatchSlotMember: bool - type ValRef with - member IsDefiniteFSharpOverrideMember: bool - type ValRef with - member - IsFSharpExplicitInterfaceImplementation: g:TcGlobals.TcGlobals -> bool - type ValRef with - member ImplementedSlotSignatures: TypedTree.SlotSig list - val GetCompiledReturnTyOfProvidedMethodInfo: - amap:Import.ImportMap -> - m:Range.range -> - mi:Tainted -> - TypedTree.TType option - val ReparentSlotSigToUseMethodTypars: - g:TcGlobals.TcGlobals -> - m:Range.range -> - ovByMethValRef:TypedTree.ValRef -> - slotsig:TypedTree.SlotSig -> TypedTree.SlotSig - val MakeSlotParam: - ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo -> TypedTree.SlotParam - val MakeSlotSig: - nm:string * ty:TypedTree.TType * ctps:TypedTree.Typars * - mtps:TypedTree.Typars * paraml:TypedTree.SlotParam list list * - retTy:TypedTree.TType option -> TypedTree.SlotSig - val private AnalyzeTypeOfMemberVal: - isCSharpExt:bool -> - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType * vref:TypedTree.ValRef -> - TypedTree.Typar list * TypedTree.Typars * TypedTree.TType option * - TypedTree.TType list - val private GetObjTypeOfInstanceExtensionMethod: - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> TypedTree.TType - val private GetArgInfosOfMember: - isCSharpExt:bool -> - g:TcGlobals.TcGlobals -> - vref:TypedTree.ValRef -> - (TypedTree.TType * TypedTree.ArgReprInfo) list list - val private CombineMethInsts: - ttps:TypedTree.Typars -> - mtps:TypedTree.Typars -> - tinst:TypedTree.TTypes -> - minst:TypedTree.TTypes -> (TypedTree.Typar * TypedTree.TType) list - val private GetInstantiationForMemberVal: - g:TcGlobals.TcGlobals -> - isCSharpExt:bool -> - ty:TypedTree.TType * vref:TypedTree.ValRef * - methTyArgs:TypedTree.TypeInst -> - (TypedTree.Typar * TypedTree.TType) list - val private GetInstantiationForPropertyVal: - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType * vref:TypedTree.ValRef -> - (TypedTree.Typar * TypedTree.TType) list - type ExtensionMethodPriority = uint64 - type OptionalArgCallerSideValue = - | Constant of AbstractIL.IL.ILFieldInit - | DefaultValue - | MissingValue - | WrapperForIDispatch - | WrapperForIUnknown - | PassByRef of TypedTree.TType * OptionalArgCallerSideValue - type OptionalArgInfo = - | NotOptional - | CalleeSide - | CallerSide of OptionalArgCallerSideValue - with - static member - FieldInitForDefaultParameterValueAttrib: attrib:TypedTree.Attrib -> - AbstractIL.IL.ILFieldInit option - static member - FromILParameter: g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - ilScope:AbstractIL.IL.ILScopeRef -> - ilTypeInst:TypedTree.TType list -> - ilParam:AbstractIL.IL.ILParameter -> - OptionalArgInfo - static member - ValueOfDefaultParameterValueAttrib: TypedTree.Attrib -> - TypedTree.Expr option - member IsOptional: bool - - type CallerInfo = - | NoCallerInfo - | CallerLineNumber - | CallerMemberName - | CallerFilePath - with - override ToString: unit -> string - - [] - type ReflectedArgInfo = - | None - | Quote of bool - with - member AutoQuote: bool - - [] - type ParamNameAndType = - | ParamNameAndType of SyntaxTree.Ident option * TypedTree.TType - with - static member - FromArgInfo: ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo -> - ParamNameAndType - static member - FromMember: isCSharpExtMem:bool -> - g:TcGlobals.TcGlobals -> - vref:TypedTree.ValRef -> ParamNameAndType list list - static member - Instantiate: inst:TypedTreeOps.TyparInst -> - p:ParamNameAndType -> ParamNameAndType - static member - InstantiateCurried: inst:TypedTreeOps.TyparInst -> - paramTypes:ParamNameAndType list list -> - ParamNameAndType list list - - [] - type ParamData = - | ParamData of - isParamArray: bool * isInArg: bool * isOut: bool * - optArgInfo: OptionalArgInfo * callerInfo: CallerInfo * - nameOpt: SyntaxTree.Ident option * reflArgInfo: ReflectedArgInfo * - ttype: TypedTree.TType - type ILFieldInit with - static member - FromProvidedObj: m:Range.range -> v:obj -> AbstractIL.IL.ILFieldInit - val OptionalArgInfoOfProvidedParameter: - amap:Import.ImportMap -> - m:Range.range -> - provParam:Tainted -> - OptionalArgInfo - val GetAndSanityCheckProviderMethod: - m:Range.range -> - mi:Tainted<'T> -> - get:('T -> ExtensionTyping.ProvidedMethodInfo) -> - err:(string * string -> int * string) -> - Tainted - when 'T:> ExtensionTyping.ProvidedMemberInfo - val ArbitraryMethodInfoOfPropertyInfo: - pi:Tainted -> - m:Range.range -> Tainted - [] - type ILTypeInfo = - | ILTypeInfo of - TcGlobals.TcGlobals * TypedTree.TType * AbstractIL.IL.ILTypeRef * - AbstractIL.IL.ILTypeDef - with - static member - FromType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> ILTypeInfo - member Instantiate: inst:TypedTreeOps.TyparInst -> ILTypeInfo - member ILScopeRef: AbstractIL.IL.ILScopeRef - member ILTypeRef: AbstractIL.IL.ILTypeRef - member IsValueType: bool - member Name: string - member RawMetadata: AbstractIL.IL.ILTypeDef - member TcGlobals: TcGlobals.TcGlobals - member ToAppType: TypedTree.TType - member ToType: TypedTree.TType - member TyconRefOfRawMetadata: TypedTree.TyconRef - member TypeInstOfRawMetadata: TypedTree.TypeInst - - [] - type ILMethInfo = - | ILMethInfo of - TcGlobals.TcGlobals * TypedTree.TType * TypedTree.TyconRef option * - AbstractIL.IL.ILMethodDef * TypedTree.Typars - with - member - GetCompiledReturnTy: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> - TypedTree.TType option - member - GetFSharpReturnTy: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> TypedTree.TType - member - GetObjArgTypes: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> TypedTree.TType list - member - GetParamNamesAndTypes: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> - ParamNameAndType list - member - GetParamTypes: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> TypedTree.TType list - member - GetRawArgTypes: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> TypedTree.TType list - member IsDllImport: g:TcGlobals.TcGlobals -> bool - member IsReadOnly: g:TcGlobals.TcGlobals -> bool - member ApparentEnclosingAppType: TypedTree.TType - member ApparentEnclosingType: TypedTree.TType - member DeclaringTyconRef: TypedTree.TyconRef - member DeclaringTypeInst: TypedTree.TType list - member FormalMethodTypars: TypedTree.Typars - member ILExtensionMethodDeclaringTyconRef: TypedTree.TyconRef option - member ILMethodRef: AbstractIL.IL.ILMethodRef - member ILName: string - member IsAbstract: bool - member IsClassConstructor: bool - member IsConstructor: bool - member IsFinal: bool - member IsILExtensionMethod: bool - member IsInstance: bool - member IsNewSlot: bool - member IsProtectedAccessibility: bool - member IsStatic: bool - member IsVirtual: bool - member MetadataScope: AbstractIL.IL.ILScopeRef - member NumParams: int - member ParamMetadata: AbstractIL.IL.ILParameter list - member RawMetadata: AbstractIL.IL.ILMethodDef - member TcGlobals: TcGlobals.TcGlobals - - [] - type MethInfo = - | FSMeth of - TcGlobals.TcGlobals * TypedTree.TType * TypedTree.ValRef * - ExtensionMethodPriority option - | ILMeth of - TcGlobals.TcGlobals * ILMethInfo * ExtensionMethodPriority option - | DefaultStructCtor of TcGlobals.TcGlobals * TypedTree.TType - | ProvidedMeth of - Import.ImportMap * Tainted * - ExtensionMethodPriority option * Range.range - with - static member - CreateILExtensionMeth: amap:Import.ImportMap * m:Range.range * - apparentTy:TypedTree.TType * - declaringTyconRef:TypedTree.TyconRef * - extMethPri:ExtensionMethodPriority option * - md:AbstractIL.IL.ILMethodDef -> MethInfo - static member - CreateILMeth: amap:Import.ImportMap * m:Range.range * - ty:TypedTree.TType * md:AbstractIL.IL.ILMethodDef -> - MethInfo - static member - MethInfosUseIdenticalDefinitions: x1:MethInfo -> x2:MethInfo -> bool - member - AdjustUserTypeInstForFSharpStyleIndexedExtensionMembers: tyargs:TypedTree.TType list -> - TypedTree.TType list - member ComputeHashCode: unit -> int - member - GetCompiledReturnTy: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> - TypedTree.TType option - member - GetFSharpReturnTy: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> TypedTree.TType - member - GetFormalTyparsOfDeclaringType: m:Range.range -> TypedTree.Typar list - member - GetObjArgTypes: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TypeInst -> TypedTree.TType list - member - GetParamAttribs: amap:Import.ImportMap * m:Range.range -> - (bool * bool * bool * OptionalArgInfo * CallerInfo * - ReflectedArgInfo) list list - member - GetParamDatas: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> ParamData list list - member - GetParamTypes: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> - TypedTree.TType list list - member - GetSlotSig: amap:Import.ImportMap * m:Range.range -> - TypedTree.SlotSig - member - HasParamArrayArg: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> bool - member - Instantiate: amap:Import.ImportMap * m:Range.range * - inst:TypedTreeOps.TyparInst -> MethInfo - member - IsReadOnlyExtensionMember: amap:Import.ImportMap * m:Range.range -> - bool - member - ObjArgNeedsAddress: amap:Import.ImportMap * m:Range.range -> bool - override ToString: unit -> string - member - TryObjArgByrefType: amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TypeInst -> - TypedTree.TType option - member ApparentEnclosingAppType: TypedTree.TType - member ApparentEnclosingTyconRef: TypedTree.TyconRef - member ApparentEnclosingType: TypedTree.TType - member ArbitraryValRef: TypedTree.ValRef option - member DebuggerDisplayName: string - member DeclaringTyconRef: TypedTree.TyconRef - member DeclaringTypeInst: TypedTree.TType list - member DisplayName: string - member ExtensionMemberPriority: ExtensionMethodPriority - member ExtensionMemberPriorityOption: ExtensionMethodPriority option - member FormalMethodInst: TypedTree.TypeInst - member FormalMethodTyparInst: TypedTreeOps.TyparInst - member FormalMethodTypars: TypedTree.Typars - member GenericArity: int - member HasDirectXmlComment: bool - member ImplementedSlotSignatures: TypedTree.SlotSig list - member IsAbstract: bool - member IsCSharpStyleExtensionMember: bool - member IsClassConstructor: bool - member IsConstructor: bool - member IsCurried: bool - member IsDefiniteFSharpOverride: bool - member IsDispatchSlot: bool - member IsExtensionMember: bool - member IsFSharpEventPropertyMethod: bool - member IsFSharpExplicitInterfaceImplementation: bool - member IsFSharpStyleExtensionMember: bool - member IsFinal: bool - member IsILMethod: bool - member IsInstance: bool - member IsNewSlot: bool - member IsNullary: bool - member IsProtectedAccessibility: bool - member IsReadOnly: bool - member IsStruct: bool - member IsVirtual: bool - member LogicalName: string - member NumArgs: int list - member - ProvidedStaticParameterInfo: (Tainted * - Tainted []) option - member TcGlobals: TcGlobals.TcGlobals - member XmlDoc: XmlDoc.XmlDoc - - [] - type ILFieldInfo = - | ILFieldInfo of ILTypeInfo * AbstractIL.IL.ILFieldDef - | ProvidedField of - Import.ImportMap * Tainted * - Range.range - with - static member - ILFieldInfosUseIdenticalDefinitions: x1:ILFieldInfo -> - x2:ILFieldInfo -> bool - member ComputeHashCode: unit -> int - member - FieldType: amap:Import.ImportMap * m:Range.range -> TypedTree.TType - override ToString: unit -> string - member ApparentEnclosingAppType: TypedTree.TType - member ApparentEnclosingTyconRef: TypedTree.TyconRef - member ApparentEnclosingType: TypedTree.TType - member DeclaringTyconRef: TypedTree.TyconRef - member FieldName: string - member ILFieldRef: AbstractIL.IL.ILFieldRef - member ILFieldType: AbstractIL.IL.ILType - member ILTypeRef: AbstractIL.IL.ILTypeRef - member IsInitOnly: bool - member IsSpecialName: bool - member IsStatic: bool - member IsValueType: bool - member LiteralValue: AbstractIL.IL.ILFieldInit option - member ScopeRef: AbstractIL.IL.ILScopeRef - member TcGlobals: TcGlobals.TcGlobals - member TypeInst: TypedTree.TypeInst - - [] - type RecdFieldInfo = - | RecdFieldInfo of TypedTree.TypeInst * TypedTree.RecdFieldRef - with - override ToString: unit -> string - member DeclaringType: TypedTree.TType - member FieldType: TypedTree.TType - member IsStatic: bool - member LiteralValue: TypedTree.Const option - member Name: string - member RecdField: TypedTree.RecdField - member RecdFieldRef: TypedTree.RecdFieldRef - member Tycon: TypedTree.Entity - member TyconRef: TypedTree.TyconRef - member TypeInst: TypedTree.TypeInst - - [] - type UnionCaseInfo = - | UnionCaseInfo of TypedTree.TypeInst * TypedTree.UnionCaseRef - with - member GetTyparInst: m:Range.range -> TypedTreeOps.TyparInst - override ToString: unit -> string - member Name: string - member Tycon: TypedTree.Entity - member TyconRef: TypedTree.TyconRef - member TypeInst: TypedTree.TypeInst - member UnionCase: TypedTree.UnionCase - member UnionCaseRef: TypedTree.UnionCaseRef - - [] - type ILPropInfo = - | ILPropInfo of ILTypeInfo * AbstractIL.IL.ILPropertyDef - with - member - GetParamNamesAndTypes: amap:Import.ImportMap * m:Range.range -> - ParamNameAndType list - member - GetParamTypes: amap:Import.ImportMap * m:Range.range -> - TypedTree.TType list - member - GetPropertyType: amap:Import.ImportMap * m:Range.range -> - TypedTree.TType - override ToString: unit -> string - member ApparentEnclosingAppType: TypedTree.TType - member ApparentEnclosingType: TypedTree.TType - member GetterMethod: ILMethInfo - member HasGetter: bool - member HasSetter: bool - member ILTypeInfo: ILTypeInfo - member IsNewSlot: bool - member IsStatic: bool - member IsVirtual: bool - member PropertyName: string - member RawMetadata: AbstractIL.IL.ILPropertyDef - member SetterMethod: ILMethInfo - member TcGlobals: TcGlobals.TcGlobals - - [] - type PropInfo = - | FSProp of - TcGlobals.TcGlobals * TypedTree.TType * TypedTree.ValRef option * - TypedTree.ValRef option - | ILProp of ILPropInfo - | ProvidedProp of - Import.ImportMap * Tainted * - Range.range - with - static member - PropInfosUseIdenticalDefinitions: x1:PropInfo -> x2:PropInfo -> bool - member ComputeHashCode: unit -> int - member - GetParamDatas: amap:Import.ImportMap * m:Range.range -> - ParamData list - member - GetParamNamesAndTypes: amap:Import.ImportMap * m:Range.range -> - ParamNameAndType list - member - GetParamTypes: amap:Import.ImportMap * m:Range.range -> - TypedTree.TType list - member - GetPropertyType: amap:Import.ImportMap * m:Range.range -> - TypedTree.TType - override ToString: unit -> string - member ApparentEnclosingAppType: TypedTree.TType - member ApparentEnclosingTyconRef: TypedTree.TyconRef - member ApparentEnclosingType: TypedTree.TType - member ArbitraryValRef: TypedTree.ValRef option - member DeclaringTyconRef: TypedTree.EntityRef - member DropGetter: PropInfo - member DropSetter: PropInfo - member GetterMethod: MethInfo - member HasDirectXmlComment: bool - member HasGetter: bool - member HasSetter: bool - member ImplementedSlotSignatures: TypedTree.SlotSig list - member IsDefiniteFSharpOverride: bool - member IsDispatchSlot: bool - member IsExtensionMember: bool - member IsFSharpEventProperty: bool - member IsFSharpExplicitInterfaceImplementation: bool - member IsIndexer: bool - member IsNewSlot: bool - member IsStatic: bool - member IsValueType: bool - member IsVirtualProperty: bool - member PropertyName: string - member SetterMethod: MethInfo - member TcGlobals: TcGlobals.TcGlobals - member XmlDoc: XmlDoc.XmlDoc - - [] - type ILEventInfo = - | ILEventInfo of ILTypeInfo * AbstractIL.IL.ILEventDef - with - override ToString: unit -> string - member AddMethod: ILMethInfo - member ApparentEnclosingAppType: TypedTree.TType - member ApparentEnclosingType: TypedTree.TType - member DeclaringTyconRef: TypedTree.TyconRef - member ILTypeInfo: ILTypeInfo - member IsStatic: bool - member Name: string - member RawMetadata: AbstractIL.IL.ILEventDef - member RemoveMethod: ILMethInfo - member TcGlobals: TcGlobals.TcGlobals - member TypeRef: AbstractIL.IL.ILTypeRef - - exception BadEventTransformation of Range.range - val private tyConformsToIDelegateEvent: - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val nonStandardEventError: nm:System.String -> m:Range.range -> exn - val FindDelegateTypeOfPropertyEvent: - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - nm:System.String -> - m:Range.range -> ty:TypedTree.TType -> TypedTree.TType - [] - type EventInfo = - | FSEvent of - TcGlobals.TcGlobals * PropInfo * TypedTree.ValRef * TypedTree.ValRef - | ILEvent of ILEventInfo - | ProvidedEvent of - Import.ImportMap * Tainted * - Range.range - with - static member - EventInfosUseIdenticalDefinitions: x1:EventInfo -> - x2:EventInfo -> bool - member ComputeHashCode: unit -> int - member - GetDelegateType: amap:Import.ImportMap * m:Range.range -> - TypedTree.TType - override ToString: unit -> string - member AddMethod: MethInfo - member ApparentEnclosingAppType: TypedTree.TType - member ApparentEnclosingTyconRef: TypedTree.TyconRef - member ApparentEnclosingType: TypedTree.TType - member ArbitraryValRef: TypedTree.ValRef option - member DeclaringTyconRef: TypedTree.EntityRef - member EventName: string - member HasDirectXmlComment: bool - member IsExtensionMember: bool - member IsStatic: bool - member IsValueType: bool - member RemoveMethod: MethInfo - member TcGlobals: TcGlobals.TcGlobals - member XmlDoc: XmlDoc.XmlDoc - - val stripByrefTy: - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - type CompiledSig = - | CompiledSig of - TypedTree.TType list list * TypedTree.TType option * TypedTree.Typars * - TypedTreeOps.TyparInst - val CompiledSigOfMeth: - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> m:Range.range -> minfo:MethInfo -> CompiledSig - val MethInfosEquivByPartialSig: - erasureFlag:TypedTreeOps.Erasure -> - ignoreFinal:bool -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool - val MethInfosEquivByNameAndPartialSig: - erasureFlag:TypedTreeOps.Erasure -> - ignoreFinal:bool -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool - val PropInfosEquivByNameAndPartialSig: - erasureFlag:TypedTreeOps.Erasure -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> pinfo:PropInfo -> pinfo2:PropInfo -> bool - val MethInfosEquivByNameAndSig: - erasureFlag:TypedTreeOps.Erasure -> - ignoreFinal:bool -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool - val PropInfosEquivByNameAndSig: - erasureFlag:TypedTreeOps.Erasure -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> pinfo:PropInfo -> pinfo2:PropInfo -> bool - val SettersOfPropInfos: - pinfos:PropInfo list -> (MethInfo * PropInfo option) list - val GettersOfPropInfos: - pinfos:PropInfo list -> (MethInfo * PropInfo option) list - - namespace FSharp.Compiler module internal AccessibilityLogic = - [] + [] type AccessorDomain = | AccessibleFrom of TypedTree.CompilationPath list * TypedTree.TyconRef option @@ -9143,7 +625,7 @@ namespace FSharp.Compiler ty:TypedTree.TType -> AbstractIL.Internal.Library.NameMultiMap - [] + [] type SigOfFunctionForDelegate = | SigOfFunctionForDelegate of Infos.MethInfo * TypedTree.TType list * TypedTree.TType * @@ -10123,7 +1605,7 @@ namespace FSharp.Compiler TypedTree.ModuleOrNamespaceRef -> AbstractIL.Internal.Library.NameMap val ( |AbbrevOrAppTy|_| ): TypedTree.TType -> TypedTree.TyconRef option - [] type ArgumentContainer = | Method of Infos.MethInfo @@ -10131,7 +1613,7 @@ namespace FSharp.Compiler val emptyTypeInst: TypedTree.TypeInst type EnclosingTypeInst = TypedTree.TypeInst val emptyEnclosingTypeInst: EnclosingTypeInst - [] type Item = | Value of TypedTree.ValRef @@ -10197,7 +1679,7 @@ namespace FSharp.Compiler | FullyQualified | OpenQualified type UnqualifiedItems = AbstractIL.Internal.Library.LayeredMap - [] + [] type NameResolutionEnv = { eDisplayEnv: TypedTreeOps.DisplayEnv eUnqualifiedItems: UnqualifiedItems @@ -10378,7 +1860,7 @@ namespace FSharp.Compiler type TypeNameResolutionFlag = | ResolveTypeNamesToCtors | ResolveTypeNamesToTypeRefs - [] type TypeNameResolutionStaticArgsInfo = | Indefinite @@ -10391,7 +1873,7 @@ namespace FSharp.Compiler member NumStaticArgs: int static member DefiniteEmpty: TypeNameResolutionStaticArgsInfo - [] + [] type TypeNameResolutionInfo = | TypeNameResolutionInfo of TypeNameResolutionFlag * TypeNameResolutionStaticArgsInfo @@ -12169,7 +3651,7 @@ namespace FSharp.Compiler | Throw | Rethrow | FailFilter - [] + [] type Pattern = | TPat_const of TypedTree.Const * Range.range | TPat_wild of Range.range @@ -12578,7 +4060,7 @@ namespace FSharp.Compiler | TTraitSolvedAnonRecdProp of TypedTree.AnonRecdTypeInfo * TypedTree.TypeInst * int val BakedInTraitConstraintNames: Set - [] + [] type Trace = { mutable actions: ((unit -> unit) * (unit -> unit)) list } with @@ -14222,7 +5704,7 @@ namespace FSharp.Compiler safeThisValOpt: TypedTree.Val option safeInitInfo: SafeInitData ctorIsImplicit: bool } - [] + [] type UngeneralizableItem = new: computeFreeTyvars:(unit -> TypedTree.FreeTyvars) -> @@ -14232,7 +5714,7 @@ namespace FSharp.Compiler member CachedFreeTraitSolutions: TypedTree.FreeLocals member WillNeverHaveFreeTypars: bool - [] + [] type TcEnv = { eNameResEnv: NameResolution.NameResolutionEnv eUngeneralizableItems: UngeneralizableItem list @@ -14308,7 +5790,7 @@ namespace FSharp.Compiler n:string -> UnscopedTyparEnv -> TypedTree.Typar option val HideUnscopedTypars: typars:TypedTree.Typar list -> UnscopedTyparEnv -> UnscopedTyparEnv - [] + [] type TcFileState = { g: TcGlobals.TcGlobals mutable recUses: @@ -18937,7 +10419,7 @@ namespace FSharp.Compiler envPackM:AbstractIL.Internal.Zmap<'a,PackedReqdItems> -> AbstractIL.Internal.Zmap module Pass4_RewriteAssembly = - [] + [] type RewriteContext = { ccu: TypedTree.CcuThunk g: TcGlobals.TcGlobals @@ -19239,7 +10721,7 @@ namespace FSharp.Compiler type IlxGenBackend = | IlWriteBackend | IlReflectBackend - [] + [] type IlxGenOptions = { fragName: string generateFilterBlocks: bool @@ -19253,7 +10735,7 @@ namespace FSharp.Compiler isInteractive: bool isInteractiveItExpr: bool alwaysCallVirt: bool } - [] + [] type cenv = { g: TcGlobals.TcGlobals amap: Import.ImportMap @@ -19313,7 +10795,7 @@ namespace FSharp.Compiler val ComputeTypeAccess: tref:AbstractIL.IL.ILTypeRef -> hidden:bool -> AbstractIL.IL.ILTypeDefAccess - [] + [] type TypeReprEnv = new: reprs:Map * count:int -> TypeReprEnv @@ -19478,7 +10960,7 @@ namespace FSharp.Compiler m:Range.range -> tyenv:TypeReprEnv -> ecref:TypedTree.TyconRef -> AbstractIL.IL.ILType type ArityInfo = int list - [] + [] type IlxClosureInfo = { cloExpr: TypedTree.Expr cloName: string @@ -19496,7 +10978,7 @@ namespace FSharp.Compiler localTypeFuncContractFreeTypars: TypedTree.Typar list localTypeFuncDirectILGenericParams: AbstractIL.IL.ILGenericParameterDefs localTypeFuncInternalFreeTypars: TypedTree.Typar list } - [] + [] type ValStorage = | Null | StaticField of @@ -21541,7 +13023,7 @@ namespace FSharp.Compiler Map static member StripDependencyManagerKey: string -> string -> string - [] + [] type TcConfigBuilder = { mutable primaryAssembly: AbstractIL.IL.PrimaryAssembly mutable noFeedback: bool @@ -23290,7 +14772,7 @@ namespace FSharp.Compiler dependentILModules:(TypedTree.CcuThunk option * AbstractIL.IL.ILModuleDef) list -> AbstractIL.IL.ILModuleDef * (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILScopeRef) - [] + [] type Node = { name: string data: AbstractIL.IL.ILModuleDef @@ -23487,7 +14969,7 @@ namespace FSharp.Compiler attribName:System.String -> attribs:TypedTree.Attribs -> deterministic:bool -> AbstractIL.IL.ILVersionInfo option - [] + [] type Args<'T> = | Args of 'T val main1: ctok:'a * argv:string [] * @@ -24236,7 +15718,7 @@ namespace FSharp.Compiler.SourceCodeServices MethodGenericParameters: System.Collections.Generic.IList member Name: string - [] + [] and FSharpGenericParameterMemberConstraint = new: cenv:SymbolEnv * info:TypedTree.TraitConstraintInfo -> @@ -24248,7 +15730,7 @@ namespace FSharp.Compiler.SourceCodeServices member MemberReturnType: FSharpType member MemberSources: System.Collections.Generic.IList - [] + [] and FSharpGenericParameterDelegateConstraint = new: cenv:SymbolEnv * tupledArgTy:TypedTree.TType * rty:TypedTree.TType -> @@ -24257,7 +15739,7 @@ namespace FSharp.Compiler.SourceCodeServices member DelegateReturnType: FSharpType member DelegateTupledArgumentType: FSharpType - [] + [] and FSharpGenericParameterDefaultsToConstraint = new: cenv:SymbolEnv * pri:int * ty:TypedTree.TType -> @@ -24266,7 +15748,7 @@ namespace FSharp.Compiler.SourceCodeServices member DefaultsToPriority: int member DefaultsToTarget: FSharpType - [] + [] and FSharpGenericParameterConstraint = new: cenv:SymbolEnv * cx:TypedTree.TyparConstraint -> @@ -25064,7 +16546,7 @@ namespace FSharp.Compiler.SourceCodeServices action:(AbstractIL.Internal.Library.CompilationThreadToken -> unit) -> unit - [] + [] type internal ReactorCommands = | SetBackgroundOp of (string * string * string * @@ -25277,7 +16759,7 @@ namespace FSharp.Compiler member FileName: string - [] + [] type TcInfo = { tcState: ParseAndCheckInputs.TcState tcEnvAtEndOfFile: CheckExpressions.TcEnv @@ -25293,7 +16775,7 @@ namespace FSharp.Compiler TcErrors: (ErrorLogger.PhasedDiagnostic * SourceCodeServices.FSharpErrorSeverity) [] - [] + [] type TcInfoOptional = { tcResolutionsRev: NameResolution.TcResolutions list tcSymbolUsesRev: NameResolution.TcSymbolUses list @@ -25305,7 +16787,7 @@ namespace FSharp.Compiler with member TcSymbolUses: NameResolution.TcSymbolUses list - [] + [] type TcInfoState = | PartialState of TcInfo | FullState of TcInfo * TcInfoOptional @@ -25675,7 +17157,7 @@ namespace FSharp.Compiler.SourceCodeServices member Items: FSharpDeclarationListItem [] static member Empty: FSharpDeclarationListInfo - [] + [] type FSharpMethodGroupItem = new: description:FSharpToolTipText * xmlDoc:FSharpXmlDoc * @@ -25827,7 +17309,7 @@ namespace FSharp.Compiler.SourceCodeServices Parser.token -> FSharpTokenColorKind * FSharpTokenCharKind * FSharpTokenTriggerClass - [] + [] type FSharpTokenizerLexState = { PosBits: int64 OtherBits: int64 } @@ -26144,7 +17626,7 @@ namespace FSharp.Compiler.SourceCodeServices | InfixLsr | InfixLxor | InfixMod - [] type FSharpSyntaxToken = @@ -26370,7 +17852,7 @@ namespace FSharp.Compiler.SourceCodeServices member UniqueName: string member bodyRange: Range.range - [] + [] type FSharpNavigationTopLevelDeclaration = { Declaration: FSharpNavigationDeclarationItem Nested: FSharpNavigationDeclarationItem [] } @@ -26641,7 +18123,7 @@ namespace FSharp.Compiler.SourceCodeServices type LookupType = | Fuzzy | Precise - [] + [] type AssemblySymbol = { FullName: string CleanedIdents: Idents @@ -26680,7 +18162,7 @@ namespace FSharp.Compiler.SourceCodeServices { FileWriteTime: System.DateTime ContentType: AssemblyContentType Symbols: AssemblySymbol list } - [] + [] type IAssemblyContentCache = interface abstract member Set: AssemblyPath -> AssemblyContentCacheEntry -> unit @@ -26917,8 +18399,8 @@ namespace FSharp.Compiler.SourceCodeServices | DeclNotFound of FSharpFindDeclFailureReason | DeclFound of Range.range | ExternalDecl of assembly: string * externalSym: ExternalSymbol - [] + [] type internal NameResResult = | Members of (NameResolution.ItemWithInst list * TypedTreeOps.DisplayEnv * Range.range) @@ -27234,7 +18716,7 @@ namespace FSharp.Compiler.SourceCodeServices member PartialAssemblySignature: FSharpAssemblySignature member ProjectContext: FSharpProjectContext - [] + [] and FSharpCheckFileAnswer = | Aborted | Succeeded of FSharpCheckFileResults @@ -27327,7 +18809,7 @@ namespace FSharp.Compiler.SourceCodeServices member ProjectDirectory: string member ProjectOptions: string [] - [] + [] type IsResultObsolete = | IsResultObsolete of (unit -> bool) module Helpers = val AreSameForChecking2: @@ -27870,7 +19352,7 @@ namespace FSharp.Compiler.SourceCodeServices with override ToString: unit -> string - [] + [] type ScopeRange = { Scope: Scope Collapse: Collapse @@ -27881,7 +19363,7 @@ namespace FSharp.Compiler.SourceCodeServices type CommentType = | SingleLine | XmlDoc - [] + [] type CommentList = { Lines: ResizeArray Type: CommentType } @@ -28208,7 +19690,7 @@ namespace FSharp.Compiler.Interactive | Completed of FsiValue option | CompletedWithAlreadyReportedError | CompletedWithReportedError of exn - [] + [] type internal FsiDynamicCompilerState = { optEnv: Optimizer.IncrementalOptimizationEnv emEnv: AbstractIL.ILRuntimeWriter.emEnv diff --git a/src/fsharp/InfoReader.fs b/src/fsharp/InfoReader.fs index fd44eeb4b29..18345b408d6 100644 --- a/src/fsharp/InfoReader.fs +++ b/src/fsharp/InfoReader.fs @@ -625,8 +625,6 @@ let rec GetIntrinsicConstructorInfosOfTypeAux (infoReader: InfoReader) m origTy let GetIntrinsicConstructorInfosOfType infoReader m ty = GetIntrinsicConstructorInfosOfTypeAux infoReader m ty ty - - //------------------------------------------------------------------------- // Collecting methods and properties taking into account hiding rules in the hierarchy diff --git a/src/fsharp/InfoReader.fsi b/src/fsharp/InfoReader.fsi index fd44eeb4b29..5cfe9d95b4e 100644 --- a/src/fsharp/InfoReader.fsi +++ b/src/fsharp/InfoReader.fsi @@ -4,249 +4,47 @@ /// Select members from a type by name, searching the type hierarchy if needed module internal FSharp.Compiler.InfoReader -open System -open System.Collections.Generic -open System.Collections.Concurrent - open FSharp.Compiler -open FSharp.Compiler.AbstractIL.IL open FSharp.Compiler.AbstractIL.Internal.Library open FSharp.Compiler.AccessibilityLogic -open FSharp.Compiler.AttributeChecking -open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.Import open FSharp.Compiler.Infos open FSharp.Compiler.Range -open FSharp.Compiler.SyntaxTree open FSharp.Compiler.TypedTree -open FSharp.Compiler.TypedTreeOps open FSharp.Compiler.TcGlobals -open FSharp.Compiler.Features -open FSharp.Compiler.TypeRelations - -/// Use the given function to select some of the member values from the members of an F# type -let SelectImmediateMemberVals g optFilter f (tcref: TyconRef) = - let chooser (vref: ValRef) = - match vref.MemberInfo with - // The 'when' condition is a workaround for the fact that values providing - // override and interface implementations are published in inferred module types - // These cannot be selected directly via the "." notation. - // However, it certainly is useful to be able to publish these values, as we can in theory - // optimize code to make direct calls to these methods. - | Some membInfo when not (ValRefIsExplicitImpl g vref) -> - f membInfo vref - | _ -> - None - - match optFilter with - | None -> tcref.MembersOfFSharpTyconByName |> NameMultiMap.chooseRange chooser - | Some nm -> tcref.MembersOfFSharpTyconByName |> NameMultiMap.find nm |> List.choose chooser - -/// Check whether a name matches an optional filter -let private checkFilter optFilter (nm: string) = match optFilter with None -> true | Some n2 -> nm = n2 /// Try to select an F# value when querying members, and if so return a MethInfo that wraps the F# value. -let TrySelectMemberVal g optFilter ty pri _membInfo (vref: ValRef) = - if checkFilter optFilter vref.LogicalName then - Some(FSMeth(g, ty, vref, pri)) - else - None - -let rec GetImmediateIntrinsicMethInfosOfTypeAux (optFilter, ad) g amap m origTy metadataTy = - - let minfos = - match metadataOfTy g metadataTy with -#if !NO_EXTENSIONTYPING - | ProvidedTypeMetadata info -> - let st = info.ProvidedType - let meths = - match optFilter with - | Some name -> st.PApplyArray ((fun st -> st.GetMethods() |> Array.filter (fun mi -> mi.Name = name) ), "GetMethods", m) - | None -> st.PApplyArray ((fun st -> st.GetMethods()), "GetMethods", m) - [ for mi in meths -> ProvidedMeth(amap, mi.Coerce(m), None, m) ] -#endif - | ILTypeMetadata _ -> - let tinfo = ILTypeInfo.FromType g origTy - let mdefs = tinfo.RawMetadata.Methods - let mdefs = match optFilter with None -> mdefs.AsList | Some nm -> mdefs.FindByName nm - mdefs |> List.map (fun mdef -> MethInfo.CreateILMeth(amap, m, origTy, mdef)) - - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> - // Tuple types also support the methods get_Item1-8, get_Rest from the compiled tuple type. - // In this case convert to the .NET Tuple type that carries metadata and try again - if isAnyTupleTy g metadataTy then - let betterMetadataTy = convertToTypeWithMetadataIfPossible g metadataTy - GetImmediateIntrinsicMethInfosOfTypeAux (optFilter, ad) g amap m origTy betterMetadataTy - // Function types support methods FSharpFunc<_, _>.FromConverter and friends from .NET metadata, - // but not instance methods (you can't write "f.Invoke(x)", you have to write "f x") - elif isFunTy g metadataTy then - let betterMetadataTy = convertToTypeWithMetadataIfPossible g metadataTy - GetImmediateIntrinsicMethInfosOfTypeAux (optFilter, ad) g amap m origTy betterMetadataTy - |> List.filter (fun minfo -> not minfo.IsInstance) - else - match tryTcrefOfAppTy g metadataTy with - | ValueNone -> [] - | ValueSome tcref -> - SelectImmediateMemberVals g optFilter (TrySelectMemberVal g optFilter origTy None) tcref - let minfos = minfos |> List.filter (IsMethInfoAccessible amap m ad) - minfos +val TrySelectMemberVal: g:TcGlobals -> optFilter:string option -> ty:TType -> pri:ExtensionMethodPriority option -> _membInfo:'a -> vref:ValRef -> MethInfo option /// Query the immediate methods of an F# type, not taking into account inherited methods. The optFilter /// parameter is an optional name to restrict the set of properties returned. -let GetImmediateIntrinsicMethInfosOfType (optFilter, ad) g amap m ty = - GetImmediateIntrinsicMethInfosOfTypeAux (optFilter, ad) g amap m ty ty +val GetImmediateIntrinsicMethInfosOfType: optFilter:string option * ad:AccessorDomain -> g:TcGlobals -> amap:ImportMap -> m:range -> ty:TType -> MethInfo list /// A helper type to help collect properties. /// /// Join up getters and setters which are not associated in the F# data structure -type PropertyCollector(g, amap, m, ty, optFilter, ad) = - - let hashIdentity = - HashIdentity.FromFunctions - (fun (pinfo: PropInfo) -> hash pinfo.PropertyName) - (fun pinfo1 pinfo2 -> - pinfo1.IsStatic = pinfo2.IsStatic && - PropInfosEquivByNameAndPartialSig EraseNone g amap m pinfo1 pinfo2 && - pinfo1.IsDefiniteFSharpOverride = pinfo2.IsDefiniteFSharpOverride ) - - let props = new ConcurrentDictionary(hashIdentity) - - let add pinfo = - match props.TryGetValue pinfo, pinfo with - | (true, FSProp (_, ty, Some vref1, _)), FSProp (_, _, _, Some vref2) - | (true, FSProp (_, ty, _, Some vref2)), FSProp (_, _, Some vref1, _) -> - let pinfo = FSProp (g, ty, Some vref1, Some vref2) - props.[pinfo] <- pinfo - | (true, _), _ -> - // This assert fires while editing bad code. We will give a warning later in check.fs - //assert ("unexpected case"= "") - () - | _ -> - props.[pinfo] <- pinfo - - member x.Collect(membInfo: ValMemberInfo, vref: ValRef) = - match membInfo.MemberFlags.MemberKind with - | MemberKind.PropertyGet -> - let pinfo = FSProp(g, ty, Some vref, None) - if checkFilter optFilter vref.PropertyName && IsPropInfoAccessible g amap m ad pinfo then - add pinfo - | MemberKind.PropertySet -> - let pinfo = FSProp(g, ty, None, Some vref) - if checkFilter optFilter vref.PropertyName && IsPropInfoAccessible g amap m ad pinfo then - add pinfo - | _ -> - () - - member x.Close() = [ for KeyValue(_, pinfo) in props -> pinfo ] - -let rec GetImmediateIntrinsicPropInfosOfTypeAux (optFilter, ad) g amap m origTy metadataTy = - - let pinfos = - match metadataOfTy g metadataTy with -#if !NO_EXTENSIONTYPING - | ProvidedTypeMetadata info -> - let st = info.ProvidedType - let matchingProps = - match optFilter with - | Some name -> - match st.PApply((fun st -> st.GetProperty name), m) with - | Tainted.Null -> [||] - | pi -> [|pi|] - | None -> - st.PApplyArray((fun st -> st.GetProperties()), "GetProperties", m) - matchingProps - |> Seq.map(fun pi -> ProvidedProp(amap, pi, m)) - |> List.ofSeq -#endif - - | ILTypeMetadata _ -> - let tinfo = ILTypeInfo.FromType g origTy - let pdefs = tinfo.RawMetadata.Properties - let pdefs = match optFilter with None -> pdefs.AsList | Some nm -> pdefs.LookupByName nm - pdefs |> List.map (fun pdef -> ILProp(ILPropInfo(tinfo, pdef))) - - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> - // Tuple types also support the properties Item1-8, Rest from the compiled tuple type - // In this case convert to the .NET Tuple type that carries metadata and try again - if isAnyTupleTy g metadataTy || isFunTy g metadataTy then - let betterMetadataTy = convertToTypeWithMetadataIfPossible g metadataTy - GetImmediateIntrinsicPropInfosOfTypeAux (optFilter, ad) g amap m origTy betterMetadataTy - else - match tryTcrefOfAppTy g metadataTy with - | ValueNone -> [] - | ValueSome tcref -> - let propCollector = new PropertyCollector(g, amap, m, origTy, optFilter, ad) - SelectImmediateMemberVals g None (fun membInfo vref -> propCollector.Collect(membInfo, vref); None) tcref |> ignore - propCollector.Close() - - let pinfos = pinfos |> List.filter (IsPropInfoAccessible g amap m ad) - pinfos - +type PropertyCollector = + new: g:TcGlobals * amap:ImportMap * m:range * ty:TType * optFilter:string option * ad:AccessorDomain -> PropertyCollector + member Close: unit -> PropInfo list + member Collect: membInfo:ValMemberInfo * vref:ValRef -> unit + /// Query the immediate properties of an F# type, not taking into account inherited properties. The optFilter /// parameter is an optional name to restrict the set of properties returned. -let rec GetImmediateIntrinsicPropInfosOfType (optFilter, ad) g amap m ty = - GetImmediateIntrinsicPropInfosOfTypeAux (optFilter, ad) g amap m ty ty - -// Checks whether the given type has an indexer property. -let IsIndexerType g amap ty = - isArray1DTy g ty || - isListTy g ty || - match tryTcrefOfAppTy g ty with - | ValueSome tcref -> - let _, entityTy = generalizeTyconRef tcref - let props = GetImmediateIntrinsicPropInfosOfType (None, AccessibleFromSomeFSharpCode) g amap range0 entityTy - props |> List.exists (fun x -> x.PropertyName = "Item") - | ValueNone -> false +val GetImmediateIntrinsicPropInfosOfType: optFilter:string option * ad:AccessorDomain -> g:TcGlobals -> amap:ImportMap -> m:range -> ty:TType -> PropInfo list + +/// Checks whether the given type has an indexer property. +val IsIndexerType: g:TcGlobals -> amap:ImportMap -> ty:TType -> bool /// Get the items that are considered the most specific in the hierarchy out of the given items by type. -/// REVIEW: Note complexity O(N^2) -let GetMostSpecificItemsByType g amap f xs = - [ for x in xs do - match f x with - | None -> () - | Some (xTy, m) -> - let isEqual = - xs - |> List.forall (fun y -> - match f y with - | None -> true - | Some (yTy, _) -> - if typeEquiv g xTy yTy then true - else not (TypeFeasiblySubsumesType 0 g amap m xTy CanCoerce yTy)) - if isEqual then - yield x ] - -/// Finds the most specific methods from a method collection by a given method's signature. -let GetMostSpecificMethodInfosByMethInfoSig g amap m (ty, minfo) minfos = - minfos - |> GetMostSpecificItemsByType g amap (fun (ty2, minfo2) -> - let isEqual = - typeEquiv g ty ty2 && - MethInfosEquivByPartialSig EraseNone true g amap m minfo minfo2 - if isEqual then - Some(minfo2.ApparentEnclosingType, m) - else - None) +val GetMostSpecificItemsByType: g:TcGlobals -> amap:ImportMap -> f:('a -> (TType * range) option) -> xs:'a list -> 'a list /// From the given method sets, filter each set down to the most specific ones. -let FilterMostSpecificMethInfoSets g amap m (minfoSets: NameMultiMap<_>) : NameMultiMap<_> = - minfoSets - |> Map.map (fun _ minfos -> - ([], minfos) - ||> List.fold (fun minfoSpecifics (ty, minfo) -> - let alreadySeen = - minfoSpecifics - |> List.exists (fun (tySpecific, minfoSpecific) -> - typeEquiv g ty tySpecific && - MethInfosEquivByPartialSig EraseNone true g amap m minfo minfoSpecific) - if alreadySeen then - minfoSpecifics - else - GetMostSpecificMethodInfosByMethInfoSig g amap m (ty, minfo) minfos @ minfoSpecifics)) +val FilterMostSpecificMethInfoSets: g:TcGlobals -> amap:ImportMap -> m:range -> minfoSets:NameMultiMap -> NameMultiMap /// Sets of methods up the hierarchy, ignoring duplicates by name and sig. /// Used to collect sets of virtual methods, protected methods, protected /// properties etc. -type HierarchyItem = +type HierarchyItem = | MethodItem of MethInfo list list | PropertyItem of PropInfo list list | RecdFieldItem of RecdFieldInfo @@ -255,677 +53,103 @@ type HierarchyItem = /// An InfoReader is an object to help us read and cache infos. /// We create one of these for each file we typecheck. -type InfoReader(g: TcGlobals, amap: Import.ImportMap) as this = +type InfoReader = /// Get the declared IL fields of a type, not including inherited fields - let GetImmediateIntrinsicILFieldsOfType (optFilter, ad) m ty = - let infos = - match metadataOfTy g ty with -#if !NO_EXTENSIONTYPING - | ProvidedTypeMetadata info -> - let st = info.ProvidedType - match optFilter with - | None -> - [ for fi in st.PApplyArray((fun st -> st.GetFields()), "GetFields", m) -> ProvidedField(amap, fi, m) ] - | Some name -> - match st.PApply ((fun st -> st.GetField name), m) with - | Tainted.Null -> [] - | fi -> [ ProvidedField(amap, fi, m) ] -#endif - | ILTypeMetadata _ -> - let tinfo = ILTypeInfo.FromType g ty - let fdefs = tinfo.RawMetadata.Fields - let fdefs = match optFilter with None -> fdefs.AsList | Some nm -> fdefs.LookupByName nm - fdefs |> List.map (fun pd -> ILFieldInfo(tinfo, pd)) - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> - [] - let infos = infos |> List.filter (IsILFieldInfoAccessible g amap m ad) - infos - - /// Get the declared events of a type, not including inherited events, and not including F#-declared CLIEvents - let ComputeImmediateIntrinsicEventsOfType (optFilter, ad) m ty = - let infos = - match metadataOfTy g ty with -#if !NO_EXTENSIONTYPING - | ProvidedTypeMetadata info -> - let st = info.ProvidedType - match optFilter with - | None -> - [ for ei in st.PApplyArray((fun st -> st.GetEvents()), "GetEvents", m) -> ProvidedEvent(amap, ei, m) ] - | Some name -> - match st.PApply ((fun st -> st.GetEvent name), m) with - | Tainted.Null -> [] - | ei -> [ ProvidedEvent(amap, ei, m) ] -#endif - | ILTypeMetadata _ -> - let tinfo = ILTypeInfo.FromType g ty - let edefs = tinfo.RawMetadata.Events - let edefs = match optFilter with None -> edefs.AsList | Some nm -> edefs.LookupByName nm - [ for edef in edefs do - let ileinfo = ILEventInfo(tinfo, edef) - if IsILEventInfoAccessible g amap m ad ileinfo then - yield ILEvent ileinfo ] - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> - [] - infos - - /// Make a reference to a record or class field - let MakeRecdFieldInfo g ty (tcref: TyconRef) fspec = - RecdFieldInfo(argsOfAppTy g ty, tcref.MakeNestedRecdFieldRef fspec) - - /// Get the F#-declared record fields or class 'val' fields of a type - let GetImmediateIntrinsicRecdOrClassFieldsOfType (optFilter, _ad) _m ty = - match tryTcrefOfAppTy g ty with - | ValueNone -> [] - | ValueSome tcref -> - // Note;secret fields are not allowed in lookups here, as we're only looking - // up user-visible fields in name resolution. - match optFilter with - | Some nm -> - match tcref.GetFieldByName nm with - | Some rfield when not rfield.IsCompilerGenerated -> [MakeRecdFieldInfo g ty tcref rfield] - | _ -> [] - | None -> - [ for fdef in tcref.AllFieldsArray do - if not fdef.IsCompilerGenerated then - yield MakeRecdFieldInfo g ty tcref fdef ] - - - /// The primitive reader for the method info sets up a hierarchy - let GetIntrinsicMethodSetsUncached ((optFilter, ad, allowMultiIntfInst), m, ty) = - FoldPrimaryHierarchyOfType (fun ty acc -> GetImmediateIntrinsicMethInfosOfType (optFilter, ad) g amap m ty :: acc) g amap m allowMultiIntfInst ty [] - - /// The primitive reader for the property info sets up a hierarchy - let GetIntrinsicPropertySetsUncached ((optFilter, ad, allowMultiIntfInst), m, ty) = - FoldPrimaryHierarchyOfType (fun ty acc -> GetImmediateIntrinsicPropInfosOfType (optFilter, ad) g amap m ty :: acc) g amap m allowMultiIntfInst ty [] - - let GetIntrinsicILFieldInfosUncached ((optFilter, ad), m, ty) = - FoldPrimaryHierarchyOfType (fun ty acc -> GetImmediateIntrinsicILFieldsOfType (optFilter, ad) m ty @ acc) g amap m AllowMultiIntfInstantiations.Yes ty [] - - let GetIntrinsicEventInfosUncached ((optFilter, ad), m, ty) = - FoldPrimaryHierarchyOfType (fun ty acc -> ComputeImmediateIntrinsicEventsOfType (optFilter, ad) m ty @ acc) g amap m AllowMultiIntfInstantiations.Yes ty [] - - let GetIntrinsicRecdOrClassFieldInfosUncached ((optFilter, ad), m, ty) = - FoldPrimaryHierarchyOfType (fun ty acc -> GetImmediateIntrinsicRecdOrClassFieldsOfType (optFilter, ad) m ty @ acc) g amap m AllowMultiIntfInstantiations.Yes ty [] - - let GetEntireTypeHierarchyUncached (allowMultiIntfInst, m, ty) = - FoldEntireHierarchyOfType (fun ty acc -> ty :: acc) g amap m allowMultiIntfInst ty [] - - let GetPrimaryTypeHierarchyUncached (allowMultiIntfInst, m, ty) = - FoldPrimaryHierarchyOfType (fun ty acc -> ty :: acc) g amap m allowMultiIntfInst ty [] - - /// The primitive reader for the named items up a hierarchy - let GetIntrinsicNamedItemsUncached ((nm, ad), m, ty) = - if nm = ".ctor" then None else // '.ctor' lookups only ever happen via constructor syntax - let optFilter = Some nm - FoldPrimaryHierarchyOfType (fun ty acc -> - let minfos = GetImmediateIntrinsicMethInfosOfType (optFilter, ad) g amap m ty - let pinfos = GetImmediateIntrinsicPropInfosOfType (optFilter, ad) g amap m ty - let finfos = GetImmediateIntrinsicILFieldsOfType (optFilter, ad) m ty - let einfos = ComputeImmediateIntrinsicEventsOfType (optFilter, ad) m ty - let rfinfos = GetImmediateIntrinsicRecdOrClassFieldsOfType (optFilter, ad) m ty - match acc with - | Some(MethodItem(inheritedMethSets)) when not (isNil minfos) -> Some(MethodItem (minfos :: inheritedMethSets)) - | _ when not (isNil minfos) -> Some(MethodItem ([minfos])) - | Some(PropertyItem(inheritedPropSets)) when not (isNil pinfos) -> Some(PropertyItem(pinfos :: inheritedPropSets)) - | _ when not (isNil pinfos) -> Some(PropertyItem([pinfos])) - | _ when not (isNil finfos) -> Some(ILFieldItem(finfos)) - | _ when not (isNil einfos) -> Some(EventItem(einfos)) - | _ when not (isNil rfinfos) -> - match rfinfos with - | [single] -> Some(RecdFieldItem(single)) - | _ -> failwith "Unexpected multiple fields with the same name" // Because an explicit name (i.e., nm) was supplied, there will be only one element at most. - | _ -> acc) - g amap m - AllowMultiIntfInstantiations.Yes - ty - None - - let GetImmediateIntrinsicOverrideMethodSetsOfType optFilter m (interfaceTys: TType list) ty acc = - match tryAppTy g ty with - | ValueSome (tcref, _) when tcref.IsILTycon && tcref.ILTyconRawMetadata.IsInterface -> - let mimpls = tcref.ILTyconRawMetadata.MethodImpls.AsList - let mdefs = tcref.ILTyconRawMetadata.Methods - - // MethodImpls contains a list of methods that override. - // OverrideBy is the method that does the overriding. - // Overrides is the method being overriden. - (acc, mimpls) - ||> List.fold (fun acc ilMethImpl -> - let overridesName = ilMethImpl.Overrides.MethodRef.Name - let overrideBy = ilMethImpl.OverrideBy - let canAccumulate = - match optFilter with - | None -> true - | Some name when name = overridesName -> true - | _ -> false - if canAccumulate then - match mdefs.TryFindInstanceByNameAndCallingSignature (overrideBy.Name, overrideBy.MethodRef.CallingSignature) with - | Some mdef -> - let overridesILTy = ilMethImpl.Overrides.DeclaringType - let overridesTyFullName = overridesILTy.TypeRef.FullName - let overridesTyOpt = - interfaceTys - |> List.tryPick (fun ty -> - match tryTcrefOfAppTy g ty with - | ValueSome tcref when tcref.IsILTycon && tcref.ILTyconRawMetadata.Name = overridesTyFullName -> - generalizedTyconRef tcref - |> Some - | _ -> - None) - match overridesTyOpt with - | Some overridesTy -> - NameMultiMap.add overridesName (overridesTy, MethInfo.CreateILMeth(amap, m, ty, mdef)) acc - | _ -> - acc - | _ -> - acc - else - acc) - | _ -> acc - - /// Visiting each type in the hierarchy and accumulate most specific methods that are the OverrideBy target from types. - let GetIntrinsicMostSpecificOverrideMethodSetsUncached ((optFilter, _ad, allowMultiIntfInst), m, ty) : NameMultiMap<_> = - let interfaceTys = - FoldPrimaryHierarchyOfType (fun ty acc -> - if isInterfaceTy g ty then ty :: acc - else acc) g amap m allowMultiIntfInst ty [] - - (NameMultiMap.Empty, interfaceTys) - ||> List.fold (fun acc ty -> GetImmediateIntrinsicOverrideMethodSetsOfType optFilter m interfaceTys ty acc) - |> FilterMostSpecificMethInfoSets g amap m - - /// Make a cache for function 'f' keyed by type (plus some additional 'flags') that only - /// caches computations for monomorphic types. - - let MakeInfoCache f (flagsEq : System.Collections.Generic.IEqualityComparer<_>) = - new MemoizationTable<_, _> - (compute=f, - // Only cache closed, monomorphic types (closed = all members for the type - // have been processed). Generic type instantiations could be processed if we had - // a decent hash function for these. - canMemoize=(fun (_flags, (_: range), ty) -> - match stripTyEqns g ty with - | TType_app(tcref, []) -> tcref.TypeContents.tcaug_closed - | _ -> false), - - keyComparer= - { new System.Collections.Generic.IEqualityComparer<_> with - member x.Equals((flags1, _, typ1), (flags2, _, typ2)) = - // Ignoring the ranges - that's OK. - flagsEq.Equals(flags1, flags2) && - match stripTyEqns g typ1, stripTyEqns g typ2 with - | TType_app(tcref1, []), TType_app(tcref2, []) -> tyconRefEq g tcref1 tcref2 - | _ -> false - member x.GetHashCode((flags, _, ty)) = - // Ignoring the ranges - that's OK. - flagsEq.GetHashCode flags + - (match stripTyEqns g ty with - | TType_app(tcref, []) -> hash tcref.LogicalName - | _ -> 0) }) - - let hashFlags0 = - { new System.Collections.Generic.IEqualityComparer<_> with - member x.GetHashCode((filter: string option, ad: AccessorDomain, _allowMultiIntfInst1)) = hash filter + AccessorDomain.CustomGetHashCode ad - member x.Equals((filter1, ad1, allowMultiIntfInst1), (filter2, ad2, allowMultiIntfInst2)) = - (filter1 = filter2) && AccessorDomain.CustomEquals(g, ad1, ad2) && allowMultiIntfInst1 = allowMultiIntfInst2 } - - let hashFlags1 = - { new System.Collections.Generic.IEqualityComparer<_> with - member x.GetHashCode((filter: string option, ad: AccessorDomain)) = hash filter + AccessorDomain.CustomGetHashCode ad - member x.Equals((filter1, ad1), (filter2, ad2)) = (filter1 = filter2) && AccessorDomain.CustomEquals(g, ad1, ad2) } - - let hashFlags2 = - { new System.Collections.Generic.IEqualityComparer<_> with - member x.GetHashCode((nm: string, ad: AccessorDomain)) = hash nm + AccessorDomain.CustomGetHashCode ad - member x.Equals((nm1, ad1), (nm2, ad2)) = (nm1 = nm2) && AccessorDomain.CustomEquals(g, ad1, ad2) } - - let methodInfoCache = MakeInfoCache GetIntrinsicMethodSetsUncached hashFlags0 - let propertyInfoCache = MakeInfoCache GetIntrinsicPropertySetsUncached hashFlags0 - let recdOrClassFieldInfoCache = MakeInfoCache GetIntrinsicRecdOrClassFieldInfosUncached hashFlags1 - let ilFieldInfoCache = MakeInfoCache GetIntrinsicILFieldInfosUncached hashFlags1 - let eventInfoCache = MakeInfoCache GetIntrinsicEventInfosUncached hashFlags1 - let namedItemsCache = MakeInfoCache GetIntrinsicNamedItemsUncached hashFlags2 - let mostSpecificOverrideMethodInfoCache = MakeInfoCache GetIntrinsicMostSpecificOverrideMethodSetsUncached hashFlags0 - - let entireTypeHierarchyCache = MakeInfoCache GetEntireTypeHierarchyUncached HashIdentity.Structural - let primaryTypeHierarchyCache = MakeInfoCache GetPrimaryTypeHierarchyUncached HashIdentity.Structural - - // Runtime feature support - - let isRuntimeFeatureSupported (infoReader: InfoReader) runtimeFeature = - match g.System_Runtime_CompilerServices_RuntimeFeature_ty with - | Some runtimeFeatureTy -> - infoReader.GetILFieldInfosOfType (None, AccessorDomain.AccessibleFromEverywhere, range0, runtimeFeatureTy) - |> List.exists (fun (ilFieldInfo: ILFieldInfo) -> ilFieldInfo.FieldName = runtimeFeature) - | _ -> - false - - let isRuntimeFeatureDefaultImplementationsOfInterfacesSupported = - lazy isRuntimeFeatureSupported this "DefaultImplementationsOfInterfaces" - - member x.g = g - member x.amap = amap - - /// Read the raw method sets of a type, including inherited ones. Cache the result for monomorphic types - member x.GetRawIntrinsicMethodSetsOfType (optFilter, ad, allowMultiIntfInst, m, ty) = - methodInfoCache.Apply(((optFilter, ad, allowMultiIntfInst), m, ty)) + new: g:TcGlobals * amap:ImportMap -> InfoReader - /// Read the raw property sets of a type, including inherited ones. Cache the result for monomorphic types - member x.GetRawIntrinsicPropertySetsOfType (optFilter, ad, allowMultiIntfInst, m, ty) = - propertyInfoCache.Apply(((optFilter, ad, allowMultiIntfInst), m, ty)) + /// Get the super-types of a type, including interface types. + member GetEntireTypeHierarchy: allowMultiIntfInst:AllowMultiIntfInstantiations * m:range * ty:TType -> TType list - /// Read the record or class fields of a type, including inherited ones. Cache the result for monomorphic types. - member x.GetRecordOrClassFieldsOfType (optFilter, ad, m, ty) = - recdOrClassFieldInfoCache.Apply(((optFilter, ad), m, ty)) + /// Read the events of a type, including inherited ones. Cache the result for monomorphic types. + member GetEventInfosOfType: optFilter:string option * ad:AccessorDomain * m:range * ty:TType -> EventInfo list /// Read the IL fields of a type, including inherited ones. Cache the result for monomorphic types. - member x.GetILFieldInfosOfType (optFilter, ad, m, ty) = - ilFieldInfoCache.Apply(((optFilter, ad), m, ty)) + member GetILFieldInfosOfType: optFilter:string option * ad:AccessorDomain * m:range * ty:TType -> ILFieldInfo list + member GetImmediateIntrinsicEventsOfType: optFilter:string option * ad:AccessorDomain * m:range * ty:TType -> EventInfo list - member x.GetImmediateIntrinsicEventsOfType (optFilter, ad, m, ty) = ComputeImmediateIntrinsicEventsOfType (optFilter, ad) m ty + /// Get the super-types of a type, excluding interface types. + member GetPrimaryTypeHierarchy: allowMultiIntfInst:AllowMultiIntfInstantiations * m:range * ty:TType -> TType list - /// Read the events of a type, including inherited ones. Cache the result for monomorphic types. - member x.GetEventInfosOfType (optFilter, ad, m, ty) = - eventInfoCache.Apply(((optFilter, ad), m, ty)) + /// Read the raw method sets of a type, including inherited ones. Cache the result for monomorphic types + member GetRawIntrinsicMethodSetsOfType: optFilter:string option * ad:AccessorDomain * allowMultiIntfInst:AllowMultiIntfInstantiations * m:range * ty:TType -> MethInfo list list - /// Try and find a record or class field for a type. - member x.TryFindRecdOrClassFieldInfoOfType (nm, m, ty) = - match recdOrClassFieldInfoCache.Apply((Some nm, AccessibleFromSomewhere), m, ty) with - | [] -> ValueNone - | [single] -> ValueSome single - | flds -> - // multiple fields with the same name can come from different classes, - // so filter them by the given type name - match tryTcrefOfAppTy g ty with - | ValueNone -> ValueNone - | ValueSome tcref -> - match flds |> List.filter (fun rfinfo -> tyconRefEq g tcref rfinfo.TyconRef) with - | [] -> ValueNone - | [single] -> ValueSome single - | _ -> failwith "unexpected multiple fields with same name" // Because it should have been already reported as duplicate fields - - /// Try and find an item with the given name in a type. - member x.TryFindNamedItemOfType (nm, ad, m, ty) = - namedItemsCache.Apply(((nm, ad), m, ty)) - - /// Read the raw method sets of a type that are the most specific overrides. Cache the result for monomorphic types - member x.GetIntrinsicMostSpecificOverrideMethodSetsOfType (optFilter, ad, allowMultiIntfInst, m, ty) = - mostSpecificOverrideMethodInfoCache.Apply(((optFilter, ad, allowMultiIntfInst), m, ty)) + /// Read the record or class fields of a type, including inherited ones. Cache the result for monomorphic types. + member GetRecordOrClassFieldsOfType: optFilter:string option * ad:AccessorDomain * m:range * ty:TType -> RecdFieldInfo list - /// Get the super-types of a type, including interface types. - member x.GetEntireTypeHierarchy (allowMultiIntfInst, m, ty) = - entireTypeHierarchyCache.Apply((allowMultiIntfInst, m, ty)) + /// Check if the given language feature is supported by the runtime. + member IsLanguageFeatureRuntimeSupported: langFeature:Features.LanguageFeature -> bool - /// Get the super-types of a type, excluding interface types. - member x.GetPrimaryTypeHierarchy (allowMultiIntfInst, m, ty) = - primaryTypeHierarchyCache.Apply((allowMultiIntfInst, m, ty)) + /// Try and find a record or class field for a type. + member TryFindRecdOrClassFieldInfoOfType: nm:string * m:range * ty:TType -> RecdFieldInfo voption + member amap: ImportMap + member g: TcGlobals + +val checkLanguageFeatureRuntimeError: infoReader:InfoReader -> langFeature:Features.LanguageFeature -> m:range -> unit - /// Check if the given language feature is supported by the runtime. - member x.IsLanguageFeatureRuntimeSupported langFeature = - match langFeature with - // Both default and static interface method consumption features are tied to the runtime support of DIMs. - | LanguageFeature.DefaultInterfaceMemberConsumption -> isRuntimeFeatureDefaultImplementationsOfInterfacesSupported.Value - | _ -> true - -let private tryLanguageFeatureRuntimeErrorAux (infoReader: InfoReader) langFeature m error = - if not (infoReader.IsLanguageFeatureRuntimeSupported langFeature) then - let featureStr = infoReader.g.langVersion.GetFeatureString langFeature - error (Error(FSComp.SR.chkFeatureNotRuntimeSupported featureStr, m)) - false - else - true - -let checkLanguageFeatureRuntimeError infoReader langFeature m = - tryLanguageFeatureRuntimeErrorAux infoReader langFeature m error |> ignore - -let checkLanguageFeatureRuntimeErrorRecover infoReader langFeature m = - tryLanguageFeatureRuntimeErrorAux infoReader langFeature m errorR |> ignore - -let tryLanguageFeatureRuntimeErrorRecover infoReader langFeature m = - tryLanguageFeatureRuntimeErrorAux infoReader langFeature m errorR +val checkLanguageFeatureRuntimeErrorRecover: infoReader:InfoReader -> langFeature:Features.LanguageFeature -> m:range -> unit + +val tryLanguageFeatureRuntimeErrorRecover: infoReader:InfoReader -> langFeature:Features.LanguageFeature -> m:range -> bool /// Get the declared constructors of any F# type -let rec GetIntrinsicConstructorInfosOfTypeAux (infoReader: InfoReader) m origTy metadataTy = - protectAssemblyExploration [] (fun () -> - let g = infoReader.g - let amap = infoReader.amap - match metadataOfTy g metadataTy with -#if !NO_EXTENSIONTYPING - | ProvidedTypeMetadata info -> - let st = info.ProvidedType - [ for ci in st.PApplyArray((fun st -> st.GetConstructors()), "GetConstructors", m) do - yield ProvidedMeth(amap, ci.Coerce(m), None, m) ] -#endif - | ILTypeMetadata _ -> - let tinfo = ILTypeInfo.FromType g origTy - tinfo.RawMetadata.Methods.FindByName ".ctor" - |> List.filter (fun md -> md.IsConstructor) - |> List.map (fun mdef -> MethInfo.CreateILMeth (amap, m, origTy, mdef)) - - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> - // Tuple types also support constructors. In this case convert to the .NET Tuple type that carries metadata and try again - // Function types also support constructors. In this case convert to the FSharpFunc type that carries metadata and try again - if isAnyTupleTy g metadataTy || isFunTy g metadataTy then - let betterMetadataTy = convertToTypeWithMetadataIfPossible g metadataTy - GetIntrinsicConstructorInfosOfTypeAux infoReader m origTy betterMetadataTy - else - match tryTcrefOfAppTy g metadataTy with - | ValueNone -> [] - | ValueSome tcref -> - tcref.MembersOfFSharpTyconByName - |> NameMultiMap.find ".ctor" - |> List.choose(fun vref -> - match vref.MemberInfo with - | Some membInfo when (membInfo.MemberFlags.MemberKind = MemberKind.Constructor) -> Some vref - | _ -> None) - |> List.map (fun x -> FSMeth(g, origTy, x, None)) - ) - -let GetIntrinsicConstructorInfosOfType infoReader m ty = - GetIntrinsicConstructorInfosOfTypeAux infoReader m ty ty - - - -//------------------------------------------------------------------------- -// Collecting methods and properties taking into account hiding rules in the hierarchy +val GetIntrinsicConstructorInfosOfType: infoReader:InfoReader -> m:range -> ty:TType -> MethInfo list - /// Indicates if we prefer overrides or abstract slots. type FindMemberFlag = /// Prefer items toward the top of the hierarchy, which we do if the items are virtual /// but not when resolving base calls. | IgnoreOverrides + /// Get overrides instead of abstract slots when measuring whether a class/interface implements all its required slots. | PreferOverrides -/// The input list is sorted from most-derived to least-derived type, so any System.Object methods -/// are at the end of the list. Return a filtered list where prior/subsequent members matching by name and -/// that are in the same equivalence class have been removed. We keep a name-indexed table to -/// be more efficient when we check to see if we've already seen a particular named method. -type private IndexedList<'T>(itemLists: 'T list list, itemsByName: NameMultiMap<'T>) = - - /// Get the item sets - member x.Items = itemLists - - /// Get the items with a particular name - member x.ItemsWithName(nm) = NameMultiMap.find nm itemsByName - - /// Add new items, extracting the names using the given function. - member x.AddItems(items, nmf) = IndexedList<'T>(items :: itemLists, List.foldBack (fun x acc -> NameMultiMap.add (nmf x) x acc) items itemsByName ) - - /// Get an empty set of items - static member Empty = IndexedList<'T>([], NameMultiMap.empty) - - /// Filter a set of new items to add according to the content of the list. Only keep an item - /// if it passes 'keepTest' for all matching items already in the list. - member x.FilterNewItems keepTest nmf itemsToAdd = - // Have we already seen an item with the same name and that is in the same equivalence class? - // If so, ignore this one. Note we can check against the original incoming 'ilist' because we are assuming that - // none the elements of 'itemsToAdd' are equivalent. - itemsToAdd |> List.filter (fun item -> List.forall (keepTest item) (x.ItemsWithName(nmf item))) - -/// Add all the items to the IndexedList, preferring the ones in the super-types. This is used to hide methods -/// in super classes and/or hide overrides of methods in subclasses. -/// -/// Assume no items in 'items' are equivalent according to 'equivTest'. This is valid because each step in a -/// .NET class hierarchy introduces a consistent set of methods, none of which hide each other within the -/// given set. This is an important optimization because it means we don't have filter for equivalence between the -/// large overload sets introduced by methods like System.WriteLine. -/// -/// Assume items can be given names by 'nmf', where two items with different names are -/// not equivalent. - -let private FilterItemsInSubTypesBasedOnItemsInSuperTypes nmf keepTest itemLists = - let rec loop itemLists = - match itemLists with - | [] -> IndexedList.Empty - | items :: itemsInSuperTypes -> - let ilist = loop itemsInSuperTypes - let itemsToAdd = ilist.FilterNewItems keepTest nmf items - ilist.AddItems(itemsToAdd, nmf) - (loop itemLists).Items - -/// Add all the items to the IndexedList, preferring the ones in the sub-types. -let private FilterItemsInSuperTypesBasedOnItemsInSubTypes nmf keepTest itemLists = - let rec loop itemLists (indexedItemsInSubTypes: IndexedList<_>) = - match itemLists with - | [] -> List.rev indexedItemsInSubTypes.Items - | items :: itemsInSuperTypes -> - let itemsToAdd = items |> List.filter (fun item -> keepTest item (indexedItemsInSubTypes.ItemsWithName(nmf item))) - let ilist = indexedItemsInSubTypes.AddItems(itemsToAdd, nmf) - loop itemsInSuperTypes ilist - - loop itemLists IndexedList.Empty - -let private ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes nmf equivTest itemLists = - FilterItemsInSuperTypesBasedOnItemsInSubTypes nmf (fun item1 items -> not (items |> List.exists (fun item2 -> equivTest item1 item2))) itemLists - -/// Filter the overrides of methods or properties, either keeping the overrides or keeping the dispatch slots. -let private FilterOverrides findFlag (isVirt:'a->bool, isNewSlot, isDefiniteOverride, isFinal, equivSigs, nmf:'a->string) items = - let equivVirts x y = isVirt x && isVirt y && equivSigs x y - - match findFlag with - | PreferOverrides -> - items - // For each F#-declared override, get rid of any equivalent abstract member in the same type - // This is because F# abstract members with default overrides give rise to two members with the - // same logical signature in the same type, e.g. - // type ClassType1() = - // abstract VirtualMethod1: string -> int - // default x.VirtualMethod1(s) = 3 - - |> List.map (fun items -> - let definiteOverrides = items |> List.filter isDefiniteOverride - items |> List.filter (fun item -> (isDefiniteOverride item || not (List.exists (equivVirts item) definiteOverrides)))) - - // only keep virtuals that are not signature-equivalent to virtuals in subtypes - |> ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes nmf equivVirts - | IgnoreOverrides -> - let equivNewSlots x y = isNewSlot x && isNewSlot y && equivSigs x y - items - // Remove any F#-declared overrides. These may occur in the same type as the abstract member (unlike with .NET metadata) - // Include any 'newslot' declared methods. - |> List.map (List.filter (fun x -> not (isDefiniteOverride x))) - - // Remove any virtuals that are signature-equivalent to virtuals in subtypes, except for newslots - // That is, keep if it's - /// (a) not virtual - // (b) is a new slot or - // (c) not equivalent - // We keep virtual finals around for error detection later on - |> FilterItemsInSubTypesBasedOnItemsInSuperTypes nmf (fun newItem priorItem -> - (isVirt newItem && isFinal newItem) || not (isVirt newItem) || isNewSlot newItem || not (equivVirts newItem priorItem) ) - - // Remove any abstract slots in supertypes that are (a) hidden by another newslot and (b) implemented - // We leave unimplemented ones around to give errors, e.g. for - // [] - // type PA() = - // abstract M : int -> unit - // - // [] - // type PB<'a>() = - // inherit PA() - // abstract M : 'a -> unit - // - // [] - // type PC() = - // inherit PB() - // // Here, PA.M and PB.M have the same signature, so PA.M is unimplementable. - // // REVIEW: in future we may give a friendly error at this point - // - // type PD() = - // inherit PC() - // override this.M(x: int) = () - - |> FilterItemsInSuperTypesBasedOnItemsInSubTypes nmf (fun item1 superTypeItems -> - not (isNewSlot item1 && - superTypeItems |> List.exists (equivNewSlots item1) && - superTypeItems |> List.exists (fun item2 -> isDefiniteOverride item1 && equivVirts item1 item2))) - - -/// Filter the overrides of methods, either keeping the overrides or keeping the dispatch slots. -let private FilterOverridesOfMethInfos findFlag g amap m minfos = - minfos - |> FilterOverrides findFlag - ((fun (minfo: MethInfo) -> minfo.IsVirtual), - (fun minfo -> minfo.IsNewSlot), - (fun minfo -> minfo.IsDefiniteFSharpOverride), - (fun minfo -> minfo.IsFinal), - MethInfosEquivByNameAndSig EraseNone true g amap m, - (fun minfo -> minfo.LogicalName)) - -/// Filter the overrides of properties, either keeping the overrides or keeping the dispatch slots. -let private FilterOverridesOfPropInfos findFlag g amap m props = - props - |> FilterOverrides findFlag - ((fun (pinfo: PropInfo) -> pinfo.IsVirtualProperty), - (fun pinfo -> pinfo.IsNewSlot), - (fun pinfo -> pinfo.IsDefiniteFSharpOverride), - (fun _ -> false), - PropInfosEquivByNameAndSig EraseNone g amap m, - (fun pinfo -> pinfo.PropertyName)) - /// Exclude methods from super types which have the same signature as a method in a more specific type. -let ExcludeHiddenOfMethInfos g amap m (minfos: MethInfo list list) = - minfos - |> ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes - (fun minfo -> minfo.LogicalName) - (fun m1 m2 -> - // only hide those truly from super classes - not (tyconRefEq g m1.DeclaringTyconRef m2.DeclaringTyconRef) && - MethInfosEquivByNameAndPartialSig EraseNone true g amap m m1 m2) - - |> List.concat +val ExcludeHiddenOfMethInfos: g:TcGlobals -> amap:ImportMap -> m:range -> minfos:MethInfo list list -> MethInfo list /// Exclude properties from super types which have the same name as a property in a more specific type. -let ExcludeHiddenOfPropInfos g amap m pinfos = - pinfos - |> ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes (fun (pinfo: PropInfo) -> pinfo.PropertyName) (PropInfosEquivByNameAndPartialSig EraseNone g amap m) - |> List.concat +val ExcludeHiddenOfPropInfos: g:TcGlobals -> amap:ImportMap -> m:range -> pinfos:PropInfo list list -> PropInfo list /// Get the sets of intrinsic methods in the hierarchy (not including extension methods) -let GetIntrinsicMethInfoSetsOfType (infoReader:InfoReader) optFilter ad allowMultiIntfInst findFlag m ty = - infoReader.GetRawIntrinsicMethodSetsOfType(optFilter, ad, allowMultiIntfInst, m, ty) - |> FilterOverridesOfMethInfos findFlag infoReader.g infoReader.amap m - +val GetIntrinsicMethInfoSetsOfType: infoReader:InfoReader -> optFilter:string option -> ad:AccessorDomain -> allowMultiIntfInst:AllowMultiIntfInstantiations -> findFlag:FindMemberFlag -> m:range -> ty:TType -> MethInfo list list + /// Get the sets intrinsic properties in the hierarchy (not including extension properties) -let GetIntrinsicPropInfoSetsOfType (infoReader:InfoReader) optFilter ad allowMultiIntfInst findFlag m ty = - infoReader.GetRawIntrinsicPropertySetsOfType(optFilter, ad, allowMultiIntfInst, m, ty) - |> FilterOverridesOfPropInfos findFlag infoReader.g infoReader.amap m +val GetIntrinsicPropInfoSetsOfType: infoReader:InfoReader -> optFilter:string option -> ad:AccessorDomain -> allowMultiIntfInst:AllowMultiIntfInstantiations -> findFlag:FindMemberFlag -> m:range -> ty:TType -> PropInfo list list /// Get the flattened list of intrinsic methods in the hierarchy -let GetIntrinsicMethInfosOfType infoReader optFilter ad allowMultiIntfInst findFlag m ty = - GetIntrinsicMethInfoSetsOfType infoReader optFilter ad allowMultiIntfInst findFlag m ty |> List.concat - +val GetIntrinsicMethInfosOfType: infoReader:InfoReader -> optFilter:string option -> ad:AccessorDomain -> allowMultiIntfInst:AllowMultiIntfInstantiations -> findFlag:FindMemberFlag -> m:range -> ty:TType -> MethInfo list + /// Get the flattened list of intrinsic properties in the hierarchy -let GetIntrinsicPropInfosOfType infoReader optFilter ad allowMultiIntfInst findFlag m ty = - GetIntrinsicPropInfoSetsOfType infoReader optFilter ad allowMultiIntfInst findFlag m ty |> List.concat +val GetIntrinsicPropInfosOfType: infoReader:InfoReader -> optFilter:string option -> ad:AccessorDomain -> allowMultiIntfInst:AllowMultiIntfInstantiations -> findFlag:FindMemberFlag -> m:range -> ty:TType -> PropInfo list /// Perform type-directed name resolution of a particular named member in an F# type -let TryFindIntrinsicNamedItemOfType (infoReader: InfoReader) (nm, ad) findFlag m ty = - match infoReader.TryFindNamedItemOfType(nm, ad, m, ty) with - | Some item -> - match item with - | PropertyItem psets -> Some(PropertyItem (psets |> FilterOverridesOfPropInfos findFlag infoReader.g infoReader.amap m)) - | MethodItem msets -> Some(MethodItem (msets |> FilterOverridesOfMethInfos findFlag infoReader.g infoReader.amap m)) - | _ -> Some(item) - | None -> None +val TryFindIntrinsicNamedItemOfType: infoReader:InfoReader -> nm:string * ad:AccessorDomain -> findFlag:FindMemberFlag -> m:range -> ty:TType -> HierarchyItem option /// Try to detect the existence of a method on a type. -/// Used for -/// -- getting the GetEnumerator, get_Current, MoveNext methods for enumerable types -/// -- getting the Dispose method when resolving the 'use' construct -/// -- getting the various methods used to desugar the computation expression syntax -let TryFindIntrinsicMethInfo infoReader m ad nm ty = - GetIntrinsicMethInfosOfType infoReader (Some nm) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides m ty +val TryFindIntrinsicMethInfo: infoReader:InfoReader -> m:range -> ad:AccessorDomain -> nm:string -> ty:TType -> MethInfo list /// Try to find a particular named property on a type. Only used to ensure that local 'let' definitions and property names /// are distinct, a somewhat adhoc check in tc.fs. -let TryFindPropInfo infoReader m ad nm ty = - GetIntrinsicPropInfosOfType infoReader (Some nm) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides m ty +val TryFindPropInfo: infoReader:InfoReader -> m:range -> ad:AccessorDomain -> nm:string -> ty:TType -> PropInfo list /// Get a set of most specific override methods. -let GetIntrinisicMostSpecificOverrideMethInfoSetsOfType (infoReader: InfoReader) m ty = - infoReader.GetIntrinsicMostSpecificOverrideMethodSetsOfType (None, AccessibleFromSomewhere, AllowMultiIntfInstantiations.Yes, m, ty) - -//------------------------------------------------------------------------- -// Helpers related to delegates and events - these use method searching hence are in this file -//------------------------------------------------------------------------- +val GetIntrinisicMostSpecificOverrideMethInfoSetsOfType: infoReader:InfoReader -> m:range -> ty:TType -> NameMultiMap /// The Invoke MethInfo, the function argument types, the function return type /// and the overall F# function type for the function type associated with a .NET delegate type -[] -type SigOfFunctionForDelegate = SigOfFunctionForDelegate of MethInfo * TType list * TType * TType +[] +type SigOfFunctionForDelegate = | SigOfFunctionForDelegate of MethInfo * TType list * TType * TType /// Given a delegate type work out the minfo, argument types, return type /// and F# function type by looking at the Invoke signature of the delegate. -let GetSigOfFunctionForDelegate (infoReader: InfoReader) delty m ad = - let g = infoReader.g - let amap = infoReader.amap - let invokeMethInfo = - match GetIntrinsicMethInfosOfType infoReader (Some "Invoke") ad AllowMultiIntfInstantiations.Yes IgnoreOverrides m delty with - | [h] -> h - | [] -> error(Error(FSComp.SR.noInvokeMethodsFound (), m)) - | h :: _ -> warning(InternalError(FSComp.SR.moreThanOneInvokeMethodFound (), m)); h - - let minst = [] // a delegate's Invoke method is never generic - let compiledViewOfDelArgTys = - match invokeMethInfo.GetParamTypes(amap, m, minst) with - | [args] -> args - | _ -> error(Error(FSComp.SR.delegatesNotAllowedToHaveCurriedSignatures (), m)) - let fsharpViewOfDelArgTys = - match compiledViewOfDelArgTys with - | [] -> [g.unit_ty] - | _ -> compiledViewOfDelArgTys - let delRetTy = invokeMethInfo.GetFSharpReturnTy(amap, m, minst) - CheckMethInfoAttributes g m None invokeMethInfo |> CommitOperationResult - let fty = mkIteratedFunTy fsharpViewOfDelArgTys delRetTy - SigOfFunctionForDelegate(invokeMethInfo, compiledViewOfDelArgTys, delRetTy, fty) +val GetSigOfFunctionForDelegate: infoReader:InfoReader -> delty:TType -> m:range -> ad:AccessorDomain -> SigOfFunctionForDelegate /// Try and interpret a delegate type as a "standard" .NET delegate type associated with an event, with a "sender" parameter. -let TryDestStandardDelegateType (infoReader: InfoReader) m ad delTy = - let g = infoReader.g - let (SigOfFunctionForDelegate(_, compiledViewOfDelArgTys, delRetTy, _)) = GetSigOfFunctionForDelegate infoReader delTy m ad - match compiledViewOfDelArgTys with - | senderTy :: argTys when (isObjTy g senderTy) && not (List.exists (isByrefTy g) argTys) -> Some(mkRefTupledTy g argTys, delRetTy) - | _ -> None - +val TryDestStandardDelegateType: infoReader:InfoReader -> m:range -> ad:AccessorDomain -> delTy:TType -> (TType * TType) option /// Indicates if an event info is associated with a delegate type that is a "standard" .NET delegate type /// with a sender parameter. -// -/// In the F# design, we take advantage of the following idiom to simplify away the bogus "object" parameter of the -/// of the "Add" methods associated with events. If you want to access it you -/// can use AddHandler instead. - -/// The .NET Framework guidelines indicate that the delegate type used for -/// an event should take two parameters, an "object source" parameter -/// indicating the source of the event, and an "e" parameter that -/// encapsulates any additional information about the event. The type of -/// the "e" parameter should derive from the EventArgs class. For events -/// that do not use any additional information, the .NET Framework has -/// already defined an appropriate delegate type: EventHandler. -/// (from http://msdn.microsoft.com/library/default.asp?url=/library/en-us/csref/html/vcwlkEventsTutorial.asp) -let IsStandardEventInfo (infoReader: InfoReader) m ad (einfo: EventInfo) = - let dty = einfo.GetDelegateType(infoReader.amap, m) - match TryDestStandardDelegateType infoReader m ad dty with - | Some _ -> true - | None -> false - -/// Get the (perhaps tupled) argument type accepted by an event -let ArgsTypOfEventInfo (infoReader: InfoReader) m ad (einfo: EventInfo) = - let amap = infoReader.amap - let dty = einfo.GetDelegateType(amap, m) - match TryDestStandardDelegateType infoReader m ad dty with - | Some(argtys, _) -> argtys - | None -> error(nonStandardEventError einfo.EventName m) - -/// Get the type of the event when looked at as if it is a property -/// Used when displaying the property in Intellisense -let PropTypOfEventInfo (infoReader: InfoReader) m ad (einfo: EventInfo) = - let g = infoReader.g - let amap = infoReader.amap - let delTy = einfo.GetDelegateType(amap, m) - let argsTy = ArgsTypOfEventInfo infoReader m ad einfo - mkIEventType g delTy argsTy +val IsStandardEventInfo: infoReader:InfoReader -> m:range -> ad:AccessorDomain -> einfo:EventInfo -> bool + +val ArgsTypOfEventInfo: infoReader:InfoReader -> m:range -> ad:AccessorDomain -> einfo:EventInfo -> TType + +val PropTypOfEventInfo: infoReader:InfoReader -> m:range -> ad:AccessorDomain -> einfo:EventInfo -> TType diff --git a/src/fsharp/PostInferenceChecks.fs b/src/fsharp/PostInferenceChecks.fs index 632531362a1..b3b69aab958 100644 --- a/src/fsharp/PostInferenceChecks.fs +++ b/src/fsharp/PostInferenceChecks.fs @@ -2151,8 +2151,8 @@ let CheckEntityDefn cenv env (tycon: Entity) = if ( (pinfo.HasGetter && pinfo.HasSetter && - let setterArgs = pinfo.DropGetter.GetParamTypes(cenv.amap, m) - let getterArgs = pinfo.DropSetter.GetParamTypes(cenv.amap, m) + let setterArgs = pinfo.DropGetter().GetParamTypes(cenv.amap, m) + let getterArgs = pinfo.DropSetter().GetParamTypes(cenv.amap, m) setterArgs.Length <> getterArgs.Length) || (let nargs = pinfo.GetParamTypes(cenv.amap, m).Length @@ -2163,8 +2163,8 @@ let CheckEntityDefn cenv env (tycon: Entity) = // Check to see if the signatures of the both getter and the setter imply the same property type if pinfo.HasGetter && pinfo.HasSetter && not pinfo.IsIndexer then - let ty1 = pinfo.DropSetter.GetPropertyType(cenv.amap, m) - let ty2 = pinfo.DropGetter.GetPropertyType(cenv.amap, m) + let ty1 = pinfo.DropSetter().GetPropertyType(cenv.amap, m) + let ty2 = pinfo.DropGetter().GetPropertyType(cenv.amap, m) if not (typeEquivAux EraseNone cenv.amap.g ty1 ty2) then errorR(Error(FSComp.SR.chkGetterAndSetterHaveSamePropertyType(pinfo.PropertyName, NicePrint.minimalStringOfType cenv.denv ty1, NicePrint.minimalStringOfType cenv.denv ty2), m)) diff --git a/src/fsharp/TypeRelations.fs b/src/fsharp/TypeRelations.fs index 28352bea88a..03943339f2a 100755 --- a/src/fsharp/TypeRelations.fs +++ b/src/fsharp/TypeRelations.fs @@ -124,7 +124,6 @@ let rec TypeFeasiblySubsumesType ndeep g amap m ty1 canCoerce ty2 = ty2 |> GetImmediateInterfacesOfType SkipUnrefInterfaces.Yes g amap m |> List.exists (TypeFeasiblySubsumesType (ndeep+1) g amap m ty1 NoCoerce)) - /// Choose solutions for Expr.TyChoose type "hidden" variables introduced /// by letrec nodes. Also used by the pattern match compiler to choose type /// variables when compiling patterns at generalized bindings. @@ -225,7 +224,6 @@ let ChooseTyparSolutionsForFreeChoiceTypars g amap e = instExpr g tpenv e1 | _ -> e - /// Break apart lambdas. Needs ChooseTyparSolutionsForFreeChoiceTypars because it's used in /// PostTypeCheckSemanticChecks before we've eliminated these nodes. diff --git a/src/fsharp/TypeRelations.fsi b/src/fsharp/TypeRelations.fsi index 28352bea88a..0348c1cd478 100644 --- a/src/fsharp/TypeRelations.fsi +++ b/src/fsharp/TypeRelations.fsi @@ -4,288 +4,54 @@ /// constraint solving and method overload resolution. module internal FSharp.Compiler.TypeRelations -open FSharp.Compiler.AbstractIL.Internal -open FSharp.Compiler.AbstractIL.Internal.Library -open FSharp.Compiler.ErrorLogger +open FSharp.Compiler.Import +open FSharp.Compiler.Range open FSharp.Compiler.TypedTree -open FSharp.Compiler.TypedTreeBasics -open FSharp.Compiler.TypedTreeOps open FSharp.Compiler.TcGlobals -open FSharp.Compiler.Infos -/// Implements a :> b without coercion based on finalized (no type variable) types -// Note: This relation is approximate and not part of the language specification. -// -// Some appropriate uses: -// patcompile.fs: IsDiscrimSubsumedBy (approximate warning for redundancy of 'isinst' patterns) -// tc.fs: TcRuntimeTypeTest (approximate warning for redundant runtime type tests) -// tc.fs: TcExnDefnCore (error for bad exception abbreviation) -// ilxgen.fs: GenCoerce (omit unnecessary castclass or isinst instruction) -// -let rec TypeDefinitelySubsumesTypeNoCoercion ndeep g amap m ty1 ty2 = - if ndeep > 100 then error(InternalError("recursive class hierarchy (detected in TypeDefinitelySubsumesTypeNoCoercion), ty1 = " + (DebugPrint.showType ty1), m)) - if ty1 === ty2 then true - elif typeEquiv g ty1 ty2 then true - else - let ty1 = stripTyEqns g ty1 - let ty2 = stripTyEqns g ty2 - // F# reference types are subtypes of type 'obj' - (typeEquiv g ty1 g.obj_ty && isRefTy g ty2) || - // Follow the supertype chain - (isAppTy g ty2 && - isRefTy g ty2 && - - ((match GetSuperTypeOfType g amap m ty2 with - | None -> false - | Some ty -> TypeDefinitelySubsumesTypeNoCoercion (ndeep+1) g amap m ty1 ty) || - - // Follow the interface hierarchy - (isInterfaceTy g ty1 && - ty2 |> GetImmediateInterfacesOfType SkipUnrefInterfaces.Yes g amap m - |> List.exists (TypeDefinitelySubsumesTypeNoCoercion (ndeep+1) g amap m ty1)))) +type CanCoerce = + | CanCoerce + | NoCoerce -type CanCoerce = CanCoerce | NoCoerce +/// Implements a :> b without coercion based on finalized (no type variable) types +val TypeDefinitelySubsumesTypeNoCoercion: ndeep:int -> g:TcGlobals -> amap:ImportMap -> m:range -> ty1:TType -> ty2:TType -> bool /// The feasible equivalence relation. Part of the language spec. -let rec TypesFeasiblyEquivalent stripMeasures ndeep g amap m ty1 ty2 = - - if ndeep > 100 then error(InternalError("recursive class hierarchy (detected in TypeFeasiblySubsumesType), ty1 = " + (DebugPrint.showType ty1), m)); - let stripAll ty = - if stripMeasures then - ty |> stripTyEqnsWrtErasure EraseAll g |> stripMeasuresFromTType g - else - ty |> stripTyEqns g - - let ty1str = stripAll ty1 - let ty2str = stripAll ty2 - - match ty1str, ty2str with - | TType_var _, _ - | _, TType_var _ -> true - - | TType_app (tc1, l1), TType_app (tc2, l2) when tyconRefEq g tc1 tc2 -> - List.lengthsEqAndForall2 (TypesFeasiblyEquivalent stripMeasures ndeep g amap m) l1 l2 - - | TType_anon (anonInfo1, l1),TType_anon (anonInfo2, l2) -> - (evalTupInfoIsStruct anonInfo1.TupInfo = evalTupInfoIsStruct anonInfo2.TupInfo) && - (match anonInfo1.Assembly, anonInfo2.Assembly with ccu1, ccu2 -> ccuEq ccu1 ccu2) && - (anonInfo1.SortedNames = anonInfo2.SortedNames) && - List.lengthsEqAndForall2 (TypesFeasiblyEquivalent stripMeasures ndeep g amap m) l1 l2 - - | TType_tuple (tupInfo1, l1), TType_tuple (tupInfo2, l2) -> - evalTupInfoIsStruct tupInfo1 = evalTupInfoIsStruct tupInfo2 && - List.lengthsEqAndForall2 (TypesFeasiblyEquivalent stripMeasures ndeep g amap m) l1 l2 - - | TType_fun (d1, r1), TType_fun (d2, r2) -> - (TypesFeasiblyEquivalent stripMeasures ndeep g amap m) d1 d2 && (TypesFeasiblyEquivalent stripMeasures ndeep g amap m) r1 r2 - - | TType_measure _, TType_measure _ -> - true - - | _ -> - false +val TypesFeasiblyEquivalent: stripMeasures:bool -> ndeep:int -> g:TcGlobals -> amap:'a -> m:range -> ty1:TType -> ty2:TType -> bool /// The feasible equivalence relation. Part of the language spec. -let rec TypesFeasiblyEquiv ndeep g amap m ty1 ty2 = - TypesFeasiblyEquivalent false ndeep g amap m ty1 ty2 +val TypesFeasiblyEquiv: ndeep:int -> g:TcGlobals -> amap:'a -> m:range -> ty1:TType -> ty2:TType -> bool /// The feasible equivalence relation after stripping Measures. -let TypesFeasiblyEquivStripMeasures g amap m ty1 ty2 = - TypesFeasiblyEquivalent true 0 g amap m ty1 ty2 +val TypesFeasiblyEquivStripMeasures: g:TcGlobals -> amap:'a -> m:range -> ty1:TType -> ty2:TType -> bool /// The feasible coercion relation. Part of the language spec. -let rec TypeFeasiblySubsumesType ndeep g amap m ty1 canCoerce ty2 = - if ndeep > 100 then error(InternalError("recursive class hierarchy (detected in TypeFeasiblySubsumesType), ty1 = " + (DebugPrint.showType ty1), m)) - let ty1 = stripTyEqns g ty1 - let ty2 = stripTyEqns g ty2 - match ty1, ty2 with - | TType_var _, _ | _, TType_var _ -> true - - | TType_app (tc1, l1), TType_app (tc2, l2) when tyconRefEq g tc1 tc2 -> - List.lengthsEqAndForall2 (TypesFeasiblyEquiv ndeep g amap m) l1 l2 - - | TType_tuple _, TType_tuple _ - | TType_anon _, TType_anon _ - | TType_fun _, TType_fun _ -> TypesFeasiblyEquiv ndeep g amap m ty1 ty2 - - | TType_measure _, TType_measure _ -> - true - - | _ -> - // F# reference types are subtypes of type 'obj' - (isObjTy g ty1 && (canCoerce = CanCoerce || isRefTy g ty2)) - || - (isAppTy g ty2 && - (canCoerce = CanCoerce || isRefTy g ty2) && - begin match GetSuperTypeOfType g amap m ty2 with - | None -> false - | Some ty -> TypeFeasiblySubsumesType (ndeep+1) g amap m ty1 NoCoerce ty - end || - ty2 |> GetImmediateInterfacesOfType SkipUnrefInterfaces.Yes g amap m - |> List.exists (TypeFeasiblySubsumesType (ndeep+1) g amap m ty1 NoCoerce)) - +val TypeFeasiblySubsumesType: ndeep:int -> g:TcGlobals -> amap:ImportMap -> m:range -> ty1:TType -> canCoerce:CanCoerce -> ty2:TType -> bool /// Choose solutions for Expr.TyChoose type "hidden" variables introduced /// by letrec nodes. Also used by the pattern match compiler to choose type /// variables when compiling patterns at generalized bindings. /// e.g. let ([], x) = ([], []) /// Here x gets a generalized type "list<'T>". -let ChooseTyparSolutionAndRange (g: TcGlobals) amap (tp:Typar) = - let m = tp.Range - let max, m = - let initial = - match tp.Kind with - | TyparKind.Type -> g.obj_ty - | TyparKind.Measure -> TType_measure Measure.One - // Loop through the constraints computing the lub - ((initial, m), tp.Constraints) ||> List.fold (fun (maxSoFar, _) tpc -> - let join m x = - if TypeFeasiblySubsumesType 0 g amap m x CanCoerce maxSoFar then maxSoFar - elif TypeFeasiblySubsumesType 0 g amap m maxSoFar CanCoerce x then x - else errorR(Error(FSComp.SR.typrelCannotResolveImplicitGenericInstantiation((DebugPrint.showType x), (DebugPrint.showType maxSoFar)), m)); maxSoFar - // Don't continue if an error occurred and we set the value eagerly - if tp.IsSolved then maxSoFar, m else - match tpc with - | TyparConstraint.CoercesTo(x, m) -> - join m x, m - | TyparConstraint.MayResolveMember(_traitInfo, m) -> - maxSoFar, m - | TyparConstraint.SimpleChoice(_, m) -> - errorR(Error(FSComp.SR.typrelCannotResolveAmbiguityInPrintf(), m)) - maxSoFar, m - | TyparConstraint.SupportsNull m -> - maxSoFar, m - | TyparConstraint.SupportsComparison m -> - join m g.mk_IComparable_ty, m - | TyparConstraint.SupportsEquality m -> - maxSoFar, m - | TyparConstraint.IsEnum(_, m) -> - errorR(Error(FSComp.SR.typrelCannotResolveAmbiguityInEnum(), m)) - maxSoFar, m - | TyparConstraint.IsDelegate(_, _, m) -> - errorR(Error(FSComp.SR.typrelCannotResolveAmbiguityInDelegate(), m)) - maxSoFar, m - | TyparConstraint.IsNonNullableStruct m -> - join m g.int_ty, m - | TyparConstraint.IsUnmanaged m -> - errorR(Error(FSComp.SR.typrelCannotResolveAmbiguityInUnmanaged(), m)) - maxSoFar, m - | TyparConstraint.RequiresDefaultConstructor m -> - maxSoFar, m - | TyparConstraint.IsReferenceType m -> - maxSoFar, m - | TyparConstraint.DefaultsTo(_priority, _ty, m) -> - maxSoFar, m) - max, m - -let ChooseTyparSolution g amap tp = - let ty, _m = ChooseTyparSolutionAndRange g amap tp - if tp.Rigidity = TyparRigidity.Anon && typeEquiv g ty (TType_measure Measure.One) then - warning(Error(FSComp.SR.csCodeLessGeneric(), tp.Range)) - ty +val ChooseTyparSolutionAndRange: g:TcGlobals -> amap:ImportMap -> tp:Typar -> TType * range -// Solutions can, in theory, refer to each other -// For example -// 'a = Expr<'b> -// 'b = int -// In this case the solutions are -// 'a = Expr -// 'b = int -// We ground out the solutions by repeatedly instantiating -let IterativelySubstituteTyparSolutions g tps solutions = - let tpenv = mkTyparInst tps solutions - let rec loop n curr = - let curr' = curr |> instTypes tpenv - // We cut out at n > 40 just in case this loops. It shouldn't, since there should be no cycles in the - // solution equations, and we've only ever seen one example where even n = 2 was required. - // Perhaps it's possible in error recovery some strange situations could occur where cycles - // arise, so it's better to be on the safe side. - // - // We don't give an error if we hit the limit since it's feasible that the solutions of unknowns - // is not actually relevant to the rest of type checking or compilation. - if n > 40 || List.forall2 (typeEquiv g) curr curr' then - curr - else - loop (n+1) curr' +val ChooseTyparSolution: g:TcGlobals -> amap:ImportMap -> tp:Typar -> TType - loop 0 solutions +val IterativelySubstituteTyparSolutions: g:TcGlobals -> tps:Typars -> solutions:TTypes -> TypeInst -let ChooseTyparSolutionsForFreeChoiceTypars g amap e = - match e with - | Expr.TyChoose (tps, e1, _m) -> - - /// Only make choices for variables that are actually used in the expression - let ftvs = (freeInExpr CollectTyparsNoCaching e1).FreeTyvars.FreeTypars - let tps = tps |> List.filter (Zset.memberOf ftvs) - - let solutions = tps |> List.map (ChooseTyparSolution g amap) |> IterativelySubstituteTyparSolutions g tps - - let tpenv = mkTyparInst tps solutions - - instExpr g tpenv e1 - - | _ -> e - +val ChooseTyparSolutionsForFreeChoiceTypars: g:TcGlobals -> amap:ImportMap -> e:Expr -> Expr /// Break apart lambdas. Needs ChooseTyparSolutionsForFreeChoiceTypars because it's used in /// PostTypeCheckSemanticChecks before we've eliminated these nodes. -let tryDestTopLambda g amap (ValReprInfo (tpNames, _, _) as tvd) (e, ty) = - let rec stripLambdaUpto n (e, ty) = - match e with - | Expr.Lambda (_, None, None, v, b, _, retTy) when n > 0 -> - let (vs', b', retTy') = stripLambdaUpto (n-1) (b, retTy) - (v :: vs', b', retTy') - | _ -> - ([], e, ty) - - let rec startStripLambdaUpto n (e, ty) = - match e with - | Expr.Lambda (_, ctorThisValOpt, baseValOpt, v, b, _, retTy) when n > 0 -> - let (vs', b', retTy') = stripLambdaUpto (n-1) (b, retTy) - (ctorThisValOpt, baseValOpt, (v :: vs'), b', retTy') - | Expr.TyChoose (_tps, _b, _) -> - startStripLambdaUpto n (ChooseTyparSolutionsForFreeChoiceTypars g amap e, ty) - | _ -> - (None, None, [], e, ty) - - let n = tvd.NumCurriedArgs - let tps, taue, tauty = - match e with - | Expr.TyLambda (_, tps, b, _, retTy) when not (isNil tpNames) -> tps, b, retTy - | _ -> [], e, ty - let ctorThisValOpt, baseValOpt, vsl, body, retTy = startStripLambdaUpto n (taue, tauty) - if vsl.Length <> n then - None - else - Some (tps, ctorThisValOpt, baseValOpt, vsl, body, retTy) +val tryDestTopLambda: g:TcGlobals -> amap:ImportMap -> ValReprInfo -> e:Expr * ty:TType -> (Typars * Val option * Val option * Val list list * Expr * TType) option -let destTopLambda g amap topValInfo (e, ty) = - match tryDestTopLambda g amap topValInfo (e, ty) with - | None -> error(Error(FSComp.SR.typrelInvalidValue(), e.Range)) - | Some res -> res - -let IteratedAdjustArityOfLambdaBody g arities vsl body = - (arities, vsl, ([], body)) |||> List.foldBack2 (fun arities vs (allvs, body) -> - let vs, body = AdjustArityOfLambdaBody g arities vs body - vs :: allvs, body) +val destTopLambda: g:TcGlobals -> amap:ImportMap -> topValInfo:ValReprInfo -> e:Expr * ty:TType -> Typars * Val option * Val option * Val list list * Expr * TType -/// Do AdjustArityOfLambdaBody for a series of -/// iterated lambdas, producing one method. +/// Do AdjustArityOfLambdaBody for a series of iterated lambdas, producing one method. /// The required iterated function arity (List.length topValInfo) must be identical /// to the iterated function arity of the input lambda (List.length vsl) -let IteratedAdjustArityOfLambda g amap topValInfo e = - let tps, ctorThisValOpt, baseValOpt, vsl, body, bodyty = destTopLambda g amap topValInfo (e, tyOfExpr g e) - let arities = topValInfo.AritiesOfArgs - if arities.Length <> vsl.Length then - errorR(InternalError(sprintf "IteratedAdjustArityOfLambda, List.length arities = %d, List.length vsl = %d" arities.Length vsl.Length, body.Range)) - let vsl, body = IteratedAdjustArityOfLambdaBody g arities vsl body - tps, ctorThisValOpt, baseValOpt, vsl, body, bodyty - +val IteratedAdjustArityOfLambda: g:TcGlobals -> amap:ImportMap -> topValInfo:ValReprInfo -> e:Expr -> Typars * Val option * Val option * Val list list * Expr * TType /// "Single Feasible Type" inference /// Look for the unique supertype of ty2 for which ty2 :> ty1 might feasibly hold -let FindUniqueFeasibleSupertype g amap m ty1 ty2 = - let supertypes = Option.toList (GetSuperTypeOfType g amap m ty2) @ (GetImmediateInterfacesOfType SkipUnrefInterfaces.Yes g amap m ty2) - supertypes |> List.tryFind (TypeFeasiblySubsumesType 0 g amap m ty1 NoCoerce) - - +val FindUniqueFeasibleSupertype: g:TcGlobals -> amap:ImportMap -> m:range -> ty1:TType -> ty2:TType -> TType option diff --git a/src/fsharp/TypedTreeBasics.fs b/src/fsharp/TypedTreeBasics.fs index 8c74d6bdbeb..5074b3f90e6 100644 --- a/src/fsharp/TypedTreeBasics.fs +++ b/src/fsharp/TypedTreeBasics.fs @@ -97,7 +97,6 @@ let typarEq (lv1: Typar) (lv2: Typar) = (lv1.Stamp = lv2.Stamp) /// Equality on type variables, implemented as reference equality. This should be equivalent to using typarEq. let typarRefEq (tp1: Typar) (tp2: Typar) = (tp1 === tp2) - /// Equality on value specs, implemented as reference equality let valEq (lv1: Val) (lv2: Val) = (lv1 === lv2) @@ -172,6 +171,7 @@ let (|VRefLocal|VRefNonLocal|) (x: ValRef) = | _ -> VRefNonLocal x.nlr let mkNonLocalValRef mp id = VRefNonLocal {EnclosingEntity = ERefNonLocal mp; ItemKey=id } + let mkNonLocalValRefPreResolved x mp id = VRefNonLocalPreResolved x {EnclosingEntity = ERefNonLocal mp; ItemKey=id } let ccuOfValRef vref = diff --git a/src/fsharp/TypedTreeOps.fsi b/src/fsharp/TypedTreeOps.fsi index b4e826452e2..e47cb63da60 100755 --- a/src/fsharp/TypedTreeOps.fsi +++ b/src/fsharp/TypedTreeOps.fsi @@ -2420,3 +2420,6 @@ val (|TryFinallyExpr|_|): Expr -> (DebugPointAtTry * DebugPointAtFinally * TType /// Add a label to use as the target for a goto val mkLabelled: range -> ILCodeLabel -> Expr -> Expr + +/// Shared helper for binding attributes +val TryBindTyconRefAttribute: g:TcGlobals -> m:range -> BuiltinAttribInfo -> tcref:TyconRef -> f1:(ILAttribElem list * ILAttributeNamedArg list -> 'a option) -> f2:(Attrib -> 'a option) -> f3:(obj option list * (string * obj option) list -> 'a option) -> 'a option diff --git a/src/fsharp/infos.fs b/src/fsharp/infos.fs index a314acbd673..26ff383c38d 100755 --- a/src/fsharp/infos.fs +++ b/src/fsharp/infos.fs @@ -103,7 +103,6 @@ let mkSystemCollectionsGenericIListTy (g: TcGlobals) ty = TType_app(g.tcref_Syst /// Indicates whether we can skip interface types that lie outside the reference set type SkipUnrefInterfaces = Yes | No - /// Collect the set of immediate declared interface types for an F# type, but do not /// traverse the type hierarchy to collect further interfaces. let rec GetImmediateInterfacesOfType skipUnref g amap m ty = @@ -166,8 +165,8 @@ let rec GetImmediateInterfacesOfType skipUnref g amap m ty = itys -[] /// Indicates whether we should visit multiple instantiations of the same generic interface or not +[] type AllowMultiIntfInstantiations = Yes | No /// Traverse the type hierarchy, e.g. f D (f C (f System.Object acc)). @@ -299,7 +298,6 @@ let ExistsSameHeadTypeInHierarchy g amap m typeToSearchFrom typeToLookFor = let ExistsHeadTypeInEntireHierarchy g amap m typeToSearchFrom tcrefToLookFor = ExistsInEntireHierarchyOfType (HasHeadType g tcrefToLookFor) g amap m AllowMultiIntfInstantiations.Yes typeToSearchFrom - /// Read an Abstract IL type from metadata and convert to an F# type. let ImportILTypeFromMetadata amap m scoref tinst minst ilty = ImportILType scoref amap m (tinst@minst) ilty @@ -385,7 +383,6 @@ let FixupNewTypars m (formalEnclosingTypars: Typars) (tinst: TType list) (tpsori //------------------------------------------------------------------------- // Predicates and properties on values and members - type ValRef with /// Indicates if an F#-declared function or member value is a CLIEvent property compiled as a .NET event member x.IsFSharpEventProperty g = @@ -450,14 +447,12 @@ let ReparentSlotSigToUseMethodTypars g m ovByMethValRef slotsig = // Note: it appears PartitionValRefTypars should never return 'None' slotsig - /// Construct the data representing a parameter in the signature of an abstract method slot let MakeSlotParam (ty, argInfo: ArgReprInfo) = TSlotParam(Option.map textOfId argInfo.Name, ty, false, false, false, argInfo.Attribs) /// Construct the data representing the signature of an abstract method slot let MakeSlotSig (nm, ty, ctps, mtps, paraml, retTy) = copySlotSig (TSlotSig(nm, ty, ctps, mtps, paraml, retTy)) - /// Split the type of an F# member value into /// - the type parameters associated with method but matching those of the enclosing type /// - the type parameters associated with a generic method @@ -531,8 +526,10 @@ type OptionalArgCallerSideValue = type OptionalArgInfo = /// The argument is not optional | NotOptional + /// The argument is optional, and is an F# callee-side optional arg | CalleeSide + /// The argument is optional, and is a caller-side .NET optional or default arg. /// Note this is correctly termed caller side, even though the default value is optically specified on the callee: /// in fact the default value is read from the metadata and passed explicitly to the callee on the caller side. @@ -607,11 +604,15 @@ type ParamNameAndType = [] /// Full information about a parameter returned for use by the type checker and language service. type ParamData = - ParamData of isParamArray: bool * isInArg: bool * isOut: bool * optArgInfo: OptionalArgInfo * callerInfo: CallerInfo * nameOpt: Ident option * reflArgInfo: ReflectedArgInfo * ttype: TType - - -//------------------------------------------------------------------------- -// Helper methods associated with type providers + ParamData of + isParamArray: bool * + isInArg: bool * + isOut: bool * + optArgInfo: OptionalArgInfo * + callerInfo: CallerInfo * + nameOpt: Ident option * + reflArgInfo: ReflectedArgInfo * + ttype: TType #if !NO_EXTENSIONTYPING @@ -684,9 +685,6 @@ let ArbitraryMethodInfoOfPropertyInfo (pi: Tainted) m = #endif -//------------------------------------------------------------------------- -// ILTypeInfo - /// Describes an F# use of an IL type, including the type instantiation associated with the type at a particular usage point. /// /// This is really just 1:1 with the subset ot TType which result from building types using IL type definitions. @@ -738,20 +736,14 @@ type ILTypeInfo = else failwith "ILTypeInfo.FromType - no IL metadata for type" -//------------------------------------------------------------------------- -// ILMethInfo - - /// Describes an F# use of an IL method. [] type ILMethInfo = - /// ILMethInfo(g, ilApparentType, ilDeclaringTyconRefOpt, ilMethodDef, ilGenericMethodTyArgs) - /// /// Describes an F# use of an IL method. /// /// If ilDeclaringTyconRefOpt is 'Some' then this is an F# use of an C#-style extension method. /// If ilDeclaringTyconRefOpt is 'None' then ilApparentType is an IL type definition. - | ILMethInfo of TcGlobals * TType * TyconRef option * ILMethodDef * Typars + | ILMethInfo of g: TcGlobals * ilApparentType: TType * ilDeclaringTyconRefOpt: TyconRef option * ilMethodDef: ILMethodDef * ilGenericMethodTyArgs: Typars member x.TcGlobals = match x with ILMethInfo(g, _, _, _, _) -> g @@ -896,30 +888,23 @@ type ILMethInfo = x.GetCompiledReturnTy(amap, m, minst) |> GetFSharpViewOfReturnType amap.g -//------------------------------------------------------------------------- -// MethInfo - -[] /// Describes an F# use of a method +[] [] type MethInfo = - /// FSMeth(tcGlobals, enclosingType, valRef, extensionMethodPriority). - /// /// Describes a use of a method declared in F# code and backed by F# metadata. - | FSMeth of TcGlobals * TType * ValRef * ExtensionMethodPriority option + | FSMeth of tcGlobals: TcGlobals * enclosingType: TType * valRef: ValRef * extensionMethodPriority: ExtensionMethodPriority option - /// ILMeth(tcGlobals, ilMethInfo, extensionMethodPriority). - /// /// Describes a use of a method backed by Abstract IL # metadata - | ILMeth of TcGlobals * ILMethInfo * ExtensionMethodPriority option + | ILMeth of tcGlobals: TcGlobals * ilMethInfo: ILMethInfo * extensionMethodPriority: ExtensionMethodPriority option /// Describes a use of a pseudo-method corresponding to the default constructor for a .NET struct type - | DefaultStructCtor of TcGlobals * TType + | DefaultStructCtor of tcGlobals: TcGlobals * structTy: TType #if !NO_EXTENSIONTYPING /// Describes a use of a method backed by provided metadata - | ProvidedMeth of Import.ImportMap * Tainted * ExtensionMethodPriority option * range + | ProvidedMeth of amap: Import.ImportMap * methodBase: Tainted * extensionMethodPriority: ExtensionMethodPriority option * m: range #endif /// Get the enclosing type of the method info. @@ -967,7 +952,6 @@ type MethInfo = #endif | DefaultStructCtor _ -> None - /// Get the extension method priority of the method, if it has one. member x.ExtensionMemberPriorityOption = match x with @@ -978,12 +962,12 @@ type MethInfo = #endif | DefaultStructCtor _ -> None - /// Get the extension method priority of the method. If it is not an extension method - /// then use the highest possible value since non-extension methods always take priority - /// over extension members. + /// Get the extension method priority of the method. If it is not an extension method + /// then use the highest possible value since non-extension methods always take priority + /// over extension members. member x.ExtensionMemberPriority = defaultArg x.ExtensionMemberPriorityOption System.UInt64.MaxValue - /// Get the method name in DebuggerDisplayForm + /// Get the method name in DebuggerDisplayForm member x.DebuggerDisplayName = match x with | ILMeth(_, y, _) -> "ILMeth: " + y.ILName @@ -993,7 +977,7 @@ type MethInfo = #endif | DefaultStructCtor _ -> ".ctor" - /// Get the method name in LogicalName form, i.e. the name as it would be stored in .NET metadata + /// Get the method name in LogicalName form, i.e. the name as it would be stored in .NET metadata member x.LogicalName = match x with | ILMeth(_, y, _) -> y.ILName @@ -1051,12 +1035,12 @@ type MethInfo = | ProvidedMeth _ -> [] // There will already have been an error if there are generic parameters here. #endif - /// Get the formal generic method parameters for the method as a list of variable types. + /// Get the formal generic method parameters for the method as a list of variable types. member x.FormalMethodInst = generalizeTypars x.FormalMethodTypars member x.FormalMethodTyparInst = mkTyparInst x.FormalMethodTypars x.FormalMethodInst - /// Get the XML documentation associated with the method + /// Get the XML documentation associated with the method member x.XmlDoc = match x with | ILMeth(_, _, _) -> XmlDoc.Empty @@ -1098,7 +1082,6 @@ type MethInfo = | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> not mi.IsConstructor && not mi.IsStatic), m) #endif - /// Get the number of generic method parameters for a method. /// For an extension method this includes all type parameters, even if it is extending a generic type. member x.GenericArity = x.FormalMethodTypars.Length @@ -1526,8 +1509,6 @@ type MethInfo = yield (isParamArrayArg, isInArg, isOutArg, optArgInfo, NoCallerInfo, reflArgInfo)] ] #endif - - /// Get the signature of an abstract method slot. // // This code has grown organically over time. We've managed to unify the ILMeth+ProvidedMeth paths. @@ -1631,7 +1612,6 @@ type MethInfo = member x.HasParamArrayArg(amap, m, minst) = x.GetParamDatas(amap, m, minst) |> List.existsSquared (fun (ParamData(isParamArrayArg, _, _, _, _, _, _, _)) -> isParamArrayArg) - /// Select all the type parameters of the declaring type of a method. /// /// For extension methods, no type parameters are returned, because all the @@ -1656,18 +1636,14 @@ type MethInfo = if isByrefTy x.TcGlobals ty then Some ty else None) -//------------------------------------------------------------------------- -// ILFieldInfo - - /// Represents a single use of a IL or provided field from one point in an F# program [] type ILFieldInfo = /// Represents a single use of a field backed by Abstract IL metadata - | ILFieldInfo of ILTypeInfo * ILFieldDef // .NET IL fields + | ILFieldInfo of ilTypeInfo: ILTypeInfo * ilFieldDef: ILFieldDef #if !NO_EXTENSIONTYPING /// Represents a single use of a field backed by provided metadata - | ProvidedField of Import.ImportMap * Tainted * range + | ProvidedField of amap: Import.ImportMap * providedField: Tainted * range: range #endif /// Get the enclosing ("parent"/"declaring") type of the field. @@ -1799,7 +1775,7 @@ type ILFieldInfo = /// Describes an F# use of a field in an F#-declared record, class or struct type [] type RecdFieldInfo = - | RecdFieldInfo of TypeInst * RecdFieldRef + | RecdFieldInfo of typeInst: TypeInst * recdFieldRef: RecdFieldRef /// Get the generic instantiation of the declaring type of the field member x.TypeInst = let (RecdFieldInfo(tinst, _)) = x in tinst @@ -1861,11 +1837,10 @@ type UnionCaseInfo = override x.ToString() = x.TyconRef.ToString() + "::" + x.Name - /// Describes an F# use of a property backed by Abstract IL metadata [] type ILPropInfo = - | ILPropInfo of ILTypeInfo * ILPropertyDef + | ILPropInfo of ilTypeInfo: ILTypeInfo * ilPropertyDef: ILPropertyDef /// Get the TcGlobals governing this value member x.TcGlobals = match x with ILPropInfo(tinfo, _) -> tinfo.TcGlobals @@ -1941,18 +1916,18 @@ type ILPropInfo = override x.ToString() = x.ILTypeInfo.ToString() + "::" + x.PropertyName - - /// Describes an F# use of a property [] type PropInfo = /// An F# use of a property backed by F#-declared metadata - | FSProp of TcGlobals * TType * ValRef option * ValRef option + | FSProp of tcGlobals: TcGlobals * apparentEnclTy: TType * getter: ValRef option * setter: ValRef option + /// An F# use of a property backed by Abstract IL metadata - | ILProp of ILPropInfo + | ILProp of ilPropInfo: ILPropInfo + #if !NO_EXTENSIONTYPING /// An F# use of a property backed by provided metadata - | ProvidedProp of Import.ImportMap * Tainted * range + | ProvidedProp of amap: Import.ImportMap * providedProp: Tainted * range: range #endif /// Get the enclosing type of the property. @@ -2031,7 +2006,6 @@ type PropInfo = | ProvidedProp(_, pi, m) -> pi.PUntaint((fun pi -> pi.CanWrite), m) #endif - /// Indicates if this is an extension member member x.IsExtensionMember = match x.ArbitraryValRef with @@ -2065,7 +2039,6 @@ type PropInfo = mi.PUntaint((fun mi -> mi.IsHideBySig), m) #endif - /// Indicates if the getter (or, if absent, the setter) for the property is a dispatch slot. // REVIEW: for IL properties this is getter OR setter. For F# properties it is getter ELSE setter member x.IsDispatchSlot = @@ -2107,7 +2080,6 @@ type PropInfo = | Some vref -> vref.IsFSharpExplicitInterfaceImplementation x.TcGlobals | None -> false - /// Indicates if this property is an indexer property, i.e. a property with arguments. member x.IsIndexer = match x with @@ -2142,14 +2114,13 @@ type PropInfo = /// /// Property infos can combine getters and setters, assuming they are consistent w.r.t. 'virtual', indexer argument types etc. /// When checking consistency we split these apart - member x.DropSetter = + member x.DropSetter() = match x with | FSProp(g, ty, Some vref, _) -> FSProp(g, ty, Some vref, None) | _ -> x - /// Return a new property info where there is no associated getter, only an associated setter. - member x.DropGetter = + member x.DropGetter() = match x with | FSProp(g, ty, _, Some vref) -> FSProp(g, ty, None, Some vref) | _ -> x @@ -2181,7 +2152,6 @@ type PropInfo = /// For an extension property, this indicates if the property extends a struct type. member x.IsValueType = isStructTy x.TcGlobals x.ApparentEnclosingType - /// Get the result type of the property member x.GetPropertyType (amap, m) = match x with @@ -2198,7 +2168,6 @@ type PropInfo = Import.ImportProvidedType amap m (pi.PApply((fun pi -> pi.PropertyType), m)) #endif - /// Get the names and types of the indexer parameters associated with the property /// /// If the property is in a generic type, then the type parameters are instantiated in the types returned. @@ -2290,7 +2259,7 @@ type PropInfo = /// Describes an F# use of an event backed by Abstract IL metadata [] type ILEventInfo = - | ILEventInfo of ILTypeInfo * ILEventDef + | ILEventInfo of ilTypeInfo: ILTypeInfo * ilEventDef: ILEventDef /// Get the enclosing ("parent"/"declaring") type of the field. member x.ApparentEnclosingType = match x with ILEventInfo(tinfo, _) -> tinfo.ToType @@ -2366,12 +2335,14 @@ let FindDelegateTypeOfPropertyEvent g amap nm m ty = [] type EventInfo = /// An F# use of an event backed by F#-declared metadata - | FSEvent of TcGlobals * PropInfo * ValRef * ValRef + | FSEvent of tcGlobals: TcGlobals * propInfo: PropInfo * addMethod: ValRef * removeMethod: ValRef + /// An F# use of an event backed by .NET metadata - | ILEvent of ILEventInfo + | ILEvent of ilEventInfo: ILEventInfo + #if !NO_EXTENSIONTYPING /// An F# use of an event backed by provided metadata - | ProvidedEvent of Import.ImportMap * Tainted * range + | ProvidedEvent of amap: Import.ImportMap * providedEvent: Tainted * range: range #endif /// Get the enclosing type of the event. @@ -2401,7 +2372,6 @@ type EventInfo = | Some vref when x.IsExtensionMember && vref.HasDeclaringEntity -> vref.TopValDeclaringEntity | _ -> x.ApparentEnclosingTyconRef - /// Indicates if this event has an associated XML comment authored in this assembly. member x.HasDirectXmlComment = match x with @@ -2509,7 +2479,6 @@ type EventInfo = Import.ImportProvidedType amap m (ei.PApply((fun ei -> ei.EventHandlerType), m)) #endif - /// Test whether two event infos have the same underlying definition. /// Must be compatible with ItemsAreEffectivelyEqual relation. static member EventInfosUseIdenticalDefinitions x1 x2 = @@ -2543,7 +2512,7 @@ let stripByrefTy g ty = /// Represents the information about the compiled form of a method signature. Used when analyzing implementation /// relations between members and abstract slots. -type CompiledSig = CompiledSig of TType list list * TType option * Typars * TyparInst +type CompiledSig = CompiledSig of argTys: TType list list * returnTy: TType option * formalMethTypars: Typars * formalMethTyparInst: TyparInst /// Get the information about the compiled form of a method signature. Used when analyzing implementation /// relations between members and abstract slots. @@ -2563,7 +2532,6 @@ let CompiledSigOfMeth g amap m (minfo: MethInfo) = CompiledSig(vargtys, vrty, formalMethTypars, fmtpinst) - /// Inref and outref parameter types will be treated as a byref type for equivalency. let MethInfosEquivByPartialSig erasureFlag ignoreFinal g amap m (minfo: MethInfo) (minfo2: MethInfo) = (minfo.GenericArity = minfo2.GenericArity) && @@ -2583,14 +2551,14 @@ let MethInfosEquivByNameAndPartialSig erasureFlag ignoreFinal g amap m (minfo: M (minfo.LogicalName = minfo2.LogicalName) && MethInfosEquivByPartialSig erasureFlag ignoreFinal g amap m minfo minfo2 -/// Used to hide/filter members from super classes based on signature +/// Used to hide/filter members from base classes based on signature let PropInfosEquivByNameAndPartialSig erasureFlag g amap m (pinfo: PropInfo) (pinfo2: PropInfo) = pinfo.PropertyName = pinfo2.PropertyName && let argtys = pinfo.GetParamTypes(amap, m) let argtys2 = pinfo2.GetParamTypes(amap, m) List.lengthsEqAndForall2 (typeEquivAux erasureFlag g) argtys argtys2 -/// Used to hide/filter members from super classes based on signature +/// Used to hide/filter members from base classes based on signature let MethInfosEquivByNameAndSig erasureFlag ignoreFinal g amap m minfo minfo2 = MethInfosEquivByNameAndPartialSig erasureFlag ignoreFinal g amap m minfo minfo2 && let (CompiledSig(_, retTy, formalMethTypars, _)) = CompiledSigOfMeth g amap m minfo @@ -2608,5 +2576,5 @@ let PropInfosEquivByNameAndSig erasureFlag g amap m (pinfo: PropInfo) (pinfo2: P typeEquivAux erasureFlag g retTy retTy2 let SettersOfPropInfos (pinfos: PropInfo list) = pinfos |> List.choose (fun pinfo -> if pinfo.HasSetter then Some(pinfo.SetterMethod, Some pinfo) else None) -let GettersOfPropInfos (pinfos: PropInfo list) = pinfos |> List.choose (fun pinfo -> if pinfo.HasGetter then Some(pinfo.GetterMethod, Some pinfo) else None) +let GettersOfPropInfos (pinfos: PropInfo list) = pinfos |> List.choose (fun pinfo -> if pinfo.HasGetter then Some(pinfo.GetterMethod, Some pinfo) else None) diff --git a/src/fsharp/infos.fsi b/src/fsharp/infos.fsi index a314acbd673..a2b6b5f88df 100644 --- a/src/fsharp/infos.fsi +++ b/src/fsharp/infos.fsi @@ -2,328 +2,88 @@ module internal FSharp.Compiler.Infos -open System open FSharp.Compiler -open FSharp.Compiler.AbstractIL open FSharp.Compiler.AbstractIL.IL -open FSharp.Compiler.AbstractIL.Internal.Library -open FSharp.Compiler.ErrorLogger -open FSharp.Compiler.Lib +open FSharp.Compiler.ExtensionTyping +open FSharp.Compiler.Import open FSharp.Compiler.Range -open FSharp.Compiler.SyntaxTree -open FSharp.Compiler.SyntaxTreeOps open FSharp.Compiler.TypedTree -open FSharp.Compiler.TypedTreeBasics open FSharp.Compiler.TypedTreeOps -open FSharp.Compiler.TypedTreeOps.DebugPrint open FSharp.Compiler.TcGlobals -open FSharp.Compiler.XmlDoc - -#if !NO_EXTENSIONTYPING -open FSharp.Compiler.ExtensionTyping -#endif - -//------------------------------------------------------------------------- -// From IL types to F# types -//------------------------------------------------------------------------- /// Import an IL type as an F# type. importInst gives the context for interpreting type variables. -let ImportILType scoref amap m importInst ilty = - ilty |> rescopeILType scoref |> Import.ImportILType amap m importInst +val ImportILType: scoref:ILScopeRef -> amap:ImportMap -> m:range -> importInst:TType list -> ilty:ILType -> TType -let CanImportILType scoref amap m ilty = - ilty |> rescopeILType scoref |> Import.CanImportILType amap m - -//------------------------------------------------------------------------- -// Fold the hierarchy. -// REVIEW: this code generalizes the iteration used below for member lookup. -//------------------------------------------------------------------------- +val CanImportILType: scoref:ILScopeRef -> amap:ImportMap -> m:range -> ilty:ILType -> bool /// Indicates if an F# type is the type associated with an F# exception declaration -let isExnDeclTy g ty = - match tryTcrefOfAppTy g ty with - | ValueSome tcref -> tcref.IsExceptionDecl - | _ -> false +val isExnDeclTy: g:TcGlobals -> ty:TType -> bool /// Get the base type of a type, taking into account type instantiations. Return None if the /// type has no base type. -let GetSuperTypeOfType g amap m ty = -#if !NO_EXTENSIONTYPING - let ty = - match tryTcrefOfAppTy g ty with - | ValueSome tcref when tcref.IsProvided -> stripTyEqns g ty - | _ -> stripTyEqnsAndMeasureEqns g ty -#else - let ty = stripTyEqnsAndMeasureEqns g ty -#endif - - match metadataOfTy g ty with -#if !NO_EXTENSIONTYPING - | ProvidedTypeMetadata info -> - let st = info.ProvidedType - let superOpt = st.PApplyOption((fun st -> match st.BaseType with null -> None | t -> Some t), m) - match superOpt with - | None -> None - | Some super -> Some(Import.ImportProvidedType amap m super) -#endif - | ILTypeMetadata (TILObjectReprData(scoref, _, tdef)) -> - let tinst = argsOfAppTy g ty - match tdef.Extends with - | None -> None - | Some ilty -> Some (ImportILType scoref amap m tinst ilty) - - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> - if isFSharpObjModelTy g ty || isExnDeclTy g ty then - let tcref = tcrefOfAppTy g ty - Some (instType (mkInstForAppTy g ty) (superOfTycon g tcref.Deref)) - elif isArrayTy g ty then - Some g.system_Array_ty - elif isRefTy g ty && not (isObjTy g ty) then - Some g.obj_ty - elif isStructTupleTy g ty then - Some g.system_Value_ty - elif isFSharpStructOrEnumTy g ty then - if isFSharpEnumTy g ty then - Some g.system_Enum_ty - else - Some g.system_Value_ty - elif isStructAnonRecdTy g ty then - Some g.system_Value_ty - elif isAnonRecdTy g ty then - Some g.obj_ty - elif isRecdTy g ty || isUnionTy g ty then - Some g.obj_ty - else - None - -/// Make a type for System.Collections.Generic.IList -let mkSystemCollectionsGenericIListTy (g: TcGlobals) ty = TType_app(g.tcref_System_Collections_Generic_IList, [ty]) +val GetSuperTypeOfType: g:TcGlobals -> amap:ImportMap -> m:range -> ty:TType -> TType option -[] /// Indicates whether we can skip interface types that lie outside the reference set -type SkipUnrefInterfaces = Yes | No - +[] +type SkipUnrefInterfaces = + | Yes + | No /// Collect the set of immediate declared interface types for an F# type, but do not /// traverse the type hierarchy to collect further interfaces. -let rec GetImmediateInterfacesOfType skipUnref g amap m ty = - let itys = - match tryAppTy g ty with - | ValueSome(tcref, tinst) -> - if tcref.IsMeasureableReprTycon then - [ match tcref.TypeReprInfo with - | TMeasureableRepr reprTy -> - for ity in GetImmediateInterfacesOfType skipUnref g amap m reprTy do - match tryTcrefOfAppTy g ity with - | ValueNone -> () - | ValueSome itcref -> - if not (tyconRefEq g itcref g.system_GenericIComparable_tcref) && - not (tyconRefEq g itcref g.system_GenericIEquatable_tcref) then - yield ity - | _ -> () - yield mkAppTy g.system_GenericIComparable_tcref [ty] - yield mkAppTy g.system_GenericIEquatable_tcref [ty]] - else - match metadataOfTy g ty with -#if !NO_EXTENSIONTYPING - | ProvidedTypeMetadata info -> - [ for ity in info.ProvidedType.PApplyArray((fun st -> st.GetInterfaces()), "GetInterfaces", m) do - yield Import.ImportProvidedType amap m ity ] -#endif - | ILTypeMetadata (TILObjectReprData(scoref, _, tdef)) -> - - // ImportILType may fail for an interface if the assembly load set is incomplete and the interface - // comes from another assembly. In this case we simply skip the interface: - // if we don't skip it, then compilation will just fail here, and if type checking - // succeeds with fewer non-dereferencable interfaces reported then it would have - // succeeded with more reported. There are pathological corner cases where this - // doesn't apply: e.g. for mscorlib interfaces like IComparable, but we can always - // assume those are present. - tdef.Implements |> List.choose (fun ity -> - if skipUnref = SkipUnrefInterfaces.No || CanImportILType scoref amap m ity then - Some (ImportILType scoref amap m tinst ity) - else None) - - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> - tcref.ImmediateInterfaceTypesOfFSharpTycon |> List.map (instType (mkInstForAppTy g ty)) - | _ -> [] - - - // NOTE: Anonymous record types are not directly considered to implement IComparable, - // IComparable or IEquatable. This is because whether they support these interfaces depend on their - // consitutent types, which may not yet be known in type inference. - // - // NOTE: Tuples could in theory always support IComparable etc. because this - // is in the .NET metadata for System.Tuple etc. However from the F# perspective tuple types don't - // always support the 'comparable' and 'equality' constraints (again, it depends on their constitutent types). - - // .NET array types are considered to implement IList - let itys = - if isArray1DTy g ty then - mkSystemCollectionsGenericIListTy g (destArrayTy g ty) :: itys - else - itys - - itys +val GetImmediateInterfacesOfType: skipUnref:SkipUnrefInterfaces -> g:TcGlobals -> amap:ImportMap -> m:range -> ty:TType -> TType list -[] /// Indicates whether we should visit multiple instantiations of the same generic interface or not -type AllowMultiIntfInstantiations = Yes | No - -/// Traverse the type hierarchy, e.g. f D (f C (f System.Object acc)). -/// Visit base types and interfaces first. -let private FoldHierarchyOfTypeAux followInterfaces allowMultiIntfInst skipUnref visitor g amap m ty acc = - let rec loop ndeep ty ((visitedTycon, visited: TyconRefMultiMap<_>, acc) as state) = - - let seenThisTycon = - match tryTcrefOfAppTy g ty with - | ValueSome tcref -> Set.contains tcref.Stamp visitedTycon - | _ -> false - - // Do not visit the same type twice. Could only be doing this if we've seen this tycon - if seenThisTycon && List.exists (typeEquiv g ty) (visited.Find (tcrefOfAppTy g ty)) then state else - - // Do not visit the same tycon twice, e.g. I and I, collect I only, unless directed to allow this - if seenThisTycon && allowMultiIntfInst = AllowMultiIntfInstantiations.No then state else - - let state = - match tryTcrefOfAppTy g ty with - | ValueSome tcref -> - let visitedTycon = Set.add tcref.Stamp visitedTycon - visitedTycon, visited.Add (tcref, ty), acc - | _ -> - state - - if ndeep > 100 then (errorR(Error((FSComp.SR.recursiveClassHierarchy (showType ty)), m)); (visitedTycon, visited, acc)) else - let visitedTycon, visited, acc = - if isInterfaceTy g ty then - List.foldBack - (loop (ndeep+1)) - (GetImmediateInterfacesOfType skipUnref g amap m ty) - (loop ndeep g.obj_ty state) - else - match tryDestTyparTy g ty with - | ValueSome tp -> - let state = loop (ndeep+1) g.obj_ty state - List.foldBack - (fun x vacc -> - match x with - | TyparConstraint.MayResolveMember _ - | TyparConstraint.DefaultsTo _ - | TyparConstraint.SupportsComparison _ - | TyparConstraint.SupportsEquality _ - | TyparConstraint.IsEnum _ - | TyparConstraint.IsDelegate _ - | TyparConstraint.SupportsNull _ - | TyparConstraint.IsNonNullableStruct _ - | TyparConstraint.IsUnmanaged _ - | TyparConstraint.IsReferenceType _ - | TyparConstraint.SimpleChoice _ - | TyparConstraint.RequiresDefaultConstructor _ -> vacc - | TyparConstraint.CoercesTo(cty, _) -> - loop (ndeep + 1) cty vacc) - tp.Constraints - state - | _ -> - let state = - if followInterfaces then - List.foldBack - (loop (ndeep+1)) - (GetImmediateInterfacesOfType skipUnref g amap m ty) - state - else - state - let state = - Option.foldBack - (loop (ndeep+1)) - (GetSuperTypeOfType g amap m ty) - state - state - let acc = visitor ty acc - (visitedTycon, visited, acc) - loop 0 ty (Set.empty, TyconRefMultiMap<_>.Empty, acc) |> p33 +[] +type AllowMultiIntfInstantiations = + | Yes + | No /// Fold, do not follow interfaces (unless the type is itself an interface) -let FoldPrimaryHierarchyOfType f g amap m allowMultiIntfInst ty acc = - FoldHierarchyOfTypeAux false allowMultiIntfInst SkipUnrefInterfaces.No f g amap m ty acc +val FoldPrimaryHierarchyOfType: f:(TType -> 'a -> 'a) -> g:TcGlobals -> amap:ImportMap -> m:range -> allowMultiIntfInst:AllowMultiIntfInstantiations -> ty:TType -> acc:'a -> 'a /// Fold, following interfaces. Skipping interfaces that lie outside the referenced assembly set is allowed. -let FoldEntireHierarchyOfType f g amap m allowMultiIntfInst ty acc = - FoldHierarchyOfTypeAux true allowMultiIntfInst SkipUnrefInterfaces.Yes f g amap m ty acc +val FoldEntireHierarchyOfType: f:(TType -> 'a -> 'a) -> g:TcGlobals -> amap:ImportMap -> m:range -> allowMultiIntfInst:AllowMultiIntfInstantiations -> ty:TType -> acc:'a -> 'a /// Iterate, following interfaces. Skipping interfaces that lie outside the referenced assembly set is allowed. -let IterateEntireHierarchyOfType f g amap m allowMultiIntfInst ty = - FoldHierarchyOfTypeAux true allowMultiIntfInst SkipUnrefInterfaces.Yes (fun ty () -> f ty) g amap m ty () +val IterateEntireHierarchyOfType: f:(TType -> unit) -> g:TcGlobals -> amap:ImportMap -> m:range -> allowMultiIntfInst:AllowMultiIntfInstantiations -> ty:TType -> unit /// Search for one element satisfying a predicate, following interfaces -let ExistsInEntireHierarchyOfType f g amap m allowMultiIntfInst ty = - FoldHierarchyOfTypeAux true allowMultiIntfInst SkipUnrefInterfaces.Yes (fun ty acc -> acc || f ty ) g amap m ty false +val ExistsInEntireHierarchyOfType: f:(TType -> bool) -> g:TcGlobals -> amap:ImportMap -> m:range -> allowMultiIntfInst:AllowMultiIntfInstantiations -> ty:TType -> bool /// Search for one element where a function returns a 'Some' result, following interfaces -let SearchEntireHierarchyOfType f g amap m ty = - FoldHierarchyOfTypeAux true AllowMultiIntfInstantiations.Yes SkipUnrefInterfaces.Yes - (fun ty acc -> - match acc with - | None -> if f ty then Some ty else None - | Some _ -> acc) - g amap m ty None +val SearchEntireHierarchyOfType: f:(TType -> bool) -> g:TcGlobals -> amap:ImportMap -> m:range -> ty:TType -> TType option /// Get all super types of the type, including the type itself -let AllSuperTypesOfType g amap m allowMultiIntfInst ty = - FoldHierarchyOfTypeAux true allowMultiIntfInst SkipUnrefInterfaces.No (ListSet.insert (typeEquiv g)) g amap m ty [] +val AllSuperTypesOfType: g:TcGlobals -> amap:ImportMap -> m:range -> allowMultiIntfInst:AllowMultiIntfInstantiations -> ty:TType -> TType list /// Get all interfaces of a type, including the type itself if it is an interface -let AllInterfacesOfType g amap m allowMultiIntfInst ty = - AllSuperTypesOfType g amap m allowMultiIntfInst ty |> List.filter (isInterfaceTy g) +val AllInterfacesOfType: g:TcGlobals -> amap:ImportMap -> m:range -> allowMultiIntfInst:AllowMultiIntfInstantiations -> ty:TType -> TType list /// Check if two types have the same nominal head type -let HaveSameHeadType g ty1 ty2 = - match tryTcrefOfAppTy g ty1 with - | ValueSome tcref1 -> - match tryTcrefOfAppTy g ty2 with - | ValueSome tcref2 -> tyconRefEq g tcref1 tcref2 - | _ -> false - | _ -> false +val HaveSameHeadType: g:TcGlobals -> ty1:TType -> ty2:TType -> bool /// Check if a type has a particular head type -let HasHeadType g tcref ty2 = - match tryTcrefOfAppTy g ty2 with - | ValueSome tcref2 -> tyconRefEq g tcref tcref2 - | ValueNone -> false +val HasHeadType: g:TcGlobals -> tcref:TyconRef -> ty2:TType -> bool /// Check if a type exists somewhere in the hierarchy which has the same head type as the given type (note, the given type need not have a head type at all) -let ExistsSameHeadTypeInHierarchy g amap m typeToSearchFrom typeToLookFor = - ExistsInEntireHierarchyOfType (HaveSameHeadType g typeToLookFor) g amap m AllowMultiIntfInstantiations.Yes typeToSearchFrom +val ExistsSameHeadTypeInHierarchy: g:TcGlobals -> amap:ImportMap -> m:range -> typeToSearchFrom:TType -> typeToLookFor:TType -> bool /// Check if a type exists somewhere in the hierarchy which has the given head type. -let ExistsHeadTypeInEntireHierarchy g amap m typeToSearchFrom tcrefToLookFor = - ExistsInEntireHierarchyOfType (HasHeadType g tcrefToLookFor) g amap m AllowMultiIntfInstantiations.Yes typeToSearchFrom - +val ExistsHeadTypeInEntireHierarchy: g:TcGlobals -> amap:ImportMap -> m:range -> typeToSearchFrom:TType -> tcrefToLookFor:TyconRef -> bool /// Read an Abstract IL type from metadata and convert to an F# type. -let ImportILTypeFromMetadata amap m scoref tinst minst ilty = - ImportILType scoref amap m (tinst@minst) ilty +val ImportILTypeFromMetadata: amap:ImportMap -> m:range -> scoref:ILScopeRef -> tinst:TType list -> minst:TType list -> ilty:ILType -> TType /// Read an Abstract IL type from metadata, including any attributes that may affect the type itself, and convert to an F# type. -let ImportILTypeFromMetadataWithAttributes amap m scoref tinst minst ilty cattrs = - let ty = ImportILType scoref amap m (tinst@minst) ilty - // If the type is a byref and one of attributes from a return or parameter has IsReadOnly, then it's a inref. - if isByrefTy amap.g ty && TryFindILAttribute amap.g.attrib_IsReadOnlyAttribute cattrs then - mkInByrefTy amap.g (destByrefTy amap.g ty) - else - ty +val ImportILTypeFromMetadataWithAttributes: amap:ImportMap -> m:range -> scoref:ILScopeRef -> tinst:TType list -> minst:TType list -> ilty:ILType -> cattrs:ILAttributes -> TType /// Get the parameter type of an IL method. -let ImportParameterTypeFromMetadata amap m ilty cattrs scoref tinst mist = - ImportILTypeFromMetadataWithAttributes amap m scoref tinst mist ilty cattrs +val ImportParameterTypeFromMetadata: amap:ImportMap -> m:range -> ilty:ILType -> cattrs:ILAttributes -> scoref:ILScopeRef -> tinst:TType list -> mist:TType list -> TType /// Get the return type of an IL method, taking into account instantiations for type, return attributes and method generic parameters, and /// translating 'void' to 'None'. -let ImportReturnTypeFromMetadata amap m ilty cattrs scoref tinst minst = - match ilty with - | ILType.Void -> None - | retTy -> Some(ImportILTypeFromMetadataWithAttributes amap m scoref tinst minst retTy cattrs) - +val ImportReturnTypeFromMetadata: amap:ImportMap -> m:range -> ilty:ILType -> cattrs:ILAttributes -> scoref:ILScopeRef -> tinst:TType list -> minst:TType list -> TType option /// Copy constraints. If the constraint comes from a type parameter associated /// with a type constructor then we are simply renaming type variables. If it comes @@ -333,194 +93,52 @@ let ImportReturnTypeFromMetadata amap m ilty cattrs scoref tinst minst = /// /// Note: this now looks identical to constraint instantiation. -let CopyTyparConstraints m tprefInst (tporig: Typar) = - tporig.Constraints - |> List.map (fun tpc -> - match tpc with - | TyparConstraint.CoercesTo(ty, _) -> - TyparConstraint.CoercesTo (instType tprefInst ty, m) - | TyparConstraint.DefaultsTo(priority, ty, _) -> - TyparConstraint.DefaultsTo (priority, instType tprefInst ty, m) - | TyparConstraint.SupportsNull _ -> - TyparConstraint.SupportsNull m - | TyparConstraint.IsEnum (uty, _) -> - TyparConstraint.IsEnum (instType tprefInst uty, m) - | TyparConstraint.SupportsComparison _ -> - TyparConstraint.SupportsComparison m - | TyparConstraint.SupportsEquality _ -> - TyparConstraint.SupportsEquality m - | TyparConstraint.IsDelegate(aty, bty, _) -> - TyparConstraint.IsDelegate (instType tprefInst aty, instType tprefInst bty, m) - | TyparConstraint.IsNonNullableStruct _ -> - TyparConstraint.IsNonNullableStruct m - | TyparConstraint.IsUnmanaged _ -> - TyparConstraint.IsUnmanaged m - | TyparConstraint.IsReferenceType _ -> - TyparConstraint.IsReferenceType m - | TyparConstraint.SimpleChoice (tys, _) -> - TyparConstraint.SimpleChoice (List.map (instType tprefInst) tys, m) - | TyparConstraint.RequiresDefaultConstructor _ -> - TyparConstraint.RequiresDefaultConstructor m - | TyparConstraint.MayResolveMember(traitInfo, _) -> - TyparConstraint.MayResolveMember (instTrait tprefInst traitInfo, m)) +val CopyTyparConstraints: m:range -> tprefInst:TypedTreeOps.TyparInst -> tporig:Typar -> TyparConstraint list /// The constraints for each typar copied from another typar can only be fixed up once /// we have generated all the new constraints, e.g. f List, B :> List> ... -let FixupNewTypars m (formalEnclosingTypars: Typars) (tinst: TType list) (tpsorig: Typars) (tps: Typars) = - // Checks.. These are defensive programming against early reported errors. - let n0 = formalEnclosingTypars.Length - let n1 = tinst.Length - let n2 = tpsorig.Length - let n3 = tps.Length - if n0 <> n1 then error(Error((FSComp.SR.tcInvalidTypeArgumentCount(n0, n1)), m)) - if n2 <> n3 then error(Error((FSComp.SR.tcInvalidTypeArgumentCount(n2, n3)), m)) - - // The real code.. - let renaming, tptys = mkTyparToTyparRenaming tpsorig tps - let tprefInst = mkTyparInst formalEnclosingTypars tinst @ renaming - (tpsorig, tps) ||> List.iter2 (fun tporig tp -> tp.SetConstraints (CopyTyparConstraints m tprefInst tporig)) - renaming, tptys - - -//------------------------------------------------------------------------- -// Predicates and properties on values and members - +val FixupNewTypars: m:range -> formalEnclosingTypars:Typars -> tinst:TType list -> tpsorig:Typars -> tps:Typars -> TypedTreeOps.TyparInst * TTypes type ValRef with /// Indicates if an F#-declared function or member value is a CLIEvent property compiled as a .NET event - member x.IsFSharpEventProperty g = - x.IsMember && CompileAsEvent g x.Attribs && not x.IsExtensionMember + member IsFSharpEventProperty: g:TcGlobals -> bool /// Check if an F#-declared member value is a virtual method - member vref.IsVirtualMember = - let flags = vref.MemberInfo.Value.MemberFlags - flags.IsDispatchSlot || flags.IsOverrideOrExplicitImpl + member IsVirtualMember: bool /// Check if an F#-declared member value is a dispatch slot - member vref.IsDispatchSlotMember = - let membInfo = vref.MemberInfo.Value - membInfo.MemberFlags.IsDispatchSlot + member IsDispatchSlotMember: bool /// Check if an F#-declared member value is an 'override' or explicit member implementation - member vref.IsDefiniteFSharpOverrideMember = - let membInfo = vref.MemberInfo.Value - let flags = membInfo.MemberFlags - not flags.IsDispatchSlot && (flags.IsOverrideOrExplicitImpl || not (isNil membInfo.ImplementedSlotSigs)) + member IsDefiniteFSharpOverrideMember: bool /// Check if an F#-declared member value is an explicit interface member implementation - member vref.IsFSharpExplicitInterfaceImplementation g = - match vref.MemberInfo with - | None -> false - | Some membInfo -> - not membInfo.MemberFlags.IsDispatchSlot && - (match membInfo.ImplementedSlotSigs with - | TSlotSig(_, oty, _, _, _, _) :: _ -> isInterfaceTy g oty - | [] -> false) - - member vref.ImplementedSlotSignatures = - match vref.MemberInfo with - | None -> [] - | Some membInfo -> membInfo.ImplementedSlotSigs - -//------------------------------------------------------------------------- -// Helper methods associated with using TAST metadata (F# members, values etc.) -// as backing data for MethInfo, PropInfo etc. + member IsFSharpExplicitInterfaceImplementation: g:TcGlobals -> bool + member ImplementedSlotSignatures: SlotSig list #if !NO_EXTENSIONTYPING /// Get the return type of a provided method, where 'void' is returned as 'None' -let GetCompiledReturnTyOfProvidedMethodInfo amap m (mi: Tainted) = - let returnType = - if mi.PUntaint((fun mi -> mi.IsConstructor), m) then - mi.PApply((fun mi -> mi.DeclaringType), m) - else mi.Coerce(m).PApply((fun mi -> mi.ReturnType), m) - let ty = Import.ImportProvidedType amap m returnType - if isVoidTy amap.g ty then None else Some ty +val GetCompiledReturnTyOfProvidedMethodInfo: amap:ImportMap ->m:range -> mi:Tainted -> TType option #endif /// The slotsig returned by methInfo.GetSlotSig is in terms of the type parameters on the parent type of the overriding method. /// Reverse-map the slotsig so it is in terms of the type parameters for the overriding method -let ReparentSlotSigToUseMethodTypars g m ovByMethValRef slotsig = - match PartitionValRefTypars g ovByMethValRef with - | Some(_, enclosingTypars, _, _, _) -> - let parentToMemberInst, _ = mkTyparToTyparRenaming (ovByMethValRef.MemberApparentEntity.Typars m) enclosingTypars - let res = instSlotSig parentToMemberInst slotsig - res - | None -> - // Note: it appears PartitionValRefTypars should never return 'None' - slotsig - +val ReparentSlotSigToUseMethodTypars: g:TcGlobals -> m:range -> ovByMethValRef:ValRef -> slotsig:SlotSig -> SlotSig /// Construct the data representing a parameter in the signature of an abstract method slot -let MakeSlotParam (ty, argInfo: ArgReprInfo) = TSlotParam(Option.map textOfId argInfo.Name, ty, false, false, false, argInfo.Attribs) +val MakeSlotParam: ty:TType * argInfo:ArgReprInfo -> SlotParam /// Construct the data representing the signature of an abstract method slot -let MakeSlotSig (nm, ty, ctps, mtps, paraml, retTy) = copySlotSig (TSlotSig(nm, ty, ctps, mtps, paraml, retTy)) - - -/// Split the type of an F# member value into -/// - the type parameters associated with method but matching those of the enclosing type -/// - the type parameters associated with a generic method -/// - the return type of the method -/// - the actual type arguments of the enclosing type. -let private AnalyzeTypeOfMemberVal isCSharpExt g (ty, vref: ValRef) = - let memberAllTypars, _, _, retTy, _ = GetTypeOfMemberInMemberForm g vref - if isCSharpExt || vref.IsExtensionMember then - [], memberAllTypars, retTy, [] - else - let parentTyArgs = argsOfAppTy g ty - let memberParentTypars, memberMethodTypars = List.splitAt parentTyArgs.Length memberAllTypars - memberParentTypars, memberMethodTypars, retTy, parentTyArgs - -/// Get the object type for a member value which is an extension method (C#-style or F#-style) -let private GetObjTypeOfInstanceExtensionMethod g (vref: ValRef) = - let numEnclosingTypars = CountEnclosingTyparsOfActualParentOfVal vref.Deref - let _, _, curriedArgInfos, _, _ = GetTopValTypeInCompiledForm g vref.ValReprInfo.Value numEnclosingTypars vref.Type vref.Range - curriedArgInfos.Head.Head |> fst - -/// Get the object type for a member value, which might be a C#-style extension method -let private GetArgInfosOfMember isCSharpExt g (vref: ValRef) = - if isCSharpExt then - let numEnclosingTypars = CountEnclosingTyparsOfActualParentOfVal vref.Deref - let _, _, curriedArgInfos, _, _ = GetTopValTypeInCompiledForm g vref.ValReprInfo.Value numEnclosingTypars vref.Type vref.Range - [ curriedArgInfos.Head.Tail ] - else - ArgInfosOfMember g vref - -/// Combine the type instantiation and generic method instantiation -let private CombineMethInsts ttps mtps tinst minst = (mkTyparInst ttps tinst @ mkTyparInst mtps minst) - -/// Work out the instantiation relevant to interpret the backing metadata for a member. -/// -/// The 'methTyArgs' is the instantiation of any generic method type parameters (this instantiation is -/// not included in the MethInfo objects, but carried separately). -let private GetInstantiationForMemberVal g isCSharpExt (ty, vref, methTyArgs: TypeInst) = - let memberParentTypars, memberMethodTypars, _retTy, parentTyArgs = AnalyzeTypeOfMemberVal isCSharpExt g (ty, vref) - /// In some recursive inference cases involving constraints this may need to be - /// fixed up - we allow uniform generic recursion but nothing else. - /// See https://github.com/Microsoft/visualfsharp/issues/3038#issuecomment-309429410 - let methTyArgsFixedUp = - if methTyArgs.Length < memberMethodTypars.Length then - methTyArgs @ (List.skip methTyArgs.Length memberMethodTypars |> generalizeTypars) - else - methTyArgs - CombineMethInsts memberParentTypars memberMethodTypars parentTyArgs methTyArgsFixedUp - -/// Work out the instantiation relevant to interpret the backing metadata for a property. -let private GetInstantiationForPropertyVal g (ty, vref) = - let memberParentTypars, memberMethodTypars, _retTy, parentTyArgs = AnalyzeTypeOfMemberVal false g (ty, vref) - CombineMethInsts memberParentTypars memberMethodTypars parentTyArgs (generalizeTypars memberMethodTypars) +val MakeSlotSig: nm:string * ty:TType * ctps:Typars * mtps:Typars * paraml:SlotParam list list * retTy:TType option -> SlotSig /// Describes the sequence order of the introduction of an extension method. Extension methods that are introduced /// later through 'open' get priority in overload resolution. type ExtensionMethodPriority = uint64 -//------------------------------------------------------------------------- -// OptionalArgCallerSideValue, OptionalArgInfo - /// The caller-side value for the optional arg, if any type OptionalArgCallerSideValue = - | Constant of IL.ILFieldInit + | Constant of ILFieldInit | DefaultValue | MissingValue | WrapperForIDispatch @@ -531,2082 +149,883 @@ type OptionalArgCallerSideValue = type OptionalArgInfo = /// The argument is not optional | NotOptional + /// The argument is optional, and is an F# callee-side optional arg | CalleeSide + /// The argument is optional, and is a caller-side .NET optional or default arg. /// Note this is correctly termed caller side, even though the default value is optically specified on the callee: /// in fact the default value is read from the metadata and passed explicitly to the callee on the caller side. | CallerSide of OptionalArgCallerSideValue - member x.IsOptional = match x with CalleeSide | CallerSide _ -> true | NotOptional -> false + + static member FieldInitForDefaultParameterValueAttrib: attrib:Attrib -> ILFieldInit option /// Compute the OptionalArgInfo for an IL parameter /// /// This includes the Visual Basic rules for IDispatchConstant and IUnknownConstant and optional arguments. - static member FromILParameter g amap m ilScope ilTypeInst (ilParam: ILParameter) = - if ilParam.IsOptional then - match ilParam.Default with - | None -> - // Do a type-directed analysis of the IL type to determine the default value to pass. - // The same rules as Visual Basic are applied here. - let rec analyze ty = - if isByrefTy g ty then - let ty = destByrefTy g ty - PassByRef (ty, analyze ty) - elif isObjTy g ty then - match ilParam.Marshal with - | Some(ILNativeType.IUnknown | ILNativeType.IDispatch | ILNativeType.Interface) -> Constant ILFieldInit.Null - | _ -> - if TryFindILAttributeOpt g.attrib_IUnknownConstantAttribute ilParam.CustomAttrs then WrapperForIUnknown - elif TryFindILAttributeOpt g.attrib_IDispatchConstantAttribute ilParam.CustomAttrs then WrapperForIDispatch - else MissingValue - else - DefaultValue - CallerSide (analyze (ImportILTypeFromMetadata amap m ilScope ilTypeInst [] ilParam.Type)) - | Some v -> - CallerSide (Constant v) - else - NotOptional - - static member ValueOfDefaultParameterValueAttrib (Attrib (_, _, exprs, _, _, _, _)) = - let (AttribExpr (_, defaultValueExpr)) = List.head exprs - match defaultValueExpr with - | Expr.Const (_, _, _) -> Some defaultValueExpr - | _ -> None - static member FieldInitForDefaultParameterValueAttrib attrib = - match OptionalArgInfo.ValueOfDefaultParameterValueAttrib attrib with - | Some (Expr.Const (ConstToILFieldInit fi, _, _)) -> Some fi - | _ -> None + static member FromILParameter: g:TcGlobals -> amap:ImportMap -> m:range -> ilScope:ILScopeRef -> ilTypeInst:TType list -> ilParam:ILParameter -> OptionalArgInfo + static member ValueOfDefaultParameterValueAttrib: Attrib -> Expr option + + member IsOptional: bool + type CallerInfo = | NoCallerInfo | CallerLineNumber | CallerMemberName | CallerFilePath - - override x.ToString() = sprintf "%+A" x - + [] type ReflectedArgInfo = | None | Quote of bool - member x.AutoQuote = match x with None -> false | Quote _ -> true - -//------------------------------------------------------------------------- -// ParamNameAndType, ParamData -[] + member AutoQuote: bool + /// Partial information about a parameter returned for use by the Language Service -type ParamNameAndType = - | ParamNameAndType of Ident option * TType - - static member FromArgInfo (ty, argInfo : ArgReprInfo) = ParamNameAndType(argInfo.Name, ty) - static member FromMember isCSharpExtMem g vref = GetArgInfosOfMember isCSharpExtMem g vref |> List.mapSquared ParamNameAndType.FromArgInfo - static member Instantiate inst p = let (ParamNameAndType(nm, ty)) = p in ParamNameAndType(nm, instType inst ty) - static member InstantiateCurried inst paramTypes = paramTypes |> List.mapSquared (ParamNameAndType.Instantiate inst) - [] -/// Full information about a parameter returned for use by the type checker and language service. -type ParamData = - ParamData of isParamArray: bool * isInArg: bool * isOut: bool * optArgInfo: OptionalArgInfo * callerInfo: CallerInfo * nameOpt: Ident option * reflArgInfo: ReflectedArgInfo * ttype: TType - - -//------------------------------------------------------------------------- -// Helper methods associated with type providers - -#if !NO_EXTENSIONTYPING +type ParamNameAndType = + | ParamNameAndType of SyntaxTree.Ident option * TType -type ILFieldInit with - /// Compute the ILFieldInit for the given provided constant value for a provided enum type. - static member FromProvidedObj m (v: obj) = - match v with - | null -> ILFieldInit.Null - | _ -> - let objTy = v.GetType() - let v = if objTy.IsEnum then objTy.GetField("value__").GetValue v else v - match v with - | :? single as i -> ILFieldInit.Single i - | :? double as i -> ILFieldInit.Double i - | :? bool as i -> ILFieldInit.Bool i - | :? char as i -> ILFieldInit.Char (uint16 i) - | :? string as i -> ILFieldInit.String i - | :? sbyte as i -> ILFieldInit.Int8 i - | :? byte as i -> ILFieldInit.UInt8 i - | :? int16 as i -> ILFieldInit.Int16 i - | :? uint16 as i -> ILFieldInit.UInt16 i - | :? int as i -> ILFieldInit.Int32 i - | :? uint32 as i -> ILFieldInit.UInt32 i - | :? int64 as i -> ILFieldInit.Int64 i - | :? uint64 as i -> ILFieldInit.UInt64 i - | _ -> error(Error(FSComp.SR.infosInvalidProvidedLiteralValue(try v.ToString() with _ -> "?"), m)) - - -/// Compute the OptionalArgInfo for a provided parameter. -/// -/// This is the same logic as OptionalArgInfoOfILParameter except we do not apply the -/// Visual Basic rules for IDispatchConstant and IUnknownConstant to optional -/// provided parameters. -let OptionalArgInfoOfProvidedParameter (amap: Import.ImportMap) m (provParam : Tainted) = - let g = amap.g - if provParam.PUntaint((fun p -> p.IsOptional), m) then - match provParam.PUntaint((fun p -> p.HasDefaultValue), m) with - | false -> - // Do a type-directed analysis of the IL type to determine the default value to pass. - let rec analyze ty = - if isByrefTy g ty then - let ty = destByrefTy g ty - PassByRef (ty, analyze ty) - elif isObjTy g ty then MissingValue - else DefaultValue - - let pty = Import.ImportProvidedType amap m (provParam.PApply((fun p -> p.ParameterType), m)) - CallerSide (analyze pty) - | _ -> - let v = provParam.PUntaint((fun p -> p.RawDefaultValue), m) - CallerSide (Constant (ILFieldInit.FromProvidedObj m v)) - else - NotOptional - -/// Compute the ILFieldInit for the given provided constant value for a provided enum type. -let GetAndSanityCheckProviderMethod m (mi: Tainted<'T :> ProvidedMemberInfo>) (get : 'T -> ProvidedMethodInfo) err = - match mi.PApply((fun mi -> (get mi :> ProvidedMethodBase)), m) with - | Tainted.Null -> error(Error(err(mi.PUntaint((fun mi -> mi.Name), m), mi.PUntaint((fun mi -> mi.DeclaringType.Name), m)), m)) - | meth -> meth - -/// Try to get an arbitrary ProvidedMethodInfo associated with a property. -let ArbitraryMethodInfoOfPropertyInfo (pi: Tainted) m = - if pi.PUntaint((fun pi -> pi.CanRead), m) then - GetAndSanityCheckProviderMethod m pi (fun pi -> pi.GetGetMethod()) FSComp.SR.etPropertyCanReadButHasNoGetter - elif pi.PUntaint((fun pi -> pi.CanWrite), m) then - GetAndSanityCheckProviderMethod m pi (fun pi -> pi.GetSetMethod()) FSComp.SR.etPropertyCanWriteButHasNoSetter - else - error(Error(FSComp.SR.etPropertyNeedsCanWriteOrCanRead(pi.PUntaint((fun mi -> mi.Name), m), pi.PUntaint((fun mi -> mi.DeclaringType.Name), m)), m)) + static member FromArgInfo: ty:TType * argInfo:ArgReprInfo -> ParamNameAndType -#endif + static member FromMember: isCSharpExtMem:bool -> g:TcGlobals -> vref:ValRef -> ParamNameAndType list list + static member Instantiate: inst:TypedTreeOps.TyparInst -> p:ParamNameAndType -> ParamNameAndType -//------------------------------------------------------------------------- -// ILTypeInfo + static member InstantiateCurried: inst:TypedTreeOps.TyparInst -> paramTypes:ParamNameAndType list list -> ParamNameAndType list list + +/// Full information about a parameter returned for use by the type checker and language service. +[] +type ParamData = + | ParamData of + isParamArray: bool * + isInArg: bool * + isOut: bool * + optArgInfo: OptionalArgInfo * + callerInfo: CallerInfo * + nameOpt: SyntaxTree.Ident option * + reflArgInfo: ReflectedArgInfo * + ttype: TType /// Describes an F# use of an IL type, including the type instantiation associated with the type at a particular usage point. -/// -/// This is really just 1:1 with the subset ot TType which result from building types using IL type definitions. [] type ILTypeInfo = - /// ILTypeInfo (tyconRef, ilTypeRef, typeArgs, ilTypeDef). | ILTypeInfo of TcGlobals * TType * ILTypeRef * ILTypeDef + static member FromType: g:TcGlobals -> ty:TType -> ILTypeInfo - member x.TcGlobals = let (ILTypeInfo(g, _, _, _)) = x in g - - member x.ILTypeRef = let (ILTypeInfo(_, _, tref, _)) = x in tref - - member x.RawMetadata = let (ILTypeInfo(_, _, _, tdef)) = x in tdef - - member x.ToType = let (ILTypeInfo(_, ty, _, _)) = x in ty + member Instantiate: inst:TypedTreeOps.TyparInst -> ILTypeInfo - /// Get the compiled nominal type. In the case of tuple types, this is a .NET tuple type - member x.ToAppType = convertToTypeWithMetadataIfPossible x.TcGlobals x.ToType - - member x.TyconRefOfRawMetadata = tcrefOfAppTy x.TcGlobals x.ToAppType + member ILScopeRef: ILScopeRef - member x.TypeInstOfRawMetadata = argsOfAppTy x.TcGlobals x.ToAppType + member ILTypeRef: ILTypeRef - member x.ILScopeRef = x.ILTypeRef.Scope + member IsValueType: bool - member x.Name = x.ILTypeRef.Name + member Name: string - member x.IsValueType = x.RawMetadata.IsStructOrEnum + member RawMetadata: ILTypeDef - member x.Instantiate inst = - let (ILTypeInfo(g, ty, tref, tdef)) = x - ILTypeInfo(g, instType inst ty, tref, tdef) + member TcGlobals: TcGlobals - static member FromType g ty = - if isAnyTupleTy g ty then - // When getting .NET metadata for the properties and methods - // of an F# tuple type, use the compiled nominal type, which is a .NET tuple type - let metadataTy = convertToTypeWithMetadataIfPossible g ty - assert (isILAppTy g metadataTy) - let metadataTyconRef = tcrefOfAppTy g metadataTy - let (TILObjectReprData(scoref, enc, tdef)) = metadataTyconRef.ILTyconInfo - let metadataILTypeRef = mkRefForNestedILTypeDef scoref (enc, tdef) - ILTypeInfo(g, ty, metadataILTypeRef, tdef) - elif isILAppTy g ty then - let tcref = tcrefOfAppTy g ty - let (TILObjectReprData(scoref, enc, tdef)) = tcref.ILTyconInfo - let tref = mkRefForNestedILTypeDef scoref (enc, tdef) - ILTypeInfo(g, ty, tref, tdef) - else - failwith "ILTypeInfo.FromType - no IL metadata for type" + /// Get the compiled nominal type. In the case of tuple types, this is a .NET tuple type + member ToAppType: TType -//------------------------------------------------------------------------- -// ILMethInfo + member ToType: TType + member TyconRefOfRawMetadata: TyconRef + member TypeInstOfRawMetadata: TypeInst + /// Describes an F# use of an IL method. [] type ILMethInfo = - /// ILMethInfo(g, ilApparentType, ilDeclaringTyconRefOpt, ilMethodDef, ilGenericMethodTyArgs) - /// - /// Describes an F# use of an IL method. - /// - /// If ilDeclaringTyconRefOpt is 'Some' then this is an F# use of an C#-style extension method. - /// If ilDeclaringTyconRefOpt is 'None' then ilApparentType is an IL type definition. - | ILMethInfo of TcGlobals * TType * TyconRef option * ILMethodDef * Typars + | ILMethInfo of g: TcGlobals * ilApparentType: TType * ilDeclaringTyconRefOpt: TyconRef option * ilMethodDef: ILMethodDef * ilGenericMethodTyArgs: Typars - member x.TcGlobals = match x with ILMethInfo(g, _, _, _, _) -> g + /// Like ApparentEnclosingType but use the compiled nominal type if this is a method on a tuple type + member ApparentEnclosingAppType: TType /// Get the apparent declaring type of the method as an F# type. /// If this is a C#-style extension method then this is the type which the method /// appears to extend. This may be a variable type. - member x.ApparentEnclosingType = match x with ILMethInfo(_, ty, _, _, _) -> ty - - /// Like ApparentEnclosingType but use the compiled nominal type if this is a method on a tuple type - member x.ApparentEnclosingAppType = convertToTypeWithMetadataIfPossible x.TcGlobals x.ApparentEnclosingType - - /// Get the declaring type associated with an extension member, if any. - member x.ILExtensionMethodDeclaringTyconRef = match x with ILMethInfo(_, _, tcrefOpt, _, _) -> tcrefOpt - - /// Get the Abstract IL metadata associated with the method. - member x.RawMetadata = match x with ILMethInfo(_, _, _, md, _) -> md - - /// Get the formal method type parameters associated with a method. - member x.FormalMethodTypars = match x with ILMethInfo(_, _, _, _, fmtps) -> fmtps - - /// Get the IL name of the method - member x.ILName = x.RawMetadata.Name - - /// Indicates if the method is an extension method - member x.IsILExtensionMethod = x.ILExtensionMethodDeclaringTyconRef.IsSome + member ApparentEnclosingType: TType /// Get the declaring type of the method. If this is an C#-style extension method then this is the IL type /// holding the static member that is the extension method. - member x.DeclaringTyconRef = - match x.ILExtensionMethodDeclaringTyconRef with - | Some tcref -> tcref - | None -> tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + member DeclaringTyconRef: TyconRef /// Get the instantiation of the declaring type of the method. /// If this is an C#-style extension method then this is empty because extension members /// are never in generic classes. - member x.DeclaringTypeInst = - if x.IsILExtensionMethod then [] - else argsOfAppTy x.TcGlobals x.ApparentEnclosingAppType + member DeclaringTypeInst: TType list - /// Get the Abstract IL scope information associated with interpreting the Abstract IL metadata that backs this method. - member x.MetadataScope = x.DeclaringTyconRef.CompiledRepresentationForNamedType.Scope + /// Get the formal method type parameters associated with a method. + member FormalMethodTypars: Typars - /// Get the Abstract IL metadata corresponding to the parameters of the method. - /// If this is an C#-style extension method then drop the object argument. - member x.ParamMetadata = - let ps = x.RawMetadata.Parameters - if x.IsILExtensionMethod then List.tail ps else ps + /// Get the declaring type associated with an extension member, if any. + member ILExtensionMethodDeclaringTyconRef: TyconRef option - /// Get the number of parameters of the method - member x.NumParams = x.ParamMetadata.Length + /// Get a reference to the method (dropping all generic instantiations), as an Abstract IL ILMethodRef. + member ILMethodRef: ILMethodRef - /// Indicates if the method is a constructor - member x.IsConstructor = x.RawMetadata.IsConstructor + /// Get the IL name of the method + member ILName: string + + /// Indicates if the IL method is marked abstract. + member IsAbstract: bool /// Indicates if the method is a class initializer. - member x.IsClassConstructor = x.RawMetadata.IsClassInitializer + member IsClassConstructor: bool + + /// Indicates if the method is a constructor + member IsConstructor: bool + + /// Indicates if the IL method is marked final. + member IsFinal: bool + + /// Indicates if the method is an extension method + member IsILExtensionMethod: bool + + /// Does it appear to the user as an instance method? + member IsInstance: bool + + /// Does it have the .NET IL 'newslot' flag set, and is also a virtual? + member IsNewSlot: bool /// Indicates if the method has protected accessibility, - member x.IsProtectedAccessibility = - let md = x.RawMetadata - not md.IsConstructor && - not md.IsClassInitializer && - (md.Access = ILMemberAccess.Family || md.Access = ILMemberAccess.FamilyOrAssembly) + member IsProtectedAccessibility: bool + + /// Does it appear to the user as a static method? + member IsStatic: bool /// Indicates if the IL method is marked virtual. - member x.IsVirtual = x.RawMetadata.IsVirtual + member IsVirtual: bool - /// Indicates if the IL method is marked final. - member x.IsFinal = x.RawMetadata.IsFinal + /// Get the Abstract IL scope information associated with interpreting the Abstract IL metadata that backs this method. + member MetadataScope: ILScopeRef - /// Indicates if the IL method is marked abstract. - member x.IsAbstract = x.RawMetadata.IsAbstract + /// Get the number of parameters of the method + member NumParams: int - /// Does it appear to the user as a static method? - member x.IsStatic = - not x.IsILExtensionMethod && // all C#-declared extension methods are instance - x.RawMetadata.CallingConv.IsStatic + /// Get the Abstract IL metadata corresponding to the parameters of the method. + /// If this is an C#-style extension method then drop the object argument. + member ParamMetadata: ILParameter list - /// Does it have the .NET IL 'newslot' flag set, and is also a virtual? - member x.IsNewSlot = x.RawMetadata.IsNewSlot + /// Get the Abstract IL metadata associated with the method. + member RawMetadata: ILMethodDef - /// Does it appear to the user as an instance method? - member x.IsInstance = not x.IsConstructor && not x.IsStatic + member TcGlobals: TcGlobals + + /// Get the compiled return type of the method, where 'void' is None. + member GetCompiledReturnTy: amap:ImportMap * m:range * minst:TType list -> TType option - /// Get the argument types of the the IL method. If this is an C#-style extension method - /// then drop the object argument. - member x.GetParamTypes(amap, m, minst) = - x.ParamMetadata |> List.map (fun p -> ImportParameterTypeFromMetadata amap m p.Type p.CustomAttrs x.MetadataScope x.DeclaringTypeInst minst) + /// Get the F# view of the return type of the method, where 'void' is 'unit'. + member GetFSharpReturnTy: amap:ImportMap * m:range * minst:TType list -> TType - /// Get all the argument types of the IL method. Include the object argument even if this is - /// an C#-style extension method. - member x.GetRawArgTypes(amap, m, minst) = - x.RawMetadata.Parameters |> List.map (fun p -> ImportParameterTypeFromMetadata amap m p.Type p.CustomAttrs x.MetadataScope x.DeclaringTypeInst minst) + /// Get the (zero or one) 'self'/'this'/'object' arguments associated with an IL method. + /// An instance extension method returns one object argument. + member GetObjArgTypes: amap:ImportMap * m:range * minst:TType list -> TType list /// Get info about the arguments of the IL method. If this is an C#-style extension method then /// drop the object argument. /// /// Any type parameters of the enclosing type are instantiated in the type returned. - member x.GetParamNamesAndTypes(amap, m, minst) = - x.ParamMetadata |> List.map (fun p -> ParamNameAndType(Option.map (mkSynId m) p.Name, ImportParameterTypeFromMetadata amap m p.Type p.CustomAttrs x.MetadataScope x.DeclaringTypeInst minst) ) + member GetParamNamesAndTypes: amap:ImportMap * m:range * minst:TType list -> ParamNameAndType list - /// Get a reference to the method (dropping all generic instantiations), as an Abstract IL ILMethodRef. - member x.ILMethodRef = - let mref = mkRefToILMethod (x.DeclaringTyconRef.CompiledRepresentationForNamedType, x.RawMetadata) - rescopeILMethodRef x.MetadataScope mref + /// Get the argument types of the the IL method. If this is an C#-style extension method + /// then drop the object argument. + member GetParamTypes: amap:ImportMap * m:range * minst:TType list -> TType list + + /// Get all the argument types of the IL method. Include the object argument even if this is + /// an C#-style extension method. + member GetRawArgTypes: amap:ImportMap * m:range * minst:TType list -> TType list /// Indicates if the method is marked as a DllImport (a PInvoke). This is done by looking at the IL custom attributes on /// the method. - member x.IsDllImport (g: TcGlobals) = - match g.attrib_DllImportAttribute with - | None -> false - | Some attr -> - x.RawMetadata.CustomAttrs - |> TryFindILAttribute attr + member IsDllImport: g:TcGlobals -> bool /// Indicates if the method is marked with the [] attribute. This is done by looking at the IL custom attributes on /// the method. - member x.IsReadOnly (g: TcGlobals) = - x.RawMetadata.CustomAttrs - |> TryFindILAttribute g.attrib_IsReadOnlyAttribute - - /// Get the (zero or one) 'self'/'this'/'object' arguments associated with an IL method. - /// An instance extension method returns one object argument. - member x.GetObjArgTypes(amap, m, minst) = - // All C#-style extension methods are instance. We have to re-read the 'obj' type w.r.t. the - // method instantiation. - if x.IsILExtensionMethod then - let p = x.RawMetadata.Parameters.Head - [ ImportParameterTypeFromMetadata amap m p.Type p.CustomAttrs x.MetadataScope x.DeclaringTypeInst minst ] - else if x.IsInstance then - [ x.ApparentEnclosingType ] - else - [] - - /// Get the compiled return type of the method, where 'void' is None. - member x.GetCompiledReturnTy (amap, m, minst) = - ImportReturnTypeFromMetadata amap m x.RawMetadata.Return.Type x.RawMetadata.Return.CustomAttrs x.MetadataScope x.DeclaringTypeInst minst - - /// Get the F# view of the return type of the method, where 'void' is 'unit'. - member x.GetFSharpReturnTy (amap, m, minst) = - x.GetCompiledReturnTy(amap, m, minst) - |> GetFSharpViewOfReturnType amap.g - -//------------------------------------------------------------------------- -// MethInfo + member IsReadOnly: g:TcGlobals -> bool - -[] /// Describes an F# use of a method [] type MethInfo = - /// FSMeth(tcGlobals, enclosingType, valRef, extensionMethodPriority). - /// + /// Describes a use of a method declared in F# code and backed by F# metadata. - | FSMeth of TcGlobals * TType * ValRef * ExtensionMethodPriority option + | FSMeth of tcGlobals: TcGlobals * enclosingType: TType * valRef: ValRef * extensionMethodPriority: ExtensionMethodPriority option - /// ILMeth(tcGlobals, ilMethInfo, extensionMethodPriority). - /// /// Describes a use of a method backed by Abstract IL # metadata - | ILMeth of TcGlobals * ILMethInfo * ExtensionMethodPriority option + | ILMeth of tcGlobals: TcGlobals * ilMethInfo: ILMethInfo * extensionMethodPriority: ExtensionMethodPriority option /// Describes a use of a pseudo-method corresponding to the default constructor for a .NET struct type - | DefaultStructCtor of TcGlobals * TType + | DefaultStructCtor of tcGlobals: TcGlobals * structTy: TType #if !NO_EXTENSIONTYPING /// Describes a use of a method backed by provided metadata - | ProvidedMeth of Import.ImportMap * Tainted * ExtensionMethodPriority option * range + | ProvidedMeth of amap: Import.ImportMap * methodBase: Tainted * extensionMethodPriority: ExtensionMethodPriority option * m: range #endif + /// Get the enclosing type of the method info, using a nominal type for tuple types + member ApparentEnclosingAppType: TType + + member ApparentEnclosingTyconRef: TyconRef + /// Get the enclosing type of the method info. /// /// If this is an extension member, then this is the apparent parent, i.e. the type the method appears to extend. /// This may be a variable type. - member x.ApparentEnclosingType = - match x with - | ILMeth(_, ilminfo, _) -> ilminfo.ApparentEnclosingType - | FSMeth(_, ty, _, _) -> ty - | DefaultStructCtor(_, ty) -> ty -#if !NO_EXTENSIONTYPING - | ProvidedMeth(amap, mi, _, m) -> - Import.ImportProvidedType amap m (mi.PApply((fun mi -> mi.DeclaringType), m)) -#endif + member ApparentEnclosingType: TType - /// Get the enclosing type of the method info, using a nominal type for tuple types - member x.ApparentEnclosingAppType = - convertToTypeWithMetadataIfPossible x.TcGlobals x.ApparentEnclosingType + /// Try to get an arbitrary F# ValRef associated with the member. This is to determine if the member is virtual, amongst other things. + member ArbitraryValRef: ValRef option - member x.ApparentEnclosingTyconRef = - tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + /// Get the method name in DebuggerDisplayForm + member DebuggerDisplayName: string /// Get the declaring type or module holding the method. If this is an C#-style extension method then this is the type /// holding the static member that is the extension method. If this is an F#-style extension method it is the logical module /// holding the value for the extension method. - member x.DeclaringTyconRef = - match x with - | ILMeth(_, ilminfo, _) when x.IsExtensionMember -> ilminfo.DeclaringTyconRef - | FSMeth(_, _, vref, _) when x.IsExtensionMember && vref.HasDeclaringEntity -> vref.TopValDeclaringEntity - | _ -> x.ApparentEnclosingTyconRef - - /// Get the information about provided static parameters, if any - member x.ProvidedStaticParameterInfo = - match x with - | ILMeth _ -> None - | FSMeth _ -> None -#if !NO_EXTENSIONTYPING - | ProvidedMeth (_, mb, _, m) -> - let staticParams = mb.PApplyWithProvider((fun (mb, provider) -> mb.GetStaticParametersForMethod provider), range=m) - let staticParams = staticParams.PApplyArray(id, "GetStaticParametersForMethod", m) - match staticParams with - | [| |] -> None - | _ -> Some (mb, staticParams) -#endif - | DefaultStructCtor _ -> None - - - /// Get the extension method priority of the method, if it has one. - member x.ExtensionMemberPriorityOption = - match x with - | ILMeth(_, _, pri) -> pri - | FSMeth(_, _, _, pri) -> pri -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, _, pri, _) -> pri -#endif - | DefaultStructCtor _ -> None - - /// Get the extension method priority of the method. If it is not an extension method - /// then use the highest possible value since non-extension methods always take priority - /// over extension members. - member x.ExtensionMemberPriority = defaultArg x.ExtensionMemberPriorityOption System.UInt64.MaxValue - - /// Get the method name in DebuggerDisplayForm - member x.DebuggerDisplayName = - match x with - | ILMeth(_, y, _) -> "ILMeth: " + y.ILName - | FSMeth(_, _, vref, _) -> "FSMeth: " + vref.LogicalName -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m) -> "ProvidedMeth: " + mi.PUntaint((fun mi -> mi.Name), m) -#endif - | DefaultStructCtor _ -> ".ctor" - - /// Get the method name in LogicalName form, i.e. the name as it would be stored in .NET metadata - member x.LogicalName = - match x with - | ILMeth(_, y, _) -> y.ILName - | FSMeth(_, _, vref, _) -> vref.LogicalName -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.Name), m) -#endif - | DefaultStructCtor _ -> ".ctor" - - /// Get the method name in DisplayName form - member x.DisplayName = - match x with - | FSMeth(_, _, vref, _) -> vref.DisplayName - | _ -> x.LogicalName - - /// Indicates if this is a method defined in this assembly with an internal XML comment - member x.HasDirectXmlComment = - match x with - | FSMeth(g, _, vref, _) -> valRefInThisAssembly g.compilingFslib vref -#if !NO_EXTENSIONTYPING - | ProvidedMeth _ -> true -#endif - | _ -> false - - override x.ToString() = x.ApparentEnclosingType.ToString() + x.LogicalName + member DeclaringTyconRef: TyconRef /// Get the actual type instantiation of the declaring type associated with this use of the method. /// /// For extension members this is empty (the instantiation of the declaring type). - member x.DeclaringTypeInst = - if x.IsExtensionMember then [] else argsOfAppTy x.TcGlobals x.ApparentEnclosingAppType - - /// Get the TcGlobals value that governs the method declaration - member x.TcGlobals = - match x with - | ILMeth(g, _, _) -> g - | FSMeth(g, _, _, _) -> g - | DefaultStructCtor (g, _) -> g -#if !NO_EXTENSIONTYPING - | ProvidedMeth(amap, _, _, _) -> amap.g -#endif + member DeclaringTypeInst: TType list - /// Get the formal generic method parameters for the method as a list of type variables. - /// - /// For an extension method this includes all type parameters, even if it is extending a generic type. - member x.FormalMethodTypars = - match x with - | ILMeth(_, ilmeth, _) -> ilmeth.FormalMethodTypars - | FSMeth(g, _, vref, _) -> - let ty = x.ApparentEnclosingAppType - let _, memberMethodTypars, _, _ = AnalyzeTypeOfMemberVal x.IsCSharpStyleExtensionMember g (ty, vref) - memberMethodTypars - | DefaultStructCtor _ -> [] -#if !NO_EXTENSIONTYPING - | ProvidedMeth _ -> [] // There will already have been an error if there are generic parameters here. -#endif + /// Get the method name in DisplayName form + member DisplayName: string - /// Get the formal generic method parameters for the method as a list of variable types. - member x.FormalMethodInst = generalizeTypars x.FormalMethodTypars + /// Get the extension method priority of the method. If it is not an extension method + /// then use the highest possible value since non-extension methods always take priority + /// over extension members. + member ExtensionMemberPriority: ExtensionMethodPriority - member x.FormalMethodTyparInst = mkTyparInst x.FormalMethodTypars x.FormalMethodInst + /// Get the extension method priority of the method, if it has one. + member ExtensionMemberPriorityOption: ExtensionMethodPriority option - /// Get the XML documentation associated with the method - member x.XmlDoc = - match x with - | ILMeth(_, _, _) -> XmlDoc.Empty - | FSMeth(_, _, vref, _) -> vref.XmlDoc - | DefaultStructCtor _ -> XmlDoc.Empty -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m)-> - let lines = mi.PUntaint((fun mix -> (mix :> IProvidedCustomAttributeProvider).GetXmlDocAttributes(mi.TypeProvider.PUntaintNoFailure id)), m) - XmlDoc (lines, m) -#endif + /// Get the formal generic method parameters for the method as a list of variable types. + member FormalMethodInst: TypeInst - /// Try to get an arbitrary F# ValRef associated with the member. This is to determine if the member is virtual, amongst other things. - member x.ArbitraryValRef = - match x with - | FSMeth(_g, _, vref, _) -> Some vref - | _ -> None + member FormalMethodTyparInst: TypedTreeOps.TyparInst - /// Get a list of argument-number counts, one count for each set of curried arguments. + /// Get the formal generic method parameters for the method as a list of type variables. /// - /// For an extension member, drop the 'this' argument. - member x.NumArgs = - match x with - | ILMeth(_, ilminfo, _) -> [ilminfo.NumParams] - | FSMeth(g, _, vref, _) -> GetArgInfosOfMember x.IsCSharpStyleExtensionMember g vref |> List.map List.length - | DefaultStructCtor _ -> [0] -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m) -> [mi.PUntaint((fun mi -> mi.GetParameters().Length), m)] // Why is this a list? Answer: because the method might be curried -#endif - - member x.IsCurried = x.NumArgs.Length > 1 - - /// Does the method appear to the user as an instance method? - member x.IsInstance = - match x with - | ILMeth(_, ilmeth, _) -> ilmeth.IsInstance - | FSMeth(_, _, vref, _) -> vref.IsInstanceMember || x.IsCSharpStyleExtensionMember - | DefaultStructCtor _ -> false -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> not mi.IsConstructor && not mi.IsStatic), m) -#endif - + /// For an extension method this includes all type parameters, even if it is extending a generic type. + member FormalMethodTypars: Typars /// Get the number of generic method parameters for a method. /// For an extension method this includes all type parameters, even if it is extending a generic type. - member x.GenericArity = x.FormalMethodTypars.Length - - member x.IsProtectedAccessibility = - match x with - | ILMeth(_, ilmeth, _) -> ilmeth.IsProtectedAccessibility - | FSMeth _ -> false - | DefaultStructCtor _ -> false -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsFamily), m) -#endif + member GenericArity: int - member x.IsVirtual = - match x with - | ILMeth(_, ilmeth, _) -> ilmeth.IsVirtual - | FSMeth(_, _, vref, _) -> vref.IsVirtualMember - | DefaultStructCtor _ -> false -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsVirtual), m) -#endif - - member x.IsConstructor = - match x with - | ILMeth(_, ilmeth, _) -> ilmeth.IsConstructor - | FSMeth(_g, _, vref, _) -> (vref.MemberInfo.Value.MemberFlags.MemberKind = MemberKind.Constructor) - | DefaultStructCtor _ -> true -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsConstructor), m) -#endif - - member x.IsClassConstructor = - match x with - | ILMeth(_, ilmeth, _) -> ilmeth.IsClassConstructor - | FSMeth(_, _, vref, _) -> - match vref.TryDeref with - | ValueSome x -> x.IsClassConstructor - | _ -> false - | DefaultStructCtor _ -> false -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsConstructor && mi.IsStatic), m) // Note: these are never public anyway -#endif + /// Indicates if this is a method defined in this assembly with an internal XML comment + member HasDirectXmlComment: bool - member x.IsDispatchSlot = - match x with - | ILMeth(_g, ilmeth, _) -> ilmeth.IsVirtual - | FSMeth(g, _, vref, _) as x -> - isInterfaceTy g x.ApparentEnclosingType || - vref.MemberInfo.Value.MemberFlags.IsDispatchSlot - | DefaultStructCtor _ -> false -#if !NO_EXTENSIONTYPING - | ProvidedMeth _ -> x.IsVirtual // Note: follow same implementation as ILMeth -#endif - - - member x.IsFinal = - not x.IsVirtual || - match x with - | ILMeth(_, ilmeth, _) -> ilmeth.IsFinal - | FSMeth(_g, _, _vref, _) -> false - | DefaultStructCtor _ -> true -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsFinal), m) -#endif + member ImplementedSlotSignatures: SlotSig list - // This means 'is this particular MethInfo one that doesn't provide an implementation?'. + // Is this particular MethInfo one that doesn't provide an implementation? + /// // For F# methods, this is 'true' for the MethInfos corresponding to 'abstract' declarations, // and false for the (potentially) matching 'default' implementation MethInfos that eventually // provide an implementation for the dispatch slot. // // For IL methods, this is 'true' for abstract methods, and 'false' for virtual methods - member minfo.IsAbstract = - match minfo with - | ILMeth(_, ilmeth, _) -> ilmeth.IsAbstract - | FSMeth(g, _, vref, _) -> isInterfaceTy g minfo.ApparentEnclosingType || vref.IsDispatchSlotMember - | DefaultStructCtor _ -> false -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsAbstract), m) -#endif + member IsAbstract: bool - member x.IsNewSlot = - (x.IsVirtual && - (match x with - | ILMeth(_, x, _) -> x.IsNewSlot - | FSMeth(_, _, vref, _) -> vref.IsDispatchSlotMember -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, m) -> mi.PUntaint((fun mi -> mi.IsHideBySig), m) // REVIEW: Check this is correct -#endif - | DefaultStructCtor _ -> false)) + /// Indicates if this is an C#-style extension member. + member IsCSharpStyleExtensionMember: bool - /// Indicates if this is an IL method. - member x.IsILMethod = - match x with - | ILMeth _ -> true - | _ -> false + member IsClassConstructor: bool - /// Check if this method is an explicit implementation of an interface member - member x.IsFSharpExplicitInterfaceImplementation = - match x with - | ILMeth _ -> false - | FSMeth(g, _, vref, _) -> vref.IsFSharpExplicitInterfaceImplementation g - | DefaultStructCtor _ -> false -#if !NO_EXTENSIONTYPING - | ProvidedMeth _ -> false -#endif + member IsConstructor: bool + + member IsCurried: bool /// Check if this method is marked 'override' and thus definitely overrides another method. - member x.IsDefiniteFSharpOverride = - match x with - | ILMeth _ -> false - | FSMeth(_, _, vref, _) -> vref.IsDefiniteFSharpOverrideMember - | DefaultStructCtor _ -> false -#if !NO_EXTENSIONTYPING - | ProvidedMeth _ -> false -#endif + member IsDefiniteFSharpOverride: bool - member x.ImplementedSlotSignatures = - match x with - | FSMeth(_, _, vref, _) -> vref.ImplementedSlotSignatures - | _ -> failwith "not supported" + member IsDispatchSlot: bool /// Indicates if this is an extension member. - member x.IsExtensionMember = - match x with - | FSMeth (_, _, vref, pri) -> pri.IsSome || vref.IsExtensionMember - | ILMeth (_, _, Some _) -> true - | _ -> false + member IsExtensionMember: bool - /// Indicates if this is an extension member (e.g. on a struct) that takes a byref arg - member x.ObjArgNeedsAddress (amap: Import.ImportMap, m) = - (x.IsStruct && not x.IsExtensionMember) || - match x.GetObjArgTypes (amap, m, x.FormalMethodInst) with - | [h] -> isByrefTy amap.g h - | _ -> false + /// Indicates if this method is a generated method associated with an F# CLIEvent property compiled as a .NET event + member IsFSharpEventPropertyMethod: bool - /// Indicates if this is an F# extension member. - member x.IsFSharpStyleExtensionMember = - match x with FSMeth (_, _, vref, _) -> vref.IsExtensionMember | _ -> false + /// Check if this method is an explicit implementation of an interface member + member IsFSharpExplicitInterfaceImplementation: bool - /// Indicates if this is an C#-style extension member. - member x.IsCSharpStyleExtensionMember = - match x with - | FSMeth (_, _, vref, Some _) -> not vref.IsExtensionMember - | ILMeth (_, _, Some _) -> true - | _ -> false + /// Indicates if this is an F#-style extension member. + member IsFSharpStyleExtensionMember: bool - /// Add the actual type instantiation of the apparent type of an F# extension method. - // - // When an explicit type instantiation is given for an F# extension members the type - // arguments implied by the object type are not given in source code. This means we must - // add them explicitly. For example - // type List<'T> with - // member xs.Map<'U>(f : 'T -> 'U) = .... - // is called as - // xs.Map - // but is compiled as a generic methods with two type arguments - // Map<'T, 'U>(this: List<'T>, f : 'T -> 'U) - member x.AdjustUserTypeInstForFSharpStyleIndexedExtensionMembers tyargs = - (if x.IsFSharpStyleExtensionMember then argsOfAppTy x.TcGlobals x.ApparentEnclosingAppType else []) @ tyargs + member IsFinal: bool - /// Indicates if this method is a generated method associated with an F# CLIEvent property compiled as a .NET event - member x.IsFSharpEventPropertyMethod = - match x with - | FSMeth(g, _, vref, _) -> vref.IsFSharpEventProperty g -#if !NO_EXTENSIONTYPING - | ProvidedMeth _ -> false -#endif - | _ -> false + /// Indicates if this is an IL method. + member IsILMethod: bool + + /// Does the method appear to the user as an instance method? + member IsInstance: bool + + member IsNewSlot: bool /// Indicates if this method takes no arguments - member x.IsNullary = (x.NumArgs = [0]) + member IsNullary: bool - /// Indicates if the enclosing type for the method is a value type. - /// - /// For an extension method, this indicates if the method extends a struct type. - member x.IsStruct = - isStructTy x.TcGlobals x.ApparentEnclosingType + member IsProtectedAccessibility: bool /// Indicates if this method is read-only; usually by the [] attribute. /// Must be an instance method. /// Receiver must be a struct type. - member x.IsReadOnly = - // Perf Review: Is there a way we can cache this result? - x.IsInstance && - x.IsStruct && - match x with - | ILMeth (g, ilMethInfo, _) -> ilMethInfo.IsReadOnly g - | FSMeth _ -> false // F# defined methods not supported yet. Must be a language feature. - | _ -> false + member IsReadOnly: bool - /// Indicates if this method is an extension member that is read-only. - /// An extension member is considered read-only if the first argument is a read-only byref (inref) type. - member x.IsReadOnlyExtensionMember (amap: Import.ImportMap, m) = - x.IsExtensionMember && - x.TryObjArgByrefType(amap, m, x.FormalMethodInst) - |> Option.exists (isInByrefTy amap.g) + /// Indicates if the enclosing type for the method is a value type. + /// + /// For an extension method, this indicates if the method extends a struct type. + member IsStruct: bool + member IsVirtual: bool + + /// Get the method name in LogicalName form, i.e. the name as it would be stored in .NET metadata + member LogicalName: string + + /// Get a list of argument-number counts, one count for each set of curried arguments. + /// + /// For an extension member, drop the 'this' argument. + member NumArgs: int list + + /// Get the information about provided static parameters, if any + member ProvidedStaticParameterInfo: (Tainted * Tainted []) option + + /// Get the TcGlobals value that governs the method declaration + member TcGlobals: TcGlobals + + /// Get the XML documentation associated with the method + member XmlDoc: XmlDoc.XmlDoc + /// Build IL method infos. - static member CreateILMeth (amap: Import.ImportMap, m, ty: TType, md: ILMethodDef) = - let tinfo = ILTypeInfo.FromType amap.g ty - let mtps = Import.ImportILGenericParameters (fun () -> amap) m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata md.GenericParams - ILMeth (amap.g, ILMethInfo(amap.g, ty, None, md, mtps), None) + static member CreateILMeth: amap:ImportMap * m:range * ty:TType * md:ILMethodDef -> MethInfo /// Build IL method infos for a C#-style extension method - static member CreateILExtensionMeth (amap, m, apparentTy: TType, declaringTyconRef: TyconRef, extMethPri, md: ILMethodDef) = - let scoref = declaringTyconRef.CompiledRepresentationForNamedType.Scope - let mtps = Import.ImportILGenericParameters (fun () -> amap) m scoref [] md.GenericParams - ILMeth (amap.g, ILMethInfo(amap.g, apparentTy, Some declaringTyconRef, md, mtps), extMethPri) + static member CreateILExtensionMeth: amap:ImportMap * m:range * apparentTy:TType * declaringTyconRef:TyconRef * extMethPri:ExtensionMethodPriority option * md:ILMethodDef -> MethInfo /// Tests whether two method infos have the same underlying definition. /// Used to merge operator overloads collected from left and right of an operator constraint. - /// Must be compatible with ItemsAreEffectivelyEqual relation. - static member MethInfosUseIdenticalDefinitions x1 x2 = - match x1, x2 with - | ILMeth(_, x1, _), ILMeth(_, x2, _) -> (x1.RawMetadata === x2.RawMetadata) - | FSMeth(g, _, vref1, _), FSMeth(_, _, vref2, _) -> valRefEq g vref1 vref2 - | DefaultStructCtor _, DefaultStructCtor _ -> tyconRefEq x1.TcGlobals x1.DeclaringTyconRef x2.DeclaringTyconRef -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi1, _, _), ProvidedMeth(_, mi2, _, _) -> ProvidedMethodBase.TaintedEquals (mi1, mi2) -#endif - | _ -> false - - /// Calculates a hash code of method info. Must be compatible with ItemsAreEffectivelyEqual relation. - member x.ComputeHashCode() = - match x with - | ILMeth(_, x1, _) -> hash x1.RawMetadata.Name - | FSMeth(_, _, vref, _) -> hash vref.LogicalName - | DefaultStructCtor(_, _ty) -> 34892 // "ty" doesn't support hashing. We could use "hash (tcrefOfAppTy g ty).CompiledName" or - // something but we don't have a "g" parameter here yet. But this hash need only be very approximate anyway -#if !NO_EXTENSIONTYPING - | ProvidedMeth(_, mi, _, _) -> ProvidedMethodInfo.TaintedGetHashCode mi -#endif + /// + /// Compatible with ItemsAreEffectivelyEqual relation. + static member MethInfosUseIdenticalDefinitions: x1:MethInfo -> x2:MethInfo -> bool - /// Apply a type instantiation to a method info, i.e. apply the instantiation to the enclosing type. - member x.Instantiate(amap, m, inst) = - match x with - | ILMeth(_g, ilminfo, pri) -> - match ilminfo with - | ILMethInfo(_, ty, None, md, _) -> MethInfo.CreateILMeth(amap, m, instType inst ty, md) - | ILMethInfo(_, ty, Some declaringTyconRef, md, _) -> MethInfo.CreateILExtensionMeth(amap, m, instType inst ty, declaringTyconRef, pri, md) - | FSMeth(g, ty, vref, pri) -> FSMeth(g, instType inst ty, vref, pri) - | DefaultStructCtor(g, ty) -> DefaultStructCtor(g, instType inst ty) -#if !NO_EXTENSIONTYPING - | ProvidedMeth _ -> - match inst with - | [] -> x - | _ -> assert false; failwith "Not supported" -#endif + /// Add the actual type instantiation of the apparent type of an F# extension method. + member AdjustUserTypeInstForFSharpStyleIndexedExtensionMembers: tyargs:TType list -> TType list + + /// Calculates a hash code of method info. Compatible with ItemsAreEffectivelyEqual relation. + member ComputeHashCode: unit -> int /// Get the return type of a method info, where 'void' is returned as 'None' - member x.GetCompiledReturnTy (amap, m, minst) = - match x with - | ILMeth(_g, ilminfo, _) -> - ilminfo.GetCompiledReturnTy(amap, m, minst) - | FSMeth(g, _, vref, _) -> - let ty = x.ApparentEnclosingAppType - let inst = GetInstantiationForMemberVal g x.IsCSharpStyleExtensionMember (ty, vref, minst) - let _, _, retTy, _ = AnalyzeTypeOfMemberVal x.IsCSharpStyleExtensionMember g (ty, vref) - retTy |> Option.map (instType inst) - | DefaultStructCtor _ -> None -#if !NO_EXTENSIONTYPING - | ProvidedMeth(amap, mi, _, m) -> - GetCompiledReturnTyOfProvidedMethodInfo amap m mi -#endif + member GetCompiledReturnTy: amap:ImportMap * m:range * minst:TType list -> TType option /// Get the return type of a method info, where 'void' is returned as 'unit' - member x.GetFSharpReturnTy(amap, m, minst) = - x.GetCompiledReturnTy(amap, m, minst) |> GetFSharpViewOfReturnType amap.g + member GetFSharpReturnTy: amap:ImportMap * m:range * minst:TType list -> TType - /// Get the parameter types of a method info - member x.GetParamTypes(amap, m, minst) = - match x with - | ILMeth(_g, ilminfo, _) -> - // A single group of tupled arguments - [ ilminfo.GetParamTypes(amap, m, minst) ] - | FSMeth(g, ty, vref, _) -> - let paramTypes = ParamNameAndType.FromMember x.IsCSharpStyleExtensionMember g vref - let inst = GetInstantiationForMemberVal g x.IsCSharpStyleExtensionMember (ty, vref, minst) - paramTypes |> List.mapSquared (fun (ParamNameAndType(_, ty)) -> instType inst ty) - | DefaultStructCtor _ -> [] -#if !NO_EXTENSIONTYPING - | ProvidedMeth(amap, mi, _, m) -> - // A single group of tupled arguments - [ [ for p in mi.PApplyArray((fun mi -> mi.GetParameters()), "GetParameters", m) do - yield Import.ImportProvidedType amap m (p.PApply((fun p -> p.ParameterType), m)) ] ] -#endif + /// Select all the type parameters of the declaring type of a method. + /// + /// For extension methods, no type parameters are returned, because all the + /// type parameters are part of the apparent type, rather the + /// declaring type, even for extension methods extending generic types. + member GetFormalTyparsOfDeclaringType: m:range -> Typar list /// Get the (zero or one) 'self'/'this'/'object' arguments associated with a method. /// An instance method returns one object argument. - member x.GetObjArgTypes (amap, m, minst) = - match x with - | ILMeth(_, ilminfo, _) -> ilminfo.GetObjArgTypes(amap, m, minst) - | FSMeth(g, _, vref, _) -> - if x.IsInstance then - let ty = x.ApparentEnclosingAppType - // The 'this' pointer of an extension member can depend on the minst - if x.IsExtensionMember then - let inst = GetInstantiationForMemberVal g x.IsCSharpStyleExtensionMember (ty, vref, minst) - let rawObjTy = GetObjTypeOfInstanceExtensionMethod g vref - [ rawObjTy |> instType inst ] - else - [ ty ] - else [] - | DefaultStructCtor _ -> [] -#if !NO_EXTENSIONTYPING - | ProvidedMeth(amap, mi, _, m) -> - if x.IsInstance then [ Import.ImportProvidedType amap m (mi.PApply((fun mi -> mi.DeclaringType), m)) ] // find the type of the 'this' argument - else [] -#endif + member GetObjArgTypes: amap:ImportMap * m:range * minst:TypeInst -> TType list /// Get the parameter attributes of a method info, which get combined with the parameter names and types - member x.GetParamAttribs(amap, m) = - match x with - | ILMeth(g, ilMethInfo, _) -> - [ [ for p in ilMethInfo.ParamMetadata do - let isParamArrayArg = TryFindILAttribute g.attrib_ParamArrayAttribute p.CustomAttrs - let reflArgInfo = - match TryDecodeILAttribute g g.attrib_ReflectedDefinitionAttribute.TypeRef p.CustomAttrs with - | Some ([ILAttribElem.Bool b ], _) -> ReflectedArgInfo.Quote b - | Some _ -> ReflectedArgInfo.Quote false - | _ -> ReflectedArgInfo.None - let isOutArg = (p.IsOut && not p.IsIn) - let isInArg = (p.IsIn && not p.IsOut) - // Note: we get default argument values from VB and other .NET language metadata - let optArgInfo = OptionalArgInfo.FromILParameter g amap m ilMethInfo.MetadataScope ilMethInfo.DeclaringTypeInst p - - let isCallerLineNumberArg = TryFindILAttribute g.attrib_CallerLineNumberAttribute p.CustomAttrs - let isCallerFilePathArg = TryFindILAttribute g.attrib_CallerFilePathAttribute p.CustomAttrs - let isCallerMemberNameArg = TryFindILAttribute g.attrib_CallerMemberNameAttribute p.CustomAttrs - - let callerInfo = - match isCallerLineNumberArg, isCallerFilePathArg, isCallerMemberNameArg with - | false, false, false -> NoCallerInfo - | true, false, false -> CallerLineNumber - | false, true, false -> CallerFilePath - | false, false, true -> CallerMemberName - | _, _, _ -> - // if multiple caller info attributes are specified, pick the "wrong" one here - // so that we get an error later - if p.Type.TypeRef.FullName = "System.Int32" then CallerFilePath - else CallerLineNumber - - yield (isParamArrayArg, isInArg, isOutArg, optArgInfo, callerInfo, reflArgInfo) ] ] - - | FSMeth(g, _, vref, _) -> - GetArgInfosOfMember x.IsCSharpStyleExtensionMember g vref - |> List.mapSquared (fun (ty, argInfo) -> - let isParamArrayArg = HasFSharpAttribute g g.attrib_ParamArrayAttribute argInfo.Attribs - let reflArgInfo = - match TryFindFSharpBoolAttributeAssumeFalse g g.attrib_ReflectedDefinitionAttribute argInfo.Attribs with - | Some b -> ReflectedArgInfo.Quote b - | None -> ReflectedArgInfo.None - let isOutArg = (HasFSharpAttribute g g.attrib_OutAttribute argInfo.Attribs && isByrefTy g ty) || isOutByrefTy g ty - let isInArg = (HasFSharpAttribute g g.attrib_InAttribute argInfo.Attribs && isByrefTy g ty) || isInByrefTy g ty - let isCalleeSideOptArg = HasFSharpAttribute g g.attrib_OptionalArgumentAttribute argInfo.Attribs - let isCallerSideOptArg = HasFSharpAttributeOpt g g.attrib_OptionalAttribute argInfo.Attribs - let optArgInfo = - if isCalleeSideOptArg then - CalleeSide - elif isCallerSideOptArg then - let defaultParameterValueAttribute = TryFindFSharpAttributeOpt g g.attrib_DefaultParameterValueAttribute argInfo.Attribs - match defaultParameterValueAttribute with - | None -> - // Do a type-directed analysis of the type to determine the default value to pass. - // Similar rules as OptionalArgInfo.FromILParameter are applied here, except for the COM and byref-related stuff. - CallerSide (if isObjTy g ty then MissingValue else DefaultValue) - | Some attr -> - let defaultValue = OptionalArgInfo.ValueOfDefaultParameterValueAttrib attr - match defaultValue with - | Some (Expr.Const (_, m, ty2)) when not (typeEquiv g ty2 ty) -> - // the type of the default value does not match the type of the argument. - // Emit a warning, and ignore the DefaultParameterValue argument altogether. - warning(Error(FSComp.SR.DefaultParameterValueNotAppropriateForArgument(), m)) - NotOptional - | Some (Expr.Const ((ConstToILFieldInit fi), _, _)) -> - // Good case - all is well. - CallerSide (Constant fi) - | _ -> - // Default value is not appropriate, i.e. not a constant. - // Compiler already gives an error in that case, so just ignore here. - NotOptional - else NotOptional - - let isCallerLineNumberArg = HasFSharpAttribute g g.attrib_CallerLineNumberAttribute argInfo.Attribs - let isCallerFilePathArg = HasFSharpAttribute g g.attrib_CallerFilePathAttribute argInfo.Attribs - let isCallerMemberNameArg = HasFSharpAttribute g g.attrib_CallerMemberNameAttribute argInfo.Attribs - - let callerInfo = - match isCallerLineNumberArg, isCallerFilePathArg, isCallerMemberNameArg with - | false, false, false -> NoCallerInfo - | true, false, false -> CallerLineNumber - | false, true, false -> CallerFilePath - | false, false, true -> CallerMemberName - | false, true, true -> - match TryFindFSharpAttribute g g.attrib_CallerMemberNameAttribute argInfo.Attribs with - | Some(Attrib(_, _, _, _, _, _, callerMemberNameAttributeRange)) -> - warning(Error(FSComp.SR.CallerMemberNameIsOverriden(argInfo.Name.Value.idText), callerMemberNameAttributeRange)) - CallerFilePath - | _ -> failwith "Impossible" - | _, _, _ -> - // if multiple caller info attributes are specified, pick the "wrong" one here - // so that we get an error later - match tryDestOptionTy g ty with - | ValueSome optTy when typeEquiv g g.int32_ty optTy -> CallerFilePath - | _ -> CallerLineNumber - - (isParamArrayArg, isInArg, isOutArg, optArgInfo, callerInfo, reflArgInfo)) - - | DefaultStructCtor _ -> - [[]] - -#if !NO_EXTENSIONTYPING - | ProvidedMeth(amap, mi, _, _) -> - // A single group of tupled arguments - [ [for p in mi.PApplyArray((fun mi -> mi.GetParameters()), "GetParameters", m) do - let isParamArrayArg = p.PUntaint((fun px -> (px :> IProvidedCustomAttributeProvider).GetAttributeConstructorArgs(p.TypeProvider.PUntaintNoFailure id, typeof.FullName).IsSome), m) - let optArgInfo = OptionalArgInfoOfProvidedParameter amap m p - let reflArgInfo = - match p.PUntaint((fun px -> (px :> IProvidedCustomAttributeProvider).GetAttributeConstructorArgs(p.TypeProvider.PUntaintNoFailure id, typeof.FullName)), m) with - | Some ([ Some (:? bool as b) ], _) -> ReflectedArgInfo.Quote b - | Some _ -> ReflectedArgInfo.Quote false - | None -> ReflectedArgInfo.None - let isOutArg = p.PUntaint((fun p -> p.IsOut && not p.IsIn), m) - let isInArg = p.PUntaint((fun p -> p.IsIn && not p.IsOut), m) - yield (isParamArrayArg, isInArg, isOutArg, optArgInfo, NoCallerInfo, reflArgInfo)] ] -#endif + member GetParamAttribs: amap:ImportMap * m:range -> (bool * bool * bool * OptionalArgInfo * CallerInfo * ReflectedArgInfo) list list + /// Get the ParamData objects for the parameters of a MethInfo + member GetParamDatas: amap:ImportMap * m:range * minst:TType list -> ParamData list list + /// Get the parameter types of a method info + member GetParamTypes: amap:ImportMap * m:range * minst:TType list -> TType list list /// Get the signature of an abstract method slot. - // - // This code has grown organically over time. We've managed to unify the ILMeth+ProvidedMeth paths. - // The FSMeth, ILMeth+ProvidedMeth paths can probably be unified too. - member x.GetSlotSig(amap, m) = - match x with - | FSMeth(g, _, vref, _) -> - match vref.RecursiveValInfo with - | ValInRecScope false -> error(Error((FSComp.SR.InvalidRecursiveReferenceToAbstractSlot()), m)) - | _ -> () - - let allTyparsFromMethod, _, _, retTy, _ = GetTypeOfMemberInMemberForm g vref - - // A slot signature is w.r.t. the type variables of the type it is associated with. - // So we have to rename from the member type variables to the type variables of the type. - let formalEnclosingTypars = x.ApparentEnclosingTyconRef.Typars m - let formalEnclosingTyparsFromMethod, formalMethTypars = List.splitAt formalEnclosingTypars.Length allTyparsFromMethod - let methodToParentRenaming, _ = mkTyparToTyparRenaming formalEnclosingTyparsFromMethod formalEnclosingTypars - let formalParams = - GetArgInfosOfMember x.IsCSharpStyleExtensionMember g vref - |> List.mapSquared (map1Of2 (instType methodToParentRenaming) >> MakeSlotParam ) - let formalRetTy = Option.map (instType methodToParentRenaming) retTy - MakeSlotSig(x.LogicalName, x.ApparentEnclosingType, formalEnclosingTypars, formalMethTypars, formalParams, formalRetTy) - | DefaultStructCtor _ -> error(InternalError("no slotsig for DefaultStructCtor", m)) - | _ -> - let g = x.TcGlobals - // slotsigs must contain the formal types for the arguments and return type - // a _formal_ 'void' return type is represented as a 'unit' type. - // slotsigs are independent of instantiation: if an instantiation - // happens to make the return type 'unit' (i.e. it was originally a variable type - // then that does not correspond to a slotsig compiled as a 'void' return type. - // REVIEW: should we copy down attributes to slot params? - let tcref = tcrefOfAppTy g x.ApparentEnclosingAppType - let formalEnclosingTyparsOrig = tcref.Typars m - let formalEnclosingTypars = copyTypars formalEnclosingTyparsOrig - let _, formalEnclosingTyparTys = FixupNewTypars m [] [] formalEnclosingTyparsOrig formalEnclosingTypars - let formalMethTypars = copyTypars x.FormalMethodTypars - let _, formalMethTyparTys = FixupNewTypars m formalEnclosingTypars formalEnclosingTyparTys x.FormalMethodTypars formalMethTypars - let formalRetTy, formalParams = - match x with - | ILMeth(_, ilminfo, _) -> - let ftinfo = ILTypeInfo.FromType g (TType_app(tcref, formalEnclosingTyparTys)) - let formalRetTy = ImportReturnTypeFromMetadata amap m ilminfo.RawMetadata.Return.Type ilminfo.RawMetadata.Return.CustomAttrs ftinfo.ILScopeRef ftinfo.TypeInstOfRawMetadata formalMethTyparTys - let formalParams = - [ [ for p in ilminfo.RawMetadata.Parameters do - let paramType = ImportILTypeFromMetadataWithAttributes amap m ftinfo.ILScopeRef ftinfo.TypeInstOfRawMetadata formalMethTyparTys p.Type p.CustomAttrs - yield TSlotParam(p.Name, paramType, p.IsIn, p.IsOut, p.IsOptional, []) ] ] - formalRetTy, formalParams -#if !NO_EXTENSIONTYPING - | ProvidedMeth (_, mi, _, _) -> - // GENERIC TYPE PROVIDERS: for generics, formal types should be generated here, not the actual types - // For non-generic type providers there is no difference - let formalRetTy = x.GetCompiledReturnTy(amap, m, formalMethTyparTys) - // GENERIC TYPE PROVIDERS: formal types should be generated here, not the actual types - // For non-generic type providers there is no difference - let formalParams = - [ [ for p in mi.PApplyArray((fun mi -> mi.GetParameters()), "GetParameters", m) do - let paramName = p.PUntaint((fun p -> match p.Name with null -> None | s -> Some s), m) - let paramType = Import.ImportProvidedType amap m (p.PApply((fun p -> p.ParameterType), m)) - let isIn, isOut, isOptional = p.PUntaint((fun p -> p.IsIn, p.IsOut, p.IsOptional), m) - yield TSlotParam(paramName, paramType, isIn, isOut, isOptional, []) ] ] - formalRetTy, formalParams -#endif - | _ -> failwith "unreachable" - MakeSlotSig(x.LogicalName, x.ApparentEnclosingType, formalEnclosingTypars, formalMethTypars, formalParams, formalRetTy) + member GetSlotSig: amap:ImportMap * m:range -> SlotSig /// Get the ParamData objects for the parameters of a MethInfo - member x.GetParamDatas(amap, m, minst) = - let paramNamesAndTypes = - match x with - | ILMeth(_g, ilminfo, _) -> - [ ilminfo.GetParamNamesAndTypes(amap, m, minst) ] - | FSMeth(g, _, vref, _) -> - let ty = x.ApparentEnclosingAppType - let items = ParamNameAndType.FromMember x.IsCSharpStyleExtensionMember g vref - let inst = GetInstantiationForMemberVal g x.IsCSharpStyleExtensionMember (ty, vref, minst) - items |> ParamNameAndType.InstantiateCurried inst - | DefaultStructCtor _ -> - [[]] -#if !NO_EXTENSIONTYPING - | ProvidedMeth(amap, mi, _, _) -> - // A single set of tupled parameters - [ [for p in mi.PApplyArray((fun mi -> mi.GetParameters()), "GetParameters", m) do - let pname = - match p.PUntaint((fun p -> p.Name), m) with - | null -> None - | name -> Some (mkSynId m name) - let pty = - match p.PApply((fun p -> p.ParameterType), m) with - | Tainted.Null -> amap.g.unit_ty - | parameterType -> Import.ImportProvidedType amap m parameterType - yield ParamNameAndType(pname, pty) ] ] - -#endif - - let paramAttribs = x.GetParamAttribs(amap, m) - (paramAttribs, paramNamesAndTypes) ||> List.map2 (List.map2 (fun (isParamArrayArg, isInArg, isOutArg, optArgInfo, callerInfo, reflArgInfo) (ParamNameAndType(nmOpt, pty)) -> - ParamData(isParamArrayArg, isInArg, isOutArg, optArgInfo, callerInfo, nmOpt, reflArgInfo, pty))) + member HasParamArrayArg: amap:ImportMap * m:range * minst:TType list -> bool - /// Get the ParamData objects for the parameters of a MethInfo - member x.HasParamArrayArg(amap, m, minst) = - x.GetParamDatas(amap, m, minst) |> List.existsSquared (fun (ParamData(isParamArrayArg, _, _, _, _, _, _, _)) -> isParamArrayArg) + /// Apply a type instantiation to a method info, i.e. apply the instantiation to the enclosing type. + member Instantiate: amap:ImportMap * m:range * inst:TypedTreeOps.TyparInst -> MethInfo + /// Indicates if this method is an extension member that is read-only. + /// An extension member is considered read-only if the first argument is a read-only byref (inref) type. + member IsReadOnlyExtensionMember: amap:ImportMap * m:range -> bool - /// Select all the type parameters of the declaring type of a method. - /// - /// For extension methods, no type parameters are returned, because all the - /// type parameters are part of the apparent type, rather the - /// declaring type, even for extension methods extending generic types. - member x.GetFormalTyparsOfDeclaringType m = - if x.IsExtensionMember then [] - else - match x with - | FSMeth(g, _, vref, _) -> - let ty = x.ApparentEnclosingAppType - let memberParentTypars, _, _, _ = AnalyzeTypeOfMemberVal false g (ty, vref) - memberParentTypars - | _ -> - x.DeclaringTyconRef.Typars m + /// Indicates if this is an extension member (e.g. on a struct) that takes a byref arg + member ObjArgNeedsAddress: amap:ImportMap * m:range -> bool /// Tries to get the object arg type if it's a byref type. - member x.TryObjArgByrefType(amap, m, minst) = - x.GetObjArgTypes(amap, m, minst) - |> List.tryHead - |> Option.bind (fun ty -> - if isByrefTy x.TcGlobals ty then Some ty - else None) - -//------------------------------------------------------------------------- -// ILFieldInfo - + member TryObjArgByrefType: amap:ImportMap * m:range * minst:TypeInst -> TType option /// Represents a single use of a IL or provided field from one point in an F# program [] type ILFieldInfo = /// Represents a single use of a field backed by Abstract IL metadata - | ILFieldInfo of ILTypeInfo * ILFieldDef // .NET IL fields -#if !NO_EXTENSIONTYPING - /// Represents a single use of a field backed by provided metadata - | ProvidedField of Import.ImportMap * Tainted * range -#endif + | ILFieldInfo of ilTypeInfo: ILTypeInfo * ilFieldDef: ILFieldDef - /// Get the enclosing ("parent"/"declaring") type of the field. - member x.ApparentEnclosingType = - match x with - | ILFieldInfo(tinfo, _) -> tinfo.ToType #if !NO_EXTENSIONTYPING - | ProvidedField(amap, fi, m) -> (Import.ImportProvidedType amap m (fi.PApply((fun fi -> fi.DeclaringType), m))) + /// Represents a single use of a field backed by provided metadata + | ProvidedField of amap: ImportMap * providedField: Tainted * range: range #endif - member x.ApparentEnclosingAppType = x.ApparentEnclosingType + /// Like ApparentEnclosingType but use the compiled nominal type if this is a method on a tuple type + member ApparentEnclosingAppType: TType - member x.ApparentEnclosingTyconRef = tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + member ApparentEnclosingTyconRef: TyconRef - member x.DeclaringTyconRef = x.ApparentEnclosingTyconRef + /// Get the enclosing ("parent"/"declaring") type of the field. + member ApparentEnclosingType: TType - member x.TcGlobals = - match x with - | ILFieldInfo(tinfo, _) -> tinfo.TcGlobals -#if !NO_EXTENSIONTYPING - | ProvidedField(amap, _, _) -> amap.g -#endif + member DeclaringTyconRef: TyconRef - /// Get a reference to the declaring type of the field as an ILTypeRef - member x.ILTypeRef = - match x with - | ILFieldInfo(tinfo, _) -> tinfo.ILTypeRef -#if !NO_EXTENSIONTYPING - | ProvidedField(amap, fi, m) -> (Import.ImportProvidedTypeAsILType amap m (fi.PApply((fun fi -> fi.DeclaringType), m))).TypeRef -#endif + /// Get the name of the field + member FieldName: string - /// Get the scope used to interpret IL metadata - member x.ScopeRef = x.ILTypeRef.Scope + /// Get an (uninstantiated) reference to the field as an Abstract IL ILFieldRef + member ILFieldRef: ILFieldRef - /// Get the type instantiation of the declaring type of the field - member x.TypeInst = - match x with - | ILFieldInfo(tinfo, _) -> tinfo.TypeInstOfRawMetadata -#if !NO_EXTENSIONTYPING - | ProvidedField _ -> [] /// GENERIC TYPE PROVIDERS -#endif + /// Get the type of the field as an IL type + member ILFieldType: ILType - /// Get the name of the field - member x.FieldName = - match x with - | ILFieldInfo(_, pd) -> pd.Name -#if !NO_EXTENSIONTYPING - | ProvidedField(_, fi, m) -> fi.PUntaint((fun fi -> fi.Name), m) -#endif + /// Get a reference to the declaring type of the field as an ILTypeRef + member ILTypeRef: ILTypeRef /// Indicates if the field is readonly (in the .NET/C# sense of readonly) - member x.IsInitOnly = - match x with - | ILFieldInfo(_, pd) -> pd.IsInitOnly -#if !NO_EXTENSIONTYPING - | ProvidedField(_, fi, m) -> fi.PUntaint((fun fi -> fi.IsInitOnly), m) -#endif + member IsInitOnly: bool - /// Indicates if the field is a member of a struct or enum type - member x.IsValueType = - match x with - | ILFieldInfo(tinfo, _) -> tinfo.IsValueType -#if !NO_EXTENSIONTYPING - | ProvidedField(amap, _, _) -> isStructTy amap.g x.ApparentEnclosingType -#endif + /// Indicates if the field has the 'specialname' property in the .NET IL + member IsSpecialName: bool /// Indicates if the field is static - member x.IsStatic = - match x with - | ILFieldInfo(_, pd) -> pd.IsStatic -#if !NO_EXTENSIONTYPING - | ProvidedField(_, fi, m) -> fi.PUntaint((fun fi -> fi.IsStatic), m) -#endif + member IsStatic: bool - /// Indicates if the field has the 'specialname' property in the .NET IL - member x.IsSpecialName = - match x with - | ILFieldInfo(_, pd) -> pd.IsSpecialName -#if !NO_EXTENSIONTYPING - | ProvidedField(_, fi, m) -> fi.PUntaint((fun fi -> fi.IsSpecialName), m) -#endif + /// Indicates if the field is a member of a struct or enum type + member IsValueType: bool /// Indicates if the field is a literal field with an associated literal value - member x.LiteralValue = - match x with - | ILFieldInfo(_, pd) -> if pd.IsLiteral then pd.LiteralValue else None -#if !NO_EXTENSIONTYPING - | ProvidedField(_, fi, m) -> - if fi.PUntaint((fun fi -> fi.IsLiteral), m) then - Some (ILFieldInit.FromProvidedObj m (fi.PUntaint((fun fi -> fi.GetRawConstantValue()), m))) - else - None -#endif + member LiteralValue: ILFieldInit option - /// Get the type of the field as an IL type - member x.ILFieldType = - match x with - | ILFieldInfo (_, fdef) -> fdef.FieldType -#if !NO_EXTENSIONTYPING - | ProvidedField(amap, fi, m) -> Import.ImportProvidedTypeAsILType amap m (fi.PApply((fun fi -> fi.FieldType), m)) -#endif + /// Get the scope used to interpret IL metadata + member ScopeRef: ILScopeRef - /// Get the type of the field as an F# type - member x.FieldType(amap, m) = - match x with - | ILFieldInfo (tinfo, fdef) -> ImportILTypeFromMetadata amap m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata [] fdef.FieldType -#if !NO_EXTENSIONTYPING - | ProvidedField(amap, fi, m) -> Import.ImportProvidedType amap m (fi.PApply((fun fi -> fi.FieldType), m)) -#endif + member TcGlobals: TcGlobals + + /// Get the type instantiation of the declaring type of the field + member TypeInst: TypeInst /// Tests whether two infos have the same underlying definition. - /// Must be compatible with ItemsAreEffectivelyEqual relation. - static member ILFieldInfosUseIdenticalDefinitions x1 x2 = - match x1, x2 with - | ILFieldInfo(_, x1), ILFieldInfo(_, x2) -> (x1 === x2) -#if !NO_EXTENSIONTYPING - | ProvidedField(_, fi1, _), ProvidedField(_, fi2, _)-> ProvidedFieldInfo.TaintedEquals (fi1, fi2) - | _ -> false -#endif - /// Get an (uninstantiated) reference to the field as an Abstract IL ILFieldRef - member x.ILFieldRef = rescopeILFieldRef x.ScopeRef (mkILFieldRef(x.ILTypeRef, x.FieldName, x.ILFieldType)) + /// Compatible with ItemsAreEffectivelyEqual relation. + static member ILFieldInfosUseIdenticalDefinitions: x1:ILFieldInfo -> x2:ILFieldInfo -> bool /// Calculates a hash code of field info. Must be compatible with ItemsAreEffectivelyEqual relation. - member x.ComputeHashCode() = hash x.FieldName - - override x.ToString() = x.FieldName + member ComputeHashCode: unit -> int + /// Get the type of the field as an F# type + member FieldType: amap:ImportMap * m:range -> TType /// Describes an F# use of a field in an F#-declared record, class or struct type [] type RecdFieldInfo = - | RecdFieldInfo of TypeInst * RecdFieldRef + | RecdFieldInfo of typeInst: TypeInst * recdFieldRef: RecdFieldRef - /// Get the generic instantiation of the declaring type of the field - member x.TypeInst = let (RecdFieldInfo(tinst, _)) = x in tinst - - /// Get a reference to the F# metadata for the uninstantiated field - member x.RecdFieldRef = let (RecdFieldInfo(_, rfref)) = x in rfref + /// Get the enclosing (declaring) type of the field in an F#-declared record, class or struct type + member DeclaringType: TType - /// Get the F# metadata for the uninstantiated field - member x.RecdField = x.RecdFieldRef.RecdField + /// Get the (instantiated) type of the field in an F#-declared record, class or struct type + member FieldType: TType /// Indicate if the field is a static field in an F#-declared record, class or struct type - member x.IsStatic = x.RecdField.IsStatic + member IsStatic: bool /// Indicate if the field is a literal field in an F#-declared record, class or struct type - member x.LiteralValue = x.RecdField.LiteralValue + member LiteralValue: Const option - /// Get a reference to the F# metadata for the F#-declared record, class or struct type - member x.TyconRef = x.RecdFieldRef.TyconRef + /// Get the name of the field in an F#-declared record, class or struct type + member Name: string - /// Get the F# metadata for the F#-declared record, class or struct type - member x.Tycon = x.RecdFieldRef.Tycon + /// Get the F# metadata for the uninstantiated field + member RecdField: RecdField - /// Get the name of the field in an F#-declared record, class or struct type - member x.Name = x.RecdField.Name + /// Get a reference to the F# metadata for the uninstantiated field + member RecdFieldRef: RecdFieldRef - /// Get the (instantiated) type of the field in an F#-declared record, class or struct type - member x.FieldType = actualTyOfRecdFieldRef x.RecdFieldRef x.TypeInst + /// Get the F# metadata for the F#-declared record, class or struct type + member Tycon: Entity - /// Get the enclosing (declaring) type of the field in an F#-declared record, class or struct type - member x.DeclaringType = TType_app (x.RecdFieldRef.TyconRef, x.TypeInst) - override x.ToString() = x.TyconRef.ToString() + "::" + x.Name + /// Get a reference to the F# metadata for the F#-declared record, class or struct type + member TyconRef: TyconRef + /// Get the generic instantiation of the declaring type of the field + member TypeInst: TypeInst /// Describes an F# use of a union case [] type UnionCaseInfo = | UnionCaseInfo of TypeInst * UnionCaseRef - /// Get the list of types for the instantiation of the type parameters of the declaring type of the union case - member x.TypeInst = let (UnionCaseInfo(tinst, _)) = x in tinst - - /// Get a reference to the F# metadata for the uninstantiated union case - member x.UnionCaseRef = let (UnionCaseInfo(_, ucref)) = x in ucref + /// Get the name of the union case + member Name: string - /// Get the F# metadata for the uninstantiated union case - member x.UnionCase = x.UnionCaseRef.UnionCase + /// Get the F# metadata for the declaring union type + member Tycon: Entity /// Get a reference to the F# metadata for the declaring union type - member x.TyconRef = x.UnionCaseRef.TyconRef - - /// Get the F# metadata for the declaring union type - member x.Tycon = x.UnionCaseRef.Tycon + member TyconRef: TyconRef - /// Get the name of the union case - member x.Name = x.UnionCase.DisplayName + /// Get the list of types for the instantiation of the type parameters of the declaring type of the union case + member TypeInst: TypeInst - /// Get the instantiation of the type parameters of the declaring type of the union case - member x.GetTyparInst m = mkTyparInst (x.TyconRef.Typars m) x.TypeInst + /// Get the F# metadata for the uninstantiated union case + member UnionCase: UnionCase - override x.ToString() = x.TyconRef.ToString() + "::" + x.Name + /// Get a reference to the F# metadata for the uninstantiated union case + member UnionCaseRef: UnionCaseRef + /// Get the instantiation of the type parameters of the declaring type of the union case + member GetTyparInst: m:range -> TypedTreeOps.TyparInst /// Describes an F# use of a property backed by Abstract IL metadata [] type ILPropInfo = - | ILPropInfo of ILTypeInfo * ILPropertyDef - - /// Get the TcGlobals governing this value - member x.TcGlobals = match x with ILPropInfo(tinfo, _) -> tinfo.TcGlobals + | ILPropInfo of ilTypeInfo: ILTypeInfo * ilPropertyDef: ILPropertyDef - /// Get the declaring IL type of the IL property, including any generic instantiation - member x.ILTypeInfo = match x with ILPropInfo(tinfo, _) -> tinfo + /// Like ApparentEnclosingType but use the compiled nominal type if this is a method on a tuple type + member ApparentEnclosingAppType: TType /// Get the apparent declaring type of the method as an F# type. /// If this is a C#-style extension method then this is the type which the method /// appears to extend. This may be a variable type. - member x.ApparentEnclosingType = match x with ILPropInfo(tinfo, _) -> tinfo.ToType - - /// Like ApparentEnclosingType but use the compiled nominal type if this is a method on a tuple type - member x.ApparentEnclosingAppType = convertToTypeWithMetadataIfPossible x.TcGlobals x.ApparentEnclosingType - - /// Get the raw Abstract IL metadata for the IL property - member x.RawMetadata = match x with ILPropInfo(_, pd) -> pd - - /// Get the name of the IL property - member x.PropertyName = x.RawMetadata.Name + member ApparentEnclosingType: TType /// Gets the ILMethInfo of the 'get' method for the IL property - member x.GetterMethod = - assert x.HasGetter - let mdef = resolveILMethodRef x.ILTypeInfo.RawMetadata x.RawMetadata.GetMethod.Value - ILMethInfo(x.TcGlobals, x.ILTypeInfo.ToType, None, mdef, []) - - /// Gets the ILMethInfo of the 'set' method for the IL property - member x.SetterMethod = - assert x.HasSetter - let mdef = resolveILMethodRef x.ILTypeInfo.RawMetadata x.RawMetadata.SetMethod.Value - ILMethInfo(x.TcGlobals, x.ILTypeInfo.ToType, None, mdef, []) + member GetterMethod: ILMethInfo /// Indicates if the IL property has a 'get' method - member x.HasGetter = Option.isSome x.RawMetadata.GetMethod + member HasGetter: bool /// Indicates if the IL property has a 'set' method - member x.HasSetter = Option.isSome x.RawMetadata.SetMethod + member HasSetter: bool + + /// Get the declaring IL type of the IL property, including any generic instantiation + member ILTypeInfo: ILTypeInfo + + /// Indicates if the IL property is logically a 'newslot', i.e. hides any previous slots of the same name. + member IsNewSlot: bool /// Indicates if the IL property is static - member x.IsStatic = (x.RawMetadata.CallingConv = ILThisConvention.Static) + member IsStatic: bool /// Indicates if the IL property is virtual - member x.IsVirtual = - (x.HasGetter && x.GetterMethod.IsVirtual) || - (x.HasSetter && x.SetterMethod.IsVirtual) + member IsVirtual: bool - /// Indicates if the IL property is logically a 'newslot', i.e. hides any previous slots of the same name. - member x.IsNewSlot = - (x.HasGetter && x.GetterMethod.IsNewSlot) || - (x.HasSetter && x.SetterMethod.IsNewSlot) + /// Get the name of the IL property + member PropertyName: string + + /// Get the raw Abstract IL metadata for the IL property + member RawMetadata: ILPropertyDef + + /// Gets the ILMethInfo of the 'set' method for the IL property + member SetterMethod: ILMethInfo + /// Get the TcGlobals governing this value + member TcGlobals: TcGlobals + /// Get the names and types of the indexer arguments associated with the IL property. /// /// Any type parameters of the enclosing type are instantiated in the type returned. - member x.GetParamNamesAndTypes(amap, m) = - let (ILPropInfo (tinfo, pdef)) = x - pdef.Args |> List.map (fun ty -> ParamNameAndType(None, ImportILTypeFromMetadata amap m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata [] ty) ) + member GetParamNamesAndTypes: amap:ImportMap * m:range -> ParamNameAndType list /// Get the types of the indexer arguments associated with the IL property. /// /// Any type parameters of the enclosing type are instantiated in the type returned. - member x.GetParamTypes(amap, m) = - let (ILPropInfo (tinfo, pdef)) = x - pdef.Args |> List.map (fun ty -> ImportILTypeFromMetadata amap m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata [] ty) + member GetParamTypes: amap:ImportMap * m:range -> TType list /// Get the return type of the IL property. /// /// Any type parameters of the enclosing type are instantiated in the type returned. - member x.GetPropertyType (amap, m) = - let (ILPropInfo (tinfo, pdef)) = x - ImportILTypeFromMetadata amap m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata [] pdef.PropertyType - - override x.ToString() = x.ILTypeInfo.ToString() + "::" + x.PropertyName - - + member GetPropertyType: amap:ImportMap * m:range -> TType /// Describes an F# use of a property [] type PropInfo = /// An F# use of a property backed by F#-declared metadata - | FSProp of TcGlobals * TType * ValRef option * ValRef option + | FSProp of tcGlobals: TcGlobals * apparentEnclTy: TType * getter: ValRef option * setter: ValRef option + /// An F# use of a property backed by Abstract IL metadata - | ILProp of ILPropInfo + | ILProp of ilPropInfo: ILPropInfo + #if !NO_EXTENSIONTYPING /// An F# use of a property backed by provided metadata - | ProvidedProp of Import.ImportMap * Tainted * range + | ProvidedProp of amap: ImportMap * providedProp: Tainted * range: range #endif + /// Get the enclosing type of the method info, using a nominal type for tuple types + member ApparentEnclosingAppType: TType + + member ApparentEnclosingTyconRef: TyconRef + /// Get the enclosing type of the property. /// /// If this is an extension member, then this is the apparent parent, i.e. the type the property appears to extend. - member x.ApparentEnclosingType = - match x with - | ILProp ilpinfo -> ilpinfo.ILTypeInfo.ToType - | FSProp(_, ty, _, _) -> ty -#if !NO_EXTENSIONTYPING - | ProvidedProp(amap, pi, m) -> - Import.ImportProvidedType amap m (pi.PApply((fun pi -> pi.DeclaringType), m)) -#endif - - /// Get the enclosing type of the method info, using a nominal type for tuple types - member x.ApparentEnclosingAppType = - match x with - | ILProp ilpinfo -> ilpinfo.ApparentEnclosingAppType - | _ -> x.ApparentEnclosingType + member ApparentEnclosingType: TType - member x.ApparentEnclosingTyconRef = tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + /// Try to get an arbitrary F# ValRef associated with the member. This is to determine if the member is virtual, amongst other things. + member ArbitraryValRef: ValRef option /// Get the declaring type or module holding the method. /// Note that C#-style extension properties don't exist in the C# design as yet. /// If this is an F#-style extension method it is the logical module /// holding the value for the extension method. - member x.DeclaringTyconRef = - match x.ArbitraryValRef with - | Some vref when x.IsExtensionMember && vref.HasDeclaringEntity -> vref.TopValDeclaringEntity - | _ -> x.ApparentEnclosingTyconRef + member DeclaringTyconRef: EntityRef - /// Try to get an arbitrary F# ValRef associated with the member. This is to determine if the member is virtual, amongst other things. - member x.ArbitraryValRef : ValRef option = - match x with - | FSProp(_, _, Some vref, _) - | FSProp(_, _, _, Some vref) -> Some vref - | FSProp(_, _, None, None) -> failwith "unreachable" - | _ -> None + /// Return a new property info where there is no associated getter, only an associated setter. + /// + /// Property infos can combine getters and setters, assuming they are consistent w.r.t. 'virtual', indexer argument types etc. + /// When checking consistency we split these apart + member DropGetter: unit -> PropInfo - /// Indicates if this property has an associated XML comment authored in this assembly. - member x.HasDirectXmlComment = - match x with - | FSProp(g, _, Some vref, _) - | FSProp(g, _, _, Some vref) -> valRefInThisAssembly g.compilingFslib vref -#if !NO_EXTENSIONTYPING - | ProvidedProp _ -> true -#endif - | _ -> false + /// Return a new property info where there is no associated setter, only an associated getter. + /// + /// Property infos can combine getters and setters, assuming they are consistent w.r.t. 'virtual', indexer argument types etc. + /// When checking consistency we split these apart + member DropSetter: unit -> PropInfo - /// Get the logical name of the property. - member x.PropertyName = - match x with - | ILProp ilpinfo -> ilpinfo.PropertyName - | FSProp(_, _, Some vref, _) - | FSProp(_, _, _, Some vref) -> vref.PropertyName -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi, m) -> pi.PUntaint((fun pi -> pi.Name), m) -#endif - | FSProp _ -> failwith "unreachable" + member GetterMethod: MethInfo + + /// Indicates if this property has an associated XML comment authored in this assembly. + member HasDirectXmlComment: bool /// Indicates if this property has an associated getter method. - member x.HasGetter = - match x with - | ILProp ilpinfo-> ilpinfo.HasGetter - | FSProp(_, _, x, _) -> Option.isSome x -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi, m) -> pi.PUntaint((fun pi -> pi.CanRead), m) -#endif + member HasGetter: bool /// Indicates if this property has an associated setter method. - member x.HasSetter = - match x with - | ILProp ilpinfo -> ilpinfo.HasSetter - | FSProp(_, _, _, x) -> Option.isSome x -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi, m) -> pi.PUntaint((fun pi -> pi.CanWrite), m) -#endif - - - /// Indicates if this is an extension member - member x.IsExtensionMember = - match x.ArbitraryValRef with - | Some vref -> vref.IsExtensionMember - | _ -> false - - /// True if the getter (or, if absent, the setter) is a virtual method - // REVIEW: for IL properties this is getter OR setter. For F# properties it is getter ELSE setter - member x.IsVirtualProperty = - match x with - | ILProp ilpinfo -> ilpinfo.IsVirtual - | FSProp(_, _, Some vref, _) - | FSProp(_, _, _, Some vref) -> vref.IsVirtualMember - | FSProp _-> failwith "unreachable" -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi, m) -> - let mi = ArbitraryMethodInfoOfPropertyInfo pi m - mi.PUntaint((fun mi -> mi.IsVirtual), m) -#endif + member HasSetter: bool - /// Indicates if the property is logically a 'newslot', i.e. hides any previous slots of the same name. - member x.IsNewSlot = - match x with - | ILProp ilpinfo -> ilpinfo.IsNewSlot - | FSProp(_, _, Some vref, _) - | FSProp(_, _, _, Some vref) -> vref.IsDispatchSlotMember - | FSProp(_, _, None, None) -> failwith "unreachable" -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi, m) -> - let mi = ArbitraryMethodInfoOfPropertyInfo pi m - mi.PUntaint((fun mi -> mi.IsHideBySig), m) -#endif - - - /// Indicates if the getter (or, if absent, the setter) for the property is a dispatch slot. - // REVIEW: for IL properties this is getter OR setter. For F# properties it is getter ELSE setter - member x.IsDispatchSlot = - match x with - | ILProp ilpinfo -> ilpinfo.IsVirtual - | FSProp(g, ty, Some vref, _) - | FSProp(g, ty, _, Some vref) -> - isInterfaceTy g ty || (vref.MemberInfo.Value.MemberFlags.IsDispatchSlot) - | FSProp _ -> failwith "unreachable" -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi, m) -> - let mi = ArbitraryMethodInfoOfPropertyInfo pi m - mi.PUntaint((fun mi -> mi.IsVirtual), m) -#endif - - /// Indicates if this property is static. - member x.IsStatic = - match x with - | ILProp ilpinfo -> ilpinfo.IsStatic - | FSProp(_, _, Some vref, _) - | FSProp(_, _, _, Some vref) -> not vref.IsInstanceMember - | FSProp(_, _, None, None) -> failwith "unreachable" -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi, m) -> - (ArbitraryMethodInfoOfPropertyInfo pi m).PUntaint((fun mi -> mi.IsStatic), m) -#endif + member ImplementedSlotSignatures: SlotSig list /// Indicates if this property is marked 'override' and thus definitely overrides another property. - member x.IsDefiniteFSharpOverride = - match x.ArbitraryValRef with - | Some vref -> vref.IsDefiniteFSharpOverrideMember - | None -> false - - member x.ImplementedSlotSignatures = - x.ArbitraryValRef.Value.ImplementedSlotSignatures - - member x.IsFSharpExplicitInterfaceImplementation = - match x.ArbitraryValRef with - | Some vref -> vref.IsFSharpExplicitInterfaceImplementation x.TcGlobals - | None -> false + member IsDefiniteFSharpOverride: bool + /// Indicates if the getter (or, if absent, the setter) for the property is a dispatch slot. + member IsDispatchSlot: bool - /// Indicates if this property is an indexer property, i.e. a property with arguments. - member x.IsIndexer = - match x with - | ILProp(ILPropInfo(_, pdef)) -> pdef.Args.Length <> 0 - | FSProp(g, _, Some vref, _) -> - // A getter has signature { OptionalObjectType } -> Unit -> PropertyType - // A getter indexer has signature { OptionalObjectType } -> TupledIndexerArguments -> PropertyType - let arginfos = ArgInfosOfMember g vref - arginfos.Length = 1 && arginfos.Head.Length >= 1 - | FSProp(g, _, _, Some vref) -> - // A setter has signature { OptionalObjectType } -> PropertyType -> Void - // A setter indexer has signature { OptionalObjectType } -> TupledIndexerArguments -> PropertyType -> Void - let arginfos = ArgInfosOfMember g vref - arginfos.Length = 1 && arginfos.Head.Length >= 2 - | FSProp(_, _, None, None) -> - failwith "unreachable" -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi, m) -> - pi.PUntaint((fun pi -> pi.GetIndexParameters().Length), m)>0 -#endif + /// Indicates if this is an extension member + member IsExtensionMember: bool /// Indicates if this is an F# property compiled as a CLI event, e.g. a [] property. - member x.IsFSharpEventProperty = - match x with - | FSProp(g, _, Some vref, None) -> vref.IsFSharpEventProperty g -#if !NO_EXTENSIONTYPING - | ProvidedProp _ -> false -#endif - | _ -> false - - /// Return a new property info where there is no associated setter, only an associated getter. - /// - /// Property infos can combine getters and setters, assuming they are consistent w.r.t. 'virtual', indexer argument types etc. - /// When checking consistency we split these apart - member x.DropSetter = - match x with - | FSProp(g, ty, Some vref, _) -> FSProp(g, ty, Some vref, None) - | _ -> x + member IsFSharpEventProperty: bool + member IsFSharpExplicitInterfaceImplementation: bool - /// Return a new property info where there is no associated getter, only an associated setter. - member x.DropGetter = - match x with - | FSProp(g, ty, _, Some vref) -> FSProp(g, ty, None, Some vref) - | _ -> x + /// Indicates if this property is an indexer property, i.e. a property with arguments. + member IsIndexer: bool - /// Get the intra-assembly XML documentation for the property. - member x.XmlDoc = - match x with - | ILProp _ -> XmlDoc.Empty - | FSProp(_, _, Some vref, _) - | FSProp(_, _, _, Some vref) -> vref.XmlDoc - | FSProp(_, _, None, None) -> failwith "unreachable" -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi, m) -> - let lines = pi.PUntaint((fun pix -> (pix :> IProvidedCustomAttributeProvider).GetXmlDocAttributes(pi.TypeProvider.PUntaintNoFailure id)), m) - XmlDoc (lines, m) -#endif + /// Indicates if the property is logically a 'newslot', i.e. hides any previous slots of the same name. + member IsNewSlot: bool - /// Get the TcGlobals associated with the object - member x.TcGlobals = - match x with - | ILProp ilpinfo -> ilpinfo.TcGlobals - | FSProp(g, _, _, _) -> g -#if !NO_EXTENSIONTYPING - | ProvidedProp(amap, _, _) -> amap.g -#endif + /// Indicates if this property is static. + member IsStatic: bool /// Indicates if the enclosing type for the property is a value type. /// /// For an extension property, this indicates if the property extends a struct type. - member x.IsValueType = isStructTy x.TcGlobals x.ApparentEnclosingType + member IsValueType: bool + /// True if the getter (or, if absent, the setter) is a virtual method + member IsVirtualProperty: bool - /// Get the result type of the property - member x.GetPropertyType (amap, m) = - match x with - | ILProp ilpinfo -> ilpinfo.GetPropertyType (amap, m) - | FSProp (g, _, Some vref, _) - | FSProp (g, _, _, Some vref) -> - let ty = x.ApparentEnclosingAppType - let inst = GetInstantiationForPropertyVal g (ty, vref) - ReturnTypeOfPropertyVal g vref.Deref |> instType inst - - | FSProp _ -> failwith "unreachable" -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi, m) -> - Import.ImportProvidedType amap m (pi.PApply((fun pi -> pi.PropertyType), m)) -#endif - - - /// Get the names and types of the indexer parameters associated with the property - /// - /// If the property is in a generic type, then the type parameters are instantiated in the types returned. - member x.GetParamNamesAndTypes(amap, m) = - match x with - | ILProp ilpinfo -> ilpinfo.GetParamNamesAndTypes(amap, m) - | FSProp (g, ty, Some vref, _) - | FSProp (g, ty, _, Some vref) -> - let inst = GetInstantiationForPropertyVal g (ty, vref) - ArgInfosOfPropertyVal g vref.Deref |> List.map (ParamNameAndType.FromArgInfo >> ParamNameAndType.Instantiate inst) - | FSProp _ -> failwith "unreachable" -#if !NO_EXTENSIONTYPING - | ProvidedProp (_, pi, m) -> - [ for p in pi.PApplyArray((fun pi -> pi.GetIndexParameters()), "GetIndexParameters", m) do - let paramName = p.PUntaint((fun p -> match p.Name with null -> None | s -> Some (mkSynId m s)), m) - let paramType = Import.ImportProvidedType amap m (p.PApply((fun p -> p.ParameterType), m)) - yield ParamNameAndType(paramName, paramType) ] -#endif - - /// Get the details of the indexer parameters associated with the property - member x.GetParamDatas(amap, m) = - x.GetParamNamesAndTypes(amap, m) - |> List.map (fun (ParamNameAndType(nmOpt, pty)) -> ParamData(false, false, false, NotOptional, NoCallerInfo, nmOpt, ReflectedArgInfo.None, pty)) + /// Get the logical name of the property. + member PropertyName: string - /// Get the types of the indexer parameters associated with the property - member x.GetParamTypes(amap, m) = - x.GetParamNamesAndTypes(amap, m) |> List.map (fun (ParamNameAndType(_, ty)) -> ty) - - /// Get a MethInfo for the 'getter' method associated with the property - member x.GetterMethod = - match x with - | ILProp ilpinfo -> ILMeth(x.TcGlobals, ilpinfo.GetterMethod, None) - | FSProp(g, ty, Some vref, _) -> FSMeth(g, ty, vref, None) -#if !NO_EXTENSIONTYPING - | ProvidedProp(amap, pi, m) -> - let meth = GetAndSanityCheckProviderMethod m pi (fun pi -> pi.GetGetMethod()) FSComp.SR.etPropertyCanReadButHasNoGetter - ProvidedMeth(amap, meth, None, m) + /// Get a MethInfo for the 'setter' method associated with the property + member SetterMethod: MethInfo -#endif - | FSProp _ -> failwith "no getter method" + /// Get the TcGlobals associated with the object + member TcGlobals: TcGlobals - /// Get a MethInfo for the 'setter' method associated with the property - member x.SetterMethod = - match x with - | ILProp ilpinfo -> ILMeth(x.TcGlobals, ilpinfo.SetterMethod, None) - | FSProp(g, ty, _, Some vref) -> FSMeth(g, ty, vref, None) -#if !NO_EXTENSIONTYPING - | ProvidedProp(amap, pi, m) -> - let meth = GetAndSanityCheckProviderMethod m pi (fun pi -> pi.GetSetMethod()) FSComp.SR.etPropertyCanWriteButHasNoSetter - ProvidedMeth(amap, meth, None, m) -#endif - | FSProp _ -> failwith "no setter method" + /// Get the intra-assembly XML documentation for the property. + member XmlDoc: XmlDoc.XmlDoc /// Test whether two property infos have the same underlying definition. /// Uses the same techniques as 'MethInfosUseIdenticalDefinitions'. - /// Must be compatible with ItemsAreEffectivelyEqual relation. - static member PropInfosUseIdenticalDefinitions x1 x2 = - let optVrefEq g = function - | Some v1, Some v2 -> valRefEq g v1 v2 - | None, None -> true - | _ -> false - match x1, x2 with - | ILProp ilpinfo1, ILProp ilpinfo2 -> (ilpinfo1.RawMetadata === ilpinfo2.RawMetadata) - | FSProp(g, _, vrefa1, vrefb1), FSProp(_, _, vrefa2, vrefb2) -> - (optVrefEq g (vrefa1, vrefa2)) && (optVrefEq g (vrefb1, vrefb2)) -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi1, _), ProvidedProp(_, pi2, _) -> ProvidedPropertyInfo.TaintedEquals (pi1, pi2) -#endif - | _ -> false + /// Compatible with ItemsAreEffectivelyEqual relation. + static member PropInfosUseIdenticalDefinitions: x1:PropInfo -> x2:PropInfo -> bool /// Calculates a hash code of property info. Must be compatible with ItemsAreEffectivelyEqual relation. - member pi.ComputeHashCode() = - match pi with - | ILProp ilpinfo -> hash ilpinfo.RawMetadata.Name - | FSProp(_, _, vrefOpt1, vrefOpt2) -> - // Hash on option*option - let vth = (vrefOpt1 |> Option.map (fun vr -> vr.LogicalName), (vrefOpt2 |> Option.map (fun vr -> vr.LogicalName))) - hash vth -#if !NO_EXTENSIONTYPING - | ProvidedProp(_, pi, _) -> ProvidedPropertyInfo.TaintedGetHashCode pi -#endif + member ComputeHashCode: unit -> int - override x.ToString() = "property " + x.PropertyName + /// Get the details of the indexer parameters associated with the property + member GetParamDatas: amap:ImportMap * m:range -> ParamData list -//------------------------------------------------------------------------- -// ILEventInfo + /// Get the names and types of the indexer parameters associated with the property + /// + /// If the property is in a generic type, then the type parameters are instantiated in the types returned. + member GetParamNamesAndTypes: amap:ImportMap * m:range -> ParamNameAndType list + /// Get the types of the indexer parameters associated with the property + member GetParamTypes: amap:ImportMap * m:range -> TType list + + /// Get the result type of the property + member GetPropertyType: amap:ImportMap * m:range -> TType /// Describes an F# use of an event backed by Abstract IL metadata [] type ILEventInfo = - | ILEventInfo of ILTypeInfo * ILEventDef + | ILEventInfo of ilTypeInfo: ILTypeInfo * ilEventDef: ILEventDef - /// Get the enclosing ("parent"/"declaring") type of the field. - member x.ApparentEnclosingType = match x with ILEventInfo(tinfo, _) -> tinfo.ToType + /// Get the ILMethInfo describing the 'add' method associated with the event + member AddMethod: ILMethInfo // Note: events are always associated with nominal types - member x.ApparentEnclosingAppType = x.ApparentEnclosingType - - // Note: IL Events are never extension members as C# has no notion of extension events as yet - member x.DeclaringTyconRef = tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + member ApparentEnclosingAppType: TType - member x.TcGlobals = match x with ILEventInfo(tinfo, _) -> tinfo.TcGlobals + /// Get the enclosing ("parent"/"declaring") type of the field. + member ApparentEnclosingType: TType - /// Get the raw Abstract IL metadata for the event - member x.RawMetadata = match x with ILEventInfo(_, ed) -> ed + // Note: IL Events are never extension members as C# has no notion of extension events as yet + member DeclaringTyconRef: TyconRef /// Get the declaring IL type of the event as an ILTypeInfo - member x.ILTypeInfo = match x with ILEventInfo(tinfo, _) -> tinfo - - /// Get the ILMethInfo describing the 'add' method associated with the event - member x.AddMethod = - let mdef = resolveILMethodRef x.ILTypeInfo.RawMetadata x.RawMetadata.AddMethod - ILMethInfo(x.TcGlobals, x.ILTypeInfo.ToType, None, mdef, []) - - /// Get the ILMethInfo describing the 'remove' method associated with the event - member x.RemoveMethod = - let mdef = resolveILMethodRef x.ILTypeInfo.RawMetadata x.RawMetadata.RemoveMethod - ILMethInfo(x.TcGlobals, x.ILTypeInfo.ToType, None, mdef, []) - - /// Get the declaring type of the event as an ILTypeRef - member x.TypeRef = x.ILTypeInfo.ILTypeRef - - /// Get the name of the event - member x.Name = x.RawMetadata.Name + member ILTypeInfo: ILTypeInfo /// Indicates if the property is static - member x.IsStatic = x.AddMethod.IsStatic - override x.ToString() = x.ILTypeInfo.ToString() + "::" + x.Name - -//------------------------------------------------------------------------- -// Helpers for EventInfo - -/// An exception type used to raise an error using the old error system. -/// -/// Error text: "A definition to be compiled as a .NET event does not have the expected form. Only property members can be compiled as .NET events." -exception BadEventTransformation of range - -/// Properties compatible with type IDelegateEvent and attributed with CLIEvent are special: -/// we generate metadata and add/remove methods -/// to make them into a .NET event, and mangle the name of a property. -/// We don't handle static, indexer or abstract properties correctly. -/// Note the name mangling doesn't affect the name of the get/set methods for the property -/// and so doesn't affect how we compile F# accesses to the property. -let private tyConformsToIDelegateEvent g ty = - isIDelegateEventType g ty && isDelegateTy g (destIDelegateEventType g ty) - + member IsStatic: bool -/// Create an error object to raise should an event not have the shape expected by the .NET idiom described further below -let nonStandardEventError nm m = - Error ((FSComp.SR.eventHasNonStandardType(nm, ("add_"+nm), ("remove_"+nm))), m) + /// Get the name of the event + member Name: string -/// Find the delegate type that an F# event property implements by looking through the type hierarchy of the type of the property -/// for the first instantiation of IDelegateEvent. -let FindDelegateTypeOfPropertyEvent g amap nm m ty = - match SearchEntireHierarchyOfType (tyConformsToIDelegateEvent g) g amap m ty with - | None -> error(nonStandardEventError nm m) - | Some ty -> destIDelegateEventType g ty + /// Get the raw Abstract IL metadata for the event + member RawMetadata: ILEventDef + /// Get the ILMethInfo describing the 'remove' method associated with the event + member RemoveMethod: ILMethInfo -//------------------------------------------------------------------------- -// EventInfo + member TcGlobals: TcGlobals + /// Get the declaring type of the event as an ILTypeRef + member TypeRef: ILTypeRef + /// Describes an F# use of an event [] type EventInfo = /// An F# use of an event backed by F#-declared metadata - | FSEvent of TcGlobals * PropInfo * ValRef * ValRef + | FSEvent of tcGlobals: TcGlobals * propInfo: PropInfo * addMethod: ValRef * removeMethod: ValRef + /// An F# use of an event backed by .NET metadata - | ILEvent of ILEventInfo + | ILEvent of ilEventInfo: ILEventInfo + #if !NO_EXTENSIONTYPING /// An F# use of an event backed by provided metadata - | ProvidedEvent of Import.ImportMap * Tainted * range + | ProvidedEvent of amap: Import.ImportMap * providedEvent: Tainted * range: range #endif + /// Get the enclosing type of the method info, using a nominal type for tuple types + member ApparentEnclosingAppType: TType + + member ApparentEnclosingTyconRef: TyconRef + /// Get the enclosing type of the event. /// /// If this is an extension member, then this is the apparent parent, i.e. the type the event appears to extend. - member x.ApparentEnclosingType = - match x with - | ILEvent ileinfo -> ileinfo.ApparentEnclosingType - | FSEvent (_, p, _, _) -> p.ApparentEnclosingType -#if !NO_EXTENSIONTYPING - | ProvidedEvent (amap, ei, m) -> Import.ImportProvidedType amap m (ei.PApply((fun ei -> ei.DeclaringType), m)) -#endif - /// Get the enclosing type of the method info, using a nominal type for tuple types - member x.ApparentEnclosingAppType = - match x with - | ILEvent ileinfo -> ileinfo.ApparentEnclosingAppType - | _ -> x.ApparentEnclosingType + member ApparentEnclosingType: TType - member x.ApparentEnclosingTyconRef = tcrefOfAppTy x.TcGlobals x.ApparentEnclosingAppType + /// Try to get an arbitrary F# ValRef associated with the member. This is to determine if the member is virtual, amongst other things. + member ArbitraryValRef: ValRef option /// Get the declaring type or module holding the method. /// Note that C#-style extension properties don't exist in the C# design as yet. /// If this is an F#-style extension method it is the logical module /// holding the value for the extension method. - member x.DeclaringTyconRef = - match x.ArbitraryValRef with - | Some vref when x.IsExtensionMember && vref.HasDeclaringEntity -> vref.TopValDeclaringEntity - | _ -> x.ApparentEnclosingTyconRef - - - /// Indicates if this event has an associated XML comment authored in this assembly. - member x.HasDirectXmlComment = - match x with - | FSEvent (_, p, _, _) -> p.HasDirectXmlComment -#if !NO_EXTENSIONTYPING - | ProvidedEvent _ -> true -#endif - | _ -> false - - /// Get the intra-assembly XML documentation for the property. - member x.XmlDoc = - match x with - | ILEvent _ -> XmlDoc.Empty - | FSEvent (_, p, _, _) -> p.XmlDoc -#if !NO_EXTENSIONTYPING - | ProvidedEvent (_, ei, m) -> - let lines = ei.PUntaint((fun eix -> (eix :> IProvidedCustomAttributeProvider).GetXmlDocAttributes(ei.TypeProvider.PUntaintNoFailure id)), m) - XmlDoc (lines, m) -#endif + member DeclaringTyconRef: EntityRef /// Get the logical name of the event. - member x.EventName = - match x with - | ILEvent ileinfo -> ileinfo.Name - | FSEvent (_, p, _, _) -> p.PropertyName -#if !NO_EXTENSIONTYPING - | ProvidedEvent (_, ei, m) -> ei.PUntaint((fun ei -> ei.Name), m) -#endif + member EventName: string - /// Indicates if this property is static. - member x.IsStatic = - match x with - | ILEvent ileinfo -> ileinfo.IsStatic - | FSEvent (_, p, _, _) -> p.IsStatic -#if !NO_EXTENSIONTYPING - | ProvidedEvent (_, ei, m) -> - let meth = GetAndSanityCheckProviderMethod m ei (fun ei -> ei.GetAddMethod()) FSComp.SR.etEventNoAdd - meth.PUntaint((fun mi -> mi.IsStatic), m) -#endif + /// Indicates if this event has an associated XML comment authored in this assembly. + member HasDirectXmlComment: bool /// Indicates if this is an extension member - member x.IsExtensionMember = - match x with - | ILEvent _ -> false - | FSEvent (_, p, _, _) -> p.IsExtensionMember -#if !NO_EXTENSIONTYPING - | ProvidedEvent _ -> false -#endif + member IsExtensionMember: bool - /// Get the TcGlobals associated with the object - member x.TcGlobals = - match x with - | ILEvent ileinfo -> ileinfo.TcGlobals - | FSEvent(g, _, _, _) -> g -#if !NO_EXTENSIONTYPING - | ProvidedEvent (amap, _, _) -> amap.g -#endif + /// Indicates if this property is static. + member IsStatic: bool /// Indicates if the enclosing type for the event is a value type. /// /// For an extension event, this indicates if the event extends a struct type. - member x.IsValueType = isStructTy x.TcGlobals x.ApparentEnclosingType + member IsValueType: bool /// Get the 'add' method associated with an event - member x.AddMethod = - match x with - | ILEvent ileinfo -> ILMeth(ileinfo.TcGlobals, ileinfo.AddMethod, None) - | FSEvent(g, p, addValRef, _) -> FSMeth(g, p.ApparentEnclosingType, addValRef, None) -#if !NO_EXTENSIONTYPING - | ProvidedEvent (amap, ei, m) -> - let meth = GetAndSanityCheckProviderMethod m ei (fun ei -> ei.GetAddMethod()) FSComp.SR.etEventNoAdd - ProvidedMeth(amap, meth, None, m) -#endif + member AddMethod: MethInfo /// Get the 'remove' method associated with an event - member x.RemoveMethod = - match x with - | ILEvent ileinfo -> ILMeth(x.TcGlobals, ileinfo.RemoveMethod, None) - | FSEvent(g, p, _, removeValRef) -> FSMeth(g, p.ApparentEnclosingType, removeValRef, None) -#if !NO_EXTENSIONTYPING - | ProvidedEvent (amap, ei, m) -> - let meth = GetAndSanityCheckProviderMethod m ei (fun ei -> ei.GetRemoveMethod()) FSComp.SR.etEventNoRemove - ProvidedMeth(amap, meth, None, m) -#endif - - /// Try to get an arbitrary F# ValRef associated with the member. This is to determine if the member is virtual, amongst other things. - member x.ArbitraryValRef: ValRef option = - match x with - | FSEvent(_, _, addValRef, _) -> Some addValRef - | _ -> None - - /// Get the delegate type associated with the event. - member x.GetDelegateType(amap, m) = - match x with - | ILEvent(ILEventInfo(tinfo, edef)) -> - // Get the delegate type associated with an IL event, taking into account the instantiation of the - // declaring type. - if Option.isNone edef.EventType then error (nonStandardEventError x.EventName m) - ImportILTypeFromMetadata amap m tinfo.ILScopeRef tinfo.TypeInstOfRawMetadata [] edef.EventType.Value - - | FSEvent(g, p, _, _) -> - FindDelegateTypeOfPropertyEvent g amap x.EventName m (p.GetPropertyType(amap, m)) -#if !NO_EXTENSIONTYPING - | ProvidedEvent (_, ei, _) -> - Import.ImportProvidedType amap m (ei.PApply((fun ei -> ei.EventHandlerType), m)) -#endif + member RemoveMethod: MethInfo + /// Get the TcGlobals associated with the object + member TcGlobals: TcGlobals + /// Get the intra-assembly XML documentation for the property. + member XmlDoc: XmlDoc.XmlDoc + /// Test whether two event infos have the same underlying definition. - /// Must be compatible with ItemsAreEffectivelyEqual relation. - static member EventInfosUseIdenticalDefinitions x1 x2 = - match x1, x2 with - | FSEvent(g, pi1, vrefa1, vrefb1), FSEvent(_, pi2, vrefa2, vrefb2) -> - PropInfo.PropInfosUseIdenticalDefinitions pi1 pi2 && valRefEq g vrefa1 vrefa2 && valRefEq g vrefb1 vrefb2 - | ILEvent ileinfo1, ILEvent ileinfo2 -> (ileinfo1.RawMetadata === ileinfo2.RawMetadata) -#if !NO_EXTENSIONTYPING - | ProvidedEvent (_, ei1, _), ProvidedEvent (_, ei2, _) -> ProvidedEventInfo.TaintedEquals (ei1, ei2) -#endif - | _ -> false + /// Compatible with ItemsAreEffectivelyEqual relation. + static member EventInfosUseIdenticalDefinitions: x1:EventInfo -> x2:EventInfo -> bool /// Calculates a hash code of event info (similar as previous) - /// Must be compatible with ItemsAreEffectivelyEqual relation. - member ei.ComputeHashCode() = - match ei with - | ILEvent ileinfo -> hash ileinfo.RawMetadata.Name - | FSEvent(_, pi, vref1, vref2) -> hash ( pi.ComputeHashCode(), vref1.LogicalName, vref2.LogicalName) -#if !NO_EXTENSIONTYPING - | ProvidedEvent (_, ei, _) -> ProvidedEventInfo.TaintedGetHashCode ei -#endif - override x.ToString() = "event " + x.EventName + /// Compatible with ItemsAreEffectivelyEqual relation. + member ComputeHashCode: unit -> int -//------------------------------------------------------------------------- -// Helpers associated with getting and comparing method signatures + /// Get the delegate type associated with the event. + member GetDelegateType: amap:ImportMap * m:range -> TType + +/// An exception type used to raise an error using the old error system. +/// +/// Error text: "A definition to be compiled as a .NET event does not have the expected form. Only property members can be compiled as .NET events." +exception BadEventTransformation of range + +/// Create an error object to raise should an event not have the shape expected by the .NET idiom described further below +val nonStandardEventError: nm:System.String -> m:range -> exn + +/// Find the delegate type that an F# event property implements by looking through the type hierarchy of the type of the property +/// for the first instantiation of IDelegateEvent. +val FindDelegateTypeOfPropertyEvent: g:TcGlobals -> amap:ImportMap -> nm:System.String -> m:range -> ty:TType -> TType /// Strips inref and outref to be a byref. -let stripByrefTy g ty = - if isByrefTy g ty then mkByrefTy g (destByrefTy g ty) - else ty +val stripByrefTy: g:TcGlobals -> ty:TType -> TType /// Represents the information about the compiled form of a method signature. Used when analyzing implementation /// relations between members and abstract slots. -type CompiledSig = CompiledSig of TType list list * TType option * Typars * TyparInst +type CompiledSig = CompiledSig of argTys: TType list list * returnTy: TType option * formalMethTypars: Typars * formalMethTyparInst: TyparInst /// Get the information about the compiled form of a method signature. Used when analyzing implementation /// relations between members and abstract slots. -let CompiledSigOfMeth g amap m (minfo: MethInfo) = - let formalMethTypars = minfo.FormalMethodTypars - let fminst = generalizeTypars formalMethTypars - let vargtys = minfo.GetParamTypes(amap, m, fminst) - let vrty = minfo.GetCompiledReturnTy(amap, m, fminst) - - // The formal method typars returned are completely formal - they don't take into account the instantiation - // of the enclosing type. For example, they may have constraints involving the _formal_ type parameters - // of the enclosing type. This instantiations can be used to interpret those type parameters - let fmtpinst = - let parentTyArgs = argsOfAppTy g minfo.ApparentEnclosingAppType - let memberParentTypars = minfo.GetFormalTyparsOfDeclaringType m - mkTyparInst memberParentTypars parentTyArgs - - CompiledSig(vargtys, vrty, formalMethTypars, fmtpinst) - +val CompiledSigOfMeth: g:TcGlobals -> amap:ImportMap -> m:range -> minfo:MethInfo -> CompiledSig /// Inref and outref parameter types will be treated as a byref type for equivalency. -let MethInfosEquivByPartialSig erasureFlag ignoreFinal g amap m (minfo: MethInfo) (minfo2: MethInfo) = - (minfo.GenericArity = minfo2.GenericArity) && - (ignoreFinal || minfo.IsFinal = minfo2.IsFinal) && - let formalMethTypars = minfo.FormalMethodTypars - let fminst = generalizeTypars formalMethTypars - let formalMethTypars2 = minfo2.FormalMethodTypars - let fminst2 = generalizeTypars formalMethTypars2 - let argtys = minfo.GetParamTypes(amap, m, fminst) - let argtys2 = minfo2.GetParamTypes(amap, m, fminst2) - (argtys, argtys2) ||> List.lengthsEqAndForall2 (List.lengthsEqAndForall2 (fun ty1 ty2 -> - typeAEquivAux erasureFlag g (TypeEquivEnv.FromEquivTypars formalMethTypars formalMethTypars2) (stripByrefTy g ty1) (stripByrefTy g ty2))) +val MethInfosEquivByPartialSig: erasureFlag:TypedTreeOps.Erasure -> ignoreFinal:bool -> g:TcGlobals -> amap:ImportMap -> m:range -> minfo:MethInfo -> minfo2:MethInfo -> bool /// Used to hide/filter members from super classes based on signature /// Inref and outref parameter types will be treated as a byref type for equivalency. -let MethInfosEquivByNameAndPartialSig erasureFlag ignoreFinal g amap m (minfo: MethInfo) (minfo2: MethInfo) = - (minfo.LogicalName = minfo2.LogicalName) && - MethInfosEquivByPartialSig erasureFlag ignoreFinal g amap m minfo minfo2 +val MethInfosEquivByNameAndPartialSig: erasureFlag:TypedTreeOps.Erasure -> ignoreFinal:bool -> g:TcGlobals -> amap:ImportMap -> m:range -> minfo:MethInfo -> minfo2:MethInfo -> bool /// Used to hide/filter members from super classes based on signature -let PropInfosEquivByNameAndPartialSig erasureFlag g amap m (pinfo: PropInfo) (pinfo2: PropInfo) = - pinfo.PropertyName = pinfo2.PropertyName && - let argtys = pinfo.GetParamTypes(amap, m) - let argtys2 = pinfo2.GetParamTypes(amap, m) - List.lengthsEqAndForall2 (typeEquivAux erasureFlag g) argtys argtys2 +val PropInfosEquivByNameAndPartialSig: erasureFlag:TypedTreeOps.Erasure -> g:TcGlobals -> amap:ImportMap -> m:range -> pinfo:PropInfo -> pinfo2:PropInfo -> bool -/// Used to hide/filter members from super classes based on signature -let MethInfosEquivByNameAndSig erasureFlag ignoreFinal g amap m minfo minfo2 = - MethInfosEquivByNameAndPartialSig erasureFlag ignoreFinal g amap m minfo minfo2 && - let (CompiledSig(_, retTy, formalMethTypars, _)) = CompiledSigOfMeth g amap m minfo - let (CompiledSig(_, retTy2, formalMethTypars2, _)) = CompiledSigOfMeth g amap m minfo2 - match retTy, retTy2 with - | None, None -> true - | Some retTy, Some retTy2 -> typeAEquivAux erasureFlag g (TypeEquivEnv.FromEquivTypars formalMethTypars formalMethTypars2) retTy retTy2 - | _ -> false +/// Used to hide/filter members from base classes based on signature +val MethInfosEquivByNameAndSig: erasureFlag:TypedTreeOps.Erasure -> ignoreFinal:bool -> g:TcGlobals -> amap:ImportMap -> m:range -> minfo:MethInfo -> minfo2:MethInfo -> bool /// Used to hide/filter members from super classes based on signature -let PropInfosEquivByNameAndSig erasureFlag g amap m (pinfo: PropInfo) (pinfo2: PropInfo) = - PropInfosEquivByNameAndPartialSig erasureFlag g amap m pinfo pinfo2 && - let retTy = pinfo.GetPropertyType(amap, m) - let retTy2 = pinfo2.GetPropertyType(amap, m) - typeEquivAux erasureFlag g retTy retTy2 - -let SettersOfPropInfos (pinfos: PropInfo list) = pinfos |> List.choose (fun pinfo -> if pinfo.HasSetter then Some(pinfo.SetterMethod, Some pinfo) else None) -let GettersOfPropInfos (pinfos: PropInfo list) = pinfos |> List.choose (fun pinfo -> if pinfo.HasGetter then Some(pinfo.GetterMethod, Some pinfo) else None) +val PropInfosEquivByNameAndSig: erasureFlag:TypedTreeOps.Erasure -> g:TcGlobals -> amap:ImportMap -> m:range -> pinfo:PropInfo -> pinfo2:PropInfo -> bool + +val SettersOfPropInfos: pinfos:PropInfo list -> (MethInfo * PropInfo option) list + +val GettersOfPropInfos: pinfos:PropInfo list -> (MethInfo * PropInfo option) list From 300747dca28ed9d54453259100ad72dde4a42f2c Mon Sep 17 00:00:00 2001 From: Don Syme Date: Fri, 11 Dec 2020 19:56:26 +0000 Subject: [PATCH 3/8] add signatures --- src/fsharp/AttributeChecking.fs | 32 +- src/fsharp/AttributeChecking.fsi | 4 + src/fsharp/CompilerImports.fs | 17 +- src/fsharp/ErrorLogger.fsi | 1 + .../FSharp.Compiler.Private.fsproj | 78 + .../FSharp.Compiler.Service.fsproj | 17 +- src/fsharp/FSharp.Compiler.Service/all.fsi | 37130 +++++++++++++--- src/fsharp/MethodCalls.fs | 32 +- src/fsharp/MethodCalls.fsi | 2029 +- src/fsharp/MethodOverrides.fsi | 900 +- .../DependencyProvider.fs | 7 + src/fsharp/NicePrint.fs | 10 +- src/fsharp/NicePrint.fsi | 117 + src/fsharp/ReferenceResolver.fsi | 92 +- src/fsharp/SignatureConformance.fsi | 652 +- src/fsharp/TypeRelations.fs | 1 - src/fsharp/TypedTreeOps.fs | 2 +- src/fsharp/TypedTreeOps.fsi | 10 +- src/fsharp/XmlAdapters.fs | 23 +- src/fsharp/absil/il.fs | 17 + src/fsharp/absil/il.fsi | 2 + src/fsharp/absil/ilreflect.fs | 27 +- src/fsharp/infos.fsi | 11 +- src/fsharp/service/FSharpCheckerResults.fs | 5 +- src/fsharp/symbols/Symbols.fs | 4 +- src/fsharp/utils/CompilerLocationUtils.fsi | 1 - 26 files changed, 31711 insertions(+), 9510 deletions(-) create mode 100644 src/fsharp/NicePrint.fsi diff --git a/src/fsharp/AttributeChecking.fs b/src/fsharp/AttributeChecking.fs index fc09a339c0f..58c69ef404e 100644 --- a/src/fsharp/AttributeChecking.fs +++ b/src/fsharp/AttributeChecking.fs @@ -179,29 +179,6 @@ let GetAttribInfosOfEvent amap m einfo = | ProvidedEvent _ -> [] #endif -/// Analyze three cases for attributes declared on type definitions: IL-declared attributes, F#-declared attributes and -/// provided attributes. -// -// This is used for AttributeUsageAttribute, DefaultMemberAttribute and ConditionalAttribute (on attribute types) -let TryBindTyconRefAttribute g m (AttribInfo (atref, _) as args) (tcref:TyconRef) f1 f2 f3 = - ignore m; ignore f3 - match metadataOfTycon tcref.Deref with -#if !NO_EXTENSIONTYPING - | ProvidedTypeMetadata info -> - let provAttribs = info.ProvidedType.PApply((fun a -> (a :> IProvidedCustomAttributeProvider)), m) - match provAttribs.PUntaint((fun a -> a.GetAttributeConstructorArgs(provAttribs.TypeProvider.PUntaintNoFailure(id), atref.FullName)), m) with - | Some args -> f3 args - | None -> None -#endif - | ILTypeMetadata (TILObjectReprData(_, _, tdef)) -> - match TryDecodeILAttribute g atref tdef.CustomAttrs with - | Some attr -> f1 attr - | _ -> None - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata -> - match TryFindFSharpAttribute g args tcref.Attribs with - | Some attr -> f2 attr - | _ -> None - /// Analyze three cases for attributes declared on methods: IL-declared attributes, F#-declared attributes and /// provided attributes. let BindMethInfoAttributes m minfo f1 f2 f3 = @@ -216,9 +193,8 @@ let BindMethInfoAttributes m minfo f1 f2 f3 = /// Analyze three cases for attributes declared on methods: IL-declared attributes, F#-declared attributes and /// provided attributes. -let TryBindMethInfoAttribute g m (AttribInfo(atref, _) as attribSpec) minfo f1 f2 f3 = -#if !NO_EXTENSIONTYPING -#else +let TryBindMethInfoAttribute g (m: range) (AttribInfo(atref, _) as attribSpec) minfo f1 f2 f3 = +#if NO_EXTENSIONTYPING // to prevent unused parameter warning ignore f3 #endif @@ -237,7 +213,7 @@ let TryBindMethInfoAttribute g m (AttribInfo(atref, _) as attribSpec) minfo f1 f /// Try to find a specific attribute on a method, where the attribute accepts a string argument. /// /// This is just used for the 'ConditionalAttribute' attribute -let TryFindMethInfoStringAttribute g m attribSpec minfo = +let TryFindMethInfoStringAttribute g (m: range) attribSpec minfo = TryBindMethInfoAttribute g m attribSpec minfo (function ([ILAttribElem.String (Some msg) ], _) -> Some msg | _ -> None) (function (Attrib(_, _, [ AttribStringArg msg ], _, _, _, _)) -> Some msg | _ -> None) @@ -438,7 +414,7 @@ let CheckMethInfoAttributes g m tyargsOpt minfo = /// Indicate if a method has 'Obsolete', 'CompilerMessageAttribute' or 'TypeProviderEditorHideMethodsAttribute'. /// Used to suppress the item in intellisense. -let MethInfoIsUnseen g m ty minfo = +let MethInfoIsUnseen g (m: range) (ty: TType) minfo = let isUnseenByObsoleteAttrib () = match BindMethInfoAttributes m minfo (fun ilAttribs -> Some(CheckILAttributesForUnseen g ilAttribs m)) diff --git a/src/fsharp/AttributeChecking.fsi b/src/fsharp/AttributeChecking.fsi index 7e9acc046e9..ab827c9e91b 100644 --- a/src/fsharp/AttributeChecking.fsi +++ b/src/fsharp/AttributeChecking.fsi @@ -34,7 +34,11 @@ val GetAttribInfosOfProp: amap:Import.ImportMap -> m:range -> pinfo:PropInfo -> val GetAttribInfosOfEvent: amap:Import.ImportMap -> m:range -> einfo:EventInfo -> AttribInfo list +#if NO_EXTENSIONTYPING +val TryBindMethInfoAttribute: g:TcGlobals -> m:range -> BuiltinAttribInfo -> minfo:MethInfo -> f1:(ILAttribElem list * ILAttributeNamedArg list -> 'a option) -> f2:(Attrib -> 'a option) -> f3: _ -> 'a option +#else val TryBindMethInfoAttribute: g:TcGlobals -> m:range -> BuiltinAttribInfo -> minfo:MethInfo -> f1:(ILAttribElem list * ILAttributeNamedArg list -> 'a option) -> f2:(Attrib -> 'a option) -> f3:(obj option list * (string * obj option) list -> 'a option) -> 'a option +#endif val TryFindMethInfoStringAttribute: g:TcGlobals -> m:range -> attribSpec:BuiltinAttribInfo -> minfo:MethInfo -> string option diff --git a/src/fsharp/CompilerImports.fs b/src/fsharp/CompilerImports.fs index 7818867e62f..ba78d9bdc37 100644 --- a/src/fsharp/CompilerImports.fs +++ b/src/fsharp/CompilerImports.fs @@ -692,12 +692,7 @@ type RawFSharpAssemblyDataBackedByFileOnDisk (ilModule: ILModuleDef, ilAssemblyR //-------------------------------------------------------------------------- [] -type TcImportsSafeDisposal - (disposeActions: ResizeArray unit>, -#if !NO_EXTENSIONTYPING - disposeTypeProviderActions: ResizeArray unit> -#endif - ) = +type TcImportsSafeDisposal(disposeActions: ResizeArray unit>,disposeTypeProviderActions: ResizeArray unit>) = let mutable isDisposed = false @@ -706,9 +701,7 @@ type TcImportsSafeDisposal isDisposed <- true if verbose then dprintf "disposing of TcImports, %d binaries\n" disposeActions.Count -#if !NO_EXTENSIONTYPING for action in disposeTypeProviderActions do action() -#endif for action in disposeActions do action() override _.Finalize() = @@ -758,7 +751,11 @@ and TcImportsWeakHack (tcImports: WeakReference) = /// Is a disposable object, but it is recommended not to explicitly call Dispose unless you absolutely know nothing will be using its contents after the disposal. /// Otherwise, simply allow the GC to collect this and it will properly call Dispose from the finalizer. and [] TcImports(tcConfigP: TcConfigProvider, initialResolutions: TcAssemblyResolutions, importsBase: TcImports option, - ilGlobalsOpt, dependencyProviderOpt: DependencyProvider option) as this = + ilGlobalsOpt, dependencyProviderOpt: DependencyProvider option) +#if !NO_EXTENSIONTYPING + as this +#endif + = let mutable resolutions = initialResolutions let mutable importsBase: TcImports option = importsBase @@ -777,8 +774,8 @@ and [] TcImports(tcConfigP: TcConfigProvider, initialResolutions: TcAsse let mutable disposed = false let mutable ilGlobalsOpt = ilGlobalsOpt let mutable tcGlobals = None -#if !NO_EXTENSIONTYPING let disposeTypeProviderActions = ResizeArray() +#if !NO_EXTENSIONTYPING let mutable generatedTypeRoots = new System.Collections.Generic.Dictionary() let mutable tcImportsWeak = TcImportsWeakHack (WeakReference<_> this) #endif diff --git a/src/fsharp/ErrorLogger.fsi b/src/fsharp/ErrorLogger.fsi index 32939980d54..144ec183461 100644 --- a/src/fsharp/ErrorLogger.fsi +++ b/src/fsharp/ErrorLogger.fsi @@ -170,6 +170,7 @@ type internal CompileThreadStatic = static member ErrorLogger: ErrorLogger +[] module ErrorLoggerExtensions = val tryAndDetectDev15: bool diff --git a/src/fsharp/FSharp.Compiler.Private/FSharp.Compiler.Private.fsproj b/src/fsharp/FSharp.Compiler.Private/FSharp.Compiler.Private.fsproj index 1284eb8bdc9..e732f6fe2e0 100644 --- a/src/fsharp/FSharp.Compiler.Private/FSharp.Compiler.Private.fsproj +++ b/src/fsharp/FSharp.Compiler.Private/FSharp.Compiler.Private.fsproj @@ -106,6 +106,9 @@ Utilities\HashMultiMap.fs + + Utilities\EditDistance.fsi + Utilities\EditDistance.fs @@ -121,6 +124,9 @@ Utilities\ildiag.fs + + Utilities\illib.fsi + Utilities\illib.fs @@ -148,6 +154,9 @@ Utilities\bytes.fs + + Utilities\XmlAdapters.fsi + Utilities\XmlAdapters.fs @@ -157,9 +166,15 @@ Utilities\InternalCollections.fs + + Utilities\QueueList.fsi + Utilities\QueueList.fs + + Utilities\lib.fsi + Utilities\lib.fs @@ -181,9 +196,15 @@ ErrorLogging\range.fs + + ErrorLogging\ErrorLogger.fsi + ErrorLogging\ErrorLogger.fs + + ErrorLogging\ErrorResolutionHints.fsi + ErrorLogging\ErrorResolutionHints.fs @@ -279,9 +300,15 @@ AbsIL\ilwrite.fs + + AbsIL\ilreflect.fsi + AbsIL\ilreflect.fs + + ReferenceResolution\ReferenceResolver.fsi + ReferenceResolution\ReferenceResolver.fs @@ -293,13 +320,22 @@ ReferenceResolution/LegacyMSBuildReferenceResolver.fs + + ReferenceResolution/SimulatedMSBuildReferenceResolver.fsi + ReferenceResolution/SimulatedMSBuildReferenceResolver.fs + + CompilerLocation\CompilerLocationUtils.fsi + CompilerLocation\CompilerLocationUtils.fs + + PrettyNaming\PrettyNaming.fsi + PrettyNaming\PrettyNaming.fs @@ -358,15 +394,24 @@ ParserAndUntypedAST\layout.fs + + ParserAndUntypedAST\XmlDoc.fsi + ParserAndUntypedAST\XmlDoc.fs ParserAndUntypedAST\SyntaxTree.fs + + ParserAndUntypedAST\SyntaxTreeOps.fsi + ParserAndUntypedAST\SyntaxTreeOps.fs + + ParserAndUntypedAST\ParseHelpers.fsi + ParserAndUntypedAST\ParseHelpers.fs @@ -412,12 +457,18 @@ TypedTree\QuotationPickler.fs + + TypedTree\CompilerGlobalState.fsi + TypedTree\CompilerGlobalState.fs TypedTree\TypedTree.fs + + TypedTree\TypedTreeBasics.fsi + TypedTree\TypedTreeBasics.fs @@ -442,21 +493,39 @@ Logic\import.fs + + Logic\infos.fsi + Logic\infos.fs + + Logic\AccessibilityLogic.fsi + Logic\AccessibilityLogic.fs + + Logic\AttributeChecking.fsi + Logic\AttributeChecking.fs + + Logic\TypeRelations.fsi + Logic\TypeRelations.fs + + Logic\InfoReader.fsi + Logic\InfoReader.fs + + Logic\NicePrint.fsi + Logic\NicePrint.fs @@ -472,12 +541,21 @@ Logic\NameResolution.fs + + Logic\SignatureConformance.fsi + Logic\SignatureConformance.fs + + Logic\MethodOverrides.fsi + Logic\MethodOverrides.fs + + Logic\MethodCalls.fsi + Logic\MethodCalls.fs diff --git a/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj b/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj index ce22a67f26f..836c31fb5be 100644 --- a/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj +++ b/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj @@ -7,7 +7,7 @@ true $(DefineConstants);COMPILER_SERVICE_AS_DLL $(DefineConstants);COMPILER - $(DefineConstants);ENABLE_MONO_SUPPORT + $(DefineConstants);ENABLE_MONO_SUPPORT;NO_EXTENSIONTYPING $(OtherFlags) --sig:all.fsi /warnon:3218 /warnon:1182 /warnon:3390 --times true @@ -291,9 +291,6 @@ AbsIL\ilsupp.fs - - AbsIL\FsYaccOut\ilpars.fsi - AbsIL\FsYaccOut\ilpars.fs @@ -798,6 +795,12 @@ Service/IncrementalBuild.fs + + Service/ServiceCompilerDiagnostics.fsi + + + Service/ServiceCompilerDiagnostics.fs + Service/ServiceConstants.fs @@ -870,6 +873,12 @@ Service/service.fs + + Service/ServiceErrorResolutionHints.fsi + + + Service/ServiceErrorResolutionHints.fs + Service/ServiceInterfaceStubGenerator.fsi diff --git a/src/fsharp/FSharp.Compiler.Service/all.fsi b/src/fsharp/FSharp.Compiler.Service/all.fsi index 88407d67588..a9de56778fb 100644 --- a/src/fsharp/FSharp.Compiler.Service/all.fsi +++ b/src/fsharp/FSharp.Compiler.Service/all.fsi @@ -1,39 +1,25115 @@ +namespace FSComp + type internal SR = + class + private new : unit -> SR + static member + ArgumentsInSigAndImplMismatch : a0:System.String * a1:System.String -> + int * string + static member + CallerMemberNameIsOverriden : a0:System.String -> int * string + static member + DefaultParameterValueNotAppropriateForArgument : unit -> int * string + static member + DefinitionsInSigAndImplNotCompatibleAbbreviationHiddenBySig : a0:System.String * + a1:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleAbbreviationsDiffer : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleAbstractMemberMissingInImpl : a0:System.String * + a1:System.String * + a2:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleAbstractMemberMissingInSig : a0:System.String * + a1:System.String * + a2:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleAccessibilityDiffer : a0:System.String * + a1:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleDotNetTypeRepresentationIsHidden : a0:System.String * + a1:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleFieldIsInImplButNotSig : a0:System.String * + a1:System.String * + a2:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleFieldOrderDiffer : a0:System.String * + a1:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleFieldRequiredButNotSpecified : a0:System.String * + a1:System.String * + a2:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleFieldWasPresent : a0:System.String * + a1:System.String * + a2:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleILDiffer : a0:System.String * + a1:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleImplDefinesButSignatureDoesNot : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleImplDefinesStruct : a0:System.String * + a1:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleImplementationIsAbstract : a0:System.String * + a1:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleImplementationIsNotSealed : a0:System.String * + a1:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleImplementationSaysNull : a0:System.String * + a1:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleImplementationSaysNull2 : a0:System.String * + a1:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleImplementationSealed : a0:System.String * + a1:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleMissingInterface : a0:System.String * + a1:System.String * + a2:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleNamesDiffer : a0:System.String * + a1:System.String * + a2:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleNumbersDiffer : a0:System.String * + a1:System.String * + a2:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleParameterCountsDiffer : a0:System.String * + a1:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleRepresentationsDiffer : a0:System.String * + a1:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleSigHasAbbreviation : a0:System.String * + a1:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleSignatureDeclaresDiffer : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleSignatureDefinesButImplDoesNot : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String -> + int * + string + static member + DefinitionsInSigAndImplNotCompatibleSignatureIsAbstract : a0:System.String * + a1:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleSignatureSaysNull : a0:System.String * + a1:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleSignatureSaysNull2 : a0:System.String * + a1:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleTypeIsDifferentKind : a0:System.String * + a1:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleTypeIsHidden : a0:System.String * + a1:System.String -> + int * string + static member + DefinitionsInSigAndImplNotCompatibleTypesHaveDifferentBaseTypes : a0:System.String * + a1:System.String -> + int * + string + static member + ExceptionDefsNotCompatibleAbbreviationHiddenBySignature : a0:System.String * + a1:System.String -> + string + static member + ExceptionDefsNotCompatibleDotNetRepresentationsDiffer : a0:System.String * + a1:System.String -> + string + static member + ExceptionDefsNotCompatibleExceptionDeclarationsDiffer : a0:System.String * + a1:System.String -> + string + static member + ExceptionDefsNotCompatibleFieldInImplButNotSig : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ExceptionDefsNotCompatibleFieldInSigButNotImpl : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ExceptionDefsNotCompatibleFieldOrderDiffers : a0:System.String * + a1:System.String -> string + static member + ExceptionDefsNotCompatibleHiddenBySignature : a0:System.String * + a1:System.String -> string + static member + ExceptionDefsNotCompatibleSignaturesDiffer : a0:System.String * + a1:System.String -> string + static member + FieldNotContainedAccessibilitiesDiffer : a0:System.String * + a1:System.String -> string + static member + FieldNotContainedLiteralsDiffer : a0:System.String * a1:System.String -> + string + static member + FieldNotContainedMutablesDiffer : a0:System.String * a1:System.String -> + string + static member + FieldNotContainedNamesDiffer : a0:System.String * a1:System.String -> + string + static member + FieldNotContainedStaticsDiffer : a0:System.String * a1:System.String -> + string + static member + FieldNotContainedTypesDiffer : a0:System.String * a1:System.String -> + string + static member + InvalidRecursiveReferenceToAbstractSlot : unit -> int * string + static member + ModuleContainsConstructorButAccessibilityDiffers : a0:System.String * + a1:System.String -> + string + static member + ModuleContainsConstructorButDataFieldsDiffer : a0:System.String * + a1:System.String -> + string + static member + ModuleContainsConstructorButNamesDiffer : a0:System.String * + a1:System.String -> string + static member + ModuleContainsConstructorButTypesOfFieldsDiffer : a0:System.String * + a1:System.String -> + string + static member RunStartupValidation : unit -> unit + static member + ValueNotContainedMutabilityAbstractsDiffer : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + ValueNotContainedMutabilityAccessibilityMore : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ValueNotContainedMutabilityAritiesDiffer : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String * + a4:System.String * + a5:System.String * + a6:System.String -> string + static member + ValueNotContainedMutabilityArityNotInferred : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + ValueNotContainedMutabilityAttributesDiffer : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + ValueNotContainedMutabilityCompiledNamesDiffer : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ValueNotContainedMutabilityDisplayNamesDiffer : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ValueNotContainedMutabilityDotNetNamesDiffer : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ValueNotContainedMutabilityExtensionsDiffer : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + ValueNotContainedMutabilityFinalsDiffer : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + ValueNotContainedMutabilityGenericParametersAreDifferentKinds : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ValueNotContainedMutabilityGenericParametersDiffer : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String * + a4:System.String -> + string + static member + ValueNotContainedMutabilityInlineFlagsDiffer : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ValueNotContainedMutabilityInstanceButStatic : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ValueNotContainedMutabilityLiteralConstantValuesDiffer : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ValueNotContainedMutabilityNamesDiffer : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + ValueNotContainedMutabilityOneIsConstructor : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + ValueNotContainedMutabilityOneIsTypeFunction : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ValueNotContainedMutabilityOverridesDiffer : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + ValueNotContainedMutabilityParameterCountsDiffer : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ValueNotContainedMutabilityStaticButInstance : a0:System.String * + a1:System.String * + a2:System.String -> + string + static member + ValueNotContainedMutabilityStaticsDiffer : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + ValueNotContainedMutabilityTypesDiffer : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + ValueNotContainedMutabilityVirtualsDiffer : a0:System.String * + a1:System.String * + a2:System.String -> string + static member abImplicitHeapAllocation : a0:System.String -> int * string + static member + activePatternChoiceHasFreeTypars : a0:System.String -> int * string + static member + activePatternIdentIsNotFunctionTyped : a0:System.String -> int * string + static member addIndexerDot : unit -> string + static member + arrayElementHasWrongType : a0:System.String * a1:System.String -> string + static member + assemblyResolutionFoundByAssemblyFoldersExKey : unit -> string + static member assemblyResolutionFoundByAssemblyFoldersKey : unit -> string + static member assemblyResolutionGAC : unit -> string + static member assemblyResolutionNetFramework : unit -> string + static member astDeprecatedIndexerNotation : unit -> string + static member astInvalidExprLeftHandOfAssignment : unit -> int * string + static member astParseEmbeddedILError : unit -> int * string + static member astParseEmbeddedILTypeError : unit -> int * string + static member augCustomCompareNeedsIComp : unit -> int * string + static member augCustomEqNeedsNoCompOrCustomComp : unit -> int * string + static member augCustomEqNeedsObjEquals : unit -> int * string + static member augInvalidAttrs : unit -> int * string + static member augNoCompCantImpIComp : unit -> int * string + static member augNoEqNeedsNoObjEquals : unit -> int * string + static member augNoEqualityNeedsNoComparison : unit -> int * string + static member augNoRefEqualsOnStruct : unit -> int * string + static member augOnlyCertainTypesCanHaveAttrs : unit -> int * string + static member augRefEqCantHaveObjEquals : unit -> int * string + static member augStructCompNeedsStructEquality : unit -> int * string + static member augStructEqNeedsNoCompOrStructComp : unit -> int * string + static member augTypeCantHaveRefEqAndStructAttrs : unit -> int * string + static member buildArgInvalidFloat : a0:System.String -> int * string + static member buildArgInvalidInt : a0:System.String -> int * string + static member buildAssemblyResolutionFailed : unit -> int * string + static member buildCannotReadAssembly : a0:System.String -> int * string + static member buildCompilingExtensionIsForML : unit -> string + static member + buildCouldNotFindSourceFile : a0:System.String -> int * string + static member + buildCouldNotResolveAssembly : a0:System.String -> int * string + static member + buildCouldNotResolveAssemblyRequiredByFile : a0:System.String * + a1:System.String -> + int * string + static member + buildDifferentVersionMustRecompile : a0:System.String -> int * string + static member buildDirectivesInModulesAreIgnored : unit -> int * string + static member + buildErrorOpeningBinaryFile : a0:System.String * a1:System.String -> + int * string + static member + buildExpectedFileAlongSideFSharpCore : a0:System.String * + a1:System.String -> int * string + static member buildExpectedSigdataFile : a0:System.String -> int * string + static member + buildImplementationAlreadyGiven : a0:System.String -> int * string + static member + buildImplementationAlreadyGivenDetail : a0:System.String -> int * string + static member + buildImplicitModuleIsNotLegalIdentifier : a0:System.String * + a1:System.String -> + int * string + static member buildInvalidAssemblyName : a0:System.String -> int * string + static member buildInvalidFilename : a0:System.String -> int * string + static member buildInvalidHashIDirective : unit -> int * string + static member buildInvalidHashloadDirective : unit -> int * string + static member buildInvalidHashrDirective : unit -> int * string + static member buildInvalidHashtimeDirective : unit -> int * string + static member buildInvalidModuleOrNamespaceName : unit -> int * string + static member buildInvalidPrivacy : a0:System.String -> int * string + static member + buildInvalidSearchDirectory : a0:System.String -> int * string + static member + buildInvalidSourceFileExtension : a0:System.String -> int * string + static member buildInvalidVersionFile : a0:System.String -> int * string + static member buildInvalidVersionString : a0:System.String -> int * string + static member buildInvalidWarningNumber : a0:System.String -> int * string + static member + buildMultiFileRequiresNamespaceOrModule : unit -> int * string + static member buildMultipleToplevelModules : unit -> int * string + static member buildNoInputsSpecified : unit -> int * string + static member + buildOptionRequiresParameter : a0:System.String -> int * string + static member buildPdbRequiresDebug : unit -> int * string + static member + buildProblemReadingAssembly : a0:System.String * a1:System.String -> + int * string + static member + buildProblemWithFilename : a0:System.String * a1:System.String -> + int * string + static member + buildSearchDirectoryNotFound : a0:System.String -> int * string + static member + buildSignatureAlreadySpecified : a0:System.String -> int * string + static member + buildSignatureWithoutImplementation : a0:System.String -> int * string + static member + buildUnexpectedFileNameCharacter : a0:System.String * a1:System.String -> + int * string + static member + buildUnexpectedTypeArgs : a0:System.String * a1:System.Int32 -> string + static member buildUnrecognizedOption : a0:System.String -> int * string + static member + cannotResolveNullableOperators : a0:System.String -> int * string + static member + checkLowercaseLiteralBindingInPattern : a0:System.String -> int * string + static member + checkNotSufficientlyGenericBecauseOfScope : a0:System.String -> + int * string + static member + checkNotSufficientlyGenericBecauseOfScopeAnon : unit -> int * string + static member + checkRaiseFamilyFunctionArgumentCount : a0:System.String * + a1:System.Int32 * + a2:System.Int32 -> int * string + static member chkAttrHasAllowMultiFalse : a0:System.String -> int * string + static member chkBaseUsedInInvalidWay : unit -> int * string + static member chkByrefUsedInInvalidWay : a0:System.String -> int * string + static member chkCantStoreByrefValue : unit -> int * string + static member chkCurriedMethodsCantHaveOutParams : unit -> int * string + static member + chkDuplicateMethod : a0:System.String * a1:System.String -> int * string + static member + chkDuplicateMethodCurried : a0:System.String * a1:System.String -> + int * string + static member + chkDuplicateMethodInheritedType : a0:System.String -> int * string + static member + chkDuplicateMethodInheritedTypeWithSuffix : a0:System.String -> + int * string + static member + chkDuplicateMethodWithSuffix : a0:System.String * a1:System.String -> + int * string + static member + chkDuplicateProperty : a0:System.String * a1:System.String -> + int * string + static member + chkDuplicatePropertyWithSuffix : a0:System.String * a1:System.String -> + int * string + static member chkEntryPointUsage : unit -> int * string + static member chkErrorContainsCallToRethrow : unit -> int * string + static member chkErrorUseOfByref : unit -> int * string + static member + chkFeatureNotLanguageSupported : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member + chkFeatureNotRuntimeSupported : a0:System.String -> int * string + static member + chkFeatureNotSupportedInLibrary : a0:System.String * a1:System.String -> + int * string + static member chkFirstClassFuncNoByref : unit -> int * string + static member + chkGetterAndSetterHaveSamePropertyType : a0:System.String * + a1:System.String * + a2:System.String -> + int * string + static member + chkGetterSetterDoNotMatchAbstract : a0:System.String * a1:System.String -> + int * string + static member chkInvalidCustAttrVal : unit -> int * string + static member + chkInvalidFunctionParameterType : a0:System.String * a1:System.String -> + int * string + static member + chkInvalidFunctionReturnType : a0:System.String -> int * string + static member chkLimitationsOfBaseKeyword : unit -> int * string + static member + chkMemberUsedInInvalidWay : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member + chkMultipleGenericInterfaceInstantiations : a0:System.String * + a1:System.String -> + int * string + static member + chkNoAddressFieldAtThisPoint : a0:System.String -> int * string + static member chkNoAddressOfArrayElementAtThisPoint : unit -> int * string + static member chkNoAddressOfAtThisPoint : a0:System.String -> int * string + static member + chkNoAddressStaticFieldAtThisPoint : a0:System.String -> int * string + static member chkNoByrefAddressOfLocal : a0:System.String -> int * string + static member + chkNoByrefAddressOfValueFromExpression : unit -> int * string + static member chkNoByrefAsTopValue : unit -> int * string + static member chkNoByrefAtThisPoint : a0:System.String -> int * string + static member chkNoByrefInTypeAbbrev : unit -> int * string + static member chkNoByrefLikeFunctionCall : unit -> int * string + static member chkNoByrefsOfByrefs : a0:System.String -> int * string + static member chkNoFirstClassAddressOf : unit -> int * string + static member chkNoFirstClassNameOf : unit -> int * string + static member chkNoFirstClassRethrow : unit -> int * string + static member chkNoFirstClassSplicing : unit -> int * string + static member + chkNoReflectedDefinitionOnStructMember : unit -> int * string + static member chkNoSpanLikeValueFromExpression : unit -> int * string + static member chkNoSpanLikeVariable : a0:System.String -> int * string + static member chkNoWriteToLimitedSpan : a0:System.String -> int * string + static member chkObjCtorsCantUseExceptionHandling : unit -> int * string + static member + chkPropertySameNameIndexer : a0:System.String * a1:System.String -> + int * string + static member + chkPropertySameNameMethod : a0:System.String * a1:System.String -> + int * string + static member chkProtectedOrBaseCalled : unit -> int * string + static member chkReflectedDefCantSplice : unit -> int * string + static member chkReturnTypeNoByref : unit -> int * string + static member chkSplicingOnlyInQuotations : unit -> int * string + static member + chkStructsMayNotReturnAddressesOfContents : unit -> int * string + static member chkSystemVoidOnlyInTypeof : unit -> int * string + static member chkTyparMultipleClassConstraints : unit -> int * string + static member + chkTypeLessAccessibleThanType : a0:System.String * a1:System.String -> + int * string + static member chkUnionCaseCompiledForm : unit -> string + static member chkUnionCaseDefaultAugmentation : unit -> string + static member chkUnusedThisVariable : a0:System.String -> int * string + static member chkUnusedValue : a0:System.String -> int * string + static member + chkValueWithDefaultValueMustHaveDefaultValue : unit -> int * string + static member chkVariableUsedInInvalidWay : a0:System.String -> string + static member commaInsteadOfSemicolonInRecord : unit -> string + static member + considerUpcast : a0:System.String * a1:System.String -> int * string + static member + considerUpcastOperator : a0:System.String * a1:System.String -> + int * string + static member + couldNotLoadDependencyManagerExtension : a0:System.String * + a1:System.String -> + int * string + static member crefBoundVarUsedInSplice : a0:System.String -> int * string + static member crefNoInnerGenericsInQuotations : unit -> int * string + static member crefNoSetOfHole : unit -> int * string + static member crefQuotationsCantCallTraitMembers : unit -> int * string + static member crefQuotationsCantContainAddressOf : unit -> int * string + static member + crefQuotationsCantContainArrayPatternMatching : unit -> int * string + static member + crefQuotationsCantContainDescendingForLoops : unit -> int * string + static member crefQuotationsCantContainGenericExprs : unit -> int * string + static member + crefQuotationsCantContainGenericFunctions : unit -> int * string + static member crefQuotationsCantContainInlineIL : unit -> int * string + static member crefQuotationsCantContainObjExprs : unit -> int * string + static member + crefQuotationsCantContainStaticFieldRef : unit -> int * string + static member crefQuotationsCantContainThisConstant : unit -> int * string + static member + crefQuotationsCantContainThisPatternMatch : unit -> int * string + static member crefQuotationsCantContainThisType : unit -> int * string + static member crefQuotationsCantFetchUnionIndexes : unit -> int * string + static member crefQuotationsCantRequireByref : unit -> int * string + static member crefQuotationsCantSetExceptionFields : unit -> int * string + static member crefQuotationsCantSetUnionFields : unit -> int * string + static member csArgumentLengthMismatch : unit -> int * string + static member csArgumentTypesDoNotMatch : unit -> int * string + static member csAvailableOverloads : a0:System.String -> string + static member csCandidates : a0:System.String -> string + static member csCodeLessGeneric : unit -> int * string + static member + csCtorHasNoArgumentOrReturnProperty : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + csCtorSignatureMismatchArity : a0:System.String * a1:System.Int32 * + a2:System.Int32 * a3:System.String -> + int * string + static member + csCtorSignatureMismatchArityProp : a0:System.String * a1:System.Int32 * + a2:System.Int32 * a3:System.String -> + int * string + static member + csExpectTypeWithOperatorButGivenFunction : a0:System.String -> string + static member + csExpectTypeWithOperatorButGivenTuple : a0:System.String -> string + static member csExpectedArguments : unit -> string + static member + csGenericConstructRequiresNonAbstract : a0:System.String -> string + static member + csGenericConstructRequiresPublicDefaultConstructor : a0:System.String -> + string + static member + csGenericConstructRequiresReferenceSemantics : a0:System.String -> + string + static member + csGenericConstructRequiresStructOrReferenceConstraint : unit -> string + static member + csGenericConstructRequiresStructType : a0:System.String -> string + static member + csGenericConstructRequiresUnmanagedType : a0:System.String -> string + static member + csIncorrectGenericInstantiation : a0:System.String * a1:System.String * + a2:System.Int32 -> int * string + static member + csIndexArgumentMismatch : a0:System.Int32 * a1:System.Int32 -> string + static member + csMemberHasNoArgumentOrReturnProperty : a0:System.String * + a1:System.String * + a2:System.String -> string + static member + csMemberIsNotAccessible : a0:System.String * a1:System.String -> + int * string + static member + csMemberIsNotAccessible2 : a0:System.String * a1:System.String -> + int * string + static member csMemberIsNotInstance : a0:System.String -> int * string + static member csMemberIsNotStatic : a0:System.String -> int * string + static member + csMemberNotAccessible : a0:System.String * a1:System.Int32 * + a2:System.String * a3:System.Int32 -> + int * string + static member + csMemberOverloadArityMismatch : a0:System.String * a1:System.Int32 * + a2:System.Int32 -> int * string + static member + csMemberSignatureMismatch : a0:System.String * a1:System.Int32 * + a2:System.String -> int * string + static member + csMemberSignatureMismatch2 : a0:System.String * a1:System.Int32 * + a2:System.String -> int * string + static member + csMemberSignatureMismatch3 : a0:System.String * a1:System.Int32 * + a2:System.String * a3:System.String -> + int * string + static member + csMemberSignatureMismatch4 : a0:System.String * a1:System.Int32 * + a2:System.String * a3:System.String -> + int * string + static member + csMemberSignatureMismatchArity : a0:System.String * a1:System.Int32 * + a2:System.Int32 * a3:System.String -> + int * string + static member + csMemberSignatureMismatchArityNamed : a0:System.String * a1:System.Int32 * + a2:System.Int32 * a3:System.Int32 * + a4:System.String -> int * string + static member + csMemberSignatureMismatchArityType : a0:System.String * a1:System.Int32 * + a2:System.Int32 * a3:System.String -> + int * string + static member csMethodExpectsParams : unit -> int * string + static member + csMethodFoundButIsNotStatic : a0:System.String * a1:System.String * + a2:System.String -> string + static member + csMethodFoundButIsStatic : a0:System.String * a1:System.String * + a2:System.String -> string + static member + csMethodIsNotAStaticMethod : a0:System.String -> int * string + static member + csMethodIsNotAnInstanceMethod : a0:System.String -> int * string + static member csMethodIsOverloaded : a0:System.String -> string + static member csMethodNotFound : a0:System.String -> int * string + static member + csNoMemberTakesTheseArguments : a0:System.String * a1:System.String * + a2:System.Int32 -> int * string + static member + csNoMemberTakesTheseArguments2 : a0:System.String * a1:System.String * + a2:System.Int32 * a3:System.Int32 -> + int * string + static member + csNoMemberTakesTheseArguments3 : a0:System.String * a1:System.String * + a2:System.Int32 * a3:System.String -> + int * string + static member csNoOverloadsFound : a0:System.String -> string + static member + csNoOverloadsFoundArgumentsPrefixPlural : a0:System.String -> string + static member + csNoOverloadsFoundArgumentsPrefixSingular : a0:System.String -> string + static member csNoOverloadsFoundReturnType : a0:System.String -> string + static member + csNoOverloadsFoundTypeParametersPrefixPlural : a0:System.String -> + string + static member + csNoOverloadsFoundTypeParametersPrefixSingular : a0:System.String -> + string + static member csNullableTypeDoesNotHaveNull : a0:System.String -> string + static member csOptionalArgumentNotPermittedHere : unit -> int * string + static member + csOverloadCandidateIndexedArgumentTypeMismatch : a0:System.Int32 -> + string + static member + csOverloadCandidateNamedArgumentTypeMismatch : a0:System.String -> + string + static member csRequiredSignatureIs : a0:System.String -> int * string + static member csStructConstraintInconsistent : unit -> int * string + static member + csTypeCannotBeResolvedAtCompileTime : a0:System.String -> string + static member csTypeDoesNotHaveNull : a0:System.String -> string + static member csTypeDoesNotSupportComparison1 : a0:System.String -> string + static member csTypeDoesNotSupportComparison2 : a0:System.String -> string + static member csTypeDoesNotSupportComparison3 : a0:System.String -> string + static member + csTypeDoesNotSupportConversion : a0:System.String * a1:System.String -> + string + static member csTypeDoesNotSupportEquality1 : a0:System.String -> string + static member csTypeDoesNotSupportEquality2 : a0:System.String -> string + static member csTypeDoesNotSupportEquality3 : a0:System.String -> string + static member + csTypeDoesNotSupportOperator : a0:System.String * a1:System.String -> + string + static member + csTypeDoesNotSupportOperatorNullable : a0:System.String * + a1:System.String -> string + static member + csTypeHasNonStandardDelegateType : a0:System.String -> string + static member csTypeInferenceMaxDepth : unit -> int * string + static member csTypeInstantiationLengthMismatch : unit -> int * string + static member csTypeIsNotDelegateType : a0:System.String -> string + static member csTypeIsNotEnumType : a0:System.String -> string + static member + csTypeNotCompatibleBecauseOfPrintf : a0:System.String * a1:System.String -> + string + static member csTypeParameterCannotBeNullable : unit -> string + static member + csTypesDoNotSupportOperator : a0:System.String * a1:System.String -> + string + static member + csTypesDoNotSupportOperatorNullable : a0:System.String * + a1:System.String -> string + static member + customOperationTextLikeGroupJoin : a0:System.String * a1:System.String * + a2:System.String -> string + static member + customOperationTextLikeJoin : a0:System.String * a1:System.String * + a2:System.String -> string + static member customOperationTextLikeZip : a0:System.String -> string + static member + delegatesNotAllowedToHaveCurriedSignatures : unit -> int * string + static member derefInsteadOfNot : unit -> string + static member descriptionUnavailable : unit -> string + static member descriptionWordIs : unit -> string + static member docfileNoXmlSuffix : unit -> int * string + static member elDeprecatedOperator : unit -> string + static member elSysEnvExitDidntExit : unit -> string + static member + elseBranchHasWrongType : a0:System.String * a1:System.String -> string + static member erasedTo : unit -> string + static member + estApplyStaticArgumentsForMethodNotImplemented : unit -> string + static member etBadUnnamedStaticArgs : unit -> int * string + static member + etDirectReferenceToGeneratedTypeNotAllowed : a0:System.String -> + int * string + static member + etEmptyNamespaceNotAllowed : a0:System.String -> int * string + static member + etEmptyNamespaceOfTypeNotAllowed : a0:System.String * a1:System.String -> + int * string + static member + etErasedTypeUsedInGeneration : a0:System.String * a1:System.String -> + int * string + static member + etErrorApplyingStaticArgumentsToMethod : unit -> int * string + static member etErrorApplyingStaticArgumentsToType : unit -> int * string + static member + etEventNoAdd : a0:System.String * a1:System.String -> int * string + static member + etEventNoRemove : a0:System.String * a1:System.String -> int * string + static member + etHostingAssemblyFoundWithoutHosts : a0:System.String * a1:System.String -> + int * string + static member + etIllegalCharactersInNamespaceName : a0:System.String * a1:System.String -> + int * string + static member + etIllegalCharactersInTypeName : a0:System.String * a1:System.String -> + int * string + static member + etIncorrectParameterExpression : a0:System.String * a1:System.String -> + int * string + static member + etIncorrectProvidedConstructor : a0:System.String * a1:System.String -> + int * string + static member + etIncorrectProvidedMethod : a0:System.String * a1:System.String * + a2:System.Int32 * a3:System.String -> + int * string + static member etInvalidStaticArgument : a0:System.String -> int * string + static member + etInvalidTypeProviderAssemblyName : a0:System.String * a1:System.String -> + int * string + static member + etMethodHasRequirements : a0:System.String * a1:System.String -> + int * string + static member etMissingStaticArgumentsToMethod : unit -> int * string + static member + etMultipleStaticParameterWithName : a0:System.String -> int * string + static member etMustNotBeAnArray : a0:System.String -> int * string + static member etMustNotBeGeneric : a0:System.String -> int * string + static member + etNestedProvidedTypesDoNotTakeStaticArgumentsOrGenericParameters : unit -> + int * + string + static member + etNoStaticParameterWithName : a0:System.String -> int * string + static member etNullMember : a0:System.String -> int * string + static member + etNullMemberDeclaringType : a0:System.String * a1:System.String -> + int * string + static member + etNullMemberDeclaringTypeDifferentFromProvidedType : a0:System.String * + a1:System.String * + a2:System.String -> + int * string + static member etNullOrEmptyMemberName : a0:System.String -> int * string + static member etNullProvidedExpression : a0:System.String -> int * string + static member + etOneOrMoreErrorsSeenDuringExtensionTypeSetting : unit -> int * string + static member + etPropertyCanReadButHasNoGetter : a0:System.String * a1:System.String -> + int * string + static member + etPropertyCanWriteButHasNoSetter : a0:System.String * a1:System.String -> + int * string + static member + etPropertyHasGetterButNoCanRead : a0:System.String * a1:System.String -> + int * string + static member + etPropertyHasSetterButNoCanWrite : a0:System.String * a1:System.String -> + int * string + static member + etPropertyNeedsCanWriteOrCanRead : a0:System.String * a1:System.String -> + int * string + static member + etProvidedAppliedMethodHadWrongName : a0:System.String * + a1:System.String * + a2:System.String -> int * string + static member + etProvidedAppliedTypeHadWrongName : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member + etProvidedTypeHasUnexpectedName : a0:System.String * a1:System.String -> + int * string + static member + etProvidedTypeHasUnexpectedPath : a0:System.String * a1:System.String -> + int * string + static member + etProvidedTypeReferenceInvalidText : a0:System.String -> int * string + static member + etProvidedTypeReferenceMissingArgument : a0:System.String -> + int * string + static member + etProvidedTypeWithNameException : a0:System.String * a1:System.String -> + int * string + static member + etProvidedTypeWithNullOrEmptyName : a0:System.String -> int * string + static member etProviderDoesNotHaveValidConstructor : unit -> int * string + static member + etProviderError : a0:System.String * a1:System.String -> int * string + static member + etProviderErrorWithContext : a0:System.String * a1:System.String * + a2:System.String * a3:System.String -> + int * string + static member + etProviderHasDesignerAssemblyDependency : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String -> + int * string + static member + etProviderHasDesignerAssemblyException : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String -> + int * string + static member + etProviderHasWrongDesignerAssembly : a0:System.String * a1:System.String * + a2:System.String * a3:System.String * + a4:System.String -> int * string + static member + etProviderHasWrongDesignerAssemblyNoPath : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String -> + int * string + static member etProviderReturnedNull : a0:System.String -> int * string + static member + etStaticParameterAlreadyHasValue : a0:System.String -> int * string + static member + etStaticParameterRequiresAValue : a0:System.String * a1:System.String * + a2:System.String * a3:System.String -> + int * string + static member + etTooManyStaticParameters : a0:System.Int32 * a1:System.Int32 * + a2:System.Int32 -> int * string + static member + etTypeProviderConstructorException : a0:System.String -> int * string + static member + etUnexpectedExceptionFromProvidedMemberMember : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String -> + int * string + static member + etUnexpectedExceptionFromProvidedTypeMember : a0:System.String * + a1:System.String * + a2:System.String -> + int * string + static member + etUnexpectedNullFromProvidedTypeMember : a0:System.String * + a1:System.String -> + int * string + static member + etUnknownStaticArgumentKind : a0:System.String * a1:System.String -> + int * string + static member etUnsupportedConstantType : a0:System.String -> int * string + static member + etUnsupportedMemberKind : a0:System.String * a1:System.String -> + int * string + static member + etUnsupportedProvidedExpression : a0:System.String -> int * string + static member + eventHasNonStandardType : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member experimentalConstruct : unit -> string + static member expressionHasNoName : unit -> int * string + static member featureAndBang : unit -> string + static member featureDefaultInterfaceMemberConsumption : unit -> string + static member featureDotlessFloat32Literal : unit -> string + static member featureExpandedMeasurables : unit -> string + static member featureFixedIndexSlice3d4d : unit -> string + static member featureFromEndSlicing : unit -> string + static member featureImplicitYield : unit -> string + static member + featureInterfacesWithMultipleGenericInstantiation : unit -> string + static member featureNameOf : unit -> string + static member featureNullableOptionalInterop : unit -> string + static member featureOpenTypeDeclaration : unit -> string + static member featureOverloadsForCustomOperations : unit -> string + static member featurePackageManagement : unit -> string + static member featureRelaxWhitespace : unit -> string + static member featureSingleUnderscorePattern : unit -> string + static member featureStringInterpolation : unit -> string + static member featureWildCardInForLoop : unit -> string + static member featureWitnessPassing : unit -> string + static member fieldIsNotAccessible : a0:System.String -> int * string + static member + followingPatternMatchClauseHasWrongType : a0:System.String * + a1:System.String -> string + static member forBadFormatSpecifier : unit -> string + static member forBadFormatSpecifierGeneral : a0:System.String -> string + static member forBadPrecision : unit -> string + static member forBadWidth : unit -> string + static member + forDoesNotSupportPrefixFlag : a0:System.String * a1:System.String -> + string + static member forDoesNotSupportZeroFlag : a0:System.String -> string + static member forFlagSetTwice : a0:System.String -> string + static member forFormatDoesntSupportPrecision : a0:System.String -> string + static member forFormatInvalidForInterpolated : unit -> string + static member forFormatInvalidForInterpolated2 : unit -> string + static member forFormatInvalidForInterpolated3 : unit -> string + static member forFormatInvalidForInterpolated4 : unit -> string + static member forHIsUnnecessary : unit -> string + static member forHashSpecifierIsInvalid : unit -> string + static member forLIsUnnecessary : unit -> string + static member forMissingFormatSpecifier : unit -> string + static member forPositionalSpecifiersNotPermitted : unit -> string + static member forPrecisionMissingAfterDot : unit -> string + static member forPrefixFlagSpacePlusSetTwice : unit -> string + static member formatDashItem : a0:System.String -> string + static member fromEndSlicingRequiresVFive : unit -> int * string + static member fscAssemblyCultureAttributeError : unit -> int * string + static member + fscAssemblyNotFoundInDependencySet : a0:System.String -> int * string + static member fscAssemblyVersionAttributeIgnored : unit -> int * string + static member + fscAssemblyWildcardAndDeterminism : a0:System.String * a1:System.String -> + int * string + static member + fscAssumeStaticLinkContainsNoDependencies : a0:System.String -> + int * string + static member + fscBadAssemblyVersion : a0:System.String * a1:System.String -> + int * string + static member fscDelaySignWarning : unit -> int * string + static member + fscDeterministicDebugRequiresPortablePdb : unit -> int * string + static member + fscIgnoringMixedWhenLinking : a0:System.String -> int * string + static member + fscKeyFileCouldNotBeOpened : a0:System.String -> int * string + static member fscKeyFileWarning : unit -> int * string + static member fscKeyNameWarning : unit -> int * string + static member fscNoImplementationFiles : unit -> int * string + static member fscPathMapDebugRequiresPortablePdb : unit -> int * string + static member + fscProblemWritingBinary : a0:System.String * a1:System.String -> + int * string + static member + fscQuotationLiteralsStaticLinking : a0:System.String -> int * string + static member fscQuotationLiteralsStaticLinking0 : unit -> int * string + static member fscReferenceOnCommandLine : a0:System.String -> int * string + static member fscRemotingError : unit -> int * string + static member + fscResxSourceFileDeprecated : a0:System.String -> int * string + static member fscStaticLinkingNoEXE : unit -> int * string + static member fscStaticLinkingNoMixedDLL : unit -> int * string + static member fscStaticLinkingNoProfileMismatches : unit -> int * string + static member + fscSystemRuntimeInteropServicesIsRequired : unit -> int * string + static member fscTooManyErrors : unit -> string + static member fscTwoResourceManifests : unit -> int * string + static member fsharpCoreNotFoundToBeCopied : unit -> int * string + static member + fsiInvalidDirective : a0:System.String * a1:System.String -> + int * string + static member ifExpression : a0:System.String * a1:System.String -> string + static member ilAddressOfLiteralFieldIsInvalid : unit -> int * string + static member + ilAddressOfValueHereIsInvalid : a0:System.String -> int * string + static member + ilCustomMarshallersCannotBeUsedInFSharp : unit -> int * string + static member + ilDefaultAugmentationAttributeCouldNotBeDecoded : unit -> int * string + static member ilDllImportAttributeCouldNotBeDecoded : unit -> int * string + static member ilDynamicInvocationNotSupported : a0:System.String -> string + static member + ilFieldDoesNotHaveValidOffsetForStructureLayout : a0:System.String * + a1:System.String -> + int * string + static member ilFieldHasOffsetForSequentialLayout : unit -> int * string + static member + ilFieldOffsetAttributeCouldNotBeDecoded : unit -> int * string + static member ilIncorrectNumberOfTypeArguments : unit -> int * string + static member ilLabelNotFound : a0:System.String -> int * string + static member ilLiteralFieldsCannotBeSet : unit -> int * string + static member ilMainModuleEmpty : unit -> int * string + static member ilMarshalAsAttributeCannotBeDecoded : unit -> int * string + static member ilMutableVariablesCannotEscapeMethod : unit -> int * string + static member + ilReflectedDefinitionsCannotUseSliceOperator : unit -> int * string + static member ilSignBadImageFormat : unit -> int * string + static member ilSignInvalidAlgId : unit -> int * string + static member ilSignInvalidBitLen : unit -> int * string + static member ilSignInvalidMagicValue : unit -> int * string + static member ilSignInvalidPKBlob : unit -> int * string + static member ilSignInvalidRSAParams : unit -> int * string + static member ilSignInvalidSignatureSize : unit -> int * string + static member ilSignNoSignatureDirectory : unit -> int * string + static member ilSignPrivateKeyExpected : unit -> int * string + static member ilSignRsaKeyExpected : unit -> int * string + static member + ilSignatureForExternalFunctionContainsTypeParameters : unit -> + int * string + static member ilStaticMethodIsNotLambda : a0:System.String -> int * string + static member + ilStructLayoutAttributeCouldNotBeDecoded : unit -> int * string + static member ilTypeCannotBeUsedForLiteralField : unit -> int * string + static member ilUndefinedValue : a0:System.String -> int * string + static member ilUnexpectedGetSetAnnotation : unit -> int * string + static member ilUnexpectedUnrealizedValue : unit -> int * string + static member ilreadFileChanged : a0:System.String -> int * string + static member ilwriteErrorCreatingMdb : unit -> int * string + static member ilwriteErrorCreatingPdb : a0:System.String -> int * string + static member + ilwriteMDBFileNameCannotBeChangedWarning : unit -> int * string + static member ilwriteMDBMemberMissing : a0:System.String -> int * string + static member + ilxgenUnexpectedArgumentToMethodHandleOfDuringCodegen : unit -> + int * string + static member + impImportedAssemblyUsesNotPublicType : a0:System.String -> int * string + static member + impInvalidMeasureArgument1 : a0:System.String * a1:System.String -> + int * string + static member + impInvalidMeasureArgument2 : a0:System.String -> int * string + static member + impInvalidNumberOfGenericArguments : a0:System.String * a1:System.Int32 * + a2:System.Int32 -> int * string + static member + impNotEnoughTypeParamsInScopeWhileImporting : unit -> int * string + static member + impReferenceToDllRequiredByAssembly : a0:System.String * + a1:System.String * + a2:System.String -> int * string + static member + impReferencedTypeCouldNotBeFoundInAssembly : a0:System.String * + a1:System.String -> + int * string + static member + impTypeRequiredUnavailable : a0:System.String * a1:System.String -> + int * string + static member + implicitlyDiscardedInSequenceExpression : a0:System.String -> + int * string + static member + implicitlyDiscardedSequenceInSequenceExpression : a0:System.String -> + int * string + static member + infosInvalidProvidedLiteralValue : a0:System.String -> int * string + static member invalidFullNameForProvidedType : unit -> string + static member invalidNamespaceForProvidedType : unit -> string + static member invalidPlatformTarget : unit -> int * string + static member + itemNotFoundDuringDynamicCodeGen : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member + itemNotFoundInTypeDuringDynamicCodeGen : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String -> + int * string + static member keywordDescriptionAbstract : unit -> string + static member keywordDescriptionAs : unit -> string + static member keywordDescriptionAssert : unit -> string + static member keywordDescriptionBase : unit -> string + static member keywordDescriptionBegin : unit -> string + static member keywordDescriptionCast : unit -> string + static member keywordDescriptionClass : unit -> string + static member keywordDescriptionConst : unit -> string + static member keywordDescriptionDefault : unit -> string + static member keywordDescriptionDelegate : unit -> string + static member keywordDescriptionDo : unit -> string + static member keywordDescriptionDone : unit -> string + static member keywordDescriptionDowncast : unit -> string + static member keywordDescriptionDownto : unit -> string + static member keywordDescriptionDynamicCast : unit -> string + static member keywordDescriptionElif : unit -> string + static member keywordDescriptionElse : unit -> string + static member keywordDescriptionEnd : unit -> string + static member keywordDescriptionException : unit -> string + static member keywordDescriptionExtern : unit -> string + static member keywordDescriptionFinally : unit -> string + static member keywordDescriptionFor : unit -> string + static member keywordDescriptionFun : unit -> string + static member keywordDescriptionFunction : unit -> string + static member keywordDescriptionGlobal : unit -> string + static member keywordDescriptionIf : unit -> string + static member keywordDescriptionIn : unit -> string + static member keywordDescriptionInherit : unit -> string + static member keywordDescriptionInline : unit -> string + static member keywordDescriptionInterface : unit -> string + static member keywordDescriptionInternal : unit -> string + static member keywordDescriptionLazy : unit -> string + static member keywordDescriptionLeftArrow : unit -> string + static member keywordDescriptionLet : unit -> string + static member keywordDescriptionLetBang : unit -> string + static member keywordDescriptionMatch : unit -> string + static member keywordDescriptionMatchBang : unit -> string + static member keywordDescriptionMember : unit -> string + static member keywordDescriptionModule : unit -> string + static member keywordDescriptionMutable : unit -> string + static member keywordDescriptionNamespace : unit -> string + static member keywordDescriptionNew : unit -> string + static member keywordDescriptionNot : unit -> string + static member keywordDescriptionNull : unit -> string + static member keywordDescriptionOf : unit -> string + static member keywordDescriptionOpen : unit -> string + static member keywordDescriptionOr : unit -> string + static member keywordDescriptionOverride : unit -> string + static member keywordDescriptionPrivate : unit -> string + static member keywordDescriptionPublic : unit -> string + static member keywordDescriptionRec : unit -> string + static member keywordDescriptionReturn : unit -> string + static member keywordDescriptionReturnBang : unit -> string + static member keywordDescriptionRightArrow : unit -> string + static member keywordDescriptionSelect : unit -> string + static member keywordDescriptionStatic : unit -> string + static member keywordDescriptionStruct : unit -> string + static member keywordDescriptionThen : unit -> string + static member keywordDescriptionTo : unit -> string + static member keywordDescriptionTrueFalse : unit -> string + static member keywordDescriptionTry : unit -> string + static member keywordDescriptionType : unit -> string + static member keywordDescriptionTypedQuotation : unit -> string + static member keywordDescriptionUntypedQuotation : unit -> string + static member keywordDescriptionUpcast : unit -> string + static member keywordDescriptionUse : unit -> string + static member keywordDescriptionUseBang : unit -> string + static member keywordDescriptionVal : unit -> string + static member keywordDescriptionVoid : unit -> string + static member keywordDescriptionWhen : unit -> string + static member keywordDescriptionWhile : unit -> string + static member keywordDescriptionWith : unit -> string + static member keywordDescriptionYield : unit -> string + static member keywordDescriptionYieldBang : unit -> string + static member keyworkDescriptionAnd : unit -> string + static member lexByteArrayCannotEncode : unit -> int * string + static member lexByteStringMayNotBeInterpolated : unit -> int * string + static member + lexCharNotAllowedInOperatorNames : a0:System.String -> string + static member lexHashBangMustBeFirstInFile : unit -> string + static member lexHashElseMustBeFirst : unit -> int * string + static member lexHashElseNoMatchingIf : unit -> string + static member lexHashEndifMustBeFirst : unit -> int * string + static member lexHashEndifRequiredForElse : unit -> string + static member lexHashEndingNoMatchingIf : unit -> string + static member lexHashIfMustBeFirst : unit -> int * string + static member lexHashIfMustHaveIdent : unit -> int * string + static member lexIdentEndInMarkReserved : a0:System.String -> int * string + static member lexIndentOffForML : unit -> string + static member lexInvalidByteLiteral : unit -> int * string + static member lexInvalidCharLiteral : unit -> int * string + static member lexInvalidFloat : unit -> int * string + static member lexInvalidLineNumber : a0:System.String -> int * string + static member lexInvalidNumericLiteral : unit -> int * string + static member lexInvalidUnicodeLiteral : a0:System.String -> int * string + static member lexOusideDecimal : unit -> int * string + static member lexOusideThirtyTwoBitFloat : unit -> int * string + static member lexOutsideEightBitSigned : unit -> int * string + static member lexOutsideEightBitSignedHex : unit -> int * string + static member lexOutsideEightBitUnsigned : unit -> int * string + static member lexOutsideIntegerRange : unit -> int * string + static member lexOutsideNativeSigned : unit -> int * string + static member lexOutsideNativeUnsigned : unit -> int * string + static member lexOutsideSixteenBitSigned : unit -> int * string + static member lexOutsideSixteenBitUnsigned : unit -> int * string + static member lexOutsideSixtyFourBitSigned : unit -> int * string + static member lexOutsideSixtyFourBitUnsigned : unit -> int * string + static member lexOutsideThirtyTwoBitSigned : unit -> int * string + static member lexOutsideThirtyTwoBitUnsigned : unit -> int * string + static member lexRBraceInInterpolatedString : unit -> int * string + static member lexSingleQuoteInSingleQuote : unit -> int * string + static member lexTabsNotAllowed : unit -> int * string + static member lexThisUnicodeOnlyInStringLiterals : unit -> int * string + static member lexTokenReserved : unit -> int * string + static member lexTripleQuoteInTripleQuote : unit -> int * string + static member lexUnexpectedChar : a0:System.String -> string + static member lexWrongNestedHashEndif : unit -> int * string + static member lexfltIncorrentIndentationOfIn : unit -> string + static member + lexfltSeparatorTokensOfPatternMatchMisaligned : unit -> string + static member + lexfltTokenIsOffsideOfContextStartedEarlier : a0:System.String -> string + static member lexhlpIdentifierReserved : a0:System.String -> string + static member + lexhlpIdentifiersContainingAtSymbolReserved : unit -> int * string + static member + listElementHasWrongType : a0:System.String * a1:System.String -> string + static member loadingDescription : unit -> string + static member + memberOperatorDefinitionWithCurriedArguments : a0:System.String -> + int * string + static member + memberOperatorDefinitionWithNoArguments : a0:System.String -> + int * string + static member + memberOperatorDefinitionWithNonPairArgument : a0:System.String * + a1:System.Int32 -> + int * string + static member + memberOperatorDefinitionWithNonTripleArgument : a0:System.String * + a1:System.Int32 -> + int * string + static member methodIsNotStatic : a0:System.String -> int * string + static member missingElseBranch : a0:System.String -> string + static member mlCompatMessage : a0:System.String -> string + static member moreThanOneInvokeMethodFound : unit -> string + static member nativeResourceFormatError : unit -> string + static member nativeResourceHeaderMalformed : a0:System.String -> string + static member nicePrintOtherOverloads1 : unit -> string + static member nicePrintOtherOverloadsN : a0:System.Int32 -> string + static member noEqualSignAfterModule : unit -> int * string + static member noInvokeMethodsFound : unit -> int * string + static member notAFunction : unit -> string + static member notAFunctionButMaybeDeclaration : unit -> string + static member notAFunctionButMaybeIndexer : unit -> string + static member notAFunctionButMaybeIndexerErrorCode : unit -> int * string + static member + notAFunctionButMaybeIndexerWithName : a0:System.String -> string + static member nrGlobalUsedOnlyAsFirstName : unit -> int * string + static member nrInvalidExpression : a0:System.String -> int * string + static member nrInvalidFieldLabel : unit -> int * string + static member nrInvalidModuleExprType : unit -> int * string + static member nrIsNotConstructorOrLiteral : unit -> int * string + static member + nrNoConstructorsAvailableForType : a0:System.String -> int * string + static member + nrRecordDoesNotContainSuchLabel : a0:System.String * a1:System.String -> + int * string + static member + nrRecordTypeNeedsQualifiedAccess : a0:System.String * a1:System.String -> + int * string + static member + nrTypeInstantiationIsMissingAndCouldNotBeInferred : a0:System.String * + a1:System.String -> + int * string + static member + nrTypeInstantiationNeededToDisambiguateTypesWithSameName : a0:System.String * + a1:System.String -> + int * + string + static member nrUnexpectedEmptyLongId : unit -> int * string + static member + nrUnionTypeNeedsQualifiedAccess : a0:System.String * a1:System.String -> + int * string + static member optFailedToInlineValue : a0:System.String -> int * string + static member + optLocalValueNotFoundDuringOptimization : a0:System.String -> + int * string + static member optRecursiveValValue : a0:System.String -> int * string + static member + optValueMarkedInlineButIncomplete : a0:System.String -> int * string + static member + optValueMarkedInlineButWasNotBoundInTheOptEnv : a0:System.String -> + int * string + static member optValueMarkedInlineCouldNotBeInlined : unit -> int * string + static member + optValueMarkedInlineHasUnexpectedValue : unit -> int * string + static member optsBaseaddress : unit -> string + static member optsBuildConsole : unit -> string + static member optsBuildLibrary : unit -> string + static member optsBuildModule : unit -> string + static member optsBuildWindows : unit -> string + static member optsChecked : unit -> string + static member optsChecksumAlgorithm : unit -> string + static member optsClirootDeprecatedMsg : unit -> string + static member optsClirootDescription : unit -> string + static member optsCodepage : unit -> string + static member optsCompilerTool : unit -> string + static member optsConsoleColors : unit -> string + static member optsCopyright : unit -> string + static member optsCopyrightCommunity : unit -> string + static member optsCrossoptimize : unit -> string + static member + optsDCLODeprecatedSuggestAlternative : a0:System.String * + a1:System.String -> string + static member optsDCLOHtmlDoc : a0:System.String -> string + static member optsDCLONoDescription : a0:System.String -> string + static member optsDebug : a0:System.String -> string + static member optsDebugPM : unit -> string + static member optsDefine : unit -> string + static member optsDelaySign : unit -> string + static member optsDeterministic : unit -> string + static member optsEmbedAllSource : unit -> string + static member optsEmbedSource : unit -> string + static member optsEmbeddedSourceRequirePortablePDBs : unit -> int * string + static member optsEmitDebugInfoInQuotations : unit -> string + static member optsFullpaths : unit -> string + static member optsHelp : unit -> string + static member optsHelpBannerAdvanced : unit -> string + static member optsHelpBannerCodeGen : unit -> string + static member optsHelpBannerErrsAndWarns : unit -> string + static member optsHelpBannerInputFiles : unit -> string + static member optsHelpBannerLanguage : unit -> string + static member optsHelpBannerMisc : unit -> string + static member optsHelpBannerOutputFiles : unit -> string + static member optsHelpBannerResources : unit -> string + static member optsInternalNoDescription : a0:System.String -> string + static member optsInvalidPathMapFormat : unit -> int * string + static member + optsInvalidResponseFile : a0:System.String * a1:System.String -> + int * string + static member + optsInvalidSubSystemVersion : a0:System.String -> int * string + static member optsInvalidTargetProfile : a0:System.String -> int * string + static member optsInvalidWarningLevel : a0:System.Int32 -> int * string + static member optsLangVersion : unit -> string + static member optsLib : unit -> string + static member optsLinkresource : unit -> string + static member optsMlcompatibility : unit -> string + static member optsNameOfOutputFile : unit -> string + static member optsNoCopyFsharpCore : unit -> string + static member optsNoInterface : unit -> string + static member optsNoOpt : unit -> string + static member optsNoframework : unit -> string + static member optsNologo : unit -> string + static member optsNowarn : unit -> string + static member optsNowin32manifest : unit -> string + static member optsOptimize : unit -> string + static member optsPathMap : unit -> string + static member optsPdb : unit -> string + static member optsPlatform : unit -> string + static member optsPreferredUiLang : unit -> string + static member + optsProblemWithCodepage : a0:System.Int32 * a1:System.String -> + int * string + static member optsPublicSign : unit -> string + static member optsReference : unit -> string + static member optsResident : unit -> string + static member optsResource : unit -> string + static member optsResponseFile : unit -> string + static member + optsResponseFileNameInvalid : a0:System.String -> int * string + static member + optsResponseFileNotFound : a0:System.String * a1:System.String -> + int * string + static member optsShortFormOf : a0:System.String -> string + static member optsSig : unit -> string + static member optsSimpleresolution : unit -> string + static member optsSourceLink : unit -> string + static member optsSourceLinkRequirePortablePDBs : unit -> int * string + static member optsStandalone : unit -> string + static member optsStaticlink : unit -> string + static member optsStrongKeyContainer : unit -> string + static member optsStrongKeyFile : unit -> string + static member optsSubSystemVersion : unit -> string + static member optsSupportedLangVersions : unit -> string + static member optsTailcalls : unit -> string + static member optsTargetProfile : unit -> string + static member + optsUnknownArgumentToTheTestSwitch : a0:System.String -> int * string + static member + optsUnknownChecksumAlgorithm : a0:System.String -> int * string + static member optsUnknownPlatform : a0:System.String -> int * string + static member optsUnrecognizedDebugType : a0:System.String -> int * string + static member + optsUnrecognizedLanguageVersion : a0:System.String -> int * string + static member optsUnrecognizedTarget : a0:System.String -> int * string + static member optsUseHighEntropyVA : unit -> string + static member optsUtf8output : unit -> string + static member optsVersion : unit -> string + static member optsWarn : unit -> string + static member optsWarnOn : unit -> string + static member optsWarnaserror : unit -> string + static member optsWarnaserrorPM : unit -> string + static member optsWin32manifest : unit -> string + static member optsWin32res : unit -> string + static member optsWriteXml : unit -> string + static member packageManagementRequiresVFive : unit -> int * string + static member packageManagerError : a0:System.String -> int * string + static member + packageManagerUnknown : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member + parsAccessibilityModsIllegalForAbstract : unit -> int * string + static member parsActivePatternCaseContainsPipe : unit -> int * string + static member + parsActivePatternCaseMustBeginWithUpperCase : unit -> int * string + static member parsAllEnumFieldsRequireValues : unit -> int * string + static member parsArrowUseIsLimited : unit -> int * string + static member parsAssertIsNotFirstClassValue : unit -> int * string + static member parsAttributeOnIncompleteCode : unit -> int * string + static member + parsAttributesAreNotPermittedOnInterfaceImplementations : unit -> + int * string + static member parsAttributesIgnored : unit -> int * string + static member parsAttributesIllegalHere : unit -> int * string + static member parsAttributesIllegalOnInherit : unit -> int * string + static member parsAttributesMustComeBeforeVal : unit -> string + static member + parsAugmentationsIllegalOnDelegateType : unit -> int * string + static member parsConsiderUsingSeparateRecordType : unit -> string + static member + parsDoCannotHaveVisibilityDeclarations : a0:System.String -> + int * string + static member parsEmptyFillInInterpolatedString : unit -> int * string + static member parsEmptyTypeDefinition : unit -> int * string + static member + parsEnumFieldsCannotHaveVisibilityDeclarations : unit -> int * string + static member + parsEnumTypesCannotHaveVisibilityDeclarations : unit -> int * string + static member parsEofInComment : unit -> int * string + static member parsEofInDirective : unit -> int * string + static member parsEofInHashIf : unit -> int * string + static member parsEofInIfOcaml : unit -> int * string + static member parsEofInInterpolatedString : unit -> int * string + static member parsEofInInterpolatedStringFill : unit -> int * string + static member + parsEofInInterpolatedTripleQuoteString : unit -> int * string + static member parsEofInInterpolatedVerbatimString : unit -> int * string + static member parsEofInString : unit -> int * string + static member parsEofInStringInComment : unit -> int * string + static member parsEofInTripleQuoteString : unit -> int * string + static member parsEofInTripleQuoteStringInComment : unit -> int * string + static member parsEofInVerbatimString : unit -> int * string + static member parsEofInVerbatimStringInComment : unit -> int * string + static member + parsEqualsMissingInTypeDefinition : a0:System.String -> int * string + static member + parsErrorInReturnForLetIncorrectIndentation : unit -> int * string + static member parsErrorParsingAsOperatorName : unit -> int * string + static member + parsExpectedExpressionAfterLet : a0:System.String * a1:System.String -> + int * string + static member parsExpectedExpressionAfterToken : unit -> int * string + static member parsExpectedNameAfterToken : unit -> int * string + static member parsExpectedTypeAfterToken : unit -> int * string + static member parsFieldBinding : unit -> int * string + static member parsForDoExpected : unit -> int * string + static member parsGetAndOrSetRequired : unit -> int * string + static member parsGetOrSetRequired : unit -> int * string + static member parsGetterAtMostOneArgument : unit -> int * string + static member parsGetterMustHaveAtLeastOneArgument : unit -> int * string + static member parsIdentifierExpected : unit -> int * string + static member + parsIgnoreAttributesOnModuleAbbreviation : unit -> int * string + static member + parsIgnoreAttributesOnModuleAbbreviationAlwaysPrivate : a0:System.String -> + int * string + static member + parsIgnoreVisibilityOnModuleAbbreviationAlwaysPrivate : a0:System.String -> + int * string + static member + parsIllegalDenominatorForMeasureExponent : unit -> int * string + static member + parsIllegalMemberVarInObjectImplementation : unit -> int * string + static member parsInOrEqualExpected : unit -> int * string + static member parsIncompleteIf : unit -> int * string + static member + parsIndexerPropertyRequiresAtLeastOneArgument : unit -> int * string + static member + parsInheritDeclarationsCannotHaveAsBindings : unit -> int * string + static member + parsInlineAssemblyCannotHaveVisibilityDeclarations : unit -> + int * string + static member + parsIntegerForLoopRequiresSimpleIdentifier : unit -> int * string + static member + parsInterfacesHaveSameVisibilityAsEnclosingType : unit -> int * string + static member parsInvalidAnonRecdExpr : unit -> int * string + static member parsInvalidAnonRecdType : unit -> int * string + static member parsInvalidDeclarationSyntax : unit -> int * string + static member parsInvalidLiteralInType : unit -> int * string + static member parsInvalidPrefixOperator : unit -> int * string + static member parsInvalidPrefixOperatorDefinition : unit -> int * string + static member parsInvalidProperty : unit -> int * string + static member parsInvalidUseOfRec : unit -> int * string + static member parsLetAndForNonRecBindings : unit -> int * string + static member + parsMemberIllegalInObjectImplementation : unit -> int * string + static member + parsMismatchedQuotationName : a0:System.String -> int * string + static member parsMismatchedQuote : a0:System.String -> int * string + static member parsMissingFunctionBody : unit -> int * string + static member parsMissingGreaterThan : unit -> int * string + static member parsMissingQualificationAfterDot : unit -> int * string + static member parsMissingTypeArgs : unit -> int * string + static member + parsModuleAbbreviationMustBeSimpleName : unit -> int * string + static member parsModuleDefnMustBeSimpleName : unit -> int * string + static member parsMultiArgumentGenericTypeFormDeprecated : unit -> string + static member parsMultipleAccessibilitiesForGetSet : unit -> int * string + static member + parsMutableOnAutoPropertyShouldBeGetSet : unit -> int * string + static member + parsMutableOnAutoPropertyShouldBeGetSetNotJustSet : unit -> int * string + static member parsNamespaceOrModuleNotBoth : unit -> int * string + static member parsNoEqualShouldFollowNamespace : unit -> string + static member parsNoHashEndIfFound : unit -> int * string + static member parsNoMatchingInForLet : unit -> int * string + static member parsNonAdjacentTyargs : unit -> int * string + static member parsNonAdjacentTypars : unit -> int * string + static member parsNonAtomicType : unit -> string + static member parsOnlyClassCanTakeValueArguments : unit -> int * string + static member parsOnlyHashDirectivesAllowed : unit -> int * string + static member parsOnlyOneWithAugmentationAllowed : unit -> int * string + static member parsParenFormIsForML : unit -> string + static member + parsRecordFieldsCannotHaveVisibilityDeclarations : unit -> int * string + static member parsSetSyntax : unit -> int * string + static member parsSetterAtMostTwoArguments : unit -> int * string + static member + parsSuccessiveArgsShouldBeSpacedOrTupled : unit -> int * string + static member + parsSuccessivePatternsShouldBeSpacedOrTupled : unit -> int * string + static member parsSyntaxError : unit -> int * string + static member parsSyntaxErrorInLabeledType : unit -> int * string + static member parsSyntaxModuleSigEndDeprecated : unit -> string + static member parsSyntaxModuleStructEndDeprecated : unit -> string + static member + parsTypeAbbreviationsCannotHaveVisibilityDeclarations : unit -> + int * string + static member parsTypeAnnotationsOnGetSet : unit -> int * string + static member parsTypeNameCannotBeEmpty : unit -> int * string + static member parsUnClosedBlockInHashLight : unit -> int * string + static member parsUnderscoreInvalidFieldName : unit -> int * string + static member parsUnexpectedEmptyModuleDefn : unit -> int * string + static member parsUnexpectedEndOfFile : unit -> int * string + static member parsUnexpectedEndOfFileDefinition : unit -> int * string + static member parsUnexpectedEndOfFileElse : unit -> int * string + static member parsUnexpectedEndOfFileExpression : unit -> int * string + static member parsUnexpectedEndOfFileFor : unit -> int * string + static member parsUnexpectedEndOfFileFunBody : unit -> int * string + static member parsUnexpectedEndOfFileMatch : unit -> int * string + static member parsUnexpectedEndOfFileObjectMembers : unit -> int * string + static member parsUnexpectedEndOfFileThen : unit -> int * string + static member parsUnexpectedEndOfFileTry : unit -> int * string + static member parsUnexpectedEndOfFileTypeArgs : unit -> int * string + static member parsUnexpectedEndOfFileTypeDefinition : unit -> int * string + static member parsUnexpectedEndOfFileTypeSignature : unit -> int * string + static member parsUnexpectedEndOfFileWhile : unit -> int * string + static member parsUnexpectedEndOfFileWith : unit -> int * string + static member parsUnexpectedIdentifier : a0:System.String -> int * string + static member parsUnexpectedInfixOperator : unit -> int * string + static member + parsUnexpectedIntegerLiteralForUnitOfMeasure : unit -> int * string + static member + parsUnexpectedOperatorForUnitOfMeasure : unit -> int * string + static member + parsUnexpectedQuotationOperatorInTypeAliasDidYouMeanVerbatimString : unit -> + int * + string + static member parsUnexpectedSemicolon : unit -> int * string + static member parsUnexpectedSymbolDot : unit -> int * string + static member parsUnexpectedSymbolEqualsInsteadOfIn : unit -> int * string + static member parsUnexpectedTypeParameter : unit -> int * string + static member + parsUnexpectedVisibilityDeclaration : a0:System.String -> int * string + static member parsUnfinishedExpression : a0:System.String -> int * string + static member + parsUnionCasesCannotHaveVisibilityDeclarations : unit -> int * string + static member parsUnmatched : a0:System.String -> int * string + static member parsUnmatchedBegin : unit -> int * string + static member parsUnmatchedBeginOrStruct : unit -> int * string + static member parsUnmatchedBrace : unit -> int * string + static member parsUnmatchedBraceBar : unit -> int * string + static member parsUnmatchedBracket : unit -> int * string + static member parsUnmatchedBracketBar : unit -> int * string + static member parsUnmatchedClassInterfaceOrStruct : unit -> int * string + static member parsUnmatchedLBrackLess : unit -> int * string + static member parsUnmatchedLet : unit -> int * string + static member parsUnmatchedLetBang : unit -> int * string + static member parsUnmatchedParen : unit -> int * string + static member parsUnmatchedUse : unit -> int * string + static member parsUnmatchedUseBang : unit -> int * string + static member parsUnmatchedWith : unit -> int * string + static member + parsUseBindingsIllegalInImplicitClassConstructors : unit -> int * string + static member parsUseBindingsIllegalInModules : unit -> int * string + static member + parsVisibilityDeclarationsShouldComePriorToIdentifier : unit -> + int * string + static member parsVisibilityIllegalOnInherit : unit -> int * string + static member parsWhileDoExpected : unit -> int * string + static member patcMissingVariable : a0:System.String -> int * string + static member + patcPartialActivePatternsGenerateOneResult : unit -> int * string + static member pathIsInvalid : a0:System.String -> int * string + static member patternMatchGuardIsNotBool : a0:System.String -> string + static member + pickleErrorReadingWritingMetadata : a0:System.String * a1:System.String -> + string + static member + pickleMissingDefinition : a0:System.Int32 * a1:System.String * + a2:System.String -> int * string + static member pickleUnexpectedNonZero : a0:System.String -> int * string + static member + poundiNotSupportedByRegisteredDependencyManagers : unit -> int * string + static member pplexExpectedSingleLineComment : unit -> int * string + static member pplexUnexpectedChar : a0:System.String -> int * string + static member ppparsIncompleteExpression : unit -> int * string + static member ppparsMissingToken : a0:System.String -> int * string + static member ppparsUnexpectedToken : a0:System.String -> int * string + static member + readOnlyAttributeOnStructWithMutableField : unit -> int * string + static member recursiveClassHierarchy : a0:System.String -> int * string + static member replaceWithSuggestion : a0:System.String -> string + static member returnUsedInsteadOfReturnBang : unit -> string + static member srcFileTooLarge : unit -> string + static member + structOrClassFieldIsNotAccessible : a0:System.String -> int * string + static member tastActivePatternsLimitedToSeven : unit -> int * string + static member tastCantTakeAddressOfExpression : unit -> int * string + static member + tastConflictingModuleAndTypeDefinitionInAssembly : a0:System.String * + a1:System.String -> + int * string + static member tastConstantExpressionOverflow : unit -> int * string + static member + tastDuplicateTypeDefinitionInAssembly : a0:System.String * + a1:System.String -> int * string + static member + tastInvalidAddressOfMutableAcrossAssemblyBoundary : unit -> int * string + static member tastInvalidFormForPropertyGetter : unit -> int * string + static member tastInvalidFormForPropertySetter : unit -> int * string + static member tastInvalidMemberSignature : unit -> int * string + static member tastInvalidMutationOfConstant : unit -> int * string + static member + tastNamespaceAndModuleWithSameNameInAssembly : a0:System.String -> + int * string + static member tastNotAConstantExpression : unit -> int * string + static member + tastRecursiveValuesMayNotAppearInConstructionOfType : a0:System.String -> + int * string + static member + tastRecursiveValuesMayNotBeAssignedToNonMutableField : a0:System.String * + a1:System.String -> + int * string + static member + tastRecursiveValuesMayNotBeInConstructionOfTuple : unit -> int * string + static member + tastTwoModulesWithSameNameInAssembly : a0:System.String -> int * string + static member + tastTypeHasAssemblyCodeRepresentation : a0:System.String -> string + static member + tastTypeOrModuleNotConcrete : a0:System.String -> int * string + static member + tastUndefinedItemRefModuleNamespace : a0:System.String * + a1:System.String * + a2:System.String -> int * string + static member + tastUndefinedItemRefModuleNamespaceType : a0:System.String * + a1:System.String * + a2:System.String -> + int * string + static member + tastUndefinedItemRefVal : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member tastUnexpectedByRef : unit -> int * string + static member tastUnexpectedDecodeOfAutoOpenAttribute : unit -> string + static member + tastUnexpectedDecodeOfInterfaceDataVersionAttribute : unit -> string + static member + tastUnexpectedDecodeOfInternalsVisibleToAttribute : unit -> string + static member tastValueDoesNotHaveSetterType : unit -> int * string + static member tastValueHasBeenCopied : unit -> string + static member tastValueMustBeLocal : unit -> int * string + static member tastValueMustBeMutable : unit -> int * string + static member tastopsMaxArrayThirtyTwo : a0:System.Int32 -> int * string + static member tcAbbreviatedTypesCannotBeSealed : unit -> int * string + static member + tcAbbreviationsFordotNetExceptionsCannotTakeArguments : unit -> + int * string + static member + tcAbbreviationsFordotNetExceptionsMustHaveMatchingObjectConstructor : unit -> + int * + string + static member + tcAbstractMembersIllegalInAugmentation : unit -> int * string + static member + tcAbstractPropertyMissingGetOrSet : a0:System.String -> int * string + static member tcAbstractTypeCannotBeInstantiated : unit -> int * string + static member tcActivePatternsDoNotHaveFields : unit -> int * string + static member + tcAllImplementedInterfacesShouldBeDeclared : unit -> int * string + static member + tcAllowNullTypesMayOnlyInheritFromAllowNullTypes : unit -> int * string + static member tcAndBangNotSupported : unit -> int * string + static member + tcAnonRecdCcuMismatch : a0:System.String * a1:System.String -> string + static member tcAnonRecdFieldNameDifferent : a0:System.String -> string + static member + tcAnonRecdFieldNameMismatch : a0:System.String * a1:System.String -> + string + static member tcAnonRecdFieldNameSubset : a0:System.String -> string + static member tcAnonRecdFieldNameSuperset : a0:System.String -> string + static member tcAnonRecdInvalid : unit -> string + static member tcAnonymousTypeInvalidInDeclaration : unit -> int * string + static member + tcAnonymousUnitsOfMeasureCannotBeNested : unit -> int * string + static member + tcArgumentArityMismatch : a0:System.String * a1:System.Int32 * + a2:System.Int32 * a3:System.String * + a4:System.String -> int * string + static member + tcArgumentArityMismatchOneOverload : a0:System.String * a1:System.Int32 * + a2:System.Int32 * a3:System.String * + a4:System.String -> int * string + static member tcAtLeastOneOverrideIsInvalid : unit -> int * string + static member tcAttribArgsDiffer : a0:System.String -> int * string + static member + tcAttributeAutoOpenWasIgnored : a0:System.String * a1:System.String -> + int * string + static member + tcAttributeExpressionsMustBeConstructorCalls : unit -> int * string + static member + tcAttributeIsNotValidForLanguageElement : unit -> int * string + static member + tcAttributeIsNotValidForLanguageElementUseDo : unit -> int * string + static member + tcAttributesAreNotPermittedOnLetBindings : unit -> int * string + static member tcAttributesInvalidInPatterns : unit -> int * string + static member + tcAttributesOfTypeSpecifyMultipleKindsForType : unit -> int * string + static member tcAugmentationsCannotHaveAttributes : unit -> int * string + static member + tcAutoPropertyRequiresImplicitConstructionSequence : unit -> + int * string + static member + tcBinaryOperatorRequiresBody : a0:System.String * a1:System.String -> + int * string + static member + tcBinaryOperatorRequiresVariable : a0:System.String * a1:System.String -> + int * string + static member tcBindMayNotBeUsedInQueries : unit -> int * string + static member tcBindingCannotBeUseAndRec : unit -> int * string + static member tcByRefLikeNotStruct : unit -> int * string + static member tcByrefReturnImplicitlyDereferenced : unit -> int * string + static member tcByrefsMayNotHaveTypeExtensions : unit -> int * string + static member tcCallerInfoNotOptional : a0:System.String -> int * string + static member + tcCallerInfoWrongType : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member + tcCannotCallAbstractBaseMember : a0:System.String -> int * string + static member + tcCannotCallExtensionMethodInrefToByref : a0:System.String -> + int * string + static member tcCannotCreateExtensionOfSealedType : unit -> int * string + static member tcCannotInheritFromErasedType : unit -> int * string + static member tcCannotInheritFromInterfaceType : unit -> int * string + static member tcCannotInheritFromSealedType : unit -> int * string + static member tcCannotInheritFromVariableType : unit -> int * string + static member + tcCannotOverrideSealedMethod : a0:System.String -> int * string + static member + tcCannotPartiallyApplyExtensionMethodForByref : a0:System.String -> + int * string + static member tcCompiledNameAttributeMisused : unit -> int * string + static member tcConcreteMembersIllegalInInterface : unit -> int * string + static member tcConditionalAttributeRequiresMembers : unit -> int * string + static member tcConditionalAttributeUsage : unit -> int * string + static member + tcConstrainedTypeVariableCannotBeGeneralized : unit -> int * string + static member + tcConstructIsAmbiguousInComputationExpression : unit -> int * string + static member + tcConstructIsAmbiguousInSequenceExpression : unit -> int * string + static member + tcConstructRequiresComputationExpression : unit -> int * string + static member + tcConstructRequiresComputationExpressions : unit -> int * string + static member + tcConstructRequiresListArrayOrSequence : unit -> int * string + static member + tcConstructRequiresSequenceOrComputations : unit -> int * string + static member tcConstructorCannotHaveTypeParameters : unit -> int * string + static member + tcConstructorDoesNotHaveFieldWithGivenName : a0:System.String -> + int * string + static member + tcConstructorForInterfacesDoNotTakeArguments : unit -> int * string + static member tcConstructorRequiresArguments : unit -> int * string + static member tcConstructorRequiresCall : a0:System.String -> int * string + static member + tcConstructorsCannotBeFirstClassValues : unit -> int * string + static member + tcConstructorsDisallowedInExceptionAugmentation : unit -> int * string + static member tcConstructorsIllegalForThisType : unit -> int * string + static member tcConstructorsIllegalInAugmentation : unit -> int * string + static member tcCopyAndUpdateNeedsRecordType : unit -> int * string + static member tcCouldNotFindIDisposable : unit -> string + static member tcCouldNotFindOffsetToStringData : unit -> int * string + static member tcCustomAttributeArgumentMismatch : unit -> int * string + static member tcCustomAttributeMustBeReferenceType : unit -> int * string + static member + tcCustomAttributeMustInvokeConstructor : unit -> int * string + static member + tcCustomOperationHasIncorrectArgCount : a0:System.String * + a1:System.Int32 * + a2:System.Int32 -> int * string + static member tcCustomOperationInvalid : a0:System.String -> int * string + static member + tcCustomOperationMayNotBeOverloaded : a0:System.String -> int * string + static member tcCustomOperationMayNotBeUsedHere : unit -> int * string + static member + tcCustomOperationMayNotBeUsedInConjunctionWithNonSimpleLetBindings : unit -> + int * + string + static member + tcCustomOperationNotUsedCorrectly : a0:System.String -> int * string + static member + tcCustomOperationNotUsedCorrectly2 : a0:System.String * a1:System.String -> + int * string + static member + tcDeclarationElementNotPermittedInAugmentation : unit -> int * string + static member + tcDeclaredTypeParametersForExtensionDoNotMatchOriginal : a0:System.String -> + int * string + static member tcDefaultAmbiguous : unit -> int * string + static member tcDefaultImplementationAlreadyExists : unit -> int * string + static member + tcDefaultImplementationForInterfaceHasAlreadyBeenAdded : unit -> + int * string + static member tcDefaultStructConstructorCall : unit -> int * string + static member tcDefaultValueAttributeRequiresVal : unit -> int * string + static member tcDelegateConstructorMustBePassed : unit -> int * string + static member tcDelegatesCannotBeCurried : unit -> int * string + static member tcDllImportNotAllowed : unit -> int * string + static member tcDllImportStubsCannotBeInlined : unit -> int * string + static member tcDoBangIllegalInSequenceExpression : unit -> int * string + static member + tcDoesNotAllowExplicitTypeArguments : a0:System.String -> int * string + static member tcDuplicateSpecOfInterface : unit -> int * string + static member tcEmptyCopyAndUpdateRecordInvalid : unit -> int * string + static member tcEmptyRecordInvalid : unit -> int * string + static member + tcEntryPointAttributeRequiresFunctionInModule : unit -> int * string + static member + tcEnumTypeCannotBeEnumerated : a0:System.String -> int * string + static member + tcEnumerationsCannotHaveInterfaceDeclaration : unit -> int * string + static member tcEnumerationsMayNotHaveMembers : unit -> int * string + static member tcEventIsNotStatic : a0:System.String -> int * string + static member tcEventIsStatic : a0:System.String -> int * string + static member + tcExceptionAbbreviationsMustReferToValidExceptions : unit -> + int * string + static member + tcExceptionAbbreviationsShouldNotHaveArgumentList : unit -> int * string + static member + tcExceptionConstructorDoesNotHaveFieldWithGivenName : a0:System.String * + a1:System.String -> + int * string + static member tcExpectModuleOrNamespaceParent : a0:System.String -> string + static member tcExpectedInterfaceType : unit -> int * string + static member tcExpectedTypeNotUnitOfMeasure : unit -> int * string + static member tcExpectedTypeParameter : unit -> int * string + static member + tcExpectedUnitOfMeasureMarkWithAttribute : unit -> int * string + static member tcExpectedUnitOfMeasureNotType : unit -> int * string + static member tcExplicitObjectConstructorSyntax : unit -> int * string + static member tcExplicitStaticInitializerSyntax : unit -> int * string + static member tcExplicitTypeParameterInvalid : unit -> int * string + static member + tcExplicitTypeSpecificationCannotBeUsedForExceptionConstructors : unit -> + int * + string + static member tcExprUndelayed : unit -> int * string + static member + tcExpressionCountMisMatch : a0:System.Int32 * a1:System.Int32 -> + int * string + static member + tcExpressionFormRequiresObjectConstructor : unit -> int * string + static member tcExpressionFormRequiresRecordTypes : unit -> int * string + static member tcExpressionRequiresSequence : unit -> int * string + static member tcExpressionWithIfRequiresParenthesis : unit -> string + static member tcExtraneousFieldsGivenValues : unit -> int * string + static member tcFSharpCoreRequiresExplicit : unit -> int * string + static member + tcFieldAppearsTwiceInRecord : a0:System.String -> int * string + static member tcFieldIsNotMutable : unit -> int * string + static member tcFieldIsNotStatic : a0:System.String -> int * string + static member tcFieldIsReadonly : unit -> int * string + static member + tcFieldNameConflictsWithGeneratedNameForAnonymousField : a0:System.String -> + int * string + static member + tcFieldNameIsUsedModeThanOnce : a0:System.String -> int * string + static member + tcFieldNotLiteralCannotBeUsedInPattern : unit -> int * string + static member + tcFieldRequiresAssignment : a0:System.String * a1:System.String -> + int * string + static member tcFieldRequiresName : unit -> int * string + static member tcFieldValIllegalHere : unit -> int * string + static member + tcFieldsDoNotDetermineUniqueRecordType : unit -> int * string + static member tcFixedNotAllowed : unit -> int * string + static member tcFormalArgumentIsNotOptional : unit -> int * string + static member + tcFunctionRequiresExplicitLambda : a0:System.Int32 -> int * string + static member + tcFunctionRequiresExplicitTypeArguments : a0:System.String -> + int * string + static member + tcGeneratedTypesShouldBeInternalOrPrivate : unit -> int * string + static member + tcGenericParameterHasBeenConstrained : a0:System.String -> int * string + static member tcGenericTypesCannotHaveStructLayout : unit -> int * string + static member tcGlobalsSystemTypeNotFound : a0:System.String -> string + static member tcIDisposableTypeShouldUseNew : unit -> int * string + static member tcIfThenElseMayNotBeUsedWithinQueries : unit -> int * string + static member tcIllegalAttributesForLiteral : unit -> int * string + static member tcIllegalByrefsInOpenTypeDeclaration : unit -> int * string + static member + tcIllegalFormForExplicitTypeDeclaration : unit -> int * string + static member tcIllegalPattern : unit -> int * string + static member + tcIllegalStructTypeForConstantExpression : unit -> int * string + static member tcIllegalSyntaxInTypeExpression : unit -> int * string + static member + tcImplementsGenericIComparableExplicitly : a0:System.String -> + int * string + static member + tcImplementsIComparableExplicitly : a0:System.String -> int * string + static member + tcImplementsIEquatableExplicitly : a0:System.String -> int * string + static member + tcImplementsIStructuralComparableExplicitly : a0:System.String -> + int * string + static member + tcImplementsIStructuralEquatableExplicitly : a0:System.String -> + int * string + static member tcImplicitMeasureFollowingSlash : unit -> int * string + static member + tcInferredGenericTypeGivesRiseToInconsistency : a0:System.String * + a1:System.String -> + int * string + static member tcInheritCannotBeUsedOnInterfaceType : unit -> int * string + static member + tcInheritConstructionCallNotPartOfImplicitSequence : unit -> + int * string + static member tcInheritDeclarationMissingArguments : unit -> int * string + static member tcInheritIllegalHere : unit -> int * string + static member tcInheritedTypeIsNotObjectModelType : unit -> int * string + static member tcInstanceMemberRequiresTarget : unit -> int * string + static member + tcInterfaceTypesAndDelegatesCannotContainFields : unit -> int * string + static member tcInterfaceTypesCannotBeSealed : unit -> int * string + static member + tcInterfacesShouldUseInheritNotInterface : unit -> int * string + static member tcInterpolationMixedWithPercent : unit -> int * string + static member tcIntoNeedsRestOfQuery : unit -> int * string + static member tcInvalidActivePatternName : unit -> int * string + static member + tcInvalidAlignmentInInterpolatedString : unit -> int * string + static member tcInvalidArgForParameterizedPattern : unit -> int * string + static member tcInvalidAssignment : unit -> int * string + static member tcInvalidConstantExpression : unit -> int * string + static member tcInvalidConstraint : unit -> int * string + static member tcInvalidConstraintTypeSealed : unit -> int * string + static member tcInvalidDeclaration : unit -> int * string + static member tcInvalidDelegateSpecification : unit -> int * string + static member tcInvalidEnumConstraint : unit -> int * string + static member tcInvalidEnumerationLiteral : unit -> int * string + static member tcInvalidIndexIntoActivePatternArray : unit -> int * string + static member + tcInvalidIndexOperatorDefinition : a0:System.String -> string + static member tcInvalidIndexerExpression : unit -> int * string + static member tcInvalidInlineSpecification : unit -> int * string + static member + tcInvalidMemberName : a0:System.String * a1:System.String -> string + static member tcInvalidMemberNameCtor : unit -> int * string + static member tcInvalidMemberNameFixedTypes : a0:System.String -> string + static member + tcInvalidMethodNameForEquality : a0:System.String * a1:System.String -> + string + static member + tcInvalidMethodNameForRelationalOperator : a0:System.String * + a1:System.String -> string + static member tcInvalidMixtureOfRecursiveForms : unit -> int * string + static member tcInvalidModuleName : unit -> int * string + static member tcInvalidNamespaceModuleTypeUnionName : unit -> int * string + static member tcInvalidNewConstraint : unit -> int * string + static member + tcInvalidNonPrimitiveLiteralInPatternMatch : unit -> int * string + static member tcInvalidObjectConstructionExpression : unit -> int * string + static member tcInvalidObjectExpressionSyntaxForm : unit -> int * string + static member + tcInvalidObjectSequenceOrRecordExpression : unit -> int * string + static member tcInvalidOperatorDefinition : a0:System.String -> string + static member + tcInvalidOperatorDefinitionEquality : a0:System.String -> string + static member + tcInvalidOperatorDefinitionRelational : a0:System.String -> string + static member + tcInvalidOptionalAssignmentToPropertyOrField : unit -> int * string + static member tcInvalidPattern : unit -> int * string + static member tcInvalidPropertyType : unit -> int * string + static member tcInvalidRecordConstruction : unit -> int * string + static member tcInvalidRelationInJoin : a0:System.String -> int * string + static member tcInvalidSequenceExpressionSyntaxForm : unit -> int * string + static member tcInvalidSignatureForSet : unit -> int * string + static member + tcInvalidTypeArgumentCount : a0:System.Int32 * a1:System.Int32 -> + int * string + static member tcInvalidTypeArgumentUsage : unit -> int * string + static member tcInvalidTypeExtension : unit -> int * string + static member tcInvalidTypeForLiteralEnumeration : unit -> int * string + static member tcInvalidTypeForUnitsOfMeasure : unit -> int * string + static member tcInvalidUnitsOfMeasurePrefix : unit -> int * string + static member tcInvalidUseBangBinding : unit -> int * string + static member tcInvalidUseBangBindingNoAndBangs : unit -> int * string + static member tcInvalidUseBinding : unit -> int * string + static member tcInvalidUseNullAsTrueValue : unit -> int * string + static member tcInvalidUseOfDelegate : unit -> int * string + static member tcInvalidUseOfInterfaceType : unit -> int * string + static member tcInvalidUseOfTypeName : unit -> int * string + static member tcIsReadOnlyNotStruct : unit -> int * string + static member + tcJoinMustUseSimplePattern : a0:System.String -> int * string + static member + tcKindOfTypeSpecifiedDoesNotMatchDefinition : unit -> int * string + static member + tcLessGenericBecauseOfAnnotation : a0:System.String * a1:System.String -> + int * string + static member + tcLetAndDoRequiresImplicitConstructionSequence : unit -> int * string + static member tcListLiteralMaxSize : unit -> int * string + static member + tcLiteralAttributeRequiresConstantValue : unit -> int * string + static member tcLiteralCannotBeInline : unit -> int * string + static member tcLiteralCannotBeMutable : unit -> int * string + static member tcLiteralCannotHaveGenericParameters : unit -> int * string + static member tcLiteralDoesNotTakeArguments : unit -> int * string + static member tcLiteralFieldAssignmentNoArg : unit -> int * string + static member + tcLiteralFieldAssignmentWithArg : a0:System.String -> int * string + static member tcLocalClassBindingsCannotBeInline : unit -> int * string + static member tcLookupMayNotBeUsedHere : unit -> int * string + static member tcMatchMayNotBeUsedWithQuery : unit -> int * string + static member + tcMeasureDeclarationsRequireStaticMembers : unit -> int * string + static member + tcMeasureDeclarationsRequireStaticMembersNotConstructors : unit -> + int * + string + static member + tcMeasureDefinitionsCannotHaveTypeParameters : unit -> int * string + static member + tcMemberAndLocalClassBindingHaveSameName : a0:System.String -> + int * string + static member + tcMemberFoundIsNotAbstractOrVirtual : a0:System.String * + a1:System.String -> int * string + static member tcMemberIsNotSufficientlyGeneric : unit -> int * string + static member tcMemberKindPropertyGetSetNotExpected : unit -> string + static member + tcMemberNotPermittedInInterfaceImplementation : unit -> int * string + static member tcMemberOperatorDefinitionInExtrinsic : unit -> int * string + static member tcMemberOverridesIllegalInInterface : unit -> int * string + static member + tcMemberUsedInInvalidWay : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member + tcMembersThatExtendInterfaceMustBePlacedInSeparateModule : unit -> + int * + string + static member tcMethodNotAccessible : a0:System.String -> int * string + static member tcMethodOverridesIllegalHere : unit -> int * string + static member tcMissingCustomOperation : a0:System.String -> int * string + static member tcModuleAbbrevFirstInMutRec : unit -> int * string + static member + tcModuleAbbreviationForNamespace : a0:System.String -> int * string + static member + tcModuleRequiresQualifiedAccess : a0:System.String -> int * string + static member tcMultipleVisibilityAttributes : unit -> int * string + static member tcMultipleVisibilityAttributesWithLet : unit -> int * string + static member tcMutableValuesCannotBeInline : unit -> int * string + static member + tcMutableValuesMayNotHaveGenericParameters : unit -> int * string + static member tcMutableValuesSyntax : unit -> int * string + static member tcNameArgumentsMustAppearLast : unit -> int * string + static member tcNameNotBoundInPattern : a0:System.String -> int * string + static member tcNamedActivePattern : a0:System.String -> int * string + static member + tcNamedArgumentDidNotMatch : a0:System.String -> int * string + static member + tcNamedArgumentsCannotBeUsedInMemberTraits : unit -> int * string + static member tcNamedTypeRequired : a0:System.String -> int * string + static member + tcNamespaceCannotContainExtensionMembers : unit -> int * string + static member tcNamespaceCannotContainValues : unit -> int * string + static member tcNewCannotBeUsedOnInterfaceType : unit -> int * string + static member + tcNewMemberHidesAbstractMember : a0:System.String -> int * string + static member + tcNewMemberHidesAbstractMemberWithSuffix : a0:System.String -> + int * string + static member tcNewMustBeUsedWithNamedType : unit -> int * string + static member tcNewRequiresObjectConstructor : unit -> int * string + static member + tcNoAbstractOrVirtualMemberFound : a0:System.String -> int * string + static member tcNoArgumentsForRecordValue : unit -> int * string + static member + tcNoComparisonNeeded1 : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member + tcNoComparisonNeeded2 : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member + tcNoEqualityNeeded1 : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member + tcNoEqualityNeeded2 : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member tcNoIntegerForLoopInQuery : unit -> int * string + static member + tcNoInterfaceImplementationForConstructionExpression : unit -> + int * string + static member tcNoMemberFoundForOverride : unit -> int * string + static member tcNoPropertyFoundForOverride : unit -> int * string + static member tcNoTryFinallyInQuery : unit -> int * string + static member tcNoWhileInQuery : unit -> int * string + static member tcNonLiteralCannotBeUsedInPattern : unit -> int * string + static member tcNonSimpleLetBindingInQuery : unit -> int * string + static member tcNonUniformMemberUse : a0:System.String -> int * string + static member + tcNonZeroConstantCannotHaveGenericUnit : unit -> int * string + static member tcNotAnException : unit -> int * string + static member + tcNotSufficientlyGenericBecauseOfScope : a0:System.String -> + int * string + static member tcNotValidEnumCaseName : unit -> int * string + static member + tcNumericLiteralRequiresModule : a0:System.String -> int * string + static member + tcObjectConstructionCanOnlyBeUsedInClassTypes : unit -> int * string + static member + tcObjectConstructionExpressionCanOnlyImplementConstructorsInObjectModelTypes : unit -> + int * + string + static member tcObjectConstructorRequiresArgument : unit -> int * string + static member + tcObjectConstructorsIllegalInInterface : unit -> int * string + static member + tcObjectConstructorsOnTypeParametersCannotTakeArguments : unit -> + int * string + static member tcObjectExpressionFormDeprecated : unit -> string + static member + tcObjectExpressionsCanOnlyOverrideAbstractOrVirtual : unit -> + int * string + static member + tcObjectOfIndeterminateTypeUsedRequireTypeConstraint : unit -> + int * string + static member + tcObjectsMustBeInitializedWithObjectExpression : unit -> int * string + static member tcOnlyClassesCanHaveAbstract : unit -> int * string + static member tcOnlyFunctionsCanBeInline : unit -> int * string + static member + tcOnlyRecordFieldsAndSimpleLetCanBeMutable : unit -> int * string + static member + tcOnlySimpleBindingsCanBeUsedInConstructionExpressions : unit -> + int * string + static member tcOnlySimplePatternsInLetRec : unit -> int * string + static member tcOnlyStructsCanHaveStructLayout : unit -> int * string + static member + tcOnlyTypesRepresentingUnitsOfMeasureCanHaveMeasure : unit -> + int * string + static member tcOpenFirstInMutRec : unit -> int * string + static member + tcOpenUsedWithPartiallyQualifiedPath : a0:System.String -> int * string + static member + tcOperatorDoesntAcceptInto : a0:System.String -> int * string + static member + tcOperatorIncorrectSyntax : a0:System.String * a1:System.String -> + int * string + static member + tcOperatorRequiresIn : a0:System.String * a1:System.String -> + int * string + static member + tcOptionalArgsMustComeAfterNonOptionalArgs : unit -> int * string + static member tcOptionalArgsOnlyOnMembers : unit -> int * string + static member + tcOptionalArgumentsCannotBeUsedInCustomAttribute : unit -> int * string + static member tcOverloadsCannotHaveCurriedArguments : unit -> int * string + static member tcOverrideArityMismatch : a0:System.String -> int * string + static member + tcOverridesCannotHaveVisibilityDeclarations : unit -> int * string + static member + tcOverridingMethodRequiresAllOrNoTypeParameters : unit -> int * string + static member tcParameterInferredByref : a0:System.String -> int * string + static member tcParameterRequiresName : unit -> int * string + static member + tcPredefinedTypeCannotBeUsedAsSuperType : unit -> int * string + static member tcPropertyCannotBeSet0 : unit -> int * string + static member tcPropertyCannotBeSet1 : a0:System.String -> int * string + static member tcPropertyIsNotReadable : a0:System.String -> int * string + static member tcPropertyIsNotStatic : a0:System.String -> int * string + static member tcPropertyIsStatic : a0:System.String -> int * string + static member tcPropertyOrFieldNotFoundInAttribute : unit -> int * string + static member + tcPropertyRequiresExplicitTypeParameters : unit -> int * string + static member tcRecImplied : unit -> int * string + static member tcRecordFieldInconsistentTypes : unit -> int * string + static member + tcRecordsUnionsAbbreviationsStructsMayNotHaveAllowNullLiteralAttribute : unit -> + int * + string + static member + tcRecursiveBindingsWithMembersMustBeDirectAugmentation : unit -> + int * string + static member + tcRepresentationOfTypeHiddenBySignature : unit -> int * string + static member tcRequireActivePatternWithOneResult : unit -> int * string + static member tcRequireBuilderMethod : a0:System.String -> int * string + static member + tcRequireMergeSourcesOrBindN : a0:System.String -> int * string + static member tcRequireVarConstRecogOrLiteral : unit -> int * string + static member tcReservedSyntaxForAugmentation : unit -> string + static member tcReturnMayNotBeUsedInQueries : unit -> int * string + static member tcReturnTypesForUnionMustBeSameAsType : unit -> int * string + static member tcReturnValuesCannotHaveNames : unit -> int * string + static member + tcRuntimeSuppliedMethodCannotBeUsedInUserCode : a0:System.String -> + int * string + static member tcSeqResultsUseYield : unit -> int * string + static member tcSimpleMethodNameRequired : unit -> int * string + static member + tcStaticFieldUsedWhenInstanceFieldExpected : unit -> int * string + static member tcStaticInitializerRequiresArgument : unit -> int * string + static member + tcStaticInitializersIllegalInInterface : unit -> int * string + static member + tcStaticLetBindingsRequireClassesWithImplicitConstructors : unit -> + int * + string + static member tcStaticMemberShouldNotHaveThis : unit -> int * string + static member + tcStaticOptimizationConditionalsOnlyForFSharpLibrary : unit -> + int * string + static member + tcStaticValFieldsMustBeMutableAndPrivate : unit -> int * string + static member + tcStructTypesCannotContainAbstractMembers : unit -> int * string + static member tcStructUnionMultiCaseDistinctFields : unit -> int * string + static member + tcStructsCanOnlyBindThisAtMemberDeclaration : unit -> int * string + static member + tcStructsCannotHaveConstructorWithNoArguments : unit -> int * string + static member + tcStructsInterfacesEnumsDelegatesMayNotInheritFromOtherTypes : unit -> + int * + string + static member tcStructsMayNotContainDoBindings : unit -> string + static member tcStructsMayNotContainLetBindings : unit -> int * string + static member + tcStructsMustDeclareTypesOfImplicitCtorArgsExplicitly : unit -> + int * string + static member + tcStructuralComparisonNotSatisfied1 : a0:System.String * + a1:System.String -> int * string + static member + tcStructuralComparisonNotSatisfied2 : a0:System.String * + a1:System.String -> int * string + static member + tcStructuralEqualityNotSatisfied1 : a0:System.String * a1:System.String -> + int * string + static member + tcStructuralEqualityNotSatisfied2 : a0:System.String * a1:System.String -> + int * string + static member + tcSyntaxCanOnlyBeUsedToCreateObjectTypes : a0:System.String -> + int * string + static member tcSyntaxErrorUnexpectedQMark : unit -> int * string + static member + tcSyntaxFormUsedOnlyWithRecordLabelsPropertiesAndFields : unit -> + int * string + static member tcTPFieldMustBeLiteral : unit -> int * string + static member + tcThisTypeMayNotHaveACLIMutableAttribute : unit -> int * string + static member tcThisValueMayNotBeInlined : unit -> int * string + static member + tcThreadStaticAndContextStaticMustBeStatic : unit -> int * string + static member tcTryIllegalInSequenceExpression : unit -> int * string + static member tcTryWithMayNotBeUsedInQueries : unit -> int * string + static member tcTupleMemberNotNormallyUsed : unit -> int * string + static member tcTupleStructMismatch : unit -> string + static member + tcTypeAbbreviationHasTypeParametersMissingOnType : unit -> string + static member + tcTypeAbbreviationsCannotHaveAugmentations : unit -> int * string + static member + tcTypeAbbreviationsCannotHaveInterfaceDeclaration : unit -> int * string + static member tcTypeAbbreviationsCheckedAtCompileTime : unit -> string + static member tcTypeAbbreviationsMayNotHaveMembers : unit -> int * string + static member tcTypeCannotBeEnumerated : a0:System.String -> int * string + static member + tcTypeCastErased : a0:System.String * a1:System.String -> int * string + static member tcTypeDefinitionIsCyclic : unit -> int * string + static member + tcTypeDefinitionIsCyclicThroughInheritance : unit -> int * string + static member + tcTypeDefinitionsWithImplicitConstructionMustHaveLocalBindingsBeforeMembers : unit -> + int * + string + static member + tcTypeDefinitionsWithImplicitConstructionMustHaveOneInherit : unit -> + int * + string + static member tcTypeDoesNotInheritAttribute : unit -> int * string + static member tcTypeExceptionOrModule : unit -> string + static member tcTypeHasNoAccessibleConstructor : unit -> int * string + static member tcTypeHasNoNestedTypes : unit -> int * string + static member tcTypeIsInaccessible : unit -> int * string + static member tcTypeIsNotARecordType : unit -> int * string + static member tcTypeIsNotARecordTypeNeedConstructor : unit -> int * string + static member tcTypeIsNotInterfaceType0 : unit -> int * string + static member tcTypeIsNotInterfaceType1 : a0:System.String -> int * string + static member tcTypeOrModule : unit -> string + static member + tcTypeParameterArityMismatch : a0:System.Int32 * a1:System.Int32 -> + int * string + static member + tcTypeParameterHasBeenConstrained : a0:System.String -> int * string + static member + tcTypeParameterInvalidAsTypeConstructor : unit -> int * string + static member tcTypeParametersInferredAreNotStable : unit -> int * string + static member tcTypeRequiresDefinition : unit -> int * string + static member + tcTypeTestErased : a0:System.String * a1:System.String -> int * string + static member tcTypeTestLosesMeasures : a0:System.String -> int * string + static member + tcTypeTestLossy : a0:System.String * a1:System.String -> int * string + static member + tcTypeUsedInInvalidWay : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member tcTypesAreAlwaysSealedAssemblyCode : unit -> int * string + static member tcTypesAreAlwaysSealedDU : unit -> int * string + static member tcTypesAreAlwaysSealedDelegate : unit -> int * string + static member tcTypesAreAlwaysSealedEnum : unit -> int * string + static member tcTypesAreAlwaysSealedRecord : unit -> int * string + static member tcTypesAreAlwaysSealedStruct : unit -> int * string + static member tcTypesCannotContainNestedTypes : unit -> int * string + static member + tcTypesCannotInheritFromMultipleConcreteTypes : unit -> int * string + static member + tcUnableToParseFormatString : a0:System.String -> int * string + static member + tcUnableToParseInterpolatedString : a0:System.String -> int * string + static member + tcUndefinedField : a0:System.String * a1:System.String -> int * string + static member tcUnexpectedBigRationalConstant : unit -> string + static member + tcUnexpectedConditionInImportedAssembly : unit -> int * string + static member tcUnexpectedConstByteArray : unit -> string + static member tcUnexpectedConstUint16Array : unit -> string + static member tcUnexpectedExprAtRecInfPoint : unit -> int * string + static member tcUnexpectedMeasureAnon : unit -> int * string + static member tcUnexpectedPropertyInSyntaxTree : unit -> int * string + static member tcUnexpectedPropertySpec : unit -> int * string + static member tcUnexpectedSlashInType : unit -> int * string + static member + tcUnexpectedSymbolInTypeExpression : a0:System.String -> int * string + static member tcUnexpectedTypeArguments : unit -> int * string + static member tcUninitializedValFieldsMustBeMutable : unit -> int * string + static member + tcUnionCaseConstructorDoesNotHaveFieldWithGivenName : a0:System.String * + a1:System.String -> + int * string + static member tcUnionCaseDoesNotTakeArguments : unit -> int * string + static member + tcUnionCaseExpectsTupledArguments : a0:System.Int32 -> int * string + static member + tcUnionCaseFieldCannotBeUsedMoreThanOnce : a0:System.String -> + int * string + static member + tcUnionCaseNameConflictsWithGeneratedType : a0:System.String * + a1:System.String -> + int * string + static member tcUnionCaseRequiresOneArgument : unit -> int * string + static member + tcUnitsOfMeasureInvalidInTypeConstructor : unit -> int * string + static member tcUnknownUnion : unit -> int * string + static member tcUnnamedArgumentsDoNotFormPrefix : unit -> string + static member tcUnrecognizedAttributeTarget : unit -> int * string + static member tcUnrecognizedQueryBinaryOperator : unit -> int * string + static member tcUnrecognizedQueryOperator : unit -> int * string + static member tcUnsupportedAttribute : unit -> int * string + static member tcUnsupportedMutRecDecl : unit -> int * string + static member tcUseForInSequenceExpression : unit -> int * string + static member tcUseMayNotBeUsedInQueries : unit -> int * string + static member tcUseWhenPatternGuard : unit -> string + static member tcUseYieldBangForMultipleResults : unit -> int * string + static member + tcValueInSignatureRequiresLiteralAttribute : unit -> int * string + static member tcVolatileFieldsMustBeMutable : unit -> int * string + static member tcVolatileOnlyOnClassLetBindings : unit -> int * string + static member + tlrLambdaLiftingOptimizationsNotApplied : unit -> int * string + static member tlrUnexpectedTExpr : unit -> int * string + static member + toolLocationHelperUnsupportedFrameworkVersion : a0:System.String -> + int * string + static member tupleRequiredInAbstractMethod : unit -> string + static member typeInfoActivePatternResult : unit -> string + static member typeInfoActiveRecognizer : unit -> string + static member typeInfoAnonRecdField : unit -> string + static member typeInfoArgument : unit -> string + static member typeInfoCallsWord : unit -> string + static member typeInfoCustomOperation : unit -> string + static member typeInfoEvent : unit -> string + static member typeInfoExtension : unit -> string + static member typeInfoField : unit -> string + static member typeInfoFromFirst : a0:System.String -> string + static member typeInfoFromNext : a0:System.String -> string + static member typeInfoFullName : unit -> string + static member typeInfoGeneratedProperty : unit -> string + static member typeInfoGeneratedType : unit -> string + static member typeInfoModule : unit -> string + static member typeInfoNamespace : unit -> string + static member typeInfoNamespaceOrModule : unit -> string + static member typeInfoOtherOverloads : a0:System.Int32 -> string + static member typeInfoPatternVariable : unit -> string + static member typeInfoProperty : unit -> string + static member typeInfoUnionCase : unit -> string + static member typeIsNotAccessible : a0:System.String -> int * string + static member + typrelCannotResolveAmbiguityInDelegate : unit -> int * string + static member typrelCannotResolveAmbiguityInEnum : unit -> int * string + static member typrelCannotResolveAmbiguityInPrintf : unit -> int * string + static member + typrelCannotResolveAmbiguityInUnmanaged : unit -> int * string + static member + typrelCannotResolveImplicitGenericInstantiation : a0:System.String * + a1:System.String -> + int * string + static member typrelDuplicateInterface : unit -> int * string + static member + typrelExplicitImplementationOfEquals : a0:System.String -> int * string + static member + typrelExplicitImplementationOfGetHashCode : a0:System.String -> + int * string + static member + typrelExplicitImplementationOfGetHashCodeOrEquals : a0:System.String -> + int * string + static member + typrelInterfaceMemberNoMostSpecificImplementation : a0:System.String -> + int * string + static member + typrelInterfaceWithConcreteAndVariable : a0:System.String * + a1:System.String * + a2:System.String * + a3:System.String -> + int * string + static member + typrelInterfaceWithConcreteAndVariableObjectExpression : a0:System.String * + a1:System.String * + a2:System.String -> + int * string + static member typrelInvalidValue : unit -> int * string + static member + typrelMemberCannotImplement : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member + typrelMemberDoesNotHaveCorrectKindsOfGenericParameters : a0:System.String * + a1:System.String -> + int * string + static member + typrelMemberDoesNotHaveCorrectNumberOfArguments : a0:System.String * + a1:System.String -> + int * string + static member + typrelMemberDoesNotHaveCorrectNumberOfTypeParameters : a0:System.String * + a1:System.String -> + int * string + static member + typrelMemberHasMultiplePossibleDispatchSlots : a0:System.String * + a1:System.String -> + int * string + static member typrelMethodIsOverconstrained : unit -> int * string + static member typrelMethodIsSealed : a0:System.String -> int * string + static member + typrelModuleNamespaceAttributesDifferInSigAndImpl : unit -> int * string + static member typrelMoreThenOneOverride : a0:System.String -> int * string + static member + typrelNamedArgumentHasBeenAssignedMoreThenOnce : a0:System.String -> + int * string + static member + typrelNeedExplicitImplementation : a0:System.String -> int * string + static member + typrelNoImplementationGiven : a0:System.String -> int * string + static member + typrelNoImplementationGivenSeveral : a0:System.String -> int * string + static member + typrelNoImplementationGivenSeveralTruncated : a0:System.String -> + int * string + static member + typrelNoImplementationGivenSeveralTruncatedWithSuggestion : a0:System.String -> + int * + string + static member + typrelNoImplementationGivenSeveralWithSuggestion : a0:System.String -> + int * string + static member + typrelNoImplementationGivenWithSuggestion : a0:System.String -> + int * string + static member + typrelOverloadNotFound : a0:System.String * a1:System.String -> + int * string + static member + typrelOverrideImplementsMoreThenOneSlot : a0:System.String * + a1:System.String * + a2:System.String -> + int * string + static member + typrelOverrideWasAmbiguous : a0:System.String -> int * string + static member + typrelSigImplNotCompatibleCompileTimeRequirementsDiffer : unit -> + int * string + static member + typrelSigImplNotCompatibleConstraintsDiffer : a0:System.String * + a1:System.String -> + int * string + static member + typrelSigImplNotCompatibleConstraintsDifferRemove : a0:System.String * + a1:System.String -> + int * string + static member + typrelSigImplNotCompatibleParamCountsDiffer : unit -> int * string + static member + typrelTypeImplementsIComparableDefaultObjectEqualsProvided : a0:System.String -> + int * + string + static member + typrelTypeImplementsIComparableShouldOverrideObjectEquals : a0:System.String -> + int * + string + static member + undefinedNameConstructorModuleOrNamespace : a0:System.String -> string + static member + undefinedNameFieldConstructorOrMember : a0:System.String -> string + static member + undefinedNameFieldConstructorOrMemberWhenTypeIsKnown : a0:System.String * + a1:System.String -> + string + static member undefinedNameNamespace : a0:System.String -> string + static member undefinedNameNamespaceOrModule : a0:System.String -> string + static member + undefinedNamePatternDiscriminator : a0:System.String -> string + static member undefinedNameRecordLabel : a0:System.String -> string + static member + undefinedNameRecordLabelOrNamespace : a0:System.String -> string + static member undefinedNameSuggestionsIntro : unit -> string + static member undefinedNameType : a0:System.String -> string + static member + undefinedNameTypeIn : a0:System.String * a1:System.String -> string + static member undefinedNameTypeParameter : a0:System.String -> string + static member + undefinedNameValueConstructorNamespaceOrType : a0:System.String -> + string + static member + undefinedNameValueNamespaceTypeOrModule : a0:System.String -> string + static member undefinedNameValueOfConstructor : a0:System.String -> string + static member unionCaseIsNotAccessible : a0:System.String -> int * string + static member + unionCasesAreNotAccessible : a0:System.String -> int * string + static member useSdkRefs : unit -> string + static member valueIsNotAccessible : a0:System.String -> int * string + static member writeToReadOnlyByref : unit -> int * string + static member xmlDocBadlyFormed : a0:System.String -> int * string + static member xmlDocDuplicateParameter : a0:System.String -> int * string + static member + xmlDocInvalidParameterName : a0:System.String -> int * string + static member xmlDocMissingCrossReference : unit -> int * string + static member xmlDocMissingParameter : a0:System.String -> int * string + static member xmlDocMissingParameterName : unit -> int * string + static member + xmlDocUnresolvedCrossReference : a0:System.String -> int * string + static member yieldUsedInsteadOfYieldBang : unit -> string + static member SwallowResourceText : bool + end + +namespace DependencyManager + type internal SR = + class + private new : unit -> SR + static member RunStartupValidation : unit -> unit + static member + couldNotLoadDependencyManagerExtension : a0:System.String * + a1:System.String -> + int * string + static member packageManagerError : a0:System.String -> int * string + static member + packageManagerUnknown : a0:System.String * a1:System.String * + a2:System.String -> int * string + static member SwallowResourceText : bool + end + +namespace FSIstrings + type internal SR = + class + private new : unit -> SR + static member RunStartupValidation : unit -> unit + static member fsiAbortingMainThread : unit -> string + static member fsiAdvanced : unit -> string + static member fsiBanner3 : unit -> string + static member fsiBindingSessionTo : a0:System.String -> string + static member fsiCodeGeneration : unit -> string + static member fsiConsoleProblem : unit -> string + static member fsiCouldNotInstallCtrlCHandler : a0:System.String -> string + static member fsiDidAHashI : a0:System.String -> string + static member fsiDidAHashr : a0:System.String -> string + static member fsiDidAHashrWithLockWarning : a0:System.String -> string + static member fsiDidAHashrWithStaleWarning : a0:System.String -> string + static member fsiDirectoryDoesNotExist : a0:System.String -> int * string + static member fsiEmitDebugInfoInQuotations : unit -> string + static member fsiErrorsAndWarnings : unit -> string + static member + fsiExceptionDuringPrettyPrinting : a0:System.String -> string + static member + fsiExceptionRaisedStartingServer : a0:System.String -> string + static member fsiExec : unit -> string + static member fsiExit : unit -> string + static member fsiFailedToResolveAssembly : a0:System.String -> string + static member fsiGui : unit -> string + static member fsiHelp : unit -> string + static member fsiInputFiles : unit -> string + static member fsiInterrupt : unit -> string + static member fsiIntroPackageSourceUriInfo : unit -> string + static member fsiIntroTextHashIInfo : unit -> string + static member fsiIntroTextHashhelpInfo : unit -> string + static member fsiIntroTextHashloadInfo : unit -> string + static member fsiIntroTextHashquitInfo : unit -> string + static member fsiIntroTextHashrInfo : unit -> string + static member fsiIntroTextHashtimeInfo : unit -> string + static member fsiIntroTextHeader1directives : unit -> string + static member fsiIntroTextHeader2commandLine : unit -> string + static member fsiIntroTextHeader3 : a0:System.String -> string + static member fsiInvalidAssembly : a0:System.String -> int * string + static member fsiLanguage : unit -> string + static member fsiLineTooLong : unit -> string + static member fsiLoad : unit -> string + static member fsiLoadingFilesPrefixText : unit -> string + static member fsiMiscellaneous : unit -> string + static member fsiOperationCouldNotBeCompleted : unit -> string + static member fsiOperationFailed : unit -> string + static member fsiProductName : a0:System.String -> string + static member fsiProductNameCommunity : a0:System.String -> string + static member fsiQuiet : unit -> string + static member fsiReadline : unit -> string + static member fsiRemaining : unit -> string + static member + fsiTimeInfoGCGenerationLabelSomeShorthandForTheWordGeneration : unit -> + string + static member + fsiTimeInfoMainString : a0:System.String * a1:System.String * + a2:System.String -> string + static member fsiTurnedTimingOff : unit -> string + static member fsiTurnedTimingOn : unit -> string + static member fsiUnexpectedThreadAbortException : unit -> string + static member fsiUsage : a0:System.String -> string + static member fsiUse : unit -> string + static member shadowCopyReferences : unit -> string + static member stoppedDueToError : unit -> string + static member SwallowResourceText : bool + end + +namespace UtilsStrings + type internal SR = + class + private new : unit -> SR + static member RunStartupValidation : unit -> unit + static member buildProductName : a0:System.String -> string + static member + fSharpBannerVersion : a0:System.String * a1:System.String -> string + static member SwallowResourceText : bool + end + +namespace FSharp + module internal BuildProperties = begin + val fsProductVersion : string + val fsLanguageVersion : string + end + + + + + + + +namespace Internal.Utilities.StructuredFormat + [] + type LayoutTag = + | ActivePatternCase + | ActivePatternResult + | Alias + | Class + | Union + | UnionCase + | Delegate + | Enum + | Event + | Field + | Interface + | Keyword + | LineBreak + | Local + | Record + | RecordField + | Method + | Member + | ModuleBinding + | Function + | Module + | Namespace + | NumericLiteral + | Operator + | Parameter + | Property + | Space + | StringLiteral + | Struct + | TypeParameter + | Text + | Punctuation + | UnknownType + | UnknownEntity + type TaggedText = + interface + abstract member Tag : LayoutTag + abstract member Text : string + end + type TaggedTextWriter = + interface + abstract member Write : t:TaggedText -> unit + abstract member WriteLine : unit -> unit + end + [] + type Joint = + | Unbreakable + | Breakable of indentation: int + | Broken of indentation: int + [] + type Layout = + | ObjLeaf of juxtLeft: bool * object: obj * juxtRight: bool + | Leaf of juxtLeft: bool * text: TaggedText * justRight: bool + | Node of leftLayout: Layout * rightLayout: Layout * joint: Joint + | Attr of text: string * attributes: (string * string) list * layout: Layout + with + static member JuxtapositionMiddle : left:Layout * right:Layout -> bool + member JuxtapositionLeft : bool + member JuxtapositionRight : bool + end + [] + type IEnvironment = + interface + abstract member GetLayout : obj -> Layout + abstract member MaxColumns : int + abstract member MaxRows : int + end + module TaggedTextOps = begin + val mkTag : LayoutTag -> string -> TaggedText + val length : tt:TaggedText -> int + val toText : tt:TaggedText -> string + val tagAlias : string -> TaggedText + val keywordFunctions : Set + val tagClass : string -> TaggedText + val tagUnionCase : string -> TaggedText + val tagDelegate : string -> TaggedText + val tagEnum : string -> TaggedText + val tagEvent : string -> TaggedText + val tagField : string -> TaggedText + val tagInterface : string -> TaggedText + val tagKeyword : string -> TaggedText + val tagLineBreak : string -> TaggedText + val tagLocal : string -> TaggedText + val tagRecord : string -> TaggedText + val tagRecordField : string -> TaggedText + val tagMethod : string -> TaggedText + val tagModule : string -> TaggedText + val tagModuleBinding : string -> TaggedText + val tagFunction : string -> TaggedText + val tagNamespace : string -> TaggedText + val tagNumericLiteral : string -> TaggedText + val tagOperator : string -> TaggedText + val tagParameter : string -> TaggedText + val tagProperty : string -> TaggedText + val tagSpace : string -> TaggedText + val tagStringLiteral : string -> TaggedText + val tagStruct : string -> TaggedText + val tagTypeParameter : string -> TaggedText + val tagText : string -> TaggedText + val tagPunctuation : string -> TaggedText + module Literals = begin + val lineBreak : TaggedText + val space : TaggedText + val comma : TaggedText + val semicolon : TaggedText + val leftParen : TaggedText + val rightParen : TaggedText + val leftBracket : TaggedText + val rightBracket : TaggedText + val leftBrace : TaggedText + val rightBrace : TaggedText + val leftBraceBar : TaggedText + val rightBraceBar : TaggedText + val equals : TaggedText + val arrow : TaggedText + val questionMark : TaggedText + end + end + module LayoutOps = begin + val mkNode : l:Layout -> r:Layout -> joint:Joint -> Layout + val objL : value:obj -> Layout + val sLeaf : l:bool * t:TaggedText * r:bool -> Layout + val wordL : text:TaggedText -> Layout + val sepL : text:TaggedText -> Layout + val rightL : text:TaggedText -> Layout + val leftL : text:TaggedText -> Layout + val emptyL : Layout + val isEmptyL : layout:Layout -> bool + val aboveL : layout1:Layout -> layout2:Layout -> Layout + val tagAttrL : + text:string -> maps:(string * string) list -> layout:Layout -> Layout + val apply2 : + f:(Layout -> Layout -> Layout) -> l:Layout -> r:Layout -> Layout + val ( ^^ ) : layout1:Layout -> layout2:Layout -> Layout + val ( ++ ) : layout1:Layout -> layout2:Layout -> Layout + val ( -- ) : layout1:Layout -> layout2:Layout -> Layout + val ( --- ) : layout1:Layout -> layout2:Layout -> Layout + val ( @@ ) : layout1:Layout -> layout2:Layout -> Layout + val ( @@- ) : layout1:Layout -> layout2:Layout -> Layout + val ( @@-- ) : layout1:Layout -> layout2:Layout -> Layout + val tagListL : tagger:(Layout -> Layout) -> els:Layout list -> Layout + val commaListL : layouts:Layout list -> Layout + val semiListL : layouts:Layout list -> Layout + val spaceListL : layouts:Layout list -> Layout + val sepListL : layout1:Layout -> layouts:Layout list -> Layout + val bracketL : layout:Layout -> Layout + val tupleL : layouts:Layout list -> Layout + val aboveListL : layouts:Layout list -> Layout + val optionL : selector:('T -> Layout) -> value:'T option -> Layout + val listL : selector:('T -> Layout) -> value:'T list -> Layout + val squareBracketL : layout:Layout -> Layout + val braceL : layout:Layout -> Layout + val boundedUnfoldL : + itemL:('a -> Layout) -> + project:('z -> ('a * 'z) option) -> + stopShort:('z -> bool) -> z:'z -> maxLength:int -> Layout list + val unfoldL : + selector:('T -> Layout) -> + folder:('State -> ('T * 'State) option) -> + state:'State -> count:int -> Layout list + end + [] + type FormatOptions = + { FloatingPointFormat: string + AttributeProcessor: string -> (string * string) list -> bool -> unit + PrintIntercepts: (IEnvironment -> obj -> Layout option) list + StringLimit: int + FormatProvider: System.IFormatProvider + BindingFlags: System.Reflection.BindingFlags + PrintWidth: int + PrintDepth: int + PrintLength: int + PrintSize: int + ShowProperties: bool + ShowIEnumerable: bool } + with + static member Default : FormatOptions + end + module ReflectUtils = begin + [] + type TypeInfo = + | TupleType of System.Type list + | FunctionType of System.Type * System.Type + | RecordType of (string * System.Type) list + | SumType of (string * (string * System.Type) list) list + | UnitType + | ObjectType of System.Type + val isNamedType : ty:System.Type -> bool + val equivHeadTypes : ty1:System.Type -> ty2:System.Type -> bool + val option : System.Type + val func : System.Type + val isOptionTy : ty:System.Type -> bool + val isUnitType : ty:System.Type -> bool + val isListType : ty:System.Type -> bool + [] + type TupleType = + | Value + | Reference + [] + type ValueInfo = + | TupleValue of TupleType * (obj * System.Type) [] + | FunctionClosureValue of System.Type + | RecordValue of (string * obj * System.Type) [] + | UnionCaseValue of string * (string * (obj * System.Type)) [] + | ExceptionValue of System.Type * (string * (obj * System.Type)) [] + | NullValue + | UnitValue + | ObjectValue of obj + module Value = begin + val GetValueInfoOfObject : + bindingFlags:System.Reflection.BindingFlags -> obj:obj -> ValueInfo + val GetValueInfo : + bindingFlags:System.Reflection.BindingFlags -> + x:'a * ty:System.Type -> ValueInfo + end + end + module Display = begin + val string_of_int : i:int -> string + val typeUsesSystemObjectToString : ty:System.Type -> bool + val catchExn : f:(unit -> 'a) -> Choice<'a,exn> + [] + type Breaks = + | Breaks of nextFreeSlot: int * nextOuterBreak: int * savingsStack: int [] + val chunkN : int + val breaks0 : unit -> Breaks + val pushBreak : saving:int -> Breaks -> Breaks + val popBreak : Breaks -> Breaks * bool + val forceBreak : Breaks -> (Breaks * int) option + val squashToAux : + maxWidth:int * leafFormatter:(obj -> TaggedText) -> + layout:Layout -> Layout + val combine : strs:string list -> string + val showL : + opts:FormatOptions -> + leafFormatter:(obj -> string) -> layout:Layout -> string + val outL : + outAttribute:(string -> (string * string) list -> bool -> 'a) -> + leafFormatter:(obj -> #TaggedText) -> + chan:TaggedTextWriter -> layout:Layout -> unit + val unpackCons : recd:('a * 'b) [] -> 'b * 'b + val getListValueInfo : + bindingFlags:System.Reflection.BindingFlags -> + x:obj * ty:System.Type -> + ((obj * System.Type) * (obj * System.Type)) option + val structL : Layout + val nullL : Layout + val unitL : Layout + val makeRecordL : nameXs:(#TaggedText * Layout) list -> Layout + val makePropertiesL : nameXs:(#TaggedText * Layout option) list -> Layout + val makeListL : itemLs:Layout list -> Layout + val makeArrayL : xs:Layout list -> Layout + val makeArray2L : xs:Layout list -> Layout + val getProperty : ty:System.Type -> obj:obj -> name:string -> obj + val getField : obj:'a -> fieldInfo:System.Reflection.FieldInfo -> obj + val formatChar : isChar:bool -> c:char -> string + val formatString : s:string -> string + val formatStringInWidth : width:int -> str:string -> string + type Precedence = + | BracketIfTupleOrNotAtomic = 2 + | BracketIfTuple = 3 + | NeverBracket = 4 + [] + type ShowMode = + | ShowAll + | ShowTopLevelBinding + val isSetOrMapType : ty:System.Type -> bool + type ObjectGraphFormatter = + class + new : opts:FormatOptions * bindingFlags:System.Reflection.BindingFlags -> + ObjectGraphFormatter + member Format : showMode:ShowMode * x:'a * xty:System.Type -> Layout + end + val leafFormatter : opts:FormatOptions -> obj:obj -> TaggedText + val any_to_layout : + options:FormatOptions -> value:'T * typValue:System.Type -> Layout + val squashTo : width:int -> layout:Layout -> Layout + val squash_layout : options:FormatOptions -> layout:Layout -> Layout + val asTaggedTextWriter : writer:System.IO.TextWriter -> TaggedTextWriter + val output_layout_tagged : + options:FormatOptions -> writer:TaggedTextWriter -> layout:Layout -> unit + val output_layout : + options:FormatOptions -> + writer:System.IO.TextWriter -> layout:Layout -> unit + val layout_to_string : options:FormatOptions -> layout:Layout -> string + val output_any_ex : + opts:FormatOptions -> oc:System.IO.TextWriter -> 'a * System.Type -> unit + val output_any : writer:System.IO.TextWriter -> 'a * System.Type -> unit + val layout_as_string : + options:FormatOptions -> value:'T * typValue:System.Type -> string + val any_to_string : 'a * System.Type -> string + val fsi_any_to_layout : + options:FormatOptions -> value:'T * typValue:System.Type -> Layout + end + +namespace FSharp.Compiler + module internal SR = begin + val private resources : Lazy + val GetString : string -> string + end + module internal DiagnosticMessage = begin + val mkFunctionValue : tys:System.Type [] -> impl:(obj -> obj) -> obj + val funTyC : System.Type + val mkFunTy : a:System.Type -> b:System.Type -> System.Type + val isNamedType : ty:System.Type -> bool + val isFunctionType : ty1:System.Type -> bool + val destFunTy : ty:System.Type -> System.Type * System.Type [] + val buildFunctionForOneArgPat : + ty:System.Type -> impl:(System.Type -> obj -> obj) -> obj + val capture1 : + fmt:string -> + i:int -> + args:obj list -> + ty:System.Type -> go:(obj list -> System.Type -> int -> obj) -> obj + val postProcessString : s:string -> string + val createMessageString : + messageString:string -> fmt:Printf.StringFormat<'T> -> 'T + type ResourceString<'T> = + class + new : string * Printf.StringFormat<'T> -> ResourceString<'T> + member Format : 'T + end + val DeclareResourceString : + string * Printf.StringFormat<'T> -> ResourceString<'T> + end + +namespace FSharp.Compiler + type LogCompilerFunctionId = + | Service_ParseAndCheckFileInProject = 1 + | Service_CheckOneFile = 2 + | Service_IncrementalBuildersCache_BuildingNewCache = 3 + | Service_IncrementalBuildersCache_GettingCache = 4 + | CompileOps_TypeCheckOneInputAndFinishEventually = 5 + | IncrementalBuild_CreateItemKeyStoreAndSemanticClassification = 6 + | IncrementalBuild_TypeCheck = 7 + [] + type FSharpCompilerEventSource = + class + inherit System.Diagnostics.Tracing.EventSource + new : unit -> FSharpCompilerEventSource + [] + member + BlockMessageStart : message:string * functionId:LogCompilerFunctionId -> + unit + [] + member + BlockMessageStop : message:string * functionId:LogCompilerFunctionId -> + unit + [] + member BlockStart : functionId:LogCompilerFunctionId -> unit + [] + member BlockStop : functionId:LogCompilerFunctionId -> unit + [] + member Log : functionId:LogCompilerFunctionId -> unit + [] + member + LogMessage : message:string * functionId:LogCompilerFunctionId -> unit + static member Instance : FSharpCompilerEventSource + end + module Logger = begin + val Log : LogCompilerFunctionId -> unit + val LogMessage : message:string -> LogCompilerFunctionId -> unit + val LogBlockStart : LogCompilerFunctionId -> unit + val LogBlockStop : LogCompilerFunctionId -> unit + val LogBlockMessageStart : message:string -> LogCompilerFunctionId -> unit + val LogBlockMessageStop : message:string -> LogCompilerFunctionId -> unit + val LogBlock : LogCompilerFunctionId -> System.IDisposable + val LogBlockMessage : + message:string -> LogCompilerFunctionId -> System.IDisposable + end + +namespace FSharp.Compiler + module internal Features = begin + [] + type LanguageFeature = + | SingleUnderscorePattern + | WildCardInForLoop + | RelaxWhitespace + | NameOf + | ImplicitYield + | OpenTypeDeclaration + | DotlessFloat32Literal + | PackageManagement + | FromEndSlicing + | FixedIndexSlice3d4d + | AndBang + | NullableOptionalInterop + | DefaultInterfaceMemberConsumption + | WitnessPassing + | InterfacesWithMultipleGenericInstantiation + | StringInterpolation + | OverloadsForCustomOperations + | ExpandedMeasurables + type LanguageVersion = + class + new : string -> LanguageVersion + member ContainsVersion : string -> bool + member GetFeatureString : feature:LanguageFeature -> string + member GetFeatureVersionString : feature:LanguageFeature -> string + member SupportsFeature : LanguageFeature -> bool + member IsPreviewEnabled : bool + member SpecifiedVersion : decimal + member SpecifiedVersionString : string + member ValidOptions : string [] + member ValidVersions : string [] + end + end + +namespace FSharp.Compiler.Text + type ISourceText = + interface + abstract member ContentEquals : sourceText:ISourceText -> bool + abstract member + CopyTo : sourceIndex:int * destination:char [] * destinationIndex:int * + count:int -> unit + abstract member GetLastCharacterPosition : unit -> int * int + abstract member GetLineCount : unit -> int + abstract member GetLineString : lineIndex:int -> string + abstract member GetSubTextString : start:int * length:int -> string + abstract member SubTextEquals : target:string * startIndex:int -> bool + abstract member Item : int -> char with get + abstract member Length : int + end + [] + type StringText = + class + interface ISourceText + new : str:string -> StringText + override Equals : obj:obj -> bool + override GetHashCode : unit -> int + override ToString : unit -> string + member String : string + end + module SourceText = begin + val ofString : string -> ISourceText + end +namespace Internal.Utilities.Text.Lexing + [] + type internal Position = + struct + new : fileIndex:int * line:int * originalLine:int * + startOfLineAbsoluteOffset:int * absoluteOffset:int -> Position + val FileIndex: int + val Line: int + val OriginalLine: int + val AbsoluteOffset: int + val StartOfLineAbsoluteOffset: int + static member FirstLine : fileIdx:int -> Position + member ApplyLineDirective : fileIdx:int * line:int -> Position + member EndOfToken : n:int -> Position + member ShiftColumnBy : by:int -> Position + member Column : int + member ColumnMinusOne : Position + member NextLine : Position + static member Empty : Position + end + type internal LexBufferFiller<'Char> = LexBuffer<'Char> -> unit + [] + and internal LexBuffer<'Char> = + class + new : filler:LexBufferFiller<'Char> * + supportsFeature:(FSharp.Compiler.Features.LanguageFeature -> bool) -> + LexBuffer<'Char> + static member + FromArray : supportsFeature:(FSharp.Compiler.Features.LanguageFeature -> + bool) * s:'Char [] -> LexBuffer<'Char> + static member + FromArrayNoCopy : supportsFeature:(FSharp.Compiler.Features.LanguageFeature -> + bool) * buffer:'Char [] -> + LexBuffer<'Char> + static member + FromChars : (FSharp.Compiler.Features.LanguageFeature -> bool) * char [] -> + LexBuffer + static member + FromFunction : (FSharp.Compiler.Features.LanguageFeature -> bool) * + ('Char [] * int * int -> int) -> LexBuffer<'Char> + static member + FromSourceText : (FSharp.Compiler.Features.LanguageFeature -> bool) * + FSharp.Compiler.Text.ISourceText -> LexBuffer + static member LexemeString : LexBuffer -> System.String + member DiscardInput : unit -> unit + member EndOfScan : unit -> int + member EnsureBufferSize : n:int -> unit + member LexemeChar : int -> 'Char + member LexemeContains : 'Char -> bool + member RefillBuffer : unit -> unit + member SupportsFeature : FSharp.Compiler.Features.LanguageFeature -> bool + member Buffer : 'Char [] + member BufferAcceptAction : int + member + BufferLocalStore : System.Collections.Generic.IDictionary + member BufferMaxScanLength : int + member BufferScanLength : int + member BufferScanPos : int + member BufferScanStart : int + member EndPos : Position + member IsPastEndOfStream : bool + member LexemeLength : int + member LexemeView : System.ReadOnlySpan<'Char> + member StartPos : Position + end + module GenericImplFragments = begin + val startInterpret : lexBuffer:LexBuffer -> unit + val afterRefill : + trans:uint16 [] [] * sentinel:int * lexBuffer:LexBuffer * + scanUntilSentinel:(LexBuffer -> int -> 'a) * endOfScan:(unit -> 'a) * + state:int * eofPos:int -> 'a + val onAccept : lexBuffer:LexBuffer * a:int -> unit + end + [] + type internal UnicodeTables = + class + new : trans:uint16 [] array * accept:uint16 [] -> UnicodeTables + static member Create : uint16 [] array * uint16 [] -> UnicodeTables + member Interpret : initialState:int * LexBuffer -> int + end + +namespace Internal.Utilities.Text.Parsing + exception RecoverableParseError + exception Accept of obj + [] + type internal IParseState = + class + new : ruleStartPoss:Lexing.Position [] * ruleEndPoss:Lexing.Position [] * + lhsPos:Lexing.Position [] * ruleValues:obj [] * + lexbuf:Lexing.LexBuffer -> IParseState + member GetInput : index:int -> obj + member InputEndPosition : index:int -> Lexing.Position + member InputRange : index:int -> Lexing.Position * Lexing.Position + member InputStartPosition : index:int -> Lexing.Position + member RaiseError : unit -> 'b + member LexBuffer : Lexing.LexBuffer + member ResultEndPosition : Lexing.Position + member ResultRange : Lexing.Position * Lexing.Position + member ResultStartPosition : Lexing.Position + end + [] + type internal ParseErrorContext<'tok> = + class + new : stateStack:int list * parseState:IParseState * reduceTokens:int list * + currentToken:'tok option * reducibleProductions:int list list * + shiftableTokens:int list * message:string -> ParseErrorContext<'tok> + member CurrentToken : 'tok option + member Message : string + member ParseState : IParseState + member ReduceTokens : int list + member ReducibleProductions : int list list + member ShiftTokens : int list + member StateStack : int list + end + type internal Tables<'tok> = + { reductions: (IParseState -> obj) [] + endOfInputTag: int + tagOfToken: 'tok -> int + dataOfToken: 'tok -> obj + actionTableElements: uint16 [] + actionTableRowOffsets: uint16 [] + reductionSymbolCounts: uint16 [] + immediateActions: uint16 [] + gotos: uint16 [] + sparseGotoTableRowOffsets: uint16 [] + stateToProdIdxsTableElements: uint16 [] + stateToProdIdxsTableRowOffsets: uint16 [] + productionToNonTerminalTable: uint16 [] + parseError: ParseErrorContext<'tok> -> unit + numTerminals: int + tagOfErrorTerminal: int } + with + member + Interpret : lexer:(Lexing.LexBuffer -> 'tok) * + lexbuf:Lexing.LexBuffer * initialState:int -> obj + end + type Stack<'a> = + class + new : n:int -> Stack<'a> + member Ensure : newSize:int -> unit + member Peep : unit -> 'a + member Pop : unit -> unit + member PrintStack : unit -> unit + member Push : x:'a -> unit + member Top : n:int -> 'a list + member Count : int + member IsEmpty : bool + end + module Flags = begin + val mutable debug : bool + end + module internal Implementation = begin + val anyMarker : int + val shiftFlag : int + val reduceFlag : int + val errorFlag : int + val acceptFlag : int + val actionMask : int + val actionValue : action:int -> int + val actionKind : action:int -> int + type AssocTable = + class + new : elemTab:uint16 [] * offsetTab:uint16 [] * cache:int [] * + cacheSize:int -> AssocTable + member Read : rowNumber:int * keyToFind:int -> int + member ReadAll : n:int -> (int * int) list * int + member + ReadAssoc : minElemNum:int * maxElemNum:int * defaultValueOfAssoc:int * + keyToFind:int -> int + end + type IdxToIdxListTable = + class + new : elemTab:uint16 [] * offsetTab:uint16 [] -> IdxToIdxListTable + member ReadAll : n:int -> int list + end + [] + type ValueInfo = + struct + new : value:obj * startPos:Lexing.Position * endPos:Lexing.Position -> + ValueInfo + val value: obj + val startPos: Lexing.Position + val endPos: Lexing.Position + end + val interpret : + tables:Tables<'tok> -> + lexer:(Lexing.LexBuffer -> 'tok) -> + lexbuf:Lexing.LexBuffer -> initialState:int -> obj + end + module internal ParseHelpers = begin + val parse_error : string -> unit + val parse_error_rich : (ParseErrorContext<'tok> -> unit) option + end + +namespace Internal.Utilities + module internal ResizeArray = begin + val length : ResizeArray<'T> -> int + val get : ResizeArray<'T> -> int -> 'T + val set : ResizeArray<'T> -> int -> 'T -> unit + val create : int -> 'T -> ResizeArray<'T> + val init : int -> (int -> 'T) -> ResizeArray<'T> + val blit : ResizeArray<'T> -> int -> ResizeArray<'T> -> int -> int -> unit + val concat : ResizeArray<'T> list -> ResizeArray<'T> + val append : ResizeArray<'T> -> ResizeArray<'T> -> ResizeArray<'T> + val sub : ResizeArray<'T> -> int -> int -> ResizeArray<'T> + val fill : ResizeArray<'T> -> int -> int -> 'T -> unit + val copy : ResizeArray<'T> -> ResizeArray<'T> + val toList : ResizeArray<'T> -> 'T list + val ofList : 'T list -> ResizeArray<'T> + val iter : ('T -> unit) -> ResizeArray<'T> -> unit + val map : ('T -> 'U) -> ResizeArray<'T> -> ResizeArray<'U> + val mapi : (int -> 'T -> 'U) -> ResizeArray<'T> -> ResizeArray<'U> + val iteri : (int -> 'T -> unit) -> ResizeArray<'T> -> unit + val exists : ('T -> bool) -> ResizeArray<'T> -> bool + val forall : ('T -> bool) -> ResizeArray<'T> -> bool + val indexNotFound : unit -> 'a + val find : ('T -> bool) -> ResizeArray<'T> -> 'T + val tryPick : ('T -> 'U option) -> ResizeArray<'T> -> 'U option + val tryFind : ('T -> bool) -> ResizeArray<'T> -> 'T option + val iter2 : ('T -> 'U -> unit) -> ResizeArray<'T> -> ResizeArray<'U> -> unit + val map2 : + ('T -> 'U -> 'c) -> ResizeArray<'T> -> ResizeArray<'U> -> ResizeArray<'c> + val choose : ('T -> 'U option) -> ResizeArray<'T> -> ResizeArray<'U> + val filter : ('T -> bool) -> ResizeArray<'T> -> ResizeArray<'T> + val partition : + ('T -> bool) -> ResizeArray<'T> -> ResizeArray<'T> * ResizeArray<'T> + val rev : ResizeArray<'T> -> ResizeArray<'T> + val foldBack : ('T -> 'U -> 'U) -> ResizeArray<'T> -> 'U -> 'U + val fold : ('T -> 'U -> 'T) -> 'T -> ResizeArray<'U> -> 'T + val toArray : ResizeArray<'T> -> 'T [] + val ofArray : 'T [] -> ResizeArray<'T> + val toSeq : ResizeArray<'T> -> seq<'T> + val sort : ('T -> 'T -> int) -> ResizeArray<'T> -> unit + val sortBy : ('T -> 'Key) -> ResizeArray<'T> -> unit when 'Key : comparison + val exists2 : + ('T -> 'U -> bool) -> ResizeArray<'T> -> ResizeArray<'U> -> bool + val findIndex : ('T -> bool) -> ResizeArray<'T> -> int + val findIndexi : (int -> 'T -> bool) -> ResizeArray<'T> -> int + val foldSub : + f:('a -> 'b -> 'a) -> + acc:'a -> arr:ResizeArray<'b> -> start:int -> fin:int -> 'a + val foldBackSub : + f:('a -> 'b -> 'b) -> + arr:ResizeArray<'a> -> start:int -> fin:int -> acc:'b -> 'b + val reduce : ('T -> 'T -> 'T) -> ResizeArray<'T> -> 'T + val reduceBack : ('T -> 'T -> 'T) -> ResizeArray<'T> -> 'T + val fold2 : + ('state -> 'b1 -> 'b2 -> 'state) -> + 'state -> ResizeArray<'b1> -> ResizeArray<'b2> -> 'state + val foldBack2 : + ('a1 -> 'a2 -> 'U -> 'U) -> + ResizeArray<'a1> -> ResizeArray<'a2> -> 'U -> 'U + val forall2 : + ('T -> 'U -> bool) -> ResizeArray<'T> -> ResizeArray<'U> -> bool + val isEmpty : ResizeArray<'T> -> bool + val iteri2 : + (int -> 'T -> 'U -> unit) -> ResizeArray<'T> -> ResizeArray<'U> -> unit + val mapi2 : + (int -> 'T -> 'U -> 'c) -> + ResizeArray<'T> -> ResizeArray<'U> -> ResizeArray<'c> + val scanBackSub : + f:('T -> 'a -> 'a) -> + arr:ResizeArray<'T> -> start:int -> fin:int -> acc:'a -> ResizeArray<'a> + val scanSub : + f:('a -> 'T -> 'a) -> + acc:'a -> arr:ResizeArray<'T> -> start:int -> fin:int -> ResizeArray<'a> + val scan : ('U -> 'T -> 'U) -> 'U -> ResizeArray<'T> -> ResizeArray<'U> + val scanBack : ('T -> 'c -> 'c) -> ResizeArray<'T> -> 'c -> ResizeArray<'c> + val singleton : 'T -> ResizeArray<'T> + val tryFindIndex : ('T -> bool) -> ResizeArray<'T> -> int option + val tryFindIndexi : (int -> 'T -> bool) -> ResizeArray<'T> -> int option + val zip : ResizeArray<'T> -> ResizeArray<'U> -> ResizeArray<'T * 'U> + val unzip : ResizeArray<'T * 'U> -> ResizeArray<'T> * ResizeArray<'U> + end + +namespace Internal.Utilities.Collections + [] + type internal HashMultiMap<'Key,'Value> = + class + interface + System.Collections.Generic.ICollection> + interface System.Collections.Generic.IDictionary<'Key,'Value> + interface System.Collections.IEnumerable + interface + System.Collections.Generic.IEnumerable> + new : entries:seq<'Key * 'Value> * + comparer:System.Collections.Generic.IEqualityComparer<'Key> -> + HashMultiMap<'Key,'Value> + new : comparer:System.Collections.Generic.IEqualityComparer<'Key> -> + HashMultiMap<'Key,'Value> + new : size:int * + comparer:System.Collections.Generic.IEqualityComparer<'Key> -> + HashMultiMap<'Key,'Value> + member Add : 'Key * 'Value -> unit + member Clear : unit -> unit + member Contains : y:'Key -> bool + member ContainsKey : 'Key -> bool + member Copy : unit -> HashMultiMap<'Key,'Value> + member FindAll : 'Key -> 'Value list + member Fold : ('Key -> 'Value -> 'State -> 'State) -> 'State -> 'State + member GetRest : k:'Key -> 'Value list + member Iterate : ('Key -> 'Value -> unit) -> unit + member Remove : 'Key -> unit + member Replace : 'Key * 'Value -> unit + member TryFind : 'Key -> 'Value option + member Count : int + member FirstEntries : System.Collections.Generic.Dictionary<'Key,'Value> + member Item : 'Key -> 'Value with get + member Rest : System.Collections.Generic.Dictionary<'Key,'Value list> + end + +namespace Internal.Utilities + module internal EditDistance = begin + val inline existsInWin : + mChar:char -> str:string -> offset:int -> rad:int -> bool + val jaro : s1:string -> s2:string -> float + val JaroWinklerDistance : s1:string -> s2:string -> float + val private calcDamerauLevenshtein : a:string * b:string -> int + val CalcEditDistance : a:string * b:string -> int + end + +namespace Internal.Utilities.Collections.Tagged + [] + type internal SetTree<'T> = + class + new : k:'T -> SetTree<'T> + member Key : 'T + end + [] + type internal SetTreeNode<'T> = + class + inherit SetTree<'T> + new : v:'T * left:SetTree<'T> * right:SetTree<'T> * h:int -> + SetTreeNode<'T> + member Height : int + member Left : SetTree<'T> + member Right : SetTree<'T> + end + module SetTree = begin + val empty : 'a when 'a : null + val inline isEmpty : t:SetTree<'T> -> bool + val countAux : t:SetTree<'T> -> acc:int -> int + val count : s:SetTree<'a> -> int + val inline height : t:SetTree<'T> -> int + [] + val tolerance : int = 2 + val mk : l:SetTree<'T> -> k:'T -> r:SetTree<'T> -> SetTree<'T> + val inline private asNode : value:SetTree<'T> -> SetTreeNode<'T> + val rebalance : t1:SetTree<'a> -> v:'a -> t2:SetTree<'a> -> SetTree<'a> + val add : + comparer:System.Collections.Generic.IComparer<'T> -> + k:'T -> t:SetTree<'T> -> SetTree<'T> + val balance : + comparer:System.Collections.Generic.IComparer<'T> -> + t1:SetTree<'T> -> k:'T -> t2:SetTree<'T> -> SetTree<'T> + val split : + comparer:System.Collections.Generic.IComparer<'T> -> + pivot:'T -> t:SetTree<'T> -> SetTree<'T> * bool * SetTree<'T> + val spliceOutSuccessor : t:SetTree<'T> -> 'T * SetTree<'T> + val remove : + comparer:System.Collections.Generic.IComparer<'T> -> + k:'T -> t:SetTree<'T> -> SetTree<'T> + val contains : + comparer:System.Collections.Generic.IComparer<'T> -> + k:'T -> t:SetTree<'T> -> bool + val iter : f:('T -> unit) -> t:SetTree<'T> -> unit + val fold : f:('T -> 'a -> 'a) -> t:SetTree<'T> -> x:'a -> 'a + val forall : f:('T -> bool) -> t:SetTree<'T> -> bool + val exists : f:('T -> bool) -> t:SetTree<'T> -> bool + val subset : + comparer:System.Collections.Generic.IComparer<'a> -> + a:SetTree<'a> -> b:SetTree<'a> -> bool + val filterAux : + comparer:System.Collections.Generic.IComparer<'T> -> + f:('T -> bool) -> t:SetTree<'T> -> acc:SetTree<'T> -> SetTree<'T> + val filter : + comparer:System.Collections.Generic.IComparer<'a> -> + f:('a -> bool) -> s:SetTree<'a> -> SetTree<'a> + val diffAux : + comparer:System.Collections.Generic.IComparer<'T> -> + t:SetTree<'T> -> acc:SetTree<'T> -> SetTree<'T> + val diff : + comparer:System.Collections.Generic.IComparer<'a> -> + a:SetTree<'a> -> b:SetTree<'a> -> SetTree<'a> + val union : + comparer:System.Collections.Generic.IComparer<'T> -> + t1:SetTree<'T> -> t2:SetTree<'T> -> SetTree<'T> + val intersectionAux : + comparer:System.Collections.Generic.IComparer<'T> -> + b:SetTree<'T> -> t:SetTree<'T> -> acc:SetTree<'T> -> SetTree<'T> + val intersection : + comparer:System.Collections.Generic.IComparer<'a> -> + a:SetTree<'a> -> b:SetTree<'a> -> SetTree<'a> + val partition1 : + comparer:System.Collections.Generic.IComparer<'a> -> + f:('a -> bool) -> + k:'a -> + acc1:SetTree<'a> * acc2:SetTree<'a> -> SetTree<'a> * SetTree<'a> + val partitionAux : + comparer:System.Collections.Generic.IComparer<'T> -> + f:('T -> bool) -> + t:SetTree<'T> -> + SetTree<'T> * SetTree<'T> -> SetTree<'T> * SetTree<'T> + val partition : + comparer:System.Collections.Generic.IComparer<'a> -> + f:('a -> bool) -> s:SetTree<'a> -> SetTree<'a> * SetTree<'a> + val minimumElementAux : t:SetTree<'T> -> n:'T -> 'T + val minimumElementOpt : t:SetTree<'T> -> 'T option + val maximumElementAux : t:SetTree<'T> -> n:'T -> 'T + val maximumElementOpt : t:SetTree<'T> -> 'T option + val minimumElement : s:SetTree<'a> -> 'a + val maximumElement : s:SetTree<'a> -> 'a + type SetIterator<'T> = + class + new : s:SetTree<'T> -> SetTree.SetIterator<'T> + member MoveNext : unit -> bool + member Current : 'T + end + val toSeq : s:SetTree<'a> -> System.Collections.Generic.IEnumerator<'a> + val compareStacks : + comparer:System.Collections.Generic.IComparer<'T> -> + l1:SetTree<'T> list -> l2:SetTree<'T> list -> int + val compare : + comparer:System.Collections.Generic.IComparer<'T> -> + t1:SetTree<'T> -> t2:SetTree<'T> -> int + val choose : s:SetTree<'a> -> 'a + val toList : t:SetTree<'T> -> 'T list + val copyToArray : s:SetTree<'a> -> arr:'a [] -> i:int -> unit + val toArray : s:SetTree<'a> -> 'a [] + val mkFromEnumerator : + comparer:System.Collections.Generic.IComparer<'a> -> + acc:SetTree<'a> -> + e:System.Collections.Generic.IEnumerator<'a> -> SetTree<'a> + val ofSeq : + comparer:System.Collections.Generic.IComparer<'a> -> + c:System.Collections.Generic.IEnumerable<'a> -> SetTree<'a> + val ofArray : + comparer:System.Collections.Generic.IComparer<'a> -> + l:'a [] -> SetTree<'a> + end + [] + type internal Set<'T,'ComparerTag + when 'ComparerTag :> + System.Collections.Generic.IComparer<'T>> = + class + interface System.Collections.IEnumerable + interface System.Collections.Generic.IEnumerable<'T> + interface System.Collections.Generic.ICollection<'T> + interface System.IComparable + new : comparer:System.Collections.Generic.IComparer<'T> * tree:SetTree<'T> -> + Set<'T,'ComparerTag> + static member + ( + ) : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> + Set<'T,'ComparerTag> + static member + ( - ) : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> + Set<'T,'ComparerTag> + static member + Compare : a:Set<'T,'ComparerTag> * b:Set<'T,'ComparerTag> -> int + static member Create : 'ComparerTag * seq<'T> -> Set<'T,'ComparerTag> + static member + Difference : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> + Set<'T,'ComparerTag> + static member Empty : 'ComparerTag -> Set<'T,'ComparerTag> + static member + Equality : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> bool + static member + Intersection : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> + Set<'T,'ComparerTag> + static member Singleton : 'ComparerTag * 'T -> Set<'T,'ComparerTag> + static member + Union : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> + Set<'T,'ComparerTag> + member Add : 'T -> Set<'T,'ComparerTag> + member ComputeHashCode : unit -> int + member Contains : 'T -> bool + override Equals : obj -> bool + member Exists : predicate:('T -> bool) -> bool + member Filter : predicate:('T -> bool) -> Set<'T,'ComparerTag> + member Fold : ('T -> 'State -> 'State) -> 'State -> 'State + member ForAll : predicate:('T -> bool) -> bool + override GetHashCode : unit -> int + member IsSubsetOf : Set<'T,'ComparerTag> -> bool + member IsSupersetOf : Set<'T,'ComparerTag> -> bool + member Iterate : ('T -> unit) -> unit + member + Partition : predicate:('T -> bool) -> + Set<'T,'ComparerTag> * Set<'T,'ComparerTag> + member Remove : 'T -> Set<'T,'ComparerTag> + member ToArray : unit -> 'T [] + member ToList : unit -> 'T list + member Choose : 'T + member Comparer : System.Collections.Generic.IComparer<'T> + member Count : int + member IsEmpty : bool + member MaximumElement : 'T + member MinimumElement : 'T + member Tree : SetTree<'T> + end + [] + type internal MapTree<'Key,'Value> = + class + new : k:'Key * v:'Value -> MapTree<'Key,'Value> + member Key : 'Key + member Value : 'Value + end + [] + type internal MapTreeNode<'Key,'Value> = + class + inherit MapTree<'Key,'Value> + new : k:'Key * v:'Value * left:MapTree<'Key,'Value> * + right:MapTree<'Key,'Value> * h:int -> MapTreeNode<'Key,'Value> + member Height : int + member Left : MapTree<'Key,'Value> + member Right : MapTree<'Key,'Value> + end + module MapTree = begin + val empty : 'a when 'a : null + val inline isEmpty : m:MapTree<'Key,'Value> -> bool + val sizeAux : acc:int -> m:MapTree<'Key,'Value> -> int + val size : x:MapTree<'a,'b> -> int + val inline height : m:MapTree<'Key,'Value> -> int + val mk : + l:MapTree<'Key,'Value> -> + k:'Key -> v:'Value -> r:MapTree<'Key,'Value> -> MapTree<'Key,'Value> + val inline private asNode : + value:MapTree<'Key,'Value> -> MapTreeNode<'Key,'Value> + val rebalance : + t1:MapTree<'Key,'Value> -> + k:'Key -> v:'Value -> t2:MapTree<'Key,'Value> -> MapTree<'Key,'Value> + val add : + comparer:System.Collections.Generic.IComparer<'Key> -> + k:'Key -> v:'Value -> m:MapTree<'Key,'Value> -> MapTree<'Key,'Value> + val indexNotFound : unit -> 'a + val tryGetValue : + comparer:System.Collections.Generic.IComparer<'Key> -> + k:'Key -> v:byref<'Value> -> m:MapTree<'Key,'Value> -> bool + val find : + comparer:System.Collections.Generic.IComparer<'Key> -> + k:'Key -> m:MapTree<'Key,'Value> -> 'Value + val tryFind : + comparer:System.Collections.Generic.IComparer<'Key> -> + k:'Key -> m:MapTree<'Key,'Value> -> 'Value option + val partition1 : + comparer:System.Collections.Generic.IComparer<'Key> -> + f:OptimizedClosures.FSharpFunc<'Key,'a,bool> -> + k:'Key -> + v:'a -> + acc1:MapTree<'Key,'a> * acc2:MapTree<'Key,'a> -> + MapTree<'Key,'a> * MapTree<'Key,'a> + val partitionAux : + comparer:System.Collections.Generic.IComparer<'Key> -> + f:OptimizedClosures.FSharpFunc<'Key,'Value,bool> -> + m:MapTree<'Key,'Value> -> + MapTree<'Key,'Value> * MapTree<'Key,'Value> -> + MapTree<'Key,'Value> * MapTree<'Key,'Value> + val partition : + comparer:System.Collections.Generic.IComparer<'Key> -> + f:('Key -> 'a -> bool) -> + m:MapTree<'Key,'a> -> MapTree<'Key,'a> * MapTree<'Key,'a> + val filter1 : + comparer:System.Collections.Generic.IComparer<'Key> -> + f:OptimizedClosures.FSharpFunc<'Key,'a,bool> -> + k:'Key -> v:'a -> acc:MapTree<'Key,'a> -> MapTree<'Key,'a> + val filterAux : + comparer:System.Collections.Generic.IComparer<'Key> -> + f:OptimizedClosures.FSharpFunc<'Key,'Value,bool> -> + m:MapTree<'Key,'Value> -> + acc:MapTree<'Key,'Value> -> MapTree<'Key,'Value> + val filter : + comparer:System.Collections.Generic.IComparer<'Key> -> + f:('Key -> 'a -> bool) -> m:MapTree<'Key,'a> -> MapTree<'Key,'a> + val spliceOutSuccessor : + m:MapTree<'Key,'Value> -> 'Key * 'Value * MapTree<'Key,'Value> + val remove : + comparer:System.Collections.Generic.IComparer<'Key> -> + k:'Key -> m:MapTree<'Key,'Value> -> MapTree<'Key,'Value> + val mem : + comparer:System.Collections.Generic.IComparer<'Key> -> + k:'Key -> m:MapTree<'Key,'Value> -> bool + val iterOpt : + f:OptimizedClosures.FSharpFunc<'Key,'Value,unit> -> + m:MapTree<'Key,'Value> -> unit + val iter : f:('a -> 'b -> unit) -> m:MapTree<'a,'b> -> unit + val tryPickOpt : + f:OptimizedClosures.FSharpFunc<'Key,'Value,'a option> -> + m:MapTree<'Key,'Value> -> 'a option + val tryPick : f:('a -> 'b -> 'c option) -> m:MapTree<'a,'b> -> 'c option + val existsOpt : + f:OptimizedClosures.FSharpFunc<'Key,'Value,bool> -> + m:MapTree<'Key,'Value> -> bool + val exists : f:('a -> 'b -> bool) -> m:MapTree<'a,'b> -> bool + val forallOpt : + f:OptimizedClosures.FSharpFunc<'Key,'Value,bool> -> + m:MapTree<'Key,'Value> -> bool + val forall : f:('a -> 'b -> bool) -> m:MapTree<'a,'b> -> bool + val map : + f:('Value -> 'Result) -> m:MapTree<'Key,'Value> -> MapTree<'Key,'Result> + val mapiOpt : + f:OptimizedClosures.FSharpFunc<'Key,'Value,'Result> -> + m:MapTree<'Key,'Value> -> MapTree<'Key,'Result> + val mapi : f:('a -> 'b -> 'c) -> m:MapTree<'a,'b> -> MapTree<'a,'c> + val foldBackOpt : + f:OptimizedClosures.FSharpFunc<'Key,'Value,'a,'a> -> + m:MapTree<'Key,'Value> -> x:'a -> 'a + val foldBack : f:('a -> 'b -> 'c -> 'c) -> m:MapTree<'a,'b> -> x:'c -> 'c + val foldSectionOpt : + comparer:System.Collections.Generic.IComparer<'Key> -> + lo:'Key -> + hi:'Key -> + f:OptimizedClosures.FSharpFunc<'Key,'Value,'a,'a> -> + m:MapTree<'Key,'Value> -> x:'a -> 'a + val foldSection : + comparer:System.Collections.Generic.IComparer<'Key> -> + lo:'Key -> + hi:'Key -> + f:('Key -> 'a -> 'b -> 'b) -> m:MapTree<'Key,'a> -> x:'b -> 'b + val foldMapOpt : + comparer:System.Collections.Generic.IComparer<'Key> -> + f:OptimizedClosures.FSharpFunc<'Key,'Value,'a,('b * 'a)> -> + m:MapTree<'Key,'Value> -> + z:'a -> acc:MapTree<'Key,'b> -> MapTree<'Key,'b> * 'a + val foldMap : + comparer:System.Collections.Generic.IComparer<'Key> -> + f:('Key -> 'Value -> 'a -> 'b * 'a) -> + m:MapTree<'Key,'Value> -> + z:'a -> acc:MapTree<'Key,'b> -> MapTree<'Key,'b> * 'a + val toList : m:MapTree<'a,'b> -> ('a * 'b) list + val toArray : m:MapTree<'a,'b> -> ('a * 'b) [] + val ofList : + comparer:System.Collections.Generic.IComparer<'a> -> + l:('a * 'b) list -> MapTree<'a,'b> + val mkFromEnumerator : + comparer:System.Collections.Generic.IComparer<'a> -> + acc:MapTree<'a,'b> -> + e:System.Collections.Generic.IEnumerator<'a * 'b> -> MapTree<'a,'b> + val ofSeq : + comparer:System.Collections.Generic.IComparer<'a> -> + c:seq<'a * 'b> -> MapTree<'a,'b> + val copyToArray : + s:MapTree<'a,'b> -> + arr:System.Collections.Generic.KeyValuePair<'a,'b> [] -> i:int -> unit + type MapIterator<'Key,'Value> = + class + new : s:MapTree<'Key,'Value> -> MapTree.MapIterator<'Key,'Value> + member MoveNext : unit -> bool + member Current : System.Collections.Generic.KeyValuePair<'Key,'Value> + end + val toSeq : + s:MapTree<'a,'b> -> + System.Collections.Generic.IEnumerator> + end + [] + type internal Map<'Key,'Value,'ComparerTag + when 'ComparerTag :> + System.Collections.Generic.IComparer<'Key>> = + class + interface System.IComparable + interface System.Collections.IEnumerable + interface + System.Collections.Generic.IEnumerable> + new : comparer:System.Collections.Generic.IComparer<'Key> * + tree:MapTree<'Key,'Value> -> Map<'Key,'Value,'ComparerTag> + static member + Create : 'ComparerTag * seq<'Key * 'Value> -> + Map<'Key,'Value,'ComparerTag> + static member Empty : 'ComparerTag -> Map<'Key,'Value,'ComparerTag> + static member + FromList : 'ComparerTag * ('Key * 'Value) list -> + Map<'Key,'Value,'ComparerTag> + member Add : 'Key * 'Value -> Map<'Key,'Value,'ComparerTag> + member ComputeHashCode : unit -> int + member ContainsKey : 'Key -> bool + override Equals : obj -> bool + member Exists : ('Key -> 'Value -> bool) -> bool + member Filter : ('Key -> 'Value -> bool) -> Map<'Key,'Value,'ComparerTag> + member First : ('Key -> 'Value -> 'T option) -> 'T option + member + Fold : folder:('Key -> 'Value -> 'State -> 'State) -> 'State -> 'State + member + FoldAndMap : ('Key -> 'Value -> 'State -> 'T * 'State) -> + 'State -> Map<'Key,'T,'ComparerTag> * 'State + member + FoldSection : 'Key -> + 'Key -> + ('Key -> 'Value -> 'State -> 'State) -> + 'State -> 'State + member ForAll : ('Key -> 'Value -> bool) -> bool + override GetHashCode : unit -> int + member Iterate : action:('Key -> 'Value -> unit) -> unit + member Map : mapping:('Key -> 'Value -> 'T) -> Map<'Key,'T,'ComparerTag> + member MapRange : mapping:('Value -> 'T) -> Map<'Key,'T,'ComparerTag> + member + Partition : ('Key -> 'Value -> bool) -> + Map<'Key,'Value,'ComparerTag> * + Map<'Key,'Value,'ComparerTag> + member Remove : 'Key -> Map<'Key,'Value,'ComparerTag> + member ToArray : unit -> ('Key * 'Value) [] + member ToList : unit -> ('Key * 'Value) list + member TryFind : 'Key -> 'Value option + member Comparer : System.Collections.Generic.IComparer<'Key> + member Count : int + member IsEmpty : bool + member Item : 'Key -> 'Value with get + member Tree : MapTree<'Key,'Value> + end + type internal Map<'Key,'Value> = + Map<'Key,'Value,System.Collections.Generic.IComparer<'Key>> + type internal Set<'T> = Set<'T,System.Collections.Generic.IComparer<'T>> + +namespace FSharp.Compiler.AbstractIL + module internal Diagnostics = begin + val mutable diagnosticsLog : System.IO.TextWriter option + val setDiagnosticsChannel : System.IO.TextWriter option -> unit + val dflushn : unit -> unit + val dflush : unit -> unit + val dprintn : string -> unit + val dprintf : Format<'a,System.IO.TextWriter,unit,unit> -> 'a + val dprintfn : Format<'a,System.IO.TextWriter,unit,unit> -> 'a + end + +namespace FSharp.Compiler.AbstractIL.Internal + module Library = begin + val ( >>>& ) : x:int32 -> n:int32 -> int32 + val notlazy : v:'a -> System.Lazy<'a> + val inline isNil : l:'a list -> bool + val inline isNilOrSingleton : l:'a list -> bool + val inline isSingleton : l:'a list -> bool + val inline isNonNull : x:'a -> bool when 'a : null + val inline nonNull : msg:string -> x:'a -> 'a when 'a : null + val inline ( === ) : x:'a -> y:'a -> bool when 'a : not struct + val LOH_SIZE_THRESHOLD_BYTES : int + val reportTime : (bool -> string -> unit) + [] + type InlineDelayInit<'T when 'T : not struct> = + struct + new : f:(unit -> 'T) -> InlineDelayInit<'T> + val mutable store: 'T + val mutable func: System.Func<'T> + member Value : 'T + end + val foldOn : p:('a -> 'b) -> f:('c -> 'b -> 'd) -> z:'c -> x:'a -> 'd + val notFound : unit -> 'a + module Order = begin + val orderBy : + p:('T -> 'U) -> System.Collections.Generic.IComparer<'T> + when 'U : comparison + val orderOn : + p:('T -> 'U) -> + pxOrder:System.Collections.Generic.IComparer<'U> -> + System.Collections.Generic.IComparer<'T> + val toFunction : + pxOrder:System.Collections.Generic.IComparer<'U> -> x:'U -> y:'U -> int + end + module Array = begin + val mapq : f:('a -> 'a) -> inp:'a [] -> 'a [] when 'a : not struct + val lengthsEqAndForall2 : + p:('a -> 'b -> bool) -> l1:'a [] -> l2:'b [] -> bool + val order : + eltOrder:System.Collections.Generic.IComparer<'T> -> + System.Collections.Generic.IComparer<'T array> + val existsOne : p:('a -> bool) -> l:'a [] -> bool + val existsTrue : arr:bool [] -> bool + val findFirstIndexWhereTrue : arr:'a [] -> p:('a -> bool) -> int + val revInPlace : array:'T [] -> unit + val mapAsync : mapping:('T -> Async<'U>) -> array:'T [] -> Async<'U []> + val replace : index:int -> value:'a -> array:'a [] -> 'a [] + val inline areEqual : xs:'T [] -> ys:'T [] -> bool when 'T : equality + val heads : array:'T [] -> 'T [] [] + val inline isSubArray : + subArray:'T [] -> wholeArray:'T [] -> index:int -> bool + when 'T : equality + val startsWith : prefix:'a [] -> whole:'a [] -> bool when 'a : equality + val endsWith : suffix:'a [] -> whole:'a [] -> bool when 'a : equality + end + module Option = begin + val mapFold : + f:('a -> 'b -> 'c * 'a) -> s:'a -> opt:'b option -> 'c option * 'a + val attempt : f:(unit -> 'T) -> 'T option + end + module List = begin + val sortWithOrder : + c:System.Collections.Generic.IComparer<'T> -> + elements:'T list -> 'T list + val splitAfter : n:int -> l:'a list -> 'a list * 'a list + val existsi : f:(int -> 'a -> bool) -> xs:'a list -> bool + val lengthsEqAndForall2 : + p:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool + val findi : n:int -> f:('a -> bool) -> l:'a list -> ('a * int) option + val splitChoose : + select:('a -> Choice<'b,'c>) -> l:'a list -> 'b list * 'c list + val checkq : l1:'a list -> l2:'a list -> bool when 'a : not struct + val mapq : f:('T -> 'T) -> inp:'T list -> 'T list when 'T : not struct + val frontAndBack : l:'a list -> 'a list * 'a + val tryRemove : f:('a -> bool) -> inp:'a list -> ('a * 'a list) option + val zip4 : + l1:'a list -> + l2:'b list -> l3:'c list -> l4:'d list -> ('a * 'b * 'c * 'd) list + val unzip4 : + l:('a * 'b * 'c * 'd) list -> 'a list * 'b list * 'c list * 'd list + val iter3 : + f:('a -> 'b -> 'c -> unit) -> + l1:'a list -> l2:'b list -> l3:'c list -> unit + val takeUntil : p:('a -> bool) -> l:'a list -> 'a list * 'a list + val order : + eltOrder:System.Collections.Generic.IComparer<'T> -> + System.Collections.Generic.IComparer<'T list> + val indexNotFound : unit -> 'a + val assoc : x:'a -> l:('a * 'b) list -> 'b when 'a : equality + val memAssoc : x:'a -> l:('a * 'b) list -> bool when 'a : equality + val memq : x:'a -> l:'a list -> bool when 'a : not struct + val mapNth : n:int -> f:('a -> 'a) -> xs:'a list -> 'a list + val count : pred:('a -> bool) -> xs:'a list -> int + val headAndTail : l:'a list -> 'a * 'a list + val mapHeadTail : + fhead:('a -> 'b) -> ftail:('a -> 'b) -> _arg1:'a list -> 'b list + val collectFold : + f:('a -> 'b -> 'c list * 'a) -> s:'a -> l:'b list -> 'c list * 'a + val collect2 : + f:('a -> 'b -> 'c list) -> xs:'a list -> ys:'b list -> 'c list + val toArraySquared : xss:'a list list -> 'a [] [] + val iterSquared : f:('a -> unit) -> xss:'a list list -> unit + val collectSquared : f:('a -> 'b list) -> xss:'a list list -> 'b list + val mapSquared : f:('a -> 'b) -> xss:'a list list -> 'b list list + val mapFoldSquared : + f:('a -> 'b -> 'c * 'a) -> z:'a -> xss:'b list list -> 'c list list * 'a + val forallSquared : f:('a -> bool) -> xss:'a list list -> bool + val mapiSquared : + f:(int -> int -> 'a -> 'b) -> xss:'a list list -> 'b list list + val existsSquared : f:('a -> bool) -> xss:'a list list -> bool + val mapiFoldSquared : + f:('a -> int * int * 'b -> 'c * 'a) -> + z:'a -> xss:'b list list -> 'c list list * 'a + val duplicates : xs:'T list -> 'T list when 'T : equality + val internal allEqual : xs:'T list -> bool when 'T : equality + end + module ResizeArray = begin + val chunkBySize : + chunkSize:int -> f:('t -> 'a) -> items:ResizeArray<'t> -> 'a [] [] + val mapToSmallArrayChunks : + f:('t -> 'a) -> inp:ResizeArray<'t> -> 'a [] [] + end + module ValueOptionInternal = begin + val inline ofOption : x:'a option -> 'a voption + val inline bind : f:('a -> 'b voption) -> x:'a voption -> 'b voption + end + type String with + member StartsWithOrdinal : value:string -> bool + type String with + member EndsWithOrdinal : value:string -> bool + module String = begin + val make : n:int -> c:char -> string + val get : str:string -> i:int -> char + val sub : s:string -> start:int -> len:int -> string + val contains : s:string -> c:char -> bool + val order : System.Collections.Generic.IComparer + val lowercase : s:string -> string + val uppercase : s:string -> string + val isLeadingIdentifierCharacterUpperCase : s:string -> bool + val capitalize : s:string -> string + val uncapitalize : s:string -> string + val dropPrefix : s:string -> t:string -> string + val dropSuffix : s:string -> t:string -> string + val inline toCharArray : str:string -> char [] + val lowerCaseFirstChar : str:string -> string + val extractTrailingIndex : str:string -> string * int option + val trim : value:string -> string + val split : + options:System.StringSplitOptions -> + separator:string [] -> value:string -> string [] + val ( |StartsWith|_| ) : pattern:string -> value:string -> unit option + val ( |Contains|_| ) : pattern:string -> value:string -> unit option + val getLines : str:string -> string [] + end + module Dictionary = begin + val inline newWithSize : + size:int -> System.Collections.Generic.Dictionary<'a,'b> + when 'a : equality + end + [] + type DictionaryExtensions = + class + new : unit -> DictionaryExtensions + [] + static member + BagAdd : dic:System.Collections.Generic.Dictionary<'key,'value list> * + key:'key * value:'value -> unit + [] + static member + BagExistsValueForKey : dic:System.Collections.Generic.Dictionary<'key, + 'value list> * + key:'key * f:('value -> bool) -> bool + end + module Lazy = begin + val force : x:System.Lazy<'T> -> 'T + end + type ExecutionToken + type CompilationThreadToken = + class + interface ExecutionToken + new : unit -> CompilationThreadToken + end + val RequireCompilationThread : _ctok:CompilationThreadToken -> unit + val DoesNotRequireCompilerThreadTokenAndCouldPossiblyBeMadeConcurrent : + _ctok:CompilationThreadToken -> unit + val AssumeCompilationThreadWithoutEvidence : unit -> CompilationThreadToken + type AnyCallerThreadToken = + class + interface ExecutionToken + new : unit -> AnyCallerThreadToken + end + val AnyCallerThread : AnyCallerThreadToken + type LockToken = + interface + inherit ExecutionToken + end + val AssumeLockWithoutEvidence : unit -> #LockToken + type Lock<'LockTokenType when 'LockTokenType :> LockToken> = + class + new : unit -> Lock<'LockTokenType> + member AcquireLock : f:('LockTokenType -> 'a) -> 'a + end + val getHole : r:'a option ref -> 'a + module Map = begin + val tryFindMulti : + k:'a -> map:Map<'a,'b list> -> 'b list when 'a : comparison + end + type ResultOrException<'TResult> = + | Result of 'TResult + | Exception of System.Exception + module ResultOrException = begin + val success : a:'a -> ResultOrException<'a> + val raze : b:exn -> ResultOrException<'a> + val ( |?> ) : + res:ResultOrException<'a> -> f:('a -> 'b) -> ResultOrException<'b> + val ForceRaise : res:ResultOrException<'a> -> 'a + val otherwise : + f:(unit -> ResultOrException<'a>) -> + x:ResultOrException<'a> -> ResultOrException<'a> + end + [] + type ValueOrCancelled<'TResult> = + | Value of 'TResult + | Cancelled of System.OperationCanceledException + [] + type Cancellable<'TResult> = + | Cancellable of + (System.Threading.CancellationToken -> ValueOrCancelled<'TResult>) + module Cancellable = begin + val run : + ct:System.Threading.CancellationToken -> + Cancellable<'a> -> ValueOrCancelled<'a> + val bind : + f:('a -> Cancellable<'b>) -> comp1:Cancellable<'a> -> Cancellable<'b> + val map : f:('a -> 'b) -> oper:Cancellable<'a> -> Cancellable<'b> + val ret : x:'a -> Cancellable<'a> + val fold : + f:('a -> 'b -> Cancellable<'a>) -> + acc:'a -> seq:seq<'b> -> Cancellable<'a> + val each : + f:('a -> Cancellable<'b>) -> seq:seq<'a> -> Cancellable<'b list> + val delay : f:(unit -> Cancellable<'T>) -> Cancellable<'T> + val runWithoutCancellation : comp:Cancellable<'a> -> 'a + val token : unit -> Cancellable + val canceled : unit -> Cancellable<'a> + val private catch : Cancellable<'a> -> Cancellable> + val tryFinally : + e:Cancellable<'a> -> compensation:(unit -> unit) -> Cancellable<'a> + val tryWith : + e:Cancellable<'a> -> handler:(exn -> Cancellable<'a>) -> Cancellable<'a> + end + type CancellableBuilder = + class + new : unit -> CancellableBuilder + member + Bind : e:Cancellable<'k> * k:('k -> Cancellable<'l>) -> + Cancellable<'l> + member + Combine : e1:Cancellable * e2:Cancellable<'h> -> Cancellable<'h> + member Delay : f:(unit -> Cancellable<'a>) -> Cancellable<'a> + member + For : es:seq<'f> * f:('f -> Cancellable<'g>) -> Cancellable<'g list> + member Return : v:'j -> Cancellable<'j> + member ReturnFrom : v:'i -> 'i + member + TryFinally : e:Cancellable<'b> * compensation:(unit -> unit) -> + Cancellable<'b> + member + TryWith : e:Cancellable<'e> * handler:(exn -> Cancellable<'e>) -> + Cancellable<'e> + member + Using : resource:'c * e:('c -> Cancellable<'d>) -> Cancellable<'d> + when 'c :> System.IDisposable + member Zero : unit -> Cancellable + end + val cancellable : CancellableBuilder + type Eventually<'T> = + | Done of 'T + | NotYetDone of (CompilationThreadToken -> Eventually<'T>) + module Eventually = begin + val box : e:Eventually<'a> -> Eventually + val forceWhile : + ctok:CompilationThreadToken -> + check:(unit -> bool) -> e:Eventually<'a> -> 'a option + val force : ctok:CompilationThreadToken -> e:Eventually<'a> -> 'a + val repeatedlyProgressUntilDoneOrTimeShareOverOrCanceled : + timeShareInMilliseconds:int64 -> + ct:System.Threading.CancellationToken -> + runner:(CompilationThreadToken -> + (#CompilationThreadToken -> Eventually<'b>) -> + Eventually<'b>) -> e:Eventually<'b> -> Eventually<'b> + val forceAsync : + runner:((CompilationThreadToken -> Eventually<'T>) -> + Async>) -> e:Eventually<'T> -> Async<'T option> + val bind : k:('a -> Eventually<'b>) -> e:Eventually<'a> -> Eventually<'b> + val fold : + f:('a -> 'b -> Eventually<'a>) -> + acc:'a -> seq:seq<'b> -> Eventually<'a> + val catch : e:Eventually<'a> -> Eventually> + val delay : f:(unit -> Eventually<'T>) -> Eventually<'T> + val tryFinally : + e:Eventually<'a> -> compensation:(unit -> unit) -> Eventually<'a> + val tryWith : + e:Eventually<'a> -> + handler:(System.Exception -> Eventually<'a>) -> Eventually<'a> + val token : Eventually + end + [] + type EventuallyBuilder = + class + new : unit -> EventuallyBuilder + member + Bind : e:Eventually<'g> * k:('g -> Eventually<'h>) -> Eventually<'h> + member + Combine : e1:Eventually * e2:Eventually<'d> -> Eventually<'d> + member Delay : f:(unit -> Eventually<'a>) -> Eventually<'a> + member Return : v:'f -> Eventually<'f> + member ReturnFrom : v:'e -> 'e + member + TryFinally : e:Eventually<'b> * compensation:(unit -> unit) -> + Eventually<'b> + member + TryWith : e:Eventually<'c> * + handler:(System.Exception -> Eventually<'c>) -> + Eventually<'c> + member Zero : unit -> Eventually + end + val eventually : EventuallyBuilder + type UniqueStampGenerator<'T when 'T : equality> = + class + new : unit -> UniqueStampGenerator<'T> + member Encode : str:'T -> int + member Table : System.Collections.Generic.ICollection<'T> + end + type MemoizationTable<'T,'U> = + class + new : compute:('T -> 'U) * + keyComparer:System.Collections.Generic.IEqualityComparer<'T> * + ?canMemoize:('T -> bool) -> MemoizationTable<'T,'U> + member Apply : x:'T -> 'U + end + exception UndefinedException + type LazyWithContextFailure = + class + new : exn:exn -> LazyWithContextFailure + member Exception : exn + static member Undefined : LazyWithContextFailure + end + [] + type LazyWithContext<'T,'ctxt> = + { mutable value: 'T + mutable funcOrException: obj + findOriginalException: exn -> exn } + with + static member + Create : f:('ctxt -> 'T) * findOriginalException:(exn -> exn) -> + LazyWithContext<'T,'ctxt> + static member NotLazy : x:'T -> LazyWithContext<'T,'ctxt> + member Force : ctxt:'ctxt -> 'T + member UnsynchronizedForce : ctxt:'ctxt -> 'T + member IsDelayed : bool + member IsForced : bool + end + module Tables = begin + val memoize : f:('a -> 'b) -> ('a -> 'b) when 'a : equality + end + type IPartialEqualityComparer<'T> = + interface + inherit System.Collections.Generic.IEqualityComparer<'T> + abstract member InEqualityRelation : 'T -> bool + end + module IPartialEqualityComparer = begin + val On : + f:('a -> 'b) -> + c:IPartialEqualityComparer<'b> -> IPartialEqualityComparer<'a> + [] + type private WrapType<'T> = | Wrap of 'T + val partialDistinctBy : + per:IPartialEqualityComparer<'T> -> seq:'T list -> 'T list + end + type NameMap<'T> = Map + type NameMultiMap<'T> = NameMap<'T list> + type MultiMap<'T,'U when 'T : comparison> = Map<'T,'U list> + module NameMap = begin + val empty : Map<'a,'b> when 'a : comparison + val range : m:Map<'a,'b> -> 'b list when 'a : comparison + val foldBack : f:(string -> 'T -> 'a -> 'a) -> m:NameMap<'T> -> z:'a -> 'a + val forall : + f:('a -> 'b -> bool) -> m:Map<'a,'b> -> bool when 'a : comparison + val exists : + f:('a -> 'b -> bool) -> m:Map<'a,'b> -> bool when 'a : comparison + val ofKeyedList : + f:('a -> 'b) -> l:'a list -> Map<'b,'a> when 'b : comparison + val ofList : l:(string * 'T) list -> NameMap<'T> + val ofSeq : l:seq -> NameMap<'T> + val toList : l:NameMap<'T> -> (string * 'T) list + val layer : m1:NameMap<'T> -> m2:Map -> Map + val layerAdditive : + addf:('a list -> 'b -> 'a list) -> + m1:Map<'c,'b> -> m2:Map<'c,'a list> -> Map<'c,'a list> + when 'c : comparison + val union : + unionf:(seq<'a> -> 'b) -> ms:seq> -> Map + val subfold2 : + errf:('a -> 'b -> 'c) -> + f:('a -> 'd -> 'b -> 'c -> 'c) -> + m1:Map<'a,'d> -> m2:Map<'a,'b> -> acc:'c -> 'c when 'a : comparison + val suball2 : + errf:('a -> 'b -> bool) -> + p:('c -> 'b -> bool) -> m1:Map<'a,'c> -> m2:Map<'a,'b> -> bool + when 'a : comparison + val mapFold : + f:('a -> string -> 'T -> 'b * 'a) -> + s:'a -> l:NameMap<'T> -> Map * 'a + val foldBackRange : f:('T -> 'a -> 'a) -> l:NameMap<'T> -> acc:'a -> 'a + val filterRange : f:('T -> bool) -> l:NameMap<'T> -> Map + val mapFilter : f:('T -> 'a option) -> l:NameMap<'T> -> Map + val map : f:('T -> 'a) -> l:NameMap<'T> -> Map + val iter : f:('T -> unit) -> l:NameMap<'T> -> unit + val partition : + f:('T -> bool) -> l:NameMap<'T> -> Map * Map + val mem : v:string -> m:NameMap<'T> -> bool + val find : v:string -> m:NameMap<'T> -> 'T + val tryFind : v:string -> m:NameMap<'T> -> 'T option + val add : v:string -> x:'T -> m:NameMap<'T> -> Map + val isEmpty : m:NameMap<'T> -> bool + val existsInRange : + p:('a -> bool) -> m:Map<'b,'a> -> bool when 'b : comparison + val tryFindInRange : + p:('a -> bool) -> m:Map<'b,'a> -> 'a option when 'b : comparison + end + module NameMultiMap = begin + val existsInRange : f:('T -> bool) -> m:NameMultiMap<'T> -> bool + val find : v:string -> m:NameMultiMap<'T> -> 'T list + val add : v:string -> x:'T -> m:NameMultiMap<'T> -> Map + val range : m:NameMultiMap<'T> -> 'T list + val rangeReversingEachBucket : m:NameMultiMap<'T> -> 'T list + val chooseRange : f:('T -> 'a option) -> m:NameMultiMap<'T> -> 'a list + val map : f:('T -> 'a) -> m:NameMultiMap<'T> -> Map + val empty : NameMultiMap<'T> + val initBy : f:('T -> string) -> xs:seq<'T> -> NameMultiMap<'T> + val ofList : xs:(string * 'T) list -> NameMultiMap<'T> + end + module MultiMap = begin + val existsInRange : + f:('a -> bool) -> m:MultiMap<'b,'a> -> bool when 'b : comparison + val find : v:'a -> m:MultiMap<'a,'b> -> 'b list when 'a : comparison + val add : + v:'a -> x:'b -> m:MultiMap<'a,'b> -> Map<'a,'b list> + when 'a : comparison + val range : m:MultiMap<'a,'b> -> 'b list when 'a : comparison + val empty : MultiMap<'a,'b> when 'a : comparison + val initBy : + f:('a -> 'b) -> xs:seq<'a> -> MultiMap<'b,'a> when 'b : comparison + end + type LayeredMap<'Key,'Value when 'Key : comparison> = Map<'Key,'Value> + type Map<'Key,'Value when 'Key : comparison> with + static member Empty : Map<'Key,'Value> when 'Key : comparison + type Map<'Key,'Value when 'Key : comparison> with + member Values : 'Value list + type Map<'Key,'Value when 'Key : comparison> with + member + AddAndMarkAsCollapsible : kvs:System.Collections.Generic.KeyValuePair<'Key, + 'Value> [] -> + Map<'Key,'Value> when 'Key : comparison + type Map<'Key,'Value when 'Key : comparison> with + member + LinearTryModifyThenLaterFlatten : key:'Key * f:('Value option -> 'Value) -> + Map<'Key,'Value> + when 'Key : comparison + type Map<'Key,'Value when 'Key : comparison> with + member MarkAsCollapsible : unit -> Map<'Key,'Value> when 'Key : comparison + [] + type LayeredMultiMap<'Key,'Value when 'Key : comparison> = + class + new : contents:LayeredMap<'Key,'Value list> -> + LayeredMultiMap<'Key,'Value> + member Add : k:'Key * v:'Value -> LayeredMultiMap<'Key,'Value> + member + AddAndMarkAsCollapsible : kvs:System.Collections.Generic.KeyValuePair<'Key, + 'Value> [] -> + LayeredMultiMap<'Key,'Value> + member MarkAsCollapsible : unit -> LayeredMultiMap<'Key,'Value> + member TryFind : k:'Key -> 'Value list option + member TryGetValue : k:'Key -> bool * 'Value list + member Item : k:'Key -> 'Value list with get + member Values : 'Value list + static member Empty : LayeredMultiMap<'Key,'Value> + end + module Shim = begin + type IFileSystem = + interface + abstract member + AssemblyLoad : assemblyName:System.Reflection.AssemblyName -> + System.Reflection.Assembly + abstract member + AssemblyLoadFrom : fileName:string -> System.Reflection.Assembly + abstract member FileDelete : fileName:string -> unit + abstract member + FileStreamCreateShim : fileName:string -> System.IO.Stream + abstract member + FileStreamReadShim : fileName:string -> System.IO.Stream + abstract member + FileStreamWriteExistingShim : fileName:string -> System.IO.Stream + abstract member GetFullPathShim : fileName:string -> string + abstract member + GetLastWriteTimeShim : fileName:string -> System.DateTime + abstract member GetTempPathShim : unit -> string + abstract member IsInvalidPathShim : filename:string -> bool + abstract member IsPathRootedShim : path:string -> bool + abstract member IsStableFileHeuristic : fileName:string -> bool + abstract member ReadAllBytesShim : fileName:string -> byte [] + abstract member SafeExists : fileName:string -> bool + end + type DefaultFileSystem = + class + interface IFileSystem + new : unit -> DefaultFileSystem + end + val mutable FileSystem : IFileSystem + val private retryDelayMilliseconds : int + val private numRetries : int + val private getReader : + filename:string * codePage:int option * retryLocked:bool -> + System.IO.StreamReader + type File with + static member + ReadBinaryChunk : fileName:string * start:int * len:int -> byte [] + type File with + static member + OpenReaderAndRetry : filename:string * codepage:int option * + retryLocked:bool -> System.IO.StreamReader + end + end + +namespace Internal.Utilities + module internal Filename = begin + exception IllegalFileNameChar of string * char + val checkPathForIllegalChars : (string -> unit) + val checkSuffix : string -> string -> bool + val hasExtensionWithValidate : validate:bool -> s:string -> bool + val hasExtension : string -> bool + val chopExtension : string -> string + val directoryName : string -> string + val fileNameOfPath : string -> string + val fileNameWithoutExtensionWithValidate : bool -> string -> string + val fileNameWithoutExtension : string -> string + val trimQuotes : string -> string + end + +namespace FSharp.Compiler.AbstractIL.Internal + type internal Zmap<'Key,'T> = + Internal.Utilities.Collections.Tagged.Map<'Key,'T> + module internal Zmap = begin + val empty : + System.Collections.Generic.IComparer<'Key> -> + Internal.Utilities.Collections.Tagged.Map<'Key,'T, + System.Collections.Generic.IComparer<'Key>> + val add : + 'Key -> + 'T -> + Zmap<'Key,'T> -> + Internal.Utilities.Collections.Tagged.Map<'Key,'T, + System.Collections.Generic.IComparer<'Key>> + val find : 'Key -> Zmap<'Key,'T> -> 'T + val tryFind : 'Key -> Zmap<'Key,'T> -> 'T option + val remove : + 'Key -> + Zmap<'Key,'T> -> + Internal.Utilities.Collections.Tagged.Map<'Key,'T, + System.Collections.Generic.IComparer<'Key>> + val mem : 'Key -> Zmap<'Key,'T> -> bool + val iter : action:('T -> 'U -> unit) -> Zmap<'T,'U> -> unit + val first : ('Key -> 'T -> bool) -> Zmap<'Key,'T> -> ('Key * 'T) option + val exists : ('Key -> 'T -> bool) -> Zmap<'Key,'T> -> bool + val forall : ('Key -> 'T -> bool) -> Zmap<'Key,'T> -> bool + val map : + mapping:('T -> 'U) -> + Zmap<'Key,'T> -> + Internal.Utilities.Collections.Tagged.Map<'Key,'U, + System.Collections.Generic.IComparer<'Key>> + val mapi : + mapping:('Key -> 'T -> 'U) -> + Zmap<'Key,'T> -> + Internal.Utilities.Collections.Tagged.Map<'Key,'U, + System.Collections.Generic.IComparer<'Key>> + val fold : ('Key -> 'T -> 'U -> 'U) -> Zmap<'Key,'T> -> 'U -> 'U + val toList : Zmap<'Key,'T> -> ('Key * 'T) list + val foldSection : + 'Key -> 'Key -> ('Key -> 'T -> 'U -> 'U) -> Zmap<'Key,'T> -> 'U -> 'U + val isEmpty : Zmap<'Key,'T> -> bool + val foldMap : + ('State -> 'Key -> 'T -> 'State * 'U) -> + 'State -> + Zmap<'Key,'T> -> + 'State * + Internal.Utilities.Collections.Tagged.Map<'Key,'U, + System.Collections.Generic.IComparer<'Key>> + val choose : ('Key -> 'T -> 'U option) -> Zmap<'Key,'T> -> 'U option + val chooseL : ('Key -> 'T -> 'U option) -> Zmap<'Key,'T> -> 'U list + val ofList : + System.Collections.Generic.IComparer<'Key> -> + ('Key * 'T) list -> + Internal.Utilities.Collections.Tagged.Map<'Key,'T, + System.Collections.Generic.IComparer<'Key>> + val keys : Zmap<'Key,'T> -> 'Key list + val values : Zmap<'Key,'T> -> 'T list + val memberOf : Zmap<'Key,'T> -> 'Key -> bool + end + +namespace FSharp.Compiler.AbstractIL.Internal + type internal Zset<'T> = Internal.Utilities.Collections.Tagged.Set<'T> + module internal Zset = begin + val empty : + System.Collections.Generic.IComparer<'T> -> + Internal.Utilities.Collections.Tagged.Set<'T, + System.Collections.Generic.IComparer<'T>> + val isEmpty : Zset<'T> -> bool + val contains : 'T -> Zset<'T> -> bool + val add : + 'T -> + Zset<'T> -> + Internal.Utilities.Collections.Tagged.Set<'T, + System.Collections.Generic.IComparer<'T>> + val addList : + 'T list -> + Internal.Utilities.Collections.Tagged.Set<'T, + System.Collections.Generic.IComparer<'T>> -> + Internal.Utilities.Collections.Tagged.Set<'T, + System.Collections.Generic.IComparer<'T>> + val singleton : + System.Collections.Generic.IComparer<'T> -> + 'T -> + Internal.Utilities.Collections.Tagged.Set<'T, + System.Collections.Generic.IComparer<'T>> + val remove : + 'T -> + Zset<'T> -> + Internal.Utilities.Collections.Tagged.Set<'T, + System.Collections.Generic.IComparer<'T>> + val fold : ('T -> 'State -> 'State) -> Zset<'T> -> 'State -> 'State + val iter : ('T -> unit) -> Zset<'T> -> unit + val forall : predicate:('T -> bool) -> Zset<'T> -> bool + val count : Zset<'T> -> int + val exists : predicate:('T -> bool) -> Zset<'T> -> bool + val subset : Zset<'T> -> Zset<'T> -> bool + val equal : Zset<'T> -> Zset<'T> -> bool + val elements : Zset<'T> -> 'T list + val filter : + predicate:('T -> bool) -> + Zset<'T> -> + Internal.Utilities.Collections.Tagged.Set<'T, + System.Collections.Generic.IComparer<'T>> + val union : + Zset<'T> -> + Zset<'T> -> + Internal.Utilities.Collections.Tagged.Set<'T, + System.Collections.Generic.IComparer<'T>> + val inter : + Zset<'T> -> + Zset<'T> -> + Internal.Utilities.Collections.Tagged.Set<'T, + System.Collections.Generic.IComparer<'T>> + val diff : + Zset<'T> -> + Zset<'T> -> + Internal.Utilities.Collections.Tagged.Set<'T, + System.Collections.Generic.IComparer<'T>> + val memberOf : Zset<'T> -> 'T -> bool + end + +namespace FSharp.Compiler.AbstractIL.Internal + module Utils = begin + val runningOnMono : bool + end + module internal Bytes = begin + val b0 : n:int -> int + val b1 : n:int -> int + val b2 : n:int -> int + val b3 : n:int -> int + val dWw1 : n:int64 -> int32 + val dWw0 : n:int64 -> int32 + val get : byte [] -> int -> int32 + val zeroCreate : int -> byte [] + val sub : b:byte [] -> s:int -> l:int -> byte [] + val blit : byte [] -> int -> byte [] -> int -> int -> unit + val ofInt32Array : int [] -> byte [] + val stringAsUtf8NullTerminated : string -> byte [] + val stringAsUnicodeNullTerminated : string -> byte [] + end + [] + type ByteMemory = + class + new : unit -> ByteMemory + static member FromArray : bytes:byte [] -> ByteMemory + static member + FromArray : bytes:byte [] * offset:int * length:int -> ByteMemory + static member + FromFile : path:string * System.IO.FileAccess * ?canShadowCopy:bool -> + ByteMemory + static member + FromMemoryMappedFile : System.IO.MemoryMappedFiles.MemoryMappedFile -> + ByteMemory + static member + FromUnsafePointer : addr:nativeint * length:int * holder:obj -> + ByteMemory + member AsReadOnly : unit -> ReadOnlyByteMemory + abstract member AsReadOnlyStream : unit -> System.IO.Stream + abstract member AsStream : unit -> System.IO.Stream + abstract member + Copy : srcOffset:int * dest:byte [] * destOffset:int * count:int -> unit + abstract member CopyTo : System.IO.Stream -> unit + abstract member ReadBytes : pos:int * count:int -> byte [] + abstract member ReadInt32 : pos:int -> int + abstract member ReadUInt16 : pos:int -> uint16 + abstract member ReadUtf8String : pos:int * count:int -> string + abstract member Slice : pos:int * count:int -> ByteMemory + abstract member ToArray : unit -> byte [] + abstract member Item : int -> byte with get + abstract member Length : int + static member Empty : ByteMemory + end + [] + type ByteArrayMemory = + class + inherit ByteMemory + new : bytes:byte [] * offset:int * length:int -> ByteArrayMemory + override AsReadOnlyStream : unit -> System.IO.Stream + override AsStream : unit -> System.IO.Stream + override + Copy : srcOffset:int * dest:byte [] * destOffset:int * count:int -> unit + override CopyTo : stream:System.IO.Stream -> unit + override ReadBytes : pos:int * count:int -> byte [] + override ReadInt32 : pos:int -> int + override ReadUInt16 : pos:int -> uint16 + override ReadUtf8String : pos:int * count:int -> string + override Slice : pos:int * count:int -> ByteMemory + override ToArray : unit -> byte [] + override Item : i:int -> byte with get + override Length : int + end + [] + type SafeUnmanagedMemoryStream = + class + inherit System.IO.UnmanagedMemoryStream + new : addr:nativeptr * length:int64 * capacity:int64 * + access:System.IO.FileAccess * holder:obj -> + SafeUnmanagedMemoryStream + new : addr:nativeptr * length:int64 * holder:obj -> + SafeUnmanagedMemoryStream + val mutable private holder: obj + val mutable private isDisposed: bool + override Dispose : disposing:bool -> unit + end + type RawByteMemory = + class + inherit ByteMemory + new : addr:nativeptr * length:int * holder:obj -> RawByteMemory + override AsReadOnlyStream : unit -> System.IO.Stream + override AsStream : unit -> System.IO.Stream + override + Copy : srcOffset:int * dest:byte [] * destOffset:int * count:int -> unit + override CopyTo : stream:System.IO.Stream -> unit + override ReadBytes : pos:int * count:int -> byte [] + override ReadInt32 : pos:int -> int + override ReadUInt16 : pos:int -> uint16 + override ReadUtf8String : pos:int * count:int -> string + override Slice : pos:int * count:int -> ByteMemory + override ToArray : unit -> byte [] + override Item : i:int -> byte with get + override Length : int + end + [] + type ReadOnlyByteMemory = + struct + new : ByteMemory -> ReadOnlyByteMemory + member AsStream : unit -> System.IO.Stream + member + Copy : srcOffset:int * dest:byte [] * destOffset:int * count:int -> unit + member CopyTo : System.IO.Stream -> unit + member ReadBytes : pos:int * count:int -> byte [] + member ReadInt32 : pos:int -> int + member ReadUInt16 : pos:int -> uint16 + member ReadUtf8String : pos:int * count:int -> string + member Slice : pos:int * count:int -> ReadOnlyByteMemory + member ToArray : unit -> byte [] + member Item : int -> byte with get + member Length : int + member Underlying : ByteMemory + end + module MemoryMappedFileExtensions = begin + type MemoryMappedFile with + static member + TryFromByteMemory : bytes:ReadOnlyByteMemory -> + System.IO.MemoryMappedFiles.MemoryMappedFile option + end + [] + type internal ByteStream = + { bytes: ReadOnlyByteMemory + mutable pos: int + max: int } + with + static member + FromBytes : ReadOnlyByteMemory * start:int * length:int -> ByteStream + member ReadByte : unit -> byte + member ReadBytes : int -> ReadOnlyByteMemory + member ReadUtf8String : int -> string + member Position : int + end + [] + type internal ByteBuffer = + { mutable bbArray: byte [] + mutable bbCurrent: int } + with + static member Create : int -> ByteBuffer + member Close : unit -> byte [] + member EmitBoolAsByte : bool -> unit + member EmitByte : byte -> unit + member EmitByteMemory : ReadOnlyByteMemory -> unit + member EmitBytes : byte [] -> unit + member EmitInt32 : int -> unit + member EmitInt32AsUInt16 : int -> unit + member EmitInt64 : int64 -> unit + member EmitIntAsByte : int -> unit + member EmitIntsAsBytes : int [] -> unit + member EmitUInt16 : uint16 -> unit + member Ensure : newSize:int -> unit + member FixupInt32 : pos:int -> value:int -> unit + member Position : int + end + [] + type ByteStorage = + class + new : getByteMemory:(unit -> ReadOnlyByteMemory) -> ByteStorage + static member FromByteArray : byte [] -> ByteStorage + static member + FromByteArrayAndCopy : byte [] * useBackingMemoryMappedFile:bool -> + ByteStorage + static member FromByteMemory : ReadOnlyByteMemory -> ByteStorage + static member + FromByteMemoryAndCopy : ReadOnlyByteMemory * + useBackingMemoryMappedFile:bool -> ByteStorage + member GetByteMemory : unit -> ReadOnlyByteMemory + end + +namespace FSharp.Compiler + module internal XmlAdapters = begin + val s_escapeChars : char [] + val getEscapeSequence : c:char -> string + val escape : str:string -> string + end + +namespace Internal.Utilities.Collections + [] + type internal ValueStrength<'T when 'T : not struct> = + | Strong of 'T + | Weak of System.WeakReference<'T> + type internal AgedLookup<'Token,'Key,'Value when 'Value : not struct> = + class + new : keepStrongly:int * areSimilar:('Key * 'Key -> bool) * + ?requiredToKeep:('Value -> bool) * ?keepMax:int -> + AgedLookup<'Token,'Key,'Value> + member Clear : 'Token -> unit + member Put : 'Token * 'Key * 'Value -> unit + member Remove : 'Token * key:'Key -> unit + member Resize : 'Token * newKeepStrongly:int * ?newKeepMax:int -> unit + member TryGet : 'Token * key:'Key -> 'Value option + member TryGetKeyValue : 'Token * key:'Key -> ('Key * 'Value) option + member TryPeekKeyValue : 'Token * key:'Key -> ('Key * 'Value) option + end + type internal MruCache<'Token,'Key,'Value when 'Value : not struct> = + class + new : keepStrongly:int * areSame:('Key * 'Key -> bool) * + ?isStillValid:('Key * 'Value -> bool) * + ?areSimilar:('Key * 'Key -> bool) * ?requiredToKeep:('Value -> bool) * + ?keepMax:int -> MruCache<'Token,'Key,'Value> + member Clear : 'Token -> unit + member ContainsSimilarKey : 'Token * key:'Key -> bool + member RemoveAnySimilar : 'Token * key:'Key -> unit + member Resize : 'Token * newKeepStrongly:int * ?newKeepMax:int -> unit + member Set : 'Token * key:'Key * value:'Value -> unit + member TryGet : 'Token * key:'Key -> 'Value option + member TryGetAny : 'Token * key:'Key -> 'Value option + member TryGetSimilar : 'Token * key:'Key -> 'Value option + member TryGetSimilarAny : 'Token * key:'Key -> 'Value option + end + +namespace Internal.Utilities + type internal QueueList<'T> = + class + interface System.Collections.IEnumerable + interface System.Collections.Generic.IEnumerable<'T> + new : xs:'T list -> QueueList<'T> + new : firstElementsIn:'T list * lastElementsRevIn:'T list * + numLastElementsIn:int -> QueueList<'T> + member Append : ys:seq<'T> -> QueueList<'T> + member AppendOne : y:'T -> QueueList<'T> + member ToList : unit -> 'T list + member FirstElements : 'T list + member LastElements : 'T list + static member Empty : QueueList<'T> + end + module internal QueueList = begin + val empty<'T> : QueueList<'T> + val ofSeq : x:seq<'a> -> QueueList<'a> + val iter : f:('a -> unit) -> x:QueueList<'a> -> unit + val map : f:('a -> 'b) -> x:QueueList<'a> -> QueueList<'b> + val exists : f:('a -> bool) -> x:QueueList<'a> -> bool + val filter : f:('a -> bool) -> x:QueueList<'a> -> QueueList<'a> + val foldBack : f:('a -> 'b -> 'b) -> x:QueueList<'a> -> acc:'b -> 'b + val forall : f:('a -> bool) -> x:QueueList<'a> -> bool + val ofList : x:'a list -> QueueList<'a> + val toList : x:QueueList<'a> -> 'a list + val tryFind : f:('a -> bool) -> x:QueueList<'a> -> 'a option + val one : x:'a -> QueueList<'a> + val appendOne : x:QueueList<'a> -> y:'a -> QueueList<'a> + val append : x:QueueList<'a> -> ys:QueueList<'a> -> QueueList<'a> + end + +namespace FSharp.Compiler + module internal Lib = begin + val debug : bool + val verbose : bool + val mutable progress : bool + val mutable tracking : bool + val condition : s:string -> bool + val GetEnvInteger : e:string -> dflt:int -> int + val dispose : x:System.IDisposable -> unit + module Bits = begin + val b0 : n:int -> int + val b1 : n:int -> int + val b2 : n:int -> int + val b3 : n:int -> int + val pown32 : n:int -> int + val pown64 : n:int -> int64 + val mask32 : m:int32 -> n:int -> int + val mask64 : m:int32 -> n:int -> int64 + end + module Filename = begin + val fullpath : cwd:string -> nm:string -> string + val hasSuffixCaseInsensitive : suffix:string -> filename:string -> bool + val isDll : file:string -> bool + end + module Bool = begin + val order : System.Collections.Generic.IComparer + end + module Int32 = begin + val order : System.Collections.Generic.IComparer + end + module Int64 = begin + val order : System.Collections.Generic.IComparer + end + module Pair = begin + val order : + compare1:System.Collections.Generic.IComparer<'T1> * + compare2:System.Collections.Generic.IComparer<'T2> -> + System.Collections.Generic.IComparer<'T1 * 'T2> + end + type NameSet = AbstractIL.Internal.Zset + module NameSet = begin + val ofList : l:string list -> NameSet + end + module NameMap = begin + val domain : m:Map -> AbstractIL.Internal.Zset + val domainL : m:Map -> string list + end + module Check = begin + val NotNone : argName:string -> arg:'T option -> 'T + val ArgumentNotNull : arg:'a -> argName:string -> unit + val ArrayArgumentNotNullOrEmpty : arr:'T [] -> argName:string -> unit + val StringArgumentNotNullOrEmpty : s:string -> argName:string -> unit + end + type IntMap<'T> = AbstractIL.Internal.Zmap + module IntMap = begin + val empty : unit -> AbstractIL.Internal.Zmap + val add : + k:int -> v:'T -> t:IntMap<'T> -> AbstractIL.Internal.Zmap + val find : k:int -> t:IntMap<'T> -> 'T + val tryFind : k:int -> t:IntMap<'T> -> 'T option + val remove : k:int -> t:IntMap<'T> -> AbstractIL.Internal.Zmap + val mem : k:int -> t:IntMap<'T> -> bool + val iter : f:(int -> 'T -> unit) -> t:IntMap<'T> -> unit + val map : f:('T -> 'a) -> t:IntMap<'T> -> AbstractIL.Internal.Zmap + val fold : f:(int -> 'T -> 'a -> 'a) -> t:IntMap<'T> -> z:'a -> 'a + end + module ListAssoc = begin + val find : f:('a -> 'b -> bool) -> x:'a -> l:('b * 'c) list -> 'c + val tryFind : + f:('key -> 'key -> bool) -> + x:'key -> l:('key * 'value) list -> 'value option + end + module ListSet = begin + val inline contains : f:('a -> 'b -> bool) -> x:'a -> l:'b list -> bool + val insert : f:('a -> 'a -> bool) -> x:'a -> l:'a list -> 'a list + val unionFavourRight : + f:('a -> 'a -> bool) -> l1:'a list -> l2:'a list -> 'a list + val private findIndexAux : + eq:('a -> 'b -> bool) -> x:'b -> l:'a list -> n:int -> int + val findIndex : eq:('a -> 'b -> bool) -> x:'b -> l:'a list -> int + val remove : f:('a -> 'b -> bool) -> x:'a -> l:'b list -> 'b list + val subtract : f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> 'a list + val isSubsetOf : f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool + val isSupersetOf : + f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool + val equals : f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool + val unionFavourLeft : + f:('a -> 'a -> bool) -> l1:'a list -> l2:'a list -> 'a list + val intersect : + f:('a -> 'b -> bool) -> l1:'b list -> l2:'a list -> 'a list + val setify : f:('a -> 'a -> bool) -> l:'a list -> 'a list + val hasDuplicates : f:('a -> 'a -> bool) -> l:'a list -> bool + end + val mapFoldFst : + f:('a -> 'b -> 'c * 'd) -> s:'a -> x:'b * y:'e -> ('c * 'e) * 'd + val mapFoldSnd : + f:('a -> 'b -> 'c * 'd) -> s:'a -> x:'e * y:'b -> ('e * 'c) * 'd + val pair : a:'a -> b:'b -> 'a * 'b + val p13 : x:'a * _y:'b * _z:'c -> 'a + val p23 : _x:'a * y:'b * _z:'c -> 'b + val p33 : _x:'a * _y:'b * z:'c -> 'c + val map1Of2 : f:('a -> 'b) -> a1:'a * a2:'c -> 'b * 'c + val map2Of2 : f:('a -> 'b) -> a1:'c * a2:'a -> 'c * 'b + val map1Of3 : f:('a -> 'b) -> a1:'a * a2:'c * a3:'d -> 'b * 'c * 'd + val map2Of3 : f:('a -> 'b) -> a1:'c * a2:'a * a3:'d -> 'c * 'b * 'd + val map3Of3 : f:('a -> 'b) -> a1:'c * a2:'d * a3:'a -> 'c * 'd * 'b + val map3Of4 : + f:('a -> 'b) -> a1:'c * a2:'d * a3:'a * a4:'e -> 'c * 'd * 'b * 'e + val map4Of4 : + f:('a -> 'b) -> a1:'c * a2:'d * a3:'e * a4:'a -> 'c * 'd * 'e * 'b + val map5Of5 : + f:('a -> 'b) -> + a1:'c * a2:'d * a3:'e * a4:'f * a5:'a -> 'c * 'd * 'e * 'f * 'b + val map6Of6 : + f:('a -> 'b) -> + a1:'c * a2:'d * a3:'e * a4:'f * a5:'g * a6:'a -> + 'c * 'd * 'e * 'f * 'g * 'b + val foldPair : + f1:('a -> 'b -> 'c) * f2:('c -> 'd -> 'e) -> acc:'a -> a1:'b * a2:'d -> 'e + val fold1Of2 : f1:('a -> 'b -> 'c) -> acc:'a -> a1:'b * _a2:'d -> 'c + val foldTriple : + f1:('a -> 'b -> 'c) * f2:('c -> 'd -> 'e) * f3:('e -> 'f -> 'g) -> + acc:'a -> a1:'b * a2:'d * a3:'f -> 'g + val foldQuadruple : + f1:('a -> 'b -> 'c) * f2:('c -> 'd -> 'e) * f3:('e -> 'f -> 'g) * + f4:('g -> 'h -> 'i) -> acc:'a -> a1:'b * a2:'d * a3:'f * a4:'h -> 'i + val mapPair : f1:('a -> 'b) * f2:('c -> 'd) -> a1:'a * a2:'c -> 'b * 'd + val mapTriple : + f1:('a -> 'b) * f2:('c -> 'd) * f3:('e -> 'f) -> + a1:'a * a2:'c * a3:'e -> 'b * 'd * 'f + val mapQuadruple : + f1:('a -> 'b) * f2:('c -> 'd) * f3:('e -> 'f) * f4:('g -> 'h) -> + a1:'a * a2:'c * a3:'e * a4:'g -> 'b * 'd * 'f * 'h + val fmap2Of2 : + f:('a -> 'b -> 'c * 'd) -> z:'a -> a1:'e * a2:'b -> 'c * ('e * 'd) + module Zmap = begin + val force : k:'a -> mp:AbstractIL.Internal.Zmap<'a,'b> -> 'b + val mapKey : + key:'a -> + f:('b option -> 'b option) -> + mp:AbstractIL.Internal.Zmap<'a,'b> -> + AbstractIL.Internal.Zmap<'a,'b> + end + module Zset = begin + val ofList : + order:System.Collections.Generic.IComparer<'a> -> + xs:'a list -> AbstractIL.Internal.Zset<'a> + val fixpoint : + f:(AbstractIL.Internal.Zset<'a> -> AbstractIL.Internal.Zset<'a>) -> + AbstractIL.Internal.Zset<'a> -> AbstractIL.Internal.Zset<'a> + end + val equalOn : f:('a -> 'b) -> x:'a -> y:'a -> bool when 'b : equality + val bufs : f:(System.Text.StringBuilder -> unit) -> string + val writeViaBuffer : + os:System.IO.TextWriter -> + f:(System.Text.StringBuilder -> 'a -> unit) -> x:'a -> unit + type GraphNode<'Data,'Id> = + { nodeId: 'Id + nodeData: 'Data + mutable nodeNeighbours: GraphNode<'Data,'Id> list } + type Graph<'Data,'Id when 'Id : comparison> = + class + new : nodeIdentity:('Data -> 'Id) * nodes:'Data list * + edges:('Data * 'Data) list -> Graph<'Data,'Id> + member GetNodeData : nodeId:'Id -> 'Data + member IterateCycles : f:('Data list -> unit) -> unit + end + type NonNullSlot<'T> = 'T + val nullableSlotEmpty : unit -> 'T + val nullableSlotFull : x:'a -> 'a + type cache<'T> = + { mutable cacheVal: NonNullSlot<'T> } + val newCache : unit -> cache<'a> + val inline cached : cache:cache<'a> -> resF:(unit -> 'a) -> 'a + val inline cacheOptByref : cache:byref<'T option> -> f:(unit -> 'T) -> 'T + val inline cacheOptRef : cache:'a option ref -> f:(unit -> 'a) -> 'a + val inline tryGetCacheValue : cache:cache<'a> -> NonNullSlot<'a> voption + module AsyncUtil = begin + [] + type AsyncResult<'T> = + | AsyncOk of 'T + | AsyncException of exn + | AsyncCanceled of System.OperationCanceledException + with + static member Commit : res:AsyncResult<'T> -> Async<'T> + end + [] + type AsyncResultCell<'T> = + class + new : unit -> AsyncResultCell<'T> + member RegisterResult : res:AsyncResult<'T> -> unit + member private AsyncPrimitiveResult : Async> + member AsyncResult : Async<'T> + end + end + module UnmanagedProcessExecutionOptions = begin + val private GetProcessHeap : unit -> System.UIntPtr + val private HeapSetInformation : + _HeapHandle:System.UIntPtr * _HeapInformationClass:System.UInt32 * + _HeapInformation:System.UIntPtr * _HeapInformationLength:System.UIntPtr -> + bool + val private GetLastError : unit -> System.UInt32 + [ (3))>] + val EnableHeapTerminationOnCorruption : unit -> unit + end + module StackGuard = begin + [] + val private MaxUncheckedRecursionDepth : int = 20 + val EnsureSufficientExecutionStack : recursionDepth:int -> unit + end + [] + type MaybeLazy<'T> = + | Strict of 'T + | Lazy of System.Lazy<'T> + with + member Force : unit -> 'T + member Value : 'T + end + val inline vsnd : struct ('T * 'T) -> 'T + type DisposablesTracker = + class + interface System.IDisposable + new : unit -> DisposablesTracker + member Register : i:System.IDisposable -> unit + end + end + +namespace FSharp.Compiler + module internal Rational = begin + type Rational = + { numerator: System.Numerics.BigInteger + denominator: System.Numerics.BigInteger } + val gcd : + a:System.Numerics.BigInteger -> + b:System.Numerics.BigInteger -> System.Numerics.BigInteger + val lcm : + a:System.Numerics.BigInteger -> + b:System.Numerics.BigInteger -> System.Numerics.BigInteger + val mkRational : + p:System.Numerics.BigInteger -> q:System.Numerics.BigInteger -> Rational + val intToRational : int -> Rational + val ZeroRational : Rational + val OneRational : Rational + val AddRational : Rational -> Rational -> Rational + val NegRational : Rational -> Rational + val MulRational : Rational -> Rational -> Rational + val DivRational : Rational -> Rational -> Rational + val AbsRational : Rational -> Rational + val RationalToString : Rational -> string + val GcdRational : Rational -> Rational -> Rational + val GetNumerator : Rational -> int + val GetDenominator : Rational -> int + val SignRational : Rational -> int + end + +namespace Internal.Utilities + type PathMap = | PathMap of Map + module internal PathMap = begin + val dirSepStr : string + val empty : PathMap + val addMapping : string -> string -> PathMap -> PathMap + val apply : PathMap -> string -> string + val applyDir : PathMap -> string -> string + end + +namespace Internal.Utilities + module internal RidHelpers = begin + val probingRids : string [] + val platformRid : string + val baseRid : string + end + +namespace FSharp.Compiler + module Range = begin + type FileIndex = int32 + [] + val columnBitCount : int = 20 + [] + val lineBitCount : int = 31 + val posBitCount : int + val posColumnMask : int64 + val lineColumnMask : int64 + [] + type pos = + struct + new : l:int * c:int -> pos + new : code:int64 -> pos + static member Decode : int64 -> pos + override Equals : obj:obj -> bool + override GetHashCode : unit -> int + override ToString : unit -> string + member Column : int32 + member Encoding : int64 + member Line : int32 + static member EncodingSize : int + end + [] + val fileIndexBitCount : int = 24 + [] + val startColumnBitCount : int = 20 + [] + val endColumnBitCount : int = 20 + [] + val startLineBitCount : int = 31 + [] + val heightBitCount : int = 27 + [] + val isSyntheticBitCount : int = 1 + [] + val fileIndexShift : int = 0 + [] + val startColumnShift : int = 24 + [] + val endColumnShift : int = 44 + [] + val startLineShift : int = 0 + [] + val heightShift : int = 31 + [] + val isSyntheticShift : int = 58 + [] + val fileIndexMask : int64 = 16777215L + [] + val startColumnMask : int64 = 17592169267200L + [] + val endColumnMask : int64 = -17592186044416L + [] + val startLineMask : int64 = 2147483647L + [] + val heightMask : int64 = 288230374004228096L + [] + val isSyntheticMask : int64 = 288230376151711744L + val normalizeFilePath : filePath:string -> string + type FileIndexTable = + class + new : unit -> FileIndexTable + member FileToIndex : normalize:bool -> filePath:string -> int + member IndexToFile : n:int -> string + end + val maxFileIndex : int + val fileIndexTable : FileIndexTable + val fileIndexOfFileAux : normalize:bool -> f:string -> int + val fileIndexOfFile : filePath:string -> int + val fileOfFileIndex : int -> string + val mkPos : line:int -> column:int -> pos + val unknownFileName : string + val startupFileName : string + val commandLineArgsFileName : string + [ {DebugCode}")>] + type range = + struct + new : fIdx:int32 * b:pos * e:pos -> range + new : fIdx:int32 * bl:int32 * bc:int32 * el:int32 * ec:int32 -> range + new : code1:int64 * code2:int64 -> range + override Equals : obj:obj -> bool + override GetHashCode : unit -> int + member MakeSynthetic : unit -> range + member ToShortString : unit -> string + override ToString : unit -> string + member Code1 : int64 + member Code2 : int64 + member DebugCode : string + member End : pos + member EndColumn : int32 + member EndLine : int32 + member EndRange : range + member FileIndex : int32 + member FileName : string + member IsSynthetic : bool + member ShortFileName : string + member Start : pos + member StartColumn : int32 + member StartLine : int32 + member StartRange : range + static member Zero : range + end + val mkRange : string -> pos -> pos -> range + val equals : range -> range -> bool + val mkFileIndexRange : int32 -> pos -> pos -> range + val posOrder : System.Collections.Generic.IComparer + val rangeOrder : System.Collections.Generic.IComparer + val outputPos : System.IO.TextWriter -> pos -> unit + val outputRange : System.IO.TextWriter -> range -> unit + val posGt : pos -> pos -> bool + val posEq : pos -> pos -> bool + val posGeq : pos -> pos -> bool + val posLt : pos -> pos -> bool + val unionRanges : range -> range -> range + val rangeContainsRange : range -> range -> bool + val rangeContainsPos : range -> pos -> bool + val rangeBeforePos : range -> pos -> bool + val rangeN : string -> int -> range + val pos0 : pos + val range0 : range + val rangeStartup : range + val rangeCmdArgs : range + val trimRangeToLine : range -> range + val stringOfPos : pos -> string + val stringOfRange : range -> string + type Line0 = int + type Pos01 = Line0 * int + type Range01 = Pos01 * Pos01 + module Line = begin + val fromZ : Line0 -> int + val toZ : int -> Line0 + end + module Pos = begin + val fromZ : line:Line0 -> column:int -> pos + val toZ : pos -> Line0 * int32 + end + module Range = begin + val toZ : range -> (Line0 * int32) * (Line0 * int32) + val toFileZ : range -> string * ((Line0 * int32) * (Line0 * int32)) + val comparer : System.Collections.Generic.IEqualityComparer + end + end + +namespace FSharp.Compiler + module ErrorLogger = begin + [] + type ErrorStyle = + | DefaultErrors + | EmacsErrors + | TestErrors + | VSErrors + | GccErrors + exception WrappedError of exn * Range.range + exception ReportedError of exn option + val findOriginalException : err:exn -> exn + type Suggestions = (string -> unit) -> unit + val NoSuggestions : Suggestions + exception StopProcessingExn of exn option + val ( |StopProcessing|_| ) : exn:exn -> unit option + val StopProcessing<'T> : exn + exception NumberedError of (int * string) * Range.range + exception Error of (int * string) * Range.range + exception InternalError of msg: string * Range.range + exception UserCompilerMessage of string * int * Range.range + exception LibraryUseOnly of Range.range + exception Deprecated of string * Range.range + exception Experimental of string * Range.range + exception PossibleUnverifiableCode of Range.range + exception UnresolvedReferenceNoRange of string + exception UnresolvedReferenceError of string * Range.range + exception UnresolvedPathReferenceNoRange of string * string + exception UnresolvedPathReference of string * string * Range.range + exception ErrorWithSuggestions of + (int * string) * Range.range * string * + Suggestions + val inline protectAssemblyExploration : dflt:'a -> f:(unit -> 'a) -> 'a + val inline protectAssemblyExplorationF : + dflt:(string * string -> 'a) -> f:(unit -> 'a) -> 'a + val inline protectAssemblyExplorationNoReraise : + dflt1:'a -> dflt2:'a -> f:(unit -> 'a) -> 'a + val AttachRange : m:Range.range -> exn:exn -> exn + type Exiter = + interface + abstract member Exit : int -> 'T + end + val QuitProcessExiter : Exiter + [] + type BuildPhase = + | DefaultPhase + | Compile + | Parameter + | Parse + | TypeCheck + | CodeGen + | Optimize + | IlxGen + | IlGen + | Output + | Interactive + module BuildPhaseSubcategory = begin + [] + val DefaultPhase : string = "" + [] + val Compile : string = "compile" + [] + val Parameter : string = "parameter" + [] + val Parse : string = "parse" + [] + val TypeCheck : string = "typecheck" + [] + val CodeGen : string = "codegen" + [] + val Optimize : string = "optimize" + [] + val IlxGen : string = "ilxgen" + [] + val IlGen : string = "ilgen" + [] + val Output : string = "output" + [] + val Interactive : string = "interactive" + [] + val Internal : string = "internal" + end + [] + type PhasedDiagnostic = + { Exception: exn + Phase: BuildPhase } + with + static member Create : exn:exn * phase:BuildPhase -> PhasedDiagnostic + static member IsSubcategoryOfCompile : subcategory:string -> bool + member DebugDisplay : unit -> string + member IsPhaseInCompile : unit -> bool + member Subcategory : unit -> string + end + [] + type ErrorLogger = + class + new : nameForDebugging:string -> ErrorLogger + member DebugDisplay : unit -> string + abstract member + DiagnosticSink : phasedError:PhasedDiagnostic * isError:bool -> unit + abstract member ErrorCount : int + end + val DiscardErrorsLogger : ErrorLogger + val AssertFalseErrorLogger : ErrorLogger + type CapturingErrorLogger = + class + inherit ErrorLogger + new : nm:string -> CapturingErrorLogger + member CommitDelayedDiagnostics : errorLogger:ErrorLogger -> unit + override + DiagnosticSink : phasedError:PhasedDiagnostic * isError:bool -> unit + member Diagnostics : (PhasedDiagnostic * bool) list + override ErrorCount : int + end + [] + type internal CompileThreadStatic = + class + static member BuildPhase : BuildPhase + static member BuildPhaseUnchecked : BuildPhase + static member ErrorLogger : ErrorLogger + static val mutable private buildPhase: BuildPhase + static val mutable private errorLogger: ErrorLogger + end + module ErrorLoggerExtensions = begin + val tryAndDetectDev15 : bool + val PreserveStackTrace : exn:'a -> unit + val ReraiseIfWatsonable : exn:exn -> unit + type ErrorLogger with + member ErrorR : exn:exn -> unit + type ErrorLogger with + member Warning : exn:exn -> unit + type ErrorLogger with + member Error : exn:exn -> 'b + type ErrorLogger with + member SimulateError : ph:PhasedDiagnostic -> 'a + type ErrorLogger with + member ErrorRecovery : exn:exn -> m:Range.range -> unit + type ErrorLogger with + member StopProcessingRecovery : exn:exn -> m:Range.range -> unit + type ErrorLogger with + member ErrorRecoveryNoRange : exn:exn -> unit + end + val PushThreadBuildPhaseUntilUnwind : phase:BuildPhase -> System.IDisposable + val PushErrorLoggerPhaseUntilUnwind : + errorLoggerTransformer:(ErrorLogger -> #ErrorLogger) -> System.IDisposable + val SetThreadBuildPhaseNoUnwind : phase:BuildPhase -> unit + val SetThreadErrorLoggerNoUnwind : errorLogger:ErrorLogger -> unit + val errorR : exn:exn -> unit + val warning : exn:exn -> unit + val error : exn:exn -> 'a + val simulateError : p:PhasedDiagnostic -> 'a + val diagnosticSink : phasedError:PhasedDiagnostic * isError:bool -> unit + val errorSink : pe:PhasedDiagnostic -> unit + val warnSink : pe:PhasedDiagnostic -> unit + val errorRecovery : exn:exn -> m:Range.range -> unit + val stopProcessingRecovery : exn:exn -> m:Range.range -> unit + val errorRecoveryNoRange : exn:exn -> unit + val report : f:(unit -> 'a) -> 'a + val deprecatedWithError : s:string -> m:Range.range -> unit + val mutable reportLibraryOnlyFeatures : bool + val libraryOnlyError : m:Range.range -> unit + val libraryOnlyWarning : m:Range.range -> unit + val deprecatedOperator : m:Range.range -> unit + val mlCompatWarning : s:System.String -> m:Range.range -> unit + val suppressErrorReporting : f:(unit -> 'a) -> 'a + val conditionallySuppressErrorReporting : cond:bool -> f:(unit -> 'a) -> 'a + [] + type OperationResult<'T> = + | OkResult of warnings: exn list * 'T + | ErrorResult of warnings: exn list * exn + type ImperativeOperationResult = OperationResult + val ReportWarnings : warns:#exn list -> unit + val CommitOperationResult : res:OperationResult<'a> -> 'a + val RaiseOperationResult : res:OperationResult -> unit + val ErrorD : err:exn -> OperationResult<'a> + val WarnD : err:exn -> OperationResult + val CompleteD : OperationResult + val ResultD : x:'a -> OperationResult<'a> + val CheckNoErrorsAndGetWarnings : res:OperationResult<'a> -> exn list option + val ( ++ ) : + res:OperationResult<'a> -> + f:('a -> OperationResult<'b>) -> OperationResult<'b> + val IterateD : + f:('a -> OperationResult) -> xs:'a list -> OperationResult + val WhileD : + gd:(unit -> bool) -> + body:(unit -> OperationResult) -> OperationResult + val MapD : + f:('a -> OperationResult<'b>) -> xs:'a list -> OperationResult<'b list> + type TrackErrorsBuilder = + class + new : unit -> TrackErrorsBuilder + member + Bind : res:OperationResult<'h> * k:('h -> OperationResult<'i>) -> + OperationResult<'i> + member + Combine : expr1:OperationResult<'c> * + expr2:('c -> OperationResult<'d>) -> OperationResult<'d> + member Delay : fn:(unit -> 'b) -> (unit -> 'b) + member + For : seq:'e list * k:('e -> OperationResult) -> + OperationResult + member Return : res:'g -> OperationResult<'g> + member ReturnFrom : res:'f -> 'f + member Run : fn:(unit -> 'a) -> 'a + member + While : gd:(unit -> bool) * k:(unit -> OperationResult) -> + OperationResult + member Zero : unit -> OperationResult + end + val trackErrors : TrackErrorsBuilder + val OptionD : + f:('a -> OperationResult) -> xs:'a option -> OperationResult + val IterateIdxD : + f:(int -> 'a -> OperationResult) -> + xs:'a list -> OperationResult + val Iterate2D : + f:('a -> 'b -> OperationResult) -> + xs:'a list -> ys:'b list -> OperationResult + val TryD : + f:(unit -> OperationResult<'a>) -> + g:(exn -> OperationResult<'a>) -> OperationResult<'a> + val RepeatWhileD : + nDeep:int -> body:(int -> OperationResult) -> OperationResult + val AtLeastOneD : + f:('a -> OperationResult) -> l:'a list -> OperationResult + module OperationResult = begin + val inline ignore : res:OperationResult<'a> -> OperationResult + end + val stringThatIsAProxyForANewlineInFlatErrors : System.String + val NewlineifyErrorString : message:string -> string + val NormalizeErrorString : text:string -> string + type FSharpErrorSeverityOptions = + { WarnLevel: int + GlobalWarnAsError: bool + WarnOff: int list + WarnOn: int list + WarnAsError: int list + WarnAsWarn: int list } + with + static member Default : FSharpErrorSeverityOptions + end + val private tryLanguageFeatureErrorAux : + langVersion:Features.LanguageVersion -> + langFeature:Features.LanguageFeature -> m:Range.range -> exn option + val internal checkLanguageFeatureError : + langVersion:Features.LanguageVersion -> + langFeature:Features.LanguageFeature -> m:Range.range -> unit + val internal checkLanguageFeatureErrorRecover : + langVersion:Features.LanguageVersion -> + langFeature:Features.LanguageFeature -> m:Range.range -> unit + val internal tryLanguageFeatureErrorOption : + langVersion:Features.LanguageVersion -> + langFeature:Features.LanguageFeature -> m:Range.range -> exn option + val internal languageFeatureNotSupportedInLibraryError : + langVersion:Features.LanguageVersion -> + langFeature:Features.LanguageFeature -> m:Range.range -> 'a + end + +namespace FSharp.Compiler + module internal ErrorResolutionHints = begin + val maxSuggestions : int + val minThresholdForSuggestions : float + val highConfidenceThreshold : float + val minStringLengthForSuggestion : int + val IsInEditDistanceProximity : idText:string -> suggestion:string -> bool + val DemangleOperator : nm:string -> string + type SuggestionBufferEnumerator = + class + interface System.IDisposable + interface System.Collections.IEnumerator + interface System.Collections.Generic.IEnumerator + new : tail:int * + data:System.Collections.Generic.KeyValuePair [] -> + SuggestionBufferEnumerator + end + type SuggestionBuffer = + class + interface System.Collections.IEnumerable + interface System.Collections.Generic.IEnumerable + new : idText:string -> SuggestionBuffer + member Add : suggestion:string -> unit + member Disabled : bool + member IsEmpty : bool + end + end + +namespace FSharp.Compiler.AbstractIL + module IL = begin + val logging : bool + val int_order : System.Collections.Generic.IComparer + val notlazy : v:'a -> System.Lazy<'a> + val lazyMap : f:('a -> 'b) -> x:System.Lazy<'a> -> System.Lazy<'b> + [] + type PrimaryAssembly = + | Mscorlib + | System_Runtime + | NetStandard + with + member Name : string + end + val splitNameAt : nm:string -> idx:int -> string * string + val splitNamespaceAux : nm:string -> string list + val memoizeNamespaceTable : + System.Collections.Concurrent.ConcurrentDictionary + val memoizeNamespaceRightTable : + System.Collections.Concurrent.ConcurrentDictionary + val splitNamespace : string -> string list + val splitNamespaceMemoized : nm:string -> string list + val memoizeNamespaceArrayTable : + System.Collections.Concurrent.ConcurrentDictionary + val splitNamespaceToArray : string -> string [] + val splitILTypeName : string -> string list * string + val emptyStringArray : string [] + val splitILTypeNameWithPossibleStaticArguments : + string -> string [] * string + val unsplitTypeName : ns:string list * n:string -> string + val splitTypeNameRightAux : nm:string -> string option * string + val splitTypeNameRight : string -> string option * string + type LazyOrderedMultiMap<'Key,'Data when 'Key : equality> = + class + new : keyf:('Data -> 'Key) * lazyItems:System.Lazy<'Data list> -> + LazyOrderedMultiMap<'Key,'Data> + member Add : y:'Data -> LazyOrderedMultiMap<'Key,'Data> + member Entries : unit -> 'Data list + member Filter : f:('Data -> bool) -> LazyOrderedMultiMap<'Key,'Data> + member Item : x:'Key -> 'Data list with get + end + val b0 : n:int -> int + val b1 : n:int -> int + val b2 : n:int -> int + val b3 : n:int -> int + module SHA1 = begin + val inline ( >>>& ) : x:int -> y:int -> int32 + val f : t:int * b:int * c:int * d:int -> int + [] + val k0to19 : int = 1518500249 + [] + val k20to39 : int = 1859775393 + [] + val k40to59 : int = -1894007588 + [] + val k60to79 : int = -899497514 + val k : t:int -> int + type SHAStream = + { stream: byte [] + mutable pos: int + mutable eof: bool } + val rotLeft32 : x:int32 -> n:int32 -> int32 + val shaAfterEof : sha:SHAStream -> int + val shaRead8 : sha:SHAStream -> int + val shaRead32 : sha:SHAStream -> int + val sha1Hash : sha:SHAStream -> int * int * int * int * int + val sha1HashBytes : s:byte [] -> byte [] + val sha1HashInt64 : s:byte [] -> int64 + end + val sha1HashBytes : byte [] -> byte [] + val sha1HashInt64 : byte [] -> int64 + [] + type ILVersionInfo = + struct + new : major:uint16 * minor:uint16 * build:uint16 * revision:uint16 -> + ILVersionInfo + val Major: uint16 + val Minor: uint16 + val Build: uint16 + val Revision: uint16 + override ToString : unit -> string + end + type Locale = string + [] + type PublicKey = + | PublicKey of byte [] + | PublicKeyToken of byte [] + with + static member KeyAsToken : byte [] -> PublicKey + member ToToken : unit -> byte [] + member IsKey : bool + member IsKeyToken : bool + member Key : byte [] + member KeyToken : byte [] + end + [] + type AssemblyRefData = + { assemRefName: string + assemRefHash: byte [] option + assemRefPublicKeyInfo: PublicKey option + assemRefRetargetable: bool + assemRefVersion: ILVersionInfo option + assemRefLocale: Locale option } + val AssemblyRefUniqueStampGenerator : + Internal.Library.UniqueStampGenerator + val isMscorlib : data:AssemblyRefData -> bool + [] + type ILAssemblyRef = + class + interface System.IComparable + new : data:AssemblyRefData -> ILAssemblyRef + static member + Create : name:string * hash:byte [] option * + publicKey:PublicKey option * retargetable:bool * + version:ILVersionInfo option * locale:Locale option -> + ILAssemblyRef + static member + FromAssemblyName : System.Reflection.AssemblyName -> ILAssemblyRef + override Equals : yobj:obj -> bool + member EqualsIgnoringVersion : ILAssemblyRef -> bool + override GetHashCode : unit -> int + member Hash : byte [] option + member Locale : Locale option + member Name : string + member PublicKey : PublicKey option + member QualifiedName : string + member Retargetable : bool + member UniqueIgnoringVersionStamp : int + member UniqueStamp : int + member Version : ILVersionInfo option + end + [] + type ILModuleRef = + { name: string + hasMetadata: bool + hash: byte [] option } + with + static member + Create : name:string * hasMetadata:bool * hash:byte [] option -> + ILModuleRef + member HasMetadata : bool + member Hash : byte [] option + member Name : string + end + [] + type ILScopeRef = + | Local + | Module of ILModuleRef + | Assembly of ILAssemblyRef + | PrimaryAssembly + with + member IsLocalRef : bool + member QualifiedName : string + end + type ILArrayBound = int32 option + type ILArrayBounds = ILArrayBound * ILArrayBound + [] + type ILArrayShape = + | ILArrayShape of ILArrayBounds list + with + static member FromRank : int -> ILArrayShape + member Rank : int + static member SingleDimensional : ILArrayShape + end + and ILArrayShapeStatics = + class + new : unit -> ILArrayShapeStatics + static member SingleDimensional : ILArrayShape + end + [] + type ILArgConvention = + | Default + | CDecl + | StdCall + | ThisCall + | FastCall + | VarArg + [] + type ILThisConvention = + | Instance + | InstanceExplicit + | Static + [] + type ILCallingConv = + | Callconv of ILThisConvention * ILArgConvention + with + member BasicConv : ILArgConvention + member IsInstance : bool + member IsInstanceExplicit : bool + member IsStatic : bool + member ThisConv : ILThisConvention + static member Instance : ILCallingConv + static member Static : ILCallingConv + end + and ILCallingConvStatics = + class + new : unit -> ILCallingConvStatics + static member Instance : ILCallingConv + static member Static : ILCallingConv + end + type ILBoxity = + | AsObject + | AsValue + [] + type ILTypeRef = + { trefScope: ILScopeRef + trefEnclosing: string list + trefName: string + hashCode: int + mutable asBoxedType: ILType } + with + interface System.IComparable + static member + ComputeHash : scope:'a * enclosing:'b * name:'c -> int + when 'a : equality and 'b : equality and 'c : equality + static member + Create : scope:ILScopeRef * enclosing:string list * name:string -> + ILTypeRef + member AddQualifiedNameExtension : basic:string -> string + member AsBoxedType : tspec:ILTypeSpec -> ILType + override Equals : yobj:obj -> bool + member EqualsWithPrimaryScopeRef : ILScopeRef * obj -> bool + override GetHashCode : unit -> int + override ToString : unit -> string + member ApproxId : int + member BasicQualifiedName : string + [ (0))>] + member DebugText : string + member Enclosing : string list + member FullName : string + member Name : string + member QualifiedName : string + member Scope : ILScopeRef + end + [] + and ILTypeSpec = + { tspecTypeRef: ILTypeRef + tspecInst: ILGenericArgs } + with + static member + Create : typeRef:ILTypeRef * instantiation:ILGenericArgs -> ILTypeSpec + member AddQualifiedNameExtension : basic:string -> string + member EqualsWithPrimaryScopeRef : ILScopeRef * obj -> bool + override ToString : unit -> string + member BasicQualifiedName : string + [ (0))>] + member DebugText : string + member Enclosing : string list + member FullName : string + member GenericArgs : ILGenericArgs + member Name : string + member Scope : ILScopeRef + member TypeRef : ILTypeRef + end + [] + and ILType = + | Void + | Array of ILArrayShape * ILType + | Value of ILTypeSpec + | Boxed of ILTypeSpec + | Ptr of ILType + | Byref of ILType + | FunctionPointer of ILCallingSignature + | TypeVar of uint16 + | Modified of bool * ILTypeRef * ILType + with + member AddQualifiedNameExtension : basic:string -> string + override ToString : unit -> string + member BasicQualifiedName : string + member Boxity : ILBoxity + [ (0))>] + member DebugText : string + member GenericArgs : ILGenericArgs + member IsNominal : bool + member IsTyvar : bool + member QualifiedName : string + member TypeRef : ILTypeRef + member TypeSpec : ILTypeSpec + end + [] + and ILCallingSignature = + { CallingConv: ILCallingConv + ArgTypes: ILTypes + ReturnType: ILType } + and ILGenericArgs = ILType list + and ILTypes = ILType list + val mkILCallSig : ILCallingConv * ILTypes * ILType -> ILCallingSignature + val mkILBoxedType : ILTypeSpec -> ILType + [] + type ILMethodRef = + { mrefParent: ILTypeRef + mrefCallconv: ILCallingConv + mrefGenericArity: int + mrefName: string + mrefArgs: ILTypes + mrefReturn: ILType } + with + static member + Create : enclosingTypeRef:ILTypeRef * callingConv:ILCallingConv * + name:string * genericArity:int * argTypes:ILTypes * + returnType:ILType -> ILMethodRef + override ToString : unit -> string + member ArgCount : int + member ArgTypes : ILTypes + member CallingConv : ILCallingConv + member CallingSignature : ILCallingSignature + [ (0))>] + member DebugText : string + member DeclaringTypeRef : ILTypeRef + member GenericArity : int + member Name : string + member ReturnType : ILType + end + [] + type ILFieldRef = + { DeclaringTypeRef: ILTypeRef + Name: string + Type: ILType } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + type ILMethodSpec = + { mspecMethodRef: ILMethodRef + mspecDeclaringType: ILType + mspecMethodInst: ILGenericArgs } + with + static member + Create : ILType * ILMethodRef * ILGenericArgs -> ILMethodSpec + override ToString : unit -> string + member CallingConv : ILCallingConv + [ (0))>] + member DebugText : string + member DeclaringType : ILType + member FormalArgTypes : ILTypes + member FormalReturnType : ILType + member GenericArgs : ILGenericArgs + member GenericArity : int + member MethodRef : ILMethodRef + member Name : string + end + [] + type ILFieldSpec = + { FieldRef: ILFieldRef + DeclaringType: ILType } + with + override ToString : unit -> string + member ActualType : ILType + [ (0))>] + member DebugText : string + member DeclaringTypeRef : ILTypeRef + member FormalType : ILType + member Name : string + end + type ILGuid = byte [] + [] + type ILPlatform = + | X86 + | AMD64 + | IA64 + [] + type ILSourceDocument = + { sourceLanguage: ILGuid option + sourceVendor: ILGuid option + sourceDocType: ILGuid option + sourceFile: string } + with + static member + Create : language:ILGuid option * vendor:ILGuid option * + documentType:ILGuid option * file:string -> ILSourceDocument + member DocumentType : ILGuid option + member File : string + member Language : ILGuid option + member Vendor : ILGuid option + end + [] + type ILSourceMarker = + { sourceDocument: ILSourceDocument + sourceLine: int + sourceColumn: int + sourceEndLine: int + sourceEndColumn: int } + with + static member + Create : document:ILSourceDocument * line:int * column:int * + endLine:int * endColumn:int -> ILSourceMarker + override ToString : unit -> string + member Column : int + [ (0))>] + member DebugText : string + member Document : ILSourceDocument + member EndColumn : int + member EndLine : int + member Line : int + end + [] + type ILAttribElem = + | String of string option + | Bool of bool + | Char of char + | SByte of int8 + | Int16 of int16 + | Int32 of int32 + | Int64 of int64 + | Byte of uint8 + | UInt16 of uint16 + | UInt32 of uint32 + | UInt64 of uint64 + | Single of single + | Double of double + | Null + | Type of ILType option + | TypeRef of ILTypeRef option + | Array of ILType * ILAttribElem list + type ILAttributeNamedArg = string * ILType * bool * ILAttribElem + [] + type ILAttribute = + | Encoded of + method: ILMethodSpec * data: byte [] * elements: ILAttribElem list + | Decoded of + method: ILMethodSpec * fixedArgs: ILAttribElem list * + namedArgs: ILAttributeNamedArg list + with + override ToString : unit -> string + member WithMethod : method:ILMethodSpec -> ILAttribute + [ (0))>] + member DebugText : string + member Elements : ILAttribElem list + member Method : ILMethodSpec + end + [] + type ILAttributes = + struct + new : array:ILAttribute [] -> ILAttributes + member AsArray : ILAttribute [] + member AsList : ILAttribute list + end + [] + type ILAttributesStored = + | Reader of (int32 -> ILAttribute []) + | Given of ILAttributes + with + member GetCustomAttrs : metadataIndex:int32 -> ILAttributes + end + val emptyILCustomAttrs : ILAttributes + val mkILCustomAttrsFromArray : ILAttribute [] -> ILAttributes + val mkILCustomAttrs : ILAttribute list -> ILAttributes + val emptyILCustomAttrsStored : ILAttributesStored + val storeILCustomAttrs : ILAttributes -> ILAttributesStored + val mkILCustomAttrsReader : (int32 -> ILAttribute []) -> ILAttributesStored + type ILCodeLabel = int + [] + type ILBasicType = + | DT_R + | DT_I1 + | DT_U1 + | DT_I2 + | DT_U2 + | DT_I4 + | DT_U4 + | DT_I8 + | DT_U8 + | DT_R4 + | DT_R8 + | DT_I + | DT_U + | DT_REF + [] + type ILToken = + | ILType of ILType + | ILMethod of ILMethodSpec + | ILField of ILFieldSpec + [] + type ILConst = + | I4 of int32 + | I8 of int64 + | R4 of single + | R8 of double + type ILTailcall = + | Tailcall + | Normalcall + type ILAlignment = + | Aligned + | Unaligned1 + | Unaligned2 + | Unaligned4 + type ILVolatility = + | Volatile + | Nonvolatile + type ILReadonly = + | ReadonlyAddress + | NormalAddress + type ILVarArgs = ILTypes option + [] + type ILComparisonInstr = + | BI_beq + | BI_bge + | BI_bge_un + | BI_bgt + | BI_bgt_un + | BI_ble + | BI_ble_un + | BI_blt + | BI_blt_un + | BI_bne_un + | BI_brfalse + | BI_brtrue + [] + type ILInstr = + | AI_add + | AI_add_ovf + | AI_add_ovf_un + | AI_and + | AI_div + | AI_div_un + | AI_ceq + | AI_cgt + | AI_cgt_un + | AI_clt + | AI_clt_un + | AI_conv of ILBasicType + | AI_conv_ovf of ILBasicType + | AI_conv_ovf_un of ILBasicType + | AI_mul + | AI_mul_ovf + | AI_mul_ovf_un + | AI_rem + | AI_rem_un + | AI_shl + | AI_shr + | AI_shr_un + | AI_sub + | AI_sub_ovf + | AI_sub_ovf_un + | AI_xor + | AI_or + | AI_neg + | AI_not + | AI_ldnull + | AI_dup + | AI_pop + | AI_ckfinite + | AI_nop + | AI_ldc of ILBasicType * ILConst + | I_ldarg of uint16 + | I_ldarga of uint16 + | I_ldind of ILAlignment * ILVolatility * ILBasicType + | I_ldloc of uint16 + | I_ldloca of uint16 + | I_starg of uint16 + | I_stind of ILAlignment * ILVolatility * ILBasicType + | I_stloc of uint16 + | I_br of ILCodeLabel + | I_jmp of ILMethodSpec + | I_brcmp of ILComparisonInstr * ILCodeLabel + | I_switch of ILCodeLabel list + | I_ret + | I_call of ILTailcall * ILMethodSpec * ILVarArgs + | I_callvirt of ILTailcall * ILMethodSpec * ILVarArgs + | I_callconstraint of ILTailcall * ILType * ILMethodSpec * ILVarArgs + | I_calli of ILTailcall * ILCallingSignature * ILVarArgs + | I_ldftn of ILMethodSpec + | I_newobj of ILMethodSpec * ILVarArgs + | I_throw + | I_endfinally + | I_endfilter + | I_leave of ILCodeLabel + | I_rethrow + | I_ldsfld of ILVolatility * ILFieldSpec + | I_ldfld of ILAlignment * ILVolatility * ILFieldSpec + | I_ldsflda of ILFieldSpec + | I_ldflda of ILFieldSpec + | I_stsfld of ILVolatility * ILFieldSpec + | I_stfld of ILAlignment * ILVolatility * ILFieldSpec + | I_ldstr of string + | I_isinst of ILType + | I_castclass of ILType + | I_ldtoken of ILToken + | I_ldvirtftn of ILMethodSpec + | I_cpobj of ILType + | I_initobj of ILType + | I_ldobj of ILAlignment * ILVolatility * ILType + | I_stobj of ILAlignment * ILVolatility * ILType + | I_box of ILType + | I_unbox of ILType + | I_unbox_any of ILType + | I_sizeof of ILType + | I_ldelem of ILBasicType + | I_stelem of ILBasicType + | I_ldelema of ILReadonly * bool * ILArrayShape * ILType + | I_ldelem_any of ILArrayShape * ILType + | I_stelem_any of ILArrayShape * ILType + | I_newarr of ILArrayShape * ILType + | I_ldlen + | I_mkrefany of ILType + | I_refanytype + | I_refanyval of ILType + | I_break + | I_seqpoint of ILSourceMarker + | I_arglist + | I_localloc + | I_cpblk of ILAlignment * ILVolatility + | I_initblk of ILAlignment * ILVolatility + | EI_ilzero of ILType + | EI_ldlen_multi of int32 * int32 + [] + type ILExceptionClause = + | Finally of (ILCodeLabel * ILCodeLabel) + | Fault of (ILCodeLabel * ILCodeLabel) + | FilterCatch of + filterRange: ILCodeLabel * ILCodeLabel * + handlerRange: ILCodeLabel * ILCodeLabel + | TypeCatch of ILType * (ILCodeLabel * ILCodeLabel) + [] + type ILExceptionSpec = + { Range: ILCodeLabel * ILCodeLabel + Clause: ILExceptionClause } + [] + type ILLocalDebugMapping = + { LocalIndex: int + LocalName: string } + [] + type ILLocalDebugInfo = + { Range: ILCodeLabel * ILCodeLabel + DebugMappings: ILLocalDebugMapping list } + [] + type ILCode = + { Labels: System.Collections.Generic.Dictionary + Instrs: ILInstr [] + Exceptions: ILExceptionSpec list + Locals: ILLocalDebugInfo list } + [] + type ILLocal = + { Type: ILType + IsPinned: bool + DebugInfo: (string * int * int) option } + type ILLocals = ILLocal list + [] + type ILMethodBody = + { IsZeroInit: bool + MaxStack: int32 + NoInlining: bool + AggressiveInlining: bool + Locals: ILLocals + Code: ILCode + SourceMarker: ILSourceMarker option } + [] + type ILMemberAccess = + | Assembly + | CompilerControlled + | FamilyAndAssembly + | FamilyOrAssembly + | Family + | Private + | Public + [] + type ILFieldInit = + | String of string + | Bool of bool + | Char of uint16 + | Int8 of int8 + | Int16 of int16 + | Int32 of int32 + | Int64 of int64 + | UInt8 of uint8 + | UInt16 of uint16 + | UInt32 of uint32 + | UInt64 of uint64 + | Single of single + | Double of double + | Null + with + member AsObject : unit -> obj + end + [] + type ILNativeType = + | Empty + | Custom of + ILGuid * nativeTypeName: string * custMarshallerName: string * + cookieString: byte [] + | FixedSysString of int32 + | FixedArray of int32 + | Currency + | LPSTR + | LPWSTR + | LPTSTR + | LPUTF8STR + | ByValStr + | TBSTR + | LPSTRUCT + | Struct + | Void + | Bool + | Int8 + | Int16 + | Int32 + | Int64 + | Single + | Double + | Byte + | UInt16 + | UInt32 + | UInt64 + | Array of ILNativeType option * (int32 * int32 option) option + | Int + | UInt + | Method + | AsAny + | BSTR + | IUnknown + | IDispatch + | Interface + | Error + | SafeArray of ILNativeVariant * string option + | ANSIBSTR + | VariantBool + [] + and ILNativeVariant = + | Empty + | Null + | Variant + | Currency + | Decimal + | Date + | BSTR + | LPSTR + | LPWSTR + | IUnknown + | IDispatch + | SafeArray + | Error + | HRESULT + | CArray + | UserDefined + | Record + | FileTime + | Blob + | Stream + | Storage + | StreamedObject + | StoredObject + | BlobObject + | CF + | CLSID + | Void + | Bool + | Int8 + | Int16 + | Int32 + | Int64 + | Single + | Double + | UInt8 + | UInt16 + | UInt32 + | UInt64 + | PTR + | Array of ILNativeVariant + | Vector of ILNativeVariant + | Byref of ILNativeVariant + | Int + | UInt + [] + type ILSecurityAction = + | Request + | Demand + | Assert + | Deny + | PermitOnly + | LinkCheck + | InheritCheck + | ReqMin + | ReqOpt + | ReqRefuse + | PreJitGrant + | PreJitDeny + | NonCasDemand + | NonCasLinkDemand + | NonCasInheritance + | LinkDemandChoice + | InheritanceDemandChoice + | DemandChoice + [] + type ILSecurityDecl = | ILSecurityDecl of ILSecurityAction * byte [] + [] + type ILSecurityDecls = + struct + new : array:ILSecurityDecl [] -> ILSecurityDecls + member AsArray : ILSecurityDecl [] + member AsList : ILSecurityDecl list + end + [] + type ILSecurityDeclsStored = + | Reader of (int32 -> ILSecurityDecl []) + | Given of ILSecurityDecls + with + member GetSecurityDecls : metadataIndex:int32 -> ILSecurityDecls + end + val emptyILSecurityDecls : ILSecurityDecls + val emptyILSecurityDeclsStored : ILSecurityDeclsStored + val mkILSecurityDecls : ILSecurityDecl list -> ILSecurityDecls + val storeILSecurityDecls : ILSecurityDecls -> ILSecurityDeclsStored + val mkILSecurityDeclsReader : + (int32 -> ILSecurityDecl []) -> ILSecurityDeclsStored + [] + type PInvokeCharBestFit = + | UseAssembly + | Enabled + | Disabled + [] + type PInvokeThrowOnUnmappableChar = + | UseAssembly + | Enabled + | Disabled + [] + type PInvokeCallingConvention = + | None + | Cdecl + | Stdcall + | Thiscall + | Fastcall + | WinApi + [] + type PInvokeCharEncoding = + | None + | Ansi + | Unicode + | Auto + [] + type PInvokeMethod = + { Where: ILModuleRef + Name: string + CallingConv: PInvokeCallingConvention + CharEncoding: PInvokeCharEncoding + NoMangle: bool + LastError: bool + ThrowOnUnmappableChar: PInvokeThrowOnUnmappableChar + CharBestFit: PInvokeCharBestFit } + [] + type ILParameter = + { Name: string option + Type: ILType + Default: ILFieldInit option + Marshal: ILNativeType option + IsIn: bool + IsOut: bool + IsOptional: bool + CustomAttrsStored: ILAttributesStored + MetadataIndex: int32 } + with + member CustomAttrs : ILAttributes + end + type ILParameters = ILParameter list + [] + type ILReturn = + { Marshal: ILNativeType option + Type: ILType + CustomAttrsStored: ILAttributesStored + MetadataIndex: int32 } + with + member WithCustomAttrs : customAttrs:ILAttributes -> ILReturn + member CustomAttrs : ILAttributes + end + type ILOverridesSpec = + | OverridesSpec of ILMethodRef * ILType + with + member DeclaringType : ILType + member MethodRef : ILMethodRef + end + type ILMethodVirtualInfo = + { IsFinal: bool + IsNewSlot: bool + IsCheckAccessOnOverride: bool + IsAbstract: bool } + [] + type MethodKind = + | Static + | Cctor + | Ctor + | NonVirtual + | Virtual of ILMethodVirtualInfo + [] + type MethodBody = + | IL of ILMethodBody + | PInvoke of PInvokeMethod + | Abstract + | Native + | NotAvailable + [] + type ILLazyMethodBody = + | ILLazyMethodBody of System.Lazy + with + member Contents : MethodBody + end + [] + type MethodCodeKind = + | IL + | Native + | Runtime + val mkMethBodyAux : MethodBody -> ILLazyMethodBody + val mkMethBodyLazyAux : System.Lazy -> ILLazyMethodBody + val typesOfILParams : ILParameters -> ILTypes + [] + type ILGenericVariance = + | NonVariant + | CoVariant + | ContraVariant + [] + type ILGenericParameterDef = + { Name: string + Constraints: ILTypes + Variance: ILGenericVariance + HasReferenceTypeConstraint: bool + HasNotNullableValueTypeConstraint: bool + HasDefaultConstructorConstraint: bool + CustomAttrsStored: ILAttributesStored + MetadataIndex: int32 } + with + override ToString : unit -> string + member CustomAttrs : ILAttributes + [ (0))>] + member DebugText : string + end + type ILGenericParameterDefs = ILGenericParameterDef list + val memberAccessOfFlags : flags:int -> ILMemberAccess + val convertMemberAccess : + ilMemberAccess:ILMemberAccess -> System.Reflection.MethodAttributes + val inline conditionalAdd : + condition:bool -> flagToAdd: ^a -> source: ^a -> ^a + when ^a : (static member ( ~~~ ) : ^a -> ^a) and + ^a : (static member ( ||| ) : ^a * ^a -> ^a) and + ^a : (static member ( &&& ) : ^a * ^a -> ^a) + val NoMetadataIdx : int + [] + type ILMethodDef = + class + new : name:string * attributes:System.Reflection.MethodAttributes * + implAttributes:System.Reflection.MethodImplAttributes * + callingConv:ILCallingConv * parameters:ILParameters * ret:ILReturn * + body:ILLazyMethodBody * isEntryPoint:bool * + genericParams:ILGenericParameterDefs * + securityDecls:ILSecurityDecls * customAttrs:ILAttributes -> + ILMethodDef + new : name:string * attributes:System.Reflection.MethodAttributes * + implAttributes:System.Reflection.MethodImplAttributes * + callingConv:ILCallingConv * parameters:ILParameters * ret:ILReturn * + body:ILLazyMethodBody * isEntryPoint:bool * + genericParams:ILGenericParameterDefs * + securityDeclsStored:ILSecurityDeclsStored * + customAttrsStored:ILAttributesStored * metadataIndex:int32 -> + ILMethodDef + member + With : ?name:string * ?attributes:System.Reflection.MethodAttributes * + ?implAttributes:System.Reflection.MethodImplAttributes * + ?callingConv:ILCallingConv * ?parameters:ILParameters * + ?ret:ILReturn * ?body:ILLazyMethodBody * + ?securityDecls:ILSecurityDecls * ?isEntryPoint:bool * + ?genericParams:ILGenericParameterDefs * + ?customAttrs:ILAttributes -> ILMethodDef + member WithAbstract : bool -> ILMethodDef + member WithAccess : ILMemberAccess -> ILMethodDef + member WithAggressiveInlining : bool -> ILMethodDef + member WithFinal : bool -> ILMethodDef + member WithHideBySig : unit -> ILMethodDef + member WithHideBySig : bool -> ILMethodDef + member WithNoInlining : bool -> ILMethodDef + member WithPInvoke : bool -> ILMethodDef + member WithPreserveSig : bool -> ILMethodDef + member WithRuntime : bool -> ILMethodDef + member WithSecurity : bool -> ILMethodDef + member WithSynchronized : bool -> ILMethodDef + member Access : ILMemberAccess + member Attributes : System.Reflection.MethodAttributes + member Body : ILLazyMethodBody + member CallingConv : ILCallingConv + member CallingSignature : ILCallingSignature + member Code : ILCode option + member CustomAttrs : ILAttributes + member CustomAttrsStored : ILAttributesStored + member GenericParams : ILGenericParameterDefs + member HasSecurity : bool + member ImplAttributes : System.Reflection.MethodImplAttributes + member IsAbstract : bool + member IsAggressiveInline : bool + member IsCheckAccessOnOverride : bool + member IsClassInitializer : bool + member IsConstructor : bool + member IsEntryPoint : bool + member IsFinal : bool + member IsForwardRef : bool + member IsHideBySig : bool + member IsIL : bool + member IsInternalCall : bool + member IsManaged : bool + member IsMustRun : bool + member IsNewSlot : bool + member IsNoInline : bool + member IsNonVirtualInstance : bool + member IsPreserveSig : bool + member IsReqSecObj : bool + member IsSpecialName : bool + member IsStatic : bool + member IsSynchronized : bool + member IsUnmanagedExport : bool + member IsVirtual : bool + member IsZeroInit : bool + member Locals : ILLocals + member MaxStack : int32 + member MetadataIndex : int32 + member MethodBody : ILMethodBody + member Name : string + member ParameterTypes : ILTypes + member Parameters : ILParameters + member Return : ILReturn + member SecurityDecls : ILSecurityDecls + member SecurityDeclsStored : ILSecurityDeclsStored + member SourceMarker : ILSourceMarker option + member WithNewSlot : ILMethodDef + member WithSpecialName : ILMethodDef + end + type MethodDefMap = Map + [] + type ILMethodDefs = + class + interface System.Collections.Generic.IEnumerable + interface System.Collections.IEnumerable + new : f:(unit -> ILMethodDef []) -> ILMethodDefs + member FindByName : string -> ILMethodDef list + member FindByNameAndArity : nm:string * arity:int -> ILMethodDef list + member + TryFindInstanceByNameAndCallingSignature : string * ILCallingSignature -> + ILMethodDef option + member AsArray : ILMethodDef [] + member AsList : ILMethodDef list + end + [] + type ILEventDef = + class + new : eventType:ILType option * name:string * + attributes:System.Reflection.EventAttributes * + addMethod:ILMethodRef * removeMethod:ILMethodRef * + fireMethod:ILMethodRef option * otherMethods:ILMethodRef list * + customAttrs:ILAttributes -> ILEventDef + new : eventType:ILType option * name:string * + attributes:System.Reflection.EventAttributes * + addMethod:ILMethodRef * removeMethod:ILMethodRef * + fireMethod:ILMethodRef option * otherMethods:ILMethodRef list * + customAttrsStored:ILAttributesStored * metadataIndex:int32 -> + ILEventDef + override ToString : unit -> string + member + With : ?eventType:ILType option * ?name:string * + ?attributes:System.Reflection.EventAttributes * + ?addMethod:ILMethodRef * ?removeMethod:ILMethodRef * + ?fireMethod:ILMethodRef option * ?otherMethods:ILMethodRef list * + ?customAttrs:ILAttributes -> ILEventDef + member AddMethod : ILMethodRef + member Attributes : System.Reflection.EventAttributes + member CustomAttrs : ILAttributes + member CustomAttrsStored : ILAttributesStored + [ (0))>] + member DebugText : string + member EventType : ILType option + member FireMethod : ILMethodRef option + member IsRTSpecialName : bool + member IsSpecialName : bool + member MetadataIndex : int32 + member Name : string + member OtherMethods : ILMethodRef list + member RemoveMethod : ILMethodRef + end + [] + type ILEventDefs = + | ILEvents of LazyOrderedMultiMap + with + member LookupByName : string -> ILEventDef list + member AsList : ILEventDef list + end + [] + type ILPropertyDef = + class + new : name:string * attributes:System.Reflection.PropertyAttributes * + setMethod:ILMethodRef option * getMethod:ILMethodRef option * + callingConv:ILThisConvention * propertyType:ILType * + init:ILFieldInit option * args:ILTypes * customAttrs:ILAttributes -> + ILPropertyDef + new : name:string * attributes:System.Reflection.PropertyAttributes * + setMethod:ILMethodRef option * getMethod:ILMethodRef option * + callingConv:ILThisConvention * propertyType:ILType * + init:ILFieldInit option * args:ILTypes * + customAttrsStored:ILAttributesStored * metadataIndex:int32 -> + ILPropertyDef + override ToString : unit -> string + member + With : ?name:string * ?attributes:System.Reflection.PropertyAttributes * + ?setMethod:ILMethodRef option * ?getMethod:ILMethodRef option * + ?callingConv:ILThisConvention * ?propertyType:ILType * + ?init:ILFieldInit option * ?args:ILTypes * + ?customAttrs:ILAttributes -> ILPropertyDef + member Args : ILTypes + member Attributes : System.Reflection.PropertyAttributes + member CallingConv : ILThisConvention + member CustomAttrs : ILAttributes + member CustomAttrsStored : ILAttributesStored + [ (0))>] + member DebugText : string + member GetMethod : ILMethodRef option + member Init : ILFieldInit option + member IsRTSpecialName : bool + member IsSpecialName : bool + member MetadataIndex : int32 + member Name : string + member PropertyType : ILType + member SetMethod : ILMethodRef option + end + [] + type ILPropertyDefs = + | ILProperties of LazyOrderedMultiMap + with + member LookupByName : string -> ILPropertyDef list + member AsList : ILPropertyDef list + end + val convertFieldAccess : + ilMemberAccess:ILMemberAccess -> System.Reflection.FieldAttributes + [] + type ILFieldDef = + class + new : name:string * fieldType:ILType * + attributes:System.Reflection.FieldAttributes * data:byte [] option * + literalValue:ILFieldInit option * offset:int32 option * + marshal:ILNativeType option * customAttrs:ILAttributes -> + ILFieldDef + new : name:string * fieldType:ILType * + attributes:System.Reflection.FieldAttributes * data:byte [] option * + literalValue:ILFieldInit option * offset:int32 option * + marshal:ILNativeType option * customAttrsStored:ILAttributesStored * + metadataIndex:int32 -> ILFieldDef + member + With : ?name:string * ?fieldType:ILType * + ?attributes:System.Reflection.FieldAttributes * + ?data:byte [] option * ?literalValue:ILFieldInit option * + ?offset:int32 option * ?marshal:ILNativeType option * + ?customAttrs:ILAttributes -> ILFieldDef + member WithAccess : ILMemberAccess -> ILFieldDef + member WithFieldMarshal : ILNativeType option -> ILFieldDef + member WithInitOnly : bool -> ILFieldDef + member WithLiteralDefaultValue : ILFieldInit option -> ILFieldDef + member WithNotSerialized : bool -> ILFieldDef + member WithSpecialName : bool -> ILFieldDef + member WithStatic : bool -> ILFieldDef + member Access : ILMemberAccess + member Attributes : System.Reflection.FieldAttributes + member CustomAttrs : ILAttributes + member CustomAttrsStored : ILAttributesStored + member Data : byte [] option + member FieldType : ILType + member IsInitOnly : bool + member IsLiteral : bool + member IsSpecialName : bool + member IsStatic : bool + member LiteralValue : ILFieldInit option + member Marshal : ILNativeType option + member MetadataIndex : int32 + member Name : string + member NotSerialized : bool + member Offset : int32 option + end + [] + type ILFieldDefs = + | ILFields of LazyOrderedMultiMap + with + member LookupByName : string -> ILFieldDef list + member AsList : ILFieldDef list + end + type ILMethodImplDef = + { Overrides: ILOverridesSpec + OverrideBy: ILMethodSpec } + [] + type ILMethodImplDefs = + | ILMethodImpls of System.Lazy + with + member AsList : ILMethodImplDef list + end + and MethodImplsMap = Map<(string * int),ILMethodImplDef list> + [] + type ILTypeDefLayout = + | Auto + | Sequential of ILTypeDefLayoutInfo + | Explicit of ILTypeDefLayoutInfo + and ILTypeDefLayoutInfo = + { Size: int32 option + Pack: uint16 option } + [] + type ILTypeInit = + | BeforeField + | OnAny + [] + type ILDefaultPInvokeEncoding = + | Ansi + | Auto + | Unicode + [] + type ILTypeDefAccess = + | Public + | Private + | Nested of ILMemberAccess + val typeAccessOfFlags : flags:int -> ILTypeDefAccess + val typeEncodingOfFlags : flags:int -> ILDefaultPInvokeEncoding + [] + type ILTypeDefKind = + | Class + | ValueType + | Interface + | Enum + | Delegate + val typeKindOfFlags : + nm:string -> super:ILType option -> flags:int -> ILTypeDefKind + val convertTypeAccessFlags : + access:ILTypeDefAccess -> System.Reflection.TypeAttributes + val convertTypeKind : kind:ILTypeDefKind -> System.Reflection.TypeAttributes + val convertLayout : + layout:ILTypeDefLayout -> System.Reflection.TypeAttributes + val convertEncoding : + encoding:ILDefaultPInvokeEncoding -> System.Reflection.TypeAttributes + val convertToNestedTypeAccess : + ilMemberAccess:ILMemberAccess -> System.Reflection.TypeAttributes + val convertInitSemantics : + init:ILTypeInit -> System.Reflection.TypeAttributes + [] + type ILTypeDef = + class + new : name:string * attributes:System.Reflection.TypeAttributes * + layout:ILTypeDefLayout * implements:ILTypes * + genericParams:ILGenericParameterDefs * extends:ILType option * + methods:ILMethodDefs * nestedTypes:ILTypeDefs * fields:ILFieldDefs * + methodImpls:ILMethodImplDefs * events:ILEventDefs * + properties:ILPropertyDefs * securityDecls:ILSecurityDecls * + customAttrs:ILAttributes -> ILTypeDef + new : name:string * attributes:System.Reflection.TypeAttributes * + layout:ILTypeDefLayout * implements:ILTypes * + genericParams:ILGenericParameterDefs * extends:ILType option * + methods:ILMethodDefs * nestedTypes:ILTypeDefs * fields:ILFieldDefs * + methodImpls:ILMethodImplDefs * events:ILEventDefs * + properties:ILPropertyDefs * + securityDeclsStored:ILSecurityDeclsStored * + customAttrsStored:ILAttributesStored * metadataIndex:int32 -> + ILTypeDef + member + With : ?name:string * ?attributes:System.Reflection.TypeAttributes * + ?layout:ILTypeDefLayout * ?implements:ILTypes * + ?genericParams:ILGenericParameterDefs * ?extends:ILType option * + ?methods:ILMethodDefs * ?nestedTypes:ILTypeDefs * + ?fields:ILFieldDefs * ?methodImpls:ILMethodImplDefs * + ?events:ILEventDefs * ?properties:ILPropertyDefs * + ?customAttrs:ILAttributes * ?securityDecls:ILSecurityDecls -> + ILTypeDef + member WithAbstract : bool -> ILTypeDef + member WithAccess : ILTypeDefAccess -> ILTypeDef + member WithEncoding : ILDefaultPInvokeEncoding -> ILTypeDef + member WithHasSecurity : bool -> ILTypeDef + member WithImport : bool -> ILTypeDef + member WithInitSemantics : ILTypeInit -> ILTypeDef + member WithKind : ILTypeDefKind -> ILTypeDef + member WithLayout : ILTypeDefLayout -> ILTypeDef + member WithNestedAccess : ILMemberAccess -> ILTypeDef + member WithSealed : bool -> ILTypeDef + member WithSerializable : bool -> ILTypeDef + member WithSpecialName : bool -> ILTypeDef + member Access : ILTypeDefAccess + member Attributes : System.Reflection.TypeAttributes + member CustomAttrs : ILAttributes + member CustomAttrsStored : ILAttributesStored + member Encoding : ILDefaultPInvokeEncoding + member Events : ILEventDefs + member Extends : ILType option + member Fields : ILFieldDefs + member GenericParams : ILGenericParameterDefs + member HasSecurity : bool + member Implements : ILTypes + member IsAbstract : bool + member IsClass : bool + member IsComInterop : bool + member IsDelegate : bool + member IsEnum : bool + member IsInterface : bool + member IsSealed : bool + member IsSerializable : bool + member IsSpecialName : bool + member IsStruct : bool + member IsStructOrEnum : bool + member Layout : ILTypeDefLayout + member MetadataIndex : int32 + member MethodImpls : ILMethodImplDefs + member Methods : ILMethodDefs + member Name : string + member NestedTypes : ILTypeDefs + member Properties : ILPropertyDefs + member SecurityDecls : ILSecurityDecls + member SecurityDeclsStored : ILSecurityDeclsStored + end + [] + and ILTypeDefs = + class + interface System.Collections.Generic.IEnumerable + interface System.Collections.IEnumerable + new : f:(unit -> ILPreTypeDef []) -> ILTypeDefs + member FindByName : string -> ILTypeDef + member AsArray : ILTypeDef [] + member AsArrayOfPreTypeDefs : ILPreTypeDef [] + member AsList : ILTypeDef list + end + [] + and ILPreTypeDef = + interface + abstract member GetTypeDef : unit -> ILTypeDef + abstract member Name : string + abstract member Namespace : string list + end + [] + and ILPreTypeDefImpl = + class + interface ILPreTypeDef + new : nameSpace:string list * name:string * metadataIndex:int32 * + storage:ILTypeDefStored -> ILPreTypeDefImpl + end + [] + and ILTypeDefStored = + | Given of ILTypeDef + | Reader of (int32 -> ILTypeDef) + | Computed of (unit -> ILTypeDef) + val mkILTypeDefReader : (int32 -> ILTypeDef) -> ILTypeDefStored + type ILNestedExportedType = + { Name: string + Access: ILMemberAccess + Nested: ILNestedExportedTypes + CustomAttrsStored: ILAttributesStored + MetadataIndex: int32 } + with + member CustomAttrs : ILAttributes + end + [] + and ILNestedExportedTypes = + | ILNestedExportedTypes of System.Lazy> + with + member AsList : ILNestedExportedType list + end + [] + and ILExportedTypeOrForwarder = + { ScopeRef: ILScopeRef + Name: string + Attributes: System.Reflection.TypeAttributes + Nested: ILNestedExportedTypes + CustomAttrsStored: ILAttributesStored + MetadataIndex: int32 } + with + member Access : ILTypeDefAccess + member CustomAttrs : ILAttributes + member IsForwarder : bool + end + [] + and ILExportedTypesAndForwarders = + | ILExportedTypesAndForwarders of + System.Lazy> + with + member TryFindByName : string -> ILExportedTypeOrForwarder option + member AsList : ILExportedTypeOrForwarder list + end + [] + type ILResourceAccess = + | Public + | Private + [] + type ILResourceLocation = + | Local of Internal.ByteStorage + | File of ILModuleRef * int32 + | Assembly of ILAssemblyRef + type ILResource = + { Name: string + Location: ILResourceLocation + Access: ILResourceAccess + CustomAttrsStored: ILAttributesStored + MetadataIndex: int32 } + with + member GetBytes : unit -> Internal.ReadOnlyByteMemory + member CustomAttrs : ILAttributes + end + [] + type ILResources = + | ILResources of ILResource list + with + member AsList : ILResource list + end + [] + type ILAssemblyLongevity = + | Unspecified + | Library + | PlatformAppDomain + | PlatformProcess + | PlatformSystem + type ILAssemblyManifest = + { Name: string + AuxModuleHashAlgorithm: int32 + SecurityDeclsStored: ILSecurityDeclsStored + PublicKey: byte [] option + Version: ILVersionInfo option + Locale: Locale option + CustomAttrsStored: ILAttributesStored + AssemblyLongevity: ILAssemblyLongevity + DisableJitOptimizations: bool + JitTracking: bool + IgnoreSymbolStoreSequencePoints: bool + Retargetable: bool + ExportedTypes: ILExportedTypesAndForwarders + EntrypointElsewhere: ILModuleRef option + MetadataIndex: int32 } + with + member CustomAttrs : ILAttributes + member SecurityDecls : ILSecurityDecls + end + [] + type ILNativeResource = + | In of + fileName: string * linkedResourceBase: int * linkedResourceStart: int * + linkedResourceLength: int + | Out of unlinkedResource: byte [] + type ILModuleDef = + { Manifest: ILAssemblyManifest option + Name: string + TypeDefs: ILTypeDefs + SubsystemVersion: int * int + UseHighEntropyVA: bool + SubSystemFlags: int32 + IsDLL: bool + IsILOnly: bool + Platform: ILPlatform option + StackReserveSize: int32 option + Is32Bit: bool + Is32BitPreferred: bool + Is64Bit: bool + VirtualAlignment: int32 + PhysicalAlignment: int32 + ImageBase: int32 + MetadataVersion: string + Resources: ILResources + NativeResources: ILNativeResource list + CustomAttrsStored: ILAttributesStored + MetadataIndex: int32 } + with + member CustomAttrs : ILAttributes + member HasManifest : bool + member ManifestOfAssembly : ILAssemblyManifest + end + val mkILEmptyGenericParams : ILGenericParameterDefs + val emptyILGenericArgsList : ILType list + val mkILNestedTyRef : ILScopeRef * string list * string -> ILTypeRef + val mkILTyRef : ILScopeRef * string -> ILTypeRef + type ILGenericArgsList = ILType list + val mkILTySpec : ILTypeRef * ILGenericArgs -> ILTypeSpec + val mkILNonGenericTySpec : ILTypeRef -> ILTypeSpec + val mkILTyRefInTyRef : ILTypeRef * string -> ILTypeRef + val mkILTy : ILBoxity -> ILTypeSpec -> ILType + val mkILNamedTy : ILBoxity -> ILTypeRef -> ILGenericArgs -> ILType + val mkILValueTy : ILTypeRef -> ILGenericArgs -> ILType + val mkILBoxedTy : ILTypeRef -> ILGenericArgs -> ILType + val mkILNonGenericValueTy : ILTypeRef -> ILType + val mkILNonGenericBoxedTy : ILTypeRef -> ILType + val mkSimpleAssemblyRef : string -> ILAssemblyRef + val mkSimpleModRef : string -> ILModuleRef + val typeNameForGlobalFunctions : string + val mkILTypeForGlobalFunctions : ILScopeRef -> ILType + val isTypeNameForGlobalFunctions : string -> bool + val mkILMethRef : + ILTypeRef * ILCallingConv * string * int * ILTypes * ILType -> ILMethodRef + val mkILMethSpecForMethRefInTy : + ILMethodRef * ILType * ILGenericArgs -> ILMethodSpec + val mkILMethSpec : + ILMethodRef * ILBoxity * ILGenericArgs * ILGenericArgs -> ILMethodSpec + val mkILMethSpecInTypeRef : + tref:ILTypeRef * vc:ILBoxity * cc:ILCallingConv * nm:string * args:ILTypes * + rty:ILType * tinst:ILGenericArgs * minst:ILType list -> ILMethodSpec + val mkILMethSpecInTy : + ILType * ILCallingConv * string * ILTypes * ILType * ILGenericArgs -> + ILMethodSpec + val mkILNonGenericMethSpecInTy : + ILType * ILCallingConv * string * ILTypes * ILType -> ILMethodSpec + val mkILInstanceMethSpecInTy : + ILType * string * ILTypes * ILType * ILGenericArgs -> ILMethodSpec + val mkILNonGenericInstanceMethSpecInTy : + ILType * string * ILTypes * ILType -> ILMethodSpec + val mkILStaticMethSpecInTy : + ILType * string * ILTypes * ILType * ILGenericArgs -> ILMethodSpec + val mkILNonGenericStaticMethSpecInTy : + ILType * string * ILTypes * ILType -> ILMethodSpec + val mkILCtorMethSpec : + tref:ILTypeRef * args:ILTypes * cinst:ILGenericArgs -> ILMethodSpec + val mkILCtorMethSpecForTy : ILType * ILTypes -> ILMethodSpec + val mkILNonGenericCtorMethSpec : + tref:ILTypeRef * args:ILTypes -> ILMethodSpec + val mkILFieldRef : ILTypeRef * string * ILType -> ILFieldRef + val mkILFieldSpec : ILFieldRef * ILType -> ILFieldSpec + val mkILFieldSpecInTy : ILType * string * ILType -> ILFieldSpec + val andTailness : ILTailcall -> bool -> ILTailcall + val formatCodeLabel : int -> string + val codeLabelCount : int ref + val generateCodeLabel : unit -> int + val instrIsRet : i:ILInstr -> bool + val nonBranchingInstrsToCode : ILInstr list -> ILCode + val mkILTyvarTy : uint16 -> ILType + val mkILSimpleTypar : string -> ILGenericParameterDef + val gparam_of_gactual : _ga:ILType -> ILGenericParameterDef + val mkILFormalTypars : ILGenericArgsList -> ILGenericParameterDef list + val mkILFormalGenericArgs : int -> ILGenericParameterDefs -> ILType list + val mkILFormalBoxedTy : ILTypeRef -> ILGenericParameterDefs -> ILType + val mkILFormalNamedTy : + ILBoxity -> ILTypeRef -> ILGenericParameterDefs -> ILType + val mkRefForNestedILTypeDef : + ILScopeRef -> ILTypeDef list * ILTypeDef -> ILTypeRef + val mkILPreTypeDef : ILTypeDef -> ILPreTypeDef + val mkILPreTypeDefComputed : + string list * string * (unit -> ILTypeDef) -> ILPreTypeDef + val mkILPreTypeDefRead : + string list * string * int32 * ILTypeDefStored -> ILPreTypeDef + val addILTypeDef : ILTypeDef -> ILTypeDefs -> ILTypeDefs + val mkILTypeDefsFromArray : ILTypeDef [] -> ILTypeDefs + val mkILTypeDefs : ILTypeDef list -> ILTypeDefs + val mkILTypeDefsComputed : (unit -> ILPreTypeDef []) -> ILTypeDefs + val emptyILTypeDefs : ILTypeDefs + val mkILMethodsFromArray : ILMethodDef [] -> ILMethodDefs + val mkILMethods : ILMethodDef list -> ILMethodDefs + val mkILMethodsComputed : (unit -> ILMethodDef []) -> ILMethodDefs + val emptyILMethods : ILMethodDefs + val filterILMethodDefs : + f:(ILMethodDef -> bool) -> mdefs:ILMethodDefs -> ILMethodDefs + val defaultSubSystem : int + val defaultPhysAlignment : int + val defaultVirtAlignment : int + val defaultImageBase : int + val mkILArrTy : ILType * ILArrayShape -> ILType + val mkILArr1DTy : ILType -> ILType + val isILArrTy : ILType -> bool + val destILArrTy : ILType -> ILArrayShape * ILType + [] + val tname_Object : string = "System.Object" + [] + val tname_String : string = "System.String" + [] + val tname_Array : string = "System.Array" + [] + val tname_Type : string = "System.Type" + [] + val tname_Int64 : string = "System.Int64" + [] + val tname_UInt64 : string = "System.UInt64" + [] + val tname_Int32 : string = "System.Int32" + [] + val tname_UInt32 : string = "System.UInt32" + [] + val tname_Int16 : string = "System.Int16" + [] + val tname_UInt16 : string = "System.UInt16" + [] + val tname_SByte : string = "System.SByte" + [] + val tname_Byte : string = "System.Byte" + [] + val tname_Single : string = "System.Single" + [] + val tname_Double : string = "System.Double" + [] + val tname_Bool : string = "System.Boolean" + [] + val tname_Char : string = "System.Char" + [] + val tname_IntPtr : string = "System.IntPtr" + [] + val tname_UIntPtr : string = "System.UIntPtr" + [] + val tname_TypedReference : string = "System.TypedReference" + [] + type ILGlobals = + class + new : primaryScopeRef:ILScopeRef * + assembliesThatForwardToPrimaryAssembly:ILAssemblyRef list -> + ILGlobals + member IsPossiblePrimaryAssemblyRef : ILAssemblyRef -> bool + override ToString : unit -> string + [ (0))>] + member DebugText : string + member primaryAssemblyName : string + member primaryAssemblyRef : ILAssemblyRef + member primaryAssemblyScopeRef : ILScopeRef + member typ_Array : ILType + member typ_Bool : ILType + member typ_Byte : ILType + member typ_Char : ILType + member typ_Double : ILType + member typ_Int16 : ILType + member typ_Int32 : ILType + member typ_Int64 : ILType + member typ_IntPtr : ILType + member typ_Object : ILType + member typ_SByte : ILType + member typ_Single : ILType + member typ_String : ILType + member typ_Type : ILType + member typ_TypedReference : ILType + member typ_UInt16 : ILType + member typ_UInt32 : ILType + member typ_UInt64 : ILType + member typ_UIntPtr : ILType + end + val mkILGlobals : + primaryScopeRef:ILScopeRef * + assembliesThatForwardToPrimaryAssembly:ILAssemblyRef list -> ILGlobals + val mkNormalCall : ILMethodSpec -> ILInstr + val mkNormalCallvirt : ILMethodSpec -> ILInstr + val mkNormalCallconstraint : ILType * ILMethodSpec -> ILInstr + val mkNormalNewobj : ILMethodSpec -> ILInstr + val ldargs : ILInstr [] + val mkLdarg : uint16 -> ILInstr + val mkLdarg0 : ILInstr + val ldlocs : ILInstr [] + val mkLdloc : uint16 -> ILInstr + val stlocs : ILInstr [] + val mkStloc : uint16 -> ILInstr + val ldi32s : ILInstr [] + val mkLdcInt32 : int -> ILInstr + val tname_CompilerGeneratedAttribute : string + val tname_DebuggableAttribute : string + val ecmaPublicKey : PublicKey + val isILBoxedTy : _arg1:ILType -> bool + val isILValueTy : _arg1:ILType -> bool + val isBuiltInTySpec : ilg:ILGlobals -> tspec:ILTypeSpec -> n:string -> bool + val isILBoxedBuiltInTy : ilg:ILGlobals -> ty:ILType -> n:string -> bool + val isILValueBuiltInTy : ilg:ILGlobals -> ty:ILType -> n:string -> bool + val isILObjectTy : ILGlobals -> ILType -> bool + val isILStringTy : ILGlobals -> ILType -> bool + val isILTypedReferenceTy : ILGlobals -> ILType -> bool + val isILSByteTy : ILGlobals -> ILType -> bool + val isILByteTy : ILGlobals -> ILType -> bool + val isILInt16Ty : ILGlobals -> ILType -> bool + val isILUInt16Ty : ILGlobals -> ILType -> bool + val isILInt32Ty : ILGlobals -> ILType -> bool + val isILUInt32Ty : ILGlobals -> ILType -> bool + val isILInt64Ty : ILGlobals -> ILType -> bool + val isILUInt64Ty : ILGlobals -> ILType -> bool + val isILIntPtrTy : ILGlobals -> ILType -> bool + val isILUIntPtrTy : ILGlobals -> ILType -> bool + val isILBoolTy : ILGlobals -> ILType -> bool + val isILCharTy : ILGlobals -> ILType -> bool + val isILSingleTy : ILGlobals -> ILType -> bool + val isILDoubleTy : ILGlobals -> ILType -> bool + val rescopeILScopeRef : ILScopeRef -> ILScopeRef -> ILScopeRef + val rescopeILTypeRef : scoref:ILScopeRef -> tref1:ILTypeRef -> ILTypeRef + val rescopeILTypeSpec : ILScopeRef -> ILTypeSpec -> ILTypeSpec + val rescopeILType : ILScopeRef -> ILType -> ILType + val rescopeILTypes : scoref:ILScopeRef -> i:ILGenericArgs -> ILGenericArgs + val rescopeILCallSig : + scoref:ILScopeRef -> csig:ILCallingSignature -> ILCallingSignature + val rescopeILMethodRef : ILScopeRef -> ILMethodRef -> ILMethodRef + val rescopeILFieldRef : ILScopeRef -> ILFieldRef -> ILFieldRef + val instILTypeSpecAux : + numFree:int -> inst:ILGenericArgs -> tspec:ILTypeSpec -> ILTypeSpec + val instILTypeAux : int -> ILGenericArgs -> ILType -> ILType + val instILGenericArgsAux : + numFree:int -> inst:ILGenericArgs -> i:ILGenericArgs -> ILGenericArgs + val instILCallSigAux : + numFree:int -> + inst:ILGenericArgs -> csig:ILCallingSignature -> ILCallingSignature + val instILType : ILGenericArgs -> ILType -> ILType + val mkILParam : string option * ILType -> ILParameter + val mkILParamNamed : string * ILType -> ILParameter + val mkILParamAnon : ILType -> ILParameter + val mkILReturn : ILType -> ILReturn + val mkILLocal : ILType -> (string * int * int) option -> ILLocal + val mkILMethodBody : + initlocals:bool * ILLocals * int32 * ILCode * ILSourceMarker option -> + ILMethodBody + val mkMethodBody : + bool * ILLocals * int32 * ILCode * ILSourceMarker option -> MethodBody + val mkILVoidReturn : ILReturn + val methBodyNotAvailable : ILLazyMethodBody + val methBodyAbstract : ILLazyMethodBody + val methBodyNative : ILLazyMethodBody + val mkILCtor : ILMemberAccess * ILParameters * MethodBody -> ILMethodDef + val mkCallBaseConstructor : ILType * ILType list -> ILInstr list + val mkNormalStfld : ILFieldSpec -> ILInstr + val mkNormalStsfld : ILFieldSpec -> ILInstr + val mkNormalLdsfld : ILFieldSpec -> ILInstr + val mkNormalLdfld : ILFieldSpec -> ILInstr + val mkNormalLdflda : ILFieldSpec -> ILInstr + val mkNormalLdobj : ILType -> ILInstr + val mkNormalStobj : ILType -> ILInstr + val mkILNonGenericEmptyCtor : ILSourceMarker option -> ILType -> ILMethodDef + val mkILStaticMethod : + ILGenericParameterDefs * string * ILMemberAccess * ILParameters * ILReturn * + MethodBody -> ILMethodDef + val mkILNonGenericStaticMethod : + string * ILMemberAccess * ILParameters * ILReturn * MethodBody -> + ILMethodDef + val mkILClassCtor : MethodBody -> ILMethodDef + val mk_ospec : + ty:ILType * callconv:ILCallingConv * nm:string * genparams:int * + formal_args:ILTypes * formal_ret:ILType -> ILOverridesSpec + val mkILGenericVirtualMethod : + string * ILMemberAccess * ILGenericParameterDefs * ILParameters * ILReturn * + MethodBody -> ILMethodDef + val mkILNonGenericVirtualMethod : + string * ILMemberAccess * ILParameters * ILReturn * MethodBody -> + ILMethodDef + val mkILGenericNonVirtualMethod : + string * ILMemberAccess * ILGenericParameterDefs * ILParameters * ILReturn * + MethodBody -> ILMethodDef + val mkILNonGenericInstanceMethod : + string * ILMemberAccess * ILParameters * ILReturn * MethodBody -> + ILMethodDef + val ilmbody_code2code : + f:(ILCode -> ILCode) -> il:ILMethodBody -> ILMethodBody + val mdef_code2code : f:(ILCode -> ILCode) -> md:ILMethodDef -> ILMethodDef + val prependInstrsToCode : ILInstr list -> ILCode -> ILCode + val prependInstrsToMethod : ILInstr list -> ILMethodDef -> ILMethodDef + val cdef_cctorCode2CodeOrCreate : + tag:ILSourceMarker option -> + f:(ILMethodDef -> ILMethodDef) -> cd:ILTypeDef -> ILTypeDef + val code_of_mdef : md:ILMethodDef -> ILCode + val mkRefToILMethod : ILTypeRef * ILMethodDef -> ILMethodRef + val mkRefToILField : ILTypeRef * ILFieldDef -> ILFieldRef + val mkRefForILMethod : + ILScopeRef -> ILTypeDef list * ILTypeDef -> ILMethodDef -> ILMethodRef + val mkRefForILField : + ILScopeRef -> ILTypeDef list * ILTypeDef -> ILFieldDef -> ILFieldRef + val prependInstrsToClassCtor : + ILInstr list -> ILSourceMarker option -> ILTypeDef -> ILTypeDef + val mkILField : + isStatic:bool * nm:string * ty:ILType * init:ILFieldInit option * + at:byte [] option * access:ILMemberAccess * isLiteral:bool -> ILFieldDef + val mkILInstanceField : + string * ILType * ILFieldInit option * ILMemberAccess -> ILFieldDef + val mkILStaticField : + string * ILType * ILFieldInit option * byte [] option * ILMemberAccess -> + ILFieldDef + val mkILLiteralField : + string * ILType * ILFieldInit * byte [] option * ILMemberAccess -> + ILFieldDef + type ILLocalsAllocator = + class + new : preAlloc:int -> ILLocalsAllocator + member AllocLocal : ILLocal -> uint16 + member Close : unit -> ILLocal list + end + val mkILFieldsLazy : System.Lazy -> ILFieldDefs + val mkILFields : ILFieldDef list -> ILFieldDefs + val emptyILFields : ILFieldDefs + val mkILEventsLazy : System.Lazy -> ILEventDefs + val mkILEvents : ILEventDef list -> ILEventDefs + val emptyILEvents : ILEventDefs + val mkILPropertiesLazy : System.Lazy -> ILPropertyDefs + val mkILProperties : ILPropertyDef list -> ILPropertyDefs + val emptyILProperties : ILPropertyDefs + val addExportedTypeToTable : + y:ILExportedTypeOrForwarder -> + tab:Map -> + Map + val mkILExportedTypes : + ILExportedTypeOrForwarder list -> ILExportedTypesAndForwarders + val mkILExportedTypesLazy : + System.Lazy -> + ILExportedTypesAndForwarders + val addNestedExportedTypeToTable : + y:ILNestedExportedType -> + tab:Map -> Map + val mkTypeForwarder : + ILScopeRef -> + string -> + ILNestedExportedTypes -> + ILAttributes -> ILTypeDefAccess -> ILExportedTypeOrForwarder + val mkILNestedExportedTypes : + ILNestedExportedType list -> ILNestedExportedTypes + val mkILNestedExportedTypesLazy : + System.Lazy -> ILNestedExportedTypes + val mkILResources : ILResource list -> ILResources + val addMethodImplToTable : + y:ILMethodImplDef -> + tab:Map<(string * int),ILMethodImplDef list> -> + Map<(string * int),ILMethodImplDef list> + val mkILMethodImpls : ILMethodImplDef list -> ILMethodImplDefs + val mkILMethodImplsLazy : + System.Lazy -> ILMethodImplDefs + val emptyILMethodImpls : ILMethodImplDefs + val mkILStorageCtorWithParamNames : + tag:ILSourceMarker option * preblock:ILInstr list * ty:ILType * + extraParams:ILParameter list * flds:(string * string * ILType) list * + access:ILMemberAccess -> ILMethodDef + val mkILSimpleStorageCtorWithParamNames : + ILSourceMarker option * ILTypeSpec option * ILType * ILParameter list * + (string * string * ILType) list * ILMemberAccess -> ILMethodDef + val addParamNames : flds:('a * 'b) list -> ('a * 'a * 'b) list + val mkILSimpleStorageCtor : + ILSourceMarker option * ILTypeSpec option * ILType * ILParameter list * + (string * ILType) list * ILMemberAccess -> ILMethodDef + val mkILStorageCtor : + ILSourceMarker option * ILInstr list * ILType * (string * ILType) list * + ILMemberAccess -> ILMethodDef + val mkILGenericClass : + string * ILTypeDefAccess * ILGenericParameterDefs * ILType * ILTypes * + ILMethodDefs * ILFieldDefs * ILTypeDefs * ILPropertyDefs * ILEventDefs * + ILAttributes * ILTypeInit -> ILTypeDef + val mkRawDataValueTypeDef : + ILType -> string * size:int32 * pack:uint16 -> ILTypeDef + val mkILSimpleClass : + ILGlobals -> + string * ILTypeDefAccess * ILMethodDefs * ILFieldDefs * ILTypeDefs * + ILPropertyDefs * ILEventDefs * ILAttributes * ILTypeInit -> ILTypeDef + val mkILTypeDefForGlobalFunctions : + ILGlobals -> ILMethodDefs * ILFieldDefs -> ILTypeDef + val destTypeDefsWithGlobalFunctionsFirst : + ILGlobals -> ILTypeDefs -> ILTypeDef list + val mkILSimpleModule : + assemblyName:string -> + moduleName:string -> + dll:bool -> + subsystemVersion:(int * int) -> + useHighEntropyVA:bool -> + ILTypeDefs -> + int32 option -> + Locale option -> + int -> + ILExportedTypesAndForwarders -> string -> ILModuleDef + val buildILCode : + string -> + lab2pc:System.Collections.Generic.Dictionary -> + instrs:ILInstr [] -> + ILExceptionSpec list -> ILLocalDebugInfo list -> ILCode + val mkILDelegateMethods : + ILMemberAccess -> + ILGlobals -> + ILType * ILType -> ILParameters * ILReturn -> ILMethodDef list + val mkCtorMethSpecForDelegate : ILGlobals -> ILType * bool -> ILMethodSpec + type ILEnumInfo = + { enumValues: (string * ILFieldInit) list + enumType: ILType } + val getTyOfILEnumInfo : ILEnumInfo -> ILType + val computeILEnumInfo : string * ILFieldDefs -> ILEnumInfo + val sigptr_get_byte : bytes:byte [] -> sigptr:int -> int * int + val sigptr_get_bool : bytes:byte [] -> sigptr:int -> bool * int + val sigptr_get_u8 : bytes:byte [] -> sigptr:int -> byte * int + val sigptr_get_i8 : bytes:byte [] -> sigptr:int -> sbyte * int + val sigptr_get_u16 : bytes:byte [] -> sigptr:int -> uint16 * int + val sigptr_get_i16 : bytes:byte [] -> sigptr:int -> int16 * int + val sigptr_get_i32 : bytes:byte [] -> sigptr:int -> int * int + val sigptr_get_u32 : bytes:byte [] -> sigptr:int -> uint32 * int + val sigptr_get_i64 : bytes:byte [] -> sigptr:int -> int64 * int + val sigptr_get_u64 : bytes:byte [] -> sigptr:int -> uint64 * int + val float32_of_bits : x:int32 -> float32 + val float_of_bits : x:int64 -> float + val sigptr_get_ieee32 : bytes:byte [] -> sigptr:int -> float32 * int + val sigptr_get_ieee64 : bytes:byte [] -> sigptr:int -> float * int + val sigptr_get_intarray : + n:int -> bytes:byte [] -> sigptr:int -> byte [] * int + val sigptr_get_string : n:int -> bytes:byte [] -> sigptr:int -> string * int + val sigptr_get_z_i32 : bytes:byte [] -> sigptr:int -> int * int + val sigptr_get_serstring : bytes:byte [] -> sigptr:int -> string * int + val sigptr_get_serstring_possibly_null : + bytes:byte [] -> sigptr:int -> string option * int + val mkRefToILAssembly : ILAssemblyManifest -> ILAssemblyRef + val z_unsigned_int_size : n:int -> int + val z_unsigned_int : n:int -> byte [] + val string_as_utf8_bytes : s:string -> byte [] + val dw7 : n:int64 -> byte + val dw6 : n:int64 -> byte + val dw5 : n:int64 -> byte + val dw4 : n:int64 -> byte + val dw3 : n:int64 -> byte + val dw2 : n:int64 -> byte + val dw1 : n:int64 -> byte + val dw0 : n:int64 -> byte + val u8AsBytes : i:byte -> byte [] + val u16AsBytes : x:uint16 -> byte [] + val i32AsBytes : i:int -> byte [] + val i64AsBytes : i:int64 -> byte [] + val i8AsBytes : i:sbyte -> byte [] + val i16AsBytes : i:int16 -> byte [] + val u32AsBytes : i:uint32 -> byte [] + val u64AsBytes : i:uint64 -> byte [] + val bits_of_float32 : x:float32 -> int + val bits_of_float : x:float -> int64 + val ieee32AsBytes : i:float32 -> byte [] + val ieee64AsBytes : i:float -> byte [] + val et_END : byte + val et_VOID : byte + val et_BOOLEAN : byte + val et_CHAR : byte + val et_I1 : byte + val et_U1 : byte + val et_I2 : byte + val et_U2 : byte + val et_I4 : byte + val et_U4 : byte + val et_I8 : byte + val et_U8 : byte + val et_R4 : byte + val et_R8 : byte + val et_STRING : byte + val et_PTR : byte + val et_BYREF : byte + val et_VALUETYPE : byte + val et_CLASS : byte + val et_VAR : byte + val et_ARRAY : byte + val et_WITH : byte + val et_TYPEDBYREF : byte + val et_I : byte + val et_U : byte + val et_FNPTR : byte + val et_OBJECT : byte + val et_SZARRAY : byte + val et_MVAR : byte + val et_CMOD_REQD : byte + val et_CMOD_OPT : byte + val formatILVersion : ILVersionInfo -> string + val encodeCustomAttrString : s:string -> byte [] + val encodeCustomAttrElemType : x:ILType -> byte [] + val encodeCustomAttrElemTypeForObject : x:ILAttribElem -> byte [] + val decodeCustomAttrElemType : + ilg:ILGlobals -> bytes:byte [] -> sigptr:int -> x:byte -> ILType * int + val encodeCustomAttrPrimValue : ilg:'a -> c:ILAttribElem -> byte [] + val encodeCustomAttrValue : ilg:'a -> ty:ILType -> c:ILAttribElem -> byte [] + val encodeCustomAttrNamedArg : + ilg:'a -> nm:string * ty:ILType * prop:bool * elem:ILAttribElem -> byte [] + val encodeCustomAttrArgs : + ilg:ILGlobals -> + mspec:ILMethodSpec -> + fixedArgs:ILAttribElem list -> + namedArgs:(string * ILType * bool * ILAttribElem) list -> byte [] + val encodeCustomAttr : + ilg:ILGlobals -> + mspec:ILMethodSpec * fixedArgs:ILAttribElem list * + namedArgs:(string * ILType * bool * ILAttribElem) list -> ILAttribute + val mkILCustomAttribMethRef : + ILGlobals -> + ILMethodSpec * ILAttribElem list * + (string * ILType * bool * ILAttribElem) list -> ILAttribute + val mkILCustomAttribute : + ILGlobals -> + ILTypeRef * ILTypes * ILAttribElem list * + (string * ILType * bool * ILAttribElem) list -> ILAttribute + val getCustomAttrData : ILGlobals -> ILAttribute -> byte [] + val MscorlibScopeRef : ILScopeRef + val EcmaMscorlibILGlobals : ILGlobals + val PrimaryAssemblyILGlobals : ILGlobals + val mkPermissionSet : + ILGlobals -> + ILSecurityAction * + (ILTypeRef * (string * ILType * ILAttribElem) list) list -> + ILSecurityDecl + type ILTypeSigParser = + class + new : tstring:string -> ILTypeSigParser + member private ParseType : unit -> ILType + member ParseTypeSpec : unit -> ILAttribElem + end + val decodeILAttribData : + ILGlobals -> ILAttribute -> ILAttribElem list * ILAttributeNamedArg list + type ILReferences = + { AssemblyReferences: ILAssemblyRef list + ModuleReferences: ILModuleRef list } + type ILReferencesAccumulator = + { ilg: ILGlobals + refsA: System.Collections.Generic.HashSet + refsM: System.Collections.Generic.HashSet } + val emptyILRefs : ILReferences + val refs_of_assemblyRef : + s:ILReferencesAccumulator -> x:ILAssemblyRef -> unit + val refs_of_modref : s:ILReferencesAccumulator -> x:ILModuleRef -> unit + val refs_of_scoref : s:ILReferencesAccumulator -> x:ILScopeRef -> unit + val refs_of_tref : s:ILReferencesAccumulator -> x:ILTypeRef -> unit + val refs_of_typ : s:ILReferencesAccumulator -> x:ILType -> unit + val refs_of_inst : s:ILReferencesAccumulator -> i:ILGenericArgs -> unit + val refs_of_tspec : s:ILReferencesAccumulator -> x:ILTypeSpec -> unit + val refs_of_callsig : + s:ILReferencesAccumulator -> csig:ILCallingSignature -> unit + val refs_of_genparam : + s:ILReferencesAccumulator -> x:ILGenericParameterDef -> unit + val refs_of_genparams : + s:ILReferencesAccumulator -> b:ILGenericParameterDef list -> unit + val refs_of_dloc : s:ILReferencesAccumulator -> ts:ILTypeRef -> unit + val refs_of_mref : s:ILReferencesAccumulator -> x:ILMethodRef -> unit + val refs_of_fref : s:ILReferencesAccumulator -> x:ILFieldRef -> unit + val refs_of_ospec : s:ILReferencesAccumulator -> ILOverridesSpec -> unit + val refs_of_mspec : s:ILReferencesAccumulator -> x:ILMethodSpec -> unit + val refs_of_fspec : s:ILReferencesAccumulator -> x:ILFieldSpec -> unit + val refs_of_tys : s:ILReferencesAccumulator -> l:ILGenericArgs -> unit + val refs_of_token : s:ILReferencesAccumulator -> x:ILToken -> unit + val refs_of_custom_attr : + s:ILReferencesAccumulator -> cattr:ILAttribute -> unit + val refs_of_custom_attrs : + s:ILReferencesAccumulator -> cas:ILAttributes -> unit + val refs_of_varargs : + s:ILReferencesAccumulator -> tyso:ILGenericArgs option -> unit + val refs_of_instr : s:ILReferencesAccumulator -> x:ILInstr -> unit + val refs_of_il_code : s:ILReferencesAccumulator -> c:ILCode -> unit + val refs_of_ilmbody : s:ILReferencesAccumulator -> il:ILMethodBody -> unit + val refs_of_local : s:ILReferencesAccumulator -> loc:ILLocal -> unit + val refs_of_mbody : s:ILReferencesAccumulator -> x:MethodBody -> unit + val refs_of_mdef : s:ILReferencesAccumulator -> md:ILMethodDef -> unit + val refs_of_param : s:ILReferencesAccumulator -> p:ILParameter -> unit + val refs_of_return : s:ILReferencesAccumulator -> rt:ILReturn -> unit + val refs_of_mdefs : s:ILReferencesAccumulator -> x:seq<#ILMethodDef> -> unit + val refs_of_event_def : s:ILReferencesAccumulator -> ed:ILEventDef -> unit + val refs_of_events : s:ILReferencesAccumulator -> x:ILEventDefs -> unit + val refs_of_property_def : + s:ILReferencesAccumulator -> pd:ILPropertyDef -> unit + val refs_of_properties : + s:ILReferencesAccumulator -> x:ILPropertyDefs -> unit + val refs_of_fdef : s:ILReferencesAccumulator -> fd:ILFieldDef -> unit + val refs_of_fields : + s:ILReferencesAccumulator -> fields:#ILFieldDef list -> unit + val refs_of_method_impls : + s:ILReferencesAccumulator -> mimpls:ILMethodImplDef list -> unit + val refs_of_method_impl : + s:ILReferencesAccumulator -> m:ILMethodImplDef -> unit + val refs_of_tdef_kind : _s:'c -> _k:'d -> unit + val refs_of_tdef : s:ILReferencesAccumulator -> td:ILTypeDef -> unit + val refs_of_string : _s:'e -> 'f -> unit + val refs_of_types : s:ILReferencesAccumulator -> types:ILTypeDefs -> unit + val refs_of_exported_type : + s:ILReferencesAccumulator -> c:ILExportedTypeOrForwarder -> unit + val refs_of_exported_types : + s:ILReferencesAccumulator -> tab:ILExportedTypesAndForwarders -> unit + val refs_of_resource_where : + s:ILReferencesAccumulator -> x:ILResourceLocation -> unit + val refs_of_resource : s:ILReferencesAccumulator -> x:ILResource -> unit + val refs_of_resources : s:ILReferencesAccumulator -> tab:ILResources -> unit + val refs_of_modul : s:ILReferencesAccumulator -> m:ILModuleDef -> unit + val refs_of_manifest : + s:ILReferencesAccumulator -> m:ILAssemblyManifest -> unit + val computeILRefs : ILGlobals -> ILModuleDef -> ILReferences + val tspan : System.TimeSpan + val parseILVersion : string -> ILVersionInfo + val compareILVersions : ILVersionInfo -> ILVersionInfo -> int + val unscopeILTypeRef : x:ILTypeRef -> ILTypeRef + val unscopeILTypeSpec : tspec:ILTypeSpec -> ILTypeSpec + val unscopeILType : ILType -> ILType + val unscopeILTypes : i:ILGenericArgs -> ILGenericArgs + val unscopeILCallSig : csig:ILCallingSignature -> ILCallingSignature + val resolveILMethodRefWithRescope : + (ILType -> ILType) -> ILTypeDef -> ILMethodRef -> ILMethodDef + val resolveILMethodRef : ILTypeDef -> ILMethodRef -> ILMethodDef + val mkRefToILModule : ILModuleDef -> ILModuleRef + [] + type ILEventRef = + { erA: ILTypeRef + erB: string } + with + static member Create : ILTypeRef * string -> ILEventRef + member DeclaringTypeRef : ILTypeRef + member Name : string + end + [] + type ILPropertyRef = + { prA: ILTypeRef + prB: string } + with + static member Create : ILTypeRef * string -> ILPropertyRef + member DeclaringTypeRef : ILTypeRef + member Name : string + end + end + +namespace FSharp.Compiler.AbstractIL.Extensions.ILX + module internal Types = begin + val mkLowerName : nm:string -> string + [] + type IlxUnionField = + class + new : IL.ILFieldDef -> IlxUnionField + member ILField : IL.ILFieldDef + member LowerName : string + member Name : string + member Type : IL.ILType + end + type IlxUnionAlternative = + { altName: string + altFields: IlxUnionField [] + altCustomAttrs: IL.ILAttributes } + with + member FieldDef : int -> IlxUnionField + member FieldDefs : IlxUnionField [] + member FieldTypes : IL.ILType [] + member IsNullary : bool + member Name : string + end + type IlxUnionHasHelpers = + | NoHelpers + | AllHelpers + | SpecialFSharpListHelpers + | SpecialFSharpOptionHelpers + type IlxUnionRef = + | IlxUnionRef of + boxity: IL.ILBoxity * IL.ILTypeRef * IlxUnionAlternative [] * bool * + IlxUnionHasHelpers + type IlxUnionSpec = + | IlxUnionSpec of IlxUnionRef * IL.ILGenericArgs + with + member Alternative : int -> IlxUnionAlternative + member FieldDef : int -> int -> IlxUnionField + member Alternatives : IlxUnionAlternative list + member AlternativesArray : IlxUnionAlternative [] + member Boxity : IL.ILBoxity + member DeclaringType : IL.ILType + member GenericArgs : IL.ILGenericArgs + member HasHelpers : IlxUnionHasHelpers + member IsNullPermitted : bool + member TypeRef : IL.ILTypeRef + end + type IlxClosureLambdas = + | Lambdas_forall of IL.ILGenericParameterDef * IlxClosureLambdas + | Lambdas_lambda of IL.ILParameter * IlxClosureLambdas + | Lambdas_return of IL.ILType + type IlxClosureApps = + | Apps_tyapp of IL.ILType * IlxClosureApps + | Apps_app of IL.ILType * IlxClosureApps + | Apps_done of IL.ILType + val instAppsAux : + int -> IL.ILGenericArgs -> IlxClosureApps -> IlxClosureApps + val instLambdasAux : + n:int -> + inst:IL.ILGenericArgs -> _arg1:IlxClosureLambdas -> IlxClosureLambdas + val instLambdas : + i:IL.ILGenericArgs -> t:IlxClosureLambdas -> IlxClosureLambdas + type IlxClosureFreeVar = + { fvName: string + fvCompilerGenerated: bool + fvType: IL.ILType } + val mkILFreeVar : string * bool * IL.ILType -> IlxClosureFreeVar + type IlxClosureRef = + | IlxClosureRef of IL.ILTypeRef * IlxClosureLambdas * IlxClosureFreeVar [] + type IlxClosureSpec = + | IlxClosureSpec of + IlxClosureRef * IL.ILGenericArgs * IL.ILType * useStaticField: bool + with + static member + Create : IlxClosureRef * IL.ILGenericArgs * useStaticField:bool -> + IlxClosureSpec + member GetStaticFieldSpec : unit -> IL.ILFieldSpec + member ClosureRef : IlxClosureRef + member Constructor : IL.ILMethodSpec + member FormalFreeVars : IlxClosureFreeVar [] + member FormalLambdas : IlxClosureLambdas + member GenericArgs : IL.ILGenericArgs + member ILType : IL.ILType + member TypeRef : IL.ILTypeRef + member UseStaticField : bool + end + type IlxClosureInfo = + { cloStructure: IlxClosureLambdas + cloFreeVars: IlxClosureFreeVar [] + cloCode: Lazy + cloUseStaticField: bool } + type IlxUnionInfo = + { cudReprAccess: IL.ILMemberAccess + cudHelpersAccess: IL.ILMemberAccess + cudHasHelpers: IlxUnionHasHelpers + cudDebugProxies: bool + cudDebugDisplayAttributes: IL.ILAttribute list + cudAlternatives: IlxUnionAlternative [] + cudNullPermitted: bool + cudWhere: IL.ILSourceMarker option } + val destTyFuncApp : IlxClosureApps -> IL.ILType * IlxClosureApps + val mkILFormalCloRef : + IL.ILGenericParameterDefs -> + IlxClosureRef -> useStaticField:bool -> IlxClosureSpec + val actualTypOfIlxUnionField : IlxUnionSpec -> int -> int -> IL.ILType + end + +namespace FSharp.Compiler.AbstractIL.Internal + module internal AsciiConstants = begin + val noArgInstrs : Lazy<(string list * IL.ILInstr) list> + val wordsOfNoArgInstr : (IL.ILInstr -> string list) + val isNoArgInstr : (IL.ILInstr -> bool) + val mk_stind : nm:'a * dt:IL.ILBasicType -> 'a * (unit -> IL.ILInstr) + val mk_ldind : nm:'a * dt:IL.ILBasicType -> 'a * (unit -> IL.ILInstr) + type NoArgInstr = unit -> IL.ILInstr + type Int32Instr = int32 -> IL.ILInstr + type Int32Int32Instr = int32 * int32 -> IL.ILInstr + type Int64Instr = int64 -> IL.ILInstr + type DoubleInstr = IL.ILConst -> IL.ILInstr + type MethodSpecInstr = IL.ILMethodSpec * IL.ILVarArgs -> IL.ILInstr + type TypeInstr = IL.ILType -> IL.ILInstr + type IntTypeInstr = int * IL.ILType -> IL.ILInstr + type ValueTypeInstr = IL.ILType -> IL.ILInstr + type StringInstr = string -> IL.ILInstr + type TokenInstr = IL.ILToken -> IL.ILInstr + type SwitchInstr = IL.ILCodeLabel list * IL.ILCodeLabel -> IL.ILInstr + type InstrTable<'T> = (string list * 'T) list + type LazyInstrTable<'T> = Lazy> + val NoArgInstrs : Lazy> + val Int64Instrs : Lazy> + val Int32Instrs : Lazy> + val Int32Int32Instrs : Lazy> + val DoubleInstrs : Lazy> + val StringInstrs : Lazy> + val TokenInstrs : Lazy> + val TypeInstrs : Lazy> + val IntTypeInstrs : Lazy> + val ValueTypeInstrs : Lazy> + end + +namespace FSharp.Compiler.AbstractIL + module internal ILAsciiWriter = begin + val pretty : unit -> bool + val tyvar_generator : (string -> string) + type ppenv = + { ilGlobals: IL.ILGlobals + ppenvClassFormals: int + ppenvMethodFormals: int } + val ppenv_enter_method : mgparams:int -> env:ppenv -> ppenv + val ppenv_enter_tdef : gparams:'a list -> env:ppenv -> ppenv + val mk_ppenv : ilg:IL.ILGlobals -> ppenv + val debug_ppenv : (IL.ILGlobals -> ppenv) + val ppenv_enter_modul : env:ppenv -> ppenv + val output_string : os:System.IO.TextWriter -> s:string -> unit + val output_char : os:System.IO.TextWriter -> c:char -> unit + val output_int : os:System.IO.TextWriter -> i:int -> unit + val output_hex_digit : os:System.IO.TextWriter -> i:int -> unit + val output_qstring : os:System.IO.TextWriter -> s:string -> unit + val output_sqstring : os:System.IO.TextWriter -> s:string -> unit + val output_seq : + sep:string -> f:('a -> 'b -> unit) -> os:'a -> a:seq<'b> -> unit + when 'a :> System.IO.TextWriter + val output_array : + sep:string -> f:('a -> 'b -> unit) -> os:'a -> a:'b [] -> unit + when 'a :> System.IO.TextWriter + val output_parens : + f:('a -> 'b -> unit) -> os:'a -> a:'b -> unit + when 'a :> System.IO.TextWriter + val output_angled : + f:('a -> 'b -> unit) -> os:'a -> a:'b -> unit + when 'a :> System.IO.TextWriter + val output_bracks : + f:('a -> 'b -> unit) -> os:'a -> a:'b -> unit + when 'a :> System.IO.TextWriter + val output_id : os:System.IO.TextWriter -> n:string -> unit + val output_label : os:System.IO.TextWriter -> n:string -> unit + val output_lid : os:System.IO.TextWriter -> lid:seq -> unit + val string_of_type_name : 'a * n:'b -> 'b + val output_byte : os:System.IO.TextWriter -> i:int -> unit + val output_bytes : os:System.IO.TextWriter -> bytes:byte [] -> unit + val bits_of_float32 : x:float32 -> int + val bits_of_float : x:float -> int64 + val output_u8 : os:System.IO.TextWriter -> x:byte -> unit + val output_i8 : os:System.IO.TextWriter -> x:sbyte -> unit + val output_u16 : os:System.IO.TextWriter -> x:uint16 -> unit + val output_i16 : os:System.IO.TextWriter -> x:int16 -> unit + val output_u32 : os:System.IO.TextWriter -> x:uint32 -> unit + val output_i32 : os:System.IO.TextWriter -> x:int32 -> unit + val output_u64 : os:System.IO.TextWriter -> x:uint64 -> unit + val output_i64 : os:System.IO.TextWriter -> x:int64 -> unit + val output_ieee32 : os:System.IO.TextWriter -> x:float32 -> unit + val output_ieee64 : os:System.IO.TextWriter -> x:float -> unit + val goutput_scoref : + env:ppenv -> os:System.IO.TextWriter -> _arg2:IL.ILScopeRef -> unit + val goutput_type_name_ref : + env:ppenv -> + os:System.IO.TextWriter -> + scoref:IL.ILScopeRef * enc:string list * n:string -> unit + val goutput_tref : + env:ppenv -> os:System.IO.TextWriter -> x:IL.ILTypeRef -> unit + val goutput_typ : + env:ppenv -> os:System.IO.TextWriter -> ty:IL.ILType -> unit + val output_tyvar : os:System.IO.TextWriter -> d:uint16 -> unit + val goutput_ldtoken_info : + env:ppenv -> os:System.IO.TextWriter -> _arg3:IL.ILToken -> unit + val goutput_typ_with_shortened_class_syntax : + env:ppenv -> os:System.IO.TextWriter -> _arg4:IL.ILType -> unit + val goutput_gactuals : + env:ppenv -> os:System.IO.TextWriter -> inst:IL.ILGenericArgs -> unit + val goutput_gactual : + env:ppenv -> os:System.IO.TextWriter -> ty:IL.ILType -> unit + val goutput_tspec : + env:ppenv -> os:System.IO.TextWriter -> tspec:IL.ILTypeSpec -> unit + val output_arr_bounds : + os:System.IO.TextWriter -> _arg5:IL.ILArrayShape -> unit + val goutput_permission : + _env:'a -> os:System.IO.TextWriter -> p:IL.ILSecurityDecl -> unit + val goutput_security_decls : + env:'b -> os:System.IO.TextWriter -> ps:IL.ILSecurityDecls -> unit + val goutput_gparam : + env:ppenv -> + os:System.IO.TextWriter -> gf:IL.ILGenericParameterDef -> unit + val goutput_gparams : + env:ppenv -> + os:System.IO.TextWriter -> b:IL.ILGenericParameterDef list -> unit + val output_bcc : os:System.IO.TextWriter -> bcc:IL.ILArgConvention -> unit + val output_callconv : os:System.IO.TextWriter -> IL.ILCallingConv -> unit + val goutput_dlocref : + env:ppenv -> os:System.IO.TextWriter -> dref:IL.ILType -> unit + val goutput_callsig : + env:ppenv -> os:System.IO.TextWriter -> csig:IL.ILCallingSignature -> unit + val goutput_mref : + env:ppenv -> os:System.IO.TextWriter -> mref:IL.ILMethodRef -> unit + val goutput_mspec : + env:ppenv -> os:System.IO.TextWriter -> mspec:IL.ILMethodSpec -> unit + val goutput_vararg_mspec : + env:ppenv -> + os:System.IO.TextWriter -> + mspec:IL.ILMethodSpec * varargs:#seq option -> unit + val goutput_vararg_sig : + env:ppenv -> + os:System.IO.TextWriter -> + csig:IL.ILCallingSignature * varargs:IL.ILVarArgs -> unit + val goutput_fspec : + env:ppenv -> os:System.IO.TextWriter -> x:IL.ILFieldSpec -> unit + val output_member_access : + os:System.IO.TextWriter -> access:IL.ILMemberAccess -> unit + val output_type_access : + os:System.IO.TextWriter -> access:IL.ILTypeDefAccess -> unit + val output_encoding : + os:System.IO.TextWriter -> e:IL.ILDefaultPInvokeEncoding -> unit + val output_field_init : + os:System.IO.TextWriter -> _arg1:IL.ILFieldInit -> unit + val output_at : os:System.IO.TextWriter -> b:byte [] -> unit + val output_option : f:('a -> 'b -> unit) -> os:'a -> _arg1:'b option -> unit + val goutput_alternative_ref : + env:ppenv -> + os:System.IO.TextWriter -> + alt:Extensions.ILX.Types.IlxUnionAlternative -> unit + val goutput_curef : + env:ppenv -> + os:System.IO.TextWriter -> Extensions.ILX.Types.IlxUnionRef -> unit + val goutput_cuspec : + env:ppenv -> + os:System.IO.TextWriter -> Extensions.ILX.Types.IlxUnionSpec -> unit + val output_basic_type : os:System.IO.TextWriter -> x:IL.ILBasicType -> unit + val output_custom_attr_data : + os:System.IO.TextWriter -> data:byte [] -> unit + val goutput_custom_attr : + env:ppenv -> os:System.IO.TextWriter -> attr:IL.ILAttribute -> unit + val goutput_custom_attrs : + env:ppenv -> os:System.IO.TextWriter -> attrs:IL.ILAttributes -> unit + val goutput_fdef : + _tref:'a -> + env:ppenv -> os:System.IO.TextWriter -> fd:IL.ILFieldDef -> unit + val output_alignment : + os:System.IO.TextWriter -> _arg1:IL.ILAlignment -> unit + val output_volatility : + os:System.IO.TextWriter -> _arg1:IL.ILVolatility -> unit + val output_tailness : os:System.IO.TextWriter -> _arg1:IL.ILTailcall -> unit + val output_after_tailcall : + os:System.IO.TextWriter -> _arg1:IL.ILTailcall -> unit + val goutput_apps : + env:ppenv -> + os:System.IO.TextWriter -> + _arg1:Extensions.ILX.Types.IlxClosureApps -> unit + val output_short_u16 : os:System.IO.TextWriter -> x:uint16 -> unit + val output_short_i32 : os:System.IO.TextWriter -> i32:int -> unit + val output_code_label : + os:System.IO.TextWriter -> lab:IL.ILCodeLabel -> unit + val goutput_local : + env:ppenv -> os:System.IO.TextWriter -> l:IL.ILLocal -> unit + val goutput_param : + env:ppenv -> os:System.IO.TextWriter -> l:IL.ILParameter -> unit + val goutput_params : + env:ppenv -> os:System.IO.TextWriter -> ps:seq -> unit + val goutput_freevar : + env:ppenv -> + os:System.IO.TextWriter -> + l:Extensions.ILX.Types.IlxClosureFreeVar -> unit + val goutput_freevars : + env:ppenv -> + os:System.IO.TextWriter -> + ps:seq -> unit + val output_source : os:System.IO.TextWriter -> s:IL.ILSourceMarker -> unit + val goutput_instr : + env:ppenv -> os:System.IO.TextWriter -> inst:IL.ILInstr -> unit + val goutput_ilmbody : + env:ppenv -> os:System.IO.TextWriter -> il:IL.ILMethodBody -> unit + val goutput_mbody : + is_entrypoint:bool -> + env:ppenv -> os:System.IO.TextWriter -> md:IL.ILMethodDef -> unit + val goutput_mdef : + env:ppenv -> os:System.IO.TextWriter -> md:IL.ILMethodDef -> unit + val goutput_pdef : + env:ppenv -> os:System.IO.TextWriter -> pd:IL.ILPropertyDef -> unit + val goutput_superclass : + env:ppenv -> os:System.IO.TextWriter -> _arg1:IL.ILType option -> unit + val goutput_superinterfaces : + env:ppenv -> os:System.IO.TextWriter -> imp:IL.ILType list -> unit + val goutput_implements : + env:ppenv -> os:System.IO.TextWriter -> imp:IL.ILTypes -> unit + val the : _arg1:'a option -> 'a + val output_type_layout_info : + os:System.IO.TextWriter -> info:IL.ILTypeDefLayoutInfo -> unit + val splitTypeLayout : + _arg1:IL.ILTypeDefLayout -> + string * (#System.IO.TextWriter -> unit -> unit) + val goutput_fdefs : + tref:'a -> + env:ppenv -> os:System.IO.TextWriter -> fdefs:IL.ILFieldDefs -> unit + val goutput_mdefs : + env:ppenv -> os:System.IO.TextWriter -> mdefs:IL.ILMethodDefs -> unit + val goutput_pdefs : + env:ppenv -> os:System.IO.TextWriter -> pdefs:IL.ILPropertyDefs -> unit + val goutput_tdef : + enc:string list -> + env:ppenv -> + contents:bool -> os:System.IO.TextWriter -> cd:IL.ILTypeDef -> unit + val output_init_semantics : + os:System.IO.TextWriter -> f:System.Reflection.TypeAttributes -> unit + val goutput_lambdas : + env:ppenv -> + os:System.IO.TextWriter -> + lambdas:Extensions.ILX.Types.IlxClosureLambdas -> unit + val goutput_tdefs : + contents:bool -> + enc:string list -> + env:ppenv -> os:System.IO.TextWriter -> td:IL.ILTypeDefs -> unit + val output_ver : os:System.IO.TextWriter -> version:IL.ILVersionInfo -> unit + val output_locale : os:System.IO.TextWriter -> s:string -> unit + val output_hash : os:System.IO.TextWriter -> x:byte [] -> unit + val output_publickeytoken : os:System.IO.TextWriter -> x:byte [] -> unit + val output_publickey : os:System.IO.TextWriter -> x:byte [] -> unit + val output_publickeyinfo : + os:System.IO.TextWriter -> _arg1:IL.PublicKey -> unit + val output_assemblyRef : + os:System.IO.TextWriter -> aref:IL.ILAssemblyRef -> unit + val output_modref : os:System.IO.TextWriter -> modref:IL.ILModuleRef -> unit + val goutput_resource : + env:ppenv -> os:System.IO.TextWriter -> r:IL.ILResource -> unit + val goutput_manifest : + env:ppenv -> os:System.IO.TextWriter -> m:IL.ILAssemblyManifest -> unit + val output_module_fragment_aux : + _refs:'a -> + os:System.IO.TextWriter -> + ilg:IL.ILGlobals -> modul:IL.ILModuleDef -> unit + val output_module_fragment : + os:System.IO.TextWriter -> + ilg:IL.ILGlobals -> modul:IL.ILModuleDef -> IL.ILReferences + val output_module_refs : + os:System.IO.TextWriter -> refs:IL.ILReferences -> unit + val goutput_module_manifest : + env:ppenv -> os:System.IO.TextWriter -> modul:IL.ILModuleDef -> unit + val output_module : + System.IO.TextWriter -> ilg:IL.ILGlobals -> IL.ILModuleDef -> unit + end + +namespace FSharp.Compiler.AbstractIL + module internal Morphs = begin + val mutable morphCustomAttributeData : bool + val enableMorphCustomAttributeData : unit -> unit + val disableMorphCustomAttributeData : unit -> unit + val code_instr2instr : + f:(IL.ILInstr -> IL.ILInstr) -> code:IL.ILCode -> IL.ILCode + val code_instr2instrs : + f:(IL.ILInstr -> IL.ILInstr list) -> code:IL.ILCode -> IL.ILCode + val code_instr2instr_ty2ty : + finstr:(IL.ILInstr -> IL.ILInstr) * fty:(IL.ILType -> IL.ILType) -> + c:IL.ILCode -> IL.ILCode + val ty_tref2tref : + f:(IL.ILTypeRef -> IL.ILTypeRef) -> x:IL.ILType -> IL.ILType + val tspec_tref2tref : + f:(IL.ILTypeRef -> IL.ILTypeRef) -> x:IL.ILTypeSpec -> IL.ILTypeSpec + val ty_scoref2scoref_tyvar2ty : + (IL.ILScopeRef -> IL.ILScopeRef) * (uint16 -> IL.ILType) -> + x:IL.ILType -> IL.ILType + val tspec_scoref2scoref_tyvar2ty : + (IL.ILScopeRef -> IL.ILScopeRef) * (uint16 -> IL.ILType) -> + x:IL.ILTypeSpec -> IL.ILTypeSpec + val callsig_scoref2scoref_tyvar2ty : + (IL.ILScopeRef -> IL.ILScopeRef) * (uint16 -> IL.ILType) -> + x:IL.ILCallingSignature -> IL.ILCallingSignature + val tys_scoref2scoref_tyvar2ty : + (IL.ILScopeRef -> IL.ILScopeRef) * (uint16 -> IL.ILType) -> + i:IL.ILGenericArgs -> IL.ILGenericArgs + val gparams_scoref2scoref_tyvar2ty : f:'a -> i:'b list -> 'b list + val gparam_scoref2scoref_tyvar2ty : _f:'a -> i:'b -> 'b + val morphILScopeRefsInILTypeRef : + (IL.ILScopeRef -> IL.ILScopeRef) -> IL.ILTypeRef -> IL.ILTypeRef + val callsig_ty2ty : + f:(IL.ILType -> IL.ILType) -> + x:IL.ILCallingSignature -> IL.ILCallingSignature + val gparam_ty2ty : + f:(IL.ILType -> IL.ILType) -> + gf:IL.ILGenericParameterDef -> IL.ILGenericParameterDef + val gparams_ty2ty : + f:(IL.ILType -> IL.ILType) -> + gfs:IL.ILGenericParameterDef list -> IL.ILGenericParameterDef list + val tys_ty2ty : + f:(IL.ILType -> IL.ILType) -> x:IL.ILType list -> IL.ILType list + val mref_ty2ty : + f:(IL.ILType -> IL.ILType) -> x:IL.ILMethodRef -> IL.ILMethodRef + type formal_scopeCtxt = Choice + val mspec_ty2ty : + (IL.ILType -> IL.ILType) * (formal_scopeCtxt -> IL.ILType -> IL.ILType) -> + x:IL.ILMethodSpec -> IL.ILMethodSpec + val fref_ty2ty : + f:(IL.ILType -> IL.ILType) -> x:IL.ILFieldRef -> IL.ILFieldRef + val fspec_ty2ty : + (IL.ILType -> IL.ILType) * (formal_scopeCtxt -> IL.ILType -> IL.ILType) -> + x:IL.ILFieldSpec -> IL.ILFieldSpec + val celem_ty2ty : + f:(IL.ILType -> IL.ILType) -> celem:IL.ILAttribElem -> IL.ILAttribElem + val cnamedarg_ty2ty : + f:(IL.ILType -> IL.ILType) -> + string * IL.ILType * bool * IL.ILAttribElem -> + string * IL.ILType * bool * IL.ILAttribElem + val cattr_ty2ty : + ilg:IL.ILGlobals -> + f:(IL.ILType -> IL.ILType) -> c:IL.ILAttribute -> IL.ILAttribute + val cattrs_ty2ty : + ilg:IL.ILGlobals -> + f:(IL.ILType -> IL.ILType) -> cs:IL.ILAttributes -> IL.ILAttributes + val fdef_ty2ty : + ilg:IL.ILGlobals -> + ftye:(IL.ILType -> IL.ILType) -> fd:IL.ILFieldDef -> IL.ILFieldDef + val local_ty2ty : f:(IL.ILType -> IL.ILType) -> l:IL.ILLocal -> IL.ILLocal + val varargs_ty2ty : + f:(IL.ILType -> 'a) -> varargs:IL.ILVarArgs -> 'a list option + val morphILTypesInILInstr : + (IL.ILInstr option -> IL.ILType -> IL.ILType) * + (IL.ILInstr option -> formal_scopeCtxt -> IL.ILType -> IL.ILType) -> + i:IL.ILInstr -> IL.ILInstr + val return_ty2ty : + ilg:IL.ILGlobals -> + f:(IL.ILType -> IL.ILType) -> r:IL.ILReturn -> IL.ILReturn + val param_ty2ty : + ilg:IL.ILGlobals -> + f:(IL.ILType -> IL.ILType) -> p:IL.ILParameter -> IL.ILParameter + val morphILMethodDefs : + f:(IL.ILMethodDef -> IL.ILMethodDef) -> + m:IL.ILMethodDefs -> IL.ILMethodDefs + val fdefs_fdef2fdef : + f:(IL.ILFieldDef -> IL.ILFieldDef) -> m:IL.ILFieldDefs -> IL.ILFieldDefs + val morphILTypeDefs : + f:(IL.ILTypeDef -> IL.ILTypeDef) -> m:IL.ILTypeDefs -> IL.ILTypeDefs + val locals_ty2ty : + f:(IL.ILType -> IL.ILType) -> ls:IL.ILLocal list -> IL.ILLocal list + val ilmbody_instr2instr_ty2ty : + (IL.ILInstr -> IL.ILInstr) * (IL.ILType -> IL.ILType) -> + il:IL.ILMethodBody -> IL.ILMethodBody + val morphILMethodBody : + filmbody:(IL.ILMethodBody -> IL.ILMethodBody) -> + x:IL.ILLazyMethodBody -> IL.ILLazyMethodBody + val ospec_ty2ty : + f:(IL.ILType -> IL.ILType) -> IL.ILOverridesSpec -> IL.ILOverridesSpec + val mdef_ty2ty_ilmbody2ilmbody : + ilg:IL.ILGlobals -> + (IL.ILMethodDef option -> IL.ILType -> IL.ILType) * + (IL.ILMethodDef option -> IL.ILMethodBody -> IL.ILMethodBody) -> + md:IL.ILMethodDef -> IL.ILMethodDef + val fdefs_ty2ty : + ilg:IL.ILGlobals -> + f:(IL.ILType -> IL.ILType) -> x:IL.ILFieldDefs -> IL.ILFieldDefs + val mdefs_ty2ty_ilmbody2ilmbody : + ilg:IL.ILGlobals -> + (IL.ILMethodDef option -> IL.ILType -> IL.ILType) * + (IL.ILMethodDef option -> IL.ILMethodBody -> IL.ILMethodBody) -> + x:IL.ILMethodDefs -> IL.ILMethodDefs + val mimpl_ty2ty : + f:(IL.ILType -> IL.ILType) -> e:IL.ILMethodImplDef -> IL.ILMethodImplDef + val edef_ty2ty : + ilg:IL.ILGlobals -> + f:(IL.ILType -> IL.ILType) -> e:IL.ILEventDef -> IL.ILEventDef + val pdef_ty2ty : + ilg:IL.ILGlobals -> + f:(IL.ILType -> IL.ILType) -> p:IL.ILPropertyDef -> IL.ILPropertyDef + val pdefs_ty2ty : + ilg:IL.ILGlobals -> + f:(IL.ILType -> IL.ILType) -> + pdefs:IL.ILPropertyDefs -> IL.ILPropertyDefs + val edefs_ty2ty : + ilg:IL.ILGlobals -> + f:(IL.ILType -> IL.ILType) -> edefs:IL.ILEventDefs -> IL.ILEventDefs + val mimpls_ty2ty : + f:(IL.ILType -> IL.ILType) -> + mimpls:IL.ILMethodImplDefs -> IL.ILMethodImplDefs + val tdef_ty2ty_ilmbody2ilmbody_mdefs2mdefs : + ilg:IL.ILGlobals -> + enc:IL.ILTypeDef list -> + ((IL.ILTypeDef list * IL.ILTypeDef) option -> 'a option -> + IL.ILType -> IL.ILType) * + (IL.ILTypeDef list * IL.ILTypeDef -> IL.ILMethodDefs -> + IL.ILMethodDefs) -> td:IL.ILTypeDef -> IL.ILTypeDef + val tdefs_ty2ty_ilmbody2ilmbody_mdefs2mdefs : + ilg:IL.ILGlobals -> + enc:IL.ILTypeDef list -> + ((IL.ILTypeDef list * IL.ILTypeDef) option -> 'a option -> + IL.ILType -> IL.ILType) * + (IL.ILTypeDef list * IL.ILTypeDef -> IL.ILMethodDefs -> + IL.ILMethodDefs) -> tdefs:IL.ILTypeDefs -> IL.ILTypeDefs + val manifest_ty2ty : + ilg:IL.ILGlobals -> + f:(IL.ILType -> IL.ILType) -> + m:IL.ILAssemblyManifest -> IL.ILAssemblyManifest + val morphILTypeInILModule_ilmbody2ilmbody_mdefs2mdefs : + ilg:IL.ILGlobals -> + ftye:(IL.ILModuleDef -> (IL.ILTypeDef list * IL.ILTypeDef) option -> + IL.ILMethodDef option -> IL.ILType -> IL.ILType) * + fmdefs:(IL.ILModuleDef -> IL.ILTypeDef list * IL.ILTypeDef -> + IL.ILMethodDefs -> IL.ILMethodDefs) -> + m:IL.ILModuleDef -> IL.ILModuleDef + val module_instr2instr_ty2ty : + ilg:IL.ILGlobals -> + (IL.ILModuleDef -> IL.ILTypeDef list * IL.ILTypeDef -> + IL.ILMethodDef option -> IL.ILInstr -> IL.ILInstr) * + (IL.ILModuleDef -> (IL.ILTypeDef list * IL.ILTypeDef) option -> + IL.ILMethodDef option -> IL.ILType -> IL.ILType) -> + x:IL.ILModuleDef -> IL.ILModuleDef + val morphILInstrsAndILTypesInILModule : + ilg:IL.ILGlobals -> + f1:(IL.ILModuleDef -> IL.ILTypeDef list * IL.ILTypeDef -> + IL.ILMethodDef option -> IL.ILInstr -> IL.ILInstr) * + f2:(IL.ILModuleDef -> (IL.ILTypeDef list * IL.ILTypeDef) option -> + IL.ILMethodDef option -> IL.ILType -> IL.ILType) -> + x:IL.ILModuleDef -> IL.ILModuleDef + val morphILInstrsInILCode : + (IL.ILInstr -> IL.ILInstr list) -> IL.ILCode -> IL.ILCode + val morphILTypeInILModule : + ilg:IL.ILGlobals -> + ftye:(IL.ILModuleDef -> (IL.ILTypeDef list * IL.ILTypeDef) option -> + IL.ILMethodDef option -> IL.ILType -> IL.ILType) -> + y:IL.ILModuleDef -> IL.ILModuleDef + val morphILTypeRefsInILModuleMemoized : + IL.ILGlobals -> + (IL.ILTypeRef -> IL.ILTypeRef) -> IL.ILModuleDef -> IL.ILModuleDef + val morphILScopeRefsInILModuleMemoized : + IL.ILGlobals -> + (IL.ILScopeRef -> IL.ILScopeRef) -> IL.ILModuleDef -> IL.ILModuleDef + end + +namespace FSharp.Compiler.AbstractIL.Internal + module internal StrongNameSign = begin + type KeyType = + | Public + | KeyPair + val ALG_TYPE_RSA : int + val ALG_CLASS_KEY_EXCHANGE : int + val ALG_CLASS_SIGNATURE : int + val CALG_RSA_KEYX : int + val CALG_RSA_SIGN : int + val ALG_CLASS_HASH : int + val ALG_TYPE_ANY : int + val CALG_SHA1 : int + val CALG_SHA_256 : int + val CALG_SHA_384 : int + val CALG_SHA_512 : int + val PUBLICKEYBLOB : int + val PRIVATEKEYBLOB : int + val BLOBHEADER_CURRENT_BVERSION : int + val BLOBHEADER_LENGTH : int + val RSA_PUB_MAGIC : int + val RSA_PRIV_MAGIC : int + val getResourceString : 'a * str:'b -> 'b + val check : _action:'a -> hresult:int -> unit + [] + type ByteArrayUnion = + struct + new : immutableArray:System.Collections.Immutable.ImmutableArray -> + ByteArrayUnion + val UnderlyingArray: byte [] + val ImmutableArray: System.Collections.Immutable.ImmutableArray + end + val getUnderlyingArray : + array:System.Collections.Immutable.ImmutableArray -> byte [] + val hashAssembly : + peReader:System.Reflection.PortableExecutable.PEReader -> + hashAlgorithm:System.Security.Cryptography.IncrementalHash -> byte [] + type BlobReader = + class + new : blob:byte [] -> BlobReader + member ReadBigInteger : length:int -> byte [] + member ReadInt32 : int + end + val RSAParamatersFromBlob : + blob:byte [] -> + keyType:KeyType -> System.Security.Cryptography.RSAParameters + val toCLRKeyBlob : + rsaParameters:System.Security.Cryptography.RSAParameters -> + algId:int -> byte [] + val createSignature : + hash:byte [] -> keyBlob:byte [] -> keyType:KeyType -> byte [] + val patchSignature : + stream:System.IO.Stream -> + peReader:System.Reflection.PortableExecutable.PEReader -> + signature:byte [] -> unit + val signStream : stream:System.IO.Stream -> keyBlob:byte [] -> unit + val signFile : filename:string -> keyBlob:byte [] -> unit + val signatureSize : pk:byte [] -> int + val getPublicKeyForKeyPair : keyBlob:byte [] -> byte [] + type keyContainerName = string + type keyPair = byte [] + type pubkey = byte [] + type pubkeyOptions = byte [] * bool + val signerOpenPublicKeyFile : filePath:string -> byte [] + val signerOpenKeyPairFile : filePath:string -> byte [] + val signerGetPublicKeyForKeyPair : kp:keyPair -> pubkey + val signerGetPublicKeyForKeyContainer : _kcName:keyContainerName -> pubkey + val signerCloseKeyContainer : _kc:keyContainerName -> unit + val signerSignatureSize : pk:pubkey -> int + val signerSignFileWithKeyPair : fileName:string -> kp:keyPair -> unit + val signerSignFileWithKeyContainer : + _fileName:string -> _kcName:keyContainerName -> unit + [] + type ILStrongNameSigner = + | PublicKeySigner of pubkey + | PublicKeyOptionsSigner of pubkeyOptions + | KeyPair of keyPair + | KeyContainer of keyContainerName + with + static member OpenKeyContainer : keyContainerName -> ILStrongNameSigner + static member OpenKeyPairFile : string -> ILStrongNameSigner + static member OpenPublicKey : pubkey -> ILStrongNameSigner + static member + OpenPublicKeyOptions : string -> bool -> ILStrongNameSigner + member Close : unit -> unit + member SignFile : string -> unit + member IsFullySigned : bool + member PublicKey : pubkey + member SignatureSize : int + end + end + +namespace FSharp.Compiler.AbstractIL.Internal + module internal NativeRes = begin + type BYTE = byte + type DWORD = uint32 + type WCHAR = System.Char + type WORD = uint16 + val inline WORD : + s: ^a -> uint16 when ^a : (static member op_Explicit : ^a -> uint16) + val inline DWORD : + s: ^a -> uint32 when ^a : (static member op_Explicit : ^a -> uint32) + val inline WCHAR : + s: ^a -> char when ^a : (static member op_Explicit : ^a -> char) + val inline BYTE : + s: ^a -> byte when ^a : (static member op_Explicit : ^a -> byte) + type ResourceException = + class + inherit System.Exception + new : name:string * ?inner:System.Exception -> ResourceException + end + [] + type RESOURCE_STRING = + class + new : unit -> RESOURCE_STRING + member Ordinal : WORD + member theString : string + end + [] + type RESOURCE = + class + new : unit -> RESOURCE + member Characteristics : DWORD + member DataSize : DWORD + member DataVersion : DWORD + member HeaderSize : DWORD + member LanguageId : WORD + member MemoryFlags : WORD + member Version : DWORD + member data : byte [] + member pstringName : RESOURCE_STRING + member pstringType : RESOURCE_STRING + end + [] + type CvtResFile = + class + new : unit -> CvtResFile + static member + ReadResFile : stream:System.IO.Stream -> + System.Collections.Generic.List + static member + private ReadStringOrID : fhIn:System.IO.BinaryReader -> + RESOURCE_STRING + static member private RT_DLGINCLUDE : int + end + [] + type SectionCharacteristics = + | TypeReg = 0u + | TypeDSect = 1u + | TypeNoLoad = 2u + | TypeGroup = 4u + | TypeNoPad = 8u + | TypeCopy = 16u + | ContainsCode = 32u + | ContainsInitializedData = 64u + | ContainsUninitializedData = 128u + | LinkerOther = 256u + | LinkerInfo = 512u + | TypeOver = 1024u + | LinkerRemove = 2048u + | LinkerComdat = 4096u + | MemProtected = 16384u + | NoDeferSpecExc = 16384u + | GPRel = 32768u + | MemFardata = 32768u + | MemSysheap = 65536u + | MemPurgeable = 131072u + | Mem16Bit = 131072u + | MemLocked = 262144u + | MemPreload = 524288u + | Align1Bytes = 1048576u + | Align2Bytes = 2097152u + | Align4Bytes = 3145728u + | Align8Bytes = 4194304u + | Align16Bytes = 5242880u + | Align32Bytes = 6291456u + | Align64Bytes = 7340032u + | Align128Bytes = 8388608u + | Align256Bytes = 9437184u + | Align512Bytes = 10485760u + | Align1024Bytes = 11534336u + | Align2048Bytes = 12582912u + | Align4096Bytes = 13631488u + | Align8192Bytes = 14680064u + | AlignMask = 15728640u + | LinkerNRelocOvfl = 16777216u + | MemDiscardable = 33554432u + | MemNotCached = 67108864u + | MemNotPaged = 134217728u + | MemShared = 268435456u + | MemExecute = 536870912u + | MemRead = 1073741824u + | MemWrite = 2147483648u + type ResourceSection = + class + new : sectionBytes:byte [] * relocations:uint32 [] -> ResourceSection + new : unit -> ResourceSection + member Relocations : uint32 [] + member SectionBytes : byte [] + end + [] + type StreamExtensions = + class + new : unit -> StreamExtensions + [] + static member + TryReadAll : stream:System.IO.Stream * buffer:byte [] * offset:int * + count:int -> int + end + type COFFResourceReader = + class + new : unit -> COFFResourceReader + static member + private ConfirmSectionValues : hdr:System.Reflection.PortableExecutable.SectionHeader * + fileSize:int64 -> unit + static member + ReadWin32ResourcesFromCOFF : stream:System.IO.Stream -> + ResourceSection + end + [] + type ICONDIRENTRY = + struct + val mutable bWidth: BYTE + val mutable bHeight: BYTE + val mutable bColorCount: BYTE + val mutable bReserved: BYTE + val mutable wPlanes: WORD + val mutable wBitCount: WORD + val mutable dwBytesInRes: DWORD + val mutable dwImageOffset: DWORD + end + type VersionHelper = + class + new : unit -> VersionHelper + static member + GenerateVersionFromPatternAndCurrentTime : time:System.DateTime * + pattern:System.Version -> + System.Version + static member + private TryGetValue : s:string * value:byref -> bool + static member + TryParse : s:string * version:byref -> bool + static member + private TryParse : s:string * allowWildcard:bool * maxValue:uint16 * + allowPartialParse:bool * + version:byref -> bool + static member + TryParseAssemblyVersion : s:string * allowWildcard:bool * + version:byref -> bool + static member private NullVersion : System.Version + end + type VersionResourceSerializer = + class + new : isDll:bool * comments:string * companyName:string * + fileDescription:string * fileVersion:string * internalName:string * + legalCopyright:string * legalTrademark:string * + originalFileName:string * productName:string * + productVersion:string * assemblyVersion:System.Version -> + VersionResourceSerializer + new : unit -> VersionResourceSerializer + static member private KEYBYTES : sz:string -> int + static member private KEYSIZE : sz:string -> int + static member private PadKeyLen : cb:int -> int + static member private PadToDword : cb:int -> int + static member + private SizeofVerString : lpszKey:string * lpszValue:string -> int + static member + private WriteVersionString : keyValuePair:System.Collections.Generic.KeyValuePair * + writer:System.IO.BinaryWriter -> unit + member GetDataSize : unit -> int + member private GetStringsSize : unit -> int + member + private GetVerStrings : unit -> + seq> + member + private WriteVSFixedFileInfo : writer:System.IO.BinaryWriter -> unit + member WriteVerResource : writer:System.IO.BinaryWriter -> unit + member private FileType : uint32 + member private _assemblyVersionContents : System.Version + member private _commentsContents : string + member private _companyNameContents : string + member private _fileDescriptionContents : string + member private _fileVersionContents : string + member private _internalNameContents : string + member private _isDll : bool + member private _langIdAndCodePageKey : string + member private _legalCopyrightContents : string + member private _legalTrademarksContents : string + member private _originalFileNameContents : string + member private _productNameContents : string + member private _productVersionContents : string + static member private CP_WINUNICODE : uint32 + static member private HDRSIZE : int + static member private VFT_APP : uint32 + static member private VFT_DLL : uint32 + static member private sizeVS_FIXEDFILEINFO : uint16 + static member private stringFileInfoKey : string + static member private translationKey : string + static member private varFileInfoKey : string + static member private vsVersionInfoKey : string + end + [] + type Win32ResourceConversions = + class + new : unit -> Win32ResourceConversions + static member + AppendIconToResourceStream : resStream:System.IO.Stream * + iconStream:System.IO.Stream -> unit + static member + AppendManifestToResourceStream : resStream:System.IO.Stream * + manifestStream:System.IO.Stream * + isDll:bool -> unit + static member + AppendVersionToResourceStream : resStream:System.IO.Stream * + isDll:bool * fileVersion:string * + originalFileName:string * + internalName:string * + productVersion:string * + assemblyVersion:System.Version * + ?fileDescription:string * + ?legalCopyright:string * + ?legalTrademarks:string * + ?productName:string * ?comments:string * + ?companyName:string -> unit + end + type Win32Resource = + class + new : data:byte [] * codePage:DWORD * languageId:DWORD * id:int * + name:string * typeId:int * typeName:string -> Win32Resource + member CodePage : DWORD + member Data : byte [] + member Id : int + member LanguageId : DWORD + member Name : string + member TypeId : int + member TypeName : string + end + type Directory = + class + new : name:string * id:int -> Directory + member Entries : System.Collections.Generic.List + member ID : int + member Name : string + member NumberOfIdEntries : uint16 + member NumberOfNamedEntries : uint16 + end + [] + type NativeResourceWriter = + class + new : unit -> NativeResourceWriter + static member + private CompareResourceIdentifiers : xOrdinal:int * xString:string * + yOrdinal:int * yString:string -> + int + static member + private CompareResources : left:Win32Resource -> + right:Win32Resource -> int + static member + SerializeWin32Resources : builder:System.Reflection.Metadata.BlobBuilder * + theResources:System.Collections.Generic.IEnumerable * + resourcesRva:int -> unit + static member private SizeOfDirectory : directory:Directory -> uint32 + static member + SortResources : resources:System.Collections.Generic.IEnumerable -> + System.Collections.Generic.IEnumerable + static member + private WriteDirectory : directory:Directory * + writer:System.Reflection.Metadata.BlobBuilder * + offset:uint32 * level:uint32 * + sizeOfDirectoryTree:uint32 * + virtualAddressBase:int * + dataWriter:System.Reflection.Metadata.BlobBuilder -> + unit + end + end + +namespace FSharp.Compiler.AbstractIL.Internal + module internal Support = begin + val DateTime1970Jan01 : System.DateTime + val absilWriteGetTimeStamp : unit -> int + val inline ignore : _x:'a -> unit + type IStream = System.Runtime.InteropServices.ComTypes.IStream + val check : _action:'a -> hresult:int -> unit + val MAX_PATH : int + val E_FAIL : int + val bytesToWord : b0:byte * b1:byte -> int16 + val bytesToDWord : b0:byte * b1:byte * b2:byte * b3:byte -> int + val bytesToQWord : + b0:byte * b1:byte * b2:byte * b3:byte * b4:byte * b5:byte * b6:byte * + b7:byte -> int64 + val dwToBytes : n:int -> byte [] * int + val wToBytes : n:int16 -> byte [] * int + type IMAGE_FILE_HEADER = + class + new : m:int16 * secs:int16 * tds:int32 * ptst:int32 * nos:int32 * + soh:int16 * c:int16 -> IMAGE_FILE_HEADER + member toBytes : unit -> byte [] + member Characteristics : int16 + member Machine : int16 + member NumberOfSections : int16 + member NumberOfSymbols : int32 + member PointerToSymbolTable : int32 + member SizeOfOptionalHeader : int16 + member TimeDateStamp : int32 + static member Width : int + end + val bytesToIFH : buffer:byte [] -> offset:int -> IMAGE_FILE_HEADER + type IMAGE_SECTION_HEADER = + class + new : n:int64 * ai:int32 * va:int32 * srd:int32 * prd:int32 * pr:int32 * + pln:int32 * nr:int16 * nl:int16 * c:int32 -> IMAGE_SECTION_HEADER + member toBytes : unit -> byte [] + member Characteristics : int32 + member Name : int64 + member NumberOfLineNumbers : int16 + member NumberOfRelocations : int16 + member PhysicalAddress : int32 + member PointerToLineNumbers : int32 + member PointerToRawData : int32 + member PointerToRelocations : int32 + member SizeOfRawData : int32 + member VirtualAddress : int32 + member VirtualSize : int32 + static member Width : int + end + val bytesToISH : buffer:byte [] -> offset:int -> IMAGE_SECTION_HEADER + type IMAGE_SYMBOL = + class + new : n:int64 * v:int32 * sn:int16 * t:int16 * sc:byte * nas:byte -> + IMAGE_SYMBOL + member toBytes : unit -> byte [] + member Name : int64 + member NumberOfAuxSymbols : byte + member SectionNumber : int16 + member StorageClass : byte + member Type : int16 + member Value : int32 + static member Width : int + end + val bytesToIS : buffer:byte [] -> offset:int -> IMAGE_SYMBOL + type IMAGE_RELOCATION = + class + new : va:int32 * sti:int32 * t:int16 -> IMAGE_RELOCATION + member toBytes : unit -> byte [] + member RelocCount : int32 + member SymbolTableIndex : int32 + member Type : int16 + member VirtualAddress : int32 + static member Width : int + end + val bytesToIR : buffer:byte [] -> offset:int -> IMAGE_RELOCATION + type IMAGE_RESOURCE_DIRECTORY = + class + new : c:int32 * tds:int32 * mjv:int16 * mnv:int16 * nne:int16 * + nie:int16 -> IMAGE_RESOURCE_DIRECTORY + member toBytes : unit -> byte [] + member Characteristics : int32 + member MajorVersion : int16 + member MinorVersion : int16 + member NumberOfIdEntries : int16 + member NumberOfNamedEntries : int16 + member TimeDateStamp : int32 + static member Width : int + end + val bytesToIRD : buffer:byte [] -> offset:int -> IMAGE_RESOURCE_DIRECTORY + type IMAGE_RESOURCE_DIRECTORY_ENTRY = + class + new : n:int32 * o:int32 -> IMAGE_RESOURCE_DIRECTORY_ENTRY + member toBytes : unit -> byte [] + member DataIsDirectory : bool + member Name : int32 + member OffsetToData : int32 + member OffsetToDirectory : int32 + static member Width : int + end + val bytesToIRDE : + buffer:byte [] -> offset:int -> IMAGE_RESOURCE_DIRECTORY_ENTRY + type IMAGE_RESOURCE_DATA_ENTRY = + class + new : o:int32 * s:int32 * c:int32 * r:int32 -> IMAGE_RESOURCE_DATA_ENTRY + member toBytes : unit -> unit + member CodePage : int32 + member OffsetToData : int32 + member Reserved : int32 + member Size : int32 + static member Width : int + end + val bytesToIRDataE : + buffer:byte [] -> offset:int -> IMAGE_RESOURCE_DATA_ENTRY + type ResFormatHeader = + class + new : unit -> ResFormatHeader + member toBytes : unit -> byte [] + member Characteristics : int + member DataSize : int + member DataVersion : int + member HeaderSize : int + member LangID : int16 + member MemFlags : int16 + member NameID : int + member TypeID : int + member Version : int + static member Width : int + end + type ResFormatNode = + class + new : tid:int32 * nid:int32 * lid:int32 * dataOffset:int32 * + pbLinkedResource:byte [] -> ResFormatNode + member + Save : ulLinkedResourceBaseRVA:int32 * pbLinkedResource:byte [] * + pUnlinkedResource:byte [] * offset:int -> int + member DataEntry : IMAGE_RESOURCE_DATA_ENTRY + member Name : byte [] + member ResHdr : ResFormatHeader + member Type : byte [] + end + val linkNativeResources : + unlinkedResources:byte [] list -> rva:int32 -> byte [] + val unlinkResource : int32 -> byte [] -> byte [] + end + +namespace FSharp.Compiler.AbstractIL.Internal + module internal AsciiParser = begin + val pfailwith : s:string -> 'a + type ResolvedAtMethodSpecScope<'T> = + | ResolvedAtMethodSpecScope of (IL.ILGenericParameterDefs -> 'T) + val noMethodSpecScope : x:'a -> ResolvedAtMethodSpecScope<'a> + val resolveMethodSpecScope : + ResolvedAtMethodSpecScope<'a> -> x:IL.ILGenericParameterDefs -> 'a + val resolveMethodSpecScopeThen : + ResolvedAtMethodSpecScope<'a> -> + g:('a -> ResolvedAtMethodSpecScope<'b>) -> ResolvedAtMethodSpecScope<'b> + val resolveCurrentMethodSpecScope : obj:ResolvedAtMethodSpecScope<'a> -> 'a + type token = + | VOID + | VARARG + | VALUETYPE + | VALUE + | UNSIGNED + | UNMANAGED + | UINT8 + | UINT64 + | UINT32 + | UINT16 + | UINT + | STRING + | STAR + | SLASH + | RPAREN + | RBRACK + | PLUS + | OBJECT + | NATIVE + | METHOD + | LPAREN + | LESS + | LBRACK + | INT8 + | INT64 + | INT32 + | INT16 + | INT + | INSTANCE + | GREATER + | FLOAT64 + | FLOAT32 + | FIELD + | EXPLICIT + | EOF + | ELIPSES + | DOT + | DEFAULT + | DCOLON + | COMMA + | CLASS + | CHAR + | BYTEARRAY + | BOOL + | BANG + | AMP + | VAL_SQSTRING of string + | VAL_QSTRING of string + | VAL_DOTTEDNAME of string + | VAL_ID of string + | VAL_HEXBYTE of int + | INSTR_VALUETYPE of AsciiConstants.ValueTypeInstr + | INSTR_INT_TYPE of AsciiConstants.IntTypeInstr + | INSTR_TYPE of AsciiConstants.TypeInstr + | INSTR_TOK of AsciiConstants.TokenInstr + | INSTR_STRING of AsciiConstants.StringInstr + | INSTR_NONE of AsciiConstants.NoArgInstr + | INSTR_R of AsciiConstants.DoubleInstr + | INSTR_I8 of AsciiConstants.Int64Instr + | INSTR_I32_I32 of AsciiConstants.Int32Int32Instr + | INSTR_I of AsciiConstants.Int32Instr + | VAL_FLOAT64 of double + | VAL_INT32_ELIPSES of int32 + | VAL_INT64 of int64 + type tokenId = + | TOKEN_VOID + | TOKEN_VARARG + | TOKEN_VALUETYPE + | TOKEN_VALUE + | TOKEN_UNSIGNED + | TOKEN_UNMANAGED + | TOKEN_UINT8 + | TOKEN_UINT64 + | TOKEN_UINT32 + | TOKEN_UINT16 + | TOKEN_UINT + | TOKEN_STRING + | TOKEN_STAR + | TOKEN_SLASH + | TOKEN_RPAREN + | TOKEN_RBRACK + | TOKEN_PLUS + | TOKEN_OBJECT + | TOKEN_NATIVE + | TOKEN_METHOD + | TOKEN_LPAREN + | TOKEN_LESS + | TOKEN_LBRACK + | TOKEN_INT8 + | TOKEN_INT64 + | TOKEN_INT32 + | TOKEN_INT16 + | TOKEN_INT + | TOKEN_INSTANCE + | TOKEN_GREATER + | TOKEN_FLOAT64 + | TOKEN_FLOAT32 + | TOKEN_FIELD + | TOKEN_EXPLICIT + | TOKEN_EOF + | TOKEN_ELIPSES + | TOKEN_DOT + | TOKEN_DEFAULT + | TOKEN_DCOLON + | TOKEN_COMMA + | TOKEN_CLASS + | TOKEN_CHAR + | TOKEN_BYTEARRAY + | TOKEN_BOOL + | TOKEN_BANG + | TOKEN_AMP + | TOKEN_VAL_SQSTRING + | TOKEN_VAL_QSTRING + | TOKEN_VAL_DOTTEDNAME + | TOKEN_VAL_ID + | TOKEN_VAL_HEXBYTE + | TOKEN_INSTR_VALUETYPE + | TOKEN_INSTR_INT_TYPE + | TOKEN_INSTR_TYPE + | TOKEN_INSTR_TOK + | TOKEN_INSTR_STRING + | TOKEN_INSTR_NONE + | TOKEN_INSTR_R + | TOKEN_INSTR_I8 + | TOKEN_INSTR_I32_I32 + | TOKEN_INSTR_I + | TOKEN_VAL_FLOAT64 + | TOKEN_VAL_INT32_ELIPSES + | TOKEN_VAL_INT64 + | TOKEN_end_of_input + | TOKEN_error + type nonTerminalId = + | NONTERM__startilInstrs + | NONTERM__startilType + | NONTERM_ilType + | NONTERM_ilInstrs + | NONTERM_compQstring + | NONTERM_methodName + | NONTERM_instrs2 + | NONTERM_instr + | NONTERM_name1 + | NONTERM_className + | NONTERM_slashedName + | NONTERM_typeNameInst + | NONTERM_typeName + | NONTERM_typSpec + | NONTERM_callConv + | NONTERM_callKind + | NONTERM_typ + | NONTERM_bounds1 + | NONTERM_bound + | NONTERM_id + | NONTERM_int32 + | NONTERM_int64 + | NONTERM_float64 + | NONTERM_opt_actual_tyargs + | NONTERM_actual_tyargs + | NONTERM_actualTypSpecs + val tagOfToken : t:token -> int + val tokenTagToTokenId : tokenIdx:int -> tokenId + val prodIdxToNonTerminal : prodIdx:int -> nonTerminalId + val _fsyacc_endOfInputTag : int + val _fsyacc_tagOfErrorTerminal : int + val token_to_string : t:token -> string + val _fsyacc_dataOfToken : t:token -> System.Object + val _fsyacc_gotos : uint16 [] + val _fsyacc_sparseGotoTableRowOffsets : uint16 [] + val _fsyacc_stateToProdIdxsTableElements : uint16 [] + val _fsyacc_stateToProdIdxsTableRowOffsets : uint16 [] + val _fsyacc_action_rows : int + val _fsyacc_actionTableElements : uint16 [] + val _fsyacc_actionTableRowOffsets : uint16 [] + val _fsyacc_reductionSymbolCounts : uint16 [] + val _fsyacc_productionToNonTerminalTable : uint16 [] + val _fsyacc_immediateActions : uint16 [] + val _fsyacc_reductions : + unit -> (Internal.Utilities.Text.Parsing.IParseState -> obj) [] + val tables : unit -> Internal.Utilities.Text.Parsing.Tables + val engine : + lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + startState:int -> obj + val ilInstrs : + lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + IL.ILInstr array + val ilType : + lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> IL.ILType + end + +namespace FSharp.Compiler.AbstractIL.Internal + module internal AsciiLexer = begin + val lexeme : lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> string + val lexemeChar : + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> n:int -> char + val unexpectedChar : _lexbuf:'a -> 'b + val keywords : Lazy<(string * AsciiParser.token) list> + val kwdInstrTable : + Lazy> + val kwdOrInstr : s:string -> AsciiParser.token + val evalDigit : ch:char -> int + val kwdOrInstrOrId : s:string -> AsciiParser.token + val trans : uint16 [] array + val actions : uint16 [] + val _fslex_tables : Internal.Utilities.Text.Lexing.UnicodeTables + val _fslex_dummy : unit -> 'a + val token : + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> AsciiParser.token + end + +namespace FSharp.Compiler.AbstractIL.Internal + module internal BinaryConstants = begin + [] + type TableName = + struct + new : idx:int -> TableName + static member FromIndex : int -> TableName + member Index : int + end + module TableNames = begin + val Module : TableName + val TypeRef : TableName + val TypeDef : TableName + val FieldPtr : TableName + val Field : TableName + val MethodPtr : TableName + val Method : TableName + val ParamPtr : TableName + val Param : TableName + val InterfaceImpl : TableName + val MemberRef : TableName + val Constant : TableName + val CustomAttribute : TableName + val FieldMarshal : TableName + val Permission : TableName + val ClassLayout : TableName + val FieldLayout : TableName + val StandAloneSig : TableName + val EventMap : TableName + val EventPtr : TableName + val Event : TableName + val PropertyMap : TableName + val PropertyPtr : TableName + val Property : TableName + val MethodSemantics : TableName + val MethodImpl : TableName + val ModuleRef : TableName + val TypeSpec : TableName + val ImplMap : TableName + val FieldRVA : TableName + val ENCLog : TableName + val ENCMap : TableName + val Assembly : TableName + val AssemblyProcessor : TableName + val AssemblyOS : TableName + val AssemblyRef : TableName + val AssemblyRefProcessor : TableName + val AssemblyRefOS : TableName + val File : TableName + val ExportedType : TableName + val ManifestResource : TableName + val Nested : TableName + val GenericParam : TableName + val MethodSpec : TableName + val GenericParamConstraint : TableName + val UserStrings : TableName + end + val sortedTableInfo : (TableName * int) list + [] + type TypeDefOrRefTag = + struct + new : tag:int32 -> TypeDefOrRefTag + member Tag : int32 + end + val tdor_TypeDef : TypeDefOrRefTag + val tdor_TypeRef : TypeDefOrRefTag + val tdor_TypeSpec : TypeDefOrRefTag + val mkTypeDefOrRefOrSpecTag : int -> TypeDefOrRefTag + [] + type HasConstantTag = + struct + new : tag:int32 -> HasConstantTag + member Tag : int32 + end + val hc_FieldDef : HasConstantTag + val hc_ParamDef : HasConstantTag + val hc_Property : HasConstantTag + val mkHasConstantTag : int -> HasConstantTag + [] + type HasCustomAttributeTag = + struct + new : tag:int32 -> HasCustomAttributeTag + member Tag : int32 + end + val hca_MethodDef : HasCustomAttributeTag + val hca_FieldDef : HasCustomAttributeTag + val hca_TypeRef : HasCustomAttributeTag + val hca_TypeDef : HasCustomAttributeTag + val hca_ParamDef : HasCustomAttributeTag + val hca_InterfaceImpl : HasCustomAttributeTag + val hca_MemberRef : HasCustomAttributeTag + val hca_Module : HasCustomAttributeTag + val hca_Permission : HasCustomAttributeTag + val hca_Property : HasCustomAttributeTag + val hca_Event : HasCustomAttributeTag + val hca_StandAloneSig : HasCustomAttributeTag + val hca_ModuleRef : HasCustomAttributeTag + val hca_TypeSpec : HasCustomAttributeTag + val hca_Assembly : HasCustomAttributeTag + val hca_AssemblyRef : HasCustomAttributeTag + val hca_File : HasCustomAttributeTag + val hca_ExportedType : HasCustomAttributeTag + val hca_ManifestResource : HasCustomAttributeTag + val hca_GenericParam : HasCustomAttributeTag + val hca_GenericParamConstraint : HasCustomAttributeTag + val hca_MethodSpec : HasCustomAttributeTag + val mkHasCustomAttributeTag : int -> HasCustomAttributeTag + [] + type HasFieldMarshalTag = + struct + new : tag:int32 -> HasFieldMarshalTag + member Tag : int32 + end + val hfm_FieldDef : HasFieldMarshalTag + val hfm_ParamDef : HasFieldMarshalTag + val mkHasFieldMarshalTag : int -> HasFieldMarshalTag + [] + type HasDeclSecurityTag = + struct + new : tag:int32 -> HasDeclSecurityTag + member Tag : int32 + end + val hds_TypeDef : HasDeclSecurityTag + val hds_MethodDef : HasDeclSecurityTag + val hds_Assembly : HasDeclSecurityTag + val mkHasDeclSecurityTag : int -> HasDeclSecurityTag + [] + type MemberRefParentTag = + struct + new : tag:int32 -> MemberRefParentTag + member Tag : int32 + end + val mrp_TypeRef : MemberRefParentTag + val mrp_ModuleRef : MemberRefParentTag + val mrp_MethodDef : MemberRefParentTag + val mrp_TypeSpec : MemberRefParentTag + val mkMemberRefParentTag : int -> MemberRefParentTag + [] + type HasSemanticsTag = + struct + new : tag:int32 -> HasSemanticsTag + member Tag : int32 + end + val hs_Event : HasSemanticsTag + val hs_Property : HasSemanticsTag + val mkHasSemanticsTag : int -> HasSemanticsTag + [] + type MethodDefOrRefTag = + struct + new : tag:int32 -> MethodDefOrRefTag + member Tag : int32 + end + val mdor_MethodDef : MethodDefOrRefTag + val mdor_MemberRef : MethodDefOrRefTag + val mdor_MethodSpec : MethodDefOrRefTag + val mkMethodDefOrRefTag : int -> MethodDefOrRefTag + [] + type MemberForwardedTag = + struct + new : tag:int32 -> MemberForwardedTag + member Tag : int32 + end + val mf_FieldDef : MemberForwardedTag + val mf_MethodDef : MemberForwardedTag + val mkMemberForwardedTag : int -> MemberForwardedTag + [] + type ImplementationTag = + struct + new : tag:int32 -> ImplementationTag + member Tag : int32 + end + val i_File : ImplementationTag + val i_AssemblyRef : ImplementationTag + val i_ExportedType : ImplementationTag + val mkImplementationTag : int -> ImplementationTag + [] + type CustomAttributeTypeTag = + struct + new : tag:int32 -> CustomAttributeTypeTag + member Tag : int32 + end + val cat_MethodDef : CustomAttributeTypeTag + val cat_MemberRef : CustomAttributeTypeTag + val mkILCustomAttributeTypeTag : int -> CustomAttributeTypeTag + [] + type ResolutionScopeTag = + struct + new : tag:int32 -> ResolutionScopeTag + member Tag : int32 + end + val rs_Module : ResolutionScopeTag + val rs_ModuleRef : ResolutionScopeTag + val rs_AssemblyRef : ResolutionScopeTag + val rs_TypeRef : ResolutionScopeTag + val mkResolutionScopeTag : int -> ResolutionScopeTag + [] + type TypeOrMethodDefTag = + struct + new : tag:int32 -> TypeOrMethodDefTag + member Tag : int32 + end + val tomd_TypeDef : TypeOrMethodDefTag + val tomd_MethodDef : TypeOrMethodDefTag + val mkTypeOrMethodDefTag : int -> TypeOrMethodDefTag + val et_END : byte + val et_VOID : byte + val et_BOOLEAN : byte + val et_CHAR : byte + val et_I1 : byte + val et_U1 : byte + val et_I2 : byte + val et_U2 : byte + val et_I4 : byte + val et_U4 : byte + val et_I8 : byte + val et_U8 : byte + val et_R4 : byte + val et_R8 : byte + val et_STRING : byte + val et_PTR : byte + val et_BYREF : byte + val et_VALUETYPE : byte + val et_CLASS : byte + val et_VAR : byte + val et_ARRAY : byte + val et_WITH : byte + val et_TYPEDBYREF : byte + val et_I : byte + val et_U : byte + val et_FNPTR : byte + val et_OBJECT : byte + val et_SZARRAY : byte + val et_MVAR : byte + val et_CMOD_REQD : byte + val et_CMOD_OPT : byte + val et_SENTINEL : byte + val et_PINNED : byte + val i_nop : int + val i_break : int + val i_ldarg_0 : int + val i_ldarg_1 : int + val i_ldarg_2 : int + val i_ldarg_3 : int + val i_ldloc_0 : int + val i_ldloc_1 : int + val i_ldloc_2 : int + val i_ldloc_3 : int + val i_stloc_0 : int + val i_stloc_1 : int + val i_stloc_2 : int + val i_stloc_3 : int + val i_ldarg_s : int + val i_ldarga_s : int + val i_starg_s : int + val i_ldloc_s : int + val i_ldloca_s : int + val i_stloc_s : int + val i_ldnull : int + val i_ldc_i4_m1 : int + val i_ldc_i4_0 : int + val i_ldc_i4_1 : int + val i_ldc_i4_2 : int + val i_ldc_i4_3 : int + val i_ldc_i4_4 : int + val i_ldc_i4_5 : int + val i_ldc_i4_6 : int + val i_ldc_i4_7 : int + val i_ldc_i4_8 : int + val i_ldc_i4_s : int + val i_ldc_i4 : int + val i_ldc_i8 : int + val i_ldc_r4 : int + val i_ldc_r8 : int + val i_dup : int + val i_pop : int + val i_jmp : int + val i_call : int + val i_calli : int + val i_ret : int + val i_br_s : int + val i_brfalse_s : int + val i_brtrue_s : int + val i_beq_s : int + val i_bge_s : int + val i_bgt_s : int + val i_ble_s : int + val i_blt_s : int + val i_bne_un_s : int + val i_bge_un_s : int + val i_bgt_un_s : int + val i_ble_un_s : int + val i_blt_un_s : int + val i_br : int + val i_brfalse : int + val i_brtrue : int + val i_beq : int + val i_bge : int + val i_bgt : int + val i_ble : int + val i_blt : int + val i_bne_un : int + val i_bge_un : int + val i_bgt_un : int + val i_ble_un : int + val i_blt_un : int + val i_switch : int + val i_ldind_i1 : int + val i_ldind_u1 : int + val i_ldind_i2 : int + val i_ldind_u2 : int + val i_ldind_i4 : int + val i_ldind_u4 : int + val i_ldind_i8 : int + val i_ldind_i : int + val i_ldind_r4 : int + val i_ldind_r8 : int + val i_ldind_ref : int + val i_stind_ref : int + val i_stind_i1 : int + val i_stind_i2 : int + val i_stind_i4 : int + val i_stind_i8 : int + val i_stind_r4 : int + val i_stind_r8 : int + val i_add : int + val i_sub : int + val i_mul : int + val i_div : int + val i_div_un : int + val i_rem : int + val i_rem_un : int + val i_and : int + val i_or : int + val i_xor : int + val i_shl : int + val i_shr : int + val i_shr_un : int + val i_neg : int + val i_not : int + val i_conv_i1 : int + val i_conv_i2 : int + val i_conv_i4 : int + val i_conv_i8 : int + val i_conv_r4 : int + val i_conv_r8 : int + val i_conv_u4 : int + val i_conv_u8 : int + val i_callvirt : int + val i_cpobj : int + val i_ldobj : int + val i_ldstr : int + val i_newobj : int + val i_castclass : int + val i_isinst : int + val i_conv_r_un : int + val i_unbox : int + val i_throw : int + val i_ldfld : int + val i_ldflda : int + val i_stfld : int + val i_ldsfld : int + val i_ldsflda : int + val i_stsfld : int + val i_stobj : int + val i_conv_ovf_i1_un : int + val i_conv_ovf_i2_un : int + val i_conv_ovf_i4_un : int + val i_conv_ovf_i8_un : int + val i_conv_ovf_u1_un : int + val i_conv_ovf_u2_un : int + val i_conv_ovf_u4_un : int + val i_conv_ovf_u8_un : int + val i_conv_ovf_i_un : int + val i_conv_ovf_u_un : int + val i_box : int + val i_newarr : int + val i_ldlen : int + val i_ldelema : int + val i_ldelem_i1 : int + val i_ldelem_u1 : int + val i_ldelem_i2 : int + val i_ldelem_u2 : int + val i_ldelem_i4 : int + val i_ldelem_u4 : int + val i_ldelem_i8 : int + val i_ldelem_i : int + val i_ldelem_r4 : int + val i_ldelem_r8 : int + val i_ldelem_ref : int + val i_stelem_i : int + val i_stelem_i1 : int + val i_stelem_i2 : int + val i_stelem_i4 : int + val i_stelem_i8 : int + val i_stelem_r4 : int + val i_stelem_r8 : int + val i_stelem_ref : int + val i_conv_ovf_i1 : int + val i_conv_ovf_u1 : int + val i_conv_ovf_i2 : int + val i_conv_ovf_u2 : int + val i_conv_ovf_i4 : int + val i_conv_ovf_u4 : int + val i_conv_ovf_i8 : int + val i_conv_ovf_u8 : int + val i_refanyval : int + val i_ckfinite : int + val i_mkrefany : int + val i_ldtoken : int + val i_conv_u2 : int + val i_conv_u1 : int + val i_conv_i : int + val i_conv_ovf_i : int + val i_conv_ovf_u : int + val i_add_ovf : int + val i_add_ovf_un : int + val i_mul_ovf : int + val i_mul_ovf_un : int + val i_sub_ovf : int + val i_sub_ovf_un : int + val i_endfinally : int + val i_leave : int + val i_leave_s : int + val i_stind_i : int + val i_conv_u : int + val i_arglist : int + val i_ceq : int + val i_cgt : int + val i_cgt_un : int + val i_clt : int + val i_clt_un : int + val i_ldftn : int + val i_ldvirtftn : int + val i_ldarg : int + val i_ldarga : int + val i_starg : int + val i_ldloc : int + val i_ldloca : int + val i_stloc : int + val i_localloc : int + val i_endfilter : int + val i_unaligned : int + val i_volatile : int + val i_constrained : int + val i_readonly : int + val i_tail : int + val i_initobj : int + val i_cpblk : int + val i_initblk : int + val i_rethrow : int + val i_sizeof : int + val i_refanytype : int + val i_ldelem_any : int + val i_stelem_any : int + val i_unbox_any : int + val mk_ldc : i:int32 -> IL.ILInstr + val noArgInstrs : Lazy<(int * IL.ILInstr) list> + val isNoArgInstr : IL.ILInstr -> bool + val ILCmpInstrMap : + Lazy> + val ILCmpInstrRevMap : + Lazy> + val nt_VOID : byte + val nt_BOOLEAN : byte + val nt_I1 : byte + val nt_U1 : byte + val nt_I2 : byte + val nt_U2 : byte + val nt_I4 : byte + val nt_U4 : byte + val nt_I8 : byte + val nt_U8 : byte + val nt_R4 : byte + val nt_R8 : byte + val nt_SYSCHAR : byte + val nt_VARIANT : byte + val nt_CURRENCY : byte + val nt_PTR : byte + val nt_DECIMAL : byte + val nt_DATE : byte + val nt_BSTR : byte + val nt_LPSTR : byte + val nt_LPWSTR : byte + val nt_LPTSTR : byte + val nt_FIXEDSYSSTRING : byte + val nt_OBJECTREF : byte + val nt_IUNKNOWN : byte + val nt_IDISPATCH : byte + val nt_STRUCT : byte + val nt_INTF : byte + val nt_SAFEARRAY : byte + val nt_FIXEDARRAY : byte + val nt_INT : byte + val nt_UINT : byte + val nt_NESTEDSTRUCT : byte + val nt_BYVALSTR : byte + val nt_ANSIBSTR : byte + val nt_TBSTR : byte + val nt_VARIANTBOOL : byte + val nt_FUNC : byte + val nt_ASANY : byte + val nt_ARRAY : byte + val nt_LPSTRUCT : byte + val nt_CUSTOMMARSHALER : byte + val nt_ERROR : byte + val nt_LPUTF8STR : byte + val nt_MAX : byte + val vt_EMPTY : int + val vt_NULL : int + val vt_I2 : int + val vt_I4 : int + val vt_R4 : int + val vt_R8 : int + val vt_CY : int + val vt_DATE : int + val vt_BSTR : int + val vt_DISPATCH : int + val vt_ERROR : int + val vt_BOOL : int + val vt_VARIANT : int + val vt_UNKNOWN : int + val vt_DECIMAL : int + val vt_I1 : int + val vt_UI1 : int + val vt_UI2 : int + val vt_UI4 : int + val vt_I8 : int + val vt_UI8 : int + val vt_INT : int + val vt_UINT : int + val vt_VOID : int + val vt_HRESULT : int + val vt_PTR : int + val vt_SAFEARRAY : int + val vt_CARRAY : int + val vt_USERDEFINED : int + val vt_LPSTR : int + val vt_LPWSTR : int + val vt_RECORD : int + val vt_FILETIME : int + val vt_BLOB : int + val vt_STREAM : int + val vt_STORAGE : int + val vt_STREAMED_OBJECT : int + val vt_STORED_OBJECT : int + val vt_BLOB_OBJECT : int + val vt_CF : int + val vt_CLSID : int + val vt_VECTOR : int + val vt_ARRAY : int + val vt_BYREF : int + val ILNativeTypeMap : Lazy<(byte * IL.ILNativeType) list> + val ILNativeTypeRevMap : Lazy<(IL.ILNativeType * byte) list> + val ILVariantTypeMap : Lazy<(IL.ILNativeVariant * int) list> + val ILVariantTypeRevMap : Lazy<(int * IL.ILNativeVariant) list> + val ILSecurityActionMap : Lazy<(IL.ILSecurityAction * int) list> + val ILSecurityActionRevMap : Lazy<(int * IL.ILSecurityAction) list> + val e_CorILMethod_TinyFormat : byte + val e_CorILMethod_FatFormat : byte + val e_CorILMethod_FormatMask : byte + val e_CorILMethod_MoreSects : byte + val e_CorILMethod_InitLocals : byte + val e_CorILMethod_Sect_EHTable : byte + val e_CorILMethod_Sect_FatFormat : byte + val e_CorILMethod_Sect_MoreSects : byte + val e_COR_ILEXCEPTION_CLAUSE_EXCEPTION : int + val e_COR_ILEXCEPTION_CLAUSE_FILTER : int + val e_COR_ILEXCEPTION_CLAUSE_FINALLY : int + val e_COR_ILEXCEPTION_CLAUSE_FAULT : int + val e_IMAGE_CEE_CS_CALLCONV_FASTCALL : byte + val e_IMAGE_CEE_CS_CALLCONV_STDCALL : byte + val e_IMAGE_CEE_CS_CALLCONV_THISCALL : byte + val e_IMAGE_CEE_CS_CALLCONV_CDECL : byte + val e_IMAGE_CEE_CS_CALLCONV_VARARG : byte + val e_IMAGE_CEE_CS_CALLCONV_FIELD : byte + val e_IMAGE_CEE_CS_CALLCONV_LOCAL_SIG : byte + val e_IMAGE_CEE_CS_CALLCONV_PROPERTY : byte + val e_IMAGE_CEE_CS_CALLCONV_GENERICINST : byte + val e_IMAGE_CEE_CS_CALLCONV_GENERIC : byte + val e_IMAGE_CEE_CS_CALLCONV_INSTANCE : byte + val e_IMAGE_CEE_CS_CALLCONV_INSTANCE_EXPLICIT : byte + end + +namespace FSharp.Compiler.AbstractIL + module ILBinaryReader = begin + val checking : bool + val logging : bool + val noStableFileHeuristic : bool + val alwaysMemoryMapFSC : bool + val stronglyHeldReaderCacheSizeDefault : int + val stronglyHeldReaderCacheSize : int + val singleOfBits : x:int32 -> float32 + val doubleOfBits : x:int64 -> float + val align : alignment:int -> n:int -> int + val uncodedToken : tab:Internal.BinaryConstants.TableName -> idx:int -> int + val i32ToUncodedToken : tok:int -> Internal.BinaryConstants.TableName * int + [] + type TaggedIndex<'T> = + struct + new : tag:'T * index:int32 -> TaggedIndex<'T> + val tag: 'T + val index: int32 + end + val uncodedTokenToTypeDefOrRefOrSpec : + tab:Internal.BinaryConstants.TableName * tok:int32 -> + TaggedIndex + val uncodedTokenToMethodDefOrRef : + tab:Internal.BinaryConstants.TableName * tok:int32 -> + TaggedIndex + val ( |TaggedIndex| ) : x:TaggedIndex<'T> -> 'T * int32 + val inline tokToTaggedIdx : + f:(int -> 'a) -> nbits:int -> tok:int -> TaggedIndex<'a> + type Statistics = + { mutable rawMemoryFileCount: int + mutable memoryMapFileOpenedCount: int + mutable memoryMapFileClosedCount: int + mutable weakByteFileCount: int + mutable byteFileCount: int } + val stats : Statistics + val GetStatistics : unit -> Statistics + type private BinaryView = Internal.ReadOnlyByteMemory + type BinaryFile = + interface + abstract member GetView : unit -> BinaryView + end + type RawMemoryFile = + class + interface BinaryFile + new : fileName:string * obj:obj * addr:nativeint * length:int -> + RawMemoryFile + member HoldObj : unit -> obj + member FileName : string + end + [] + type ByteFile = + class + interface BinaryFile + new : fileName:string * bytes:byte [] -> ByteFile + member FileName : string + end + [] + type WeakByteFile = + class + interface BinaryFile + new : fileName:string * chunk:(int * int) option -> WeakByteFile + member FileName : string + end + val seekReadByte : mdv:BinaryView -> addr:int -> byte + val seekReadBytes : mdv:BinaryView -> addr:int -> len:int -> byte [] + val seekReadInt32 : mdv:BinaryView -> addr:int -> int + val seekReadUInt16 : mdv:BinaryView -> addr:int -> uint16 + val seekReadByteAsInt32 : mdv:BinaryView -> addr:int -> int32 + val seekReadInt64 : mdv:BinaryView -> addr:int -> int64 + val seekReadUInt16AsInt32 : mdv:BinaryView -> addr:int -> int32 + val seekReadCompressedUInt32 : + mdv:BinaryView -> addr:int -> struct (int * int) + val seekReadSByte : mdv:BinaryView -> addr:int -> sbyte + val seekReadSingle : mdv:BinaryView -> addr:int -> float32 + val seekReadDouble : mdv:BinaryView -> addr:int -> float + val seekCountUtf8String : mdv:BinaryView -> addr:int -> n:int -> int + val seekReadUTF8String : mdv:BinaryView -> addr:int -> string + val seekReadBlob : mdv:BinaryView -> addr:int -> byte [] + val seekReadUserString : mdv:BinaryView -> addr:int -> string + val seekReadGuid : mdv:BinaryView -> addr:int -> byte [] + val seekReadUncodedToken : + mdv:BinaryView -> addr:int -> Internal.BinaryConstants.TableName * int + val sigptrCheck : bytes:byte [] -> sigptr:int -> unit + val sigptrGetByte : bytes:byte [] -> sigptr:int -> byte * int + val sigptrGetBool : bytes:byte [] -> sigptr:int -> bool * int + val sigptrGetSByte : bytes:byte [] -> sigptr:int -> sbyte * int + val sigptrGetUInt16 : bytes:byte [] -> sigptr:int -> uint16 * int + val sigptrGetInt16 : bytes:byte [] -> sigptr:int -> int16 * int + val sigptrGetInt32 : bytes:byte [] -> sigptr:int -> int * int + val sigptrGetUInt32 : bytes:byte [] -> sigptr:int -> uint32 * int + val sigptrGetUInt64 : bytes:byte [] -> sigptr:int -> uint64 * int + val sigptrGetInt64 : bytes:byte [] -> sigptr:int -> int64 * int + val sigptrGetSingle : bytes:byte [] -> sigptr:int -> float32 * int + val sigptrGetDouble : bytes:byte [] -> sigptr:int -> float * int + val sigptrGetZInt32 : bytes:byte [] -> sigptr:int -> struct (int * int) + val sigptrFoldAcc : + f:(byte [] -> int -> 'a * int) -> + n:int -> + bytes:byte [] -> sigptr:int -> i:int -> acc:'a list -> 'a list * int + val sigptrFold : + f:(byte [] -> int -> 'a * int) -> + n:int -> bytes:byte [] -> sigptr:int -> 'a list * int + val sigptrFoldStruct : + f:(byte [] -> int -> struct ('a * int)) -> + n:int -> bytes:byte [] -> sigptr:int -> struct ('a list * int) + val sigptrGetBytes : n:int -> bytes:byte [] -> sigptr:int -> byte [] * int + val sigptrGetString : n:int -> bytes:byte [] -> sigptr:int -> string * int + [] + type ILInstrPrefixesRegister = + { mutable al: IL.ILAlignment + mutable tl: IL.ILTailcall + mutable vol: IL.ILVolatility + mutable ro: IL.ILReadonly + mutable constrained: IL.ILType option } + val noPrefixes : mk:'a -> prefixes:ILInstrPrefixesRegister -> 'a + val volatileOrUnalignedPrefix : + mk:(IL.ILAlignment * IL.ILVolatility -> 'a) -> + prefixes:ILInstrPrefixesRegister -> 'a + val volatilePrefix : + mk:(IL.ILVolatility -> 'a) -> prefixes:ILInstrPrefixesRegister -> 'a + val tailPrefix : + mk:(IL.ILTailcall -> 'a) -> prefixes:ILInstrPrefixesRegister -> 'a + val constraintOrTailPrefix : + mk:(IL.ILType option * IL.ILTailcall -> 'a) -> + prefixes:ILInstrPrefixesRegister -> 'a + val readonlyPrefix : + mk:(IL.ILReadonly -> 'a) -> prefixes:ILInstrPrefixesRegister -> 'a + [] + type ILInstrDecoder = + | I_u16_u8_instr of (ILInstrPrefixesRegister -> uint16 -> IL.ILInstr) + | I_u16_u16_instr of (ILInstrPrefixesRegister -> uint16 -> IL.ILInstr) + | I_none_instr of (ILInstrPrefixesRegister -> IL.ILInstr) + | I_i64_instr of (ILInstrPrefixesRegister -> int64 -> IL.ILInstr) + | I_i32_i32_instr of (ILInstrPrefixesRegister -> int32 -> IL.ILInstr) + | I_i32_i8_instr of (ILInstrPrefixesRegister -> int32 -> IL.ILInstr) + | I_r4_instr of (ILInstrPrefixesRegister -> single -> IL.ILInstr) + | I_r8_instr of (ILInstrPrefixesRegister -> double -> IL.ILInstr) + | I_field_instr of + (ILInstrPrefixesRegister -> IL.ILFieldSpec -> IL.ILInstr) + | I_method_instr of + (ILInstrPrefixesRegister -> IL.ILMethodSpec * IL.ILVarArgs -> IL.ILInstr) + | I_unconditional_i32_instr of + (ILInstrPrefixesRegister -> IL.ILCodeLabel -> IL.ILInstr) + | I_unconditional_i8_instr of + (ILInstrPrefixesRegister -> IL.ILCodeLabel -> IL.ILInstr) + | I_conditional_i32_instr of + (ILInstrPrefixesRegister -> IL.ILCodeLabel -> IL.ILInstr) + | I_conditional_i8_instr of + (ILInstrPrefixesRegister -> IL.ILCodeLabel -> IL.ILInstr) + | I_string_instr of (ILInstrPrefixesRegister -> string -> IL.ILInstr) + | I_switch_instr of + (ILInstrPrefixesRegister -> IL.ILCodeLabel list -> IL.ILInstr) + | I_tok_instr of (ILInstrPrefixesRegister -> IL.ILToken -> IL.ILInstr) + | I_sig_instr of + (ILInstrPrefixesRegister -> IL.ILCallingSignature * IL.ILVarArgs -> + IL.ILInstr) + | I_type_instr of (ILInstrPrefixesRegister -> IL.ILType -> IL.ILInstr) + | I_invalid_instr + val mkStind : dt:IL.ILBasicType -> (ILInstrPrefixesRegister -> IL.ILInstr) + val mkLdind : dt:IL.ILBasicType -> (ILInstrPrefixesRegister -> IL.ILInstr) + val instrs : unit -> (int * ILInstrDecoder) list + val oneByteInstrs : ILInstrDecoder [] option ref + val twoByteInstrs : ILInstrDecoder [] option ref + val fillInstrs : unit -> unit + val getOneByteInstr : i:int -> ILInstrDecoder + val getTwoByteInstr : i:int -> ILInstrDecoder + type ImageChunk = + { size: int32 + addr: int32 } + val chunk : sz:int32 -> next:int32 -> ImageChunk * int32 + val nochunk : next:'a -> ImageChunk * 'a + type RowElementKind = + | UShort + | ULong + | Byte + | Data + | GGuid + | Blob + | SString + | SimpleIndex of Internal.BinaryConstants.TableName + | TypeDefOrRefOrSpec + | TypeOrMethodDef + | HasConstant + | HasCustomAttribute + | HasFieldMarshal + | HasDeclSecurity + | MemberRefParent + | HasSemantics + | MethodDefOrRef + | MemberForwarded + | Implementation + | CustomAttributeType + | ResolutionScope + type RowKind = | RowKind of RowElementKind list + val kindAssemblyRef : RowKind + val kindModuleRef : RowKind + val kindFileRef : RowKind + val kindTypeRef : RowKind + val kindTypeSpec : RowKind + val kindTypeDef : RowKind + val kindPropertyMap : RowKind + val kindEventMap : RowKind + val kindInterfaceImpl : RowKind + val kindNested : RowKind + val kindCustomAttribute : RowKind + val kindDeclSecurity : RowKind + val kindMemberRef : RowKind + val kindStandAloneSig : RowKind + val kindFieldDef : RowKind + val kindFieldRVA : RowKind + val kindFieldMarshal : RowKind + val kindConstant : RowKind + val kindFieldLayout : RowKind + val kindParam : RowKind + val kindMethodDef : RowKind + val kindMethodImpl : RowKind + val kindImplMap : RowKind + val kindMethodSemantics : RowKind + val kindProperty : RowKind + val kindEvent : RowKind + val kindManifestResource : RowKind + val kindClassLayout : RowKind + val kindExportedType : RowKind + val kindAssembly : RowKind + val kindGenericParam_v1_1 : RowKind + val kindGenericParam_v2_0 : RowKind + val kindMethodSpec : RowKind + val kindGenericParamConstraint : RowKind + val kindModule : RowKind + val kindIllegal : RowKind + val hcCompare : + TaggedIndex -> + TaggedIndex -> int + val hsCompare : + TaggedIndex -> + TaggedIndex -> int + val hcaCompare : + TaggedIndex -> + TaggedIndex -> int + val mfCompare : + TaggedIndex -> + TaggedIndex -> int + val hdsCompare : + TaggedIndex -> + TaggedIndex -> int + val hfmCompare : + TaggedIndex -> + TaggedIndex -> int + val tomdCompare : + TaggedIndex -> + TaggedIndex -> int + val simpleIndexCompare : idx1:int -> idx2:int -> int + type TypeDefAsTypIdx = + | TypeDefAsTypIdx of IL.ILBoxity * IL.ILGenericArgs * int + type TypeRefAsTypIdx = + | TypeRefAsTypIdx of IL.ILBoxity * IL.ILGenericArgs * int + type BlobAsMethodSigIdx = + | BlobAsMethodSigIdx of numtypars: int * blobIdx: int32 + type BlobAsFieldSigIdx = + | BlobAsFieldSigIdx of numtypars: int * blobIdx: int32 + type BlobAsPropSigIdx = + | BlobAsPropSigIdx of numtypars: int * blobIdx: int32 + type BlobAsLocalSigIdx = + | BlobAsLocalSigIdx of numtypars: int * blobIdx: int32 + type MemberRefAsMspecIdx = + | MemberRefAsMspecIdx of numtypars: int * idx: int + type MethodSpecAsMspecIdx = + | MethodSpecAsMspecIdx of numtypars: int * idx: int + type MemberRefAsFspecIdx = + | MemberRefAsFspecIdx of numtypars: int * idx: int + type CustomAttrIdx = + | CustomAttrIdx of + Internal.BinaryConstants.CustomAttributeTypeTag * idx: int * + valIdx: int32 + type GenericParamsIdx = + | GenericParamsIdx of + numtypars: int * Internal.BinaryConstants.TypeOrMethodDefTag * idx: int + val mkCacheInt32 : + lowMem:bool -> + _inbase:'a -> _nm:'b -> _sz:'c -> ((int32 -> 'd) -> int32 -> 'd) + val mkCacheGeneric : + lowMem:bool -> _inbase:'a -> _nm:'b -> _sz:'c -> (('T -> 'd) -> 'T -> 'd) + val seekFindRow : numRows:int -> rowChooser:(int -> bool) -> int + val seekReadIndexedRows : + numRows:int * rowReader:(int -> 'a) * keyFunc:('a -> 'b) * + keyComparer:('b -> int) * binaryChop:bool * rowConverter:('a -> 'c) -> + 'c list + val seekReadOptionalIndexedRow : + int * (int -> 'a) * ('a -> 'b) * ('b -> int) * bool * ('a -> 'c) -> + 'c option + val seekReadIndexedRow : + int * (int -> 'a) * ('a -> 'b) * ('b -> int) * bool * ('a -> 'c) -> 'c + type MethodData = + | MethodData of + enclTy: IL.ILType * IL.ILCallingConv * name: string * argtys: IL.ILTypes * + retty: IL.ILType * minst: IL.ILTypes + type VarArgMethodData = + | VarArgMethodData of + enclTy: IL.ILType * IL.ILCallingConv * name: string * argtys: IL.ILTypes * + IL.ILVarArgs * retty: IL.ILType * minst: IL.ILTypes + [] + type PEReader = + { fileName: string + pdb: obj option + entryPointToken: Internal.BinaryConstants.TableName * int + pefile: BinaryFile + textSegmentPhysicalLoc: int32 + textSegmentPhysicalSize: int32 + dataSegmentPhysicalLoc: int32 + dataSegmentPhysicalSize: int32 + anyV2P: string * int32 -> int32 + metadataAddr: int32 + sectionHeaders: (int32 * int32 * int32) list + nativeResourcesAddr: int32 + nativeResourcesSize: int32 + resourcesAddr: int32 + strongnameAddr: int32 + vtableFixupsAddr: int32 + noFileOnDisk: bool } + [] + type ILMetadataReader = + { sorted: int64 + mdfile: BinaryFile + pectxtCaptured: PEReader option + entryPointToken: Internal.BinaryConstants.TableName * int + dataEndPoints: System.Lazy + fileName: string + getNumRows: Internal.BinaryConstants.TableName -> int + userStringsStreamPhysicalLoc: int32 + stringsStreamPhysicalLoc: int32 + blobsStreamPhysicalLoc: int32 + blobsStreamSize: int32 + readUserStringHeap: int32 -> string + memoizeString: string -> string + readStringHeap: int32 -> string + readBlobHeap: int32 -> byte [] + guidsStreamPhysicalLoc: int32 + rowAddr: Internal.BinaryConstants.TableName -> int -> int32 + tableBigness: bool [] + rsBigness: bool + tdorBigness: bool + tomdBigness: bool + hcBigness: bool + hcaBigness: bool + hfmBigness: bool + hdsBigness: bool + mrpBigness: bool + hsBigness: bool + mdorBigness: bool + mfBigness: bool + iBigness: bool + catBigness: bool + stringsBigness: bool + guidsBigness: bool + blobsBigness: bool + seekReadNestedRow: int -> int * int + seekReadConstantRow: + int -> + uint16 * TaggedIndex * + int32 + seekReadMethodSemanticsRow: + int -> + int32 * int * TaggedIndex + seekReadTypeDefRow: + int -> + int32 * int32 * int32 * + TaggedIndex * int * int + seekReadAssemblyRef: int -> IL.ILAssemblyRef + seekReadMethodSpecAsMethodData: MethodSpecAsMspecIdx -> VarArgMethodData + seekReadMemberRefAsMethodData: MemberRefAsMspecIdx -> VarArgMethodData + seekReadMemberRefAsFieldSpec: MemberRefAsFspecIdx -> IL.ILFieldSpec + seekReadCustomAttr: CustomAttrIdx -> IL.ILAttribute + seekReadTypeRef: int -> IL.ILTypeRef + seekReadTypeRefAsType: TypeRefAsTypIdx -> IL.ILType + readBlobHeapAsPropertySig: + BlobAsPropSigIdx -> IL.ILThisConvention * IL.ILType * IL.ILTypes + readBlobHeapAsFieldSig: BlobAsFieldSigIdx -> IL.ILType + readBlobHeapAsMethodSig: + BlobAsMethodSigIdx -> + bool * int32 * IL.ILCallingConv * IL.ILType * IL.ILTypes * + IL.ILVarArgs + readBlobHeapAsLocalsSig: BlobAsLocalSigIdx -> IL.ILLocal list + seekReadTypeDefAsType: TypeDefAsTypIdx -> IL.ILType + seekReadMethodDefAsMethodData: int -> MethodData + seekReadGenericParams: GenericParamsIdx -> IL.ILGenericParameterDef list + seekReadFieldDefAsFieldSpec: int -> IL.ILFieldSpec + customAttrsReader_Module: IL.ILAttributesStored + customAttrsReader_Assembly: IL.ILAttributesStored + customAttrsReader_TypeDef: IL.ILAttributesStored + customAttrsReader_GenericParam: IL.ILAttributesStored + customAttrsReader_FieldDef: IL.ILAttributesStored + customAttrsReader_MethodDef: IL.ILAttributesStored + customAttrsReader_ParamDef: IL.ILAttributesStored + customAttrsReader_Event: IL.ILAttributesStored + customAttrsReader_Property: IL.ILAttributesStored + customAttrsReader_ManifestResource: IL.ILAttributesStored + customAttrsReader_ExportedType: IL.ILAttributesStored + securityDeclsReader_TypeDef: IL.ILSecurityDeclsStored + securityDeclsReader_MethodDef: IL.ILSecurityDeclsStored + securityDeclsReader_Assembly: IL.ILSecurityDeclsStored + typeDefReader: IL.ILTypeDefStored } + type ISeekReadIndexedRowReader<'RowT,'KeyT,'T when 'RowT : struct> = + interface + abstract member CompareKey : 'KeyT -> int + abstract member ConvertRow : byref<'RowT> -> 'T + abstract member GetKey : byref<'RowT> -> 'KeyT + abstract member GetRow : int * byref<'RowT> -> unit + end + val seekReadIndexedRowsByInterface : + numRows:int -> + binaryChop:bool -> + reader:ISeekReadIndexedRowReader<'RowT,'a,'b> -> 'b [] + when 'RowT : struct + [] + type CustomAttributeRow = + struct + val mutable parentIndex: + TaggedIndex + val mutable typeIndex: + TaggedIndex + val mutable valueIndex: int + end + val seekReadUInt16Adv : mdv:BinaryView -> addr:byref -> uint16 + val seekReadInt32Adv : mdv:BinaryView -> addr:byref -> int + val seekReadUInt16AsInt32Adv : mdv:BinaryView -> addr:byref -> int32 + val inline seekReadTaggedIdx : + f:(int -> 'a) -> + nbits:int -> + big:bool -> mdv:BinaryView -> addr:byref -> TaggedIndex<'a> + val seekReadIdx : big:bool -> mdv:BinaryView -> addr:byref -> int + val seekReadUntaggedIdx : + tab:Internal.BinaryConstants.TableName -> + ctxt:ILMetadataReader -> mdv:BinaryView -> addr:byref -> int + val seekReadResolutionScopeIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadTypeDefOrRefOrSpecIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadTypeOrMethodDefIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadHasConstantIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadHasCustomAttributeIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadHasFieldMarshalIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadHasDeclSecurityIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadMemberRefParentIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadHasSemanticsIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadMethodDefOrRefIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadMemberForwardedIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadImplementationIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadCustomAttributeTypeIdx : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + addr:byref -> + TaggedIndex + val seekReadStringIdx : + ctxt:ILMetadataReader -> mdv:BinaryView -> addr:byref -> int + val seekReadGuidIdx : + ctxt:ILMetadataReader -> mdv:BinaryView -> addr:byref -> int + val seekReadBlobIdx : + ctxt:ILMetadataReader -> mdv:BinaryView -> addr:byref -> int + val seekReadModuleRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> idx:int -> uint16 * int * int * int * int + val seekReadTypeRefRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + TaggedIndex * int * int + val seekReadTypeDefRow : + ctxt:ILMetadataReader -> + idx:int -> + int32 * int32 * int32 * + TaggedIndex * int * int + val seekReadTypeDefRowUncached : + ctxtH:ILMetadataReader option ref -> + idx:int -> + int * int * int * + TaggedIndex * int * int + val seekReadFieldRow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int32 * int * int + val seekReadMethodRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> idx:int -> int * int32 * int32 * int * int * int + val seekReadParamRow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int32 * int32 * int + val seekReadInterfaceImplRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> int * TaggedIndex + val seekReadMemberRefRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + TaggedIndex * int * int + val seekReadConstantRow : + ctxt:ILMetadataReader -> + idx:int -> + uint16 * TaggedIndex * int32 + val seekReadConstantRowUncached : + ctxtH:ILMetadataReader option ref -> + idx:int -> + uint16 * TaggedIndex * int + val seekReadCustomAttributeRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> idx:int -> attrRow:byref -> unit + val seekReadFieldMarshalRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + TaggedIndex * int + val seekReadPermissionRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + uint16 * TaggedIndex * + int + val seekReadClassLayoutRow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> uint16 * int * int + val seekReadFieldLayoutRow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int * int + val seekReadStandAloneSigRow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int + val seekReadEventMapRow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int * int + val seekReadEventRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + int32 * int * TaggedIndex + val seekReadPropertyMapRow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int * int + val seekReadPropertyRow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int32 * int * int + val seekReadMethodSemanticsRow : + ctxt:ILMetadataReader -> + idx:int -> + int32 * int * TaggedIndex + val seekReadMethodSemanticsRowUncached : + ctxtH:ILMetadataReader option ref -> + idx:int -> + int32 * int * TaggedIndex + val seekReadMethodImplRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + int * TaggedIndex * + TaggedIndex + val seekReadModuleRefRow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int + val seekReadTypeSpecRow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int + val seekReadImplMapRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + int32 * TaggedIndex * + int * int + val seekReadFieldRVARow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int * int + val seekReadAssemblyRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + int * uint16 * uint16 * uint16 * uint16 * int * int * int * int + val seekReadAssemblyRefRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + uint16 * uint16 * uint16 * uint16 * int * int * int * int * int + val seekReadFileRow : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int * int * int + val seekReadExportedTypeRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + int * int * int * int * + TaggedIndex + val seekReadManifestResourceRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + int * int * int * + TaggedIndex + val seekReadNestedRow : ctxt:ILMetadataReader -> idx:int -> int * int + val seekReadNestedRowUncached : + ctxtH:ILMetadataReader option ref -> idx:int -> int * int + val seekReadGenericParamRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + int * uint16 * uint16 * + TaggedIndex * int + val seekReadGenericParamConstraintRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> int * TaggedIndex + val seekReadMethodSpecRow : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + idx:int -> + TaggedIndex * int + val readUserStringHeapUncached : + ctxtH:ILMetadataReader option ref -> idx:int32 -> string + val readUserStringHeap : ctxt:ILMetadataReader -> idx:int32 -> string + val readStringHeapUncached : + ctxtH:ILMetadataReader option ref -> idx:int32 -> string + val readStringHeap : ctxt:ILMetadataReader -> idx:int32 -> string + val readStringHeapOption : ctxt:ILMetadataReader -> idx:int -> string option + val emptyByteArray : byte [] + val readBlobHeapUncached : + ctxtH:ILMetadataReader option ref -> idx:int -> byte [] + val readBlobHeap : ctxt:ILMetadataReader -> idx:int32 -> byte [] + val readBlobHeapOption : ctxt:ILMetadataReader -> idx:int -> byte [] option + val readBlobHeapAsBool : ctxt:ILMetadataReader -> vidx:int32 -> bool + val readBlobHeapAsSByte : ctxt:ILMetadataReader -> vidx:int32 -> sbyte + val readBlobHeapAsInt16 : ctxt:ILMetadataReader -> vidx:int32 -> int16 + val readBlobHeapAsInt32 : ctxt:ILMetadataReader -> vidx:int32 -> int + val readBlobHeapAsInt64 : ctxt:ILMetadataReader -> vidx:int32 -> int64 + val readBlobHeapAsByte : ctxt:ILMetadataReader -> vidx:int32 -> byte + val readBlobHeapAsUInt16 : ctxt:ILMetadataReader -> vidx:int32 -> uint16 + val readBlobHeapAsUInt32 : ctxt:ILMetadataReader -> vidx:int32 -> uint32 + val readBlobHeapAsUInt64 : ctxt:ILMetadataReader -> vidx:int32 -> uint64 + val readBlobHeapAsSingle : ctxt:ILMetadataReader -> vidx:int32 -> float32 + val readBlobHeapAsDouble : ctxt:ILMetadataReader -> vidx:int32 -> float + val readNativeResources : pectxt:PEReader -> IL.ILNativeResource list + val getDataEndPointsDelayed : + pectxt:PEReader -> ctxtH:ILMetadataReader option ref -> Lazy + val rvaToData : + ctxt:ILMetadataReader -> + pectxt:PEReader -> nm:string -> rva:int -> byte [] + val isSorted : + ctxt:ILMetadataReader -> tab:Internal.BinaryConstants.TableName -> bool + val seekReadModule : + ctxt:ILMetadataReader -> + canReduceMemory:bool -> + pectxtEager:PEReader -> + pevEager:BinaryView -> + uint16 * (int * int) * bool * bool * bool * bool * bool * + IL.ILPlatform option * bool * int32 * int32 * int32 -> + ilMetadataVersion:string -> idx:int -> IL.ILModuleDef + val seekReadAssemblyManifest : + ctxt:ILMetadataReader -> + pectxt:PEReader -> idx:int -> IL.ILAssemblyManifest + val seekReadAssemblyRef : + ctxt:ILMetadataReader -> idx:int -> IL.ILAssemblyRef + val seekReadAssemblyRefUncached : + ctxtH:ILMetadataReader option ref -> idx:int -> IL.ILAssemblyRef + val seekReadModuleRef : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> IL.ILModuleRef + val seekReadFile : + ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> IL.ILModuleRef + val seekReadClassLayout : + ctxt:ILMetadataReader -> + mdv:BinaryView -> idx:int -> IL.ILTypeDefLayoutInfo + val typeAccessOfFlags : flags:int -> IL.ILTypeDefAccess + val typeLayoutOfFlags : + ctxt:ILMetadataReader -> + mdv:BinaryView -> flags:int -> tidx:int -> IL.ILTypeDefLayout + val isTopTypeDef : flags:int -> bool + val seekIsTopTypeDefOfIdx : ctxt:ILMetadataReader -> idx:int -> bool + val readBlobHeapAsSplitTypeName : + ctxt:ILMetadataReader -> + nameIdx:int32 * namespaceIdx:int -> string list * string + val readBlobHeapAsTypeName : + ctxt:ILMetadataReader -> nameIdx:int32 * namespaceIdx:int -> string + val seekReadTypeDefRowExtents : + ctxt:ILMetadataReader -> _info:'a -> idx:int -> struct (int * int) + val seekReadTypeDefRowWithExtents : + ctxt:ILMetadataReader -> + idx:int -> + (int32 * int32 * int32 * + TaggedIndex * int * int) * + struct (int * int) + val seekReadPreTypeDef : + ctxt:ILMetadataReader -> toponly:bool -> idx:int -> IL.ILPreTypeDef option + val typeDefReader : ctxtH:ILMetadataReader option ref -> IL.ILTypeDefStored + val seekReadTopTypeDefs : ctxt:ILMetadataReader -> IL.ILPreTypeDef [] + val seekReadNestedTypeDefs : + ctxt:ILMetadataReader -> tidx:int32 -> IL.ILTypeDefs + val seekReadInterfaceImpls : + ctxt:ILMetadataReader -> + mdv:BinaryView -> numtypars:int -> tidx:int32 -> IL.ILTypes + val seekReadGenericParams : + ctxt:ILMetadataReader -> + numtypars:int -> + a:Internal.BinaryConstants.TypeOrMethodDefTag * b:int32 -> + IL.ILGenericParameterDefs + val seekReadGenericParamsUncached : + ctxtH:ILMetadataReader option ref -> + GenericParamsIdx -> IL.ILGenericParameterDef list + val seekReadGenericParamConstraints : + ctxt:ILMetadataReader -> + mdv:BinaryView -> numtypars:int -> gpidx:int -> IL.ILTypes + val seekReadTypeDefAsType : + ctxt:ILMetadataReader -> + boxity:IL.ILBoxity -> ginst:IL.ILTypes -> idx:int -> IL.ILType + val seekReadTypeDefAsTypeUncached : + ctxtH:ILMetadataReader option ref -> TypeDefAsTypIdx -> IL.ILType + val seekReadTypeDefAsTypeRef : + ctxt:ILMetadataReader -> idx:int -> IL.ILTypeRef + val seekReadTypeRef : ctxt:ILMetadataReader -> idx:int -> IL.ILTypeRef + val seekReadTypeRefUncached : + ctxtH:ILMetadataReader option ref -> idx:int -> IL.ILTypeRef + val seekReadTypeRefAsType : + ctxt:ILMetadataReader -> + boxity:IL.ILBoxity -> ginst:IL.ILGenericArgs -> idx:int -> IL.ILType + val seekReadTypeRefAsTypeUncached : + ctxtH:ILMetadataReader option ref -> TypeRefAsTypIdx -> IL.ILType + val seekReadTypeDefOrRef : + ctxt:ILMetadataReader -> + numtypars:int -> + boxity:IL.ILBoxity -> + ginst:IL.ILTypes -> + TaggedIndex -> IL.ILType + val seekReadTypeDefOrRefAsTypeRef : + ctxt:ILMetadataReader -> + TaggedIndex -> IL.ILTypeRef + val seekReadMethodRefParent : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + numtypars:int -> + TaggedIndex -> + IL.ILType + val seekReadMethodDefOrRef : + ctxt:ILMetadataReader -> + numtypars:int -> + TaggedIndex -> + VarArgMethodData + val seekReadMethodDefOrRefNoVarargs : + ctxt:ILMetadataReader -> + numtypars:int -> + x:TaggedIndex -> + MethodData + val seekReadCustomAttrType : + ctxt:ILMetadataReader -> + TaggedIndex -> + IL.ILMethodSpec + val seekReadImplAsScopeRef : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + TaggedIndex -> + IL.ILScopeRef + val seekReadTypeRefScope : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + TaggedIndex -> + IL.ILScopeRef * string list + val seekReadOptionalTypeDefOrRef : + ctxt:ILMetadataReader -> + numtypars:int -> + boxity:IL.ILBoxity -> + idx:TaggedIndex -> + IL.ILType option + val seekReadField : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + numtypars:int * hasLayout:bool -> idx:int -> IL.ILFieldDef + val seekReadFields : + ctxt:ILMetadataReader -> + numtypars:int * hasLayout:bool -> + fidx1:int -> fidx2:int -> IL.ILFieldDefs + val seekReadMethods : + ctxt:ILMetadataReader -> + numtypars:int -> midx1:int -> midx2:int -> IL.ILMethodDefs + val sigptrGetTypeDefOrRefOrSpecIdx : + bytes:byte [] -> + sigptr:int -> + TaggedIndex * int + val sigptrGetTy : + ctxt:ILMetadataReader -> + numtypars:int -> bytes:byte [] -> sigptr:int -> IL.ILType * int + val sigptrGetVarArgTys : + ctxt:ILMetadataReader -> + n:int -> + numtypars:int -> bytes:byte [] -> sigptr:int -> IL.ILType list * int + val sigptrGetArgTys : + ctxt:ILMetadataReader -> + n:int -> + numtypars:int -> + bytes:byte [] -> + sigptr:int -> + acc:IL.ILType list -> + (IL.ILType list * IL.ILType list option) * int + val sigptrGetLocal : + ctxt:ILMetadataReader -> + numtypars:int -> bytes:byte [] -> sigptr:int -> IL.ILLocal * int + val readBlobHeapAsMethodSig : + ctxt:ILMetadataReader -> + numtypars:int -> + blobIdx:int32 -> + bool * int32 * IL.ILCallingConv * IL.ILType * IL.ILTypes * + IL.ILVarArgs + val readBlobHeapAsMethodSigUncached : + ctxtH:ILMetadataReader option ref -> + BlobAsMethodSigIdx -> + bool * int * IL.ILCallingConv * IL.ILType * IL.ILType list * + IL.ILType list option + val readBlobHeapAsType : + ctxt:ILMetadataReader -> numtypars:int -> blobIdx:int -> IL.ILType + val readBlobHeapAsFieldSig : + ctxt:ILMetadataReader -> numtypars:int -> blobIdx:int -> IL.ILType + val readBlobHeapAsFieldSigUncached : + ctxtH:ILMetadataReader option ref -> BlobAsFieldSigIdx -> IL.ILType + val readBlobHeapAsPropertySig : + ctxt:ILMetadataReader -> + numtypars:int -> + blobIdx:int32 -> IL.ILThisConvention * IL.ILType * IL.ILTypes + val readBlobHeapAsPropertySigUncached : + ctxtH:ILMetadataReader option ref -> + BlobAsPropSigIdx -> IL.ILThisConvention * IL.ILType * IL.ILType list + val readBlobHeapAsLocalsSig : + ctxt:ILMetadataReader -> numtypars:int -> blobIdx:int32 -> IL.ILLocal list + val readBlobHeapAsLocalsSigUncached : + ctxtH:ILMetadataReader option ref -> BlobAsLocalSigIdx -> IL.ILLocal list + val byteAsHasThis : b:byte -> IL.ILThisConvention + val byteAsCallConv : b:byte -> bool * IL.ILCallingConv + val seekReadMemberRefAsMethodData : + ctxt:ILMetadataReader -> numtypars:int -> idx:int32 -> VarArgMethodData + val seekReadMemberRefAsMethodDataUncached : + ctxtH:ILMetadataReader option ref -> + MemberRefAsMspecIdx -> VarArgMethodData + val seekReadMemberRefAsMethDataNoVarArgs : + ctxt:ILMetadataReader -> numtypars:int -> idx:int32 -> MethodData + val seekReadMethodSpecAsMethodData : + ctxt:ILMetadataReader -> numtypars:int -> idx:int -> VarArgMethodData + val seekReadMethodSpecAsMethodDataUncached : + ctxtH:ILMetadataReader option ref -> + MethodSpecAsMspecIdx -> VarArgMethodData + val seekReadMemberRefAsFieldSpec : + ctxt:ILMetadataReader -> numtypars:int -> idx:int -> IL.ILFieldSpec + val seekReadMemberRefAsFieldSpecUncached : + ctxtH:ILMetadataReader option ref -> MemberRefAsFspecIdx -> IL.ILFieldSpec + val seekReadMethodDefAsMethodData : + ctxt:ILMetadataReader -> idx:int32 -> MethodData + val seekReadMethodDefAsMethodDataUncached : + ctxtH:ILMetadataReader option ref -> idx:int -> MethodData + val seekReadFieldDefAsFieldSpec : + ctxt:ILMetadataReader -> idx:int -> IL.ILFieldSpec + val seekReadFieldDefAsFieldSpecUncached : + ctxtH:ILMetadataReader option ref -> idx:int -> IL.ILFieldSpec + val seekReadMethod : + ctxt:ILMetadataReader -> + mdv:BinaryView -> numtypars:int -> idx:int -> IL.ILMethodDef + val seekReadParams : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + retty:IL.ILType * argtys:IL.ILTypes -> + pidx1:int -> pidx2:int -> IL.ILReturn * IL.ILParameters + val seekReadParamExtras : + ctxt:ILMetadataReader -> + mdv:BinaryView -> + retRes:IL.ILReturn ref * paramsRes:IL.ILParameter [] -> + idx:int -> unit + val seekReadMethodImpls : + ctxt:ILMetadataReader -> + numtypars:int -> tidx:int32 -> IL.ILMethodImplDefs + val seekReadMultipleMethodSemantics : + ctxt:ILMetadataReader -> + flags:int32 * id:TaggedIndex -> + IL.ILMethodRef list + val seekReadoptional_MethodSemantics : + ctxt:ILMetadataReader -> + int32 * TaggedIndex -> + IL.ILMethodRef option + val seekReadMethodSemantics : + ctxt:ILMetadataReader -> + int32 * TaggedIndex -> + IL.ILMethodRef + val seekReadEvent : + ctxt:ILMetadataReader -> + mdv:BinaryView -> numtypars:int -> idx:int -> IL.ILEventDef + val seekReadEvents : + ctxt:ILMetadataReader -> numtypars:int -> tidx:int32 -> IL.ILEventDefs + val seekReadProperty : + ctxt:ILMetadataReader -> + mdv:BinaryView -> numtypars:int -> idx:int -> IL.ILPropertyDef + val seekReadProperties : + ctxt:ILMetadataReader -> numtypars:int -> tidx:int32 -> IL.ILPropertyDefs + val customAttrsReader : + ctxtH:ILMetadataReader option ref -> + tag:Internal.BinaryConstants.HasCustomAttributeTag -> + IL.ILAttributesStored + val seekReadCustomAttr : + ctxt:ILMetadataReader -> + TaggedIndex * b:int -> + IL.ILAttribute + val seekReadCustomAttrUncached : + ctxtH:ILMetadataReader option ref -> CustomAttrIdx -> IL.ILAttribute + val securityDeclsReader : + ctxtH:ILMetadataReader option ref -> + tag:Internal.BinaryConstants.HasDeclSecurityTag -> + IL.ILSecurityDeclsStored + val seekReadSecurityDecl : + ctxt:ILMetadataReader -> act:uint16 * ty:int -> IL.ILSecurityDecl + val seekReadConstant : + ctxt:ILMetadataReader -> + idx:TaggedIndex -> + IL.ILFieldInit + val seekReadImplMap : + ctxt:ILMetadataReader -> nm:string -> midx:int -> IL.ILLazyMethodBody + val seekReadTopCode : + ctxt:ILMetadataReader -> + pev:BinaryView -> + mdv:BinaryView -> + numtypars:int -> + sz:int -> + start:int -> + seqpoints:(int * IL.ILSourceMarker) list -> + IL.ILInstr [] * (int -> IL.ILCodeLabel) * + System.Collections.Generic.Dictionary * + (int -> IL.ILCodeLabel) + val seekReadMethodRVA : + pectxt:PEReader -> + ctxt:ILMetadataReader -> + _idx:int * nm:string * _internalcall:bool * noinline:bool * + aggressiveinline:bool * numtypars:int -> + rva:int -> IL.ILLazyMethodBody + val int32AsILVariantType : + ctxt:ILMetadataReader -> n:int32 -> IL.ILNativeVariant + val readBlobHeapAsNativeType : + ctxt:ILMetadataReader -> blobIdx:int -> IL.ILNativeType + val sigptrGetILNativeType : + ctxt:ILMetadataReader -> + bytes:byte [] -> sigptr:int -> IL.ILNativeType * int + val seekReadManifestResources : + ctxt:ILMetadataReader -> + canReduceMemory:bool -> + mdv:BinaryView -> + pectxtEager:PEReader -> pevEager:BinaryView -> IL.ILResources + val seekReadNestedExportedTypes : + ctxt:ILMetadataReader -> + exported:(int * 'b * int32 * int * 'c) [] -> + nested:System.Lazy -> + parentIdx:int32 -> IL.ILNestedExportedTypes + val seekReadTopExportedTypes : + ctxt:ILMetadataReader -> IL.ILExportedTypesAndForwarders + val openMetadataReader : + fileName:string * mdfile:BinaryFile * metadataPhysLoc:int * + peinfo:(uint16 * (int * int) * bool * bool * bool * bool * bool * + IL.ILPlatform option * bool * int32 * int32 * int32) * + pectxtEager:PEReader * pevEager:BinaryView * + pectxtCaptured:PEReader option * reduceMemoryUsage:bool -> + IL.ILModuleDef * Lazy + val openPEFileReader : + fileName:string * pefile:BinaryFile * pdbDirPath:'a * noFileOnDisk:bool -> + int * int * + (uint16 * (int32 * int32) * bool * bool * bool * bool * bool * + IL.ILPlatform option * bool * int * int * int) * PEReader * BinaryView * + obj option + val openPE : + fileName:string * pefile:BinaryFile * pdbDirPath:'a * + reduceMemoryUsage:bool * noFileOnDisk:bool -> + IL.ILModuleDef * Lazy * obj option + val openPEMetadataOnly : + fileName:string * + peinfo:(uint16 * (int * int) * bool * bool * bool * bool * bool * + IL.ILPlatform option * bool * int32 * int32 * int32) * + pectxtEager:PEReader * pevEager:BinaryView * mdfile:BinaryFile * + reduceMemoryUsage:bool -> IL.ILModuleDef * Lazy + val ClosePdbReader : pdb:'a -> unit + type ILReaderMetadataSnapshot = obj * nativeint * int + type ILReaderTryGetMetadataSnapshot = + string * System.DateTime -> ILReaderMetadataSnapshot option + [] + type MetadataOnlyFlag = + | Yes + | No + [] + type ReduceMemoryFlag = + | Yes + | No + type ILReaderOptions = + { pdbDirPath: string option + reduceMemoryUsage: ReduceMemoryFlag + metadataOnly: MetadataOnlyFlag + tryGetMetadataSnapshot: ILReaderTryGetMetadataSnapshot } + type ILModuleReader = + interface + inherit System.IDisposable + abstract member ILAssemblyRefs : IL.ILAssemblyRef list + abstract member ILModuleDef : IL.ILModuleDef + end + [] + type ILModuleReaderImpl = + class + interface ILModuleReader + new : ilModule:IL.ILModuleDef * + ilAssemblyRefs:System.Lazy * + dispose:(unit -> unit) -> ILModuleReaderImpl + end + type ILModuleReaderCacheKey = + | ILModuleReaderCacheKey of + string * System.DateTime * bool * ReduceMemoryFlag * MetadataOnlyFlag + type ILModuleReaderCache1LockToken = + class + interface Internal.Library.LockToken + new : unit -> ILModuleReaderCache1LockToken + end + val ilModuleReaderCache1 : + Internal.Utilities.Collections.AgedLookup + val ilModuleReaderCache1Lock : + Internal.Library.Lock + val ilModuleReaderCache2 : + System.Collections.Concurrent.ConcurrentDictionary> + val stableFileHeuristicApplies : fileName:string -> bool + val createByteFileChunk : + opts:ILReaderOptions -> + fileName:string -> chunk:(int * int) option -> BinaryFile + val createMemoryMapFile : fileName:string -> System.IDisposable * BinaryFile + val OpenILModuleReaderFromBytes : + fileName:string -> + assemblyContents:byte [] -> options:ILReaderOptions -> ILModuleReader + val ClearAllILModuleReaderCache : unit -> unit + val OpenILModuleReader : string -> ILReaderOptions -> ILModuleReader + module Shim = begin + type IAssemblyReader = + interface + abstract member + GetILModuleReader : filename:string * readerOptions:ILReaderOptions -> + ILModuleReader + end + [] + type DefaultAssemblyReader = + class + interface IAssemblyReader + new : unit -> DefaultAssemblyReader + end + val mutable AssemblyReader : IAssemblyReader + end + end + +namespace FSharp.Compiler.AbstractIL + module internal ILPdbWriter = begin + type BlobBuildingStream = + class + inherit System.IO.Stream + new : unit -> BlobBuildingStream + override Dispose : _disposing:bool -> unit + override Flush : unit -> unit + override Read : _buffer:byte [] * _offset:int * _count:int -> int + override Seek : _offset:int64 * _origin:System.IO.SeekOrigin -> int64 + override SetLength : _value:int64 -> unit + member + ToImmutableArray : unit -> + System.Collections.Immutable.ImmutableArray + member TryWriteBytes : stream:System.IO.Stream * length:int -> int + override Write : buffer:byte [] * offset:int * count:int -> unit + override WriteByte : value:byte -> unit + member WriteInt32 : value:int -> unit + override CanRead : bool + override CanSeek : bool + override CanWrite : bool + override Length : int64 + override Position : int64 + end + type PdbDocumentData = IL.ILSourceDocument + type PdbLocalVar = + { Name: string + Signature: byte [] + Index: int32 } + type PdbMethodScope = + { Children: PdbMethodScope array + StartOffset: int + EndOffset: int + Locals: PdbLocalVar array } + type PdbSourceLoc = + { Document: int + Line: int + Column: int } + type PdbSequencePoint = + { Document: int + Offset: int + Line: int + Column: int + EndLine: int + EndColumn: int } + with + override ToString : unit -> string + end + type PdbMethodData = + { MethToken: int32 + MethName: string + LocalSignatureToken: int32 + Params: PdbLocalVar array + RootScope: PdbMethodScope option + Range: (PdbSourceLoc * PdbSourceLoc) option + SequencePoints: PdbSequencePoint array } + module SequencePoint = begin + val orderBySource : sp1:PdbSequencePoint -> sp2:PdbSequencePoint -> int + val orderByOffset : sp1:PdbSequencePoint -> sp2:PdbSequencePoint -> int + end + val sizeof_IMAGE_DEBUG_DIRECTORY : int + [] + type PdbData = + { EntryPoint: int32 option + Timestamp: int32 + ModuleID: byte [] + Documents: PdbDocumentData [] + Methods: PdbMethodData [] + TableRowCounts: int [] } + type BinaryChunk = + { size: int32 + addr: int32 } + type idd = + { iddCharacteristics: int32 + iddMajorVersion: int32 + iddMinorVersion: int32 + iddType: int32 + iddTimestamp: int32 + iddData: byte [] + iddChunk: BinaryChunk } + type HashAlgorithm = + | Sha1 + | Sha256 + val guidSha1 : System.Guid + val guidSha2 : System.Guid + val checkSum : + url:string -> + checksumAlgorithm:HashAlgorithm -> (System.Guid * byte []) option + val cvMagicNumber : int64 + val pdbGetCvDebugInfo : + mvid:byte [] -> + timestamp:int32 -> filepath:string -> cvChunk:BinaryChunk -> idd + val pdbMagicNumber : int64 + val pdbGetEmbeddedPdbDebugInfo : + embeddedPdbChunk:BinaryChunk -> + uncompressedLength:int64 -> stream:System.IO.MemoryStream -> idd + val pdbChecksumDebugInfo : + timestamp:int32 -> + checksumPdbChunk:BinaryChunk -> + algorithmName:string -> checksum:byte [] -> idd + val pdbGetPdbDebugDeterministicInfo : + deterministicPdbChunk:BinaryChunk -> idd + val pdbGetDebugInfo : + contentId:byte [] -> + timestamp:int32 -> + filepath:string -> + cvChunk:BinaryChunk -> + embeddedPdbChunk:BinaryChunk option -> + deterministicPdbChunk:BinaryChunk -> + checksumPdbChunk:BinaryChunk -> + algorithmName:string -> + checksum:byte [] -> + uncompressedLength:int64 -> + stream:System.IO.MemoryStream option -> + embeddedPdb:bool -> deterministic:bool -> idd [] + val getDebugFileName : string -> bool -> string + val sortMethods : showTimes:bool -> info:PdbData -> unit + val getRowCounts : + tableRowCounts:int [] -> System.Collections.Immutable.ImmutableArray + val generatePortablePdb : + embedAllSource:bool -> + embedSourceList:string list -> + sourceLink:string -> + checksumAlgorithm:HashAlgorithm -> + showTimes:bool -> + info:PdbData -> + pathMap:Internal.Utilities.PathMap -> + int64 * System.Reflection.Metadata.BlobContentId * + System.IO.MemoryStream * string * byte [] + val compressPortablePdbStream : + uncompressedLength:int64 -> + contentId:System.Reflection.Metadata.BlobContentId -> + stream:System.IO.MemoryStream -> + int64 * System.Reflection.Metadata.BlobContentId * + System.IO.MemoryStream + val writePortablePdbInfo : + contentId:System.Reflection.Metadata.BlobContentId -> + stream:System.IO.MemoryStream -> + showTimes:bool -> + fpdb:string -> + pathMap:Internal.Utilities.PathMap -> + cvChunk:BinaryChunk -> + deterministicPdbChunk:BinaryChunk -> + checksumPdbChunk:BinaryChunk -> + algorithmName:string -> + checksum:byte [] -> + embeddedPdb:bool -> deterministic:bool -> idd [] + val embedPortablePdbInfo : + uncompressedLength:int64 -> + contentId:System.Reflection.Metadata.BlobContentId -> + stream:System.IO.MemoryStream -> + showTimes:bool -> + fpdb:string -> + cvChunk:BinaryChunk -> + pdbChunk:BinaryChunk -> + deterministicPdbChunk:BinaryChunk -> + checksumPdbChunk:BinaryChunk -> + algorithmName:string -> + checksum:byte [] -> + embeddedPdb:bool -> deterministic:bool -> idd [] + val ( ? ) : this:'a -> memb:string -> args:'Args -> 'R + val monoCompilerSvc : System.Reflection.AssemblyName + val ctor : + asmName:System.Reflection.AssemblyName -> + clsName:string -> args:obj [] -> obj + val createSourceMethodImpl : + name:string -> token:int -> namespaceID:int -> obj + val createWriter : f:string -> obj + val writeMdbInfo : string -> string -> PdbData -> 'a + val logDebugInfo : string -> PdbData -> unit + end + +namespace FSharp.Compiler.AbstractIL + module internal ILBinaryWriter = begin + val showEntryLookups : bool + val b0 : n:int -> byte + val b1 : n:int -> byte + val b2 : n:int -> byte + val b3 : n:int -> byte + val dw7 : n:int64 -> byte + val dw6 : n:int64 -> byte + val dw5 : n:int64 -> byte + val dw4 : n:int64 -> byte + val dw3 : n:int64 -> byte + val dw2 : n:int64 -> byte + val dw1 : n:int64 -> byte + val dw0 : n:int64 -> byte + val bitsOfSingle : x:float32 -> int + val bitsOfDouble : x:float -> int64 + val emitBytesViaBuffer : f:(Internal.ByteBuffer -> unit) -> byte [] + val align : alignment:int -> n:int -> int + type ByteBuffer with + static member Z32Size : n:int -> int + type ByteBuffer with + member EmitZ32 : n:int -> unit + type ByteBuffer with + member EmitPadding : n:int -> unit + type ByteBuffer with + member EmitZUntaggedIndex : big:bool -> idx:int32 -> unit + type ByteBuffer with + member + EmitZTaggedIndex : tag:int32 -> + nbits:int32 -> big:bool -> idx:int32 -> unit + val getUncodedToken : + tab:Internal.BinaryConstants.TableName -> idx:int -> int + val markerForUnicodeBytes : b:byte [] -> int + val checkFixup32 : data:byte [] -> offset:int -> exp:int -> unit + val applyFixup32 : data:byte [] -> offset:int -> v:int -> unit + module RowElementTags = begin + [] + val UShort : int = 0 + [] + val ULong : int = 1 + [] + val Data : int = 2 + [] + val DataResources : int = 3 + [] + val Guid : int = 4 + [] + val Blob : int = 5 + [] + val String : int = 6 + [] + val SimpleIndexMin : int = 7 + val SimpleIndex : t:Internal.BinaryConstants.TableName -> int + [] + val SimpleIndexMax : int = 119 + [] + val TypeDefOrRefOrSpecMin : int = 120 + val TypeDefOrRefOrSpec : t:Internal.BinaryConstants.TypeDefOrRefTag -> int + [] + val TypeDefOrRefOrSpecMax : int = 122 + [] + val TypeOrMethodDefMin : int = 123 + val TypeOrMethodDef : t:Internal.BinaryConstants.TypeOrMethodDefTag -> int + [] + val TypeOrMethodDefMax : int = 124 + [] + val HasConstantMin : int = 125 + val HasConstant : t:Internal.BinaryConstants.HasConstantTag -> int + [] + val HasConstantMax : int = 127 + [] + val HasCustomAttributeMin : int = 128 + val HasCustomAttribute : + t:Internal.BinaryConstants.HasCustomAttributeTag -> int + [] + val HasCustomAttributeMax : int = 149 + [] + val HasFieldMarshalMin : int = 150 + val HasFieldMarshal : t:Internal.BinaryConstants.HasFieldMarshalTag -> int + [] + val HasFieldMarshalMax : int = 151 + [] + val HasDeclSecurityMin : int = 152 + val HasDeclSecurity : t:Internal.BinaryConstants.HasDeclSecurityTag -> int + [] + val HasDeclSecurityMax : int = 154 + [] + val MemberRefParentMin : int = 155 + val MemberRefParent : t:Internal.BinaryConstants.MemberRefParentTag -> int + [] + val MemberRefParentMax : int = 159 + [] + val HasSemanticsMin : int = 160 + val HasSemantics : t:Internal.BinaryConstants.HasSemanticsTag -> int + [] + val HasSemanticsMax : int = 161 + [] + val MethodDefOrRefMin : int = 162 + val MethodDefOrRef : t:Internal.BinaryConstants.MethodDefOrRefTag -> int + [] + val MethodDefOrRefMax : int = 164 + [] + val MemberForwardedMin : int = 165 + val MemberForwarded : t:Internal.BinaryConstants.MemberForwardedTag -> int + [] + val MemberForwardedMax : int = 166 + [] + val ImplementationMin : int = 167 + val Implementation : t:Internal.BinaryConstants.ImplementationTag -> int + [] + val ImplementationMax : int = 169 + [] + val CustomAttributeTypeMin : int = 170 + val CustomAttributeType : + t:Internal.BinaryConstants.CustomAttributeTypeTag -> int + [] + val CustomAttributeTypeMax : int = 173 + [] + val ResolutionScopeMin : int = 174 + val ResolutionScope : t:Internal.BinaryConstants.ResolutionScopeTag -> int + [] + val ResolutionScopeMax : int = 178 + end + [] + type RowElement = + struct + new : tag:int32 * idx:int32 -> RowElement + member Tag : int32 + member Val : int32 + end + val UShort : x:uint16 -> RowElement + val ULong : x:int32 -> RowElement + val Data : x:int * k:bool -> RowElement + val Guid : x:int -> RowElement + val Blob : x:int -> RowElement + val StringE : x:int -> RowElement + val SimpleIndex : t:Internal.BinaryConstants.TableName * x:int -> RowElement + val TypeDefOrRefOrSpec : + t:Internal.BinaryConstants.TypeDefOrRefTag * x:int -> RowElement + val TypeOrMethodDef : + t:Internal.BinaryConstants.TypeOrMethodDefTag * x:int -> RowElement + val HasConstant : + t:Internal.BinaryConstants.HasConstantTag * x:int -> RowElement + val HasCustomAttribute : + t:Internal.BinaryConstants.HasCustomAttributeTag * x:int -> RowElement + val HasFieldMarshal : + t:Internal.BinaryConstants.HasFieldMarshalTag * x:int -> RowElement + val HasDeclSecurity : + t:Internal.BinaryConstants.HasDeclSecurityTag * x:int -> RowElement + val MemberRefParent : + t:Internal.BinaryConstants.MemberRefParentTag * x:int -> RowElement + val HasSemantics : + t:Internal.BinaryConstants.HasSemanticsTag * x:int -> RowElement + val MethodDefOrRef : + t:Internal.BinaryConstants.MethodDefOrRefTag * x:int -> RowElement + val MemberForwarded : + t:Internal.BinaryConstants.MemberForwardedTag * x:int -> RowElement + val Implementation : + t:Internal.BinaryConstants.ImplementationTag * x:int -> RowElement + val CustomAttributeType : + t:Internal.BinaryConstants.CustomAttributeTypeTag * x:int -> RowElement + val ResolutionScope : + t:Internal.BinaryConstants.ResolutionScopeTag * x:int -> RowElement + type BlobIndex = int + type StringIndex = int + val BlobIndex : x:BlobIndex -> int + val StringIndex : x:StringIndex -> int + val inline combineHash : x2:int -> acc:int -> int + val hashRow : elems:RowElement [] -> int + val equalRows : elems:RowElement [] -> elems2:RowElement [] -> bool + type GenericRow = RowElement [] + [] + type SharedRow = + struct + new : elems:RowElement [] * hashCode:int -> SharedRow + override Equals : obj:obj -> bool + override GetHashCode : unit -> int + member GenericRow : RowElement [] + end + val SharedRow : elems:RowElement [] -> SharedRow + val AssemblyRefRow : + s1:uint16 * s2:uint16 * s3:uint16 * s4:uint16 * l1:int32 * b1:int * + nameIdx:int * str2:int * b2:int -> SharedRow + val MemberRefRow : + mrp:RowElement * nmIdx:StringIndex * blobIdx:BlobIndex -> SharedRow + [] + type UnsharedRow = + struct + new : elems:RowElement [] -> UnsharedRow + override Equals : obj:obj -> bool + override GetHashCode : unit -> int + member GenericRow : RowElement [] + end + type ILTypeWriterEnv = + { EnclosingTyparCount: int } + val envForTypeDef : td:IL.ILTypeDef -> ILTypeWriterEnv + val envForMethodRef : env:ILTypeWriterEnv -> ty:IL.ILType -> ILTypeWriterEnv + val envForNonGenericMethodRef : _mref:'a -> ILTypeWriterEnv + val envForFieldSpec : fspec:IL.ILFieldSpec -> ILTypeWriterEnv + val envForOverrideSpec : ospec:IL.ILOverridesSpec -> ILTypeWriterEnv + [] + type MetadataTable<'T> = + { name: string + dict: System.Collections.Generic.Dictionary<'T,int> + mutable lookups: int + mutable rows: ResizeArray<'T> } + with + static member + New : nm:string * + hashEq:System.Collections.Generic.IEqualityComparer<'a> -> + MetadataTable<'a> + member AddSharedEntry : x:'T -> int + member + AddUniqueEntry : nm:string -> getter:('T -> string) -> x:'T -> int + member AddUnsharedEntry : x:'T -> int + member FindOrAddSharedEntry : x:'T -> int + member GetTableEntry : x:'T -> int + member SetRowsOfTable : t:'T [] -> unit + member Count : int + member Entries : 'T list + member EntriesAsArray : 'T [] + end + type MethodDefKey = + class + new : ilg:IL.ILGlobals * tidx:int * garity:int * nm:string * + rty:IL.ILType * argtys:IL.ILTypes * isStatic:bool -> MethodDefKey + override Equals : obj:obj -> bool + override GetHashCode : unit -> int + member ArgTypes : IL.ILTypes + member GenericArity : int + member IsStatic : bool + member Name : string + member ReturnType : IL.ILType + member TypeIdx : int + end + type FieldDefKey = + class + new : tidx:int * nm:string * ty:IL.ILType -> FieldDefKey + override Equals : obj:obj -> bool + override GetHashCode : unit -> int + member Name : string + member Type : IL.ILType + member TypeIdx : int + end + type PropertyTableKey = | PropKey of int * string * IL.ILType * IL.ILTypes + type EventTableKey = | EventKey of int * string + type TypeDefTableKey = | TdKey of string list * string + [] + type MetadataTable = + | Shared of MetadataTable + | Unshared of MetadataTable + with + member AddSharedEntry : x:SharedRow -> int + member AddUnsharedEntry : x:UnsharedRow -> int + member FindOrAddSharedEntry : x:SharedRow -> int + member SetRowsOfSharedTable : rows:RowElement [] [] -> unit + member Count : int + member GenericRowsOfTable : RowElement [] [] + end + [] + type cenv = + { ilg: IL.ILGlobals + emitTailcalls: bool + deterministic: bool + showTimes: bool + desiredMetadataVersion: IL.ILVersionInfo + requiredDataFixups: (int32 * (int * bool)) list ref + mutable requiredStringFixups: (int32 * (int * int) list) list + codeChunks: Internal.ByteBuffer + mutable nextCodeAddr: int32 + mutable moduleGuid: byte [] + generatePdb: bool + pdbinfo: ResizeArray + documents: MetadataTable + data: Internal.ByteBuffer + resources: Internal.ByteBuffer + mutable entrypoint: (bool * int) option + trefCache: System.Collections.Generic.Dictionary + tables: MetadataTable [] + AssemblyRefs: MetadataTable + fieldDefs: MetadataTable + methodDefIdxsByKey: MetadataTable + methodDefIdxs: System.Collections.Generic.Dictionary + propertyDefs: MetadataTable + eventDefs: MetadataTable + typeDefs: MetadataTable + guids: MetadataTable + blobs: MetadataTable + strings: MetadataTable + userStrings: MetadataTable + normalizeAssemblyRefs: IL.ILAssemblyRef -> IL.ILAssemblyRef } + with + member AddCode : (int32 * (int * int) list) * code:byte [] -> unit + member GetCode : unit -> byte [] + member + GetTable : tab:Internal.BinaryConstants.TableName -> MetadataTable + override ToString : unit -> string + end + val FindOrAddSharedRow : + cenv:cenv -> tbl:Internal.BinaryConstants.TableName -> x:SharedRow -> int + val AddSharedRow : + cenv:cenv -> tbl:Internal.BinaryConstants.TableName -> x:SharedRow -> int + val AddUnsharedRow : + cenv:cenv -> + tbl:Internal.BinaryConstants.TableName -> x:UnsharedRow -> int + val metadataSchemaVersionSupportedByCLRVersion : + v:IL.ILVersionInfo -> int * int + val headerVersionSupportedByCLRVersion : v:IL.ILVersionInfo -> int * int + val peOptionalHeaderByteByCLRVersion : v:IL.ILVersionInfo -> int + [] + type ILTokenMappings = + { TypeDefTokenMap: IL.ILTypeDef list * IL.ILTypeDef -> int32 + FieldDefTokenMap: + IL.ILTypeDef list * IL.ILTypeDef -> IL.ILFieldDef -> int32 + MethodDefTokenMap: + IL.ILTypeDef list * IL.ILTypeDef -> IL.ILMethodDef -> int32 + PropertyTokenMap: + IL.ILTypeDef list * IL.ILTypeDef -> IL.ILPropertyDef -> int32 + EventTokenMap: + IL.ILTypeDef list * IL.ILTypeDef -> IL.ILEventDef -> int32 } + val recordRequiredDataFixup : + requiredDataFixups:('a * 'b) list ref -> + buf:Internal.ByteBuffer -> pos:'a -> lab:'b -> unit + val GetUserStringHeapIdx : cenv:cenv -> s:string -> int + val GetBytesAsBlobIdx : cenv:cenv -> bytes:byte [] -> int + val GetStringHeapIdx : cenv:cenv -> s:string -> int + val GetGuidIdx : cenv:cenv -> info:byte [] -> int + val GetStringHeapIdxOption : cenv:cenv -> sopt:string option -> int + val GetTypeNameAsElemPair : cenv:cenv -> n:string -> RowElement * RowElement + val GenTypeDefPass1 : + enc:string list -> cenv:cenv -> td:IL.ILTypeDef -> unit + val GenTypeDefsPass1 : + enc:string list -> cenv:cenv -> tds:IL.ILTypeDef list -> unit + val GetIdxForTypeDef : cenv:cenv -> key:TypeDefTableKey -> int + val GetAssemblyRefAsRow : cenv:cenv -> aref:IL.ILAssemblyRef -> SharedRow + val GetAssemblyRefAsIdx : cenv:cenv -> aref:IL.ILAssemblyRef -> int + val GetModuleRefAsRow : cenv:cenv -> mref:IL.ILModuleRef -> SharedRow + val GetModuleRefAsFileRow : cenv:cenv -> mref:IL.ILModuleRef -> SharedRow + val GetModuleRefAsIdx : cenv:cenv -> mref:IL.ILModuleRef -> int + val GetModuleRefAsFileIdx : cenv:cenv -> mref:IL.ILModuleRef -> int + val isScopeRefLocal : scoref:IL.ILScopeRef -> bool + val isTypeRefLocal : tref:IL.ILTypeRef -> bool + val isTypeLocal : ty:IL.ILType -> bool + val GetScopeRefAsImplementationElem : + cenv:cenv -> + scoref:IL.ILScopeRef -> Internal.BinaryConstants.ImplementationTag * int + val GetTypeRefAsTypeRefRow : cenv:cenv -> tref:IL.ILTypeRef -> SharedRow + val GetTypeRefAsTypeRefIdx : cenv:cenv -> tref:IL.ILTypeRef -> int + val GetTypeDescAsTypeRefIdx : + cenv:cenv -> scoref:IL.ILScopeRef * enc:string list * n:string -> int + val GetResolutionScopeAsElem : + cenv:cenv -> + scoref:IL.ILScopeRef * enc:string list -> + Internal.BinaryConstants.ResolutionScopeTag * int + val emitTypeInfoAsTypeDefOrRefEncoded : + cenv:cenv -> + bb:Internal.ByteBuffer -> + scoref:IL.ILScopeRef * enc:string list * nm:string -> unit + val getTypeDefOrRefAsUncodedToken : + tag:Internal.BinaryConstants.TypeDefOrRefTag * idx:int -> int + val EmitArrayShape : bb:Internal.ByteBuffer -> IL.ILArrayShape -> unit + val hasthisToByte : hasthis:IL.ILThisConvention -> byte + val callconvToByte : ntypars:int -> IL.ILCallingConv -> byte + val EmitTypeSpec : + cenv:cenv -> + env:ILTypeWriterEnv -> + bb:Internal.ByteBuffer -> et:byte * tspec:IL.ILTypeSpec -> unit + val GetTypeAsTypeDefOrRef : + cenv:cenv -> + env:ILTypeWriterEnv -> + ty:IL.ILType -> Internal.BinaryConstants.TypeDefOrRefTag * int + val GetTypeAsBytes : + cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> byte [] + val GetTypeOfLocalAsBytes : + cenv:cenv -> env:ILTypeWriterEnv -> l:IL.ILLocal -> byte [] + val GetTypeAsBlobIdx : + cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> int + val GetTypeAsTypeSpecRow : + cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> SharedRow + val GetTypeAsTypeSpecIdx : + cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> int + val EmitType : + cenv:cenv -> + env:ILTypeWriterEnv -> bb:Internal.ByteBuffer -> ty:IL.ILType -> unit + val EmitLocalInfo : + cenv:cenv -> + env:ILTypeWriterEnv -> bb:Internal.ByteBuffer -> l:IL.ILLocal -> unit + val EmitCallsig : + cenv:cenv -> + env:ILTypeWriterEnv -> + bb:Internal.ByteBuffer -> + callconv:IL.ILCallingConv * args:IL.ILTypes * ret:IL.ILType * + varargs:IL.ILVarArgs * genarity:int -> unit + val GetCallsigAsBytes : + cenv:cenv -> + env:ILTypeWriterEnv -> + IL.ILCallingConv * IL.ILTypes * IL.ILType * IL.ILVarArgs * int -> + byte [] + val EmitTypes : + cenv:cenv -> + env:ILTypeWriterEnv -> bb:Internal.ByteBuffer -> inst:IL.ILTypes -> unit + val GetTypeAsMemberRefParent : + cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> RowElement + val GetVariantTypeAsInt32 : ty:IL.ILNativeVariant -> int32 + val GetNativeTypeAsBlobIdx : cenv:cenv -> ty:IL.ILNativeType -> int + val GetNativeTypeAsBytes : ty:IL.ILNativeType -> byte [] + val EmitNativeType : bb:Internal.ByteBuffer -> ty:IL.ILNativeType -> unit + val GetFieldInitAsBlobIdx : cenv:cenv -> x:IL.ILFieldInit -> int + val GetFieldInit : bb:Internal.ByteBuffer -> x:IL.ILFieldInit -> unit + val GetFieldInitFlags : i:IL.ILFieldInit -> RowElement + val GetMemberAccessFlags : access:IL.ILMemberAccess -> int + val GetTypeAccessFlags : access:IL.ILTypeDefAccess -> int + val GetTypeDefAsRow : + cenv:cenv -> + env:ILTypeWriterEnv -> _enc:'a -> td:IL.ILTypeDef -> UnsharedRow + val GetTypeOptionAsTypeDefOrRef : + cenv:cenv -> + env:ILTypeWriterEnv -> + tyOpt:IL.ILType option -> + Internal.BinaryConstants.TypeDefOrRefTag * int + val GetTypeDefAsPropertyMapRow : cenv:cenv -> tidx:int -> UnsharedRow + val GetTypeDefAsEventMapRow : cenv:cenv -> tidx:int -> UnsharedRow + val GetKeyForFieldDef : tidx:int -> fd:IL.ILFieldDef -> FieldDefKey + val GenFieldDefPass2 : cenv:cenv -> tidx:int -> fd:IL.ILFieldDef -> unit + val GetKeyForMethodDef : + cenv:cenv -> tidx:int -> md:IL.ILMethodDef -> MethodDefKey + val GenMethodDefPass2 : cenv:cenv -> tidx:int -> md:IL.ILMethodDef -> unit + val GetKeyForPropertyDef : + tidx:int -> x:IL.ILPropertyDef -> PropertyTableKey + val GenPropertyDefPass2 : + cenv:cenv -> tidx:int -> x:IL.ILPropertyDef -> unit + val GetTypeAsImplementsRow : + cenv:cenv -> + env:ILTypeWriterEnv -> tidx:int -> ty:IL.ILType -> UnsharedRow + val GenImplementsPass2 : + cenv:cenv -> env:ILTypeWriterEnv -> tidx:int -> ty:IL.ILType -> unit + val GetKeyForEvent : tidx:int -> x:IL.ILEventDef -> EventTableKey + val GenEventDefPass2 : cenv:cenv -> tidx:int -> x:IL.ILEventDef -> unit + val GenTypeDefPass2 : + pidx:int -> enc:string list -> cenv:cenv -> td:IL.ILTypeDef -> unit + val GenTypeDefsPass2 : + pidx:int -> enc:string list -> cenv:cenv -> tds:IL.ILTypeDef list -> unit + exception MethodDefNotFound + val FindMethodDefIdx : cenv:cenv -> mdkey:MethodDefKey -> int + val GetMethodDefIdx : cenv:cenv -> md:IL.ILMethodDef -> int + val FindFieldDefIdx : cenv:cenv -> fdkey:FieldDefKey -> int + val GetFieldDefAsFieldDefIdx : + cenv:cenv -> tidx:int -> fd:IL.ILFieldDef -> int + val GetMethodRefAsMethodDefIdx : cenv:cenv -> mref:IL.ILMethodRef -> int + val MethodRefInfoAsMemberRefRow : + cenv:cenv -> + env:ILTypeWriterEnv -> + fenv:ILTypeWriterEnv -> + nm:string * ty:IL.ILType * callconv:IL.ILCallingConv * + args:IL.ILTypes * ret:IL.ILType * varargs:IL.ILVarArgs * + genarity:int -> SharedRow + val GetMethodRefInfoAsBlobIdx : + cenv:cenv -> + env:ILTypeWriterEnv -> + IL.ILCallingConv * IL.ILTypes * IL.ILType * IL.ILVarArgs * int -> + BlobIndex + val GetMethodRefInfoAsMemberRefIdx : + cenv:cenv -> + env:ILTypeWriterEnv -> + string * IL.ILType * IL.ILCallingConv * IL.ILTypes * IL.ILType * + IL.ILVarArgs * int -> int + val GetMethodRefInfoAsMethodRefOrDef : + isAlwaysMethodDef:bool -> + cenv:cenv -> + env:ILTypeWriterEnv -> + string * IL.ILType * IL.ILCallingConv * IL.ILType list * IL.ILType * + IL.ILTypes option * int -> + Internal.BinaryConstants.MethodDefOrRefTag * int + val GetMethodSpecInfoAsMethodSpecIdx : + cenv:cenv -> + env:ILTypeWriterEnv -> + nm:string * ty:IL.ILType * cc:IL.ILCallingConv * args:IL.ILType list * + ret:IL.ILType * varargs:IL.ILTypes option * minst:IL.ILGenericArgs -> + int + val GetMethodDefOrRefAsUncodedToken : + tag:Internal.BinaryConstants.MethodDefOrRefTag * idx:int -> int + val GetMethodSpecInfoAsUncodedToken : + cenv:cenv -> + env:ILTypeWriterEnv -> + string * IL.ILType * IL.ILCallingConv * IL.ILType list * IL.ILType * + IL.ILTypes option * IL.ILGenericArgs -> int + val GetMethodSpecAsUncodedToken : + cenv:cenv -> + env:ILTypeWriterEnv -> IL.ILMethodSpec * IL.ILTypes option -> int + val GetMethodRefInfoOfMethodSpecInfo : + nm:string * ty:IL.ILType * cc:IL.ILCallingConv * args:IL.ILType list * + ret:IL.ILType * varargs:IL.ILTypes option * minst:IL.ILGenericArgs -> + string * IL.ILType * IL.ILCallingConv * IL.ILType list * IL.ILType * + IL.ILTypes option * int + val GetMethodSpecAsMethodDefOrRef : + cenv:cenv -> + env:ILTypeWriterEnv -> + mspec:IL.ILMethodSpec * varargs:IL.ILTypes option -> + Internal.BinaryConstants.MethodDefOrRefTag * int + val GetMethodSpecAsMethodDef : + cenv:cenv -> + env:ILTypeWriterEnv -> + mspec:IL.ILMethodSpec * varargs:IL.ILTypes option -> + Internal.BinaryConstants.MethodDefOrRefTag * int + val InfoOfMethodSpec : + mspec:IL.ILMethodSpec * varargs:IL.ILTypes option -> + string * IL.ILType * IL.ILCallingConv * IL.ILType list * IL.ILType * + IL.ILTypes option * IL.ILGenericArgs + val GetOverridesSpecAsMemberRefIdx : + cenv:cenv -> env:ILTypeWriterEnv -> ospec:IL.ILOverridesSpec -> int + val GetOverridesSpecAsMethodDefOrRef : + cenv:cenv -> + env:ILTypeWriterEnv -> + ospec:IL.ILOverridesSpec -> + Internal.BinaryConstants.MethodDefOrRefTag * int + val GetMethodRefAsMemberRefIdx : + cenv:cenv -> + env:ILTypeWriterEnv -> + fenv:ILTypeWriterEnv -> mref:IL.ILMethodRef -> int + val GetMethodRefAsCustomAttribType : + cenv:cenv -> + mref:IL.ILMethodRef -> + Internal.BinaryConstants.CustomAttributeTypeTag * int + val GetCustomAttrDataAsBlobIdx : cenv:cenv -> data:byte [] -> int + val GetCustomAttrRow : + cenv:cenv -> + Internal.BinaryConstants.HasCustomAttributeTag * int -> + attr:IL.ILAttribute -> UnsharedRow + val GenCustomAttrPass3Or4 : + cenv:cenv -> + Internal.BinaryConstants.HasCustomAttributeTag * int -> + attr:IL.ILAttribute -> unit + val GenCustomAttrsPass3Or4 : + cenv:cenv -> + Internal.BinaryConstants.HasCustomAttributeTag * int -> + attrs:IL.ILAttributes -> unit + val GetSecurityDeclRow : + cenv:cenv -> + Internal.BinaryConstants.HasDeclSecurityTag * int -> + IL.ILSecurityDecl -> UnsharedRow + val GenSecurityDeclPass3 : + cenv:cenv -> + Internal.BinaryConstants.HasDeclSecurityTag * int -> + attr:IL.ILSecurityDecl -> unit + val GenSecurityDeclsPass3 : + cenv:cenv -> + Internal.BinaryConstants.HasDeclSecurityTag * int -> + attrs:IL.ILSecurityDecl list -> unit + val GetFieldSpecAsMemberRefRow : + cenv:cenv -> + env:ILTypeWriterEnv -> + fenv:ILTypeWriterEnv -> fspec:IL.ILFieldSpec -> SharedRow + val GetFieldSpecAsMemberRefIdx : + cenv:cenv -> env:ILTypeWriterEnv -> fspec:IL.ILFieldSpec -> int + val EmitFieldSpecSig : + cenv:cenv -> + env:ILTypeWriterEnv -> + bb:Internal.ByteBuffer -> fspec:IL.ILFieldSpec -> unit + val GetFieldSpecSigAsBytes : + cenv:cenv -> env:ILTypeWriterEnv -> x:IL.ILFieldSpec -> byte [] + val GetFieldSpecSigAsBlobIdx : + cenv:cenv -> env:ILTypeWriterEnv -> x:IL.ILFieldSpec -> BlobIndex + val GetFieldSpecAsFieldDefOrRef : + cenv:cenv -> env:ILTypeWriterEnv -> fspec:IL.ILFieldSpec -> bool * int + val GetFieldDefOrRefAsUncodedToken : tag:bool * idx:int -> int + val GetCallsigAsBlobIdx : + cenv:cenv -> + env:ILTypeWriterEnv -> + callsig:IL.ILCallingSignature * varargs:IL.ILVarArgs -> int + val GetCallsigAsStandAloneSigRow : + cenv:cenv -> + env:ILTypeWriterEnv -> IL.ILCallingSignature * IL.ILVarArgs -> SharedRow + val GetCallsigAsStandAloneSigIdx : + cenv:cenv -> + env:ILTypeWriterEnv -> IL.ILCallingSignature * IL.ILVarArgs -> int + val EmitLocalSig : + cenv:cenv -> + env:ILTypeWriterEnv -> + bb:Internal.ByteBuffer -> locals:IL.ILLocals -> unit + val GetLocalSigAsBlobHeapIdx : + cenv:cenv -> env:ILTypeWriterEnv -> locals:IL.ILLocals -> int + val GetLocalSigAsStandAloneSigIdx : + cenv:cenv -> env:ILTypeWriterEnv -> locals:IL.ILLocals -> SharedRow + type ExceptionClauseKind = + | FinallyClause + | FaultClause + | TypeFilterClause of int32 + | FilterClause of int + type ExceptionClauseSpec = int * int * int * int * ExceptionClauseKind + type CodeBuffer = + { code: Internal.ByteBuffer + mutable reqdBrFixups: + ((int * int option) * int * IL.ILCodeLabel list) list + availBrFixups: System.Collections.Generic.Dictionary + mutable reqdStringFixupsInMethod: (int * int) list + mutable seh: ExceptionClauseSpec list + seqpoints: ResizeArray } + with + static member Create : _nm:'a -> CodeBuffer + member EmitByte : x:int -> unit + member EmitExceptionClause : seh:ExceptionClauseSpec -> unit + member EmitInt32 : x:int32 -> unit + member EmitInt64 : x:int64 -> unit + member EmitSeqPoint : cenv:cenv -> m:IL.ILSourceMarker -> unit + member EmitUInt16 : x:uint16 -> unit + member EmitUncodedToken : u:int32 -> unit + member RecordAvailBrFixup : tg:IL.ILCodeLabel -> unit + member + RecordReqdBrFixup : i:(int * int option) -> tg:IL.ILCodeLabel -> unit + member + RecordReqdBrFixups : i:(int * int option) -> + tgs:IL.ILCodeLabel list -> unit + member RecordReqdStringFixup : stringIdx:int -> unit + end + module Codebuf = begin + val binaryChop : p:('T -> int) -> arr:'T [] -> int + val applyBrFixups : + origCode:byte [] -> + origExnClauses:(int * int * int * int * ExceptionClauseKind) list -> + origReqdStringFixups:(int * 'a) list -> + origAvailBrFixups:System.Collections.Generic.Dictionary -> + origReqdBrFixups:((int * int option) * int * IL.ILCodeLabel list) list -> + origSeqPoints:ILPdbWriter.PdbSequencePoint [] -> + origScopes:ILPdbWriter.PdbMethodScope list -> + byte [] * (int * 'a) list * + (int * int * int * int * ExceptionClauseKind) list * + ILPdbWriter.PdbSequencePoint [] * + ILPdbWriter.PdbMethodScope list + type SEHTree = | Node of ExceptionClauseSpec option * SEHTree list + val encodingsForNoArgInstrs : + System.Collections.Generic.Dictionary + val encodingsOfNoArgInstr : si:IL.ILInstr -> int + val emitInstrCode : codebuf:CodeBuffer -> i:int -> unit + val emitTypeInstr : + cenv:cenv -> + codebuf:CodeBuffer -> + env:ILTypeWriterEnv -> i:int -> ty:IL.ILType -> unit + val emitMethodSpecInfoInstr : + cenv:cenv -> + codebuf:CodeBuffer -> + env:ILTypeWriterEnv -> + i:int -> + string * IL.ILType * IL.ILCallingConv * IL.ILType list * + IL.ILType * IL.ILTypes option * IL.ILGenericArgs -> unit + val emitMethodSpecInstr : + cenv:cenv -> + codebuf:CodeBuffer -> + env:ILTypeWriterEnv -> + i:int -> IL.ILMethodSpec * IL.ILTypes option -> unit + val emitFieldSpecInstr : + cenv:cenv -> + codebuf:CodeBuffer -> + env:ILTypeWriterEnv -> i:int -> fspec:IL.ILFieldSpec -> unit + val emitShortUInt16Instr : + codebuf:CodeBuffer -> i_short:int * i:int -> x:uint16 -> unit + val emitShortInt32Instr : + codebuf:CodeBuffer -> i_short:int * i:int -> x:int -> unit + val emitTailness : + cenv:cenv -> codebuf:CodeBuffer -> tl:IL.ILTailcall -> unit + val emitVolatility : codebuf:CodeBuffer -> tl:IL.ILVolatility -> unit + val emitConstrained : + cenv:cenv -> + codebuf:CodeBuffer -> env:ILTypeWriterEnv -> ty:IL.ILType -> unit + val emitAlignment : codebuf:CodeBuffer -> tl:IL.ILAlignment -> unit + val emitInstr : + cenv:cenv -> + codebuf:CodeBuffer -> env:ILTypeWriterEnv -> instr:IL.ILInstr -> unit + val mkScopeNode : + cenv:cenv -> + localSigs:byte [] [] -> + startOffset:int * endOffset:int * ls:IL.ILLocalDebugMapping list * + childScopes:ILPdbWriter.PdbMethodScope list -> + ILPdbWriter.PdbMethodScope list + val rangeInsideRange : + start_pc1:int * end_pc1:int -> start_pc2:int * end_pc2:int -> bool + val lranges_of_clause : + cl:IL.ILExceptionClause -> (IL.ILCodeLabel * IL.ILCodeLabel) list + val labelsToRange : + lab2pc:System.Collections.Generic.Dictionary -> + IL.ILCodeLabel * IL.ILCodeLabel -> int * int + val labelRangeInsideLabelRange : + lab2pc:System.Collections.Generic.Dictionary -> + IL.ILCodeLabel * IL.ILCodeLabel -> + IL.ILCodeLabel * IL.ILCodeLabel -> bool + val findRoots : + contains:('a -> 'a -> bool) -> vs:'a list -> ('a * 'a list) list + val makeSEHTree : + cenv:cenv -> + env:ILTypeWriterEnv -> + pc2pos:int [] -> + lab2pc:System.Collections.Generic.Dictionary -> + exs:IL.ILExceptionSpec list -> SEHTree list + val makeLocalsTree : + cenv:cenv -> + localSigs:byte [] [] -> + pc2pos:int [] -> + lab2pc:System.Collections.Generic.Dictionary -> + exs:IL.ILLocalDebugInfo list -> ILPdbWriter.PdbMethodScope list + val emitExceptionHandlerTree : codebuf:CodeBuffer -> SEHTree -> unit + val emitCode : + cenv:cenv -> + localSigs:byte [] [] -> + codebuf:CodeBuffer -> + env:ILTypeWriterEnv -> + code:IL.ILCode -> ILPdbWriter.PdbMethodScope list + val EmitTopCode : + cenv:cenv -> + localSigs:byte [] [] -> + env:ILTypeWriterEnv -> + nm:'a -> + code:IL.ILCode -> + (int * int) list * + (int * int * int * int * ExceptionClauseKind) list * byte [] * + ILPdbWriter.PdbSequencePoint [] * ILPdbWriter.PdbMethodScope + end + val GetFieldDefTypeAsBlobIdx : + cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> int + val GenILMethodBody : + mname:'a -> + cenv:cenv -> + env:ILTypeWriterEnv -> + il:IL.ILMethodBody -> + int * ((int * (int * int) list) * byte []) * + ILPdbWriter.PdbSequencePoint [] * ILPdbWriter.PdbMethodScope + val GetFieldDefAsFieldDefRow : + cenv:cenv -> env:ILTypeWriterEnv -> fd:IL.ILFieldDef -> UnsharedRow + val GetFieldDefSigAsBlobIdx : + cenv:cenv -> env:ILTypeWriterEnv -> fd:IL.ILFieldDef -> int + val GenFieldDefPass3 : + cenv:cenv -> env:ILTypeWriterEnv -> fd:IL.ILFieldDef -> unit + val GetGenericParamAsGenericParamRow : + cenv:cenv -> + _env:'a -> + idx:int -> + Internal.BinaryConstants.TypeOrMethodDefTag * int -> + gp:IL.ILGenericParameterDef -> SharedRow + val GenTypeAsGenericParamConstraintRow : + cenv:cenv -> + env:ILTypeWriterEnv -> gpidx:int -> ty:IL.ILType -> UnsharedRow + val GenGenericParamConstraintPass4 : + cenv:cenv -> env:ILTypeWriterEnv -> gpidx:int -> ty:IL.ILType -> unit + val GenGenericParamPass3 : + cenv:cenv -> + env:'a -> + idx:int -> + Internal.BinaryConstants.TypeOrMethodDefTag * int -> + gp:IL.ILGenericParameterDef -> unit + val GenGenericParamPass4 : + cenv:cenv -> + env:ILTypeWriterEnv -> + idx:int -> + Internal.BinaryConstants.TypeOrMethodDefTag * int -> + gp:IL.ILGenericParameterDef -> unit + val GetParamAsParamRow : + cenv:cenv -> _env:'a -> seq:int -> param:IL.ILParameter -> UnsharedRow + val GenParamPass3 : + cenv:cenv -> env:'a -> seq:int -> param:IL.ILParameter -> unit + val GenReturnAsParamRow : returnv:IL.ILReturn -> UnsharedRow + val GenReturnPass3 : cenv:cenv -> returnv:IL.ILReturn -> unit + val GetMethodDefSigAsBytes : + cenv:cenv -> env:ILTypeWriterEnv -> mdef:IL.ILMethodDef -> byte [] + val GenMethodDefSigAsBlobIdx : + cenv:cenv -> env:ILTypeWriterEnv -> mdef:IL.ILMethodDef -> int + val GenMethodDefAsRow : + cenv:cenv -> + env:ILTypeWriterEnv -> midx:int -> md:IL.ILMethodDef -> UnsharedRow + val GenMethodImplPass3 : + cenv:cenv -> + env:ILTypeWriterEnv -> + _tgparams:'a -> tidx:int -> mimpl:IL.ILMethodImplDef -> unit + val GenMethodDefPass3 : + cenv:cenv -> env:ILTypeWriterEnv -> md:IL.ILMethodDef -> unit + val GenMethodDefPass4 : + cenv:cenv -> env:ILTypeWriterEnv -> md:IL.ILMethodDef -> unit + val GenPropertyMethodSemanticsPass3 : + cenv:cenv -> pidx:int -> kind:int -> mref:IL.ILMethodRef -> unit + val GetPropertySigAsBlobIdx : + cenv:cenv -> env:ILTypeWriterEnv -> prop:IL.ILPropertyDef -> int + val GetPropertySigAsBytes : + cenv:cenv -> env:ILTypeWriterEnv -> prop:IL.ILPropertyDef -> byte [] + val GetPropertyAsPropertyRow : + cenv:cenv -> env:ILTypeWriterEnv -> prop:IL.ILPropertyDef -> UnsharedRow + val GenPropertyPass3 : + cenv:cenv -> env:ILTypeWriterEnv -> prop:IL.ILPropertyDef -> unit + val GenEventMethodSemanticsPass3 : + cenv:cenv -> eidx:int -> kind:int -> mref:IL.ILMethodRef -> unit + val GenEventAsEventRow : + cenv:cenv -> env:ILTypeWriterEnv -> md:IL.ILEventDef -> UnsharedRow + val GenEventPass3 : + cenv:cenv -> env:ILTypeWriterEnv -> md:IL.ILEventDef -> unit + val GetResourceAsManifestResourceRow : + cenv:cenv -> r:IL.ILResource -> UnsharedRow + val GenResourcePass3 : cenv:cenv -> r:IL.ILResource -> unit + val GenTypeDefPass3 : + enc:string list -> cenv:cenv -> td:IL.ILTypeDef -> unit + val GenTypeDefsPass3 : + enc:string list -> cenv:cenv -> tds:IL.ILTypeDef list -> unit + val GenTypeDefPass4 : + enc:string list -> cenv:cenv -> td:IL.ILTypeDef -> unit + val GenTypeDefsPass4 : + enc:string list -> cenv:cenv -> tds:IL.ILTypeDef list -> unit + val timestamp : int32 + val GenNestedExportedTypePass3 : + cenv:cenv -> cidx:int -> ce:IL.ILNestedExportedType -> unit + val GenNestedExportedTypesPass3 : + cenv:cenv -> nidx:int -> nce:IL.ILNestedExportedTypes -> unit + val GenExportedTypePass3 : + cenv:cenv -> ce:IL.ILExportedTypeOrForwarder -> unit + val GenExportedTypesPass3 : + cenv:cenv -> ce:IL.ILExportedTypesAndForwarders -> unit + val GetManifestAsAssemblyRow : + cenv:cenv -> m:IL.ILAssemblyManifest -> UnsharedRow + val GenManifestPass3 : cenv:cenv -> m:IL.ILAssemblyManifest -> unit + val newGuid : modul:IL.ILModuleDef -> byte [] + val deterministicGuid : modul:IL.ILModuleDef -> byte [] + val GetModuleAsRow : cenv:cenv -> modul:IL.ILModuleDef -> UnsharedRow + val rowElemCompare : e1:RowElement -> e2:RowElement -> int + val TableRequiresSorting : tab:Internal.BinaryConstants.TableName -> bool + val SortTableRows : + tab:Internal.BinaryConstants.TableName -> + rows:GenericRow [] -> GenericRow [] + val GenModule : cenv:cenv -> modul:IL.ILModuleDef -> unit + val generateIL : + requiredDataFixups:(int32 * (int * bool)) list ref -> + desiredMetadataVersion:IL.ILVersionInfo * generatePdb:bool * + ilg:IL.ILGlobals * emitTailcalls:bool * deterministic:bool * + showTimes:bool -> + m:IL.ILModuleDef -> + cilStartAddress:int32 -> + normalizeAssemblyRefs:(IL.ILAssemblyRef -> IL.ILAssemblyRef) -> + byte [] [] * byte [] [] * byte [] [] * byte [] [] * + MetadataTable [] * int * byte [] * + (int32 * (int * int) list) list * byte [] * byte [] * + ILPdbWriter.PdbData * ILTokenMappings + val chunk : sz:int32 -> next:int32 -> ILPdbWriter.BinaryChunk * int32 + val emptychunk : next:int32 -> ILPdbWriter.BinaryChunk * int32 + val nochunk : next:'a -> ILPdbWriter.BinaryChunk * 'a + val count : f:('a -> int) -> arr:'a [] -> int + module FileSystemUtilities = begin + val progress : bool + val setExecutablePermission : filename:string -> unit + end + val writeILMetadataAndCode : + generatePdb:bool * desiredMetadataVersion:IL.ILVersionInfo * + ilg:IL.ILGlobals * emitTailcalls:bool * deterministic:bool * + showTimes:bool -> + modul:IL.ILModuleDef -> + cilStartAddress:int32 -> + normalizeAssemblyRefs:(IL.ILAssemblyRef -> IL.ILAssemblyRef) -> + int * byte [] * byte [] * byte [] * byte [] * byte [] * + (int32 * (int * bool)) list * ILPdbWriter.PdbData * + ILTokenMappings * int + val msdosHeader : byte [] + val writeInt64 : os:System.IO.BinaryWriter -> x:int64 -> unit + val writeInt32 : os:System.IO.BinaryWriter -> x:int -> unit + val writeInt32AsUInt16 : os:System.IO.BinaryWriter -> x:int -> unit + val writeDirectory : + os:System.IO.BinaryWriter -> dict:ILPdbWriter.BinaryChunk -> unit + val writeBytes : os:System.IO.BinaryWriter -> chunk:byte [] -> unit + val writeBinaryAndReportMappings : + outfile:string * ilg:IL.ILGlobals * pdbfile:string option * + signer:Internal.StrongNameSign.ILStrongNameSigner option * + portablePDB:bool * embeddedPDB:bool * embedAllSource:bool * + embedSourceList:string list * sourceLink:string * + checksumAlgorithm:ILPdbWriter.HashAlgorithm * emitTailcalls:bool * + deterministic:bool * showTimes:bool * dumpDebugInfo:bool * + pathMap:Internal.Utilities.PathMap -> + modul:IL.ILModuleDef -> + normalizeAssemblyRefs:(IL.ILAssemblyRef -> IL.ILAssemblyRef) -> + ILTokenMappings + type options = + { ilg: IL.ILGlobals + pdbfile: string option + portablePDB: bool + embeddedPDB: bool + embedAllSource: bool + embedSourceList: string list + sourceLink: string + checksumAlgorithm: ILPdbWriter.HashAlgorithm + signer: Internal.StrongNameSign.ILStrongNameSigner option + emitTailcalls: bool + deterministic: bool + showTimes: bool + dumpDebugInfo: bool + pathMap: Internal.Utilities.PathMap } + val WriteILBinary : + filename:string * options:options * inputModule:IL.ILModuleDef * + (IL.ILAssemblyRef -> IL.ILAssemblyRef) -> unit + end + +namespace FSharp.Compiler.AbstractIL + module internal ILRuntimeWriter = begin + val codeLabelOrder : System.Collections.Generic.IComparer + val wrapCustomAttr : + setCustomAttr:('a * 'b -> 'c) -> cinfo:'a * bytes:'b -> 'c + val logRefEmitCalls : bool + type AssemblyBuilder with + member + DefineDynamicModuleAndLog : a:string * b:'a * c:'b -> + System.Reflection.Emit.ModuleBuilder + type AssemblyBuilder with + member + SetCustomAttributeAndLog : cinfo:System.Reflection.ConstructorInfo * + bytes:byte [] -> unit + type AssemblyBuilder with + member + SetCustomAttributeAndLog : cab:System.Reflection.Emit.CustomAttributeBuilder -> + unit + type ModuleBuilder with + member + GetArrayMethodAndLog : aty:System.Type * nm:string * + flags:System.Reflection.CallingConventions * + rty:System.Type * tys:System.Type [] -> + System.Reflection.MethodInfo + type ModuleBuilder with + member + GetTypeAndLog : nameInModule:string * flag1:bool * flag2:bool -> + System.Type + type ModuleBuilder with + member + DefineTypeAndLog : name:string * attrs:System.Reflection.TypeAttributes -> + System.Reflection.Emit.TypeBuilder + type ModuleBuilder with + member + SetCustomAttributeAndLog : cinfo:System.Reflection.ConstructorInfo * + bytes:byte [] -> unit + type ConstructorBuilder with + member + SetImplementationFlagsAndLog : attrs:System.Reflection.MethodImplAttributes -> + unit + type ConstructorBuilder with + member + DefineParameterAndLog : n:int * + attr:System.Reflection.ParameterAttributes * + nm:string -> + System.Reflection.Emit.ParameterBuilder + type ConstructorBuilder with + member GetILGeneratorAndLog : unit -> System.Reflection.Emit.ILGenerator + type MethodBuilder with + member + SetImplementationFlagsAndLog : attrs:System.Reflection.MethodImplAttributes -> + unit + type MethodBuilder with + member + SetSignatureAndLog : returnType:System.Type * + returnTypeRequiredCustomModifiers:System.Type [] * + returnTypeOptionalCustomModifiers:System.Type [] * + parameterTypes:System.Type [] * + parameterTypeRequiredCustomModifiers:System.Type [] [] * + parameterTypeOptionalCustomModifiers:System.Type [] [] -> + unit + type MethodBuilder with + member + DefineParameterAndLog : n:int * + attr:System.Reflection.ParameterAttributes * + nm:string -> + System.Reflection.Emit.ParameterBuilder + type MethodBuilder with + member + DefineGenericParametersAndLog : gps:string [] -> + System.Reflection.Emit.GenericTypeParameterBuilder [] + type MethodBuilder with + member GetILGeneratorAndLog : unit -> System.Reflection.Emit.ILGenerator + type MethodBuilder with + member + SetCustomAttributeAndLog : cinfo:System.Reflection.ConstructorInfo * + bytes:byte [] -> unit + type TypeBuilder with + member CreateTypeAndLog : unit -> System.Type + type TypeBuilder with + member + DefineNestedTypeAndLog : name:string * + attrs:System.Reflection.TypeAttributes -> + System.Reflection.Emit.TypeBuilder + type TypeBuilder with + member + DefineMethodAndLog : name:string * + attrs:System.Reflection.MethodAttributes * + cconv:System.Reflection.CallingConventions -> + System.Reflection.Emit.MethodBuilder + type TypeBuilder with + member + DefineGenericParametersAndLog : gps:string [] -> + System.Reflection.Emit.GenericTypeParameterBuilder [] + type TypeBuilder with + member + DefineConstructorAndLog : attrs:System.Reflection.MethodAttributes * + cconv:System.Reflection.CallingConventions * + parms:System.Type [] -> + System.Reflection.Emit.ConstructorBuilder + type TypeBuilder with + member + DefineFieldAndLog : nm:string * ty:System.Type * + attrs:System.Reflection.FieldAttributes -> + System.Reflection.Emit.FieldBuilder + type TypeBuilder with + member + DefinePropertyAndLog : nm:string * + attrs:System.Reflection.PropertyAttributes * + ty:System.Type * args:System.Type [] -> + System.Reflection.Emit.PropertyBuilder + type TypeBuilder with + member + DefineEventAndLog : nm:string * attrs:System.Reflection.EventAttributes * + ty:System.Type -> + System.Reflection.Emit.EventBuilder + type TypeBuilder with + member SetParentAndLog : ty:System.Type -> unit + type TypeBuilder with + member AddInterfaceImplementationAndLog : ty:System.Type -> unit + type TypeBuilder with + member InvokeMemberAndLog : nm:string * _flags:'a * args:obj [] -> obj + type TypeBuilder with + member + SetCustomAttributeAndLog : cinfo:System.Reflection.ConstructorInfo * + bytes:byte [] -> unit + type OpCode with + member RefEmitName : string + type ILGenerator with + member + DeclareLocalAndLog : ty:System.Type * isPinned:bool -> + System.Reflection.Emit.LocalBuilder + type ILGenerator with + member MarkLabelAndLog : lab:System.Reflection.Emit.Label -> unit + type ILGenerator with + member BeginExceptionBlockAndLog : unit -> System.Reflection.Emit.Label + type ILGenerator with + member EndExceptionBlockAndLog : unit -> unit + type ILGenerator with + member BeginFinallyBlockAndLog : unit -> unit + type ILGenerator with + member BeginCatchBlockAndLog : ty:System.Type -> unit + type ILGenerator with + member BeginExceptFilterBlockAndLog : unit -> unit + type ILGenerator with + member BeginFaultBlockAndLog : unit -> unit + type ILGenerator with + member DefineLabelAndLog : unit -> System.Reflection.Emit.Label + type ILGenerator with + member EmitAndLog : op:System.Reflection.Emit.OpCode -> unit + type ILGenerator with + member + EmitAndLog : op:System.Reflection.Emit.OpCode * + v:System.Reflection.Emit.Label -> unit + type ILGenerator with + member EmitAndLog : op:System.Reflection.Emit.OpCode * v:int16 -> unit + type ILGenerator with + member EmitAndLog : op:System.Reflection.Emit.OpCode * v:int32 -> unit + type ILGenerator with + member + EmitAndLog : op:System.Reflection.Emit.OpCode * + v:System.Reflection.MethodInfo -> unit + type ILGenerator with + member EmitAndLog : op:System.Reflection.Emit.OpCode * v:string -> unit + type ILGenerator with + member + EmitAndLog : op:System.Reflection.Emit.OpCode * v:System.Type -> unit + type ILGenerator with + member + EmitAndLog : op:System.Reflection.Emit.OpCode * + v:System.Reflection.FieldInfo -> unit + type ILGenerator with + member + EmitAndLog : op:System.Reflection.Emit.OpCode * + v:System.Reflection.ConstructorInfo -> unit + val inline flagsIf : b:bool -> x: ^a -> ^a when ^a : enum + module Zmap = begin + val force : x:'a -> m:Internal.Zmap<'a,'b> -> str:string -> 'b + end + val equalTypes : s:System.Type -> t:System.Type -> bool + val equalTypeLists : ss:#System.Type list -> tt:#System.Type list -> bool + val equalTypeArrays : ss:#System.Type [] -> tt:#System.Type [] -> bool + val getGenericArgumentsOfType : typT:System.Type -> System.Type [] + val getGenericArgumentsOfMethod : + methI:System.Reflection.MethodInfo -> System.Type [] + val getTypeConstructor : ty:System.Type -> System.Type + val convAssemblyRef : + aref:IL.ILAssemblyRef -> System.Reflection.AssemblyName + type cenv = + { ilg: IL.ILGlobals + tryFindSysILTypeRef: string -> IL.ILTypeRef option + generatePdb: bool + resolveAssemblyRef: + IL.ILAssemblyRef -> Choice option } + with + override ToString : unit -> string + end + val convResolveAssemblyRef : + cenv:cenv -> + asmref:IL.ILAssemblyRef -> qualifiedName:string -> System.Type + val convTypeRefAux : cenv:cenv -> tref:IL.ILTypeRef -> System.Type + type emEnv = + { emTypMap: + Internal.Zmap + emConsMap: + Internal.Zmap + emMethMap: + Internal.Zmap + emFieldMap: + Internal.Zmap + emPropMap: + Internal.Zmap + emLocals: System.Reflection.Emit.LocalBuilder [] + emLabels: Internal.Zmap + emTyvars: System.Type [] list + emEntryPts: (System.Reflection.Emit.TypeBuilder * string) list + delayedFieldInits: (unit -> unit) list } + val orderILTypeRef : System.Collections.Generic.IComparer + val orderILMethodRef : System.Collections.Generic.IComparer + val orderILFieldRef : System.Collections.Generic.IComparer + val orderILPropertyRef : + System.Collections.Generic.IComparer + val emEnv0 : emEnv + val envBindTypeRef : + emEnv:emEnv -> + tref:IL.ILTypeRef -> + typT:System.Type * typB:System.Reflection.Emit.TypeBuilder * + typeDef:IL.ILTypeDef -> emEnv + val envUpdateCreatedTypeRef : emEnv:emEnv -> tref:IL.ILTypeRef -> emEnv + val convTypeRef : + cenv:cenv -> + emEnv:emEnv -> preferCreated:bool -> tref:IL.ILTypeRef -> System.Type + val envBindConsRef : + emEnv:emEnv -> + mref:IL.ILMethodRef -> + consB:System.Reflection.Emit.ConstructorBuilder -> emEnv + val envGetConsB : + emEnv:emEnv -> + mref:IL.ILMethodRef -> System.Reflection.Emit.ConstructorBuilder + val envBindMethodRef : + emEnv:emEnv -> + mref:IL.ILMethodRef -> + methB:System.Reflection.Emit.MethodBuilder -> emEnv + val envGetMethB : + emEnv:emEnv -> mref:IL.ILMethodRef -> System.Reflection.Emit.MethodBuilder + val envBindFieldRef : + emEnv:emEnv -> + fref:IL.ILFieldRef -> + fieldB:System.Reflection.Emit.FieldBuilder -> emEnv + val envGetFieldB : + emEnv:emEnv -> fref:IL.ILFieldRef -> System.Reflection.Emit.FieldBuilder + val envBindPropRef : + emEnv:emEnv -> + pref:IL.ILPropertyRef -> + propB:System.Reflection.Emit.PropertyBuilder -> emEnv + val envGetPropB : + emEnv:emEnv -> + pref:IL.ILPropertyRef -> System.Reflection.Emit.PropertyBuilder + val envGetTypB : + emEnv:emEnv -> tref:IL.ILTypeRef -> System.Reflection.Emit.TypeBuilder + val envGetTypeDef : emEnv:emEnv -> tref:IL.ILTypeRef -> IL.ILTypeDef + val envSetLocals : + emEnv:emEnv -> locs:System.Reflection.Emit.LocalBuilder [] -> emEnv + val envGetLocal : + emEnv:emEnv -> i:int -> System.Reflection.Emit.LocalBuilder + val envSetLabel : + emEnv:emEnv -> + name:IL.ILCodeLabel -> lab:System.Reflection.Emit.Label -> emEnv + val envGetLabel : + emEnv:emEnv -> name:IL.ILCodeLabel -> System.Reflection.Emit.Label + val envPushTyvars : emEnv:emEnv -> tys:System.Type [] -> emEnv + val envPopTyvars : emEnv:emEnv -> emEnv + val envGetTyvar : emEnv:emEnv -> u16:uint16 -> System.Type + val isEmittedTypeRef : emEnv:emEnv -> tref:IL.ILTypeRef -> bool + val envAddEntryPt : + emEnv:emEnv -> System.Reflection.Emit.TypeBuilder * string -> emEnv + val envPopEntryPts : + emEnv:emEnv -> emEnv * (System.Reflection.Emit.TypeBuilder * string) list + val convCallConv : IL.ILCallingConv -> System.Reflection.CallingConventions + val convTypeSpec : + cenv:cenv -> + emEnv:emEnv -> preferCreated:bool -> tspec:IL.ILTypeSpec -> System.Type + val convTypeAux : + cenv:cenv -> + emEnv:emEnv -> preferCreated:bool -> ty:IL.ILType -> System.Type + val convType : cenv:cenv -> emEnv:emEnv -> ty:IL.ILType -> System.Type + val convTypeOrTypeDef : + cenv:cenv -> emEnv:emEnv -> ty:IL.ILType -> System.Type + val convTypes : + cenv:cenv -> emEnv:emEnv -> tys:IL.ILTypes -> System.Type list + val convTypesToArray : + cenv:cenv -> emEnv:emEnv -> tys:IL.ILTypes -> System.Type [] + val convCreatedType : + cenv:cenv -> emEnv:emEnv -> ty:IL.ILType -> System.Type + val convCreatedTypeRef : + cenv:cenv -> emEnv:emEnv -> ty:IL.ILTypeRef -> System.Type + val convParamModifiersOfType : + cenv:cenv -> emEnv:emEnv -> pty:IL.ILType -> (bool * System.Type) [] + val splitModifiers : mods:(bool * 'a) [] -> 'a [] * 'a [] + val convParamModifiers : + cenv:cenv -> + emEnv:emEnv -> p:IL.ILParameter -> System.Type [] * System.Type [] + val convReturnModifiers : + cenv:cenv -> + emEnv:emEnv -> p:IL.ILReturn -> System.Type [] * System.Type [] + val TypeBuilderInstantiationT : System.Type + val typeIsNotQueryable : ty:System.Type -> bool + val queryableTypeGetField : + _emEnv:'a -> + parentT:System.Type -> fref:IL.ILFieldRef -> System.Reflection.FieldInfo + val nonQueryableTypeGetField : + parentTI:System.Type -> + fieldInfo:System.Reflection.FieldInfo -> System.Reflection.FieldInfo + val convFieldSpec : + cenv:cenv -> + emEnv:emEnv -> fspec:IL.ILFieldSpec -> System.Reflection.FieldInfo + val queryableTypeGetMethodBySearch : + cenv:cenv -> + emEnv:emEnv -> + parentT:System.Type -> + mref:IL.ILMethodRef -> System.Reflection.MethodInfo + val queryableTypeGetMethod : + cenv:cenv -> + emEnv:emEnv -> + parentT:System.Type -> + mref:IL.ILMethodRef -> System.Reflection.MethodInfo + val nonQueryableTypeGetMethod : + parentTI:System.Type -> + methInfo:System.Reflection.MethodInfo -> System.Reflection.MethodInfo + val convMethodRef : + cenv:cenv -> + emEnv:emEnv -> + parentTI:System.Type -> + mref:IL.ILMethodRef -> System.Reflection.MethodInfo + val convMethodSpec : + cenv:cenv -> + emEnv:emEnv -> mspec:IL.ILMethodSpec -> System.Reflection.MethodInfo + val queryableTypeGetConstructor : + cenv:cenv -> + emEnv:emEnv -> + parentT:System.Type -> + mref:IL.ILMethodRef -> System.Reflection.ConstructorInfo + val nonQueryableTypeGetConstructor : + parentTI:System.Type -> + consInfo:System.Reflection.ConstructorInfo -> + System.Reflection.ConstructorInfo + val convConstructorSpec : + cenv:cenv -> + emEnv:emEnv -> + mspec:IL.ILMethodSpec -> System.Reflection.ConstructorInfo + val emitLabelMark : + emEnv:emEnv -> + ilG:System.Reflection.Emit.ILGenerator -> label:IL.ILCodeLabel -> unit + val emitInstrCompare : + emEnv:emEnv -> + ilG:System.Reflection.Emit.ILGenerator -> + comp:IL.ILComparisonInstr -> targ:IL.ILCodeLabel -> unit + val emitInstrVolatile : + ilG:System.Reflection.Emit.ILGenerator -> _arg1:IL.ILVolatility -> unit + val emitInstrAlign : + ilG:System.Reflection.Emit.ILGenerator -> _arg1:IL.ILAlignment -> unit + val emitInstrTail : + ilG:System.Reflection.Emit.ILGenerator -> + tail:IL.ILTailcall -> emitTheCall:(unit -> unit) -> unit + val emitInstrNewobj : + cenv:cenv -> + emEnv:emEnv -> + ilG:System.Reflection.Emit.ILGenerator -> + mspec:IL.ILMethodSpec -> varargs:'a option -> unit + val emitSilverlightCheck : ilG:System.Reflection.Emit.ILGenerator -> unit + val emitInstrCall : + cenv:cenv -> + emEnv:emEnv -> + ilG:System.Reflection.Emit.ILGenerator -> + opCall:System.Reflection.Emit.OpCode -> + tail:IL.ILTailcall -> + mspec:IL.ILMethodSpec -> varargs:IL.ILTypes option -> unit + val getGenericMethodDefinition : + q:Quotations.Expr -> ty:System.Type -> System.Reflection.MethodInfo + val getArrayMethInfo : + n:int -> ty:System.Type -> System.Reflection.MethodInfo + val setArrayMethInfo : + n:int -> ty:System.Type -> System.Reflection.MethodInfo + val emitInstr : + cenv:cenv -> + modB:System.Reflection.Emit.ModuleBuilder -> + emEnv:emEnv -> + ilG:System.Reflection.Emit.ILGenerator -> instr:IL.ILInstr -> unit + val emitCode : + cenv:cenv -> + modB:System.Reflection.Emit.ModuleBuilder -> + emEnv:emEnv -> + ilG:System.Reflection.Emit.ILGenerator -> code:IL.ILCode -> unit + val emitLocal : + cenv:cenv -> + emEnv:emEnv -> + ilG:System.Reflection.Emit.ILGenerator -> + local:IL.ILLocal -> System.Reflection.Emit.LocalBuilder + val emitILMethodBody : + cenv:cenv -> + modB:System.Reflection.Emit.ModuleBuilder -> + emEnv:emEnv -> + ilG:System.Reflection.Emit.ILGenerator -> + ilmbody:IL.ILMethodBody -> unit + val emitMethodBody : + cenv:cenv -> + modB:System.Reflection.Emit.ModuleBuilder -> + emEnv:emEnv -> + ilG:(unit -> #System.Reflection.Emit.ILGenerator) -> + _name:'b -> mbody:IL.ILLazyMethodBody -> unit + val convCustomAttr : + cenv:cenv -> + emEnv:emEnv -> + cattr:IL.ILAttribute -> System.Reflection.ConstructorInfo * byte [] + val emitCustomAttr : + cenv:cenv -> + emEnv:emEnv -> + add:(System.Reflection.ConstructorInfo * byte [] -> 'a) -> + cattr:IL.ILAttribute -> 'a + val emitCustomAttrs : + cenv:cenv -> + emEnv:emEnv -> + add:(System.Reflection.ConstructorInfo * byte [] -> unit) -> + cattrs:IL.ILAttributes -> unit + val buildGenParamsPass1 : + _emEnv:'a -> + defineGenericParameters:(string [] -> 'b) -> + gps:IL.ILGenericParameterDefs -> unit + val buildGenParamsPass1b : + cenv:cenv -> + emEnv:emEnv -> + genArgs:System.Type array -> gps:IL.ILGenericParameterDefs -> unit + val emitParameter : + cenv:cenv -> + emEnv:emEnv -> + defineParameter:(int * System.Reflection.ParameterAttributes * string -> + System.Reflection.Emit.ParameterBuilder) -> + i:int -> param:IL.ILParameter -> unit + val definePInvokeMethod : System.Reflection.MethodInfo + val enablePInvoke : bool + val buildMethodPass2 : + cenv:cenv -> + tref:IL.ILTypeRef -> + typB:System.Reflection.Emit.TypeBuilder -> + emEnv:emEnv -> mdef:IL.ILMethodDef -> emEnv + val buildMethodPass3 : + cenv:cenv -> + tref:IL.ILTypeRef -> + modB:System.Reflection.Emit.ModuleBuilder -> + typB:System.Reflection.Emit.TypeBuilder -> + emEnv:emEnv -> mdef:IL.ILMethodDef -> unit + val buildFieldPass2 : + cenv:cenv -> + tref:IL.ILTypeRef -> + typB:System.Reflection.Emit.TypeBuilder -> + emEnv:emEnv -> fdef:IL.ILFieldDef -> emEnv + val buildFieldPass3 : + cenv:cenv -> + tref:IL.ILTypeRef -> + _typB:System.Reflection.Emit.TypeBuilder -> + emEnv:emEnv -> fdef:IL.ILFieldDef -> unit + val buildPropertyPass2 : + cenv:cenv -> + tref:IL.ILTypeRef -> + typB:System.Reflection.Emit.TypeBuilder -> + emEnv:emEnv -> prop:IL.ILPropertyDef -> emEnv + val buildPropertyPass3 : + cenv:cenv -> + tref:IL.ILTypeRef -> + _typB:System.Reflection.Emit.TypeBuilder -> + emEnv:emEnv -> prop:IL.ILPropertyDef -> unit + val buildEventPass3 : + cenv:cenv -> + typB:System.Reflection.Emit.TypeBuilder -> + emEnv:emEnv -> eventDef:IL.ILEventDef -> unit + val buildMethodImplsPass3 : + cenv:cenv -> + _tref:'a -> + typB:System.Reflection.Emit.TypeBuilder -> + emEnv:emEnv -> mimpl:IL.ILMethodImplDef -> emEnv + val typeAttributesOfTypeDefKind : + x:IL.ILTypeDefKind -> System.Reflection.TypeAttributes + val typeAttributesOfTypeAccess : + x:IL.ILTypeDefAccess -> System.Reflection.TypeAttributes + val typeAttributesOfTypeEncoding : + x:IL.ILDefaultPInvokeEncoding -> System.Reflection.TypeAttributes + val typeAttributesOfTypeLayout : + cenv:cenv -> + emEnv:emEnv -> + x:IL.ILTypeDefLayout -> + (System.Reflection.ConstructorInfo * byte []) option + val buildTypeDefPass1 : + cenv:cenv -> + emEnv:emEnv -> + modB:System.Reflection.Emit.ModuleBuilder -> + rootTypeBuilder:(string * System.Reflection.TypeAttributes -> + System.Reflection.Emit.TypeBuilder) -> + nesting:IL.ILTypeDef list -> tdef:IL.ILTypeDef -> emEnv + val buildTypeTypeDef : + cenv:cenv -> + emEnv:emEnv -> + modB:System.Reflection.Emit.ModuleBuilder -> + typB:System.Reflection.Emit.TypeBuilder -> + nesting:IL.ILTypeDef list -> tdef:IL.ILTypeDef -> emEnv + val buildTypeDefPass1b : + cenv:cenv -> + nesting:IL.ILTypeDef list -> emEnv:emEnv -> tdef:IL.ILTypeDef -> unit + val buildTypeDefPass2 : + cenv:cenv -> + nesting:IL.ILTypeDef list -> emEnv:emEnv -> tdef:IL.ILTypeDef -> emEnv + val buildTypeDefPass3 : + cenv:cenv -> + nesting:IL.ILTypeDef list -> + modB:System.Reflection.Emit.ModuleBuilder -> + emEnv:emEnv -> tdef:IL.ILTypeDef -> emEnv + val getEnclosingTypeRefs : tref:IL.ILTypeRef -> IL.ILTypeRef list + [] + type CollectTypes = + | ValueTypesOnly + | All + val getTypeRefsInType : + allTypes:CollectTypes -> + ty:IL.ILType -> acc:IL.ILTypeRef list -> IL.ILTypeRef list + val verbose2 : bool + val createTypeRef : + visited:System.Collections.Generic.Dictionary * + created:System.Collections.Generic.Dictionary -> + emEnv:emEnv -> tref:IL.ILTypeRef -> unit + val buildTypeDefPass4 : + visited:System.Collections.Generic.Dictionary * + created:System.Collections.Generic.Dictionary -> + nesting:IL.ILTypeDef list -> emEnv:emEnv -> tdef:IL.ILTypeDef -> unit + val buildModuleTypePass1 : + cenv:cenv -> + modB:System.Reflection.Emit.ModuleBuilder -> + emEnv:emEnv -> tdef:IL.ILTypeDef -> emEnv + val buildModuleTypePass1b : + cenv:cenv -> emEnv:emEnv -> tdef:IL.ILTypeDef -> unit + val buildModuleTypePass2 : + cenv:cenv -> emEnv:emEnv -> tdef:IL.ILTypeDef -> emEnv + val buildModuleTypePass3 : + cenv:cenv -> + modB:System.Reflection.Emit.ModuleBuilder -> + emEnv:emEnv -> tdef:IL.ILTypeDef -> emEnv + val buildModuleTypePass4 : + System.Collections.Generic.Dictionary * + System.Collections.Generic.Dictionary -> + emEnv:emEnv -> tdef:IL.ILTypeDef -> unit + val buildModuleFragment : + cenv:cenv -> + emEnv:emEnv -> + asmB:System.Reflection.Emit.AssemblyBuilder -> + modB:System.Reflection.Emit.ModuleBuilder -> + m:IL.ILModuleDef -> emEnv + val defineDynamicAssemblyAndLog : + asmName:System.Reflection.AssemblyName * + flags:System.Reflection.Emit.AssemblyBuilderAccess * asmDir:string -> + System.Reflection.Emit.AssemblyBuilder + val mkDynamicAssemblyAndModule : + assemblyName:string * optimize:bool * debugInfo:'a * collectible:bool -> + System.Reflection.Emit.AssemblyBuilder * + System.Reflection.Emit.ModuleBuilder + val emitModuleFragment : + ilg:IL.ILGlobals * emEnv:emEnv * + asmB:System.Reflection.Emit.AssemblyBuilder * + modB:System.Reflection.Emit.ModuleBuilder * modul:IL.ILModuleDef * + debugInfo:bool * + resolveAssemblyRef:(IL.ILAssemblyRef -> + Choice option) * + tryFindSysILTypeRef:(string -> IL.ILTypeRef option) -> + emEnv * (unit -> exn option) list + val LookupTypeRef : + cenv:cenv -> emEnv:emEnv -> tref:IL.ILTypeRef -> System.Type + val LookupType : cenv:cenv -> emEnv:emEnv -> ty:IL.ILType -> System.Type + val LookupFieldRef : + emEnv:emEnv -> fref:IL.ILFieldRef -> System.Reflection.FieldInfo option + val LookupMethodRef : + emEnv:emEnv -> mref:IL.ILMethodRef -> System.Reflection.MethodInfo option + end + +namespace FSharp.Compiler + module ReferenceResolver = begin + exception internal ResolutionFailure + [] + type ResolutionEnvironment = + | EditingOrCompilation of isEditing: bool + | CompilationAndEvaluation + type ResolvedFile = + { itemSpec: string + prepareToolTip: string * string -> string + baggage: string } + with + override ToString : unit -> string + end + [] + type Resolver = + interface + abstract member HighestInstalledNetFrameworkVersion : unit -> string + abstract member + Resolve : resolutionEnvironment:ResolutionEnvironment * + references:(string * string) [] * + targetFrameworkVersion:string * + targetFrameworkDirectories:string list * + targetProcessorArchitecture:string * fsharpCoreDir:string * + explicitIncludeDirs:string list * implicitIncludeDir:string * + logMessage:(string -> unit) * + logDiagnostic:(bool -> string -> string -> unit) -> + ResolvedFile [] + abstract member DotNetFrameworkReferenceAssembliesRootDirectory : string + end + end + +namespace FSharp.Compiler + module internal SimulatedMSBuildReferenceResolver = begin + [] + val private Net45 : string = "v4.5" + [] + val private Net451 : string = "v4.5.1" + [] + val private Net452 : string = "v4.5.2" + [] + val private Net46 : string = "v4.6" + [] + val private Net461 : string = "v4.6.1" + [] + val private Net462 : string = "v4.6.2" + [] + val private Net47 : string = "v4.7" + [] + val private Net471 : string = "v4.7.1" + [] + val private Net472 : string = "v4.7.2" + [] + val private Net48 : string = "v4.8" + val SupportedDesktopFrameworkVersions : string list + val private SimulatedMSBuildResolver : ReferenceResolver.Resolver + val getResolver : unit -> ReferenceResolver.Resolver + end + +namespace Internal.Utilities + module internal FSharpEnvironment = begin + val FSharpBannerVersion : string + val FSharpProductName : string + val versionOf<'t> : string + val FSharpCoreLibRunningVersion : string option + val FSharpBinaryMetadataFormatRevision : string + val isRunningOnCoreClr : bool + module Option = begin + val ofString : s:string -> string option + end + val maxPath : int + val maxDataLength : int + val tryCurrentDomain : unit -> string option + val tryAppConfig : _appConfigKey:string -> 'a option + val BinFolderOfDefaultFSharpCompiler : + probePoint:string option -> string option + val toolingCompatibleTypeProviderProtocolMonikers : unit -> string list + val toolingCompatibleVersions : string [] + val toolPaths : string [] + val toolingCompatiblePaths : unit -> string list + val searchToolPaths : + path:string option -> compilerToolPaths:seq -> seq + val getTypeProviderAssembly : + runTimeAssemblyFileName:string * designTimeAssemblyName:string * + compilerToolPaths:string list * + raiseError:(string option -> exn -> System.Reflection.Assembly option) -> + System.Reflection.Assembly option + val getCompilerToolsDesignTimeAssemblyPaths : + compilerToolPaths:seq -> seq + end + +namespace FSharp.Compiler + module PrettyNaming = begin + [] + val parenGet : string = ".()" + [] + val parenSet : string = ".()<-" + [] + val qmark : string = "?" + [] + val qmarkSet : string = "?<-" + [] + val opNamePrefix : string = "op_" + val private opNameTable : (string * string) [] + val private opCharTranslateTable : (char * string) [] + val private opCharSet : System.Collections.Generic.HashSet + val IsOperatorOrBacktickedName : name:string -> bool + val IsOperatorName : name:string -> bool + val IsMangledOpName : n:string -> bool + val private compileCustomOpName : (string -> string) + val CompileOpName : (string -> string) + val private decompileCustomOpName : (string -> string) + val DecompileOpName : (string -> string) + val DemangleOperatorName : nm:string -> string + val DemangleOperatorNameAsLayout : + nonOpTagged:(string -> #Internal.Utilities.StructuredFormat.TaggedText) -> + nm:string -> Internal.Utilities.StructuredFormat.Layout + val opNameCons : string + val opNameNil : string + val opNameEquals : string + val opNameEqualsNullable : string + val opNameNullableEquals : string + val opNameNullableEqualsNullable : string + val IsIdentifierFirstCharacter : c:char -> bool + val IsIdentifierPartCharacter : c:char -> bool + val IsLongIdentifierPartCharacter : c:char -> bool + val isTildeOnlyString : s:string -> bool + val IsValidPrefixOperatorUse : s:string -> bool + val IsValidPrefixOperatorDefinitionName : s:string -> bool + val IsPrefixOperator : s:string -> bool + val IsPunctuation : s:string -> bool + val IsTernaryOperator : s:string -> bool + val IsInfixOperator : (string -> bool) + val ( |Control|Equality|Relational|Indexer|FixedTypes|Other| ) : + opName:string -> Choice + [] + val private compilerGeneratedMarker : string = "@" + [] + val private compilerGeneratedMarkerChar : char = '@' + val IsCompilerGeneratedName : nm:string -> bool + val CompilerGeneratedName : nm:string -> string + val GetBasicNameOfPossibleCompilerGeneratedName : name:string -> string + val CompilerGeneratedNameSuffix : + basicName:string -> suffix:string -> string + [] + val private mangledGenericTypeNameSym : char = '`' + val TryDemangleGenericNameAndPos : n:string -> int voption + type NameArityPair = | NameArityPair of string * int + val DemangleGenericTypeNameWithPos : pos:int -> mangledName:string -> string + val DecodeGenericTypeNameWithPos : + pos:int -> mangledName:string -> NameArityPair + val DemangleGenericTypeName : mangledName:string -> string + val DecodeGenericTypeName : mangledName:string -> NameArityPair + val private chopStringTo : s:string -> c:char -> string + val TryChopPropertyName : s:string -> string option + val ChopPropertyName : s:string -> string + val SplitNamesForILPath : s:string -> string list + val inline private isNotQuotedQuotation : text:string -> n:int -> bool + val private splitAroundQuotation : + text:string -> separator:char -> string [] + val private splitAroundQuotationWithCount : + text:string -> separator:char -> count:int -> string [] + [] + val FSharpModuleSuffix : string = "Module" + [] + val MangledGlobalName : string = "`global`" + val IllegalCharactersInTypeAndNamespaceNames : char [] + val IsActivePatternName : name:string -> bool + type ActivePatternInfo = + | APInfo of bool * (string * Range.range) list * Range.range + with + member ActiveTags : string list + member ActiveTagsWithRanges : (string * Range.range) list + member IsTotal : bool + member Range : Range.range + end + val ActivePatternInfoOfValName : + nm:string -> m:Range.range -> ActivePatternInfo option + val private mangleStaticStringArg : nm:string * v:string -> string + val private tryDemangleStaticStringArg : + mangledText:string -> (string * string) option + exception InvalidMangledStaticArg of string + val demangleProvidedTypeName : + typeLogicalName:string -> string * (string * string) [] + val mangleProvidedTypeName : + typeLogicalName:string * nonDefaultArgs:(string * string) [] -> string + val computeMangledNameWithoutDefaultArgValues : + nm:string * staticArgs:'a [] * + defaultArgValues:(string * string option) [] -> string + val outArgCompilerGeneratedName : string + val ExtraWitnessMethodName : nm:string -> string + val mkUnionCaseFieldName : (int -> int -> string) + val mkExceptionFieldName : (int -> string) + val FsiDynamicModulePrefix : string + module FSharpLib = begin + val Root : string + val RootPath : string list + val Core : string + val CorePath : string list + end + module CustomOperations = begin + [] + val Into : string = "into" + end + val unassignedTyparName : string + val FSharpOptimizationDataResourceName : string + val FSharpSignatureDataResourceName : string + val FSharpOptimizationDataResourceName2 : string + val FSharpSignatureDataResourceName2 : string + end + +namespace FSharp.Compiler.AbstractIL.Extensions.ILX + module internal IlxSettings = begin + type IlxCallImplementation = | VirtEntriesVirtCode + val mutable ilxCompilingFSharpCoreLib : bool + val mutable ilxFsharpCoreLibAssemRef : IL.ILAssemblyRef option + val ilxFsharpCoreLibScopeRef : unit -> IL.ILScopeRef + val ilxNamespace : unit -> string + end + +namespace FSharp.Compiler.AbstractIL.Extensions.ILX + module internal EraseClosures = begin + val notlazy : v:'a -> System.Lazy<'a> + val stripUpTo : + n:int -> test:('a -> bool) -> dest:('a -> 'b * 'a) -> x:'a -> 'b list * 'a + val destTyLambda : + _arg1:Types.IlxClosureLambdas -> + IL.ILGenericParameterDef * Types.IlxClosureLambdas + val isTyLambda : _arg1:Types.IlxClosureLambdas -> bool + val isTyApp : _arg1:Types.IlxClosureApps -> bool + val stripTyLambdasUpTo : + n:int -> + lambdas:Types.IlxClosureLambdas -> + IL.ILGenericParameterDef list * Types.IlxClosureLambdas + val stripSupportedIndirectCall : + apps:Types.IlxClosureApps -> + IL.ILType list * IL.ILType list * Types.IlxClosureApps + val stripSupportedAbstraction : + lambdas:Types.IlxClosureLambdas -> + IL.ILGenericParameterDef list * IL.ILParameter list * + Types.IlxClosureLambdas + val isSupportedDirectCall : apps:Types.IlxClosureApps -> bool + val mkFuncTypeRef : n:int -> IL.ILTypeRef + type cenv = + { ilg: IL.ILGlobals + tref_Func: IL.ILTypeRef [] + mkILTyFuncTy: IL.ILType + addFieldGeneratedAttrs: IL.ILFieldDef -> IL.ILFieldDef + addFieldNeverAttrs: IL.ILFieldDef -> IL.ILFieldDef + addMethodGeneratedAttrs: IL.ILMethodDef -> IL.ILMethodDef } + with + override ToString : unit -> string + end + val addMethodGeneratedAttrsToTypeDef : + cenv:cenv -> tdef:IL.ILTypeDef -> IL.ILTypeDef + val newIlxPubCloEnv : + IL.ILGlobals * addMethodGeneratedAttrs:(IL.ILMethodDef -> IL.ILMethodDef) * + addFieldGeneratedAttrs:(IL.ILFieldDef -> IL.ILFieldDef) * + addFieldNeverAttrs:(IL.ILFieldDef -> IL.ILFieldDef) -> cenv + val mkILTyFuncTy : cenv -> IL.ILType + val mkILFuncTy : cenv -> IL.ILType -> IL.ILType -> IL.ILType + val mkILCurriedFuncTy : + cenv:cenv -> dtys:IL.ILType list -> rty:IL.ILType -> IL.ILType + val typ_Func : + cenv:cenv -> dtys:IL.ILType list -> rty:IL.ILType -> IL.ILType + val mkTyOfApps : cenv:cenv -> apps:Types.IlxClosureApps -> IL.ILType + val mkTyOfLambdas : cenv -> Types.IlxClosureLambdas -> IL.ILType + val mkMethSpecForMultiApp : + cenv:cenv -> + argtys':IL.ILType list * rty:IL.ILType -> bool * IL.ILMethodSpec + val mkCallBlockForMultiValueApp : + cenv:cenv -> + doTailCall:IL.ILTailcall -> + args':IL.ILType list * rty':IL.ILType -> IL.ILInstr list + val mkMethSpecForClosureCall : + cenv:cenv -> clospec:Types.IlxClosureSpec -> IL.ILMethodSpec + val mkLdFreeVar : + clospec:Types.IlxClosureSpec -> + fv:Types.IlxClosureFreeVar -> IL.ILInstr list + val mkCallFunc : + cenv -> + allocLocal:(IL.ILType -> uint16) -> + numThisGenParams:int -> + IL.ILTailcall -> Types.IlxClosureApps -> IL.ILInstr list + val convReturnInstr : ty:IL.ILType -> instr:IL.ILInstr -> IL.ILInstr list + val convILMethodBody : + thisClo:'a option * boxReturnTy:IL.ILType option -> + il:IL.ILMethodBody -> IL.ILMethodBody + val convMethodBody : + thisClo:'a option -> _arg1:IL.MethodBody -> IL.MethodBody + val convMethodDef : thisClo:'a option -> md:IL.ILMethodDef -> IL.ILMethodDef + val mkILFreeVarForParam : p:IL.ILParameter -> Types.IlxClosureFreeVar + val mkILLocalForFreeVar : p:Types.IlxClosureFreeVar -> IL.ILLocal + val mkILCloFldSpecs : + _cenv:'a -> flds:Types.IlxClosureFreeVar [] -> (string * IL.ILType) list + val mkILCloFldDefs : + cenv:cenv -> flds:Types.IlxClosureFreeVar [] -> IL.ILFieldDef list + val convIlxClosureDef : + cenv -> + encl:string list -> + IL.ILTypeDef -> Types.IlxClosureInfo -> IL.ILTypeDef list + end + +namespace FSharp.Compiler.AbstractIL.Extensions.ILX + module internal EraseUnions = begin + [] + val TagNil : int = 0 + [] + val TagCons : int = 1 + [] + val ALT_NAME_CONS : string = "Cons" + type DiscriminationTechnique = + | TailOrNull + | RuntimeTypes + | SingleCase + | IntegerTag + type UnionReprDecisions<'Union,'Alt,'Type> = + class + new : getAlternatives:('Union -> 'Alt []) * + nullPermitted:('Union -> bool) * isNullary:('Alt -> bool) * + isList:('Union -> bool) * isStruct:('Union -> bool) * + nameOfAlt:('Alt -> string) * makeRootType:('Union -> 'Type) * + makeNestedType:('Union * string -> 'Type) -> + UnionReprDecisions<'Union,'Alt,'Type> + member DiscriminationTechnique : cu:'Union -> DiscriminationTechnique + member Flatten : cu:'Union -> bool + member + MaintainPossiblyUniqueConstantFieldForAlternative : cu:'Union * + alt:'Alt -> bool + member OptimizeAlternativeToRootClass : cu:'Union * alt:'Alt -> bool + member + RepresentAllAlternativesAsConstantFieldsInRootClass : cu:'Union -> + bool + member + RepresentAlternativeAsConstantFieldInTaggedRootClass : cu:'Union * + alt:'Alt -> + bool + member + RepresentAlternativeAsFreshInstancesOfRootClass : cu:'Union * alt:'Alt -> + bool + member RepresentAlternativeAsNull : cu:'Union * alt:'Alt -> bool + member RepresentAlternativeAsStructValue : cu:'Union -> bool + member RepresentOneAlternativeAsNull : cu:'Union -> bool + member + RepresentSingleNonNullaryAlternativeAsInstancesOfRootClassAndAnyOtherAlternativesAsNull : cu:'Union * + alt:'Alt -> + bool + member TypeForAlternative : cuspec:'Union * alt:'Alt -> 'Type + end + val baseTyOfUnionSpec : cuspec:Types.IlxUnionSpec -> IL.ILType + val mkMakerName : cuspec:Types.IlxUnionSpec -> nm:string -> string + val mkCasesTypeRef : cuspec:Types.IlxUnionSpec -> IL.ILTypeRef + val cuspecRepr : + UnionReprDecisions + type NoTypesGeneratedViaThisReprDecider = + | NoTypesGeneratedViaThisReprDecider + val cudefRepr : + UnionReprDecisions<(IL.ILTypeDef * Types.IlxUnionInfo), + Types.IlxUnionAlternative, + NoTypesGeneratedViaThisReprDecider> + val mkTesterName : nm:string -> string + val tagPropertyName : string + val mkUnionCaseFieldId : fdef:Types.IlxUnionField -> string * IL.ILType + val refToFieldInTy : + ty:IL.ILType -> nm:string * fldTy:IL.ILType -> IL.ILFieldSpec + val formalTypeArgs : baseTy:IL.ILType -> IL.ILType list + val constFieldName : nm:string -> string + val constFormalFieldTy : baseTy:IL.ILType -> IL.ILType + val mkConstFieldSpecFromId : + baseTy:IL.ILType -> string * IL.ILType -> IL.ILFieldSpec + val mkConstFieldSpec : nm:string -> baseTy:IL.ILType -> IL.ILFieldSpec + val tyForAlt : + cuspec:Types.IlxUnionSpec -> alt:Types.IlxUnionAlternative -> IL.ILType + val GetILTypeForAlternative : Types.IlxUnionSpec -> int -> IL.ILType + val mkTagFieldType : ilg:IL.ILGlobals -> _cuspec:'a -> IL.ILType + val mkTagFieldFormalType : ilg:IL.ILGlobals -> _cuspec:'a -> IL.ILType + val mkTagFieldId : ilg:IL.ILGlobals -> cuspec:'a -> string * IL.ILType + val mkTailOrNullId : baseTy:IL.ILType -> string * IL.ILType + val altOfUnionSpec : + cuspec:Types.IlxUnionSpec -> cidx:int -> Types.IlxUnionAlternative + val doesRuntimeTypeDiscriminateUseHelper : + avoidHelpers:bool -> + cuspec:Types.IlxUnionSpec -> alt:Types.IlxUnionAlternative -> bool + val mkRuntimeTypeDiscriminate : + ilg:IL.ILGlobals -> + avoidHelpers:bool -> + cuspec:Types.IlxUnionSpec -> + alt:Types.IlxUnionAlternative -> + altName:string -> altTy:IL.ILType -> IL.ILInstr list + val mkRuntimeTypeDiscriminateThen : + ilg:IL.ILGlobals -> + avoidHelpers:bool -> + cuspec:Types.IlxUnionSpec -> + alt:Types.IlxUnionAlternative -> + altName:string -> + altTy:IL.ILType -> after:IL.ILInstr -> IL.ILInstr list + val mkGetTagFromField : + ilg:IL.ILGlobals -> cuspec:'a -> baseTy:IL.ILType -> IL.ILInstr list + val adjustFieldName : + hasHelpers:Types.IlxUnionHasHelpers -> nm:string -> string + val mkLdData : bool * Types.IlxUnionSpec * int * int -> IL.ILInstr list + val mkLdDataAddr : bool * Types.IlxUnionSpec * int * int -> IL.ILInstr list + val mkGetTailOrNull : + avoidHelpers:bool -> cuspec:Types.IlxUnionSpec -> IL.ILInstr list + val mkGetTagFromHelpers : + ilg:IL.ILGlobals -> cuspec:Types.IlxUnionSpec -> IL.ILInstr + val mkGetTag : + ilg:IL.ILGlobals -> cuspec:Types.IlxUnionSpec -> IL.ILInstr list + val mkCeqThen : after:IL.ILInstr -> IL.ILInstr list + val mkTagDiscriminate : + ilg:IL.ILGlobals -> + cuspec:Types.IlxUnionSpec -> _baseTy:'a -> cidx:int32 -> IL.ILInstr list + val mkTagDiscriminateThen : + ilg:IL.ILGlobals -> + cuspec:Types.IlxUnionSpec -> + cidx:int32 -> after:IL.ILInstr -> IL.ILInstr list + val extraTysAndInstrsForStructCtor : + ilg:IL.ILGlobals -> cidx:int -> IL.ILType list * IL.ILInstr list + val takesExtraParams : alts:Types.IlxUnionAlternative [] -> bool + val convNewDataInstrInternal : + ilg:IL.ILGlobals -> + cuspec:Types.IlxUnionSpec -> cidx:int -> IL.ILInstr list + val mkStData : Types.IlxUnionSpec * int * int -> IL.ILInstr list + val mkNewData : IL.ILGlobals -> Types.IlxUnionSpec * int -> IL.ILInstr list + val mkIsData : + IL.ILGlobals -> bool * Types.IlxUnionSpec * int -> IL.ILInstr list + type ICodeGen<'Mark> = + interface + abstract member CodeLabel : 'Mark -> IL.ILCodeLabel + abstract member EmitInstr : IL.ILInstr -> unit + abstract member EmitInstrs : IL.ILInstr list -> unit + abstract member GenLocal : IL.ILType -> uint16 + abstract member GenerateDelayMark : unit -> 'Mark + abstract member MkInvalidCastExnNewobj : unit -> IL.ILInstr + abstract member SetMarkToHere : 'Mark -> unit + end + val genWith : g:(ICodeGen -> unit) -> IL.ILCode + val mkBrIsData : + IL.ILGlobals -> + sense:bool -> + avoidHelpers:bool * Types.IlxUnionSpec * int * IL.ILCodeLabel -> + IL.ILInstr list + val emitLdDataTagPrim : + ilg:IL.ILGlobals -> + ldOpt:IL.ILInstr option -> + cg:ICodeGen<'Mark> -> + avoidHelpers:bool * cuspec:Types.IlxUnionSpec -> unit + val emitLdDataTag : + IL.ILGlobals -> + ICodeGen<'Mark> -> avoidHelpers:bool * Types.IlxUnionSpec -> unit + val emitCastData : + IL.ILGlobals -> + ICodeGen<'Mark> -> + canfail:bool * avoidHelpers:bool * Types.IlxUnionSpec * int -> unit + val emitDataSwitch : + IL.ILGlobals -> + ICodeGen<'Mark> -> + avoidHelpers:bool * Types.IlxUnionSpec * (int * IL.ILCodeLabel) list -> + unit + val mkMethodsAndPropertiesForFields : + addMethodGeneratedAttrs:(IL.ILMethodDef -> 'a) * + addPropertyGeneratedAttrs:(IL.ILPropertyDef -> 'b) -> + access:IL.ILMemberAccess -> + attr:IL.ILSourceMarker option -> + hasHelpers:Types.IlxUnionHasHelpers -> + ilTy:IL.ILType -> + fields:Types.IlxUnionField [] -> 'b list * 'a list + val convAlternativeDef : + addMethodGeneratedAttrs:(IL.ILMethodDef -> IL.ILMethodDef) * + addPropertyGeneratedAttrs:(IL.ILPropertyDef -> IL.ILPropertyDef) * + addPropertyNeverAttrs:(IL.ILPropertyDef -> 'a) * + addFieldGeneratedAttrs:('b -> IL.ILFieldDef) * + addFieldNeverAttrs:(IL.ILFieldDef -> 'b) * + mkDebuggerTypeProxyAttribute:(IL.ILType -> IL.ILAttribute) -> + ilg:IL.ILGlobals -> + num:int -> + td:IL.ILTypeDef -> + cud:Types.IlxUnionInfo -> + IL.ILTypeDef * Types.IlxUnionInfo -> + cuspec:Types.IlxUnionSpec -> + baseTy:IL.ILType -> + alt:Types.IlxUnionAlternative -> + IL.ILMethodDef list * 'a list * IL.ILMethodDef list * + IL.ILTypeDef list * IL.ILTypeDef list * + ((IL.ILTypeDef * Types.IlxUnionInfo) * + Types.IlxUnionAlternative * IL.ILType * int * + IL.ILFieldDef * bool) list + val mkClassUnionDef : + addMethodGeneratedAttrs:(IL.ILMethodDef -> IL.ILMethodDef) * + addPropertyGeneratedAttrs:(IL.ILPropertyDef -> IL.ILPropertyDef) * + addPropertyNeverAttrs:(IL.ILPropertyDef -> IL.ILPropertyDef) * + addFieldGeneratedAttrs:(IL.ILFieldDef -> IL.ILFieldDef) * + addFieldNeverAttrs:(IL.ILFieldDef -> IL.ILFieldDef) * + mkDebuggerTypeProxyAttribute:(IL.ILType -> IL.ILAttribute) -> + ilg:IL.ILGlobals -> + tref:IL.ILTypeRef -> + td:IL.ILTypeDef -> cud:Types.IlxUnionInfo -> IL.ILTypeDef + end + +namespace FSharp.Compiler + module internal UnicodeLexing = begin + type Lexbuf = Internal.Utilities.Text.Lexing.LexBuffer + val StringAsLexbuf : + (Features.LanguageFeature -> bool) * string -> + Internal.Utilities.Text.Lexing.LexBuffer + val FunctionAsLexbuf : + (Features.LanguageFeature -> bool) * (char [] * int * int -> int) -> + Internal.Utilities.Text.Lexing.LexBuffer + val SourceTextAsLexbuf : + (Features.LanguageFeature -> bool) * Text.ISourceText -> + Internal.Utilities.Text.Lexing.LexBuffer + val StreamReaderAsLexbuf : + (Features.LanguageFeature -> bool) * System.IO.StreamReader -> + Internal.Utilities.Text.Lexing.LexBuffer + end + +namespace FSharp.Compiler + module Layout = begin + type layout = Internal.Utilities.StructuredFormat.Layout + type LayoutTag = Internal.Utilities.StructuredFormat.LayoutTag + type TaggedText = Internal.Utilities.StructuredFormat.TaggedText + type NavigableTaggedText = + class + interface TaggedText + new : TaggedText * Range.range -> NavigableTaggedText + member Range : Range.range + end + val mkNav : Range.range -> TaggedText -> TaggedText + val spaces : n:int -> System.String + val emptyL : Internal.Utilities.StructuredFormat.Layout + val isEmptyL : Internal.Utilities.StructuredFormat.Layout -> bool + val mkNode : + l:Internal.Utilities.StructuredFormat.Layout -> + r:Internal.Utilities.StructuredFormat.Layout -> + joint:Internal.Utilities.StructuredFormat.Joint -> + Internal.Utilities.StructuredFormat.Layout + val wordL : TaggedText -> Internal.Utilities.StructuredFormat.Layout + val sepL : TaggedText -> Internal.Utilities.StructuredFormat.Layout + val rightL : TaggedText -> Internal.Utilities.StructuredFormat.Layout + val leftL : TaggedText -> Internal.Utilities.StructuredFormat.Layout + module TaggedTextOps = begin + val tagActivePatternCase : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagActivePatternResult : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagAlias : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagClass : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagUnion : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagUnionCase : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagDelegate : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagEnum : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagEvent : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagField : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagInterface : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagKeyword : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagLineBreak : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagLocal : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagRecord : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagRecordField : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagMethod : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagMember : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagModule : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagModuleBinding : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagFunction : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagNamespace : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagNumericLiteral : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagOperator : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagParameter : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagProperty : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagSpace : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagStringLiteral : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagStruct : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagTypeParameter : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagText : (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagPunctuation : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagUnknownEntity : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + val tagUnknownType : + (string -> Internal.Utilities.StructuredFormat.TaggedText) + module Literals = begin + val lineBreak : Internal.Utilities.StructuredFormat.TaggedText + val space : Internal.Utilities.StructuredFormat.TaggedText + val comma : Internal.Utilities.StructuredFormat.TaggedText + val semicolon : Internal.Utilities.StructuredFormat.TaggedText + val leftParen : Internal.Utilities.StructuredFormat.TaggedText + val rightParen : Internal.Utilities.StructuredFormat.TaggedText + val leftBracket : Internal.Utilities.StructuredFormat.TaggedText + val rightBracket : Internal.Utilities.StructuredFormat.TaggedText + val leftBrace : Internal.Utilities.StructuredFormat.TaggedText + val rightBrace : Internal.Utilities.StructuredFormat.TaggedText + val leftBraceBar : Internal.Utilities.StructuredFormat.TaggedText + val rightBraceBar : Internal.Utilities.StructuredFormat.TaggedText + val equals : Internal.Utilities.StructuredFormat.TaggedText + val arrow : Internal.Utilities.StructuredFormat.TaggedText + val questionMark : Internal.Utilities.StructuredFormat.TaggedText + val dot : Internal.Utilities.StructuredFormat.TaggedText + val leftAngle : Internal.Utilities.StructuredFormat.TaggedText + val rightAngle : Internal.Utilities.StructuredFormat.TaggedText + val star : Internal.Utilities.StructuredFormat.TaggedText + val colon : Internal.Utilities.StructuredFormat.TaggedText + val minus : Internal.Utilities.StructuredFormat.TaggedText + val keywordNew : Internal.Utilities.StructuredFormat.TaggedText + val leftBracketAngle : Internal.Utilities.StructuredFormat.TaggedText + val rightBracketAngle : Internal.Utilities.StructuredFormat.TaggedText + val structUnit : Internal.Utilities.StructuredFormat.TaggedText + val keywordStatic : Internal.Utilities.StructuredFormat.TaggedText + val keywordMember : Internal.Utilities.StructuredFormat.TaggedText + val keywordVal : Internal.Utilities.StructuredFormat.TaggedText + val keywordEvent : Internal.Utilities.StructuredFormat.TaggedText + val keywordWith : Internal.Utilities.StructuredFormat.TaggedText + val keywordSet : Internal.Utilities.StructuredFormat.TaggedText + val keywordGet : Internal.Utilities.StructuredFormat.TaggedText + val keywordTrue : Internal.Utilities.StructuredFormat.TaggedText + val keywordFalse : Internal.Utilities.StructuredFormat.TaggedText + val bar : Internal.Utilities.StructuredFormat.TaggedText + val keywordStruct : Internal.Utilities.StructuredFormat.TaggedText + val keywordInherit : Internal.Utilities.StructuredFormat.TaggedText + val keywordEnd : Internal.Utilities.StructuredFormat.TaggedText + val keywordNested : Internal.Utilities.StructuredFormat.TaggedText + val keywordType : Internal.Utilities.StructuredFormat.TaggedText + val keywordDelegate : Internal.Utilities.StructuredFormat.TaggedText + val keywordOf : Internal.Utilities.StructuredFormat.TaggedText + val keywordInternal : Internal.Utilities.StructuredFormat.TaggedText + val keywordPrivate : Internal.Utilities.StructuredFormat.TaggedText + val keywordAbstract : Internal.Utilities.StructuredFormat.TaggedText + val keywordOverride : Internal.Utilities.StructuredFormat.TaggedText + val keywordEnum : Internal.Utilities.StructuredFormat.TaggedText + val leftBracketBar : Internal.Utilities.StructuredFormat.TaggedText + val rightBracketBar : Internal.Utilities.StructuredFormat.TaggedText + val keywordTypeof : Internal.Utilities.StructuredFormat.TaggedText + val keywordTypedefof : Internal.Utilities.StructuredFormat.TaggedText + end + end + module SepL = begin + val dot : Internal.Utilities.StructuredFormat.Layout + val star : Internal.Utilities.StructuredFormat.Layout + val colon : Internal.Utilities.StructuredFormat.Layout + val questionMark : Internal.Utilities.StructuredFormat.Layout + val leftParen : Internal.Utilities.StructuredFormat.Layout + val comma : Internal.Utilities.StructuredFormat.Layout + val space : Internal.Utilities.StructuredFormat.Layout + val leftBracket : Internal.Utilities.StructuredFormat.Layout + val leftAngle : Internal.Utilities.StructuredFormat.Layout + val lineBreak : Internal.Utilities.StructuredFormat.Layout + val rightParen : Internal.Utilities.StructuredFormat.Layout + end + module WordL = begin + val arrow : Internal.Utilities.StructuredFormat.Layout + val star : Internal.Utilities.StructuredFormat.Layout + val colon : Internal.Utilities.StructuredFormat.Layout + val equals : Internal.Utilities.StructuredFormat.Layout + val keywordNew : Internal.Utilities.StructuredFormat.Layout + val structUnit : Internal.Utilities.StructuredFormat.Layout + val keywordStatic : Internal.Utilities.StructuredFormat.Layout + val keywordMember : Internal.Utilities.StructuredFormat.Layout + val keywordVal : Internal.Utilities.StructuredFormat.Layout + val keywordEvent : Internal.Utilities.StructuredFormat.Layout + val keywordWith : Internal.Utilities.StructuredFormat.Layout + val keywordSet : Internal.Utilities.StructuredFormat.Layout + val keywordGet : Internal.Utilities.StructuredFormat.Layout + val keywordTrue : Internal.Utilities.StructuredFormat.Layout + val keywordFalse : Internal.Utilities.StructuredFormat.Layout + val bar : Internal.Utilities.StructuredFormat.Layout + val keywordStruct : Internal.Utilities.StructuredFormat.Layout + val keywordInherit : Internal.Utilities.StructuredFormat.Layout + val keywordEnd : Internal.Utilities.StructuredFormat.Layout + val keywordNested : Internal.Utilities.StructuredFormat.Layout + val keywordType : Internal.Utilities.StructuredFormat.Layout + val keywordDelegate : Internal.Utilities.StructuredFormat.Layout + val keywordOf : Internal.Utilities.StructuredFormat.Layout + val keywordInternal : Internal.Utilities.StructuredFormat.Layout + val keywordPrivate : Internal.Utilities.StructuredFormat.Layout + val keywordAbstract : Internal.Utilities.StructuredFormat.Layout + val keywordOverride : Internal.Utilities.StructuredFormat.Layout + val keywordEnum : Internal.Utilities.StructuredFormat.Layout + end + module LeftL = begin + val leftParen : Internal.Utilities.StructuredFormat.Layout + val questionMark : Internal.Utilities.StructuredFormat.Layout + val colon : Internal.Utilities.StructuredFormat.Layout + val leftBracketAngle : Internal.Utilities.StructuredFormat.Layout + val leftBracketBar : Internal.Utilities.StructuredFormat.Layout + val keywordTypeof : Internal.Utilities.StructuredFormat.Layout + val keywordTypedefof : Internal.Utilities.StructuredFormat.Layout + end + module RightL = begin + val comma : Internal.Utilities.StructuredFormat.Layout + val rightParen : Internal.Utilities.StructuredFormat.Layout + val colon : Internal.Utilities.StructuredFormat.Layout + val rightBracket : Internal.Utilities.StructuredFormat.Layout + val rightAngle : Internal.Utilities.StructuredFormat.Layout + val rightBracketAngle : Internal.Utilities.StructuredFormat.Layout + val rightBracketBar : Internal.Utilities.StructuredFormat.Layout + end + val aboveL : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val tagAttrL : + str:string -> + attrs:(string * string) list -> + ly:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val apply2 : + f:(Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout) -> + l:Internal.Utilities.StructuredFormat.Layout -> + r:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val ( ^^ ) : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val ( ++ ) : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val ( -- ) : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val ( --- ) : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val ( ---- ) : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val ( ----- ) : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val ( @@ ) : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val ( @@- ) : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val ( @@-- ) : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val tagListL : + tagger:(Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout) -> + _arg1:Internal.Utilities.StructuredFormat.Layout list -> + Internal.Utilities.StructuredFormat.Layout + val commaListL : + Internal.Utilities.StructuredFormat.Layout list -> + Internal.Utilities.StructuredFormat.Layout + val semiListL : + Internal.Utilities.StructuredFormat.Layout list -> + Internal.Utilities.StructuredFormat.Layout + val spaceListL : + Internal.Utilities.StructuredFormat.Layout list -> + Internal.Utilities.StructuredFormat.Layout + val sepListL : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout list -> + Internal.Utilities.StructuredFormat.Layout + val bracketL : + Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val tupleL : + Internal.Utilities.StructuredFormat.Layout list -> + Internal.Utilities.StructuredFormat.Layout + val aboveListL : + Internal.Utilities.StructuredFormat.Layout list -> + Internal.Utilities.StructuredFormat.Layout + val optionL : + ('a -> Internal.Utilities.StructuredFormat.Layout) -> + 'a option -> Internal.Utilities.StructuredFormat.Layout + val listL : + ('a -> Internal.Utilities.StructuredFormat.Layout) -> + 'a list -> Internal.Utilities.StructuredFormat.Layout + type LayoutRenderer<'a,'b> = + interface + abstract member AddBreak : 'b -> int -> 'b + abstract member + AddTag : 'b -> string * (string * string) list * bool -> 'b + abstract member AddText : 'b -> TaggedText -> 'b + abstract member Finish : 'b -> 'a + abstract member Start : unit -> 'b + end + val renderL : + LayoutRenderer<'b,'a> -> Internal.Utilities.StructuredFormat.Layout -> 'b + val stringR : LayoutRenderer + type NoState = | NoState + type NoResult = | NoResult + val taggedTextListR : + collector:(TaggedText -> unit) -> LayoutRenderer + val channelR : System.IO.TextWriter -> LayoutRenderer + val bufferR : System.Text.StringBuilder -> LayoutRenderer + val showL : Internal.Utilities.StructuredFormat.Layout -> string + val outL : + System.IO.TextWriter -> Internal.Utilities.StructuredFormat.Layout -> unit + val bufferL : + System.Text.StringBuilder -> + Internal.Utilities.StructuredFormat.Layout -> unit + end + +namespace FSharp.Compiler + module XmlDoc = begin + [] + type XmlDoc = + class + new : unprocessedLines:string [] * range:Range.range -> XmlDoc + static member Merge : doc1:XmlDoc -> doc2:XmlDoc -> XmlDoc + member Check : paramNamesOpt:string list option -> unit + member GetElaboratedXmlLines : unit -> string [] + member GetXmlText : unit -> string + member IsEmpty : bool + member NonEmpty : bool + member Range : Range.range + member UnprocessedLines : string [] + static member Empty : XmlDoc + end + and XmlDocStatics = + class + new : unit -> XmlDocStatics + static member Empty : XmlDoc + end + type XmlDocCollector = + class + new : unit -> XmlDocCollector + member AddGrabPoint : pos:Range.pos -> unit + member AddXmlDocLine : line:string * range:Range.range -> unit + member LinesBefore : grabPointPos:Range.pos -> (string * Range.range) [] + end + type PreXmlDoc = + | PreXmlMerge of PreXmlDoc * PreXmlDoc + | PreXmlDoc of Range.pos * XmlDocCollector + | PreXmlDocEmpty + with + static member + CreateFromGrabPoint : collector:XmlDocCollector * + grabPointPos:Range.pos -> PreXmlDoc + static member Merge : a:PreXmlDoc -> b:PreXmlDoc -> PreXmlDoc + member + ToXmlDoc : check:bool * paramNamesOpt:string list option -> XmlDoc + static member Empty : PreXmlDoc + end + end + +namespace FSharp.Compiler + module SyntaxTree = begin + [] + type Ident = + struct + new : text:string * range:Range.range -> Ident + override ToString : unit -> string + member idRange : Range.range + member idText : string + end + and LongIdent = Ident list + and LongIdentWithDots = + | LongIdentWithDots of id: LongIdent * dotms: Range.range list + with + member Lid : LongIdent + member Range : Range.range + member RangeSansAnyExtraDot : Range.range + member ThereIsAnExtraDotAtTheEnd : bool + end + [] + and ParserDetail = + | Ok + | ErrorRecovery + and TyparStaticReq = + | NoStaticReq + | HeadTypeStaticReq + [] + and SynTypar = + | Typar of ident: Ident * staticReq: TyparStaticReq * isCompGen: bool + with + member Range : Range.range + end + [] + and SynConst = + | Unit + | Bool of bool + | SByte of sbyte + | Byte of byte + | Int16 of int16 + | UInt16 of uint16 + | Int32 of int32 + | UInt32 of uint32 + | Int64 of int64 + | UInt64 of uint64 + | IntPtr of int64 + | UIntPtr of uint64 + | Single of single + | Double of double + | Char of char + | Decimal of System.Decimal + | UserNum of value: string * suffix: string + | String of text: string * range: Range.range + | Bytes of bytes: byte [] * range: Range.range + | UInt16s of uint16 [] + | Measure of constant: SynConst * SynMeasure + with + member Range : dflt:Range.range -> Range.range + end + [] + and SynMeasure = + | Named of longId: LongIdent * range: Range.range + | Product of SynMeasure * SynMeasure * range: Range.range + | Seq of SynMeasure list * range: Range.range + | Divide of SynMeasure * SynMeasure * range: Range.range + | Power of SynMeasure * SynRationalConst * range: Range.range + | One + | Anon of range: Range.range + | Var of SynTypar * range: Range.range + [] + and SynRationalConst = + | Integer of int32 + | Rational of int32 * int32 * range: Range.range + | Negate of SynRationalConst + [] + and SynAccess = + | Public + | Internal + | Private + with + override ToString : unit -> string + end + [] + and DebugPointForTarget = + | Yes + | No + [] + and DebugPointAtSequential = + | Both + | StmtOnly + | ExprOnly + [] + and DebugPointAtTry = + | Yes of range: Range.range + | Body + | No + [] + and DebugPointAtWith = + | Yes of range: Range.range + | No + [] + and DebugPointAtFinally = + | Yes of range: Range.range + | No + [] + and DebugPointAtFor = + | Yes of range: Range.range + | No + [] + and DebugPointAtWhile = + | Yes of range: Range.range + | No + and DebugPointForBinding = + | DebugPointAtBinding of range: Range.range + | NoDebugPointAtDoBinding + | NoDebugPointAtLetBinding + | NoDebugPointAtStickyBinding + | NoDebugPointAtInvisibleBinding + with + member Combine : y:DebugPointForBinding -> DebugPointForBinding + end + and SeqExprOnly = | SeqExprOnly of bool + and BlockSeparator = Range.range * Range.pos option + and RecordFieldName = LongIdentWithDots * bool + and ExprAtomicFlag = + | Atomic = 0 + | NonAtomic = 1 + and SynBindingKind = + | StandaloneExpression + | NormalBinding + | DoBinding + [] + and SynTyparDecl = | TyparDecl of attributes: SynAttributes * SynTypar + [] + and SynTypeConstraint = + | WhereTyparIsValueType of typar: SynTypar * range: Range.range + | WhereTyparIsReferenceType of typar: SynTypar * range: Range.range + | WhereTyparIsUnmanaged of typar: SynTypar * range: Range.range + | WhereTyparSupportsNull of typar: SynTypar * range: Range.range + | WhereTyparIsComparable of typar: SynTypar * range: Range.range + | WhereTyparIsEquatable of typar: SynTypar * range: Range.range + | WhereTyparDefaultsToType of + typar: SynTypar * typeName: SynType * range: Range.range + | WhereTyparSubtypeOfType of + typar: SynTypar * typeName: SynType * range: Range.range + | WhereTyparSupportsMember of + typars: SynType list * memberSig: SynMemberSig * range: Range.range + | WhereTyparIsEnum of + typar: SynTypar * typeArgs: SynType list * range: Range.range + | WhereTyparIsDelegate of + typar: SynTypar * typeArgs: SynType list * range: Range.range + [] + and SynType = + | LongIdent of longDotId: LongIdentWithDots + | App of + typeName: SynType * lessRange: Range.range option * + typeArgs: SynType list * commaRanges: Range.range list * + greaterRange: Range.range option * isPostfix: bool * range: Range.range + | LongIdentApp of + typeName: SynType * longDotId: LongIdentWithDots * + lessRange: Range.range option * typeArgs: SynType list * + commaRanges: Range.range list * greaterRange: Range.range option * + range: Range.range + | Tuple of + isStruct: bool * elementTypes: (bool * SynType) list * + range: Range.range + | AnonRecd of + isStruct: bool * fields: (Ident * SynType) list * range: Range.range + | Array of rank: int * elementType: SynType * range: Range.range + | Fun of argType: SynType * returnType: SynType * range: Range.range + | Var of typar: SynTypar * range: Range.range + | Anon of range: Range.range + | WithGlobalConstraints of + typeName: SynType * constraints: SynTypeConstraint list * + range: Range.range + | HashConstraint of innerType: SynType * range: Range.range + | MeasureDivide of + dividend: SynType * divisor: SynType * range: Range.range + | MeasurePower of + baseMeasure: SynType * exponent: SynRationalConst * range: Range.range + | StaticConstant of constant: SynConst * range: Range.range + | StaticConstantExpr of expr: SynExpr * range: Range.range + | StaticConstantNamed of + ident: SynType * value: SynType * range: Range.range + | Paren of innerType: SynType * range: Range.range + with + member Range : Range.range + end + [] + and SynExpr = + | Paren of + expr: SynExpr * leftParenRange: Range.range * + rightParenRange: Range.range option * range: Range.range + | Quote of + operator: SynExpr * isRaw: bool * quotedExpr: SynExpr * + isFromQueryExpression: bool * range: Range.range + | Const of constant: SynConst * range: Range.range + | Typed of expr: SynExpr * targetType: SynType * range: Range.range + | Tuple of + isStruct: bool * exprs: SynExpr list * commaRanges: Range.range list * + range: Range.range + | AnonRecd of + isStruct: bool * copyInfo: (SynExpr * BlockSeparator) option * + recordFields: (Ident * SynExpr) list * range: Range.range + | ArrayOrList of isList: bool * exprs: SynExpr list * range: Range.range + | Record of + baseInfo: + (SynType * SynExpr * Range.range * BlockSeparator option * Range.range) option * + copyInfo: (SynExpr * BlockSeparator) option * + recordFields: + (RecordFieldName * SynExpr option * BlockSeparator option) list * + range: Range.range + | New of + isProtected: bool * targetType: SynType * expr: SynExpr * + range: Range.range + | ObjExpr of + objType: SynType * argOptions: (SynExpr * Ident option) option * + bindings: SynBinding list * extraImpls: SynInterfaceImpl list * + newExprRange: Range.range * range: Range.range + | While of + whileSeqPoint: DebugPointAtWhile * whileExpr: SynExpr * doExpr: SynExpr * + range: Range.range + | For of + forSeqPoint: DebugPointAtFor * ident: Ident * identBody: SynExpr * + direction: bool * toBody: SynExpr * doBody: SynExpr * range: Range.range + | ForEach of + forSeqPoint: DebugPointAtFor * seqExprOnly: SeqExprOnly * + isFromSource: bool * pat: SynPat * enumExpr: SynExpr * bodyExpr: SynExpr * + range: Range.range + | ArrayOrListOfSeqExpr of + isArray: bool * expr: SynExpr * range: Range.range + | CompExpr of + isArrayOrList: bool * isNotNakedRefCell: bool ref * expr: SynExpr * + range: Range.range + | Lambda of + fromMethod: bool * inLambdaSeq: bool * args: SynSimplePats * + body: SynExpr * parsedData: (SynPat list * SynExpr) option * + range: Range.range + | MatchLambda of + isExnMatch: bool * keywordRange: Range.range * + matchClauses: SynMatchClause list * matchSeqPoint: DebugPointForBinding * + range: Range.range + | Match of + matchSeqPoint: DebugPointForBinding * expr: SynExpr * + clauses: SynMatchClause list * range: Range.range + | Do of expr: SynExpr * range: Range.range + | Assert of expr: SynExpr * range: Range.range + | App of + flag: ExprAtomicFlag * isInfix: bool * funcExpr: SynExpr * + argExpr: SynExpr * range: Range.range + | TypeApp of + expr: SynExpr * lessRange: Range.range * typeArgs: SynType list * + commaRanges: Range.range list * greaterRange: Range.range option * + typeArgsRange: Range.range * range: Range.range + | LetOrUse of + isRecursive: bool * isUse: bool * bindings: SynBinding list * + body: SynExpr * range: Range.range + | TryWith of + tryExpr: SynExpr * tryRange: Range.range * + withCases: SynMatchClause list * withRange: Range.range * + range: Range.range * trySeqPoint: DebugPointAtTry * + withSeqPoint: DebugPointAtWith + | TryFinally of + tryExpr: SynExpr * finallyExpr: SynExpr * range: Range.range * + trySeqPoint: DebugPointAtTry * finallySeqPoint: DebugPointAtFinally + | Lazy of expr: SynExpr * range: Range.range + | Sequential of + seqPoint: DebugPointAtSequential * isTrueSeq: bool * expr1: SynExpr * + expr2: SynExpr * range: Range.range + | IfThenElse of + ifExpr: SynExpr * thenExpr: SynExpr * elseExpr: SynExpr option * + spIfToThen: DebugPointForBinding * isFromErrorRecovery: bool * + ifToThenRange: Range.range * range: Range.range + | Ident of ident: Ident + | LongIdent of + isOptional: bool * longDotId: LongIdentWithDots * + altNameRefCell: SynSimplePatAlternativeIdInfo ref option * + range: Range.range + | LongIdentSet of + longDotId: LongIdentWithDots * expr: SynExpr * range: Range.range + | DotGet of + expr: SynExpr * rangeOfDot: Range.range * longDotId: LongIdentWithDots * + range: Range.range + | DotSet of + targetExpr: SynExpr * longDotId: LongIdentWithDots * rhsExpr: SynExpr * + range: Range.range + | Set of targetExpr: SynExpr * rhsExpr: SynExpr * range: Range.range + | DotIndexedGet of + objectExpr: SynExpr * indexExprs: SynIndexerArg list * + dotRange: Range.range * range: Range.range + | DotIndexedSet of + objectExpr: SynExpr * indexExprs: SynIndexerArg list * + valueExpr: SynExpr * leftOfSetRange: Range.range * dotRange: Range.range * + range: Range.range + | NamedIndexedPropertySet of + longDotId: LongIdentWithDots * expr1: SynExpr * expr2: SynExpr * + range: Range.range + | DotNamedIndexedPropertySet of + targetExpr: SynExpr * longDotId: LongIdentWithDots * argExpr: SynExpr * + rhsExpr: SynExpr * range: Range.range + | TypeTest of expr: SynExpr * targetType: SynType * range: Range.range + | Upcast of expr: SynExpr * targetType: SynType * range: Range.range + | Downcast of expr: SynExpr * targetType: SynType * range: Range.range + | InferredUpcast of expr: SynExpr * range: Range.range + | InferredDowncast of expr: SynExpr * range: Range.range + | Null of range: Range.range + | AddressOf of + isByref: bool * expr: SynExpr * opRange: Range.range * + range: Range.range + | TraitCall of + supportTys: SynTypar list * traitSig: SynMemberSig * argExpr: SynExpr * + range: Range.range + | JoinIn of + lhsExpr: SynExpr * lhsRange: Range.range * rhsExpr: SynExpr * + range: Range.range + | ImplicitZero of range: Range.range + | SequentialOrImplicitYield of + seqPoint: DebugPointAtSequential * expr1: SynExpr * expr2: SynExpr * + ifNotStmt: SynExpr * range: Range.range + | YieldOrReturn of flags: bool * bool * expr: SynExpr * range: Range.range + | YieldOrReturnFrom of + flags: bool * bool * expr: SynExpr * range: Range.range + | LetOrUseBang of + bindSeqPoint: DebugPointForBinding * isUse: bool * isFromSource: bool * + pat: SynPat * rhs: SynExpr * + andBangs: + (DebugPointForBinding * bool * bool * SynPat * SynExpr * Range.range) list * + body: SynExpr * range: Range.range + | MatchBang of + matchSeqPoint: DebugPointForBinding * expr: SynExpr * + clauses: SynMatchClause list * range: Range.range + | DoBang of expr: SynExpr * range: Range.range + | LibraryOnlyILAssembly of + ilCode: AbstractIL.IL.ILInstr array * typeArgs: SynType list * + args: SynExpr list * retTy: SynType list * range: Range.range + | LibraryOnlyStaticOptimization of + constraints: SynStaticOptimizationConstraint list * expr: SynExpr * + optimizedExpr: SynExpr * range: Range.range + | LibraryOnlyUnionCaseFieldGet of + expr: SynExpr * longId: LongIdent * fieldNum: int * range: Range.range + | LibraryOnlyUnionCaseFieldSet of + expr: SynExpr * longId: LongIdent * fieldNum: int * rhsExpr: SynExpr * + range: Range.range + | ArbitraryAfterError of debugStr: string * range: Range.range + | FromParseError of expr: SynExpr * range: Range.range + | DiscardAfterMissingQualificationAfterDot of + expr: SynExpr * range: Range.range + | Fixed of expr: SynExpr * range: Range.range + | InterpolatedString of + contents: SynInterpolatedStringPart list * range: Range.range + with + member IsArbExprAndThusAlreadyReportedError : bool + member Range : Range.range + member RangeOfFirstPortion : Range.range + member RangeSansAnyExtraDot : Range.range + end + [] + and SynInterpolatedStringPart = + | String of string * Range.range + | FillExpr of SynExpr * Ident option + [] + and SynIndexerArg = + | Two of + expr1: SynExpr * fromEnd1: bool * expr2: SynExpr * fromEnd2: bool * + range1: Range.range * range2: Range.range + | One of expr: SynExpr * fromEnd: bool * Range.range + with + member Exprs : SynExpr list + member Range : Range.range + end + [] + and SynSimplePat = + | Id of + ident: Ident * altNameRefCell: SynSimplePatAlternativeIdInfo ref option * + isCompilerGenerated: bool * isThisVar: bool * isOptArg: bool * + range: Range.range + | Typed of pat: SynSimplePat * targetType: SynType * range: Range.range + | Attrib of + pat: SynSimplePat * attributes: SynAttributes * range: Range.range + and SynSimplePatAlternativeIdInfo = + | Undecided of Ident + | Decided of Ident + [] + and SynStaticOptimizationConstraint = + | WhenTyparTyconEqualsTycon of + typar: SynTypar * rhsType: SynType * range: Range.range + | WhenTyparIsStruct of typar: SynTypar * range: Range.range + [] + and SynSimplePats = + | SimplePats of pats: SynSimplePat list * range: Range.range + | Typed of pats: SynSimplePats * targetType: SynType * range: Range.range + and SynArgPats = + | Pats of pats: SynPat list + | NamePatPairs of pats: (Ident * SynPat) list * range: Range.range + [] + and SynPat = + | Const of constant: SynConst * range: Range.range + | Wild of range: Range.range + | Named of + pat: SynPat * ident: Ident * isSelfIdentifier: bool * + accessibility: SynAccess option * range: Range.range + | Typed of pat: SynPat * targetType: SynType * range: Range.range + | Attrib of pat: SynPat * attributes: SynAttributes * range: Range.range + | Or of lhsPat: SynPat * rhsPat: SynPat * range: Range.range + | Ands of pats: SynPat list * range: Range.range + | LongIdent of + longDotId: LongIdentWithDots * extraId: Ident option * + typarDecls: SynValTyparDecls option * argPats: SynArgPats * + accessibility: SynAccess option * range: Range.range + | Tuple of isStruct: bool * elementPats: SynPat list * range: Range.range + | Paren of pat: SynPat * range: Range.range + | ArrayOrList of + isArray: bool * elementPats: SynPat list * range: Range.range + | Record of + fieldPats: ((LongIdent * Ident) * SynPat) list * range: Range.range + | Null of range: Range.range + | OptionalVal of ident: Ident * range: Range.range + | IsInst of pat: SynType * range: Range.range + | QuoteExpr of expr: SynExpr * range: Range.range + | DeprecatedCharRange of + startChar: char * endChar: char * range: Range.range + | InstanceMember of + thisId: Ident * memberId: Ident * toolingId: Ident option * + accessibility: SynAccess option * range: Range.range + | FromParseError of pat: SynPat * range: Range.range + with + member Range : Range.range + end + [] + and SynInterfaceImpl = + | InterfaceImpl of SynType * SynBinding list * range: Range.range + [] + and SynMatchClause = + | Clause of + pat: SynPat * whenExpr: SynExpr option * resultExpr: SynExpr * + range: Range.range * spInfo: DebugPointForTarget + with + member Range : Range.range + member RangeOfGuardAndRhs : Range.range + end + [] + and SynAttribute = + { TypeName: LongIdentWithDots + ArgExpr: SynExpr + Target: Ident option + AppliesToGetterAndSetter: bool + Range: Range.range } + and SynAttributeList = + { Attributes: SynAttribute list + Range: Range.range } + and SynAttributes = SynAttributeList list + [] + and SynValData = + | SynValData of MemberFlags option * SynValInfo * Ident option + with + member SynValInfo : SynValInfo + end + [] + and SynBinding = + | Binding of + accessibility: SynAccess option * kind: SynBindingKind * + mustInline: bool * isMutable: bool * attributes: SynAttributes * + xmlDoc: XmlDoc.PreXmlDoc * valData: SynValData * headPat: SynPat * + returnInfo: SynBindingReturnInfo option * expr: SynExpr * + range: Range.range * seqPoint: DebugPointForBinding + with + member RangeOfBindingAndRhs : Range.range + member RangeOfBindingSansRhs : Range.range + member RangeOfHeadPat : Range.range + end + [] + and SynBindingReturnInfo = + | SynBindingReturnInfo of + typeName: SynType * range: Range.range * attributes: SynAttributes + [] + and MemberFlags = + { IsInstance: bool + IsDispatchSlot: bool + IsOverrideOrExplicitImpl: bool + IsFinal: bool + MemberKind: MemberKind } + [] + and MemberKind = + | ClassConstructor + | Constructor + | Member + | PropertyGet + | PropertySet + | PropertyGetSet + [] + and SynMemberSig = + | Member of memberSig: SynValSig * flags: MemberFlags * range: Range.range + | Interface of interfaceType: SynType * range: Range.range + | Inherit of inheritedType: SynType * range: Range.range + | ValField of field: SynField * range: Range.range + | NestedType of nestedType: SynTypeDefnSig * range: Range.range + [] + and SynTypeDefnKind = + | TyconUnspecified + | TyconClass + | TyconInterface + | TyconStruct + | TyconRecord + | TyconUnion + | TyconAbbrev + | TyconHiddenRepr + | TyconAugmentation + | TyconILAssemblyCode + | TyconDelegate of SynType * SynValInfo + [] + and SynTypeDefnSimpleRepr = + | Union of + accessibility: SynAccess option * unionCases: SynUnionCase list * + range: Range.range + | Enum of cases: SynEnumCase list * range: Range.range + | Record of + accessibility: SynAccess option * recordFields: SynField list * + range: Range.range + | General of + kind: SynTypeDefnKind * + inherits: (SynType * Range.range * Ident option) list * + slotsigs: (SynValSig * MemberFlags) list * fields: SynField list * + isConcrete: bool * isIncrClass: bool * + implicitCtorSynPats: SynSimplePats option * range: Range.range + | LibraryOnlyILAssembly of + ilType: AbstractIL.IL.ILType * range: Range.range + | TypeAbbrev of + detail: ParserDetail * rhsType: SynType * range: Range.range + | None of range: Range.range + | Exception of exnRepr: SynExceptionDefnRepr + with + member Range : Range.range + end + [] + and SynEnumCase = + | EnumCase of + attributes: SynAttributes * ident: Ident * SynConst * + xmldoc: XmlDoc.PreXmlDoc * range: Range.range + with + member Range : Range.range + end + [] + and SynUnionCase = + | UnionCase of + attributes: SynAttributes * ident: Ident * caseType: SynUnionCaseType * + xmlDoc: XmlDoc.PreXmlDoc * accessibility: SynAccess option * + range: Range.range + with + member Range : Range.range + end + [] + and SynUnionCaseType = + | UnionCaseFields of cases: SynField list + | UnionCaseFullType of SynType * SynValInfo + [] + and SynTypeDefnSigRepr = + | ObjectModel of + kind: SynTypeDefnKind * memberSigs: SynMemberSig list * + range: Range.range + | Simple of repr: SynTypeDefnSimpleRepr * range: Range.range + | Exception of SynExceptionDefnRepr + with + member Range : Range.range + end + [] + and SynTypeDefnSig = + | TypeDefnSig of + SynComponentInfo * SynTypeDefnSigRepr * SynMemberSig list * + range: Range.range + [] + and SynField = + | Field of + attributes: SynAttributes * isStatic: bool * idOpt: Ident option * + fieldType: SynType * isMutable: bool * xmlDoc: XmlDoc.PreXmlDoc * + accessibility: SynAccess option * range: Range.range + [] + and SynComponentInfo = + | ComponentInfo of + attributes: SynAttributes * typeParams: SynTyparDecl list * + constraints: SynTypeConstraint list * longId: LongIdent * + xmlDoc: XmlDoc.PreXmlDoc * preferPostfix: bool * + accessibility: SynAccess option * range: Range.range + with + member Range : Range.range + end + [] + and SynValSig = + | ValSpfn of + attributes: SynAttributes * ident: Ident * + explicitValDecls: SynValTyparDecls * synType: SynType * + arity: SynValInfo * isInline: bool * isMutable: bool * + xmlDoc: XmlDoc.PreXmlDoc * accessibility: SynAccess option * + synExpr: SynExpr option * range: Range.range + with + member RangeOfId : Range.range + member SynInfo : SynValInfo + member SynType : SynType + end + [] + and SynValInfo = + | SynValInfo of + curriedArgInfos: SynArgInfo list list * returnInfo: SynArgInfo + with + member ArgNames : string list + member CurriedArgInfos : SynArgInfo list list + end + [] + and SynArgInfo = + | SynArgInfo of + attributes: SynAttributes * optional: bool * ident: Ident option + with + member Ident : Ident option + end + [] + and SynValTyparDecls = + | SynValTyparDecls of + typars: SynTyparDecl list * canInfer: bool * + constraints: SynTypeConstraint list + and SynReturnInfo = + | SynReturnInfo of returnType: SynType * SynArgInfo * range: Range.range + [] + and SynExceptionDefnRepr = + | SynExceptionDefnRepr of + attributes: SynAttributes * caseName: SynUnionCase * + longId: LongIdent option * xmlDoc: XmlDoc.PreXmlDoc * + accessibility: SynAccess option * range: Range.range + with + member Range : Range.range + end + [] + and SynExceptionDefn = + | SynExceptionDefn of + exnRepr: SynExceptionDefnRepr * members: SynMemberDefns * + range: Range.range + with + member Range : Range.range + end + [] + and SynTypeDefnRepr = + | ObjectModel of + kind: SynTypeDefnKind * members: SynMemberDefns * range: Range.range + | Simple of simpleRepr: SynTypeDefnSimpleRepr * range: Range.range + | Exception of exnRepr: SynExceptionDefnRepr + with + member Range : Range.range + end + [] + and SynTypeDefn = + | TypeDefn of + typeInfo: SynComponentInfo * typeRepr: SynTypeDefnRepr * + members: SynMemberDefns * range: Range.range + with + member Range : Range.range + end + [] + and SynMemberDefn = + | Open of target: SynOpenDeclTarget * range: Range.range + | Member of memberDefn: SynBinding * range: Range.range + | ImplicitCtor of + accessibility: SynAccess option * attributes: SynAttributes * + ctorArgs: SynSimplePats * selfIdentifier: Ident option * + doc: XmlDoc.PreXmlDoc * range: Range.range + | ImplicitInherit of + inheritType: SynType * inheritArgs: SynExpr * inheritAlias: Ident option * + range: Range.range + | LetBindings of + bindings: SynBinding list * isStatic: bool * isRecursive: bool * + range: Range.range + | AbstractSlot of + slotSig: SynValSig * flags: MemberFlags * range: Range.range + | Interface of + interfaceType: SynType * members: SynMemberDefns option * + range: Range.range + | Inherit of + baseType: SynType * asIdent: Ident option * range: Range.range + | ValField of fieldInfo: SynField * range: Range.range + | NestedType of + typeDefn: SynTypeDefn * accessibility: SynAccess option * + range: Range.range + | AutoProperty of + attributes: SynAttributes * isStatic: bool * ident: Ident * + typeOpt: SynType option * propKind: MemberKind * + memberFlags: MemberKind -> MemberFlags * xmlDoc: XmlDoc.PreXmlDoc * + accessibility: SynAccess option * synExpr: SynExpr * + getSetRange: Range.range option * range: Range.range + with + member Range : Range.range + end + and SynMemberDefns = SynMemberDefn list + [] + and SynModuleDecl = + | ModuleAbbrev of ident: Ident * longId: LongIdent * range: Range.range + | NestedModule of + moduleInfo: SynComponentInfo * isRecursive: bool * + decls: SynModuleDecl list * isContinuing: bool * range: Range.range + | Let of + isRecursive: bool * bindings: SynBinding list * range: Range.range + | DoExpr of + spInfo: DebugPointForBinding * expr: SynExpr * range: Range.range + | Types of typeDefns: SynTypeDefn list * range: Range.range + | Exception of exnDefn: SynExceptionDefn * range: Range.range + | Open of target: SynOpenDeclTarget * range: Range.range + | Attributes of attributes: SynAttributes * range: Range.range + | HashDirective of hashDirective: ParsedHashDirective * range: Range.range + | NamespaceFragment of fragment: SynModuleOrNamespace + with + member Range : Range.range + end + [] + and SynOpenDeclTarget = + | ModuleOrNamespace of longId: LongIdent * range: Range.range + | Type of typeName: SynType * range: Range.range + with + member Range : Range.range + end + [] + and SynExceptionSig = + | SynExceptionSig of + exnRepr: SynExceptionDefnRepr * members: SynMemberSig list * + range: Range.range + [] + and SynModuleSigDecl = + | ModuleAbbrev of ident: Ident * longId: LongIdent * range: Range.range + | NestedModule of + moduleInfo: SynComponentInfo * isRecursive: bool * + moduleDecls: SynModuleSigDecl list * range: Range.range + | Val of valSig: SynValSig * range: Range.range + | Types of types: SynTypeDefnSig list * range: Range.range + | Exception of exnSig: SynExceptionSig * range: Range.range + | Open of target: SynOpenDeclTarget * range: Range.range + | HashDirective of hashDirective: ParsedHashDirective * range: Range.range + | NamespaceFragment of SynModuleOrNamespaceSig + with + member Range : Range.range + end + [] + and SynModuleOrNamespaceKind = + | NamedModule + | AnonModule + | DeclaredNamespace + | GlobalNamespace + with + member IsModule : bool + end + [] + and SynModuleOrNamespace = + | SynModuleOrNamespace of + longId: LongIdent * isRecursive: bool * kind: SynModuleOrNamespaceKind * + decls: SynModuleDecl list * xmlDoc: XmlDoc.PreXmlDoc * + attribs: SynAttributes * accessibility: SynAccess option * + range: Range.range + with + member Range : Range.range + end + [] + and SynModuleOrNamespaceSig = + | SynModuleOrNamespaceSig of + longId: LongIdent * isRecursive: bool * kind: SynModuleOrNamespaceKind * + decls: SynModuleSigDecl list * xmlDoc: XmlDoc.PreXmlDoc * + attribs: SynAttributes * accessibility: SynAccess option * + range: Range.range + [] + and ParsedHashDirective = + | ParsedHashDirective of + ident: string * args: string list * range: Range.range + [] + and ParsedImplFileFragment = + | AnonModule of decls: SynModuleDecl list * range: Range.range + | NamedModule of namedModule: SynModuleOrNamespace + | NamespaceFragment of + longId: LongIdent * isRecursive: bool * kind: SynModuleOrNamespaceKind * + decls: SynModuleDecl list * xmlDoc: XmlDoc.PreXmlDoc * + attributes: SynAttributes * range: Range.range + [] + and ParsedSigFileFragment = + | AnonModule of decls: SynModuleSigDecl list * range: Range.range + | NamedModule of namedModule: SynModuleOrNamespaceSig + | NamespaceFragment of + longId: LongIdent * isRecursive: bool * kind: SynModuleOrNamespaceKind * + decls: SynModuleSigDecl list * xmlDoc: XmlDoc.PreXmlDoc * + attributes: SynAttributes * range: Range.range + [] + and ParsedFsiInteraction = + | IDefns of defns: SynModuleDecl list * range: Range.range + | IHash of hashDirective: ParsedHashDirective * range: Range.range + [] + and ParsedImplFile = + | ParsedImplFile of + hashDirectives: ParsedHashDirective list * + fragments: ParsedImplFileFragment list + [] + and ParsedSigFile = + | ParsedSigFile of + hashDirectives: ParsedHashDirective list * + fragments: ParsedSigFileFragment list + [] + and ScopedPragma = | WarningOff of range: Range.range * warningNumber: int + [] + and QualifiedNameOfFile = + | QualifiedNameOfFile of Ident + with + member Id : Ident + member Range : Range.range + member Text : string + end + [] + and ParsedImplFileInput = + | ParsedImplFileInput of + fileName: string * isScript: bool * + qualifiedNameOfFile: QualifiedNameOfFile * + scopedPragmas: ScopedPragma list * + hashDirectives: ParsedHashDirective list * + modules: SynModuleOrNamespace list * isLastCompiland: bool * bool + [] + and ParsedSigFileInput = + | ParsedSigFileInput of + fileName: string * qualifiedNameOfFile: QualifiedNameOfFile * + scopedPragmas: ScopedPragma list * + hashDirectives: ParsedHashDirective list * + modules: SynModuleOrNamespaceSig list + [] + and ParsedInput = + | ImplFile of ParsedImplFileInput + | SigFile of ParsedSigFileInput + with + member Range : Range.range + end + end + +namespace FSharp.Compiler + module SyntaxTreeOps = begin + [] + type SynArgNameGenerator = + class + new : unit -> SynArgNameGenerator + member New : unit -> string + member Reset : unit -> unit + end + val ident : s:string * r:Range.range -> SyntaxTree.Ident + val textOfId : id:SyntaxTree.Ident -> string + val pathOfLid : lid:SyntaxTree.Ident list -> string list + val arrPathOfLid : lid:SyntaxTree.Ident list -> string [] + val textOfPath : path:seq -> string + val textOfLid : lid:SyntaxTree.Ident list -> string + val rangeOfLid : lid:SyntaxTree.Ident list -> Range.range + val mkSynId : m:Range.range -> s:string -> SyntaxTree.Ident + val pathToSynLid : m:Range.range -> p:string list -> SyntaxTree.Ident list + val mkSynIdGet : m:Range.range -> n:string -> SyntaxTree.SynExpr + val mkSynLidGet : + m:Range.range -> path:string list -> n:string -> SyntaxTree.SynExpr + val mkSynIdGetWithAlt : + m:Range.range -> + id:SyntaxTree.Ident -> + altInfo:SyntaxTree.SynSimplePatAlternativeIdInfo ref option -> + SyntaxTree.SynExpr + val mkSynSimplePatVar : + isOpt:bool -> id:SyntaxTree.Ident -> SyntaxTree.SynSimplePat + val mkSynCompGenSimplePatVar : + id:SyntaxTree.Ident -> SyntaxTree.SynSimplePat + val ( |LongOrSingleIdent|_| ) : + inp:SyntaxTree.SynExpr -> + (bool * SyntaxTree.LongIdentWithDots * + SyntaxTree.SynSimplePatAlternativeIdInfo ref option * Range.range) option + val ( |SingleIdent|_| ) : inp:SyntaxTree.SynExpr -> SyntaxTree.Ident option + val IsControlFlowExpression : e:SyntaxTree.SynExpr -> bool + val mkAnonField : ty:SyntaxTree.SynType -> SyntaxTree.SynField + val mkNamedField : + ident:SyntaxTree.Ident * ty:SyntaxTree.SynType * m:Range.range -> + SyntaxTree.SynField + val mkSynPatVar : + vis:SyntaxTree.SynAccess option -> + id:SyntaxTree.Ident -> SyntaxTree.SynPat + val mkSynThisPatVar : id:SyntaxTree.Ident -> SyntaxTree.SynPat + val mkSynPatMaybeVar : + lidwd:SyntaxTree.LongIdentWithDots -> + vis:SyntaxTree.SynAccess option -> m:Range.range -> SyntaxTree.SynPat + val ( |SynPatForConstructorDecl|_| ) : + x:SyntaxTree.SynPat -> SyntaxTree.SynPat option + val ( |SynPatForNullaryArgs|_| ) : x:SyntaxTree.SynPat -> unit option + val ( |SynExprErrorSkip| ) : p:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val ( |SynExprParen|_| ) : + e:SyntaxTree.SynExpr -> + (SyntaxTree.SynExpr * Range.range * Range.range option * Range.range) option + val ( |SynPatErrorSkip| ) : p:SyntaxTree.SynPat -> SyntaxTree.SynPat + val SimplePatOfPat : + synArgNameGenerator:SynArgNameGenerator -> + p:SyntaxTree.SynPat -> + SyntaxTree.SynSimplePat * + (SyntaxTree.SynExpr -> SyntaxTree.SynExpr) option + val appFunOpt : funOpt:('a -> 'a) option -> x:'a -> 'a + val composeFunOpt : + funOpt1:('a -> 'a) option -> + funOpt2:('a -> 'a) option -> ('a -> 'a) option + val SimplePatsOfPat : + synArgNameGenerator:SynArgNameGenerator -> + p:SyntaxTree.SynPat -> + SyntaxTree.SynSimplePats * + (SyntaxTree.SynExpr -> SyntaxTree.SynExpr) option + val PushPatternToExpr : + synArgNameGenerator:SynArgNameGenerator -> + isMember:bool -> + pat:SyntaxTree.SynPat -> + rhs:SyntaxTree.SynExpr -> + SyntaxTree.SynSimplePats * SyntaxTree.SynExpr + val private isSimplePattern : pat:SyntaxTree.SynPat -> bool + val PushCurriedPatternsToExpr : + synArgNameGenerator:SynArgNameGenerator -> + wholem:Range.range -> + isMember:bool -> + pats:SyntaxTree.SynPat list -> + rhs:SyntaxTree.SynExpr -> + SyntaxTree.SynSimplePats list * SyntaxTree.SynExpr + val opNameParenGet : string + val opNameQMark : string + val mkSynOperator : opm:Range.range -> oper:string -> SyntaxTree.SynExpr + val mkSynInfix : + opm:Range.range -> + l:SyntaxTree.SynExpr -> + oper:string -> r:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val mkSynBifix : + m:Range.range -> + oper:string -> + x1:SyntaxTree.SynExpr -> x2:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val mkSynTrifix : + m:Range.range -> + oper:string -> + x1:SyntaxTree.SynExpr -> + x2:SyntaxTree.SynExpr -> x3:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val mkSynPrefixPrim : + opm:Range.range -> + m:Range.range -> + oper:string -> x:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val mkSynPrefix : + opm:Range.range -> + m:Range.range -> + oper:string -> x:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val mkSynCaseName : m:Range.range -> n:string -> SyntaxTree.Ident list + val mkSynApp1 : + f:SyntaxTree.SynExpr -> + x1:SyntaxTree.SynExpr -> m:Range.range -> SyntaxTree.SynExpr + val mkSynApp2 : + f:SyntaxTree.SynExpr -> + x1:SyntaxTree.SynExpr -> + x2:SyntaxTree.SynExpr -> m:Range.range -> SyntaxTree.SynExpr + val mkSynApp3 : + f:SyntaxTree.SynExpr -> + x1:SyntaxTree.SynExpr -> + x2:SyntaxTree.SynExpr -> + x3:SyntaxTree.SynExpr -> m:Range.range -> SyntaxTree.SynExpr + val mkSynApp4 : + f:SyntaxTree.SynExpr -> + x1:SyntaxTree.SynExpr -> + x2:SyntaxTree.SynExpr -> + x3:SyntaxTree.SynExpr -> + x4:SyntaxTree.SynExpr -> m:Range.range -> SyntaxTree.SynExpr + val mkSynApp5 : + f:SyntaxTree.SynExpr -> + x1:SyntaxTree.SynExpr -> + x2:SyntaxTree.SynExpr -> + x3:SyntaxTree.SynExpr -> + x4:SyntaxTree.SynExpr -> + x5:SyntaxTree.SynExpr -> m:Range.range -> SyntaxTree.SynExpr + val mkSynDotParenSet : + m:Range.range -> + a:SyntaxTree.SynExpr -> + b:SyntaxTree.SynExpr -> c:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val mkSynDotBrackGet : + m:Range.range -> + mDot:Range.range -> + a:SyntaxTree.SynExpr -> + b:SyntaxTree.SynExpr -> fromEnd:bool -> SyntaxTree.SynExpr + val mkSynQMarkSet : + m:Range.range -> + a:SyntaxTree.SynExpr -> + b:SyntaxTree.SynExpr -> c:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val mkSynDotBrackSliceGet : + m:Range.range -> + mDot:Range.range -> + arr:SyntaxTree.SynExpr -> + sliceArg:SyntaxTree.SynIndexerArg -> SyntaxTree.SynExpr + val mkSynDotBrackSeqSliceGet : + m:Range.range -> + mDot:Range.range -> + arr:SyntaxTree.SynExpr -> + argsList:SyntaxTree.SynIndexerArg list -> SyntaxTree.SynExpr + val mkSynDotParenGet : + lhsm:Range.range -> + dotm:Range.range -> + a:SyntaxTree.SynExpr -> b:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val mkSynUnit : m:Range.range -> SyntaxTree.SynExpr + val mkSynUnitPat : m:Range.range -> SyntaxTree.SynPat + val mkSynDelay : m:Range.range -> e:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val mkSynAssign : + l:SyntaxTree.SynExpr -> r:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val mkSynDot : + dotm:Range.range -> + m:Range.range -> + l:SyntaxTree.SynExpr -> r:SyntaxTree.Ident -> SyntaxTree.SynExpr + val mkSynDotMissing : + dotm:Range.range -> + m:Range.range -> l:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val mkSynFunMatchLambdas : + synArgNameGenerator:SynArgNameGenerator -> + isMember:bool -> + wholem:Range.range -> + ps:SyntaxTree.SynPat list -> + e:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val arbExpr : debugStr:string * range:Range.range -> SyntaxTree.SynExpr + val unionRangeWithListBy : + projectRangeFromThing:('a -> Range.range) -> + m:Range.range -> listOfThing:'a list -> Range.range + val mkAttributeList : + attrs:SyntaxTree.SynAttribute list -> + range:Range.range -> SyntaxTree.SynAttributeList list + val ConcatAttributesLists : + attrsLists:SyntaxTree.SynAttributeList list -> + SyntaxTree.SynAttribute list + val ( |Attributes| ) : + synAttributes:SyntaxTree.SynAttributeList list -> + SyntaxTree.SynAttribute list + val rangeOfNonNilAttrs : attrs:SyntaxTree.SynAttributes -> Range.range + val stripParenTypes : synType:SyntaxTree.SynType -> SyntaxTree.SynType + val ( |StripParenTypes| ) : synType:SyntaxTree.SynType -> SyntaxTree.SynType + module SynInfo = begin + val unnamedTopArg1 : SyntaxTree.SynArgInfo + val unnamedTopArg : SyntaxTree.SynArgInfo list + val unitArgData : SyntaxTree.SynArgInfo list + val unnamedRetVal : SyntaxTree.SynArgInfo + val selfMetadata : SyntaxTree.SynArgInfo list + val HasNoArgs : SyntaxTree.SynValInfo -> bool + val IsOptionalArg : SyntaxTree.SynArgInfo -> bool + val HasOptionalArgs : SyntaxTree.SynValInfo -> bool + val IncorporateEmptyTupledArgForPropertyGetter : + SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo + val IncorporateSelfArg : SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo + val IncorporateSetterArg : SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo + val AritiesOfArgs : SyntaxTree.SynValInfo -> int list + val AttribsOfArgData : + SyntaxTree.SynArgInfo -> SyntaxTree.SynAttribute list + val InferSynArgInfoFromSimplePat : + attribs:SyntaxTree.SynAttributes -> + p:SyntaxTree.SynSimplePat -> SyntaxTree.SynArgInfo + val InferSynArgInfoFromSimplePats : + x:SyntaxTree.SynSimplePats -> SyntaxTree.SynArgInfo list + val InferSynArgInfoFromPat : + p:SyntaxTree.SynPat -> SyntaxTree.SynArgInfo list + val AdjustArgsForUnitElimination : + infosForArgs:SyntaxTree.SynArgInfo list list -> + SyntaxTree.SynArgInfo list list + val AdjustMemberArgs : + memFlags:SyntaxTree.MemberKind -> + infosForArgs:'a list list -> 'a list list + val InferLambdaArgs : + origRhsExpr:SyntaxTree.SynExpr -> SyntaxTree.SynArgInfo list list + val InferSynReturnData : + retInfo:SyntaxTree.SynReturnInfo option -> SyntaxTree.SynArgInfo + val private emptySynValInfo : SyntaxTree.SynValInfo + val emptySynValData : SyntaxTree.SynValData + val InferSynValData : + memberFlagsOpt:SyntaxTree.MemberFlags option * + pat:SyntaxTree.SynPat option * retInfo:SyntaxTree.SynReturnInfo option * + origRhsExpr:SyntaxTree.SynExpr -> SyntaxTree.SynValData + end + val mkSynBindingRhs : + staticOptimizations:(SyntaxTree.SynStaticOptimizationConstraint list * + SyntaxTree.SynExpr) list -> + rhsExpr:SyntaxTree.SynExpr -> + mRhs:Range.range -> + retInfo:SyntaxTree.SynReturnInfo option -> + SyntaxTree.SynExpr * SyntaxTree.SynBindingReturnInfo option + val mkSynBinding : + xmlDoc:XmlDoc.PreXmlDoc * headPat:SyntaxTree.SynPat -> + vis:SyntaxTree.SynAccess option * isInline:bool * isMutable:bool * + mBind:Range.range * spBind:SyntaxTree.DebugPointForBinding * + retInfo:SyntaxTree.SynReturnInfo option * origRhsExpr:SyntaxTree.SynExpr * + mRhs:Range.range * + staticOptimizations:(SyntaxTree.SynStaticOptimizationConstraint list * + SyntaxTree.SynExpr) list * + attrs:SyntaxTree.SynAttributes * + memberFlagsOpt:SyntaxTree.MemberFlags option -> SyntaxTree.SynBinding + val NonVirtualMemberFlags : + k:SyntaxTree.MemberKind -> SyntaxTree.MemberFlags + val CtorMemberFlags : SyntaxTree.MemberFlags + val ClassCtorMemberFlags : SyntaxTree.MemberFlags + val OverrideMemberFlags : k:SyntaxTree.MemberKind -> SyntaxTree.MemberFlags + val AbstractMemberFlags : k:SyntaxTree.MemberKind -> SyntaxTree.MemberFlags + val StaticMemberFlags : k:SyntaxTree.MemberKind -> SyntaxTree.MemberFlags + val inferredTyparDecls : SyntaxTree.SynValTyparDecls + val noInferredTypars : SyntaxTree.SynValTyparDecls + val synExprContainsError : inpExpr:SyntaxTree.SynExpr -> bool + end + +namespace FSharp.Compiler + module ParseHelpers = begin + exception SyntaxError of obj * range: Range.range + exception IndentationProblem of string * Range.range + val warningStringOfCoords : line:int -> column:int -> string + val warningStringOfPos : p:Range.pos -> string + val internal posOfLexPosition : + p:Internal.Utilities.Text.Lexing.Position -> Range.pos + val internal mkSynRange : + p1:Internal.Utilities.Text.Lexing.Position -> + p2:Internal.Utilities.Text.Lexing.Position -> Range.range + type internal LexBuffer<'Char> with + member internal LexemeRange : Range.range + val internal lhs : + parseState:Internal.Utilities.Text.Parsing.IParseState -> Range.range + val internal rhs2 : + parseState:Internal.Utilities.Text.Parsing.IParseState -> + i:int -> j:int -> Range.range + val internal rhs : + parseState:Internal.Utilities.Text.Parsing.IParseState -> + i:int -> Range.range + type internal IParseState with + member internal SynArgNameGenerator : SyntaxTreeOps.SynArgNameGenerator + type internal IParseState with + member internal ResetSynArgNameGenerator : unit -> unit + module LexbufLocalXmlDocStore = begin + val private xmlDocKey : string + val internal ClearXmlDoc : lexbuf:UnicodeLexing.Lexbuf -> unit + val internal SaveXmlDocLine : + lexbuf:UnicodeLexing.Lexbuf * lineText:string * range:Range.range -> + unit + val internal GrabXmlDocBeforeMarker : + lexbuf:UnicodeLexing.Lexbuf * markerRange:Range.range -> + XmlDoc.PreXmlDoc + end + type LexerIfdefStackEntry = + | IfDefIf + | IfDefElse + type LexerIfdefStackEntries = (LexerIfdefStackEntry * Range.range) list + type LexerIfdefStack = LexerIfdefStackEntries + type LexerEndlineContinuation = + | Token + | Skip of int * range: Range.range + type LexerIfdefExpression = + | IfdefAnd of LexerIfdefExpression * LexerIfdefExpression + | IfdefOr of LexerIfdefExpression * LexerIfdefExpression + | IfdefNot of LexerIfdefExpression + | IfdefId of string + val LexerIfdefEval : + lookup:(string -> bool) -> _arg1:LexerIfdefExpression -> bool + [] + type LexerStringStyle = + | Verbatim + | TripleQuote + | SingleQuote + [] + type LexerStringKind = + { IsByteString: bool + IsInterpolated: bool + IsInterpolatedFirst: bool } + with + static member ByteString : LexerStringKind + static member InterpolatedStringFirst : LexerStringKind + static member InterpolatedStringPart : LexerStringKind + static member String : LexerStringKind + end + type LexerInterpolatedStringNesting = + (int * LexerStringStyle * Range.range) list + [] + type LexerContinuation = + | Token of + ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting + | IfDefSkip of + ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * + int * range: Range.range + | String of + ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * + style: LexerStringStyle * kind: LexerStringKind * range: Range.range + | Comment of + ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * + int * range: Range.range + | SingleLineComment of + ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * + int * range: Range.range + | StringInComment of + ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * + style: LexerStringStyle * int * range: Range.range + | MLOnly of + ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * + range: Range.range + | EndLine of + ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * + LexerEndlineContinuation + with + member LexerIfdefStack : LexerIfdefStackEntries + member LexerInterpStringNesting : LexerInterpolatedStringNesting + static member Default : LexerContinuation + end + and LexCont = LexerContinuation + val internal internalParseAssemblyCodeInstructions : + s:string -> + isFeatureSupported:(Features.LanguageFeature -> bool) -> + m:Range.range -> AbstractIL.IL.ILInstr [] + val ParseAssemblyCodeInstructions : + s:string -> m:Range.range -> AbstractIL.IL.ILInstr [] + val internal internalParseAssemblyCodeType : + s:string -> + isFeatureSupported:(Features.LanguageFeature -> bool) -> + m:Range.range -> AbstractIL.IL.ILType + val ParseAssemblyCodeType : + s:string -> m:Range.range -> AbstractIL.IL.ILType + end + +namespace FSharp.Compiler + module internal PPParser = begin + val dummy : ParseHelpers.LexerIfdefExpression + val doNothing : 'a -> dflt:'b -> 'b + val fail : + ps:Internal.Utilities.Text.Parsing.IParseState -> + i:int -> int * string -> ParseHelpers.LexerIfdefExpression + type token = + | OP_NOT + | OP_AND + | OP_OR + | LPAREN + | RPAREN + | PRELUDE + | EOF + | ID of string + type tokenId = + | TOKEN_OP_NOT + | TOKEN_OP_AND + | TOKEN_OP_OR + | TOKEN_LPAREN + | TOKEN_RPAREN + | TOKEN_PRELUDE + | TOKEN_EOF + | TOKEN_ID + | TOKEN_end_of_input + | TOKEN_error + type nonTerminalId = + | NONTERM__startstart + | NONTERM_start + | NONTERM_Recover + | NONTERM_Full + | NONTERM_Expr + val tagOfToken : t:token -> int + val tokenTagToTokenId : tokenIdx:int -> tokenId + val prodIdxToNonTerminal : prodIdx:int -> nonTerminalId + val _fsyacc_endOfInputTag : int + val _fsyacc_tagOfErrorTerminal : int + val token_to_string : t:token -> string + val _fsyacc_dataOfToken : t:token -> System.Object + val _fsyacc_gotos : uint16 [] + val _fsyacc_sparseGotoTableRowOffsets : uint16 [] + val _fsyacc_stateToProdIdxsTableElements : uint16 [] + val _fsyacc_stateToProdIdxsTableRowOffsets : uint16 [] + val _fsyacc_action_rows : int + val _fsyacc_actionTableElements : uint16 [] + val _fsyacc_actionTableRowOffsets : uint16 [] + val _fsyacc_reductionSymbolCounts : uint16 [] + val _fsyacc_productionToNonTerminalTable : uint16 [] + val _fsyacc_immediateActions : uint16 [] + val _fsyacc_reductions : + unit -> (Internal.Utilities.Text.Parsing.IParseState -> obj) [] + val tables : unit -> Internal.Utilities.Text.Parsing.Tables + val engine : + lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + startState:int -> obj + val start : + lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + ParseHelpers.LexerIfdefExpression + end + +namespace FSharp.Compiler + module internal Parser = begin + val debugPrint : s:string -> unit + val exprFromParseError : e:SyntaxTree.SynExpr -> SyntaxTree.SynExpr + val patFromParseError : e:SyntaxTree.SynPat -> SyntaxTree.SynPat + val mkSynOptionalExpr : + m:Range.range -> xopt:SyntaxTree.SynExpr option -> SyntaxTree.SynExpr + val rebindRanges : + 'a * 'b -> + fields:(('a * 'b) * 'c) list -> lastSep:'c -> ('a * 'b * 'c) list + val mkUnderscoreRecdField : + m:Range.range -> SyntaxTree.LongIdentWithDots * bool + val mkRecdField : lidwd:'a -> 'a * bool + val mkSynDoBinding : + vis:'a option * strict:bool * expr:SyntaxTree.SynExpr * m:Range.range -> + SyntaxTree.SynBinding + val mkSynDoDecl : e:SyntaxTree.SynExpr -> SyntaxTree.SynModuleDecl + val addAttribs : + attrs:SyntaxTree.SynAttributes -> p:SyntaxTree.SynPat -> SyntaxTree.SynPat + val parse_error_rich : + (Internal.Utilities.Text.Parsing.ParseErrorContext<'a> -> unit) option + val reportParseErrorAt : m:Range.range -> int * string -> unit + val unionRangeWithPos : r:Range.range -> p:Range.pos -> Range.range + val raiseParseErrorAt : m:Range.range -> int * string -> 'a + val checkEndOfFileError : t:ParseHelpers.LexerContinuation -> unit + type BindingSet = + | BindingSetPreAttrs of + Range.range * bool * bool * + (SyntaxTree.SynAttributes -> SyntaxTree.SynAccess option -> + SyntaxTree.SynAttributes * SyntaxTree.SynBinding list) * Range.range + val mkClassMemberLocalBindings : + isStatic:bool * initialRangeOpt:Range.range option * + attrs:SyntaxTree.SynAttributes * vis:SyntaxTree.SynAccess option * + BindingSet -> SyntaxTree.SynMemberDefn + val mkLocalBindings : + mWhole:Range.range * BindingSet * body:SyntaxTree.SynExpr -> + SyntaxTree.SynExpr + val mkDefnBindings : + mWhole:Range.range * BindingSet * attrs:SyntaxTree.SynAttributes * + vis:SyntaxTree.SynAccess option * attrsm:Range.range -> + SyntaxTree.SynModuleDecl list + val idOfPat : + parseState:Internal.Utilities.Text.Parsing.IParseState -> + m:Range.range -> p:SyntaxTree.SynPat -> SyntaxTree.Ident + val checkForMultipleAugmentations : + m:Range.range -> a1:'a list -> a2:'a list -> 'a list + val grabXmlDoc : + parseState:Internal.Utilities.Text.Parsing.IParseState * elemIdx:int -> + XmlDoc.PreXmlDoc + val rangeOfLongIdent : lid:SyntaxTree.LongIdent -> Range.range + type token = + | HASH_IF of (Range.range * string * ParseHelpers.LexerContinuation) + | HASH_ELSE of (Range.range * string * ParseHelpers.LexerContinuation) + | HASH_ENDIF of (Range.range * string * ParseHelpers.LexerContinuation) + | COMMENT of ParseHelpers.LexerContinuation + | WHITESPACE of ParseHelpers.LexerContinuation + | HASH_LINE of ParseHelpers.LexerContinuation + | HASH_LIGHT of ParseHelpers.LexerContinuation + | INACTIVECODE of ParseHelpers.LexerContinuation + | LINE_COMMENT of ParseHelpers.LexerContinuation + | STRING_TEXT of ParseHelpers.LexerContinuation + | EOF of ParseHelpers.LexerContinuation + | LEX_FAILURE of string + | ODUMMY of token + | FIXED + | OINTERFACE_MEMBER + | OBLOCKEND + | OBLOCKEND_COMING_SOON + | OBLOCKEND_IS_HERE + | ORIGHT_BLOCK_END + | ODECLEND + | OEND + | OBLOCKSEP + | OBLOCKBEGIN + | ORESET + | OFUN + | OFUNCTION + | OWITH + | OELSE + | OTHEN + | ODO_BANG + | ODO + | OAND_BANG of bool + | OBINDER of string + | OLET of bool + | HIGH_PRECEDENCE_TYAPP + | HIGH_PRECEDENCE_PAREN_APP + | HIGH_PRECEDENCE_BRACK_APP + | TYPE_COMING_SOON + | TYPE_IS_HERE + | MODULE_COMING_SOON + | MODULE_IS_HERE + | EXTERN + | VOID + | PUBLIC + | PRIVATE + | INTERNAL + | GLOBAL + | STATIC + | MEMBER + | CLASS + | ABSTRACT + | OVERRIDE + | DEFAULT + | CONSTRUCTOR + | INHERIT + | GREATER_RBRACK + | STRUCT + | SIG + | BAR + | RBRACK + | RBRACE_COMING_SOON + | RBRACE_IS_HERE + | MINUS + | DOLLAR + | BAR_RBRACK + | BAR_RBRACE + | UNDERSCORE + | SEMICOLON_SEMICOLON + | LARROW + | EQUALS + | LBRACK + | LBRACK_BAR + | LBRACE_BAR + | LBRACK_LESS + | QMARK + | QMARK_QMARK + | DOT + | COLON + | COLON_COLON + | COLON_GREATER + | COLON_QMARK_GREATER + | COLON_QMARK + | COLON_EQUALS + | SEMICOLON + | WHEN + | WHILE + | WITH + | HASH + | AMP + | AMP_AMP + | QUOTE + | LPAREN + | RPAREN + | RPAREN_COMING_SOON + | RPAREN_IS_HERE + | STAR + | COMMA + | RARROW + | GREATER_BAR_RBRACK + | LPAREN_STAR_RPAREN + | OPEN + | OR + | REC + | THEN + | TO + | TRUE + | TRY + | TYPE + | VAL + | INLINE + | INTERFACE + | INSTANCE + | CONST + | LAZY + | OLAZY + | MATCH + | MATCH_BANG + | MUTABLE + | NEW + | OF + | EXCEPTION + | FALSE + | FOR + | FUN + | FUNCTION + | IF + | IN + | JOIN_IN + | FINALLY + | DO_BANG + | AND + | AS + | ASSERT + | OASSERT + | ASR + | BEGIN + | DO + | DONE + | DOWNTO + | ELSE + | ELIF + | END + | DOT_DOT + | DOT_DOT_HAT + | BAR_BAR + | UPCAST + | DOWNCAST + | NULL + | RESERVED + | MODULE + | NAMESPACE + | DELEGATE + | CONSTRAINT + | BASE + | LQUOTE of (string * bool) + | RQUOTE of (string * bool) + | RQUOTE_DOT of (string * bool) + | PERCENT_OP of string + | BINDER of string + | LESS of bool + | GREATER of bool + | LET of bool + | YIELD of bool + | YIELD_BANG of bool + | AND_BANG of bool + | BIGNUM of (string * string) + | DECIMAL of System.Decimal + | CHAR of char + | IEEE64 of double + | IEEE32 of single + | UNATIVEINT of uint64 + | UINT64 of uint64 + | UINT32 of uint32 + | UINT16 of uint16 + | UINT8 of byte + | NATIVEINT of (int64 * bool) + | INT64 of (int64 * bool) + | INT32 of (int32 * bool) + | INT32_DOT_DOT of (int32 * bool) + | INT16 of (int16 * bool) + | INT8 of (sbyte * bool) + | FUNKY_OPERATOR_NAME of string + | ADJACENT_PREFIX_OP of string + | PLUS_MINUS_OP of string + | INFIX_AMP_OP of string + | INFIX_STAR_DIV_MOD_OP of string + | PREFIX_OP of string + | INFIX_BAR_OP of string + | INFIX_AT_HAT_OP of string + | INFIX_COMPARE_OP of string + | INFIX_STAR_STAR_OP of string + | IDENT of string + | KEYWORD_STRING of string + | LBRACE of ParseHelpers.LexerContinuation + | RBRACE of ParseHelpers.LexerContinuation + | INTERP_STRING_END of (string * ParseHelpers.LexerContinuation) + | INTERP_STRING_PART of (string * ParseHelpers.LexerContinuation) + | INTERP_STRING_BEGIN_PART of (string * ParseHelpers.LexerContinuation) + | INTERP_STRING_BEGIN_END of (string * ParseHelpers.LexerContinuation) + | STRING of (string * ParseHelpers.LexerContinuation) + | BYTEARRAY of (byte [] * ParseHelpers.LexerContinuation) + type tokenId = + | TOKEN_HASH_IF + | TOKEN_HASH_ELSE + | TOKEN_HASH_ENDIF + | TOKEN_COMMENT + | TOKEN_WHITESPACE + | TOKEN_HASH_LINE + | TOKEN_HASH_LIGHT + | TOKEN_INACTIVECODE + | TOKEN_LINE_COMMENT + | TOKEN_STRING_TEXT + | TOKEN_EOF + | TOKEN_LEX_FAILURE + | TOKEN_ODUMMY + | TOKEN_FIXED + | TOKEN_OINTERFACE_MEMBER + | TOKEN_OBLOCKEND + | TOKEN_OBLOCKEND_COMING_SOON + | TOKEN_OBLOCKEND_IS_HERE + | TOKEN_ORIGHT_BLOCK_END + | TOKEN_ODECLEND + | TOKEN_OEND + | TOKEN_OBLOCKSEP + | TOKEN_OBLOCKBEGIN + | TOKEN_ORESET + | TOKEN_OFUN + | TOKEN_OFUNCTION + | TOKEN_OWITH + | TOKEN_OELSE + | TOKEN_OTHEN + | TOKEN_ODO_BANG + | TOKEN_ODO + | TOKEN_OAND_BANG + | TOKEN_OBINDER + | TOKEN_OLET + | TOKEN_HIGH_PRECEDENCE_TYAPP + | TOKEN_HIGH_PRECEDENCE_PAREN_APP + | TOKEN_HIGH_PRECEDENCE_BRACK_APP + | TOKEN_TYPE_COMING_SOON + | TOKEN_TYPE_IS_HERE + | TOKEN_MODULE_COMING_SOON + | TOKEN_MODULE_IS_HERE + | TOKEN_EXTERN + | TOKEN_VOID + | TOKEN_PUBLIC + | TOKEN_PRIVATE + | TOKEN_INTERNAL + | TOKEN_GLOBAL + | TOKEN_STATIC + | TOKEN_MEMBER + | TOKEN_CLASS + | TOKEN_ABSTRACT + | TOKEN_OVERRIDE + | TOKEN_DEFAULT + | TOKEN_CONSTRUCTOR + | TOKEN_INHERIT + | TOKEN_GREATER_RBRACK + | TOKEN_STRUCT + | TOKEN_SIG + | TOKEN_BAR + | TOKEN_RBRACK + | TOKEN_RBRACE_COMING_SOON + | TOKEN_RBRACE_IS_HERE + | TOKEN_MINUS + | TOKEN_DOLLAR + | TOKEN_BAR_RBRACK + | TOKEN_BAR_RBRACE + | TOKEN_UNDERSCORE + | TOKEN_SEMICOLON_SEMICOLON + | TOKEN_LARROW + | TOKEN_EQUALS + | TOKEN_LBRACK + | TOKEN_LBRACK_BAR + | TOKEN_LBRACE_BAR + | TOKEN_LBRACK_LESS + | TOKEN_QMARK + | TOKEN_QMARK_QMARK + | TOKEN_DOT + | TOKEN_COLON + | TOKEN_COLON_COLON + | TOKEN_COLON_GREATER + | TOKEN_COLON_QMARK_GREATER + | TOKEN_COLON_QMARK + | TOKEN_COLON_EQUALS + | TOKEN_SEMICOLON + | TOKEN_WHEN + | TOKEN_WHILE + | TOKEN_WITH + | TOKEN_HASH + | TOKEN_AMP + | TOKEN_AMP_AMP + | TOKEN_QUOTE + | TOKEN_LPAREN + | TOKEN_RPAREN + | TOKEN_RPAREN_COMING_SOON + | TOKEN_RPAREN_IS_HERE + | TOKEN_STAR + | TOKEN_COMMA + | TOKEN_RARROW + | TOKEN_GREATER_BAR_RBRACK + | TOKEN_LPAREN_STAR_RPAREN + | TOKEN_OPEN + | TOKEN_OR + | TOKEN_REC + | TOKEN_THEN + | TOKEN_TO + | TOKEN_TRUE + | TOKEN_TRY + | TOKEN_TYPE + | TOKEN_VAL + | TOKEN_INLINE + | TOKEN_INTERFACE + | TOKEN_INSTANCE + | TOKEN_CONST + | TOKEN_LAZY + | TOKEN_OLAZY + | TOKEN_MATCH + | TOKEN_MATCH_BANG + | TOKEN_MUTABLE + | TOKEN_NEW + | TOKEN_OF + | TOKEN_EXCEPTION + | TOKEN_FALSE + | TOKEN_FOR + | TOKEN_FUN + | TOKEN_FUNCTION + | TOKEN_IF + | TOKEN_IN + | TOKEN_JOIN_IN + | TOKEN_FINALLY + | TOKEN_DO_BANG + | TOKEN_AND + | TOKEN_AS + | TOKEN_ASSERT + | TOKEN_OASSERT + | TOKEN_ASR + | TOKEN_BEGIN + | TOKEN_DO + | TOKEN_DONE + | TOKEN_DOWNTO + | TOKEN_ELSE + | TOKEN_ELIF + | TOKEN_END + | TOKEN_DOT_DOT + | TOKEN_DOT_DOT_HAT + | TOKEN_BAR_BAR + | TOKEN_UPCAST + | TOKEN_DOWNCAST + | TOKEN_NULL + | TOKEN_RESERVED + | TOKEN_MODULE + | TOKEN_NAMESPACE + | TOKEN_DELEGATE + | TOKEN_CONSTRAINT + | TOKEN_BASE + | TOKEN_LQUOTE + | TOKEN_RQUOTE + | TOKEN_RQUOTE_DOT + | TOKEN_PERCENT_OP + | TOKEN_BINDER + | TOKEN_LESS + | TOKEN_GREATER + | TOKEN_LET + | TOKEN_YIELD + | TOKEN_YIELD_BANG + | TOKEN_AND_BANG + | TOKEN_BIGNUM + | TOKEN_DECIMAL + | TOKEN_CHAR + | TOKEN_IEEE64 + | TOKEN_IEEE32 + | TOKEN_UNATIVEINT + | TOKEN_UINT64 + | TOKEN_UINT32 + | TOKEN_UINT16 + | TOKEN_UINT8 + | TOKEN_NATIVEINT + | TOKEN_INT64 + | TOKEN_INT32 + | TOKEN_INT32_DOT_DOT + | TOKEN_INT16 + | TOKEN_INT8 + | TOKEN_FUNKY_OPERATOR_NAME + | TOKEN_ADJACENT_PREFIX_OP + | TOKEN_PLUS_MINUS_OP + | TOKEN_INFIX_AMP_OP + | TOKEN_INFIX_STAR_DIV_MOD_OP + | TOKEN_PREFIX_OP + | TOKEN_INFIX_BAR_OP + | TOKEN_INFIX_AT_HAT_OP + | TOKEN_INFIX_COMPARE_OP + | TOKEN_INFIX_STAR_STAR_OP + | TOKEN_IDENT + | TOKEN_KEYWORD_STRING + | TOKEN_LBRACE + | TOKEN_RBRACE + | TOKEN_INTERP_STRING_END + | TOKEN_INTERP_STRING_PART + | TOKEN_INTERP_STRING_BEGIN_PART + | TOKEN_INTERP_STRING_BEGIN_END + | TOKEN_STRING + | TOKEN_BYTEARRAY + | TOKEN_end_of_input + | TOKEN_error + type nonTerminalId = + | NONTERM__startsignatureFile + | NONTERM__startimplementationFile + | NONTERM__startinteraction + | NONTERM__starttypedSeqExprEOF + | NONTERM__starttypEOF + | NONTERM_interaction + | NONTERM_interactiveTerminator + | NONTERM_interactiveItemsTerminator + | NONTERM_interactiveDefns + | NONTERM_interactiveExpr + | NONTERM_interactiveHash + | NONTERM_interactiveSeparators + | NONTERM_interactiveSeparator + | NONTERM_hashDirective + | NONTERM_hashDirectiveArgs + | NONTERM_hashDirectiveArg + | NONTERM_signatureFile + | NONTERM_moduleIntro + | NONTERM_namespaceIntro + | NONTERM_fileNamespaceSpecs + | NONTERM_fileNamespaceSpecList + | NONTERM_fileNamespaceSpec + | NONTERM_fileModuleSpec + | NONTERM_moduleSpfnsPossiblyEmptyBlock + | NONTERM_moduleSpfnsPossiblyEmpty + | NONTERM_moduleSpfns + | NONTERM_moduleSpfn + | NONTERM_valSpfn + | NONTERM_optLiteralValueSpfn + | NONTERM_moduleSpecBlock + | NONTERM_tyconSpfns + | NONTERM_tyconSpfnList + | NONTERM_tyconSpfn + | NONTERM_tyconSpfnRhsBlock + | NONTERM_tyconSpfnRhs + | NONTERM_tyconClassSpfn + | NONTERM_classSpfnBlockKindUnspecified + | NONTERM_classSpfnBlock + | NONTERM_classSpfnMembers + | NONTERM_classSpfnMembersAtLeastOne + | NONTERM_classMemberSpfn + | NONTERM_classMemberSpfnGetSet + | NONTERM_classMemberSpfnGetSetElements + | NONTERM_memberSpecFlags + | NONTERM_exconSpfn + | NONTERM_opt_classSpfn + | NONTERM_implementationFile + | NONTERM_fileNamespaceImpls + | NONTERM_fileNamespaceImplList + | NONTERM_fileNamespaceImpl + | NONTERM_fileModuleImpl + | NONTERM_moduleDefnsOrExprPossiblyEmptyOrBlock + | NONTERM_moduleDefnsOrExprPossiblyEmpty + | NONTERM_moduleDefnsOrExpr + | NONTERM_moduleDefns + | NONTERM_moduleDefnOrDirective + | NONTERM_moduleDefn + | NONTERM_openDecl + | NONTERM_namedModuleAbbrevBlock + | NONTERM_namedModuleDefnBlock + | NONTERM_wrappedNamedModuleDefn + | NONTERM_tyconDefnAugmentation + | NONTERM_opt_attributes + | NONTERM_attributes + | NONTERM_attributeList + | NONTERM_attributeListElements + | NONTERM_attribute + | NONTERM_attributeTarget + | NONTERM_memberFlags + | NONTERM_typeNameInfo + | NONTERM_tyconDefnList + | NONTERM_tyconDefn + | NONTERM_tyconDefnRhsBlock + | NONTERM_tyconDefnRhs + | NONTERM_tyconClassDefn + | NONTERM_classDefnBlockKindUnspecified + | NONTERM_classDefnBlock + | NONTERM_classDefnMembers + | NONTERM_classDefnMembersAtLeastOne + | NONTERM_classDefnMemberGetSet + | NONTERM_classDefnMemberGetSetElements + | NONTERM_classDefnMemberGetSetElement + | NONTERM_memberCore + | NONTERM_abstractMemberFlags + | NONTERM_classDefnMember + | NONTERM_valDefnDecl + | NONTERM_autoPropsDefnDecl + | NONTERM_opt_typ + | NONTERM_atomicPatternLongIdent + | NONTERM_opt_access + | NONTERM_access + | NONTERM_opt_declVisibility + | NONTERM_opt_interfaceImplDefn + | NONTERM_opt_classDefn + | NONTERM_inheritsDefn + | NONTERM_optAsSpec + | NONTERM_asSpec + | NONTERM_optBaseSpec + | NONTERM_baseSpec + | NONTERM_objectImplementationBlock + | NONTERM_objectImplementationMembers + | NONTERM_objectImplementationMember + | NONTERM_memberOrOverride + | NONTERM_tyconDefnOrSpfnSimpleRepr + | NONTERM_braceFieldDeclList + | NONTERM_anonRecdType + | NONTERM_braceBarFieldDeclListCore + | NONTERM_inlineAssemblyTyconRepr + | NONTERM_classOrInterfaceOrStruct + | NONTERM_interfaceMember + | NONTERM_tyconNameAndTyparDecls + | NONTERM_prefixTyparDecls + | NONTERM_typarDeclList + | NONTERM_typarDecl + | NONTERM_postfixTyparDecls + | NONTERM_explicitValTyparDeclsCore + | NONTERM_explicitValTyparDecls + | NONTERM_opt_explicitValTyparDecls + | NONTERM_opt_explicitValTyparDecls2 + | NONTERM_opt_typeConstraints + | NONTERM_typeConstraints + | NONTERM_typeConstraint + | NONTERM_typarAlts + | NONTERM_unionTypeRepr + | NONTERM_barAndgrabXmlDoc + | NONTERM_attrUnionCaseDecls + | NONTERM_attrUnionCaseDecl + | NONTERM_unionCaseName + | NONTERM_firstUnionCaseDeclOfMany + | NONTERM_firstUnionCaseDecl + | NONTERM_unionCaseReprElements + | NONTERM_unionCaseReprElement + | NONTERM_unionCaseRepr + | NONTERM_recdFieldDeclList + | NONTERM_recdFieldDecl + | NONTERM_fieldDecl + | NONTERM_exconDefn + | NONTERM_exceptionAndGrabDoc + | NONTERM_exconCore + | NONTERM_exconIntro + | NONTERM_exconRepr + | NONTERM_defnBindings + | NONTERM_doBinding + | NONTERM_hardwhiteLetBindings + | NONTERM_hardwhiteDoBinding + | NONTERM_classDefnBindings + | NONTERM_hardwhiteDefnBindingsTerminator + | NONTERM_cPrototype + | NONTERM_cArgs + | NONTERM_cMoreArgs + | NONTERM_cArg + | NONTERM_cType + | NONTERM_cRetType + | NONTERM_localBindings + | NONTERM_moreLocalBindings + | NONTERM_attr_localBinding + | NONTERM_localBinding + | NONTERM_typedExprWithStaticOptimizationsBlock + | NONTERM_typedExprWithStaticOptimizations + | NONTERM_opt_staticOptimizations + | NONTERM_staticOptimization + | NONTERM_staticOptimizationConditions + | NONTERM_staticOptimizationCondition + | NONTERM_rawConstant + | NONTERM_rationalConstant + | NONTERM_atomicUnsignedRationalConstant + | NONTERM_atomicRationalConstant + | NONTERM_constant + | NONTERM_bindingPattern + | NONTERM_simplePattern + | NONTERM_simplePatternCommaList + | NONTERM_simplePatterns + | NONTERM_headBindingPattern + | NONTERM_tuplePatternElements + | NONTERM_conjPatternElements + | NONTERM_namePatPairs + | NONTERM_namePatPair + | NONTERM_constrPattern + | NONTERM_atomicPatsOrNamePatPairs + | NONTERM_atomicPatterns + | NONTERM_atomicPattern + | NONTERM_parenPatternBody + | NONTERM_parenPattern + | NONTERM_tupleParenPatternElements + | NONTERM_conjParenPatternElements + | NONTERM_recordPatternElementsAux + | NONTERM_recordPatternElement + | NONTERM_listPatternElements + | NONTERM_typedSeqExprBlock + | NONTERM_declExprBlock + | NONTERM_typedSeqExprBlockR + | NONTERM_typedSeqExpr + | NONTERM_typedSeqExprEOF + | NONTERM_seqExpr + | NONTERM_recover + | NONTERM_moreBinders + | NONTERM_declExpr + | NONTERM_dynamicArg + | NONTERM_withClauses + | NONTERM_withPatternClauses + | NONTERM_patternAndGuard + | NONTERM_patternClauses + | NONTERM_patternGuard + | NONTERM_patternResult + | NONTERM_ifExprCases + | NONTERM_ifExprThen + | NONTERM_ifExprElifs + | NONTERM_tupleExpr + | NONTERM_minusExpr + | NONTERM_appExpr + | NONTERM_argExpr + | NONTERM_atomicExpr + | NONTERM_atomicExprQualification + | NONTERM_optRangeSeqExpr + | NONTERM_optRange + | NONTERM_rangeDeclExpr + | NONTERM_atomicExprAfterType + | NONTERM_beginEndExpr + | NONTERM_quoteExpr + | NONTERM_arrayExpr + | NONTERM_parenExpr + | NONTERM_parenExprBody + | NONTERM_staticallyKnownHeadTypars + | NONTERM_staticallyKnownHeadTyparAlts + | NONTERM_braceExpr + | NONTERM_braceExprBody + | NONTERM_listExprElements + | NONTERM_monadicExprInitial + | NONTERM_rangeSequenceExpr + | NONTERM_arrowThenExprR + | NONTERM_forLoopBinder + | NONTERM_forLoopRange + | NONTERM_forLoopDirection + | NONTERM_inlineAssemblyExpr + | NONTERM_optCurriedArgExprs + | NONTERM_opt_atomicExprAfterType + | NONTERM_opt_inlineAssemblyTypeArg + | NONTERM_optInlineAssemblyReturnTypes + | NONTERM_recdExpr + | NONTERM_recdExprCore + | NONTERM_opt_seps_recd + | NONTERM_seps_recd + | NONTERM_pathOrUnderscore + | NONTERM_recdExprBindings + | NONTERM_recdBinding + | NONTERM_objExpr + | NONTERM_objExprBaseCall + | NONTERM_opt_objExprBindings + | NONTERM_objExprBindings + | NONTERM_objExprInterfaces + | NONTERM_opt_objExprInterfaces + | NONTERM_objExprInterface + | NONTERM_braceBarExpr + | NONTERM_braceBarExprCore + | NONTERM_anonLambdaExpr + | NONTERM_anonMatchingExpr + | NONTERM_typeWithTypeConstraints + | NONTERM_topTypeWithTypeConstraints + | NONTERM_opt_topReturnTypeWithTypeConstraints + | NONTERM_topType + | NONTERM_topTupleType + | NONTERM_topTupleTypeElements + | NONTERM_topAppType + | NONTERM_typ + | NONTERM_typEOF + | NONTERM_tupleType + | NONTERM_tupleOrQuotTypeElements + | NONTERM_appTypeCon + | NONTERM_appTypeConPower + | NONTERM_appType + | NONTERM_arrayTypeSuffix + | NONTERM_appTypePrefixArguments + | NONTERM_typeArgListElements + | NONTERM_powerType + | NONTERM_atomTypeNonAtomicDeprecated + | NONTERM_atomTypeOrAnonRecdType + | NONTERM_atomType + | NONTERM_typeArgsNoHpaDeprecated + | NONTERM_typeArgsActual + | NONTERM_typeArgActual + | NONTERM_typeArgActualOrDummyIfEmpty + | NONTERM_dummyTypeArg + | NONTERM_measureTypeArg + | NONTERM_measureTypeAtom + | NONTERM_measureTypePower + | NONTERM_measureTypeSeq + | NONTERM_measureTypeExpr + | NONTERM_typar + | NONTERM_staticallyKnownHeadTypar + | NONTERM_ident + | NONTERM_path + | NONTERM_opName + | NONTERM_operatorName + | NONTERM_activePatternCaseName + | NONTERM_activePatternCaseNames + | NONTERM_identOrOp + | NONTERM_pathOp + | NONTERM_nameop + | NONTERM_identExpr + | NONTERM_topSeparator + | NONTERM_topSeparators + | NONTERM_opt_topSeparators + | NONTERM_seps + | NONTERM_declEnd + | NONTERM_opt_declEnd + | NONTERM_opt_ODECLEND + | NONTERM_deprecated_opt_equals + | NONTERM_opt_equals + | NONTERM_opt_OBLOCKSEP + | NONTERM_opt_seps + | NONTERM_opt_rec + | NONTERM_opt_bar + | NONTERM_opt_inline + | NONTERM_opt_mutable + | NONTERM_doToken + | NONTERM_doneDeclEnd + | NONTERM_structOrBegin + | NONTERM_sigOrBegin + | NONTERM_colonOrEquals + | NONTERM_stringOrKeywordString + | NONTERM_interpolatedStringFill + | NONTERM_interpolatedStringParts + | NONTERM_interpolatedString + | NONTERM_opt_HIGH_PRECEDENCE_APP + | NONTERM_opt_HIGH_PRECEDENCE_TYAPP + | NONTERM_typeKeyword + | NONTERM_moduleKeyword + | NONTERM_rbrace + | NONTERM_bar_rbrace + | NONTERM_rparen + | NONTERM_oblockend + | NONTERM_ends_other_than_rparen_coming_soon_or_recover + | NONTERM_ends_coming_soon_or_recover + val tagOfToken : t:token -> int + val tokenTagToTokenId : tokenIdx:int -> tokenId + val prodIdxToNonTerminal : prodIdx:int -> nonTerminalId + val _fsyacc_endOfInputTag : int + val _fsyacc_tagOfErrorTerminal : int + val token_to_string : t:token -> string + val _fsyacc_dataOfToken : t:token -> obj + val _fsyacc_gotos : uint16 [] + val _fsyacc_sparseGotoTableRowOffsets : uint16 [] + val _fsyacc_stateToProdIdxsTableElements : uint16 [] + val _fsyacc_stateToProdIdxsTableRowOffsets : uint16 [] + val _fsyacc_action_rows : int + val _fsyacc_actionTableElements : uint16 [] + val _fsyacc_actionTableRowOffsets : uint16 [] + val _fsyacc_reductionSymbolCounts : uint16 [] + val _fsyacc_productionToNonTerminalTable : uint16 [] + val _fsyacc_immediateActions : uint16 [] + val _fsyacc_reductions : + unit -> (Internal.Utilities.Text.Parsing.IParseState -> obj) [] + val tables : unit -> Internal.Utilities.Text.Parsing.Tables + val engine : + lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + startState:int -> obj + val signatureFile : + lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + SyntaxTree.ParsedSigFile + val implementationFile : + lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + SyntaxTree.ParsedImplFile + val interaction : + lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + SyntaxTree.ParsedFsiInteraction + val typedSeqExprEOF : + lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + SyntaxTree.SynExpr + val typEOF : + lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + SyntaxTree.SynType + end + +namespace FSharp.Compiler + module internal Lexhelp = begin + val stdinMockFilename : string + [] + type LightSyntaxStatus = + class + new : initial:bool * warn:bool -> LightSyntaxStatus + member ExplicitlySet : bool + member Status : bool + member WarnOnMultipleTokens : bool + end + [] + type LexResourceManager = + class + new : ?capacity:int -> LexResourceManager + member InternIdentifierToken : s:string -> Parser.token + end + type LexArgs = + { defines: string list + resourceManager: LexResourceManager + errorLogger: ErrorLogger.ErrorLogger + applyLineDirectives: bool + pathMap: Internal.Utilities.PathMap + mutable ifdefStack: ParseHelpers.LexerIfdefStack + mutable lightStatus: LightSyntaxStatus + mutable stringNest: ParseHelpers.LexerInterpolatedStringNesting } + type LongUnicodeLexResult = + | SurrogatePair of uint16 * uint16 + | SingleChar of uint16 + | Invalid + val mkLexargs : + string list * LightSyntaxStatus * LexResourceManager * + ParseHelpers.LexerIfdefStack * ErrorLogger.ErrorLogger * + Internal.Utilities.PathMap -> LexArgs + val reusingLexbufForParsing : UnicodeLexing.Lexbuf -> (unit -> 'a) -> 'a + val resetLexbufPos : string -> UnicodeLexing.Lexbuf -> unit + val usingLexbufForParsing : + UnicodeLexing.Lexbuf * string -> (UnicodeLexing.Lexbuf -> 'a) -> 'a + val stringBufferAsString : AbstractIL.Internal.ByteBuffer -> System.String + val stringBufferAsBytes : AbstractIL.Internal.ByteBuffer -> byte [] + type LexerStringFinisher = + | LexerStringFinisher of + (AbstractIL.Internal.ByteBuffer -> ParseHelpers.LexerStringKind -> + bool -> ParseHelpers.LexerContinuation -> Parser.token) + with + member + Finish : buf:AbstractIL.Internal.ByteBuffer -> + kind:ParseHelpers.LexerStringKind -> + isInterpolatedStringPart:bool -> + cont:ParseHelpers.LexerContinuation -> Parser.token + static member Default : LexerStringFinisher + end + val addUnicodeString : AbstractIL.Internal.ByteBuffer -> string -> unit + val addIntChar : buf:AbstractIL.Internal.ByteBuffer -> c:int -> unit + val addUnicodeChar : AbstractIL.Internal.ByteBuffer -> int -> unit + val addByteChar : AbstractIL.Internal.ByteBuffer -> char -> unit + val stringBufferIsBytes : AbstractIL.Internal.ByteBuffer -> bool + val newline : Internal.Utilities.Text.Lexing.LexBuffer<'a> -> unit + val advanceColumnBy : + Internal.Utilities.Text.Lexing.LexBuffer<'a> -> n:int -> unit + val trigraph : char -> char -> char -> char + val digit : char -> int32 + val hexdigit : char -> int32 + val unicodeGraphShort : string -> uint16 + val hexGraphShort : string -> uint16 + val unicodeGraphLong : string -> LongUnicodeLexResult + val escape : char -> char + exception ReservedKeyword of string * Range.range + module Keywords = begin + type private compatibilityMode = + | ALWAYS + | FSHARP + val private keywordList : (compatibilityMode * string * Parser.token) list + val private unreserveWords : string list + val keywordNames : string list + val keywordTable : + System.Collections.Generic.Dictionary + val KeywordToken : s:string -> Parser.token + val IdentifierToken : + LexArgs -> UnicodeLexing.Lexbuf -> string -> Parser.token + val KeywordOrIdentifierToken : + LexArgs -> UnicodeLexing.Lexbuf -> string -> Parser.token + val DoesIdentifierNeedQuotation : string -> bool + val QuoteIdentifierIfNeeded : string -> string + val NormalizeIdentifierBackticks : string -> string + val keywordsWithDescription : (string * string) list + end + end + +namespace FSharp.Compiler + module internal PPLexer = begin + val lexeme : lexbuf:UnicodeLexing.Lexbuf -> string + val fail : + args:Lexhelp.LexArgs -> + lexbuf:UnicodeLexing.Lexbuf -> int * string -> PPParser.token + val trans : uint16 [] array + val actions : uint16 [] + val _fslex_tables : Internal.Utilities.Text.Lexing.UnicodeTables + val _fslex_dummy : unit -> 'a + val tokenstream : + args:Lexhelp.LexArgs -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> PPParser.token + val rest : lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> unit + end + +namespace FSharp.Compiler + module internal Lexer = begin + module Ranges = begin + val isInt8BadMax : x:int -> bool + val isInt16BadMax : x:int -> bool + val isInt32BadMax : (string -> bool) + val isInt64BadMax : (string -> bool) + end + val lexeme : lexbuf:UnicodeLexing.Lexbuf -> string + val lexemeTrimBoth : lexbuf:UnicodeLexing.Lexbuf -> n:int -> m:int -> string + val lexemeTrimRight : lexbuf:UnicodeLexing.Lexbuf -> n:int -> string + val lexemeTrimLeft : lexbuf:UnicodeLexing.Lexbuf -> n:int -> string + val fail : + args:Lexhelp.LexArgs -> + lexbuf:UnicodeLexing.Lexbuf -> int * string -> dflt:'a -> 'a + val getSign32 : s:string -> p:byref -> l:int -> int + val isOXB : c:char -> bool + val is0OXB : s:string -> p:int -> l:int -> bool + val get0OXB : s:string -> p:byref -> l:int -> char + val formatError : unit -> 'a + val parseBinaryUInt64 : s:string -> uint64 + val parseOctalUInt64 : s:string -> uint64 + val removeUnderscores : s:string -> string + val parseInt32 : s:string -> int + val lexemeTrimRightToInt32 : + args:Lexhelp.LexArgs -> lexbuf:UnicodeLexing.Lexbuf -> n:int -> int + val checkExprOp : lexbuf:UnicodeLexing.Lexbuf -> unit + val unexpectedChar : lexbuf:UnicodeLexing.Lexbuf -> Parser.token + val startString : + args:Lexhelp.LexArgs -> + lexbuf:UnicodeLexing.Lexbuf -> + AbstractIL.Internal.ByteBuffer * Lexhelp.LexerStringFinisher * + Range.range + val trySaveXmlDoc : + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + buff:(Range.range * System.Text.StringBuilder) option -> unit + val tryAppendXmlDoc : + buff:(Range.range * System.Text.StringBuilder) option -> s:string -> unit + val shouldStartLine : + args:Lexhelp.LexArgs -> + lexbuf:UnicodeLexing.Lexbuf -> + m:Range.range -> int * string -> tok:'a -> 'a + val shouldStartFile : + args:Lexhelp.LexArgs -> + lexbuf:UnicodeLexing.Lexbuf -> + m:Range.range -> int * string -> tok:'a -> 'a + val evalIfDefExpression : + startPos:Internal.Utilities.Text.Lexing.Position -> + isFeatureSupported:(Features.LanguageFeature -> bool) -> + args:Lexhelp.LexArgs -> + lookup:(string -> bool) -> lexed:string -> bool + val evalFloat : + args:Lexhelp.LexArgs -> lexbuf:UnicodeLexing.Lexbuf -> float32 + val trans : uint16 [] array + val actions : uint16 [] + val _fslex_tables : Internal.Utilities.Text.Lexing.UnicodeTables + val _fslex_dummy : unit -> 'a + val token : + args:Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token + val ifdefSkip : + n:int -> + m:Range.range -> + args:Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + Parser.token + val endline : + cont:ParseHelpers.LexerEndlineContinuation -> + args:Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + Parser.token + val singleQuoteString : + AbstractIL.Internal.ByteBuffer * Lexhelp.LexerStringFinisher * Range.range * + ParseHelpers.LexerStringKind * Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token + val verbatimString : + AbstractIL.Internal.ByteBuffer * Lexhelp.LexerStringFinisher * Range.range * + ParseHelpers.LexerStringKind * Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token + val tripleQuoteString : + AbstractIL.Internal.ByteBuffer * Lexhelp.LexerStringFinisher * Range.range * + ParseHelpers.LexerStringKind * Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token + val singleLineComment : + (Range.range * System.Text.StringBuilder) option * int * Range.range * + Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token + val comment : + int * Range.range * Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token + val stringInComment : + n:int -> + m:Range.range -> + args:Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + Parser.token + val verbatimStringInComment : + n:int -> + m:Range.range -> + args:Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + Parser.token + val tripleQuoteStringInComment : + n:int -> + m:Range.range -> + args:Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + Parser.token + val mlOnly : + m:Range.range -> + args:Lexhelp.LexArgs -> + skip:bool -> + lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> + Parser.token + end + +namespace FSharp.Compiler + module internal LexFilter = begin + val debug : bool + val stringOfPos : p:Internal.Utilities.Text.Lexing.Position -> string + val outputPos : + os:System.IO.TextWriter -> + p:Internal.Utilities.Text.Lexing.Position -> unit + val warningStringOfPosition : + p:Internal.Utilities.Text.Lexing.Position -> string + type Context = + | CtxtLetDecl of bool * Internal.Utilities.Text.Lexing.Position + | CtxtIf of Internal.Utilities.Text.Lexing.Position + | CtxtTry of Internal.Utilities.Text.Lexing.Position + | CtxtFun of Internal.Utilities.Text.Lexing.Position + | CtxtFunction of Internal.Utilities.Text.Lexing.Position + | CtxtWithAsLet of Internal.Utilities.Text.Lexing.Position + | CtxtWithAsAugment of Internal.Utilities.Text.Lexing.Position + | CtxtMatch of Internal.Utilities.Text.Lexing.Position + | CtxtFor of Internal.Utilities.Text.Lexing.Position + | CtxtWhile of Internal.Utilities.Text.Lexing.Position + | CtxtWhen of Internal.Utilities.Text.Lexing.Position + | CtxtVanilla of Internal.Utilities.Text.Lexing.Position * bool + | CtxtThen of Internal.Utilities.Text.Lexing.Position + | CtxtElse of Internal.Utilities.Text.Lexing.Position + | CtxtDo of Internal.Utilities.Text.Lexing.Position + | CtxtInterfaceHead of Internal.Utilities.Text.Lexing.Position + | CtxtTypeDefns of Internal.Utilities.Text.Lexing.Position + | CtxtNamespaceHead of + Internal.Utilities.Text.Lexing.Position * Parser.token + | CtxtModuleHead of Internal.Utilities.Text.Lexing.Position * Parser.token + | CtxtMemberHead of Internal.Utilities.Text.Lexing.Position + | CtxtMemberBody of Internal.Utilities.Text.Lexing.Position + | CtxtModuleBody of Internal.Utilities.Text.Lexing.Position * bool + | CtxtNamespaceBody of Internal.Utilities.Text.Lexing.Position + | CtxtException of Internal.Utilities.Text.Lexing.Position + | CtxtParen of Parser.token * Internal.Utilities.Text.Lexing.Position + | CtxtSeqBlock of + FirstInSequence * Internal.Utilities.Text.Lexing.Position * AddBlockEnd + | CtxtMatchClauses of bool * Internal.Utilities.Text.Lexing.Position + with + override ToString : unit -> string + member StartCol : int + member StartPos : Internal.Utilities.Text.Lexing.Position + end + and AddBlockEnd = + | AddBlockEnd + | NoAddBlockEnd + | AddOneSidedBlockEnd + and FirstInSequence = + | FirstInSeqBlock + | NotFirstInSeqBlock + val isInfix : token:Parser.token -> bool + val isNonAssocInfixToken : token:Parser.token -> bool + val infixTokenLength : token:Parser.token -> int + val isIfBlockContinuator : token:Parser.token -> bool + val isTryBlockContinuator : token:Parser.token -> bool + val isThenBlockContinuator : token:Parser.token -> bool + val isDoContinuator : token:Parser.token -> bool + val isInterfaceContinuator : token:Parser.token -> bool + val isNamespaceContinuator : token:Parser.token -> bool + val isTypeContinuator : token:Parser.token -> bool + val isForLoopContinuator : token:Parser.token -> bool + val isWhileBlockContinuator : token:Parser.token -> bool + val isLetContinuator : token:Parser.token -> bool + val isTypeSeqBlockElementContinuator : token:Parser.token -> bool + val isSeqBlockElementContinuator : token:Parser.token -> bool + val isWithAugmentBlockContinuator : token:Parser.token -> bool + val isLongIdentifier : token:Parser.token -> bool + val isLongIdentifierOrGlobal : token:Parser.token -> bool + val isAtomicExprEndToken : token:Parser.token -> bool + val parenTokensBalance : t1:Parser.token -> t2:Parser.token -> bool + [] + type LexbufState = + struct + new : startPos:Internal.Utilities.Text.Lexing.Position * + endPos:Internal.Utilities.Text.Lexing.Position * pastEOF:bool -> + LexbufState + member EndPos : Internal.Utilities.Text.Lexing.Position + member PastEOF : bool + member StartPos : Internal.Utilities.Text.Lexing.Position + end + [] + type TokenTup = + class + new : token:Parser.token * state:LexbufState * + lastTokenPos:Internal.Utilities.Text.Lexing.Position -> TokenTup + val mutable Token: Parser.token + val mutable LexbufState: LexbufState + val mutable LastTokenPos: Internal.Utilities.Text.Lexing.Position + member EndPos : Internal.Utilities.Text.Lexing.Position + member StartPos : Internal.Utilities.Text.Lexing.Position + end + type TokenTupPool = + class + new : unit -> TokenTupPool + member Rent : unit -> TokenTup + member Return : x:TokenTup -> unit + member UseLocation : x:TokenTup * tok:Parser.token -> TokenTup + member + UseShiftedLocation : x:TokenTup * tok:Parser.token * shiftLeft:int * + shiftRight:int -> TokenTup + end + val ( |TyparsCloseOp|_| ) : + txt:string -> ((bool -> Parser.token) [] * Parser.token option) option + [] + type PositionWithColumn = + struct + new : position:Internal.Utilities.Text.Lexing.Position * column:int -> + PositionWithColumn + val Position: Internal.Utilities.Text.Lexing.Position + val Column: int + end + type LexFilterImpl = + class + new : lightStatus:Lexhelp.LightSyntaxStatus * compilingFsLib:bool * + lexer:(UnicodeLexing.Lexbuf -> Parser.token) * + lexbuf:UnicodeLexing.Lexbuf -> LexFilterImpl + member GetToken : unit -> Parser.token + member LexBuffer : UnicodeLexing.Lexbuf + end + type LexFilter = + class + new : lightStatus:Lexhelp.LightSyntaxStatus * compilingFsLib:bool * + lexer:(UnicodeLexing.Lexbuf -> Parser.token) * + lexbuf:UnicodeLexing.Lexbuf -> LexFilter + member GetToken : unit -> Parser.token + member LexBuffer : UnicodeLexing.Lexbuf + end + end + +namespace FSharp.Compiler + [] + type internal TypeProviderToken = + class + interface AbstractIL.Internal.Library.LockToken + new : unit -> TypeProviderToken + end + [] + type internal TypeProviderLock = + class + inherit AbstractIL.Internal.Library.Lock + new : unit -> TypeProviderLock + end + type internal TypeProviderError = + class + inherit System.Exception + new : int * string * Range.range * seq -> TypeProviderError + new : (int * string) * string * Range.range -> TypeProviderError + new : errNum:int * tpDesignation:string * m:Range.range * + errors:string list * typeNameContext:string option * + methodNameContext:string option -> TypeProviderError + member Iter : (TypeProviderError -> unit) -> unit + member + MapText : (string -> int * string) * string * Range.range -> + TypeProviderError + member WithContext : string * string -> TypeProviderError + member ContextualErrorMessage : string + override Message : string + member Number : int + member Range : Range.range + end + type TaintedContext = + { TypeProvider: CompilerServices.ITypeProvider + TypeProviderAssemblyRef: AbstractIL.IL.ILScopeRef + Lock: TypeProviderLock } + [] + type internal Tainted<'T> = + class + new : context:TaintedContext * value:'T -> Tainted<'T> + static member + CreateAll : (CompilerServices.ITypeProvider * AbstractIL.IL.ILScopeRef) list -> + Tainted list + member Coerce : range:Range.range -> Tainted<'U> + member OfType : unit -> Tainted<'U> option + member PApply : ('T -> 'U) * range:Range.range -> Tainted<'U> + member + PApply2 : ('T -> 'U1 * 'U2) * range:Range.range -> + Tainted<'U1> * Tainted<'U2> + member + PApply3 : ('T -> 'U1 * 'U2 * 'U3) * range:Range.range -> + Tainted<'U1> * Tainted<'U2> * Tainted<'U3> + member + PApply4 : ('T -> 'U1 * 'U2 * 'U3 * 'U4) * range:Range.range -> + Tainted<'U1> * Tainted<'U2> * Tainted<'U3> * Tainted<'U4> + member + PApplyArray : ('T -> 'U []) * System.String * range:Range.range -> + Tainted<'U> [] + member PApplyNoFailure : f:('T -> 'U) -> Tainted<'U> + member + PApplyOption : ('T -> 'U option) * range:Range.range -> + Tainted<'U> option + member + PApplyWithProvider : ('T * CompilerServices.ITypeProvider -> 'U) * + range:Range.range -> Tainted<'U> + member PUntaint : ('T -> 'U) * range:Range.range -> 'U + member PUntaintNoFailure : ('T -> 'U) -> 'U + member Protect : f:('T -> 'a) -> range:Range.range -> 'a + member AccessObjectDirectly : 'T + member TypeProvider : Tainted + member TypeProviderAssemblyRef : AbstractIL.IL.ILScopeRef + member TypeProviderDesignation : string + end + module internal Tainted = begin + val ( |Null|_| ) : Tainted<'T> -> unit option when 'T : null + val Eq : Tainted<'T> -> 'T -> bool when 'T : equality + val EqTainted : Tainted<'T> -> Tainted<'T> -> bool when 'T : not struct + val GetHashCodeTainted : Tainted<'T> -> int when 'T : equality + end + +namespace FSharp.Compiler + module internal ExtensionTyping = begin + type TypeProviderDesignation = | TypeProviderDesignation of string + exception ProvidedTypeResolution of Range.range * System.Exception + exception ProvidedTypeResolutionNoRange of System.Exception + val toolingCompatiblePaths : unit -> string list + type ResolutionEnvironment = + { resolutionFolder: string + outputFile: string option + showResolutionMessages: bool + referencedAssemblies: string [] + temporaryFolder: string } + val GetTypeProviderImplementationTypes : + runTimeAssemblyFileName:string * + designTimeAssemblyNameString:System.String * m:Range.range * + compilerToolPaths:string list -> System.Type list + val StripException : e:exn -> exn + val CreateTypeProvider : + typeProviderImplementationType:System.Type * runtimeAssemblyPath:string * + resolutionEnvironment:ResolutionEnvironment * isInvalidationSupported:bool * + isInteractive:bool * systemRuntimeContainsType:(string -> bool) * + systemRuntimeAssemblyVersion:System.Version * m:Range.range -> + CompilerServices.ITypeProvider + val GetTypeProvidersOfAssembly : + runtimeAssemblyFilename:string * + ilScopeRefOfRuntimeAssembly:AbstractIL.IL.ILScopeRef * + designTimeName:string * resolutionEnvironment:ResolutionEnvironment * + isInvalidationSupported:bool * isInteractive:bool * + systemRuntimeContainsType:(string -> bool) * + systemRuntimeAssemblyVersion:System.Version * + compilerToolPaths:string list * Range.range -> + Tainted list + val unmarshal : t:Tainted<'a> -> 'a + val TryTypeMember : + st:Tainted<'a> * fullName:System.String * memberName:System.String * + m:Range.range * recover:'b * f:('a -> 'b) -> Tainted<'b> + val TryTypeMemberArray : + st:Tainted<'a> * fullName:System.String * memberName:string * + m:Range.range * f:('a -> 'b []) -> Tainted<'b> [] + val TryTypeMemberNonNull : + st:Tainted<'a> * fullName:System.String * memberName:System.String * + m:Range.range * recover:'b * f:('a -> 'b) -> Tainted<'b> when 'b : null + val TryMemberMember : + mi:Tainted<'a> * typeName:System.String * memberName:System.String * + memberMemberName:System.String * m:Range.range * recover:'b * f:('a -> 'b) -> + Tainted<'b> + val DisplayNameOfTypeProvider : + Tainted * Range.range -> string + val ValidateNamespaceName : + name:System.String * typeProvider:Tainted * + m:Range.range * nsp:string -> unit + val bindingFlags : System.Reflection.BindingFlags + type CustomAttributeData = System.Reflection.CustomAttributeData + type CustomAttributeNamedArgument = + System.Reflection.CustomAttributeNamedArgument + type CustomAttributeTypedArgument = + System.Reflection.CustomAttributeTypedArgument + type ProvidedTypeComparer = + class + interface System.Collections.Generic.IEqualityComparer + new : unit -> ProvidedTypeComparer + static member Instance : ProvidedTypeComparer + end + [] + and ProvidedTypeContext = + | NoEntries + | Entries of + System.Collections.Generic.Dictionary * + System.Lazy> + with + static member + Create : System.Collections.Generic.Dictionary * + System.Collections.Generic.Dictionary -> + ProvidedTypeContext + member + GetDictionaries : unit -> + System.Collections.Generic.Dictionary * + System.Collections.Generic.Dictionary + member RemapTyconRefs : (obj -> obj) -> ProvidedTypeContext + member TryGetILTypeRef : ProvidedType -> AbstractIL.IL.ILTypeRef option + member TryGetTyconRef : ProvidedType -> obj option + static member Empty : ProvidedTypeContext + end + [] + and ProvidedType = + class + inherit ProvidedMemberInfo + interface IProvidedCustomAttributeProvider + new : x:System.Type * ctxt:ProvidedTypeContext -> ProvidedType + static member + ApplyContext : ProvidedType * ProvidedTypeContext -> ProvidedType + static member + Create : ctxt:ProvidedTypeContext -> x:System.Type -> ProvidedType + static member + CreateArray : ctxt:ProvidedTypeContext -> + xs:System.Type [] -> ProvidedType [] + static member CreateNoContext : System.Type -> ProvidedType + static member + CreateWithNullCheck : ctxt:ProvidedTypeContext -> + name:string -> x:System.Type -> ProvidedType + static member + TaintedEquals : Tainted * Tainted -> bool + member + ApplyStaticArguments : provider:CompilerServices.ITypeProvider * + fullTypePathAfterArguments:string [] * + staticArgs:obj [] -> ProvidedType + member AsProvidedVar : name:string -> ProvidedVar + override Equals : y:obj -> bool + member GetAllNestedTypes : unit -> ProvidedType [] + member GetArrayRank : unit -> int + member GetConstructors : unit -> ProvidedConstructorInfo [] + member GetElementType : unit -> ProvidedType + member GetEnumUnderlyingType : unit -> ProvidedType + member GetEvent : string -> ProvidedEventInfo + member GetEvents : unit -> ProvidedEventInfo [] + member GetField : string -> ProvidedFieldInfo + member GetFields : unit -> ProvidedFieldInfo [] + member GetGenericArguments : unit -> ProvidedType [] + member GetGenericTypeDefinition : unit -> ProvidedType + override GetHashCode : unit -> int + member GetInterfaces : unit -> ProvidedType [] + member GetMethods : unit -> ProvidedMethodInfo [] + member GetNestedType : string -> ProvidedType + member GetNestedTypes : unit -> ProvidedType [] + member GetProperties : unit -> ProvidedPropertyInfo [] + member GetProperty : string -> ProvidedPropertyInfo + member + GetStaticParameters : CompilerServices.ITypeProvider -> + ProvidedParameterInfo [] + member MakeArrayType : unit -> ProvidedType + member MakeArrayType : rank:int -> ProvidedType + member MakeByRefType : unit -> ProvidedType + member MakeGenericType : args:ProvidedType [] -> ProvidedType + member MakePointerType : unit -> ProvidedType + member TryGetILTypeRef : unit -> AbstractIL.IL.ILTypeRef option + member TryGetTyconRef : unit -> obj option + member Assembly : ProvidedAssembly + member BaseType : ProvidedType + member Context : ProvidedTypeContext + member FullName : string + member GenericParameterPosition : int + member Handle : System.Type + member IsAbstract : bool + member IsArray : bool + member IsByRef : bool + member IsClass : bool + member IsEnum : bool + member IsErased : bool + member IsGenericParameter : bool + member IsGenericType : bool + member IsInterface : bool + member IsMeasure : bool + member IsNestedPublic : bool + member IsPointer : bool + member IsPublic : bool + member IsSealed : bool + member IsSuppressRelocate : bool + member IsValueType : bool + member IsVoid : bool + member Namespace : string + member RawSystemType : System.Type + static member Void : ProvidedType + end + [] + and IProvidedCustomAttributeProvider = + interface + abstract member + GetAttributeConstructorArgs : provider:CompilerServices.ITypeProvider * + attribName:string -> + (obj option list * + (string * obj option) list) option + abstract member + GetDefinitionLocationAttribute : provider:CompilerServices.ITypeProvider -> + (string * int * int) option + abstract member + GetHasTypeProviderEditorHideMethodsAttribute : provider:CompilerServices.ITypeProvider -> + bool + abstract member + GetXmlDocAttributes : provider:CompilerServices.ITypeProvider -> + string [] + end + and ProvidedCustomAttributeProvider = + class + static member + Create : attributes:(CompilerServices.ITypeProvider -> + seq) -> + IProvidedCustomAttributeProvider + end + [] + and ProvidedMemberInfo = + class + interface IProvidedCustomAttributeProvider + new : x:System.Reflection.MemberInfo * ctxt:ProvidedTypeContext -> + ProvidedMemberInfo + member DeclaringType : ProvidedType + member Name : string + end + [] + and ProvidedParameterInfo = + class + interface IProvidedCustomAttributeProvider + new : x:System.Reflection.ParameterInfo * ctxt:ProvidedTypeContext -> + ProvidedParameterInfo + static member + Create : ctxt:ProvidedTypeContext -> + x:System.Reflection.ParameterInfo -> ProvidedParameterInfo + static member + CreateArray : ctxt:ProvidedTypeContext -> + xs:System.Reflection.ParameterInfo [] -> + ProvidedParameterInfo [] + override Equals : y:obj -> bool + override GetHashCode : unit -> int + member Handle : System.Reflection.ParameterInfo + member HasDefaultValue : bool + member IsIn : bool + member IsOptional : bool + member IsOut : bool + member Name : string + member ParameterType : ProvidedType + member RawDefaultValue : obj + end + [] + and ProvidedAssembly = + class + new : x:System.Reflection.Assembly -> ProvidedAssembly + static member Create : x:System.Reflection.Assembly -> ProvidedAssembly + override Equals : y:obj -> bool + override GetHashCode : unit -> int + member + GetManifestModuleContents : CompilerServices.ITypeProvider -> byte [] + member GetName : unit -> System.Reflection.AssemblyName + member FullName : string + member Handle : System.Reflection.Assembly + end + [] + and ProvidedMethodBase = + class + inherit ProvidedMemberInfo + new : x:System.Reflection.MethodBase * ctxt:ProvidedTypeContext -> + ProvidedMethodBase + static member + TaintedEquals : Tainted * + Tainted -> bool + static member TaintedGetHashCode : Tainted -> int + member + ApplyStaticArgumentsForMethod : provider:CompilerServices.ITypeProvider * + fullNameAfterArguments:string * + staticArgs:obj [] -> + ProvidedMethodBase + member GetGenericArguments : unit -> ProvidedType [] + member GetParameters : unit -> ProvidedParameterInfo [] + member + GetStaticParametersForMethod : CompilerServices.ITypeProvider -> + ProvidedParameterInfo [] + member Context : ProvidedTypeContext + member Handle : System.Reflection.MethodBase + member IsAbstract : bool + member IsConstructor : bool + member IsFamily : bool + member IsFamilyAndAssembly : bool + member IsFamilyOrAssembly : bool + member IsFinal : bool + member IsGenericMethod : bool + member IsHideBySig : bool + member IsPublic : bool + member IsStatic : bool + member IsVirtual : bool + end + [] + and ProvidedFieldInfo = + class + inherit ProvidedMemberInfo + new : x:System.Reflection.FieldInfo * ctxt:ProvidedTypeContext -> + ProvidedFieldInfo + static member + Create : ctxt:ProvidedTypeContext -> + x:System.Reflection.FieldInfo -> ProvidedFieldInfo + static member + CreateArray : ctxt:ProvidedTypeContext -> + xs:System.Reflection.FieldInfo [] -> + ProvidedFieldInfo [] + static member + TaintedEquals : Tainted * + Tainted -> bool + override Equals : y:obj -> bool + override GetHashCode : unit -> int + member GetRawConstantValue : unit -> obj + member FieldType : ProvidedType + member Handle : System.Reflection.FieldInfo + member IsFamily : bool + member IsFamilyAndAssembly : bool + member IsFamilyOrAssembly : bool + member IsInitOnly : bool + member IsLiteral : bool + member IsPrivate : bool + member IsPublic : bool + member IsSpecialName : bool + member IsStatic : bool + end + [] + and ProvidedMethodInfo = + class + inherit ProvidedMethodBase + new : x:System.Reflection.MethodInfo * ctxt:ProvidedTypeContext -> + ProvidedMethodInfo + static member + Create : ctxt:ProvidedTypeContext -> + x:System.Reflection.MethodInfo -> ProvidedMethodInfo + static member + CreateArray : ctxt:ProvidedTypeContext -> + xs:System.Reflection.MethodInfo [] -> + ProvidedMethodInfo [] + override Equals : y:obj -> bool + override GetHashCode : unit -> int + member Handle : System.Reflection.MethodInfo + member MetadataToken : int + member ReturnType : ProvidedType + end + [] + and ProvidedPropertyInfo = + class + inherit ProvidedMemberInfo + new : x:System.Reflection.PropertyInfo * ctxt:ProvidedTypeContext -> + ProvidedPropertyInfo + static member + Create : ctxt:ProvidedTypeContext -> + x:System.Reflection.PropertyInfo -> ProvidedPropertyInfo + static member + CreateArray : ctxt:ProvidedTypeContext -> + xs:System.Reflection.PropertyInfo [] -> + ProvidedPropertyInfo [] + static member + TaintedEquals : Tainted * + Tainted -> bool + static member TaintedGetHashCode : Tainted -> int + override Equals : y:obj -> bool + member GetGetMethod : unit -> ProvidedMethodInfo + override GetHashCode : unit -> int + member GetIndexParameters : unit -> ProvidedParameterInfo [] + member GetSetMethod : unit -> ProvidedMethodInfo + member CanRead : bool + member CanWrite : bool + member Handle : System.Reflection.PropertyInfo + member PropertyType : ProvidedType + end + [] + and ProvidedEventInfo = + class + inherit ProvidedMemberInfo + new : x:System.Reflection.EventInfo * ctxt:ProvidedTypeContext -> + ProvidedEventInfo + static member + Create : ctxt:ProvidedTypeContext -> + x:System.Reflection.EventInfo -> ProvidedEventInfo + static member + CreateArray : ctxt:ProvidedTypeContext -> + xs:System.Reflection.EventInfo [] -> + ProvidedEventInfo [] + static member + TaintedEquals : Tainted * + Tainted -> bool + static member TaintedGetHashCode : Tainted -> int + override Equals : y:obj -> bool + member GetAddMethod : unit -> ProvidedMethodInfo + override GetHashCode : unit -> int + member GetRemoveMethod : unit -> ProvidedMethodInfo + member EventHandlerType : ProvidedType + member Handle : System.Reflection.EventInfo + end + [] + and ProvidedConstructorInfo = + class + inherit ProvidedMethodBase + new : x:System.Reflection.ConstructorInfo * ctxt:ProvidedTypeContext -> + ProvidedConstructorInfo + static member + Create : ctxt:ProvidedTypeContext -> + x:System.Reflection.ConstructorInfo -> + ProvidedConstructorInfo + static member + CreateArray : ctxt:ProvidedTypeContext -> + xs:System.Reflection.ConstructorInfo [] -> + ProvidedConstructorInfo [] + override Equals : y:obj -> bool + override GetHashCode : unit -> int + member Handle : System.Reflection.ConstructorInfo + end + and ProvidedExprType = + | ProvidedNewArrayExpr of ProvidedType * ProvidedExpr [] + | ProvidedNewObjectExpr of ProvidedConstructorInfo * ProvidedExpr [] + | ProvidedWhileLoopExpr of ProvidedExpr * ProvidedExpr + | ProvidedNewDelegateExpr of ProvidedType * ProvidedVar [] * ProvidedExpr + | ProvidedForIntegerRangeLoopExpr of + ProvidedVar * ProvidedExpr * ProvidedExpr * ProvidedExpr + | ProvidedSequentialExpr of ProvidedExpr * ProvidedExpr + | ProvidedTryWithExpr of + ProvidedExpr * ProvidedVar * ProvidedExpr * ProvidedVar * ProvidedExpr + | ProvidedTryFinallyExpr of ProvidedExpr * ProvidedExpr + | ProvidedLambdaExpr of ProvidedVar * ProvidedExpr + | ProvidedCallExpr of + ProvidedExpr option * ProvidedMethodInfo * ProvidedExpr [] + | ProvidedConstantExpr of obj * ProvidedType + | ProvidedDefaultExpr of ProvidedType + | ProvidedNewTupleExpr of ProvidedExpr [] + | ProvidedTupleGetExpr of ProvidedExpr * int + | ProvidedTypeAsExpr of ProvidedExpr * ProvidedType + | ProvidedTypeTestExpr of ProvidedExpr * ProvidedType + | ProvidedLetExpr of ProvidedVar * ProvidedExpr * ProvidedExpr + | ProvidedVarSetExpr of ProvidedVar * ProvidedExpr + | ProvidedIfThenElseExpr of ProvidedExpr * ProvidedExpr * ProvidedExpr + | ProvidedVarExpr of ProvidedVar + [] + and ProvidedExpr = + class + new : x:Quotations.Expr * ctxt:ProvidedTypeContext -> ProvidedExpr + static member + Create : ctxt:ProvidedTypeContext -> t:Quotations.Expr -> ProvidedExpr + static member + CreateArray : ctxt:ProvidedTypeContext -> + xs:Quotations.Expr [] -> ProvidedExpr [] + override Equals : y:obj -> bool + member GetExprType : unit -> ProvidedExprType option + override GetHashCode : unit -> int + member Context : ProvidedTypeContext + member Handle : Quotations.Expr + member Type : ProvidedType + member UnderlyingExpressionString : string + end + [] + and ProvidedVar = + class + new : x:Quotations.Var * ctxt:ProvidedTypeContext -> ProvidedVar + static member + Create : ctxt:ProvidedTypeContext -> t:Quotations.Var -> ProvidedVar + static member + CreateArray : ctxt:ProvidedTypeContext -> + xs:Quotations.Var [] -> ProvidedVar [] + override Equals : obj -> bool + override GetHashCode : unit -> int + member Context : ProvidedTypeContext + member Handle : Quotations.Var + member IsMutable : bool + member Name : string + member Type : ProvidedType + end + val GetInvokerExpression : + CompilerServices.ITypeProvider * ProvidedMethodBase * ProvidedVar [] -> + ProvidedExpr + val CheckAndComputeProvidedNameProperty : + m:Range.range * st:Tainted * proj:(ProvidedType -> string) * + propertyString:System.String -> string + val ValidateAttributesOfProvidedType : + m:Range.range * st:Tainted -> unit + val ValidateExpectedName : + m:Range.range -> + expectedPath:string [] -> + expectedName:string -> st:Tainted -> unit + val ValidateProvidedTypeAfterStaticInstantiation : + Range.range * Tainted * expectedPath:string [] * + expectedName:string -> unit + val ValidateProvidedTypeDefinition : + m:Range.range * st:Tainted * expectedPath:string [] * + expectedName:string -> unit + val ResolveProvidedType : + resolver:Tainted * m:Range.range * + moduleOrNamespace:string [] * typeName:string -> Tainted + val TryResolveProvidedType : + Tainted * Range.range * string [] * + typeName:string -> Tainted option + val ILPathToProvidedType : + st:Tainted * m:Range.range -> string list * string + val ComputeMangledNameForApplyStaticParameters : + nm:string * staticArgs:'a [] * + staticParams:Tainted * m:Range.range -> string + val TryApplyProvidedMethod : + methBeforeArgs:Tainted * staticArgs:obj [] * + Range.range -> Tainted option + val TryApplyProvidedType : + typeBeforeArguments:Tainted * + optGeneratedTypePath:string list option * staticArgs:obj [] * Range.range -> + (Tainted * (unit -> unit)) option + val TryLinkProvidedType : + Tainted * string [] * + typeLogicalName:string * range:Range.range -> Tainted option + val GetPartsOfNamespaceRecover : namespaceName:string -> string list + val GetProvidedNamespaceAsPath : + Range.range * Tainted * string -> + string list + val GetFSharpPathToProvidedType : + Tainted * range:Range.range -> string list + val GetOriginalILAssemblyRefOfProvidedAssembly : + assembly:Tainted * m:Range.range -> + AbstractIL.IL.ILAssemblyRef + val GetOriginalILTypeRefOfProvidedType : + Tainted * range:Range.range -> AbstractIL.IL.ILTypeRef + val GetILTypeRefOfProvidedType : + Tainted * range:Range.range -> AbstractIL.IL.ILTypeRef + type ProviderGeneratedType = + | ProviderGeneratedType of + AbstractIL.IL.ILTypeRef * AbstractIL.IL.ILTypeRef * + ProviderGeneratedType list + type ProvidedAssemblyStaticLinkingMap = + { ILTypeMap: + System.Collections.Generic.Dictionary } + with + static member CreateNew : unit -> ProvidedAssemblyStaticLinkingMap + end + val IsGeneratedTypeDirectReference : + Tainted * Range.range -> bool + end + +namespace FSharp.Compiler + module internal QuotationPickler = begin + val mkRLinear : mk:('a * 'b -> 'b) -> vs:'a list * body:'b -> 'b + type TypeVarData = + { tvName: string } + type NamedTypeData = + | Idx of int + | Named of string * string + type TypeCombOp = + | ArrayTyOp of int + | FunTyOp + | NamedTyOp of NamedTypeData + type TypeData = + | VarType of int + | AppType of TypeCombOp * TypeData list + val mkVarTy : int -> TypeData + val mkFunTy : (TypeData * TypeData) -> TypeData + val mkArrayTy : (int * TypeData) -> TypeData + val mkILNamedTy : (NamedTypeData * TypeData list) -> TypeData + type CtorData = + { ctorParent: NamedTypeData + ctorArgTypes: TypeData list } + type MethodData = + { methParent: NamedTypeData + methName: string + methArgTypes: TypeData list + methRetType: TypeData + numGenericArgs: int } + type VarData = + { vText: string + vType: TypeData + vMutable: bool } + type PropInfoData = NamedTypeData * string * TypeData * TypeData list + type CombOp = + | AppOp + | CondOp + | ModuleValueOp of NamedTypeData * string * bool + | ModuleValueWOp of NamedTypeData * string * bool * string * int + | LetRecOp + | LetRecCombOp + | LetOp + | RecdMkOp of NamedTypeData + | RecdGetOp of NamedTypeData * string + | RecdSetOp of NamedTypeData * string + | SumMkOp of NamedTypeData * string + | SumFieldGetOp of NamedTypeData * string * int + | SumTagTestOp of NamedTypeData * string + | TupleMkOp + | TupleGetOp of int + | UnitOp + | BoolOp of bool + | StringOp of string + | SingleOp of float32 + | DoubleOp of float + | CharOp of char + | SByteOp of sbyte + | ByteOp of byte + | Int16Op of int16 + | UInt16Op of uint16 + | Int32Op of int32 + | UInt32Op of uint32 + | Int64Op of int64 + | UInt64Op of uint64 + | PropGetOp of PropInfoData + | FieldGetOp of NamedTypeData * string + | CtorCallOp of CtorData + | MethodCallOp of MethodData + | MethodCallWOp of MethodData * MethodData * int + | CoerceOp + | NewArrayOp + | DelegateOp + | SeqOp + | ForLoopOp + | WhileLoopOp + | NullOp + | DefaultValueOp + | PropSetOp of PropInfoData + | FieldSetOp of NamedTypeData * string + | AddressOfOp + | ExprSetOp + | AddressSetOp + | TypeTestOp + | TryFinallyOp + | TryWithOp + type ExprData = + | AttrExpr of ExprData * ExprData list + | CombExpr of CombOp * TypeData list * ExprData list + | VarExpr of int + | QuoteExpr of ExprData + | LambdaExpr of VarData * ExprData + | HoleExpr of TypeData * int + | ThisVarExpr of TypeData + | QuoteRawExpr of ExprData + val mkVar : int -> ExprData + val mkHole : TypeData * int -> ExprData + val mkApp : ExprData * ExprData -> ExprData + val mkLambda : VarData * ExprData -> ExprData + val mkQuote : ExprData -> ExprData + val mkQuoteRaw40 : ExprData -> ExprData + val mkCond : ExprData * ExprData * ExprData -> ExprData + val mkModuleValueApp : + NamedTypeData * string * bool * TypeData list * ExprData list -> ExprData + val mkModuleValueWApp : + NamedTypeData * string * bool * string * int * TypeData list * + ExprData list -> ExprData + val mkTuple : TypeData * ExprData list -> ExprData + val mkLet : (VarData * ExprData) * ExprData -> ExprData + val mkUnit : unit -> ExprData + val mkNull : TypeData -> ExprData + val mkLetRecRaw : e1:ExprData -> ExprData + val mkLetRecCombRaw : args:ExprData list -> ExprData + val mkLetRec : (VarData * ExprData) list * ExprData -> ExprData + val mkRecdMk : NamedTypeData * TypeData list * ExprData list -> ExprData + val mkRecdGet : + NamedTypeData * string * TypeData list * ExprData list -> ExprData + val mkRecdSet : + NamedTypeData * string * TypeData list * ExprData list -> ExprData + val mkUnion : + NamedTypeData * string * TypeData list * ExprData list -> ExprData + val mkUnionFieldGet : + NamedTypeData * string * int * TypeData list * ExprData -> ExprData + val mkUnionCaseTagTest : + NamedTypeData * string * TypeData list * ExprData -> ExprData + val mkTupleGet : TypeData * int * ExprData -> ExprData + val mkCoerce : TypeData * ExprData -> ExprData + val mkTypeTest : TypeData * ExprData -> ExprData + val mkAddressOf : ExprData -> ExprData + val mkAddressSet : ExprData * ExprData -> ExprData + val mkVarSet : ExprData * ExprData -> ExprData + val mkDefaultValue : TypeData -> ExprData + val mkThisVar : TypeData -> ExprData + val mkNewArray : TypeData * ExprData list -> ExprData + val mkBool : bool * TypeData -> ExprData + val mkString : string * TypeData -> ExprData + val mkSingle : float32 * TypeData -> ExprData + val mkDouble : float * TypeData -> ExprData + val mkChar : char * TypeData -> ExprData + val mkSByte : sbyte * TypeData -> ExprData + val mkByte : byte * TypeData -> ExprData + val mkInt16 : int16 * TypeData -> ExprData + val mkUInt16 : uint16 * TypeData -> ExprData + val mkInt32 : int32 * TypeData -> ExprData + val mkUInt32 : uint32 * TypeData -> ExprData + val mkInt64 : int64 * TypeData -> ExprData + val mkUInt64 : uint64 * TypeData -> ExprData + val mkSequential : ExprData * ExprData -> ExprData + val mkForLoop : ExprData * ExprData * ExprData -> ExprData + val mkWhileLoop : ExprData * ExprData -> ExprData + val mkTryFinally : ExprData * ExprData -> ExprData + val mkTryWith : + ExprData * VarData * ExprData * VarData * ExprData -> ExprData + val mkDelegate : TypeData * ExprData -> ExprData + val mkPropGet : PropInfoData * TypeData list * ExprData list -> ExprData + val mkPropSet : PropInfoData * TypeData list * ExprData list -> ExprData + val mkFieldGet : + NamedTypeData * string * TypeData list * ExprData list -> ExprData + val mkFieldSet : + NamedTypeData * string * TypeData list * ExprData list -> ExprData + val mkCtorCall : CtorData * TypeData list * ExprData list -> ExprData + val mkMethodCall : MethodData * TypeData list * ExprData list -> ExprData + val mkMethodCallW : + MethodData * MethodData * int * TypeData list * ExprData list -> ExprData + val mkAttributedExpression : ExprData * ExprData -> ExprData + val isAttributedExpression : ExprData -> bool + val SerializedReflectedDefinitionsResourceNameBase : string + val freshVar : string * TypeData * bool -> VarData + module SimplePickle = begin + type Table<'T> = + { tbl: Internal.Utilities.Collections.HashMultiMap<'T,int> + mutable rows: 'T list + mutable count: int } + with + static member Create : unit -> Table<'a> when 'a : equality + member Add : x:'T -> int + member ContainsKey : x:'T -> bool + member Find : x:'T -> int + member FindOrAdd : x:'T -> int + member AsList : 'T list + member Count : int + end + type QuotationPickleOutState = + { os: AbstractIL.Internal.ByteBuffer + ostrings: Table } + val p_byte : b:int -> st:QuotationPickleOutState -> unit + val p_bool : b:bool -> st:QuotationPickleOutState -> unit + val p_void : _os:QuotationPickleOutState -> unit + val p_unit : unit -> _os:QuotationPickleOutState -> unit + val prim_pint32 : i:int -> st:QuotationPickleOutState -> unit + val p_int32 : n:int -> st:QuotationPickleOutState -> unit + val p_bytes : s:byte [] -> st:QuotationPickleOutState -> unit + val prim_pstring : s:string -> st:QuotationPickleOutState -> unit + val p_int : c:int -> st:QuotationPickleOutState -> unit + val p_int8 : i:int8 -> st:QuotationPickleOutState -> unit + val p_uint8 : i:uint8 -> st:QuotationPickleOutState -> unit + val p_int16 : i:int16 -> st:QuotationPickleOutState -> unit + val p_uint16 : x:uint16 -> st:QuotationPickleOutState -> unit + val puint32 : x:uint32 -> st:QuotationPickleOutState -> unit + val p_int64 : i:int64 -> st:QuotationPickleOutState -> unit + val bits_of_float32 : x:float32 -> int + val bits_of_float : x:float -> int64 + val p_uint64 : x:uint64 -> st:QuotationPickleOutState -> unit + val p_double : i:float -> st:QuotationPickleOutState -> unit + val p_single : i:float32 -> st:QuotationPickleOutState -> unit + val p_char : i:char -> st:QuotationPickleOutState -> unit + val inline p_tup2 : + p1:('a -> QuotationPickleOutState -> unit) -> + p2:('b -> QuotationPickleOutState -> unit) -> + a:'a * b:'b -> st:QuotationPickleOutState -> unit + val inline p_tup3 : + p1:('a -> 'b -> unit) -> + p2:('c -> 'b -> unit) -> + p3:('d -> 'b -> unit) -> a:'a * b:'c * c:'d -> st:'b -> unit + val inline p_tup4 : + p1:('a -> 'b -> unit) -> + p2:('c -> 'b -> unit) -> + p3:('d -> 'b -> unit) -> + p4:('e -> 'b -> unit) -> + a:'a * b:'c * c:'d * d:'e -> st:'b -> unit + val inline p_tup5 : + p1:('a -> 'b -> unit) -> + p2:('c -> 'b -> unit) -> + p3:('d -> 'b -> unit) -> + p4:('e -> 'b -> unit) -> + p5:('f -> 'b -> unit) -> + a:'a * b:'c * c:'d * d:'e * e:'f -> st:'b -> unit + val puniq : tbl:Table<'a> -> key:'a -> st:QuotationPickleOutState -> unit + val p_string : s:string -> st:QuotationPickleOutState -> unit + val p_list : + f:('a -> QuotationPickleOutState -> unit) -> + x:'a list -> st:QuotationPickleOutState -> unit + val pickle_obj : + p:('a -> QuotationPickleOutState -> unit) -> x:'a -> byte [] + end + val p_assemblyref : + x:string -> st:SimplePickle.QuotationPickleOutState -> unit + val p_NamedType : + x:NamedTypeData -> st:SimplePickle.QuotationPickleOutState -> unit + val p_tycon : + x:TypeCombOp -> st:SimplePickle.QuotationPickleOutState -> unit + val p_type : x:TypeData -> st:SimplePickle.QuotationPickleOutState -> unit + val p_types : + x:TypeData list -> st:SimplePickle.QuotationPickleOutState -> unit + val p_varDecl : v:VarData -> st:SimplePickle.QuotationPickleOutState -> unit + val p_recdFieldSpec : + NamedTypeData * string -> st:SimplePickle.QuotationPickleOutState -> unit + val p_ucaseSpec : + NamedTypeData * string -> st:SimplePickle.QuotationPickleOutState -> unit + val p_MethodData : + a:MethodData -> st:SimplePickle.QuotationPickleOutState -> unit + val p_CtorData : + a:CtorData -> st:SimplePickle.QuotationPickleOutState -> unit + val p_PropInfoData : + NamedTypeData * string * TypeData * TypeData list -> + st:SimplePickle.QuotationPickleOutState -> unit + val p_CombOp : x:CombOp -> st:SimplePickle.QuotationPickleOutState -> unit + val p_expr : x:ExprData -> st:SimplePickle.QuotationPickleOutState -> unit + type ModuleDefnData = + { Module: NamedTypeData + Name: string + IsProperty: bool } + type MethodBaseData = + | ModuleDefn of ModuleDefnData * (string * int) option + | Method of MethodData + | Ctor of CtorData + val pickle : (ExprData -> byte []) + val p_MethodBase : + x:MethodBaseData -> st:SimplePickle.QuotationPickleOutState -> unit + val PickleDefns : ((MethodBaseData * ExprData) list -> byte []) + end + +namespace FSharp.Compiler + module CompilerGlobalState = begin + type NiceNameGenerator = + class + new : unit -> NiceNameGenerator + member + FreshCompilerGeneratedName : name:string * m:Range.range -> string + member Reset : unit -> unit + end + type StableNiceNameGenerator = + class + new : unit -> StableNiceNameGenerator + member + GetUniqueCompilerGeneratedName : name:string * m:Range.range * + uniq:int64 -> string + member Reset : unit -> unit + end + type internal CompilerGlobalState = + class + new : unit -> CompilerGlobalState + member IlxGenNiceNameGenerator : NiceNameGenerator + member NiceNameGenerator : NiceNameGenerator + member StableNameGenerator : StableNiceNameGenerator + end + type Unique = int64 + val newUnique : (unit -> int64) + val newStamp : (unit -> int64) + end + +namespace FSharp.Compiler + module internal TypedTree = begin + type Stamp = int64 + and StampMap<'T> = Map + [] + and ValInline = + | PseudoVal + | Always + | Optional + | Never + with + member MustInline : bool + end + and ValRecursiveScopeInfo = + | ValInRecScope of bool + | ValNotInRecScope + and ValMutability = + | Immutable + | Mutable + [] + and TyparDynamicReq = + | No + | Yes + and ValBaseOrThisInfo = + | CtorThisVal + | BaseVal + | NormalVal + | MemberThisVal + [] + and ValFlags = + struct + new : recValInfo:ValRecursiveScopeInfo * baseOrThis:ValBaseOrThisInfo * + isCompGen:bool * inlineInfo:ValInline * isMutable:ValMutability * + isModuleOrMemberBinding:bool * isExtensionMember:bool * + isIncrClassSpecialMember:bool * isTyFunc:bool * allowTypeInst:bool * + isGeneratedEventVal:bool -> ValFlags + new : flags:int64 -> ValFlags + member SetIsCompilerGenerated : isCompGen:bool -> ValFlags + member + WithRecursiveValInfo : recValInfo:ValRecursiveScopeInfo -> ValFlags + member BaseOrThisInfo : ValBaseOrThisInfo + member HasBeenReferenced : bool + member IgnoresByrefScope : bool + member InlineInfo : ValInline + member IsCompiledAsStaticPropertyWithoutField : bool + member IsCompilerGenerated : bool + member IsExtensionMember : bool + member IsFixed : bool + member IsGeneratedEventVal : bool + member IsIncrClassSpecialMember : bool + member IsMemberOrModuleBinding : bool + member IsTypeFunction : bool + member MakesNoCriticalTailcalls : bool + member MutabilityInfo : ValMutability + member PermitsExplicitTypeInstantiation : bool + member PickledBits : int64 + member RecursiveValInfo : ValRecursiveScopeInfo + member WithHasBeenReferenced : ValFlags + member WithIgnoresByrefScope : ValFlags + member WithIsCompiledAsStaticPropertyWithoutField : ValFlags + member WithIsFixed : ValFlags + member WithIsMemberOrModuleBinding : ValFlags + member WithMakesNoCriticalTailcalls : ValFlags + end + [] + and TyparKind = + | Type + | Measure + with + override ToString : unit -> string + member AttrName : string voption + end + [] + and TyparRigidity = + | Rigid + | WillBeRigid + | WarnIfNotRigid + | Flexible + | Anon + with + member ErrorIfUnified : bool + member WarnIfMissingConstraint : bool + member WarnIfUnified : bool + end + [] + and TyparFlags = + struct + new : kind:TyparKind * rigidity:TyparRigidity * isFromError:bool * + isCompGen:bool * staticReq:SyntaxTree.TyparStaticReq * + dynamicReq:TyparDynamicReq * equalityDependsOn:bool * + comparisonDependsOn:bool -> TyparFlags + new : flags:int32 -> TyparFlags + member WithCompatFlex : b:bool -> TyparFlags + member ComparisonConditionalOn : bool + member DynamicReq : TyparDynamicReq + member EqualityConditionalOn : bool + member IsCompatFlex : bool + member IsCompilerGenerated : bool + member IsFromError : bool + member Kind : TyparKind + member PickledBits : int32 + member Rigidity : TyparRigidity + member StaticReq : SyntaxTree.TyparStaticReq + end + [] + and EntityFlags = + struct + new : usesPrefixDisplay:bool * isModuleOrNamespace:bool * + preEstablishedHasDefaultCtor:bool * hasSelfReferentialCtor:bool * + isStructRecordOrUnionType:bool -> EntityFlags + new : flags:int64 -> EntityFlags + member WithIsAssumedReadOnly : flag:bool -> EntityFlags + member WithIsByRefLike : flag:bool -> EntityFlags + member WithIsReadOnly : flag:bool -> EntityFlags + member HasSelfReferentialConstructor : bool + member IsModuleOrNamespace : bool + member IsPrefixDisplay : bool + member IsStructRecordOrUnionType : bool + member PickledBits : int64 + member PreEstablishedHasDefaultConstructor : bool + member TryIsAssumedReadOnly : bool voption + member TryIsByRefLike : bool voption + member TryIsReadOnly : bool voption + static member ReservedBitForPickleFormatTyconReprFlag : int64 + end + and UndefinedName = + with + inherit exn + interface System.Collections.IStructuralEquatable + val Data0: int + val Data1: string -> string + val Data2: SyntaxTree.Ident + val Data3: ErrorLogger.Suggestions + end + and InternalUndefinedItemRef = + with + inherit exn + interface System.Collections.IStructuralEquatable + val Data0: string * string * string -> int * string + val Data1: string + val Data2: string + val Data3: string + end + and ModuleOrNamespaceKind = + | FSharpModuleWithSuffix + | ModuleOrType + | Namespace + and PublicPath = + | PubPath of string [] + with + member EnclosingPath : string [] + end + and CompilationPath = + | CompPath of + AbstractIL.IL.ILScopeRef * (string * ModuleOrNamespaceKind) list + with + static member + DemangleEntityName : nm:string -> k:ModuleOrNamespaceKind -> string + member + NestedCompPath : n:string -> + modKind:ModuleOrNamespaceKind -> CompilationPath + member NestedPublicPath : id:SyntaxTree.Ident -> PublicPath + member AccessPath : (string * ModuleOrNamespaceKind) list + member DemangledPath : string list + member ILScopeRef : AbstractIL.IL.ILScopeRef + member MangledPath : string list + member ParentCompPath : CompilationPath + end + [] + and EntityOptionalData = + { mutable entity_compiled_name: string option + mutable entity_other_range: (Range.range * bool) option + mutable entity_kind: TyparKind + mutable entity_xmldoc: XmlDoc.XmlDoc + mutable entity_xmldocsig: string + mutable entity_tycon_abbrev: TType option + mutable entity_tycon_repr_accessibility: Accessibility + mutable entity_accessibility: Accessibility + mutable entity_exn_info: ExceptionInfo } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and Entity = + { mutable entity_typars: + AbstractIL.Internal.Library.LazyWithContext + mutable entity_flags: EntityFlags + mutable entity_stamp: Stamp + mutable entity_logical_name: string + mutable entity_range: Range.range + mutable entity_attribs: Attribs + mutable entity_tycon_repr: TyconRepresentation + mutable entity_tycon_tcaug: TyconAugmentation + mutable entity_modul_contents: Lib.MaybeLazy + mutable entity_pubpath: PublicPath option + mutable entity_cpath: CompilationPath option + mutable entity_il_repr_cache: Lib.cache + mutable entity_opt_data: EntityOptionalData option } + with + static member New : _reason:'b -> data:Entity -> Entity + static member NewEmptyEntityOptData : unit -> EntityOptionalData + static member NewUnlinked : unit -> Entity + member + GetDisplayName : ?withStaticParameters:bool * ?withTypars:bool * + ?withUnderscoreTypars:bool -> string + member GetFieldByIndex : n:int -> RecdField + member GetFieldByName : n:string -> RecdField option + member GetUnionCaseByName : n:string -> UnionCase option + member Link : tg:EntityData -> unit + member SetAttribs : attribs:Attribs -> unit + member SetCompiledName : name:string option -> unit + member SetExceptionInfo : exn_info:ExceptionInfo -> unit + member SetIsAssumedReadOnly : b:bool -> unit + member SetIsByRefLike : b:bool -> unit + member SetIsReadOnly : b:bool -> unit + member SetIsStructRecordOrUnion : b:bool -> unit + member SetOtherRange : m:(Range.range * bool) -> unit + member SetTypeAbbrev : tycon_abbrev:TType option -> unit + member SetTypeOrMeasureKind : kind:TyparKind -> unit + override ToString : unit -> string + member Typars : m:Range.range -> Typars + member Accessibility : Accessibility + member AllFieldTable : TyconRecdFields + member AllFieldsArray : RecdField [] + member AllFieldsAsList : RecdField list + member AllGeneratedValues : ValRef list + member AllInstanceFieldsAsList : RecdField list + member Attribs : Attribs + member CompilationPath : CompilationPath + member CompilationPathOpt : CompilationPath option + member CompiledName : string + member CompiledReprCache : Lib.cache + member CompiledRepresentation : CompiledTypeRepr + member CompiledRepresentationForNamedType : AbstractIL.IL.ILTypeRef + [ (0))>] + member DebugText : string + member DefinitionRange : Range.range + member DemangledModuleOrNamespaceName : string + member DisplayName : string + member DisplayNameWithStaticParameters : string + member DisplayNameWithStaticParametersAndTypars : string + member DisplayNameWithStaticParametersAndUnderscoreTypars : string + member EntityCompiledName : string option + member ExceptionInfo : ExceptionInfo + member FSharpObjectModelTypeInfo : TyconObjModelData + member GeneratedCompareToValues : (ValRef * ValRef) option + member GeneratedCompareToWithComparerValues : ValRef option + member GeneratedHashAndEqualsValues : (ValRef * ValRef) option + member + GeneratedHashAndEqualsWithComparerValues : (ValRef * ValRef * ValRef) option + member HasSelfReferentialConstructor : bool + member ILTyconInfo : TILObjectReprData + member ILTyconRawMetadata : AbstractIL.IL.ILTypeDef + member Id : SyntaxTree.Ident + member ImmediateInterfaceTypesOfFSharpTycon : TType list + member + ImmediateInterfacesOfFSharpTycon : (TType * bool * Range.range) list + member IsAsmReprTycon : bool + member IsEnumTycon : bool + member IsErased : bool + member IsExceptionDecl : bool + member IsFSharpClassTycon : bool + member IsFSharpDelegateTycon : bool + member IsFSharpEnumTycon : bool + member IsFSharpInterfaceTycon : bool + member IsFSharpObjectModelTycon : bool + member IsFSharpStructOrEnumTycon : bool + member IsHiddenReprTycon : bool + member IsILEnumTycon : bool + member IsILStructOrEnumTycon : bool + member IsILTycon : bool + member IsLinked : bool + member IsMeasureableReprTycon : bool + member IsModule : bool + member IsModuleOrNamespace : bool + member IsNamespace : bool + member IsPrefixDisplay : bool + member IsProvided : bool + member IsProvidedErasedTycon : bool + member IsProvidedGeneratedTycon : bool + member IsProvidedNamespace : bool + member IsRecordTycon : bool + member IsStaticInstantiationTycon : bool + member IsStructOrEnumTycon : bool + member IsStructRecordOrUnionTycon : bool + member IsTypeAbbrev : bool + member IsUnionTycon : bool + member LogicalName : string + member + MembersOfFSharpTyconByName : AbstractIL.Internal.Library.NameMultiMap + member MembersOfFSharpTyconSorted : ValRef list + member ModuleOrNamespaceType : ModuleOrNamespaceType + member PreEstablishedHasDefaultConstructor : bool + member PublicPath : PublicPath option + member Range : Range.range + member SigRange : Range.range + member Stamp : Stamp + member TrueFieldsAsList : RecdField list + member TrueInstanceFieldsAsList : RecdField list + member TryIsAssumedReadOnly : bool voption + member TryIsByRefLike : bool voption + member TryIsReadOnly : bool voption + member TyparsNoRange : Typars + member TypeAbbrev : TType option + member TypeContents : TyconAugmentation + member TypeOrMeasureKind : TyparKind + member TypeReprAccessibility : Accessibility + member TypeReprInfo : TyconRepresentation + member UnionCasesArray : UnionCase [] + member UnionCasesAsList : UnionCase list + member UnionTypeInfo : TyconUnionData voption + member XmlDoc : XmlDoc.XmlDoc + member XmlDocSig : string + end + and EntityData = Entity + and ParentRef = + | Parent of EntityRef + | ParentNone + [] + and CompiledTypeRepr = + | ILAsmNamed of + AbstractIL.IL.ILTypeRef * AbstractIL.IL.ILBoxity * + AbstractIL.IL.ILType option + | ILAsmOpen of AbstractIL.IL.ILType + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and TyconAugmentation = + { mutable tcaug_compare: (ValRef * ValRef) option + mutable tcaug_compare_withc: ValRef option + mutable tcaug_equals: (ValRef * ValRef) option + mutable tcaug_hash_and_equals_withc: (ValRef * ValRef * ValRef) option + mutable tcaug_hasObjectGetHashCode: bool + tcaug_adhoc_list: ResizeArray + mutable tcaug_adhoc: AbstractIL.Internal.Library.NameMultiMap + mutable tcaug_interfaces: (TType * bool * Range.range) list + mutable tcaug_super: TType option + mutable tcaug_closed: bool + mutable tcaug_abstract: bool } + with + static member Create : unit -> TyconAugmentation + member SetCompare : x:(ValRef * ValRef) -> unit + member SetCompareWith : x:ValRef -> unit + member SetEquals : x:(ValRef * ValRef) -> unit + member SetHasObjectGetHashCode : b:bool -> unit + member SetHashAndEqualsWith : x:(ValRef * ValRef * ValRef) -> unit + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and TyconRepresentation = + | TFSharpObjectRepr of TyconObjModelData + | TRecdRepr of TyconRecdFields + | TUnionRepr of TyconUnionData + | TILObjectRepr of TILObjectReprData + | TAsmRepr of AbstractIL.IL.ILType + | TMeasureableRepr of TType + | TProvidedTypeExtensionPoint of TProvidedTypeInfo + | TProvidedNamespaceExtensionPoint of + ExtensionTyping.ResolutionEnvironment * + Tainted list + | TNoRepr + with + override ToString : unit -> string + end + [] + and TILObjectReprData = + | TILObjectReprData of + scope: AbstractIL.IL.ILScopeRef * nesting: AbstractIL.IL.ILTypeDef list * + definition: AbstractIL.IL.ILTypeDef + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and TProvidedTypeInfo = + { ResolutionEnvironment: ExtensionTyping.ResolutionEnvironment + ProvidedType: Tainted + LazyBaseType: + AbstractIL.Internal.Library.LazyWithContext + IsClass: bool + IsSealed: bool + IsAbstract: bool + IsInterface: bool + IsStructOrEnum: bool + IsEnum: bool + UnderlyingTypeOfEnum: unit -> TType + IsDelegate: unit -> bool + IsErased: bool + IsSuppressRelocate: bool } + with + member BaseTypeForErased : m:Range.range * objTy:TType -> TType + override ToString : unit -> string + [ (0))>] + member DebugText : string + member IsGenerated : bool + end + and TyconObjModelKind = + | TTyconClass + | TTyconInterface + | TTyconStruct + | TTyconDelegate of SlotSig + | TTyconEnum + with + member IsValueType : bool + end + [] + and TyconObjModelData = + { fsobjmodel_kind: TyconObjModelKind + fsobjmodel_vslots: ValRef list + fsobjmodel_rfields: TyconRecdFields } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and TyconRecdFields = + { FieldsByIndex: RecdField [] + FieldsByName: AbstractIL.Internal.Library.NameMap } + with + member FieldByIndex : n:int -> RecdField + member FieldByName : nm:string -> RecdField option + override ToString : unit -> string + member AllFieldsAsList : RecdField list + [ (0))>] + member DebugText : string + member TrueFieldsAsList : RecdField list + member TrueInstanceFieldsAsList : RecdField list + end + [] + and TyconUnionCases = + { CasesByIndex: UnionCase [] + CasesByName: AbstractIL.Internal.Library.NameMap } + with + member GetUnionCaseByIndex : n:int -> UnionCase + override ToString : unit -> string + [ (0))>] + member DebugText : string + member UnionCasesAsList : UnionCase list + end + [] + and TyconUnionData = + { CasesTable: TyconUnionCases + CompiledRepresentation: + Lib.cache } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + member UnionCasesAsList : UnionCase list + end + [] + and UnionCase = + { FieldTable: TyconRecdFields + ReturnType: TType + XmlDoc: XmlDoc.XmlDoc + mutable XmlDocSig: string + Id: SyntaxTree.Ident + mutable OtherRangeOpt: (Range.range * bool) option + Accessibility: Accessibility + mutable Attribs: Attribs } + with + member GetFieldByIndex : n:int -> RecdField + member GetFieldByName : nm:string -> RecdField option + override ToString : unit -> string + member CompiledName : string + [ (0))>] + member DebugText : string + member DefinitionRange : Range.range + member DisplayName : string + member IsNullary : bool + member Range : Range.range + member RecdFields : RecdField list + member RecdFieldsArray : RecdField [] + member SigRange : Range.range + end + [] + and RecdField = + { rfield_mutable: bool + rfield_xmldoc: XmlDoc.XmlDoc + mutable rfield_xmldocsig: string + rfield_type: TType + rfield_static: bool + rfield_volatile: bool + rfield_secret: bool + rfield_const: Const option + rfield_access: Accessibility + mutable rfield_pattribs: Attribs + mutable rfield_fattribs: Attribs + rfield_id: SyntaxTree.Ident + rfield_name_generated: bool + mutable rfield_other_range: (Range.range * bool) option } + with + override ToString : unit -> string + member Accessibility : Accessibility + [ (0))>] + member DebugText : string + member DefinitionRange : Range.range + member FieldAttribs : Attribs + member FormalType : TType + member Id : SyntaxTree.Ident + member IsCompilerGenerated : bool + member IsMutable : bool + member IsStatic : bool + member IsVolatile : bool + member IsZeroInit : bool + member LiteralValue : Const option + member Name : string + member PropertyAttribs : Attribs + member Range : Range.range + member SigRange : Range.range + member XmlDoc : XmlDoc.XmlDoc + member XmlDocSig : string + end + [] + and ExceptionInfo = + | TExnAbbrevRepr of TyconRef + | TExnAsmRepr of AbstractIL.IL.ILTypeRef + | TExnFresh of TyconRecdFields + | TExnNone + with + override ToString : unit -> string + end + [] + and ModuleOrNamespaceType = + class + new : kind:ModuleOrNamespaceKind * + vals:Internal.Utilities.QueueList * + entities:Internal.Utilities.QueueList -> + ModuleOrNamespaceType + member AddEntity : tycon:Tycon -> ModuleOrNamespaceType + member AddModuleOrNamespaceByMutation : modul:ModuleOrNamespace -> unit + member AddProvidedTypeEntity : entity:Entity -> unit + member AddVal : vspec:Val -> ModuleOrNamespaceType + override ToString : unit -> string + member TryLinkVal : ccu:CcuThunk * key:ValLinkageFullKey -> Val voption + member + ActivePatternElemRefLookupTable : AbstractIL.Internal.Library.NameMap option ref + member AllEntities : Internal.Utilities.QueueList + member + AllEntitiesByCompiledAndLogicalMangledNames : AbstractIL.Internal.Library.NameMap + member + AllEntitiesByLogicalMangledName : AbstractIL.Internal.Library.NameMap + member AllValsAndMembers : Internal.Utilities.QueueList + member + AllValsAndMembersByLogicalNameUncached : AbstractIL.Internal.Library.MultiMap + member + AllValsAndMembersByPartialLinkageKey : AbstractIL.Internal.Library.MultiMap + member AllValsByLogicalName : AbstractIL.Internal.Library.NameMap + [ (0))>] + member DebugText : string + member ExceptionDefinitions : Entity list + member + ExceptionDefinitionsByDemangledName : AbstractIL.Internal.Library.NameMap + member ModuleAndNamespaceDefinitions : Entity list + member ModuleOrNamespaceKind : ModuleOrNamespaceKind + member + ModulesAndNamespacesByDemangledName : AbstractIL.Internal.Library.NameMap + member TypeAndExceptionDefinitions : Entity list + member TypeDefinitions : Entity list + member + TypesByAccessNames : AbstractIL.Internal.Library.LayeredMultiMap + member + TypesByDemangledNameAndArity : AbstractIL.Internal.Library.LayeredMap + member TypesByMangledName : AbstractIL.Internal.Library.NameMap + end + and ModuleOrNamespace = Entity + and Tycon = Entity + [] + and Accessibility = + | TAccess of CompilationPath list + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and TyparOptionalData = + { mutable typar_il_name: string option + mutable typar_xmldoc: XmlDoc.XmlDoc + mutable typar_constraints: TyparConstraint list + mutable typar_attribs: Attribs } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + and TyparData = Typar + [] + and Typar = + { mutable typar_id: SyntaxTree.Ident + mutable typar_flags: TyparFlags + mutable typar_stamp: Stamp + mutable typar_solution: TType option + mutable typar_astype: TType + mutable typar_opt_data: TyparOptionalData option } + with + static member New : data:TyparData -> Typar + static member NewUnlinked : unit -> Typar + member Link : tg:TyparData -> unit + member SetAttribs : attribs:Attrib list -> unit + member SetComparisonDependsOn : b:bool -> unit + member SetCompilerGenerated : b:bool -> unit + member SetConstraints : cs:TyparConstraint list -> unit + member SetDynamicReq : b:TyparDynamicReq -> unit + member SetEqualityDependsOn : b:bool -> unit + member SetILName : il_name:string option -> unit + member SetIdent : id:SyntaxTree.Ident -> unit + member SetIsCompatFlex : b:bool -> unit + member SetRigidity : b:TyparRigidity -> unit + member SetStaticReq : b:SyntaxTree.TyparStaticReq -> unit + override ToString : unit -> string + member AsType : TType + member Attribs : Attribs + member ComparisonConditionalOn : bool + member Constraints : TyparConstraint list + [ (0))>] + member DebugText : string + member DisplayName : string + member DynamicReq : TyparDynamicReq + member EqualityConditionalOn : bool + member ILName : string option + member Id : SyntaxTree.Ident + member IsCompatFlex : bool + member IsCompilerGenerated : bool + member IsErased : bool + member IsFromError : bool + member IsLinked : bool + member IsSolved : bool + member Kind : TyparKind + member Name : string + member Range : Range.range + member Rigidity : TyparRigidity + member Solution : TType option + member Stamp : Stamp + member StaticReq : SyntaxTree.TyparStaticReq + member XmlDoc : XmlDoc.XmlDoc + end + [] + and TyparConstraint = + | CoercesTo of TType * Range.range + | DefaultsTo of int * TType * Range.range + | SupportsNull of Range.range + | MayResolveMember of TraitConstraintInfo * Range.range + | IsNonNullableStruct of Range.range + | IsReferenceType of Range.range + | SimpleChoice of TTypes * Range.range + | RequiresDefaultConstructor of Range.range + | IsEnum of TType * Range.range + | SupportsComparison of Range.range + | SupportsEquality of Range.range + | IsDelegate of TType * TType * Range.range + | IsUnmanaged of Range.range + with + override ToString : unit -> string + end + [] + and TraitWitnessInfo = + | TraitWitnessInfo of + TTypes * string * SyntaxTree.MemberFlags * TTypes * TType option + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + member MemberName : string + member ReturnType : TType option + end + [] + and TraitConstraintInfo = + | TTrait of + tys: TTypes * memberName: string * _memFlags: SyntaxTree.MemberFlags * + argTys: TTypes * returnTy: TType option * + solution: TraitConstraintSln option ref + with + override ToString : unit -> string + member ArgumentTypes : TTypes + [ (0))>] + member DebugText : string + member MemberFlags : SyntaxTree.MemberFlags + member MemberName : string + member ReturnType : TType option + member Solution : TraitConstraintSln option + member TraitKey : TraitWitnessInfo + end + [] + and TraitConstraintSln = + | FSMethSln of TType * ValRef * TypeInst + | FSRecdFieldSln of TypeInst * RecdFieldRef * bool + | FSAnonRecdFieldSln of AnonRecdTypeInfo * TypeInst * int + | ILMethSln of + TType * AbstractIL.IL.ILTypeRef option * AbstractIL.IL.ILMethodRef * + TypeInst + | ClosedExprSln of Expr + | BuiltInSln + with + override ToString : unit -> string + end + [] + and ValLinkagePartialKey = + { MemberParentMangledName: string option + MemberIsOverride: bool + LogicalName: string + TotalArgCount: int } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and ValLinkageFullKey = + class + new : partialKey:ValLinkagePartialKey * typeForLinkage:TType option -> + ValLinkageFullKey + override ToString : unit -> string + [ (0))>] + member DebugText : string + member PartialKey : ValLinkagePartialKey + member TypeForLinkage : TType option + end + [] + and ValOptionalData = + { mutable val_compiled_name: string option + mutable val_other_range: (Range.range * bool) option + mutable val_const: Const option + mutable val_defn: Expr option + mutable val_repr_info: ValReprInfo option + mutable val_access: Accessibility + mutable val_xmldoc: XmlDoc.XmlDoc + mutable val_member_info: ValMemberInfo option + mutable val_declaring_entity: ParentRef + mutable val_xmldocsig: string + mutable val_attribs: Attribs } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + and ValData = Val + [] + and Val = + { mutable val_logical_name: string + mutable val_range: Range.range + mutable val_type: TType + mutable val_stamp: Stamp + mutable val_flags: ValFlags + mutable val_opt_data: ValOptionalData option } + with + static member New : data:Val -> Val + static member NewEmptyValOptData : unit -> ValOptionalData + static member NewUnlinked : unit -> Val + member + CompiledName : compilerGlobalState:CompilerGlobalState.CompilerGlobalState option -> + string + member GetLinkageFullKey : unit -> ValLinkageFullKey + member GetLinkagePartialKey : unit -> ValLinkagePartialKey + member Link : tg:ValData -> unit + member SetAttribs : attribs:Attribs -> unit + member SetData : tg:ValData -> unit + member SetDeclaringEntity : parent:ParentRef -> unit + member SetHasBeenReferenced : unit -> unit + member SetIgnoresByrefScope : unit -> unit + member SetIsCompiledAsStaticPropertyWithoutField : unit -> unit + member SetIsFixed : unit -> unit + member SetIsMemberOrModuleBinding : unit -> unit + member SetMakesNoCriticalTailcalls : unit -> unit + member SetMemberInfo : member_info:ValMemberInfo -> unit + member SetOtherRange : m:(Range.range * bool) -> unit + member SetType : ty:TType -> unit + member SetValDefn : val_defn:Expr -> unit + member SetValRec : b:ValRecursiveScopeInfo -> unit + member SetValReprInfo : info:ValReprInfo option -> unit + override ToString : unit -> string + member Accessibility : Accessibility + member ApparentEnclosingEntity : ParentRef + member Attribs : Attrib list + member BaseOrThisInfo : ValBaseOrThisInfo + member CoreDisplayName : string + [ (0))>] + member DebugText : string + member DeclaringEntity : ParentRef + member DefinitionRange : Range.range + member DisplayName : string + member HasBeenReferenced : bool + member HasDeclaringEntity : bool + member Id : SyntaxTree.Ident + member IgnoresByrefScope : bool + member InlineInfo : ValInline + member IsClassConstructor : bool + member IsCompiledAsStaticPropertyWithoutField : bool + member IsCompiledAsTopLevel : bool + member IsCompiledIntoModule : bool + member IsCompilerGenerated : bool + member IsConstructor : bool + member IsDispatchSlot : bool + member IsExtensionMember : bool + member IsFixed : bool + member IsIncrClassConstructor : bool + member IsIncrClassGeneratedMember : bool + member IsInstanceMember : bool + member IsIntrinsicMember : bool + member IsLinked : bool + member IsMember : bool + member IsMemberOrModuleBinding : bool + member IsModuleBinding : bool + member IsMutable : bool + member IsOverrideOrExplicitImpl : bool + member IsTypeFunction : bool + member LiteralValue : Const option + member LogicalName : string + member MakesNoCriticalTailcalls : bool + member MemberApparentEntity : TyconRef + member MemberInfo : ValMemberInfo option + member MustInline : bool + member NumObjArgs : int + member PermitsExplicitTypeInstantiation : bool + member PropertyName : string + member PublicPath : ValPublicPath option + member Range : Range.range + member RecursiveValInfo : ValRecursiveScopeInfo + member ReflectedDefinition : Expr option + member SigRange : Range.range + member Stamp : Stamp + member TauType : TType + member TopValDeclaringEntity : EntityRef + member Typars : Typars + member Type : TType + member TypeScheme : Typars * TType + member ValCompiledName : string option + member ValReprInfo : ValReprInfo option + member XmlDoc : XmlDoc.XmlDoc + member XmlDocSig : string + end + [] + and ValMemberInfo = + { ApparentEnclosingEntity: TyconRef + mutable ImplementedSlotSigs: SlotSig list + mutable IsImplemented: bool + MemberFlags: SyntaxTree.MemberFlags } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and NonLocalValOrMemberRef = + { EnclosingEntity: EntityRef + ItemKey: ValLinkageFullKey } + with + override ToString : unit -> string + member AssemblyName : string + member Ccu : CcuThunk + [ (0))>] + member DebugText : string + end + [] + and ValPublicPath = + | ValPubPath of PublicPath * ValLinkageFullKey + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and NonLocalEntityRef = + | NonLocalEntityRef of CcuThunk * string [] + with + static member + TryDerefEntityPath : ccu:CcuThunk * path:string [] * i:int * + entity:Entity -> Entity voption + static member + TryDerefEntityPathViaProvidedType : ccu:CcuThunk * path:string [] * + i:int * entity:Entity -> + Entity voption + override ToString : unit -> string + member TryDeref : canError:bool -> Entity voption + member AssemblyName : string + member Ccu : CcuThunk + [ (0))>] + member DebugText : string + member Deref : Entity + member DisplayName : string + member EnclosingMangledPath : string [] + member LastItemMangledName : string + member ModuleOrNamespaceType : ModuleOrNamespaceType + member Path : string [] + end + [] + and EntityRef = + { mutable binding: Lib.NonNullSlot + nlr: NonLocalEntityRef } + with + member GetFieldByIndex : n:int -> RecdField + member GetFieldByName : n:string -> RecdField option + member GetUnionCaseByName : n:string -> UnionCase option + member MakeNestedRecdFieldRef : rf:RecdField -> RecdFieldRef + member MakeNestedUnionCaseRef : uc:UnionCase -> UnionCaseRef + member private Resolve : canError:bool -> unit + member SetIsAssumedReadOnly : b:bool -> unit + member SetIsByRefLike : b:bool -> unit + member SetIsReadOnly : b:bool -> unit + override ToString : unit -> string + member Typars : m:Range.range -> Typars + member Accessibility : Accessibility + member AllFieldAsRefList : RecdFieldRef list + member AllFieldTable : TyconRecdFields + member AllFieldsArray : RecdField [] + member AllFieldsAsList : RecdField list + member AllInstanceFieldsAsList : RecdField list + member Attribs : Attribs + member CanDeref : bool + member CompilationPath : CompilationPath + member CompilationPathOpt : CompilationPath option + member CompiledName : string + member CompiledReprCache : Lib.cache + member CompiledRepresentation : CompiledTypeRepr + member CompiledRepresentationForNamedType : AbstractIL.IL.ILTypeRef + [ (0))>] + member DebugText : string + member DefinitionRange : Range.range + member DemangledModuleOrNamespaceName : string + member Deref : Entity + member DisplayName : string + member DisplayNameWithStaticParameters : string + member DisplayNameWithStaticParametersAndTypars : string + member DisplayNameWithStaticParametersAndUnderscoreTypars : string + member ExceptionInfo : ExceptionInfo + member FSharpObjectModelTypeInfo : TyconObjModelData + member GeneratedCompareToValues : (ValRef * ValRef) option + member GeneratedCompareToWithComparerValues : ValRef option + member GeneratedHashAndEqualsValues : (ValRef * ValRef) option + member + GeneratedHashAndEqualsWithComparerValues : (ValRef * ValRef * ValRef) option + member HasSelfReferentialConstructor : bool + member ILTyconInfo : TILObjectReprData + member ILTyconRawMetadata : AbstractIL.IL.ILTypeDef + member Id : SyntaxTree.Ident + member ImmediateInterfaceTypesOfFSharpTycon : TType list + member + ImmediateInterfacesOfFSharpTycon : (TType * bool * Range.range) list + member IsAsmReprTycon : bool + member IsEnumTycon : bool + member IsErased : bool + member IsExceptionDecl : bool + member IsFSharpDelegateTycon : bool + member IsFSharpEnumTycon : bool + member IsFSharpInterfaceTycon : bool + member IsFSharpObjectModelTycon : bool + member IsFSharpStructOrEnumTycon : bool + member IsHiddenReprTycon : bool + member IsILEnumTycon : bool + member IsILStructOrEnumTycon : bool + member IsILTycon : bool + member IsLocalRef : bool + member IsMeasureableReprTycon : bool + member IsModule : bool + member IsModuleOrNamespace : bool + member IsNamespace : bool + member IsPrefixDisplay : bool + member IsProvided : bool + member IsProvidedErasedTycon : bool + member IsProvidedGeneratedTycon : bool + member IsProvidedNamespace : bool + member IsRecordTycon : bool + member IsResolved : bool + member IsStaticInstantiationTycon : bool + member IsStructOrEnumTycon : bool + member IsTypeAbbrev : bool + member IsUnionTycon : bool + member LogicalName : string + member + MembersOfFSharpTyconByName : AbstractIL.Internal.Library.NameMultiMap + member MembersOfFSharpTyconSorted : ValRef list + member ModuleOrNamespaceType : ModuleOrNamespaceType + member PreEstablishedHasDefaultConstructor : bool + member PublicPath : PublicPath option + member Range : Range.range + member ResolvedTarget : Lib.NonNullSlot + member SigRange : Range.range + member Stamp : Stamp + member TrueFieldsAsList : RecdField list + member TrueInstanceFieldsAsList : RecdField list + member TrueInstanceFieldsAsRefList : RecdFieldRef list + member TryDeref : Lib.NonNullSlot voption + member TryIsAssumedReadOnly : bool voption + member TryIsByRefLike : bool voption + member TryIsReadOnly : bool voption + member TyparsNoRange : Typars + member TypeAbbrev : TType option + member TypeContents : TyconAugmentation + member TypeOrMeasureKind : TyparKind + member TypeReprAccessibility : Accessibility + member TypeReprInfo : TyconRepresentation + member UnionCasesArray : UnionCase [] + member UnionCasesAsList : UnionCase list + member UnionCasesAsRefList : UnionCaseRef list + member UnionTypeInfo : TyconUnionData voption + member XmlDoc : XmlDoc.XmlDoc + member XmlDocSig : string + end + and ModuleOrNamespaceRef = EntityRef + and TyconRef = EntityRef + [] + and ValRef = + { mutable binding: Lib.NonNullSlot + nlr: NonLocalValOrMemberRef } + with + override ToString : unit -> string + member Accessibility : Accessibility + member ApparentEnclosingEntity : ParentRef + member Attribs : Attrib list + member BaseOrThisInfo : ValBaseOrThisInfo + member + CompiledName : (CompilerGlobalState.CompilerGlobalState option -> + string) + member CoreDisplayName : string + [ (0))>] + member DebugText : string + member DeclaringEntity : ParentRef + member DefinitionRange : Range.range + member Deref : Val + member DisplayName : string + member HasDeclaringEntity : bool + member Id : SyntaxTree.Ident + member InlineInfo : ValInline + member IsCompiledAsTopLevel : bool + member IsCompilerGenerated : bool + member IsConstructor : bool + member IsDispatchSlot : bool + member IsExtensionMember : bool + member IsIncrClassConstructor : bool + member IsIncrClassGeneratedMember : bool + member IsInstanceMember : bool + member IsLocalRef : bool + member IsMember : bool + member IsMemberOrModuleBinding : bool + member IsModuleBinding : bool + member IsMutable : bool + member IsOverrideOrExplicitImpl : bool + member IsPropertyGetterMethod : bool + member IsPropertySetterMethod : bool + member IsResolved : bool + member IsTypeFunction : bool + member LiteralValue : Const option + member LogicalName : string + member MakesNoCriticalTailcalls : bool + member MemberApparentEntity : TyconRef + member MemberInfo : ValMemberInfo option + member MustInline : bool + member NumObjArgs : int + member PermitsExplicitTypeInstantiation : bool + member PropertyName : string + member PublicPath : ValPublicPath option + member Range : Range.range + member RecursiveValInfo : ValRecursiveScopeInfo + member ReflectedDefinition : Expr option + member ResolvedTarget : Lib.NonNullSlot + member SigRange : Range.range + member Stamp : Stamp + member TauType : TType + member TopValDeclaringEntity : EntityRef + member TryDeref : Val voption + member Typars : Typars + member Type : TType + member TypeScheme : Typars * TType + member ValReprInfo : ValReprInfo option + member XmlDoc : XmlDoc.XmlDoc + member XmlDocSig : string + end + [] + and UnionCaseRef = + | UnionCaseRef of TyconRef * string + with + member FieldByIndex : n:int -> RecdField + override ToString : unit -> string + member AllFieldsAsList : RecdField list + member Attribs : Attribs + member CaseName : string + [ (0))>] + member DebugText : string + member DefinitionRange : Range.range + member Index : int + member Range : Range.range + member ReturnType : TType + member SigRange : Range.range + member TryUnionCase : UnionCase voption + member Tycon : Entity + member TyconRef : TyconRef + member UnionCase : UnionCase + end + [] + and RecdFieldRef = + | RecdFieldRef of TyconRef * string + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + member DefinitionRange : Range.range + member FieldName : string + member Index : int + member PropertyAttribs : Attribs + member Range : Range.range + member RecdField : RecdField + member SigRange : Range.range + member TryRecdField : RecdField voption + member Tycon : Entity + member TyconRef : TyconRef + end + [] + and TType = + | TType_forall of Typars * TType + | TType_app of TyconRef * TypeInst + | TType_anon of AnonRecdTypeInfo * TType list + | TType_tuple of TupInfo * TTypes + | TType_fun of TType * TType + | TType_ucase of UnionCaseRef * TypeInst + | TType_var of Typar + | TType_measure of Measure + with + member GetAssemblyName : unit -> string + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + and TypeInst = TType list + and TTypes = TType list + [] + and AnonRecdTypeInfo = + { mutable Assembly: CcuThunk + mutable TupInfo: TupInfo + mutable SortedIds: SyntaxTree.Ident [] + mutable Stamp: Stamp + mutable SortedNames: string [] } + with + static member + Create : ccu:CcuThunk * tupInfo:TupInfo * ids:SyntaxTree.Ident [] -> + AnonRecdTypeInfo + static member NewUnlinked : unit -> AnonRecdTypeInfo + member Link : d:AnonRecdTypeInfo -> unit + member ILTypeRef : AbstractIL.IL.ILTypeRef + member IsLinked : bool + end + [] + and TupInfo = | Const of bool + [] + and Measure = + | Var of Typar + | Con of TyconRef + | Prod of Measure * Measure + | Inv of Measure + | One + | RationalPower of Measure * Rational.Rational + with + override ToString : unit -> string + end + and Attribs = Attrib list + [] + and AttribKind = + | ILAttrib of AbstractIL.IL.ILMethodRef + | FSAttrib of ValRef + with + override ToString : unit -> string + end + [] + and Attrib = + | Attrib of + TyconRef * AttribKind * AttribExpr list * AttribNamedArg list * bool * + System.AttributeTargets option * Range.range + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + member Range : Range.range + member TyconRef : TyconRef + end + [] + and AttribExpr = + | AttribExpr of Expr * Expr + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and AttribNamedArg = + | AttribNamedArg of (string * TType * bool * AttribExpr) + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and Const = + | Bool of bool + | SByte of sbyte + | Byte of byte + | Int16 of int16 + | UInt16 of uint16 + | Int32 of int32 + | UInt32 of uint32 + | Int64 of int64 + | UInt64 of uint64 + | IntPtr of int64 + | UIntPtr of uint64 + | Single of single + | Double of double + | Char of char + | String of string + | Decimal of System.Decimal + | Unit + | Zero + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and DecisionTree = + | TDSwitch of + Expr * DecisionTreeCase list * DecisionTree option * Range.range + | TDSuccess of Exprs * int + | TDBind of Binding * DecisionTree + with + override ToString : unit -> string + end + [] + and DecisionTreeCase = + | TCase of DecisionTreeTest * DecisionTree + with + override ToString : unit -> string + member CaseTree : DecisionTree + [ (0))>] + member DebugText : string + member Discriminator : DecisionTreeTest + end + [] + and DecisionTreeTest = + | UnionCase of UnionCaseRef * TypeInst + | ArrayLength of int * TType + | Const of Const + | IsNull + | IsInst of TType * TType + | ActivePatternCase of + Expr * TTypes * (ValRef * TypeInst) option * int * + PrettyNaming.ActivePatternInfo + | Error of Range.range + with + override ToString : unit -> string + end + [] + and DecisionTreeTarget = + | TTarget of Val list * Expr * SyntaxTree.DebugPointForTarget + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + and Bindings = Binding list + [] + and Binding = + | TBind of Val * Expr * SyntaxTree.DebugPointForBinding + with + override ToString : unit -> string + member DebugPoint : SyntaxTree.DebugPointForBinding + [ (0))>] + member DebugText : string + member Expr : Expr + member Var : Val + end + [] + and ActivePatternElemRef = + | APElemRef of PrettyNaming.ActivePatternInfo * ValRef * int + with + override ToString : unit -> string + member ActivePatternInfo : PrettyNaming.ActivePatternInfo + member ActivePatternVal : ValRef + member CaseIndex : int + [ (0))>] + member DebugText : string + end + [] + and ValReprInfo = + | ValReprInfo of TyparReprInfo list * ArgReprInfo list list * ArgReprInfo + with + override ToString : unit -> string + member ArgInfos : ArgReprInfo list list + member ArgNames : string list option + member AritiesOfArgs : int list + [ (0))>] + member DebugText : string + member HasNoArgs : bool + member KindsOfTypars : TyparKind list + member NumCurriedArgs : int + member NumTypars : int + member TotalArgCount : int + end + [] + and ArgReprInfo = + { mutable Attribs: Attribs + mutable Name: SyntaxTree.Ident option } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + and TyparReprInfo = | TyparReprInfo of SyntaxTree.Ident * TyparKind + and Typars = Typar list + and Exprs = Expr list + and Vals = Val list + [] + and Expr = + | Const of value: Const * range: Range.range * constType: TType + | Val of valRef: ValRef * flags: ValUseFlag * range: Range.range + | Sequential of + expr1: Expr * expr2: Expr * kind: SequentialOpKind * + debugPoint: SyntaxTree.DebugPointAtSequential * range: Range.range + | Lambda of + unique: CompilerGlobalState.Unique * ctorThisValOpt: Val option * + baseValOpt: Val option * valParams: Val list * bodyExpr: Expr * + range: Range.range * overallType: TType + | TyLambda of + unique: CompilerGlobalState.Unique * typeParams: Typars * bodyExpr: Expr * + range: Range.range * overallType: TType + | App of + funcExpr: Expr * formalType: TType * typeArgs: TypeInst * args: Exprs * + range: Range.range + | LetRec of + bindings: Bindings * bodyExpr: Expr * range: Range.range * + frees: FreeVarsCache + | Let of + binding: Binding * bodyExpr: Expr * range: Range.range * + frees: FreeVarsCache + | Obj of + unique: CompilerGlobalState.Unique * objTy: TType * baseVal: Val option * + ctorCall: Expr * overrides: ObjExprMethod list * + interfaceImpls: (TType * ObjExprMethod list) list * range: Range.range + | Match of + debugPoint: SyntaxTree.DebugPointForBinding * inputRange: Range.range * + decision: DecisionTree * targets: DecisionTreeTarget array * + fullRange: Range.range * exprType: TType + | StaticOptimization of + conditions: StaticOptimization list * expr: Expr * alternativeExpr: Expr * + range: Range.range + | Op of op: TOp * typeArgs: TypeInst * args: Exprs * range: Range.range + | Quote of + quotedExpr: Expr * + quotationInfo: + ((AbstractIL.IL.ILTypeRef list * TTypes * Exprs * + QuotationPickler.ExprData) * + (AbstractIL.IL.ILTypeRef list * TTypes * Exprs * + QuotationPickler.ExprData)) option ref * isFromQueryExpression: bool * + range: Range.range * quotedType: TType + | WitnessArg of traitInfo: TraitConstraintInfo * range: Range.range + | TyChoose of typeParams: Typars * bodyExpr: Expr * range: Range.range + | Link of Expr ref + with + member ToDebugString : depth:int -> string + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and TOp = + | UnionCase of UnionCaseRef + | ExnConstr of TyconRef + | Tuple of TupInfo + | AnonRecd of AnonRecdTypeInfo + | AnonRecdGet of AnonRecdTypeInfo * int + | Array + | Bytes of byte [] + | UInt16s of uint16 [] + | While of SyntaxTree.DebugPointAtWhile * SpecialWhileLoopMarker + | For of SyntaxTree.DebugPointAtFor * ForLoopStyle + | TryWith of SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith + | TryFinally of + SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally + | Recd of RecordConstructionInfo * TyconRef + | ValFieldSet of RecdFieldRef + | ValFieldGet of RecdFieldRef + | ValFieldGetAddr of RecdFieldRef * readonly: bool + | UnionCaseTagGet of TyconRef + | UnionCaseProof of UnionCaseRef + | UnionCaseFieldGet of UnionCaseRef * int + | UnionCaseFieldGetAddr of UnionCaseRef * int * readonly: bool + | UnionCaseFieldSet of UnionCaseRef * int + | ExnFieldGet of TyconRef * int + | ExnFieldSet of TyconRef * int + | TupleFieldGet of TupInfo * int + | ILAsm of instrs: AbstractIL.IL.ILInstr list * retTypes: TTypes + | RefAddrGet of bool + | Coerce + | Reraise + | Return + | Goto of AbstractIL.IL.ILCodeLabel + | Label of AbstractIL.IL.ILCodeLabel + | TraitCall of TraitConstraintInfo + | LValueOp of LValueOperation * ValRef + | ILCall of + isVirtual: bool * isProtected: bool * isStruct: bool * isCtor: bool * + valUseFlag: ValUseFlag * isProperty: bool * noTailCall: bool * + ilMethRef: AbstractIL.IL.ILMethodRef * enclTypeInst: TypeInst * + methInst: TypeInst * retTypes: TTypes + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + and RecordConstructionInfo = + | RecdExprIsObjInit + | RecdExpr + and ConstrainedCallInfo = TType option + and SpecialWhileLoopMarker = + | NoSpecialWhileLoopMarker + | WhileLoopForCompiledForEachExprMarker + and ForLoopStyle = + | FSharpForLoopUp + | FSharpForLoopDown + | CSharpForLoopUp + and LValueOperation = + | LAddrOf of readonly: bool + | LByrefGet + | LSet + | LByrefSet + and SequentialOpKind = + | NormalSeq + | ThenDoSeq + and ValUseFlag = + | PossibleConstrainedCall of TType + | NormalValUse + | CtorValUsedAsSuperInit + | CtorValUsedAsSelfInit + | VSlotDirectCall + and StaticOptimization = + | TTyconEqualsTycon of TType * TType + | TTyconIsStruct of TType + [] + and ObjExprMethod = + | TObjExprMethod of + SlotSig * Attribs * Typars * Val list list * Expr * Range.range + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + member Id : SyntaxTree.Ident + end + [] + and SlotSig = + | TSlotSig of + methodName: string * implementedType: TType * classTypars: Typars * + methodTypars: Typars * formalParams: SlotParam list list * + formalReturn: TType option + with + override ToString : unit -> string + member ClassTypars : Typars + [ (0))>] + member DebugText : string + member FormalParams : SlotParam list list + member FormalReturnType : TType option + member ImplementedType : TType + member MethodTypars : Typars + member Name : string + end + [] + and SlotParam = + | TSlotParam of + paramName: string option * paramType: TType * isIn: bool * isOut: bool * + isOptional: bool * attributes: Attribs + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + member Type : TType + end + [] + and ModuleOrNamespaceExprWithSig = + | ModuleOrNamespaceExprWithSig of + moduleType: ModuleOrNamespaceType * contents: ModuleOrNamespaceExpr * + range: Range.range + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + member Type : ModuleOrNamespaceType + end + [] + and ModuleOrNamespaceExpr = + | TMAbstract of ModuleOrNamespaceExprWithSig + | TMDefs of ModuleOrNamespaceExpr list + | TMDefLet of Binding * Range.range + | TMDefDo of Expr * Range.range + | TMDefRec of + isRec: bool * Tycon list * ModuleOrNamespaceBinding list * Range.range + with + override ToString : unit -> string + member DebugText : string + end + [] + and ModuleOrNamespaceBinding = + | Binding of Binding + | Module of ModuleOrNamespace * ModuleOrNamespaceExpr + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and TypedImplFile = + | TImplFile of + SyntaxTree.QualifiedNameOfFile * SyntaxTree.ScopedPragma list * + ModuleOrNamespaceExprWithSig * bool * bool * StampMap + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and TypedImplFileAfterOptimization = + { ImplFile: TypedImplFile + OptimizeDuringCodeGen: bool -> Expr -> Expr } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and TypedAssemblyAfterOptimization = + | TypedAssemblyAfterOptimization of TypedImplFileAfterOptimization list + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and CcuData = + { FileName: string option + ILScopeRef: AbstractIL.IL.ILScopeRef + Stamp: Stamp + QualifiedName: string option + SourceCodeDirectory: string + IsFSharp: bool + IsProviderGenerated: bool + InvalidateEvent: IEvent + ImportProvidedType: Tainted -> TType + mutable UsesFSharp20PlusQuotations: bool + mutable Contents: ModuleOrNamespace + TryGetILModuleDef: unit -> AbstractIL.IL.ILModuleDef option + MemberSignatureEquality: TType -> TType -> bool + TypeForwarders: CcuTypeForwarderTable } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + and CcuTypeForwarderTable = Map<(string [] * string),System.Lazy> + and CcuReference = string + [] + and CcuThunk = + { mutable target: CcuData + name: CcuReference } + with + static member Create : nm:CcuReference * x:CcuData -> CcuThunk + static member CreateDelayed : nm:CcuReference -> CcuThunk + member EnsureDerefable : requiringPath:string [] -> unit + member Fixup : avail:CcuThunk -> unit + member + ImportProvidedType : ty:Tainted -> TType + member MemberSignatureEquality : ty1:TType * ty2:TType -> bool + override ToString : unit -> string + member TryForward : nlpath:string [] * item:string -> EntityRef option + member TryGetILModuleDef : unit -> AbstractIL.IL.ILModuleDef option + member AssemblyName : string + member Contents : Entity + [ (0))>] + member DebugText : string + member Deref : CcuData + member FileName : string option + member ILScopeRef : AbstractIL.IL.ILScopeRef + member IsFSharp : bool + member IsProviderGenerated : bool + member IsUnresolvedReference : bool + member QualifiedName : string option + member RootModulesAndNamespaces : Entity list + member RootTypeAndExceptionDefinitions : Entity list + member SourceCodeDirectory : string + member Stamp : Stamp + member TypeForwarders : Map<(string [] * string),System.Lazy> + member UsesFSharp20PlusQuotations : bool + end + [] + and CcuResolutionResult = + | ResolvedCcu of CcuThunk + | UnresolvedCcu of string + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + [] + and PickledCcuInfo = + { mspec: ModuleOrNamespace + compileTimeWorkingDir: string + usesQuotations: bool } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + and FreeLocals = AbstractIL.Internal.Zset + and FreeTypars = AbstractIL.Internal.Zset + and FreeTycons = AbstractIL.Internal.Zset + and FreeRecdFields = AbstractIL.Internal.Zset + and FreeUnionCases = AbstractIL.Internal.Zset + [] + and FreeTyvars = + { FreeTycons: FreeTycons + FreeTraitSolutions: FreeLocals + FreeTypars: FreeTypars } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + and FreeVarsCache = Lib.cache + [] + and FreeVars = + { FreeLocals: FreeLocals + UsesMethodLocalConstructs: bool + UsesUnboundRethrow: bool + FreeLocalTyconReprs: FreeTycons + FreeRecdFields: FreeRecdFields + FreeUnionCases: FreeUnionCases + FreeTyvars: FreeTyvars } + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + end + and Construct = + class + new : unit -> Construct + static member + ComputeDefinitionLocationOfProvidedItem : p:Tainted<#ExtensionTyping.IProvidedCustomAttributeProvider> -> + Range.range option + static member + KeyTyconByAccessNames : nm:string -> + x:'T -> + System.Collections.Generic.KeyValuePair [] + static member + KeyTyconByDecodedName : nm:string -> + x:'T -> + System.Collections.Generic.KeyValuePair + static member + MakeRecdFieldsTable : ucs:RecdField list -> TyconRecdFields + static member MakeUnionCases : ucs:UnionCase list -> TyconUnionData + static member MakeUnionRepr : ucs:UnionCase list -> TyconRepresentation + static member + NewCcuContents : sref:AbstractIL.IL.ILScopeRef -> + m:Range.range -> + nm:string -> + mty:ModuleOrNamespaceType -> ModuleOrNamespace + static member NewClonedModuleOrNamespace : orig:Tycon -> Entity + static member NewClonedTycon : orig:Tycon -> Entity + static member + NewEmptyModuleOrNamespaceType : mkind:ModuleOrNamespaceKind -> + ModuleOrNamespaceType + static member + NewExn : cpath:CompilationPath option -> + id:SyntaxTree.Ident -> + access:Accessibility -> + repr:ExceptionInfo -> + attribs:Attribs -> doc:XmlDoc.XmlDoc -> Entity + static member NewFreeVarsCache : unit -> Lib.cache<'a> + static member + NewILTycon : nlpath:CompilationPath option -> + nm:string * m:Range.range -> + tps:AbstractIL.Internal.Library.LazyWithContext -> + scoref:AbstractIL.IL.ILScopeRef * + enc:AbstractIL.IL.ILTypeDef list * + tdef:AbstractIL.IL.ILTypeDef -> + mtyp:Lib.MaybeLazy -> + Entity + static member + NewModifiedModuleOrNamespace : f:(ModuleOrNamespaceType -> + ModuleOrNamespaceType) -> + orig:Tycon -> Entity + static member + NewModifiedTycon : f:(Tycon -> Entity) -> orig:Tycon -> Entity + static member NewModifiedVal : f:(Val -> Val) -> orig:Val -> Val + static member + NewModuleOrNamespace : cpath:CompilationPath option -> + access:Accessibility -> + id:SyntaxTree.Ident -> + xml:XmlDoc.XmlDoc -> + attribs:Attrib list -> + mtype:Lib.MaybeLazy -> + ModuleOrNamespace + static member + NewModuleOrNamespaceType : mkind:ModuleOrNamespaceKind -> + tycons:Entity list -> + vals:Val list -> ModuleOrNamespaceType + static member + NewProvidedTycon : resolutionEnvironment:ExtensionTyping.ResolutionEnvironment * + st:Tainted * + importProvidedType:(Tainted -> + TType) * + isSuppressRelocate:bool * m:Range.range * + ?access:Accessibility * ?cpath:CompilationPath -> + Entity + static member + NewProvidedTyconRepr : resolutionEnvironment:ExtensionTyping.ResolutionEnvironment * + st:Tainted * + importProvidedType:(Tainted -> + TType) * + isSuppressRelocate:bool * m:Range.range -> + TyconRepresentation + static member + NewRecdField : stat:bool -> + konst:Const option -> + id:SyntaxTree.Ident -> + nameGenerated:bool -> + ty:TType -> + isMutable:bool -> + isVolatile:bool -> + pattribs:Attribs -> + fattribs:Attribs -> + docOption:XmlDoc.XmlDoc -> + access:Accessibility -> + secret:bool -> RecdField + static member NewRigidTypar : nm:string -> m:Range.range -> Typar + static member + NewTycon : cpath:CompilationPath option * nm:string * m:Range.range * + access:Accessibility * reprAccess:Accessibility * + kind:TyparKind * + typars:AbstractIL.Internal.Library.LazyWithContext * + doc:XmlDoc.XmlDoc * usesPrefixDisplay:bool * + preEstablishedHasDefaultCtor:bool * + hasSelfReferentialCtor:bool * + mtyp:Lib.MaybeLazy -> Entity + static member + NewTypar : kind:TyparKind * rigid:TyparRigidity * SyntaxTree.SynTypar * + isFromError:bool * dynamicReq:TyparDynamicReq * + attribs:Attrib list * eqDep:bool * compDep:bool -> Typar + static member + NewUnionCase : id:SyntaxTree.Ident -> + tys:RecdField list -> + rty:TType -> + attribs:Attribs -> + docOption:XmlDoc.XmlDoc -> + access:Accessibility -> UnionCase + static member + NewVal : logicalName:string * m:Range.range * + compiledName:string option * ty:TType * + isMutable:ValMutability * isCompGen:bool * + arity:ValReprInfo option * access:Accessibility * + recValInfo:ValRecursiveScopeInfo * + specialRepr:ValMemberInfo option * + baseOrThis:ValBaseOrThisInfo * attribs:Attrib list * + inlineInfo:ValInline * doc:XmlDoc.XmlDoc * + isModuleOrMemberBinding:bool * isExtensionMember:bool * + isIncrClassSpecialMember:bool * isTyFunc:bool * + allowTypeInst:bool * isGeneratedEventVal:bool * + konst:Const option * actualParent:ParentRef -> Val + end + end + +namespace FSharp.Compiler + module internal TypedTreeBasics = begin + val getNameOfScopeRef : sref:AbstractIL.IL.ILScopeRef -> string + module ValReprInfo = begin + val unnamedTopArg1 : TypedTree.ArgReprInfo + val unnamedTopArg : TypedTree.ArgReprInfo list + val unitArgData : TypedTree.ArgReprInfo list list + val unnamedRetVal : TypedTree.ArgReprInfo + val selfMetadata : TypedTree.ArgReprInfo list + val emptyValData : TypedTree.ValReprInfo + val InferTyparInfo : + tps:TypedTree.Typar list -> TypedTree.TyparReprInfo list + val InferArgReprInfo : v:TypedTree.Val -> TypedTree.ArgReprInfo + val InferArgReprInfos : + vs:TypedTree.Val list list -> TypedTree.ValReprInfo + val HasNoArgs : TypedTree.ValReprInfo -> bool + end + val typeOfVal : v:TypedTree.Val -> TypedTree.TType + val typesOfVals : v:TypedTree.Val list -> TypedTree.TType list + val nameOfVal : v:TypedTree.Val -> string + val arityOfVal : v:TypedTree.Val -> TypedTree.ValReprInfo + val tupInfoRef : TypedTree.TupInfo + val tupInfoStruct : TypedTree.TupInfo + val mkTupInfo : b:bool -> TypedTree.TupInfo + val structnessDefault : bool + val mkRawRefTupleTy : tys:TypedTree.TTypes -> TypedTree.TType + val mkRawStructTupleTy : tys:TypedTree.TTypes -> TypedTree.TType + val mapTImplFile : + f:(TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig) -> + TypedTree.TypedImplFile -> TypedTree.TypedImplFile + val mapAccImplFile : + f:('a -> TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig * 'b) -> + z:'a -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile * 'b + val foldTImplFile : + f:('a -> TypedTree.ModuleOrNamespaceExprWithSig -> 'b) -> + z:'a -> TypedTree.TypedImplFile -> 'b + val typarEq : lv1:TypedTree.Typar -> lv2:TypedTree.Typar -> bool + val typarRefEq : tp1:TypedTree.Typar -> tp2:TypedTree.Typar -> bool + val valEq : lv1:TypedTree.Val -> lv2:TypedTree.Val -> bool + val ccuEq : mv1:TypedTree.CcuThunk -> mv2:TypedTree.CcuThunk -> bool + val ( |ValDeref| ) : vr:TypedTree.ValRef -> TypedTree.Val + val mkRecdFieldRef : + tcref:TypedTree.TyconRef -> f:string -> TypedTree.RecdFieldRef + val mkUnionCaseRef : + tcref:TypedTree.TyconRef -> c:string -> TypedTree.UnionCaseRef + val ERefLocal : x:Lib.NonNullSlot -> TypedTree.EntityRef + val ERefNonLocal : x:TypedTree.NonLocalEntityRef -> TypedTree.EntityRef + val ERefNonLocalPreResolved : + x:Lib.NonNullSlot -> + xref:TypedTree.NonLocalEntityRef -> TypedTree.EntityRef + val ( |ERefLocal|ERefNonLocal| ) : + x:TypedTree.EntityRef -> + Choice,TypedTree.NonLocalEntityRef> + val mkLocalTyconRef : + x:Lib.NonNullSlot -> TypedTree.EntityRef + val mkNonLocalEntityRef : + ccu:TypedTree.CcuThunk -> mp:string [] -> TypedTree.NonLocalEntityRef + val mkNestedNonLocalEntityRef : + nleref:TypedTree.NonLocalEntityRef -> + id:string -> TypedTree.NonLocalEntityRef + val mkNonLocalTyconRef : + nleref:TypedTree.NonLocalEntityRef -> id:string -> TypedTree.EntityRef + val mkNonLocalTyconRefPreResolved : + x:Lib.NonNullSlot -> + nleref:TypedTree.NonLocalEntityRef -> id:string -> TypedTree.EntityRef + type EntityRef with + member NestedTyconRef : x:TypedTree.Entity -> TypedTree.EntityRef + type EntityRef with + member + RecdFieldRefInNestedTycon : tycon:TypedTree.Entity -> + id:SyntaxTree.Ident -> + TypedTree.RecdFieldRef + val mkModuleUnionCaseRef : + modref:TypedTree.ModuleOrNamespaceRef -> + tycon:TypedTree.Entity -> + uc:TypedTree.UnionCase -> TypedTree.UnionCaseRef + val VRefLocal : x:Lib.NonNullSlot -> TypedTree.ValRef + val VRefNonLocal : x:TypedTree.NonLocalValOrMemberRef -> TypedTree.ValRef + val VRefNonLocalPreResolved : + x:Lib.NonNullSlot -> + xref:TypedTree.NonLocalValOrMemberRef -> TypedTree.ValRef + val ( |VRefLocal|VRefNonLocal| ) : + x:TypedTree.ValRef -> + Choice,TypedTree.NonLocalValOrMemberRef> + val mkNonLocalValRef : + mp:TypedTree.NonLocalEntityRef -> + id:TypedTree.ValLinkageFullKey -> TypedTree.ValRef + val mkNonLocalValRefPreResolved : + x:Lib.NonNullSlot -> + mp:TypedTree.NonLocalEntityRef -> + id:TypedTree.ValLinkageFullKey -> TypedTree.ValRef + val ccuOfValRef : vref:TypedTree.ValRef -> TypedTree.CcuThunk option + val ccuOfTyconRef : eref:TypedTree.EntityRef -> TypedTree.CcuThunk option + val mkTyparTy : tp:TypedTree.Typar -> TypedTree.TType + val copyTypar : tp:TypedTree.Typar -> TypedTree.Typar + val copyTypars : tps:TypedTree.Typar list -> TypedTree.Typar list + val tryShortcutSolvedUnitPar : + canShortcut:bool -> r:TypedTree.Typar -> TypedTree.Measure + val stripUnitEqnsAux : + canShortcut:bool -> unt:TypedTree.Measure -> TypedTree.Measure + val stripTyparEqnsAux : + canShortcut:bool -> ty:TypedTree.TType -> TypedTree.TType + val stripTyparEqns : ty:TypedTree.TType -> TypedTree.TType + val stripUnitEqns : unt:TypedTree.Measure -> TypedTree.Measure + val mkLocalValRef : v:TypedTree.Val -> TypedTree.ValRef + val mkLocalModRef : v:TypedTree.ModuleOrNamespace -> TypedTree.EntityRef + val mkLocalEntityRef : v:TypedTree.Entity -> TypedTree.EntityRef + val mkNonLocalCcuRootEntityRef : + ccu:TypedTree.CcuThunk -> x:TypedTree.Entity -> TypedTree.EntityRef + val mkNestedValRef : + cref:TypedTree.EntityRef -> v:TypedTree.Val -> TypedTree.ValRef + val rescopePubPathToParent : + viewedCcu:TypedTree.CcuThunk -> + TypedTree.PublicPath -> TypedTree.NonLocalEntityRef + val rescopePubPath : + viewedCcu:TypedTree.CcuThunk -> + TypedTree.PublicPath -> TypedTree.NonLocalEntityRef + val valRefInThisAssembly : compilingFslib:bool -> x:TypedTree.ValRef -> bool + val tyconRefUsesLocalXmlDoc : + compilingFslib:bool -> x:TypedTree.TyconRef -> bool + val entityRefInThisAssembly : + compilingFslib:bool -> x:TypedTree.EntityRef -> bool + val arrayPathEq : y1:string [] -> y2:string [] -> bool + val nonLocalRefEq : + TypedTree.NonLocalEntityRef -> TypedTree.NonLocalEntityRef -> bool + val nonLocalRefDefinitelyNotEq : + TypedTree.NonLocalEntityRef -> TypedTree.NonLocalEntityRef -> bool + val pubPathEq : TypedTree.PublicPath -> TypedTree.PublicPath -> bool + val fslibRefEq : + nlr1:TypedTree.NonLocalEntityRef -> TypedTree.PublicPath -> bool + val fslibEntityRefEq : + fslibCcu:TypedTree.CcuThunk -> + eref1:TypedTree.EntityRef -> eref2:TypedTree.EntityRef -> bool + val fslibValRefEq : + fslibCcu:TypedTree.CcuThunk -> + vref1:TypedTree.ValRef -> vref2:TypedTree.ValRef -> bool + val primEntityRefEq : + compilingFslib:bool -> + fslibCcu:TypedTree.CcuThunk -> + x:TypedTree.EntityRef -> y:TypedTree.EntityRef -> bool + val primUnionCaseRefEq : + compilingFslib:bool -> + fslibCcu:TypedTree.CcuThunk -> + TypedTree.UnionCaseRef -> TypedTree.UnionCaseRef -> bool + val primValRefEq : + compilingFslib:bool -> + fslibCcu:TypedTree.CcuThunk -> + x:TypedTree.ValRef -> y:TypedTree.ValRef -> bool + val fullCompPathOfModuleOrNamespace : + m:TypedTree.ModuleOrNamespace -> TypedTree.CompilationPath + val inline canAccessCompPathFrom : + TypedTree.CompilationPath -> TypedTree.CompilationPath -> bool + val canAccessFromOneOf : + cpaths:TypedTree.CompilationPath list -> + cpathTest:TypedTree.CompilationPath -> bool + val canAccessFrom : + TypedTree.Accessibility -> cpath:TypedTree.CompilationPath -> bool + val canAccessFromEverywhere : TypedTree.Accessibility -> bool + val canAccessFromSomewhere : TypedTree.Accessibility -> bool + val isLessAccessible : + TypedTree.Accessibility -> TypedTree.Accessibility -> bool + val accessSubstPaths : + newPath:TypedTree.CompilationPath * oldPath:TypedTree.CompilationPath -> + TypedTree.Accessibility -> TypedTree.Accessibility + val compPathOfCcu : ccu:TypedTree.CcuThunk -> TypedTree.CompilationPath + val taccessPublic : TypedTree.Accessibility + val taccessPrivate : + accessPath:TypedTree.CompilationPath -> TypedTree.Accessibility + val compPathInternal : TypedTree.CompilationPath + val taccessInternal : TypedTree.Accessibility + val combineAccess : + TypedTree.Accessibility -> + TypedTree.Accessibility -> TypedTree.Accessibility + exception Duplicate of string * string * Range.range + exception NameClash of + string * string * string * Range.range * string * + string * Range.range + end + +namespace FSharp.Compiler + module internal TcGlobals = begin + val DummyFileNameForRangesWithoutASpecificLocation : string + val private envRange : Range.range + [] + type IntrinsicValRef = + | IntrinsicValRef of + TypedTree.NonLocalEntityRef * string * bool * TypedTree.TType * + TypedTree.ValLinkageFullKey + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + member Name : string + end + val ValRefForIntrinsic : IntrinsicValRef -> TypedTree.ValRef + module FSharpLib = begin + val CoreOperatorsCheckedName : string + val ControlName : string + val LinqName : string + val CollectionsName : string + val LanguagePrimitivesName : string + val CompilerServicesName : string + val LinqRuntimeHelpersName : string + val RuntimeHelpersName : string + val ExtraTopLevelOperatorsName : string + val NativeInteropName : string + val QuotationsName : string + val ControlPath : string list + val LinqPath : string list + val CollectionsPath : string list + val NativeInteropPath : string [] + val CompilerServicesPath : string [] + val LinqRuntimeHelpersPath : string [] + val RuntimeHelpersPath : string [] + val QuotationsPath : string [] + val RootPathArray : string [] + val CorePathArray : string [] + val LinqPathArray : string [] + val ControlPathArray : string [] + val CollectionsPathArray : string [] + end + val private mkNonGenericTy : tcref:TypedTree.TyconRef -> TypedTree.TType + val mkNonLocalTyconRef2 : + ccu:TypedTree.CcuThunk -> + path:string [] -> n:string -> TypedTree.EntityRef + val mk_MFCore_tcref : + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFQuotations_tcref : + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFLinq_tcref : + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFCollections_tcref : + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFCompilerServices_tcref : + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFRuntimeHelpers_tcref : + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + val mk_MFControl_tcref : + ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef + [] + type BuiltinAttribInfo = + | AttribInfo of AbstractIL.IL.ILTypeRef * TypedTree.TyconRef + with + override ToString : unit -> string + [ (0))>] + member DebugText : string + member TyconRef : TypedTree.TyconRef + member TypeRef : AbstractIL.IL.ILTypeRef + end + [] + val tname_DebuggerNonUserCodeAttribute : string + = "System.Diagnostics.DebuggerNonUserCodeAttribute" + [] + val tname_DebuggableAttribute_DebuggingModes : string = "DebuggingModes" + [] + val tname_DebuggerHiddenAttribute : string + = "System.Diagnostics.DebuggerHiddenAttribute" + [] + val tname_DebuggerDisplayAttribute : string + = "System.Diagnostics.DebuggerDisplayAttribute" + [] + val tname_DebuggerTypeProxyAttribute : string + = "System.Diagnostics.DebuggerTypeProxyAttribute" + [] + val tname_DebuggerStepThroughAttribute : string + = "System.Diagnostics.DebuggerStepThroughAttribute" + [] + val tname_DebuggerBrowsableAttribute : string + = "System.Diagnostics.DebuggerBrowsableAttribute" + [] + val tname_DebuggerBrowsableState : string + = "System.Diagnostics.DebuggerBrowsableState" + [] + val tname_StringBuilder : string = "System.Text.StringBuilder" + [] + val tname_IComparable : string = "System.IComparable" + [] + val tname_Exception : string = "System.Exception" + [] + val tname_Missing : string = "System.Reflection.Missing" + [] + val tname_FormattableString : string = "System.FormattableString" + [] + val tname_SerializationInfo : string + = "System.Runtime.Serialization.SerializationInfo" + [] + val tname_StreamingContext : string + = "System.Runtime.Serialization.StreamingContext" + [] + val tname_SecurityPermissionAttribute : string + = "System.Security.Permissions.SecurityPermissionAttribute" + [] + val tname_Delegate : string = "System.Delegate" + [] + val tname_ValueType : string = "System.ValueType" + [] + val tname_Enum : string = "System.Enum" + [] + val tname_Array : string = "System.Array" + [] + val tname_RuntimeArgumentHandle : string = "System.RuntimeArgumentHandle" + [] + val tname_RuntimeTypeHandle : string = "System.RuntimeTypeHandle" + [] + val tname_RuntimeMethodHandle : string = "System.RuntimeMethodHandle" + [] + val tname_RuntimeFieldHandle : string = "System.RuntimeFieldHandle" + [] + val tname_CompilerGeneratedAttribute : string + = "System.Runtime.CompilerServices.CompilerGeneratedAttribute" + [] + val tname_DebuggableAttribute : string + = "System.Diagnostics.DebuggableAttribute" + [] + val tname_AsyncCallback : string = "System.AsyncCallback" + [] + val tname_IAsyncResult : string = "System.IAsyncResult" + type TcGlobals = + class + new : compilingFslib:bool * ilg:AbstractIL.IL.ILGlobals * + fslibCcu:TypedTree.CcuThunk * + directoryToResolveRelativePaths:string * mlCompatibility:bool * + isInteractive:bool * + tryFindSysTypeCcu:(string list -> string -> + TypedTree.CcuThunk option) * + emitDebugInfoInQuotations:bool * noDebugData:bool * + pathMap:Internal.Utilities.PathMap * + langVersion:Features.LanguageVersion -> TcGlobals + member + AddFieldGeneratedAttrs : mdef:AbstractIL.IL.ILFieldDef -> + AbstractIL.IL.ILFieldDef + member + AddFieldNeverAttrs : mdef:AbstractIL.IL.ILFieldDef -> + AbstractIL.IL.ILFieldDef + member + AddMethodGeneratedAttributes : mdef:AbstractIL.IL.ILMethodDef -> + AbstractIL.IL.ILMethodDef + member + EraseClassUnionDef : cud:AbstractIL.IL.ILTypeRef -> + (AbstractIL.IL.ILTypeDef -> + AbstractIL.Extensions.ILX.Types.IlxUnionInfo -> + AbstractIL.IL.ILTypeDef) + member FindSysAttrib : nm:string -> BuiltinAttribInfo + member FindSysILTypeRef : nm:string -> AbstractIL.IL.ILTypeRef + member + FindSysTyconRef : path:string list -> nm:string -> TypedTree.EntityRef + member + MakeBuiltInWitnessInfo : t:TypedTree.TraitConstraintInfo -> + IntrinsicValRef * TypedTree.TType list + override ToString : unit -> string + member TryFindSysAttrib : nm:string -> BuiltinAttribInfo option + member TryFindSysILTypeRef : nm:string -> AbstractIL.IL.ILTypeRef option + member + TryFindSysTyconRef : path:string list -> + nm:string -> TypedTree.EntityRef option + member + TryMakeOperatorAsBuiltInWitnessInfo : isStringTy:(TcGlobals -> + TypedTree.TType -> + bool) -> + isArrayTy:(TcGlobals -> + TypedTree.TType -> + bool) -> + t:TypedTree.TraitConstraintInfo -> + argExprs:'a list -> + (IntrinsicValRef * + TypedTree.TType list * + 'a list) option + member + decompileType : tcref:TypedTree.EntityRef -> + tinst:TypedTree.TypeInst -> TypedTree.TType + member + improveType : tcref:TypedTree.EntityRef -> + tinst:TypedTree.TType list -> TypedTree.TType + member memoize_file : x:int -> AbstractIL.IL.ILSourceDocument + member + mkDebuggableAttribute : jitOptimizerDisabled:bool -> + AbstractIL.IL.ILAttribute + member + mkDebuggableAttributeV2 : jitTracking:bool * + ignoreSymbolStoreSequencePoints:bool * + jitOptimizerDisabled:bool * enableEnC:bool -> + AbstractIL.IL.ILAttribute + member + mkDebuggerDisplayAttribute : s:string -> AbstractIL.IL.ILAttribute + member mkDebuggerHiddenAttribute : unit -> AbstractIL.IL.ILAttribute + member + mkDebuggerStepThroughAttribute : unit -> AbstractIL.IL.ILAttribute + member + unionCaseRefEq : x:TypedTree.UnionCaseRef -> + y:TypedTree.UnionCaseRef -> bool + member valRefEq : x:TypedTree.ValRef -> y:TypedTree.ValRef -> bool + member CompilerGeneratedAttribute : AbstractIL.IL.ILAttribute + member + CompilerGlobalState : CompilerGlobalState.CompilerGlobalState option + member DebuggerBrowsableNeverAttribute : AbstractIL.IL.ILAttribute + member IComparer_ty : TypedTree.TType + member IEqualityComparer_ty : TypedTree.TType + member + System_Runtime_CompilerServices_RuntimeFeature_ty : TypedTree.TType option + member addrof2_vref : TypedTree.ValRef + member addrof_vref : TypedTree.ValRef + member and2_vref : TypedTree.ValRef + member and_vref : TypedTree.ValRef + member array2D_get_info : IntrinsicValRef + member array2D_get_vref : TypedTree.ValRef + member array2D_set_info : IntrinsicValRef + member array3D_get_info : IntrinsicValRef + member array3D_get_vref : TypedTree.ValRef + member array3D_set_info : IntrinsicValRef + member array4D_get_info : IntrinsicValRef + member array4D_get_vref : TypedTree.ValRef + member array4D_set_info : IntrinsicValRef + member array_get_info : IntrinsicValRef + member array_get_vref : TypedTree.ValRef + member array_length_info : IntrinsicValRef + member array_set_info : IntrinsicValRef + member array_tcr_nice : TypedTree.EntityRef + member attrib_AbstractClassAttribute : BuiltinAttribInfo + member attrib_AllowNullLiteralAttribute : BuiltinAttribInfo + member attrib_AttributeUsageAttribute : BuiltinAttribInfo + member attrib_AutoOpenAttribute : BuiltinAttribInfo + member attrib_AutoSerializableAttribute : BuiltinAttribInfo + member attrib_CLIEventAttribute : BuiltinAttribInfo + member attrib_CLIMutableAttribute : BuiltinAttribInfo + member attrib_CallerFilePathAttribute : BuiltinAttribInfo + member attrib_CallerLineNumberAttribute : BuiltinAttribInfo + member attrib_CallerMemberNameAttribute : BuiltinAttribInfo + member attrib_ClassAttribute : BuiltinAttribInfo + member attrib_ComImportAttribute : BuiltinAttribInfo option + member attrib_ComVisibleAttribute : BuiltinAttribInfo + member attrib_ComparisonConditionalOnAttribute : BuiltinAttribInfo + member attrib_CompilationArgumentCountsAttribute : BuiltinAttribInfo + member attrib_CompilationMappingAttribute : BuiltinAttribInfo + member attrib_CompilationRepresentationAttribute : BuiltinAttribInfo + member attrib_CompiledNameAttribute : BuiltinAttribInfo + member attrib_CompilerMessageAttribute : BuiltinAttribInfo + member attrib_ComponentModelEditorBrowsableAttribute : BuiltinAttribInfo + member attrib_ConditionalAttribute : BuiltinAttribInfo + member attrib_ContextStaticAttribute : BuiltinAttribInfo option + member attrib_CustomComparisonAttribute : BuiltinAttribInfo + member attrib_CustomEqualityAttribute : BuiltinAttribInfo + member attrib_CustomOperationAttribute : BuiltinAttribInfo + member attrib_DebuggerDisplayAttribute : BuiltinAttribInfo + member attrib_DebuggerTypeProxyAttribute : BuiltinAttribInfo + member attrib_DefaultAugmentationAttribute : BuiltinAttribInfo + member attrib_DefaultMemberAttribute : BuiltinAttribInfo + member attrib_DefaultParameterValueAttribute : BuiltinAttribInfo option + member attrib_DefaultValueAttribute : BuiltinAttribInfo + member attrib_DllImportAttribute : BuiltinAttribInfo option + member attrib_EntryPointAttribute : BuiltinAttribInfo + member attrib_EqualityConditionalOnAttribute : BuiltinAttribInfo + member attrib_ExperimentalAttribute : BuiltinAttribInfo + member attrib_ExtensionAttribute : BuiltinAttribInfo + member attrib_FieldOffsetAttribute : BuiltinAttribInfo + member attrib_FlagsAttribute : BuiltinAttribInfo + member attrib_GeneralizableValueAttribute : BuiltinAttribInfo + member attrib_IDispatchConstantAttribute : BuiltinAttribInfo option + member attrib_IUnknownConstantAttribute : BuiltinAttribInfo option + member attrib_InAttribute : BuiltinAttribInfo + member attrib_InterfaceAttribute : BuiltinAttribInfo + member attrib_InternalsVisibleToAttribute : BuiltinAttribInfo + member attrib_IsByRefLikeAttribute : BuiltinAttribInfo + member attrib_IsReadOnlyAttribute : BuiltinAttribInfo + member attrib_LiteralAttribute : BuiltinAttribInfo + member attrib_MarshalAsAttribute : BuiltinAttribInfo option + member attrib_MeasureAttribute : BuiltinAttribInfo + member attrib_MeasureableAttribute : BuiltinAttribInfo + member attrib_MethodImplAttribute : BuiltinAttribInfo + member attrib_NoComparisonAttribute : BuiltinAttribInfo + member attrib_NoDynamicInvocationAttribute : BuiltinAttribInfo + member attrib_NoEqualityAttribute : BuiltinAttribInfo + member attrib_NonSerializedAttribute : BuiltinAttribInfo option + member attrib_OptionalArgumentAttribute : BuiltinAttribInfo + member attrib_OptionalAttribute : BuiltinAttribInfo option + member attrib_OutAttribute : BuiltinAttribInfo + member attrib_ParamArrayAttribute : BuiltinAttribInfo + member attrib_PreserveSigAttribute : BuiltinAttribInfo option + member attrib_ProjectionParameterAttribute : BuiltinAttribInfo + member attrib_ReferenceEqualityAttribute : BuiltinAttribInfo + member attrib_ReflectedDefinitionAttribute : BuiltinAttribInfo + member attrib_RequireQualifiedAccessAttribute : BuiltinAttribInfo + member attrib_RequiresExplicitTypeArgumentsAttribute : BuiltinAttribInfo + member attrib_SealedAttribute : BuiltinAttribInfo + member attrib_SecurityAttribute : BuiltinAttribInfo option + member attrib_SecurityCriticalAttribute : BuiltinAttribInfo + member attrib_SecuritySafeCriticalAttribute : BuiltinAttribInfo + member attrib_SpecialNameAttribute : BuiltinAttribInfo option + member attrib_StructAttribute : BuiltinAttribInfo + member attrib_StructLayoutAttribute : BuiltinAttribInfo + member attrib_StructuralComparisonAttribute : BuiltinAttribInfo + member attrib_StructuralEqualityAttribute : BuiltinAttribInfo + member attrib_SystemObsolete : BuiltinAttribInfo + member attrib_ThreadStaticAttribute : BuiltinAttribInfo option + member attrib_TypeForwardedToAttribute : BuiltinAttribInfo + member attrib_UnverifiableAttribute : BuiltinAttribInfo + member attrib_VolatileFieldAttribute : BuiltinAttribInfo + member bitwise_and_info : IntrinsicValRef + member bitwise_and_vref : TypedTree.ValRef + member bitwise_or_info : IntrinsicValRef + member bitwise_or_vref : TypedTree.ValRef + member bitwise_shift_left_info : IntrinsicValRef + member bitwise_shift_left_vref : TypedTree.ValRef + member bitwise_shift_right_info : IntrinsicValRef + member bitwise_shift_right_vref : TypedTree.ValRef + member bitwise_unary_not_info : IntrinsicValRef + member bitwise_unary_not_vref : TypedTree.ValRef + member bitwise_xor_info : IntrinsicValRef + member bitwise_xor_vref : TypedTree.ValRef + member bool_tcr : TypedTree.EntityRef + member bool_ty : TypedTree.TType + member box_info : IntrinsicValRef + member byref2_tcr : TypedTree.EntityRef + member byref_tcr : TypedTree.EntityRef + member byrefkind_InOut_tcr : TypedTree.EntityRef + member byrefkind_In_tcr : TypedTree.EntityRef + member byrefkind_Out_tcr : TypedTree.EntityRef + member byte_checked_info : IntrinsicValRef + member byte_operator_info : IntrinsicValRef + member byte_tcr : TypedTree.EntityRef + member byte_ty : TypedTree.TType + member call_with_witnesses_info : IntrinsicValRef + member cast_quotation_info : IntrinsicValRef + member char_operator_info : IntrinsicValRef + member char_tcr : TypedTree.EntityRef + member char_ty : TypedTree.TType + member check_this_info : IntrinsicValRef + member checked_addition_info : IntrinsicValRef + member checked_multiply_info : IntrinsicValRef + member checked_subtraction_info : IntrinsicValRef + member checked_unary_minus_info : IntrinsicValRef + member choice2_tcr : TypedTree.EntityRef + member choice3_tcr : TypedTree.EntityRef + member choice4_tcr : TypedTree.EntityRef + member choice5_tcr : TypedTree.EntityRef + member choice6_tcr : TypedTree.EntityRef + member choice7_tcr : TypedTree.EntityRef + member compare_operator_vref : TypedTree.ValRef + member compilingFslib : bool + member cons_ucref : TypedTree.UnionCaseRef + member create_event_info : IntrinsicValRef + member create_instance_info : IntrinsicValRef + member date_tcr : TypedTree.EntityRef + member decimal_tcr : TypedTree.EntityRef + member decimal_ty : TypedTree.TType + member deserialize_quoted_FSharp_20_plus_info : IntrinsicValRef + member deserialize_quoted_FSharp_40_plus_info : IntrinsicValRef + member directoryToResolveRelativePaths : string + member dispose_info : IntrinsicValRef + member emitDebugInfoInQuotations : bool + member enumOfValue_vref : TypedTree.ValRef + member enum_operator_info : IntrinsicValRef + member enum_vref : TypedTree.ValRef + member equals_nullable_operator_vref : TypedTree.ValRef + member equals_operator_info : IntrinsicValRef + member equals_operator_vref : TypedTree.ValRef + member exn_tcr : TypedTree.EntityRef + member exn_ty : TypedTree.TType + member expr_tcr : TypedTree.EntityRef + member fail_init_info : IntrinsicValRef + member fail_static_init_info : IntrinsicValRef + member failwith_info : IntrinsicValRef + member failwith_vref : TypedTree.ValRef + member failwithf_info : IntrinsicValRef + member failwithf_vref : TypedTree.ValRef + member fastFunc_tcr : TypedTree.EntityRef + member float32_operator_info : IntrinsicValRef + member float32_tcr : TypedTree.EntityRef + member float32_ty : TypedTree.TType + member float_operator_info : IntrinsicValRef + member float_tcr : TypedTree.EntityRef + member float_ty : TypedTree.TType + member format_tcr : TypedTree.EntityRef + member fsharpref_vref : TypedTree.ValRef + member fslibCcu : TypedTree.CcuThunk + member fslib_IDelegateEvent_tcr : TypedTree.EntityRef + member fslib_IEvent2_tcr : TypedTree.EntityRef + member generateWitnesses : bool + member generic_compare_withc_tuple2_vref : TypedTree.ValRef + member generic_compare_withc_tuple3_vref : TypedTree.ValRef + member generic_compare_withc_tuple4_vref : TypedTree.ValRef + member generic_compare_withc_tuple5_vref : TypedTree.ValRef + member generic_comparison_inner_vref : TypedTree.ValRef + member generic_comparison_withc_inner_vref : TypedTree.ValRef + member generic_comparison_withc_outer_info : IntrinsicValRef + member generic_equality_er_inner_vref : TypedTree.ValRef + member generic_equality_er_outer_info : IntrinsicValRef + member generic_equality_per_inner_vref : TypedTree.ValRef + member generic_equality_withc_inner_vref : TypedTree.ValRef + member generic_equality_withc_outer_info : IntrinsicValRef + member generic_equality_withc_outer_vref : TypedTree.ValRef + member generic_equals_withc_tuple2_vref : TypedTree.ValRef + member generic_equals_withc_tuple3_vref : TypedTree.ValRef + member generic_equals_withc_tuple4_vref : TypedTree.ValRef + member generic_equals_withc_tuple5_vref : TypedTree.ValRef + member generic_hash_inner_vref : TypedTree.ValRef + member generic_hash_withc_inner_vref : TypedTree.ValRef + member generic_hash_withc_outer_info : IntrinsicValRef + member generic_hash_withc_tuple2_vref : TypedTree.ValRef + member generic_hash_withc_tuple3_vref : TypedTree.ValRef + member generic_hash_withc_tuple4_vref : TypedTree.ValRef + member generic_hash_withc_tuple5_vref : TypedTree.ValRef + member get_generic_comparer_info : IntrinsicValRef + member get_generic_er_equality_comparer_info : IntrinsicValRef + member get_generic_per_equality_comparer_info : IntrinsicValRef + member getstring_info : IntrinsicValRef + member greater_than_operator : IntrinsicValRef + member greater_than_operator_vref : TypedTree.ValRef + member greater_than_or_equals_operator : IntrinsicValRef + member greater_than_or_equals_operator_vref : TypedTree.ValRef + member hash_info : IntrinsicValRef + member il_arr_tcr_map : TypedTree.EntityRef [] + member ilg : AbstractIL.IL.ILGlobals + member ilsigptr_tcr : TypedTree.EntityRef + member iltyp_AsyncCallback : AbstractIL.IL.ILType + member iltyp_Exception : AbstractIL.IL.ILType + member iltyp_IAsyncResult : AbstractIL.IL.ILType + member iltyp_IComparable : AbstractIL.IL.ILType + member iltyp_Missing : AbstractIL.IL.ILType + member iltyp_RuntimeFieldHandle : AbstractIL.IL.ILType + member iltyp_RuntimeMethodHandle : AbstractIL.IL.ILType + member iltyp_RuntimeTypeHandle : AbstractIL.IL.ILType + member iltyp_SerializationInfo : AbstractIL.IL.ILType option + member iltyp_StreamingContext : AbstractIL.IL.ILType option + member iltyp_TypedReference : AbstractIL.IL.ILType option + member iltyp_ValueType : AbstractIL.IL.ILType + member ilxPubCloEnv : AbstractIL.Extensions.ILX.EraseClosures.cenv + member inref_tcr : TypedTree.EntityRef + member int16_checked_info : IntrinsicValRef + member int16_operator_info : IntrinsicValRef + member int16_tcr : TypedTree.EntityRef + member int16_ty : TypedTree.TType + member int32_checked_info : IntrinsicValRef + member int32_operator_info : IntrinsicValRef + member int32_tcr : TypedTree.EntityRef + member int32_ty : TypedTree.TType + member int64_checked_info : IntrinsicValRef + member int64_operator_info : IntrinsicValRef + member int64_tcr : TypedTree.EntityRef + member int64_ty : TypedTree.TType + member int_checked_info : IntrinsicValRef + member int_operator_info : IntrinsicValRef + member int_tcr : TypedTree.EntityRef + member int_ty : TypedTree.TType + member invalid_arg_info : IntrinsicValRef + member invalid_arg_vref : TypedTree.ValRef + member invalid_op_info : IntrinsicValRef + member invalid_op_vref : TypedTree.ValRef + member isInteractive : bool + member isnotnull_info : IntrinsicValRef + member isnull_info : IntrinsicValRef + member istype_fast_info : IntrinsicValRef + member istype_fast_vref : TypedTree.ValRef + member istype_info : IntrinsicValRef + member istype_vref : TypedTree.ValRef + member + knownFSharpCoreModules : System.Collections.Generic.IDictionary + member + knownIntrinsics : System.Collections.Concurrent.ConcurrentDictionary<(string * + string option * + string * + int), + TypedTree.ValRef> + member langVersion : Features.LanguageVersion + member lazy_create_info : IntrinsicValRef + member lazy_force_info : IntrinsicValRef + member lazy_tcr_canon : TypedTree.EntityRef + member lazy_tcr_nice : TypedTree.EntityRef + member less_than_operator : IntrinsicValRef + member less_than_operator_vref : TypedTree.ValRef + member less_than_or_equals_operator : IntrinsicValRef + member less_than_or_equals_operator_vref : TypedTree.ValRef + member lift_value_info : IntrinsicValRef + member lift_value_with_defn_info : IntrinsicValRef + member lift_value_with_name_info : IntrinsicValRef + member list_tcr_canon : TypedTree.EntityRef + member list_tcr_nice : TypedTree.EntityRef + member map_tcr_canon : TypedTree.EntityRef + member measureinverse_tcr : TypedTree.EntityRef + member measureone_tcr : TypedTree.EntityRef + member measureproduct_tcr : TypedTree.EntityRef + member methodhandleof_info : IntrinsicValRef + member methodhandleof_vref : TypedTree.ValRef + member mk_IComparable_ty : TypedTree.TType + member mk_IStructuralComparable_ty : TypedTree.TType + member mk_IStructuralEquatable_ty : TypedTree.TType + member mlCompatibility : bool + member nameof_vref : TypedTree.ValRef + member nativeint_checked_info : IntrinsicValRef + member nativeint_operator_info : IntrinsicValRef + member nativeint_tcr : TypedTree.EntityRef + member nativeint_ty : TypedTree.TType + member nativeptr_tcr : TypedTree.EntityRef + member nativeptr_tobyref_vref : TypedTree.ValRef + member new_decimal_info : IntrinsicValRef + member new_format_info : IntrinsicValRef + member new_format_vref : TypedTree.ValRef + member new_query_source_info : IntrinsicValRef + member nil_ucref : TypedTree.UnionCaseRef + member not_equals_operator : IntrinsicValRef + member not_equals_operator_vref : TypedTree.ValRef + member null_arg_info : IntrinsicValRef + member null_arg_vref : TypedTree.ValRef + member nullable_equals_nullable_operator_vref : TypedTree.ValRef + member nullable_equals_operator_vref : TypedTree.ValRef + member obj_ty : TypedTree.TType + member option_defaultValue_info : IntrinsicValRef + member option_tcr_canon : TypedTree.EntityRef + member option_tcr_nice : TypedTree.EntityRef + member option_toNullable_info : IntrinsicValRef + member or2_vref : TypedTree.ValRef + member or_vref : TypedTree.ValRef + member outref_tcr : TypedTree.EntityRef + member pathMap : Internal.Utilities.PathMap + member pdecimal_tcr : TypedTree.EntityRef + member pfloat32_tcr : TypedTree.EntityRef + member pfloat_tcr : TypedTree.EntityRef + member pint16_tcr : TypedTree.EntityRef + member pint64_tcr : TypedTree.EntityRef + member pint8_tcr : TypedTree.EntityRef + member pint_tcr : TypedTree.EntityRef + member pnativeint_tcr : TypedTree.EntityRef + member puint16_tcr : TypedTree.EntityRef + member puint64_tcr : TypedTree.EntityRef + member puint8_tcr : TypedTree.EntityRef + member puint_tcr : TypedTree.EntityRef + member punativeint_tcr : TypedTree.EntityRef + member query_builder_tcref : TypedTree.EntityRef + member query_for_vref : TypedTree.ValRef + member query_run_enumerable_vref : TypedTree.ValRef + member query_run_value_vref : TypedTree.ValRef + member query_select_vref : TypedTree.ValRef + member query_source_as_enum_info : IntrinsicValRef + member query_source_vref : TypedTree.ValRef + member query_value_vref : TypedTree.ValRef + member query_where_vref : TypedTree.ValRef + member query_yield_from_vref : TypedTree.ValRef + member query_yield_vref : TypedTree.ValRef + member query_zero_vref : TypedTree.ValRef + member quote_to_linq_lambda_info : IntrinsicValRef + member raise_info : IntrinsicValRef + member raise_vref : TypedTree.ValRef + member range_int32_op_vref : TypedTree.ValRef + member range_op_vref : TypedTree.ValRef + member range_step_op_vref : TypedTree.ValRef + member raw_expr_tcr : TypedTree.EntityRef + member ref_tuple1_tcr : TypedTree.EntityRef + member ref_tuple2_tcr : TypedTree.EntityRef + member ref_tuple3_tcr : TypedTree.EntityRef + member ref_tuple4_tcr : TypedTree.EntityRef + member ref_tuple5_tcr : TypedTree.EntityRef + member ref_tuple6_tcr : TypedTree.EntityRef + member ref_tuple7_tcr : TypedTree.EntityRef + member ref_tuple8_tcr : TypedTree.EntityRef + member refcell_tcr_canon : TypedTree.EntityRef + member refcell_tcr_nice : TypedTree.EntityRef + member reference_equality_inner_vref : TypedTree.ValRef + member reraise_info : IntrinsicValRef + member reraise_vref : TypedTree.ValRef + member sbyte_checked_info : IntrinsicValRef + member sbyte_operator_info : IntrinsicValRef + member sbyte_tcr : TypedTree.EntityRef + member sbyte_ty : TypedTree.TType + member seq_append_info : IntrinsicValRef + member seq_append_vref : TypedTree.ValRef + member seq_base_tcr : TypedTree.EntityRef + member seq_collect_info : IntrinsicValRef + member seq_collect_vref : TypedTree.ValRef + member seq_delay_info : IntrinsicValRef + member seq_delay_vref : TypedTree.ValRef + member seq_empty_info : IntrinsicValRef + member seq_empty_vref : TypedTree.ValRef + member seq_finally_info : IntrinsicValRef + member seq_finally_vref : TypedTree.ValRef + member seq_generated_info : IntrinsicValRef + member seq_generated_vref : TypedTree.ValRef + member seq_info : IntrinsicValRef + member seq_map_info : IntrinsicValRef + member seq_map_vref : TypedTree.ValRef + member seq_of_functions_info : IntrinsicValRef + member seq_of_functions_vref : TypedTree.ValRef + member seq_singleton_info : IntrinsicValRef + member seq_singleton_vref : TypedTree.ValRef + member seq_tcr : TypedTree.EntityRef + member seq_to_array_info : IntrinsicValRef + member seq_to_list_info : IntrinsicValRef + member seq_using_info : IntrinsicValRef + member seq_using_vref : TypedTree.ValRef + member seq_vref : TypedTree.ValRef + member set_tcr_canon : TypedTree.EntityRef + member sizeof_vref : TypedTree.ValRef + member splice_expr_vref : TypedTree.ValRef + member splice_raw_expr_vref : TypedTree.ValRef + member sprintf_info : IntrinsicValRef + member sprintf_vref : TypedTree.ValRef + member string_ty : TypedTree.TType + member struct_tuple1_tcr : TypedTree.EntityRef + member struct_tuple2_tcr : TypedTree.EntityRef + member struct_tuple3_tcr : TypedTree.EntityRef + member struct_tuple4_tcr : TypedTree.EntityRef + member struct_tuple5_tcr : TypedTree.EntityRef + member struct_tuple6_tcr : TypedTree.EntityRef + member struct_tuple7_tcr : TypedTree.EntityRef + member struct_tuple8_tcr : TypedTree.EntityRef + member suppressed_types : TypedTree.EntityRef list + member system_ArgIterator_tcref : TypedTree.EntityRef option + member system_Array_tcref : TypedTree.EntityRef + member system_Array_ty : TypedTree.TType + member system_Bool_tcref : TypedTree.EntityRef + member system_Byte_tcref : TypedTree.EntityRef + member system_Char_tcref : TypedTree.EntityRef + member system_Decimal_tcref : TypedTree.EntityRef + member system_Delegate_ty : TypedTree.TType + member system_Double_tcref : TypedTree.EntityRef + member system_Enum_ty : TypedTree.TType + member system_ExceptionDispatchInfo_ty : TypedTree.TType option + member system_Exception_ty : TypedTree.TType + member system_FormattableStringFactory_tcref : TypedTree.EntityRef + member system_FormattableStringFactory_ty : TypedTree.TType + member system_FormattableString_tcref : TypedTree.EntityRef + member system_FormattableString_ty : TypedTree.TType + member system_GenericIComparable_tcref : TypedTree.EntityRef + member system_GenericIEquatable_tcref : TypedTree.EntityRef + member system_IDisposable_ty : TypedTree.TType + member system_IFormattable_tcref : TypedTree.EntityRef + member system_IFormattable_ty : TypedTree.TType + member system_IndexOutOfRangeException_tcref : TypedTree.EntityRef + member system_Int16_tcref : TypedTree.EntityRef + member system_Int32_tcref : TypedTree.EntityRef + member system_Int32_ty : TypedTree.TType + member system_Int64_tcref : TypedTree.EntityRef + member system_IntPtr_tcref : TypedTree.EntityRef + member system_LinqExpression_tcref : TypedTree.EntityRef + member system_MarshalByRefObject_tcref : TypedTree.EntityRef option + member system_MarshalByRefObject_ty : TypedTree.TType option + member system_MulticastDelegate_ty : TypedTree.TType + member system_Nullable_tcref : TypedTree.EntityRef + member system_Object_tcref : TypedTree.EntityRef + member system_Object_ty : TypedTree.TType + member system_Reflection_MethodInfo_ty : TypedTree.TType + member system_RuntimeArgumentHandle_tcref : TypedTree.EntityRef option + member system_RuntimeHelpers_ty : TypedTree.TType + member system_RuntimeMethodHandle_ty : TypedTree.TType + member system_RuntimeTypeHandle_ty : TypedTree.TType + member system_SByte_tcref : TypedTree.EntityRef + member system_Single_tcref : TypedTree.EntityRef + member system_String_tcref : TypedTree.EntityRef + member system_String_typ : TypedTree.TType + member system_Type_ty : TypedTree.TType + member system_TypedReference_tcref : TypedTree.EntityRef option + member system_UInt16_tcref : TypedTree.EntityRef + member system_UInt32_tcref : TypedTree.EntityRef + member system_UInt64_tcref : TypedTree.EntityRef + member system_UIntPtr_tcref : TypedTree.EntityRef + member system_Value_tcref : TypedTree.EntityRef + member system_Value_ty : TypedTree.TType + member system_Void_tcref : TypedTree.EntityRef + member tcref_IObservable : TypedTree.EntityRef + member tcref_IObserver : TypedTree.EntityRef + member tcref_IQueryable : TypedTree.EntityRef + member tcref_LanguagePrimitives : TypedTree.EntityRef + member tcref_System_Attribute : TypedTree.EntityRef + member tcref_System_Collections_Generic_Dictionary : TypedTree.EntityRef + member + tcref_System_Collections_Generic_ICollection : TypedTree.EntityRef + member + tcref_System_Collections_Generic_IDictionary : TypedTree.EntityRef + member + tcref_System_Collections_Generic_IEnumerable : TypedTree.EntityRef + member + tcref_System_Collections_Generic_IEnumerator : TypedTree.EntityRef + member + tcref_System_Collections_Generic_IEqualityComparer : TypedTree.EntityRef + member tcref_System_Collections_Generic_IList : TypedTree.EntityRef + member + tcref_System_Collections_Generic_IReadOnlyCollection : TypedTree.EntityRef + member + tcref_System_Collections_Generic_IReadOnlyList : TypedTree.EntityRef + member tcref_System_Collections_Generic_List : TypedTree.EntityRef + member tcref_System_Collections_IComparer : TypedTree.EntityRef + member tcref_System_Collections_IEnumerable : TypedTree.EntityRef + member tcref_System_Collections_IEqualityComparer : TypedTree.EntityRef + member tcref_System_IComparable : TypedTree.EntityRef + member tcref_System_IDisposable : TypedTree.EntityRef + member tcref_System_IStructuralComparable : TypedTree.EntityRef + member tcref_System_IStructuralEquatable : TypedTree.EntityRef + member typedefof_info : IntrinsicValRef + member typedefof_vref : TypedTree.ValRef + member typeof_info : IntrinsicValRef + member typeof_vref : TypedTree.ValRef + member uint16_checked_info : IntrinsicValRef + member uint16_operator_info : IntrinsicValRef + member uint16_tcr : TypedTree.EntityRef + member uint16_ty : TypedTree.TType + member uint32_checked_info : IntrinsicValRef + member uint32_operator_info : IntrinsicValRef + member uint32_tcr : TypedTree.EntityRef + member uint32_ty : TypedTree.TType + member uint64_checked_info : IntrinsicValRef + member uint64_operator_info : IntrinsicValRef + member uint64_tcr : TypedTree.EntityRef + member uint64_ty : TypedTree.TType + member unativeint_checked_info : IntrinsicValRef + member unativeint_operator_info : IntrinsicValRef + member unativeint_tcr : TypedTree.EntityRef + member unativeint_ty : TypedTree.TType + member unbox_fast_info : IntrinsicValRef + member unbox_fast_vref : TypedTree.ValRef + member unbox_info : IntrinsicValRef + member unbox_vref : TypedTree.ValRef + member unchecked_addition_info : IntrinsicValRef + member unchecked_addition_vref : TypedTree.ValRef + member unchecked_defaultof_info : IntrinsicValRef + member unchecked_defaultof_vref : TypedTree.ValRef + member unchecked_division_info : IntrinsicValRef + member unchecked_modulus_info : IntrinsicValRef + member unchecked_multiply_info : IntrinsicValRef + member unchecked_multiply_vref : TypedTree.ValRef + member unchecked_subtraction_info : IntrinsicValRef + member unchecked_subtraction_vref : TypedTree.ValRef + member unchecked_unary_minus_info : IntrinsicValRef + member unchecked_unary_minus_vref : TypedTree.ValRef + member unchecked_unary_not_info : IntrinsicValRef + member unchecked_unary_not_vref : TypedTree.ValRef + member unchecked_unary_plus_info : IntrinsicValRef + member unchecked_unary_plus_vref : TypedTree.ValRef + member unit_tcr_canon : TypedTree.EntityRef + member unit_tcr_nice : TypedTree.EntityRef + member unit_ty : TypedTree.TType + member voidptr_tcr : TypedTree.EntityRef + end + val mutable global_g : TcGlobals option + end + +namespace FSharp.Compiler + module internal TypedTreeOps = begin + [] + type TyparMap<'T> = + | TPMap of TypedTree.StampMap<'T> + with + member Add : TypedTree.Typar * 'T -> TyparMap<'T> + member ContainsKey : TypedTree.Typar -> bool + member TryFind : TypedTree.Typar -> 'T option + member Item : TypedTree.Typar -> 'T with get + static member Empty : TyparMap<'T> + end + [] + type TyconRefMap<'T> = + class + new : imap:TypedTree.StampMap<'T> -> TyconRefMap<'T> + static member OfList : (TypedTree.TyconRef * 'T) list -> TyconRefMap<'T> + member Add : TypedTree.TyconRef -> 'T -> TyconRefMap<'T> + member ContainsKey : TypedTree.TyconRef -> bool + member Remove : TypedTree.TyconRef -> TyconRefMap<'T> + member TryFind : TypedTree.TyconRef -> 'T option + member IsEmpty : bool + member Item : TypedTree.TyconRef -> 'T with get + static member Empty : TyconRefMap<'T> + end + [] + type ValMap<'T> = + struct + new : imap:TypedTree.StampMap<'T> -> ValMap<'T> + static member OfList : (TypedTree.Val * 'T) list -> ValMap<'T> + member Add : TypedTree.Val -> 'T -> ValMap<'T> + member ContainsVal : TypedTree.Val -> bool + member Remove : TypedTree.Val -> ValMap<'T> + member TryFind : TypedTree.Val -> 'T option + member Contents : TypedTree.StampMap<'T> + member IsEmpty : bool + member Item : TypedTree.Val -> 'T with get + static member Empty : ValMap<'T> + end + type TyparInst = (TypedTree.Typar * TypedTree.TType) list + type TyconRefRemap = TyconRefMap + type ValRemap = ValMap + val emptyTyconRefRemap : TyconRefRemap + val emptyTyparInst : TyparInst + [] + type Remap = + { tpinst: TyparInst + valRemap: ValRemap + tyconRefRemap: TyconRefRemap + removeTraitSolutions: bool } + with + static member Empty : Remap + end + val emptyRemap : Remap + val addTyconRefRemap : + TypedTree.TyconRef -> TypedTree.TyconRef -> Remap -> Remap + val isRemapEmpty : remap:Remap -> bool + val instTyparRef : + tpinst:(TypedTree.Typar * 'a) list -> ty:'a -> tp:TypedTree.Typar -> 'a + val instMeasureTyparRef : + tpinst:(TypedTree.Typar * TypedTree.TType) list -> + unt:TypedTree.Measure -> tp:TypedTree.Typar -> TypedTree.Measure + val remapTyconRef : + TyconRefMap -> + TypedTree.TyconRef -> TypedTree.TyconRef + val remapUnionCaseRef : + TyconRefMap -> + TypedTree.UnionCaseRef -> TypedTree.UnionCaseRef + val remapRecdFieldRef : + TyconRefMap -> + TypedTree.RecdFieldRef -> TypedTree.RecdFieldRef + val mkTyparInst : TypedTree.Typars -> TypedTree.TType list -> TyparInst + val generalizeTypar : tp:TypedTree.Typar -> TypedTree.TType + val generalizeTypars : TypedTree.Typar list -> TypedTree.TType list + val remapTypeAux : tyenv:Remap -> ty:TypedTree.TType -> TypedTree.TType + val remapMeasureAux : + tyenv:Remap -> unt:TypedTree.Measure -> TypedTree.Measure + val remapTupInfoAux : + _tyenv:Remap -> unt:TypedTree.TupInfo -> TypedTree.TupInfo + val remapTypesAux : + tyenv:Remap -> types:TypedTree.TypeInst -> TypedTree.TypeInst + val remapTyparConstraintsAux : + tyenv:Remap -> + cs:TypedTree.TyparConstraint list -> TypedTree.TyparConstraint list + val remapTraitWitnessInfo : + tyenv:Remap -> TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo + val remapTraitInfo : + tyenv:Remap -> + TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo + val bindTypars : + tps:'a list -> tyargs:'b list -> tpinst:('a * 'b) list -> ('a * 'b) list + val copyAndRemapAndBindTyparsFull : + remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> + tyenv:Remap -> tps:TypedTree.Typar list -> TypedTree.Typar list * Remap + val copyAndRemapAndBindTypars : + tyenv:Remap -> tps:TypedTree.Typars -> TypedTree.Typars * Remap + val remapValLinkage : + tyenv:Remap -> + vlink:TypedTree.ValLinkageFullKey -> TypedTree.ValLinkageFullKey + val remapNonLocalValRef : + tyenv:Remap -> + nlvref:TypedTree.NonLocalValOrMemberRef -> + TypedTree.NonLocalValOrMemberRef + val remapValRef : Remap -> TypedTree.ValRef -> TypedTree.ValRef + val remapType : tyenv:Remap -> x:TypedTree.TType -> TypedTree.TType + val remapTypes : tyenv:Remap -> x:TypedTree.TypeInst -> TypedTree.TypeInst + val remapTypeFull : + remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> + tyenv:Remap -> ty:TypedTree.TType -> TypedTree.TType + val remapParam : tyenv:Remap -> TypedTree.SlotParam -> TypedTree.SlotParam + val remapSlotSig : + remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> + tyenv:Remap -> TypedTree.SlotSig -> TypedTree.SlotSig + val mkInstRemap : tpinst:TyparInst -> Remap + val instType : + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.TType -> TypedTree.TType + val instTypes : + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.TypeInst -> TypedTree.TypeInst + val instTrait : + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo + val instTyparConstraints : + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.TyparConstraint list -> TypedTree.TyparConstraint list + val instSlotSig : TyparInst -> TypedTree.SlotSig -> TypedTree.SlotSig + val copySlotSig : TypedTree.SlotSig -> TypedTree.SlotSig + val mkTyparToTyparRenaming : + TypedTree.Typars -> + TypedTree.Typar list -> TyparInst * TypedTree.TType list + val mkTyconInst : + tycon:TypedTree.Tycon -> tinst:TypedTree.TType list -> TyparInst + val mkTyconRefInst : TypedTree.TyconRef -> TypedTree.TType list -> TyparInst + val tyconRefEq : + TcGlobals.TcGlobals -> TypedTree.EntityRef -> TypedTree.EntityRef -> bool + val valRefEq : + TcGlobals.TcGlobals -> TypedTree.ValRef -> TypedTree.ValRef -> bool + val reduceTyconRefAbbrevMeasureable : + TypedTree.TyconRef -> TypedTree.Measure + val stripUnitEqnsFromMeasureAux : + canShortcut:bool -> unt:TypedTree.Measure -> TypedTree.Measure + val stripUnitEqnsFromMeasure : m:TypedTree.Measure -> TypedTree.Measure + val MeasureExprConExponent : + TcGlobals.TcGlobals -> + bool -> TypedTree.EntityRef -> TypedTree.Measure -> Rational.Rational + val MeasureConExponentAfterRemapping : + g:TcGlobals.TcGlobals -> + r:(TypedTree.TyconRef -> TypedTree.EntityRef) -> + ucref:TypedTree.EntityRef -> + unt:TypedTree.Measure -> Rational.Rational + val MeasureVarExponent : + TypedTree.Typar -> TypedTree.Measure -> Rational.Rational + val ListMeasureVarOccs : unt:TypedTree.Measure -> TypedTree.Typar list + val ListMeasureVarOccsWithNonZeroExponents : + TypedTree.Measure -> (TypedTree.Typar * Rational.Rational) list + val ListMeasureConOccsWithNonZeroExponents : + TcGlobals.TcGlobals -> + bool -> + TypedTree.Measure -> (TypedTree.EntityRef * Rational.Rational) list + val ListMeasureConOccsAfterRemapping : + g:TcGlobals.TcGlobals -> + r:(TypedTree.TyconRef -> TypedTree.EntityRef) -> + unt:TypedTree.Measure -> TypedTree.EntityRef list + val MeasurePower : TypedTree.Measure -> int -> TypedTree.Measure + val MeasureProdOpt : + m1:TypedTree.Measure -> m2:TypedTree.Measure -> TypedTree.Measure + val ProdMeasures : TypedTree.Measure list -> TypedTree.Measure + val isDimensionless : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val destUnitParMeasure : + g:TcGlobals.TcGlobals -> unt:TypedTree.Measure -> TypedTree.Typar + val isUnitParMeasure : + g:TcGlobals.TcGlobals -> unt:TypedTree.Measure -> bool + val normalizeMeasure : + TcGlobals.TcGlobals -> TypedTree.Measure -> TypedTree.Measure + val tryNormalizeMeasureInType : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkNativePtrTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkInByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkOutByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkByrefTyWithFlag : + g:TcGlobals.TcGlobals -> + readonly:bool -> ty:TypedTree.TType -> TypedTree.TType + val mkByref2Ty : + g:TcGlobals.TcGlobals -> + ty1:TypedTree.TType -> ty2:TypedTree.TType -> TypedTree.TType + val mkVoidPtrTy : TcGlobals.TcGlobals -> TypedTree.TType + val mkByrefTyWithInference : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType -> TypedTree.TType + val mkArrayTy : + TcGlobals.TcGlobals -> + int -> TypedTree.TType -> Range.range -> TypedTree.TType + val maxTuple : int + val goodTupleFields : int + val isCompiledTupleTyconRef : + TcGlobals.TcGlobals -> TypedTree.EntityRef -> bool + val mkCompiledTupleTyconRef : + TcGlobals.TcGlobals -> bool -> int -> TypedTree.EntityRef + val mkCompiledTupleTy : + TcGlobals.TcGlobals -> bool -> TypedTree.TType list -> TypedTree.TType + val mkOuterCompiledTupleTy : + g:TcGlobals.TcGlobals -> + isStruct:bool -> tupElemTys:TypedTree.TType list -> TypedTree.TType + val applyTyconAbbrev : + abbrevTy:TypedTree.TType -> + tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType + val reduceTyconAbbrev : + tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType + val reduceTyconRefAbbrev : + TypedTree.TyconRef -> TypedTree.TType list -> TypedTree.TType + val reduceTyconMeasureableOrProvided : + g:TcGlobals.TcGlobals -> + tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType + val reduceTyconRefMeasureableOrProvided : + TcGlobals.TcGlobals -> + TypedTree.TyconRef -> TypedTree.TType list -> TypedTree.TType + val stripTyEqnsA : + TcGlobals.TcGlobals -> bool -> TypedTree.TType -> TypedTree.TType + val stripTyEqns : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val evalTupInfoIsStruct : TypedTree.TupInfo -> bool + val evalAnonInfoIsStruct : TypedTree.AnonRecdTypeInfo -> bool + val stripTyEqnsAndErase : + eraseFuncAndTuple:bool -> + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + val stripTyEqnsAndMeasureEqns : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + type Erasure = + | EraseAll + | EraseMeasures + | EraseNone + val stripTyEqnsWrtErasure : + Erasure -> TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val stripExnEqns : TypedTree.TyconRef -> TypedTree.Entity + val primDestForallTy : + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> TypedTree.Typars * TypedTree.TType + val destFunTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType * TypedTree.TType + val destAnyTupleTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TupInfo * TypedTree.TTypes + val destRefTupleTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes + val destStructTupleTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes + val destTyparTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar + val destAnyParTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar + val destMeasureTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Measure + val isFunTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isForallTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isAnyTupleTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isRefTupleTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isStructTupleTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isAnonRecdTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isStructAnonRecdTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isUnionTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isReprHiddenTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isFSharpObjModelTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isRecdTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isFSharpStructOrEnumTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isFSharpEnumTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isTyparTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isAnyParTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isMeasureTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isProvenUnionCaseTy : TypedTree.TType -> bool + val mkAppTy : TypedTree.TyconRef -> TypedTree.TypeInst -> TypedTree.TType + val mkProvenUnionCaseTy : + TypedTree.UnionCaseRef -> TypedTree.TypeInst -> TypedTree.TType + val isAppTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val tryAppTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> (TypedTree.TyconRef * TypedTree.TypeInst) voption + val destAppTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TyconRef * TypedTree.TypeInst + val tcrefOfAppTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TyconRef + val argsOfAppTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TypeInst + val tryDestTyparTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar voption + val tryDestFunTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> (TypedTree.TType * TypedTree.TType) voption + val tryTcrefOfAppTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TyconRef voption + val tryDestAnonRecdTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> + (TypedTree.AnonRecdTypeInfo * TypedTree.TType list) voption + val tryAnyParTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar voption + val tryAnyParTyOption : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar option + val ( |AppTy|_| ) : + TcGlobals.TcGlobals -> + TypedTree.TType -> (TypedTree.TyconRef * TypedTree.TypeInst) option + val ( |RefTupleTy|_| ) : + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TTypes option + val ( |FunTy|_| ) : + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> (TypedTree.TType * TypedTree.TType) option + val tryNiceEntityRefOfTy : TypedTree.TType -> TypedTree.TyconRef voption + val tryNiceEntityRefOfTyOption : + TypedTree.TType -> TypedTree.TyconRef option + val mkInstForAppTy : TcGlobals.TcGlobals -> TypedTree.TType -> TyparInst + val domainOfFunTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val rangeOfFunTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val convertToTypeWithMetadataIfPossible : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val stripMeasuresFromTType : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + [] + type TypeEquivEnv = + { EquivTypars: TyparMap + EquivTycons: TyconRefRemap } + with + static member + FromEquivTypars : TypedTree.Typar list -> + TypedTree.Typar list -> TypeEquivEnv + static member + FromTyparInst : (TypedTree.Typar * TypedTree.TType) list -> + TypeEquivEnv + member + BindEquivTypars : TypedTree.Typar list -> + TypedTree.Typar list -> TypeEquivEnv + member + BindTyparsToTypes : tps1:TypedTree.Typar list -> + tys2:TypedTree.TType list -> TypeEquivEnv + static member Empty : TypeEquivEnv + end + val typeEquivEnvEmpty : TypeEquivEnv + val traitsAEquivAux : + Erasure -> + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TraitConstraintInfo -> + TypedTree.TraitConstraintInfo -> bool + val traitKeysAEquivAux : + Erasure -> + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo -> bool + val returnTypesAEquivAux : + Erasure -> + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TType option -> TypedTree.TType option -> bool + val typarConstraintsAEquivAux : + Erasure -> + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TyparConstraint -> TypedTree.TyparConstraint -> bool + val typarConstraintSetsAEquivAux : + erasureFlag:Erasure -> + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + tp1:TypedTree.Typar -> tp2:TypedTree.Typar -> bool + val typarsAEquivAux : + erasureFlag:Erasure -> + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + tps1:TypedTree.Typar list -> tps2:TypedTree.Typar list -> bool + val tcrefAEquiv : + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.EntityRef -> TypedTree.EntityRef -> bool + val typeAEquivAux : + Erasure -> + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.TType -> TypedTree.TType -> bool + val anonInfoEquiv : + TypedTree.AnonRecdTypeInfo -> TypedTree.AnonRecdTypeInfo -> bool + val structnessAEquiv : + un1:TypedTree.TupInfo -> un2:TypedTree.TupInfo -> bool + val measureAEquiv : + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + un1:TypedTree.Measure -> un2:TypedTree.Measure -> bool + val typesAEquivAux : + erasureFlag:Erasure -> + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + l1:TypedTree.TypeInst -> l2:TypedTree.TypeInst -> bool + val typeEquivAux : + Erasure -> + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType -> bool + val typeAEquiv : + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.TType -> TypedTree.TType -> bool + val typeEquiv : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType -> bool + val traitsAEquiv : + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo -> bool + val traitKeysAEquiv : + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo -> bool + val typarConstraintsAEquiv : + TcGlobals.TcGlobals -> + TypeEquivEnv -> + TypedTree.TyparConstraint -> TypedTree.TyparConstraint -> bool + val typarsAEquiv : + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.Typar list -> TypedTree.Typar list -> bool + val returnTypesAEquiv : + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.TType option -> TypedTree.TType option -> bool + val measureEquiv : + TcGlobals.TcGlobals -> TypedTree.Measure -> TypedTree.Measure -> bool + val getMeasureOfType : + TcGlobals.TcGlobals -> + TypedTree.TType -> (TypedTree.TyconRef * TypedTree.Measure) option + val isErasedType : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val getErasedTypes : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType list + val valOrder : System.Collections.Generic.IComparer + val tyconOrder : System.Collections.Generic.IComparer + val recdFieldRefOrder : + System.Collections.Generic.IComparer + val unionCaseRefOrder : + System.Collections.Generic.IComparer + val mkFunTy : TypedTree.TType -> TypedTree.TType -> TypedTree.TType + val ( --> ) : TypedTree.TType -> TypedTree.TType -> TypedTree.TType + val mkForallTy : d:TypedTree.Typars -> r:TypedTree.TType -> TypedTree.TType + val mkForallTyIfNeeded : + TypedTree.Typar list -> TypedTree.TType -> TypedTree.TType + val ( +-> ) : TypedTree.Typar list -> TypedTree.TType -> TypedTree.TType + val mkIteratedFunTy : + TypedTree.TType list -> TypedTree.TType -> TypedTree.TType + val mkLambdaArgTy : + m:Range.range -> tys:TypedTree.TType list -> TypedTree.TType + val typeOfLambdaArg : Range.range -> TypedTree.Val list -> TypedTree.TType + val mkMultiLambdaTy : + Range.range -> TypedTree.Val list -> TypedTree.TType -> TypedTree.TType + val mkLambdaTy : + TypedTree.Typar list -> + TypedTree.TType list -> TypedTree.TType -> TypedTree.TType + val ensureCcuHasModuleOrNamespaceAtPath : + TypedTree.CcuThunk -> + SyntaxTree.Ident list -> + TypedTree.CompilationPath -> XmlDoc.XmlDoc -> unit + val stripExpr : TypedTree.Expr -> TypedTree.Expr + val mkCase : + TypedTree.DecisionTreeTest * TypedTree.DecisionTree -> + TypedTree.DecisionTreeCase + val isRefTupleExpr : TypedTree.Expr -> bool + val tryDestRefTupleExpr : TypedTree.Expr -> TypedTree.Exprs + val rangeOfExpr : x:TypedTree.Expr -> Range.range + type Expr with + member Range : Range.range + val primMkMatch : + SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * + TypedTree.DecisionTreeTarget array * Range.range * TypedTree.TType -> + TypedTree.Expr + type MatchBuilder = + class + new : SyntaxTree.DebugPointForBinding * Range.range -> MatchBuilder + member + AddResultTarget : TypedTree.Expr * SyntaxTree.DebugPointForTarget -> + TypedTree.DecisionTree + member AddTarget : TypedTree.DecisionTreeTarget -> int + member + Close : TypedTree.DecisionTree * Range.range * TypedTree.TType -> + TypedTree.Expr + member CloseTargets : unit -> TypedTree.DecisionTreeTarget list + end + val mkBoolSwitch : + Range.range -> + TypedTree.Expr -> + TypedTree.DecisionTree -> + TypedTree.DecisionTree -> TypedTree.DecisionTree + val primMkCond : + SyntaxTree.DebugPointForBinding -> + SyntaxTree.DebugPointForTarget -> + SyntaxTree.DebugPointForTarget -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCond : + SyntaxTree.DebugPointForBinding -> + SyntaxTree.DebugPointForTarget -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val exprForValRef : Range.range -> TypedTree.ValRef -> TypedTree.Expr + val exprForVal : Range.range -> TypedTree.Val -> TypedTree.Expr + val mkLocalAux : + m:Range.range -> + s:string -> + ty:TypedTree.TType -> + mut:TypedTree.ValMutability -> + compgen:bool -> TypedTree.Val * TypedTree.Expr + val mkLocal : + Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr + val mkCompGenLocal : + Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr + val mkMutableCompGenLocal : + Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr + val mkMultiLambda : + Range.range -> + TypedTree.Val list -> TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val rebuildLambda : + Range.range -> + TypedTree.Val option -> + TypedTree.Val option -> + TypedTree.Val list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkLambda : + Range.range -> + TypedTree.Val -> TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkTypeLambda : + Range.range -> + TypedTree.Typar list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkTypeChoose : + Range.range -> TypedTree.Typar list -> TypedTree.Expr -> TypedTree.Expr + val mkObjExpr : + TypedTree.TType * TypedTree.Val option * TypedTree.Expr * + TypedTree.ObjExprMethod list * + (TypedTree.TType * TypedTree.ObjExprMethod list) list * Range.range -> + TypedTree.Expr + val mkLambdas : + Range.range -> + TypedTree.Typar list -> + TypedTree.Val list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkMultiLambdasCore : + Range.range -> + TypedTree.Val list list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr * TypedTree.TType + val mkMultiLambdas : + Range.range -> + TypedTree.Typar list -> + TypedTree.Val list list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkMemberLambdas : + Range.range -> + TypedTree.Typar list -> + TypedTree.Val option -> + TypedTree.Val option -> + TypedTree.Val list list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Expr + val mkMultiLambdaBind : + TypedTree.Val -> + SyntaxTree.DebugPointForBinding -> + Range.range -> + TypedTree.Typar list -> + TypedTree.Val list list -> + TypedTree.Expr * TypedTree.TType -> TypedTree.Binding + val mkBind : + SyntaxTree.DebugPointForBinding -> + TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding + val mkLetBind : + Range.range -> TypedTree.Binding -> TypedTree.Expr -> TypedTree.Expr + val mkLetsBind : + Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr + val mkLetsFromBindings : + Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr + val mkLet : + SyntaxTree.DebugPointForBinding -> + Range.range -> + TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCompGenBind : TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding + val mkCompGenBinds : + TypedTree.Val list -> TypedTree.Expr list -> TypedTree.Binding list + val mkCompGenLet : + Range.range -> + TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCompGenLets : + m:Range.range -> + vs:TypedTree.Val list -> + xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr + val mkCompGenLetsFromBindings : + m:Range.range -> + vs:TypedTree.Val list -> + xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr + val mkInvisibleBind : TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding + val mkInvisibleBinds : + TypedTree.Val list -> TypedTree.Expr list -> TypedTree.Binding list + val mkInvisibleLet : + Range.range -> + TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkInvisibleLets : + m:Range.range -> + vs:TypedTree.Val list -> + xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr + val mkInvisibleLetsFromBindings : + m:Range.range -> + vs:TypedTree.Val list -> + xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr + val mkLetRecBinds : + Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr + val NormalizeDeclaredTyparsForEquiRecursiveInference : + TcGlobals.TcGlobals -> TypedTree.Typar list -> TypedTree.Typar list + type TypeScheme = | TypeScheme of TypedTree.Typars * TypedTree.TType + val mkGenericBindRhs : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Typar list -> TypeScheme -> TypedTree.Expr -> TypedTree.Expr + val isBeingGeneralized : TypedTree.Typar -> TypeScheme -> bool + val mkLazyAnd : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkLazyOr : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCoerceExpr : + TypedTree.Expr * TypedTree.TType * Range.range * TypedTree.TType -> + TypedTree.Expr + val mkAsmExpr : + AbstractIL.IL.ILInstr list * TypedTree.TypeInst * TypedTree.Exprs * + TypedTree.TTypes * Range.range -> TypedTree.Expr + val mkUnionCaseExpr : + TypedTree.UnionCaseRef * TypedTree.TypeInst * TypedTree.Exprs * + Range.range -> TypedTree.Expr + val mkExnExpr : + TypedTree.TyconRef * TypedTree.Exprs * Range.range -> TypedTree.Expr + val mkTupleFieldGetViaExprAddr : + tupInfo:TypedTree.TupInfo * e:TypedTree.Expr * tinst:TypedTree.TypeInst * + i:int * m:Range.range -> TypedTree.Expr + val mkAnonRecdFieldGetViaExprAddr : + TypedTree.AnonRecdTypeInfo * TypedTree.Expr * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkRecdFieldGetViaExprAddr : + TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> + TypedTree.Expr + val mkRecdFieldGetAddrViaExprAddr : + readonly:bool * TypedTree.Expr * TypedTree.RecdFieldRef * + TypedTree.TypeInst * Range.range -> TypedTree.Expr + val mkStaticRecdFieldGetAddr : + readonly:bool * TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> + TypedTree.Expr + val mkStaticRecdFieldGet : + TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> + TypedTree.Expr + val mkStaticRecdFieldSet : + TypedTree.RecdFieldRef * TypedTree.TypeInst * TypedTree.Expr * Range.range -> + TypedTree.Expr + val mkArrayElemAddress : + TcGlobals.TcGlobals -> + readonly:bool * AbstractIL.IL.ILReadonly * bool * + AbstractIL.IL.ILArrayShape * TypedTree.TType * TypedTree.Exprs * + Range.range -> TypedTree.Expr + val mkRecdFieldSetViaExprAddr : + TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * + TypedTree.Expr * Range.range -> TypedTree.Expr + val mkUnionCaseTagGetViaExprAddr : + TypedTree.Expr * TypedTree.TyconRef * TypedTree.TypeInst * Range.range -> + TypedTree.Expr + val mkUnionCaseProof : + TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * Range.range -> + TypedTree.Expr + val mkUnionCaseFieldGetProvenViaExprAddr : + TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkUnionCaseFieldGetAddrProvenViaExprAddr : + readonly:bool * TypedTree.Expr * TypedTree.UnionCaseRef * + TypedTree.TypeInst * int * Range.range -> TypedTree.Expr + val mkUnionCaseFieldGetUnprovenViaExprAddr : + TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkUnionCaseFieldSet : + TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * + TypedTree.Expr * Range.range -> TypedTree.Expr + val mkExnCaseFieldGet : + TypedTree.Expr * TypedTree.TyconRef * int * Range.range -> TypedTree.Expr + val mkExnCaseFieldSet : + TypedTree.Expr * TypedTree.TyconRef * int * TypedTree.Expr * Range.range -> + TypedTree.Expr + val mkDummyLambda : + g:TcGlobals.TcGlobals -> + e:TypedTree.Expr * ety:TypedTree.TType -> TypedTree.Expr + val mkWhile : + TcGlobals.TcGlobals -> + SyntaxTree.DebugPointAtWhile * TypedTree.SpecialWhileLoopMarker * + TypedTree.Expr * TypedTree.Expr * Range.range -> TypedTree.Expr + val mkFor : + TcGlobals.TcGlobals -> + SyntaxTree.DebugPointAtFor * TypedTree.Val * TypedTree.Expr * + TypedTree.ForLoopStyle * TypedTree.Expr * TypedTree.Expr * Range.range -> + TypedTree.Expr + val mkTryWith : + TcGlobals.TcGlobals -> + TypedTree.Expr * TypedTree.Val * TypedTree.Expr * TypedTree.Val * + TypedTree.Expr * Range.range * TypedTree.TType * + SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith -> + TypedTree.Expr + val mkTryFinally : + TcGlobals.TcGlobals -> + TypedTree.Expr * TypedTree.Expr * Range.range * TypedTree.TType * + SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally -> + TypedTree.Expr + val mkDefault : Range.range * TypedTree.TType -> TypedTree.Expr + val mkValSet : + Range.range -> TypedTree.ValRef -> TypedTree.Expr -> TypedTree.Expr + val mkAddrSet : + Range.range -> TypedTree.ValRef -> TypedTree.Expr -> TypedTree.Expr + val mkAddrGet : Range.range -> TypedTree.ValRef -> TypedTree.Expr + val mkValAddr : + Range.range -> readonly:bool -> TypedTree.ValRef -> TypedTree.Expr + [] + type ValHash<'T> = + | ValHash of System.Collections.Generic.Dictionary + with + static member Create : unit -> ValHash<'T> + member Add : TypedTree.Val * 'T -> unit + member TryFind : TypedTree.Val -> 'T option + member Values : seq<'T> + end + [] + type ValMultiMap<'T> = + struct + new : contents:TypedTree.StampMap<'T list> -> ValMultiMap<'T> + member Add : TypedTree.Val * 'T -> ValMultiMap<'T> + member ContainsKey : TypedTree.Val -> bool + member Find : TypedTree.Val -> 'T list + member Remove : TypedTree.Val -> ValMultiMap<'T> + member Contents : TypedTree.StampMap<'T list> + static member Empty : ValMultiMap<'T> + end + [] + type TyconRefMultiMap<'T> = + struct + new : contents:TyconRefMap<'T list> -> TyconRefMultiMap<'T> + static member + OfList : (TypedTree.TyconRef * 'T) list -> TyconRefMultiMap<'T> + member Add : TypedTree.TyconRef * 'T -> TyconRefMultiMap<'T> + member Find : TypedTree.TyconRef -> 'T list + static member Empty : TyconRefMultiMap<'T> + end + val tryRescopeEntity : + TypedTree.CcuThunk -> TypedTree.Entity -> ValueOption + val tryRescopeVal : + TypedTree.CcuThunk -> + Remap -> TypedTree.Val -> ValueOption + val actualTyOfRecdField : + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.RecdField -> TypedTree.TType + val actualTysOfRecdFields : + inst:(TypedTree.Typar * TypedTree.TType) list -> + rfields:TypedTree.RecdField list -> TypedTree.TType list + val actualTysOfInstanceRecdFields : + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.TyconRef -> TypedTree.TType list + val actualTysOfUnionCaseFields : + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.UnionCaseRef -> TypedTree.TType list + val actualResultTyOfUnionCase : + TypedTree.TType list -> TypedTree.UnionCaseRef -> TypedTree.TType + val recdFieldsOfExnDefRef : TypedTree.TyconRef -> TypedTree.RecdField list + val recdFieldOfExnDefRefByIdx : + x:TypedTree.TyconRef -> n:int -> TypedTree.RecdField + val recdFieldTysOfExnDefRef : TypedTree.TyconRef -> TypedTree.TType list + val recdFieldTyOfExnDefRefByIdx : + x:TypedTree.TyconRef -> j:int -> TypedTree.TType + val actualTyOfRecdFieldForTycon : + TypedTree.Tycon -> + TypedTree.TType list -> TypedTree.RecdField -> TypedTree.TType + val actualTyOfRecdFieldRef : + TypedTree.RecdFieldRef -> TypedTree.TType list -> TypedTree.TType + val actualTyOfUnionFieldRef : + fref:TypedTree.UnionCaseRef -> + n:int -> tinst:TypedTree.TType list -> TypedTree.TType + val destForallTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.Typar list * TypedTree.TType + val tryDestForallTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.Typar list * TypedTree.TType + val stripFunTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType list * TypedTree.TType + val applyForallTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType list -> TypedTree.TType + val reduceIteratedFunTy : + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> args:'a list -> TypedTree.TType + val applyTyArgs : + g:TcGlobals.TcGlobals -> + functy:TypedTree.TType -> tyargs:TypedTree.TType list -> TypedTree.TType + val applyTys : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType list * 'T list -> TypedTree.TType + val formalApplyTys : + g:TcGlobals.TcGlobals -> + functy:TypedTree.TType -> + tyargs:'a list * args:'b list -> TypedTree.TType + val stripFunTyN : + TcGlobals.TcGlobals -> + int -> TypedTree.TType -> TypedTree.TType list * TypedTree.TType + val tryDestAnyTupleTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TupInfo * TypedTree.TTypes + val tryDestRefTupleTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes + type UncurriedArgInfos = (TypedTree.TType * TypedTree.ArgReprInfo) list + type CurriedArgInfos = (TypedTree.TType * TypedTree.ArgReprInfo) list list + type TraitWitnessInfos = TypedTree.TraitWitnessInfo list + val GetTopTauTypeInFSharpForm : + TcGlobals.TcGlobals -> + TypedTree.ArgReprInfo list list -> + TypedTree.TType -> + Range.range -> + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType + val destTopForallTy : + TcGlobals.TcGlobals -> + TypedTree.ValReprInfo -> + TypedTree.TType -> TypedTree.Typar list * TypedTree.TType + val GetTopValTypeInFSharpForm : + TcGlobals.TcGlobals -> + TypedTree.ValReprInfo -> + TypedTree.TType -> + Range.range -> + TypedTree.Typar list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType * TypedTree.ArgReprInfo + val IsCompiledAsStaticProperty : + TcGlobals.TcGlobals -> TypedTree.Val -> bool + val IsCompiledAsStaticPropertyWithField : + TcGlobals.TcGlobals -> TypedTree.Val -> bool + val isArrayTyconRef : TcGlobals.TcGlobals -> TypedTree.EntityRef -> bool + val rankOfArrayTyconRef : TcGlobals.TcGlobals -> TypedTree.EntityRef -> int + val destArrayTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val destListTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val tyconRefEqOpt : + g:TcGlobals.TcGlobals -> + tcOpt:TypedTree.EntityRef option -> tc:TypedTree.EntityRef -> bool + val isStringTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isListTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isArrayTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isArray1DTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isUnitTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isObjTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isValueTypeTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isVoidTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isILAppTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isNativePtrTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isInByrefTag : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isInByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isOutByrefTag : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isOutByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val extensionInfoOfTy : + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> TypedTree.TyconRepresentation + type TypeDefMetadata = + | ILTypeMetadata of TypedTree.TILObjectReprData + | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata + | ProvidedTypeMetadata of TypedTree.TProvidedTypeInfo + val metadataOfTycon : TypedTree.Tycon -> TypeDefMetadata + val metadataOfTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypeDefMetadata + val isILReferenceTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isILInterfaceTycon : tycon:TypedTree.Tycon -> bool + val rankOfArrayTy : TcGlobals.TcGlobals -> TypedTree.TType -> int + val isFSharpObjModelRefTy : + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isFSharpClassTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isFSharpStructTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isFSharpInterfaceTy : + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isDelegateTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isInterfaceTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isClassTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isStructOrEnumTyconTy : + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isStructRecordOrUnionTyconTy : + TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isStructTyconRef : tcref:TypedTree.TyconRef -> bool + val isStructTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isRefTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isForallFunctionTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isUnmanagedTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isInterfaceTycon : x:TypedTree.Tycon -> bool + val isInterfaceTyconRef : TypedTree.TyconRef -> bool + val isEnumTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val actualReturnTyOfSlotSig : + TypedTree.TType list -> + TypedTree.TType list -> TypedTree.SlotSig -> TypedTree.TType option + val slotSigHasVoidReturnTy : TypedTree.SlotSig -> bool + val returnTyOfMethod : + TcGlobals.TcGlobals -> TypedTree.ObjExprMethod -> TypedTree.TType option + val isAbstractTycon : TypedTree.Tycon -> bool + val MemberIsExplicitImpl : + TcGlobals.TcGlobals -> TypedTree.ValMemberInfo -> bool + val ValIsExplicitImpl : TcGlobals.TcGlobals -> TypedTree.Val -> bool + val ValRefIsExplicitImpl : TcGlobals.TcGlobals -> TypedTree.ValRef -> bool + val emptyFreeLocals : AbstractIL.Internal.Zset + val unionFreeLocals : + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset + val emptyFreeRecdFields : AbstractIL.Internal.Zset + val unionFreeRecdFields : + s1:AbstractIL.Internal.Zset -> + s2:AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset + val emptyFreeUnionCases : AbstractIL.Internal.Zset + val unionFreeUnionCases : + s1:AbstractIL.Internal.Zset -> + s2:AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset + val emptyFreeTycons : AbstractIL.Internal.Zset + val unionFreeTycons : + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset + val typarOrder : System.Collections.Generic.IComparer + val emptyFreeTypars : AbstractIL.Internal.Zset + val unionFreeTypars : + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset -> + AbstractIL.Internal.Zset + val emptyFreeTyvars : TypedTree.FreeTyvars + val isEmptyFreeTyvars : TypedTree.FreeTyvars -> bool + val unionFreeTyvars : + TypedTree.FreeTyvars -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars + type FreeVarOptions = + { canCache: bool + collectInTypes: bool + includeLocalTycons: bool + includeTypars: bool + includeLocalTyconReprs: bool + includeRecdFields: bool + includeUnionCases: bool + includeLocals: bool } + val CollectAllNoCaching : FreeVarOptions + val CollectTyparsNoCaching : FreeVarOptions + val CollectLocalsNoCaching : FreeVarOptions + val CollectTyparsAndLocalsNoCaching : FreeVarOptions + val CollectAll : FreeVarOptions + val CollectTyparsAndLocals : FreeVarOptions + val CollectTypars : FreeVarOptions + val CollectLocals : FreeVarOptions + val accFreeLocalTycon : + opts:FreeVarOptions -> + x:TypedTree.Tycon -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeTycon : + opts:FreeVarOptions -> + tcref:TypedTree.TyconRef -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val boundTypars : + opts:FreeVarOptions -> + tps:TypedTree.Typar list -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTyparConstraints : + opts:FreeVarOptions -> + cxs:TypedTree.TyparConstraint list -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTyparConstraint : + opts:FreeVarOptions -> + tpc:TypedTree.TyparConstraint -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTrait : + opts:FreeVarOptions -> + TypedTree.TraitConstraintInfo -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInWitnessArg : + opts:FreeVarOptions -> + TypedTree.TraitWitnessInfo -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTraitSln : + opts:FreeVarOptions -> + sln:TypedTree.TraitConstraintSln -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeLocalValInTraitSln : + _opts:'a -> + v:TypedTree.Val -> fvs:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeValRefInTraitSln : + opts:FreeVarOptions -> + vref:TypedTree.ValRef -> + fvs:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeTyparRef : + opts:FreeVarOptions -> + tp:TypedTree.Typar -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInType : + FreeVarOptions -> + TypedTree.TType -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTupInfo : + _opts:FreeVarOptions -> + unt:TypedTree.TupInfo -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInMeasure : + opts:FreeVarOptions -> + unt:TypedTree.Measure -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val accFreeInTypes : + FreeVarOptions -> + TypedTree.TTypes -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val freeInType : FreeVarOptions -> TypedTree.TType -> TypedTree.FreeTyvars + val accFreeInVal : + opts:FreeVarOptions -> + v:TypedTree.Val -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val freeInTypes : FreeVarOptions -> TypedTree.TTypes -> TypedTree.FreeTyvars + val freeInVal : FreeVarOptions -> TypedTree.Val -> TypedTree.FreeTyvars + val freeInTyparConstraints : + opts:FreeVarOptions -> + v:TypedTree.TyparConstraint list -> TypedTree.FreeTyvars + val accFreeInTypars : + FreeVarOptions -> + TypedTree.Typar list -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val addFreeInModuleTy : + mtyp:TypedTree.ModuleOrNamespaceType -> + acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars + val freeInModuleTy : TypedTree.ModuleOrNamespaceType -> TypedTree.FreeTyvars + val emptyFreeTyparsLeftToRight : 'a list + val unionFreeTyparsLeftToRight : + fvs1:TypedTree.Typar list -> + fvs2:TypedTree.Typar list -> TypedTree.Typar list + val boundTyparsLeftToRight : + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + tps:TypedTree.Typar list -> TypedTree.Typar list + val accFreeInTyparConstraintsLeftToRight : + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + cxs:TypedTree.TyparConstraint list -> TypedTree.Typar list + val accFreeInTyparConstraintLeftToRight : + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + tpc:TypedTree.TyparConstraint -> TypedTree.Typar list + val accFreeInTraitLeftToRight : + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + TypedTree.TraitConstraintInfo -> TypedTree.Typar list + val accFreeTyparRefLeftToRight : + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + tp:TypedTree.Typar -> TypedTree.Typar list + val accFreeInTypeLeftToRight : + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + ty:TypedTree.TType -> TypedTree.Typar list + val accFreeInTupInfoLeftToRight : + _g:TcGlobals.TcGlobals -> + _cxFlag:bool -> + _thruFlag:bool -> + acc:TypedTree.Typar list -> + unt:TypedTree.TupInfo -> TypedTree.Typar list + val accFreeInTypesLeftToRight : + g:TcGlobals.TcGlobals -> + cxFlag:bool -> + thruFlag:bool -> + acc:TypedTree.Typar list -> + tys:TypedTree.TTypes -> TypedTree.Typar list + val freeInTypeLeftToRight : + TcGlobals.TcGlobals -> bool -> TypedTree.TType -> TypedTree.Typar list + val freeInTypesLeftToRight : + TcGlobals.TcGlobals -> bool -> TypedTree.TTypes -> TypedTree.Typar list + val freeInTypesLeftToRightSkippingConstraints : + TcGlobals.TcGlobals -> TypedTree.TTypes -> TypedTree.Typar list + val valOfBind : b:TypedTree.Binding -> TypedTree.Val + val valsOfBinds : TypedTree.Bindings -> TypedTree.Val list + val GetMemberTypeInFSharpForm : + g:TcGlobals.TcGlobals -> + memberFlags:SyntaxTree.MemberFlags -> + arities:TypedTree.ValReprInfo -> + ty:TypedTree.TType -> + m:Range.range -> + TypedTree.Typar list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType * TypedTree.ArgReprInfo + val checkMemberVal : + membInfo:'a option -> arity:'b option -> m:Range.range -> 'a * 'b + val checkMemberValRef : + vref:TypedTree.ValRef -> TypedTree.ValMemberInfo * TypedTree.ValReprInfo + val GetTraitConstraintInfosOfTypars : + TcGlobals.TcGlobals -> + TypedTree.Typars -> TypedTree.TraitConstraintInfo list + val GetTraitWitnessInfosOfTypars : + TcGlobals.TcGlobals -> + numParentTypars:int -> + typars:TypedTree.Typar list -> TypedTree.TraitWitnessInfo list + val CountEnclosingTyparsOfActualParentOfVal : TypedTree.Val -> int + val GetTopValTypeInCompiledForm : + TcGlobals.TcGlobals -> + TypedTree.ValReprInfo -> + int -> + TypedTree.TType -> + Range.range -> + TypedTree.Typar list * TypedTree.TraitWitnessInfo list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType option * TypedTree.ArgReprInfo + val GetMemberTypeInMemberForm : + TcGlobals.TcGlobals -> + SyntaxTree.MemberFlags -> + TypedTree.ValReprInfo -> + int -> + TypedTree.TType -> + Range.range -> + TypedTree.Typar list * TypedTree.TraitWitnessInfo list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType option * TypedTree.ArgReprInfo + val GetTypeOfMemberInMemberForm : + TcGlobals.TcGlobals -> + TypedTree.ValRef -> + TypedTree.Typar list * TypedTree.TraitWitnessInfo list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType option * TypedTree.ArgReprInfo + val GetTypeOfMemberInFSharpForm : + TcGlobals.TcGlobals -> + TypedTree.ValRef -> + TypedTree.Typar list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * TypedTree.TType * + TypedTree.ArgReprInfo + val PartitionValTyparsForApparentEnclosingType : + TcGlobals.TcGlobals -> + TypedTree.Val -> + (TypedTree.Typars * TypedTree.Typar list * TypedTree.Typar list * + TyparInst * TypedTree.TType list) option + val PartitionValTypars : + TcGlobals.TcGlobals -> + TypedTree.Val -> + (TypedTree.Typar list * TypedTree.Typar list * TypedTree.Typar list * + TyparInst * TypedTree.TType list) option + val PartitionValRefTypars : + TcGlobals.TcGlobals -> + TypedTree.ValRef -> + (TypedTree.Typar list * TypedTree.Typar list * TypedTree.Typar list * + TyparInst * TypedTree.TType list) option + val ArgInfosOfMemberVal : + g:TcGlobals.TcGlobals -> + v:TypedTree.Val -> (TypedTree.TType * TypedTree.ArgReprInfo) list list + val ArgInfosOfMember : + TcGlobals.TcGlobals -> + TypedTree.ValRef -> (TypedTree.TType * TypedTree.ArgReprInfo) list list + val GetFSharpViewOfReturnType : + TcGlobals.TcGlobals -> TypedTree.TType option -> TypedTree.TType + val ReturnTypeOfPropertyVal : + TcGlobals.TcGlobals -> TypedTree.Val -> TypedTree.TType + val ArgInfosOfPropertyVal : + TcGlobals.TcGlobals -> + TypedTree.Val -> (TypedTree.TType * TypedTree.ArgReprInfo) list + val generalTyconRefInst : tc:TypedTree.TyconRef -> TypedTree.TType list + val generalizeTyconRef : + TypedTree.TyconRef -> TypedTree.TType list * TypedTree.TType + val generalizedTyconRef : TypedTree.TyconRef -> TypedTree.TType + val isTTyparSupportsStaticMethod : _arg1:TypedTree.TyparConstraint -> bool + val isTTyparCoercesToType : _arg1:TypedTree.TyparConstraint -> bool + val prefixOfStaticReq : SyntaxTree.TyparStaticReq -> string + val prefixOfRigidTypar : TypedTree.Typar -> string + type TyparConstraintsWithTypars = + (TypedTree.Typar * TypedTree.TyparConstraint) list + module PrettyTypes = begin + val newPrettyTypar : tp:TypedTree.Typar -> nm:string -> TypedTree.Typar + val NewPrettyTypars : + (TypedTree.Typar * TypedTree.TType) list -> + TypedTree.Typar list -> + string list -> + TypedTree.Typar list * (TypedTree.Typar * TypedTree.TType) list + val NeedsPrettyTyparName : TypedTree.Typar -> bool + val PrettyTyparNames : + (TypedTree.Typar -> bool) -> + string list -> TypedTree.Typar list -> string list + val PrettifyThings : + g:TcGlobals.TcGlobals -> + foldTys:((TypedTree.Typar list -> TypedTree.TType -> + TypedTree.Typar list) -> 'a list -> 'b -> + TypedTree.Typar list) -> + mapTys:((TypedTree.TType -> TypedTree.TType) -> 'b -> 'b) -> + things:'b -> + 'b * (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyType : + TcGlobals.TcGlobals -> + TypedTree.TType -> + TypedTree.TType * (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyTypePair : + TcGlobals.TcGlobals -> + TypedTree.TType * TypedTree.TType -> + (TypedTree.TType * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyTypes : + TcGlobals.TcGlobals -> + TypedTree.TType list -> + TypedTree.TType list * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyDiscriminantAndTypePairs : + TcGlobals.TcGlobals -> + ('Discriminant * TypedTree.TType) list -> + ('Discriminant * TypedTree.TType) list * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyCurriedTypes : + TcGlobals.TcGlobals -> + TypedTree.TType list list -> + TypedTree.TType list list * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyCurriedSigTypes : + TcGlobals.TcGlobals -> + TypedTree.TType list list * TypedTree.TType -> + (TypedTree.TType list list * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val safeDestAnyParTy : + orig:TypedTree.Typar -> + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.Typar + val tee : f:('a -> 'a -> 'b) -> x:'a -> 'b + val foldUnurriedArgInfos : + f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:UncurriedArgInfos -> 'a + val mapUnurriedArgInfos : + f:(TypedTree.TType -> 'a) -> + x:UncurriedArgInfos -> ('a * TypedTree.ArgReprInfo) list + val foldTypar : + f:('a -> TypedTree.TType -> 'b) -> z:'a -> x:TypedTree.Typar -> 'b + val mapTypar : + g:TcGlobals.TcGlobals -> + f:(TypedTree.TType -> TypedTree.TType) -> + x:TypedTree.Typar -> TypedTree.Typar + val foldTypars : + f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:TypedTree.Typars -> 'a + val mapTypars : + g:TcGlobals.TcGlobals -> + f:(TypedTree.TType -> TypedTree.TType) -> + x:TypedTree.Typars -> TypedTree.Typars + val foldTyparInst : + f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:TyparInst -> 'a + val mapTyparInst : + g:TcGlobals.TcGlobals -> + f:(TypedTree.TType -> TypedTree.TType) -> x:TyparInst -> TyparInst + val PrettifyInstAndTyparsAndType : + TcGlobals.TcGlobals -> + TyparInst * TypedTree.Typars * TypedTree.TType -> + (TyparInst * TypedTree.Typars * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInstAndUncurriedSig : + TcGlobals.TcGlobals -> + TyparInst * UncurriedArgInfos * TypedTree.TType -> + (TyparInst * UncurriedArgInfos * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInstAndCurriedSig : + TcGlobals.TcGlobals -> + TyparInst * TypedTree.TTypes * CurriedArgInfos * TypedTree.TType -> + (TyparInst * TypedTree.TType list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInstAndSig : + TcGlobals.TcGlobals -> + TyparInst * TypedTree.TType list * TypedTree.TType -> + (TyparInst * TypedTree.TType list * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInstAndTypes : + TcGlobals.TcGlobals -> + TyparInst * TypedTree.TType list -> + (TyparInst * TypedTree.TType list) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInstAndType : + TcGlobals.TcGlobals -> + TyparInst * TypedTree.TType -> + (TyparInst * TypedTree.TType) * + (TypedTree.Typar * TypedTree.TyparConstraint) list + val PrettifyInst : + TcGlobals.TcGlobals -> + TyparInst -> + TyparInst * (TypedTree.Typar * TypedTree.TyparConstraint) list + end + module SimplifyTypes = begin + val foldTypeButNotConstraints : + f:('a -> TypedTree.TType -> 'a) -> z:'a -> ty:TypedTree.TType -> 'a + val incM : + x:'a -> + m:AbstractIL.Internal.Zmap<'a,int> -> AbstractIL.Internal.Zmap<'a,int> + val accTyparCounts : + z:AbstractIL.Internal.Zmap -> + ty:TypedTree.TType -> AbstractIL.Internal.Zmap + val emptyTyparCounts : AbstractIL.Internal.Zmap + val accTyparCountsMulti : + acc:AbstractIL.Internal.Zmap -> + l:TypedTree.TType list -> + AbstractIL.Internal.Zmap + type TypeSimplificationInfo = + { singletons: AbstractIL.Internal.Zset + inplaceConstraints: + AbstractIL.Internal.Zmap + postfixConstraints: (TypedTree.Typar * TypedTree.TyparConstraint) list } + val typeSimplificationInfo0 : TypeSimplificationInfo + val categorizeConstraints : + simplify:bool -> + m:AbstractIL.Internal.Zmap -> + cxs:(TypedTree.Typar * TypedTree.TyparConstraint) list -> + TypeSimplificationInfo + val CollectInfo : + bool -> + TypedTree.TType list -> + (TypedTree.Typar * TypedTree.TyparConstraint) list -> + TypeSimplificationInfo + end + [] + type DisplayEnv = + { includeStaticParametersInTypeNames: bool + openTopPathsSorted: Lazy + openTopPathsRaw: string list list + shortTypeNames: bool + suppressNestedTypes: bool + maxMembers: int option + showObsoleteMembers: bool + showHiddenMembers: bool + showTyparBinding: bool + showImperativeTyparAnnotations: bool + suppressInlineKeyword: bool + suppressMutableKeyword: bool + showMemberContainers: bool + shortConstraints: bool + useColonForReturnType: bool + showAttributes: bool + showOverrides: bool + showConstraintTyparAnnotations: bool + abbreviateAdditionalConstraints: bool + showTyparDefaultConstraints: bool + shrinkOverloads: bool + printVerboseSignatures: bool + g: TcGlobals.TcGlobals + contextAccessibility: TypedTree.Accessibility + generatedValueLayout: TypedTree.Val -> Layout.layout option } + with + static member Empty : TcGlobals.TcGlobals -> DisplayEnv + member AddAccessibility : TypedTree.Accessibility -> DisplayEnv + member + AddOpenModuleOrNamespace : TypedTree.ModuleOrNamespaceRef -> + DisplayEnv + member AddOpenPath : string list -> DisplayEnv + member SetOpenPaths : string list list -> DisplayEnv + end + val ( +.+ ) : s1:string -> s2:string -> string + val layoutOfPath : + p:string list -> Internal.Utilities.StructuredFormat.Layout + val fullNameOfParentOfPubPath : pp:TypedTree.PublicPath -> string voption + val fullNameOfParentOfPubPathAsLayout : + pp:TypedTree.PublicPath -> + Internal.Utilities.StructuredFormat.Layout voption + val fullNameOfPubPath : TypedTree.PublicPath -> string + val fullNameOfPubPathAsLayout : + TypedTree.PublicPath -> Internal.Utilities.StructuredFormat.Layout + val fullNameOfParentOfNonLocalEntityRef : + nlr:TypedTree.NonLocalEntityRef -> string voption + val fullNameOfParentOfNonLocalEntityRefAsLayout : + nlr:TypedTree.NonLocalEntityRef -> + Internal.Utilities.StructuredFormat.Layout voption + val fullNameOfParentOfEntityRef : eref:TypedTree.EntityRef -> string voption + val fullNameOfParentOfEntityRefAsLayout : + eref:TypedTree.EntityRef -> + Internal.Utilities.StructuredFormat.Layout voption + val fullNameOfEntityRef : + nmF:(TypedTree.EntityRef -> string) -> xref:TypedTree.EntityRef -> string + val tagEntityRefName : + xref:TypedTree.EntityRef -> name:string -> Layout.TaggedText + val fullDisplayTextOfTyconRef : TypedTree.TyconRef -> string + val fullNameOfEntityRefAsLayout : + nmF:(TypedTree.EntityRef -> string) -> + xref:TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout + val fullNameOfParentOfValRef : vref:TypedTree.ValRef -> string voption + val fullNameOfParentOfValRefAsLayout : + vref:TypedTree.ValRef -> + Internal.Utilities.StructuredFormat.Layout voption + val fullDisplayTextOfParentOfModRef : TypedTree.EntityRef -> string voption + val fullDisplayTextOfModRef : TypedTree.EntityRef -> string + val fullDisplayTextOfTyconRefAsLayout : + TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout + val fullDisplayTextOfExnRef : TypedTree.EntityRef -> string + val fullDisplayTextOfExnRefAsLayout : + TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout + val fullDisplayTextOfUnionCaseRef : TypedTree.UnionCaseRef -> string + val fullDisplayTextOfRecdFieldRef : TypedTree.RecdFieldRef -> string + val fullDisplayTextOfValRef : TypedTree.ValRef -> string + val fullDisplayTextOfValRefAsLayout : + TypedTree.ValRef -> Internal.Utilities.StructuredFormat.Layout + val fullMangledPathToTyconRef : tcref:TypedTree.TyconRef -> string [] + val tyconRefToFullName : tc:TypedTree.TyconRef -> string + val qualifiedInterfaceImplementationNameAux : + g:TcGlobals.TcGlobals -> x:TypedTree.TType -> string + val qualifiedInterfaceImplementationName : + TcGlobals.TcGlobals -> TypedTree.TType -> string -> string + val qualifiedMangledNameOfTyconRef : TypedTree.TyconRef -> string -> string + val firstEq : p1:'a list -> p2:'a list -> bool when 'a : equality + val firstRem : p1:'a list -> p2:'b list -> 'b list + val trimPathByDisplayEnv : DisplayEnv -> string list -> string + val superOfTycon : TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.TType + val isILAttribByName : + tencl:string list * tname:string -> attr:AbstractIL.IL.ILAttribute -> bool + val isILAttrib : + tref:AbstractIL.IL.ILTypeRef -> attr:AbstractIL.IL.ILAttribute -> bool + val HasILAttribute : + tref:AbstractIL.IL.ILTypeRef -> attrs:AbstractIL.IL.ILAttributes -> bool + val TryDecodeILAttribute : + TcGlobals.TcGlobals -> + AbstractIL.IL.ILTypeRef -> + AbstractIL.IL.ILAttributes -> + (AbstractIL.IL.ILAttribElem list * + AbstractIL.IL.ILAttributeNamedArg list) option + val IsMatchingFSharpAttribute : + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib -> bool + val HasFSharpAttribute : + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool + val findAttrib : + g:TcGlobals.TcGlobals -> + tref:TcGlobals.BuiltinAttribInfo -> + attrs:TypedTree.Attrib list -> TypedTree.Attrib + val TryFindFSharpAttribute : + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> + TypedTree.Attrib list -> TypedTree.Attrib option + val TryFindFSharpAttributeOpt : + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo option -> + TypedTree.Attrib list -> TypedTree.Attrib option + val HasFSharpAttributeOpt : + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo option -> TypedTree.Attrib list -> bool + val IsMatchingFSharpAttributeOpt : + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo option -> TypedTree.Attrib -> bool + val ( |ExtractAttribNamedArg|_| ) : + string -> TypedTree.AttribNamedArg list -> TypedTree.AttribExpr option + val ( |AttribInt32Arg|_| ) : TypedTree.AttribExpr -> int32 option + val ( |AttribInt16Arg|_| ) : TypedTree.AttribExpr -> int16 option + val ( |AttribBoolArg|_| ) : TypedTree.AttribExpr -> bool option + val ( |AttribStringArg|_| ) : TypedTree.AttribExpr -> string option + val TryFindFSharpBoolAttributeWithDefault : + dflt:bool -> + g:TcGlobals.TcGlobals -> + nm:TcGlobals.BuiltinAttribInfo -> + attrs:TypedTree.Attrib list -> bool option + val TryFindFSharpBoolAttribute : + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool option + val TryFindFSharpBoolAttributeAssumeFalse : + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool option + val TryFindFSharpInt32Attribute : + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> int32 option + val TryFindFSharpStringAttribute : + TcGlobals.TcGlobals -> + TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> string option + val TryFindILAttribute : + TcGlobals.BuiltinAttribInfo -> AbstractIL.IL.ILAttributes -> bool + val TryFindILAttributeOpt : + TcGlobals.BuiltinAttribInfo option -> AbstractIL.IL.ILAttributes -> bool + val TryBindTyconRefAttribute : + g:TcGlobals.TcGlobals -> + m:Range.range -> + TcGlobals.BuiltinAttribInfo -> + tcref:TypedTree.TyconRef -> + f1:(AbstractIL.IL.ILAttribElem list * + AbstractIL.IL.ILAttributeNamedArg list -> 'a option) -> + f2:(TypedTree.Attrib -> 'a option) -> + f3:(obj option list * (string * obj option) list -> 'a option) -> + 'a option + val TryFindTyconRefBoolAttribute : + TcGlobals.TcGlobals -> + Range.range -> + TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> bool option + val TryFindAttributeUsageAttribute : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool option + val TryFindTyconRefStringAttribute : + TcGlobals.TcGlobals -> + Range.range -> + TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> string option + val TyconRefHasAttribute : + TcGlobals.TcGlobals -> + Range.range -> TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> bool + val isByrefTyconRef : TcGlobals.TcGlobals -> TypedTree.TyconRef -> bool + val isByrefLikeTyconRef : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool + val isSpanLikeTyconRef : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool + val isByrefLikeTy : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val isSpanLikeTy : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val isSpanTyconRef : + g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool + val isSpanTy : TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val tryDestSpanTy : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + struct (TypedTree.TyconRef * TypedTree.TType) voption + val destSpanTy : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> struct (TypedTree.TyconRef * TypedTree.TType) + val isReadOnlySpanTyconRef : + g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool + val isReadOnlySpanTy : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val tryDestReadOnlySpanTy : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + struct (TypedTree.TyconRef * TypedTree.TType) voption + val destReadOnlySpanTy : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> struct (TypedTree.TyconRef * TypedTree.TType) + val destByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val ( |ByrefTy|_| ) : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option + val destNativePtrTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val isRefCellTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val destRefCellTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val StripSelfRefCell : + TcGlobals.TcGlobals * TypedTree.ValBaseOrThisInfo * TypedTree.TType -> + TypedTree.TType + val mkRefCellTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkLazyTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkPrintfFormatTy : + TcGlobals.TcGlobals -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.TType -> TypedTree.TType -> TypedTree.TType + val mkOptionTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkNullableTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkListTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val isOptionTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val tryDestOptionTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType voption + val destOptionTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val isNullableTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val tryDestNullableTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType voption + val destNullableTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val ( |NullableTy|_| ) : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option + val ( |StripNullableTy| ) : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val isLinqExpressionTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val tryDestLinqExpressionTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option + val destLinqExpressionTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkNoneCase : TcGlobals.TcGlobals -> TypedTree.UnionCaseRef + val mkSomeCase : TcGlobals.TcGlobals -> TypedTree.UnionCaseRef + val mkSome : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr + val mkNone : + TcGlobals.TcGlobals -> TypedTree.TType -> Range.range -> TypedTree.Expr + val mkOptionGetValueUnprovenViaAddr : + TcGlobals.TcGlobals -> + TypedTree.Expr -> TypedTree.TType -> Range.range -> TypedTree.Expr + type ValRef with + member IsDispatchSlot : bool + val ( |UnopExpr|_| ) : + _g:'a -> expr:TypedTree.Expr -> (TypedTree.ValRef * TypedTree.Expr) option + val ( |BinopExpr|_| ) : + _g:'a -> + expr:TypedTree.Expr -> + (TypedTree.ValRef * TypedTree.Expr * TypedTree.Expr) option + val ( |SpecificUnopExpr|_| ) : + g:TcGlobals.TcGlobals -> + vrefReqd:TypedTree.ValRef -> + expr:TypedTree.Expr -> TypedTree.Expr option + val ( |SpecificBinopExpr|_| ) : + g:TcGlobals.TcGlobals -> + vrefReqd:TypedTree.ValRef -> + expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option + val ( |EnumExpr|_| ) : + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr option + val ( |BitwiseOrExpr|_| ) : + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option + val ( |AttribBitwiseOrExpr|_| ) : + TcGlobals.TcGlobals -> + TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option + val isUncheckedDefaultOfValRef : + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val isTypeOfValRef : g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val isSizeOfValRef : g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val isNameOfValRef : TcGlobals.TcGlobals -> TypedTree.ValRef -> bool + val isTypeDefOfValRef : + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val ( |UncheckedDefaultOfExpr|_| ) : + g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> TypedTree.TType option + val ( |TypeOfExpr|_| ) : + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option + val ( |SizeOfExpr|_| ) : + g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> TypedTree.TType option + val ( |TypeDefOfExpr|_| ) : + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option + val ( |NameOfExpr|_| ) : + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option + val ( |SeqExpr|_| ) : TcGlobals.TcGlobals -> TypedTree.Expr -> unit option + module DebugPrint = begin + val layoutRanges : bool ref + val squareAngleL : + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val angleL : + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val braceL : + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val braceBarL : + x:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val boolL : _arg1:bool -> Internal.Utilities.StructuredFormat.Layout + val intL : int -> Internal.Utilities.StructuredFormat.Layout + val int64L : n:int64 -> Internal.Utilities.StructuredFormat.Layout + val jlistL : + xL:('a -> Internal.Utilities.StructuredFormat.Layout) -> + xmap:Internal.Utilities.QueueList<'a> -> + Internal.Utilities.StructuredFormat.Layout + val bracketIfL : + x:bool -> + lyt:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val lvalopL : + x:TypedTree.LValueOperation -> + Internal.Utilities.StructuredFormat.Layout + val angleBracketL : + l:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val angleBracketListL : + l:Internal.Utilities.StructuredFormat.Layout list -> + Internal.Utilities.StructuredFormat.Layout + val layoutMemberFlags : + memFlags:SyntaxTree.MemberFlags -> + Internal.Utilities.StructuredFormat.Layout + val stampL : _n:'a -> w:'b -> 'b + val layoutTyconRef : + tc:TypedTree.TyconRef -> Internal.Utilities.StructuredFormat.Layout + val auxTypeL : + env:SimplifyTypes.TypeSimplificationInfo -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val auxTypeAtomL : + env:SimplifyTypes.TypeSimplificationInfo -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val auxTyparsL : + env:SimplifyTypes.TypeSimplificationInfo -> + tcL:Internal.Utilities.StructuredFormat.Layout -> + prefix:bool -> + tinst:TypedTree.TType list -> + Internal.Utilities.StructuredFormat.Layout + val auxTypeWrapL : + env:SimplifyTypes.TypeSimplificationInfo -> + isAtomic:bool -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val auxTyparWrapL : + env:SimplifyTypes.TypeSimplificationInfo -> + isAtomic:bool -> + typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val auxTypar2L : + env:SimplifyTypes.TypeSimplificationInfo -> + typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val auxTyparAtomL : + env:SimplifyTypes.TypeSimplificationInfo -> + typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val auxTyparConstraintTypL : + env:SimplifyTypes.TypeSimplificationInfo -> + ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val auxTraitL : + env:SimplifyTypes.TypeSimplificationInfo -> + ttrait:TypedTree.TraitConstraintInfo -> + Internal.Utilities.StructuredFormat.Layout + val auxTyparConstraintL : + env:SimplifyTypes.TypeSimplificationInfo -> + tp:TypedTree.Typar * tpc:TypedTree.TyparConstraint -> + Internal.Utilities.StructuredFormat.Layout + val auxTyparConstraintsL : + env:SimplifyTypes.TypeSimplificationInfo -> + x:(TypedTree.Typar * TypedTree.TyparConstraint) list -> + Internal.Utilities.StructuredFormat.Layout + val typarL : TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val typarAtomL : + tp:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val typeAtomL : + tau:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val typeL : TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout + val typarDeclL : + TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout + val layoutTyparDecls : + tps:TypedTree.Typars -> Internal.Utilities.StructuredFormat.Layout + val rangeL : m:Range.range -> Internal.Utilities.StructuredFormat.Layout + val instL : + tyL:('a -> Internal.Utilities.StructuredFormat.Layout) -> + tys:'a list -> Internal.Utilities.StructuredFormat.Layout + val valRefL : + TypedTree.ValRef -> Internal.Utilities.StructuredFormat.Layout + val layoutAttrib : + TypedTree.Attrib -> Internal.Utilities.StructuredFormat.Layout + val layoutAttribs : + attribs:TypedTree.Attrib list -> + Internal.Utilities.StructuredFormat.Layout + val arityInfoL : + TypedTree.ValReprInfo -> Internal.Utilities.StructuredFormat.Layout + val valL : TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout + val typeOfValL : + TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout + val tslotparamL : + TypedTree.SlotParam -> Internal.Utilities.StructuredFormat.Layout + val slotSigL : + TypedTree.SlotSig -> Internal.Utilities.StructuredFormat.Layout + val memberL : + g:TcGlobals.TcGlobals -> + v:TypedTree.Val -> + membInfo:TypedTree.ValMemberInfo -> + Internal.Utilities.StructuredFormat.Layout + val valAtBindL : + TcGlobals.TcGlobals -> + TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout + val unionCaseRefL : + TypedTree.UnionCaseRef -> Internal.Utilities.StructuredFormat.Layout + val recdFieldRefL : + TypedTree.RecdFieldRef -> Internal.Utilities.StructuredFormat.Layout + val identL : + id:SyntaxTree.Ident -> Internal.Utilities.StructuredFormat.Layout + val constL : + c:TypedTree.Const -> Internal.Utilities.StructuredFormat.Layout + val tyconL : + TcGlobals.TcGlobals -> + TypedTree.Tycon -> Internal.Utilities.StructuredFormat.Layout + val bindingL : + TcGlobals.TcGlobals -> + TypedTree.Binding -> Internal.Utilities.StructuredFormat.Layout + val exprL : + TcGlobals.TcGlobals -> + TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout + val atomL : + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout + val letRecL : + g:TcGlobals.TcGlobals -> + binds:TypedTree.Binding list -> + bodyL:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val letL : + g:TcGlobals.TcGlobals -> + bind:TypedTree.Binding -> + bodyL:Internal.Utilities.StructuredFormat.Layout -> + Internal.Utilities.StructuredFormat.Layout + val exprWrapL : + g:TcGlobals.TcGlobals -> + isAtomic:bool -> + expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout + val implFilesL : + TcGlobals.TcGlobals -> + TypedTree.TypedImplFile list -> + Internal.Utilities.StructuredFormat.Layout + val appL : + g:TcGlobals.TcGlobals -> + flayout:Internal.Utilities.StructuredFormat.Layout -> + tys:TypedTree.TypeInst -> + args:TypedTree.Exprs -> Internal.Utilities.StructuredFormat.Layout + val implFileL : + TcGlobals.TcGlobals -> + TypedTree.TypedImplFile -> Internal.Utilities.StructuredFormat.Layout + val mexprL : + g:TcGlobals.TcGlobals -> + x:TypedTree.ModuleOrNamespaceExprWithSig -> + Internal.Utilities.StructuredFormat.Layout + val mdefsL : + g:TcGlobals.TcGlobals -> + defs:TypedTree.ModuleOrNamespaceExpr list -> + Internal.Utilities.StructuredFormat.Layout + val mdefL : + g:TcGlobals.TcGlobals -> + x:TypedTree.ModuleOrNamespaceExpr -> + Internal.Utilities.StructuredFormat.Layout + val mbindL : + g:TcGlobals.TcGlobals -> + x:TypedTree.ModuleOrNamespaceBinding -> + Internal.Utilities.StructuredFormat.Layout + val entityTypeL : + TcGlobals.TcGlobals -> + TypedTree.ModuleOrNamespaceType -> + Internal.Utilities.StructuredFormat.Layout + val entityL : + TcGlobals.TcGlobals -> + TypedTree.ModuleOrNamespace -> + Internal.Utilities.StructuredFormat.Layout + val ccuL : + g:TcGlobals.TcGlobals -> + ccu:TypedTree.CcuThunk -> Internal.Utilities.StructuredFormat.Layout + val decisionTreeL : + TcGlobals.TcGlobals -> + TypedTree.DecisionTree -> Internal.Utilities.StructuredFormat.Layout + val dcaseL : + g:TcGlobals.TcGlobals -> + TypedTree.DecisionTreeCase -> + Internal.Utilities.StructuredFormat.Layout + val dtestL : + g:TcGlobals.TcGlobals -> + x:TypedTree.DecisionTreeTest -> + Internal.Utilities.StructuredFormat.Layout + val targetL : + g:TcGlobals.TcGlobals -> + i:int -> + TypedTree.DecisionTreeTarget -> + Internal.Utilities.StructuredFormat.Layout + val flatValsL : + vs:TypedTree.Val list -> Internal.Utilities.StructuredFormat.Layout list + val tmethodL : + g:TcGlobals.TcGlobals -> + TypedTree.ObjExprMethod -> Internal.Utilities.StructuredFormat.Layout + val iimplL : + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType * tmeths:TypedTree.ObjExprMethod list -> + Internal.Utilities.StructuredFormat.Layout + val showType : TypedTree.TType -> string + val showExpr : TcGlobals.TcGlobals -> TypedTree.Expr -> string + val traitL : + TypedTree.TraitConstraintInfo -> + Internal.Utilities.StructuredFormat.Layout + val typarsL : + TypedTree.Typars -> Internal.Utilities.StructuredFormat.Layout + end + val wrapModuleOrNamespaceType : + SyntaxTree.Ident -> + TypedTree.CompilationPath -> + TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespace + val wrapModuleOrNamespaceTypeInNamespace : + SyntaxTree.Ident -> + TypedTree.CompilationPath -> + TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType * TypedTree.ModuleOrNamespace + val wrapModuleOrNamespaceExprInNamespace : + SyntaxTree.Ident -> + TypedTree.CompilationPath -> + TypedTree.ModuleOrNamespaceExpr -> TypedTree.ModuleOrNamespaceExpr + val SigTypeOfImplFile : + TypedTree.TypedImplFile -> TypedTree.ModuleOrNamespaceType + type SignatureRepackageInfo = + { RepackagedVals: (TypedTree.ValRef * TypedTree.ValRef) list + RepackagedEntities: (TypedTree.TyconRef * TypedTree.TyconRef) list } + with + member ImplToSigMapping : TypeEquivEnv + static member Empty : SignatureRepackageInfo + end + type SignatureHidingInfo = + { HiddenTycons: AbstractIL.Internal.Zset + HiddenTyconReprs: AbstractIL.Internal.Zset + HiddenVals: AbstractIL.Internal.Zset + HiddenRecdFields: AbstractIL.Internal.Zset + HiddenUnionCases: AbstractIL.Internal.Zset } + with + static member Empty : SignatureHidingInfo + end + val addValRemap : TypedTree.Val -> TypedTree.Val -> Remap -> Remap + val mkRepackageRemapping : SignatureRepackageInfo -> Remap + val accEntityRemap : + msigty:TypedTree.ModuleOrNamespaceType -> + entity:TypedTree.Entity -> + mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accSubEntityRemap : + msigty:TypedTree.ModuleOrNamespaceType -> + entity:TypedTree.Entity -> + mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val valLinkageAEquiv : + TcGlobals.TcGlobals -> + TypeEquivEnv -> TypedTree.Val -> TypedTree.Val -> bool + val accValRemap : + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + msigty:TypedTree.ModuleOrNamespaceType -> + implVal:TypedTree.Val -> + mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val getCorrespondingSigTy : + nm:string -> + msigty:TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType + val accEntityRemapFromModuleOrNamespaceType : + mty:TypedTree.ModuleOrNamespaceType -> + msigty:TypedTree.ModuleOrNamespaceType -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accValRemapFromModuleOrNamespaceType : + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + mty:TypedTree.ModuleOrNamespaceType -> + msigty:TypedTree.ModuleOrNamespaceType -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val ComputeRemappingFromInferredSignatureToExplicitSignature : + TcGlobals.TcGlobals -> + TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType -> + SignatureRepackageInfo * SignatureHidingInfo + val abstractSlotValRefsOfTycons : + TypedTree.Tycon list -> TypedTree.ValRef list + val abstractSlotValsOfTycons : TypedTree.Tycon list -> TypedTree.Val list + val accEntityRemapFromModuleOrNamespace : + msigty:TypedTree.ModuleOrNamespaceType -> + x:TypedTree.ModuleOrNamespaceExpr -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accEntityRemapFromModuleOrNamespaceDefs : + msigty:TypedTree.ModuleOrNamespaceType -> + mdefs:TypedTree.ModuleOrNamespaceExpr list -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accEntityRemapFromModuleOrNamespaceBind : + msigty:TypedTree.ModuleOrNamespaceType -> + x:TypedTree.ModuleOrNamespaceBinding -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accValRemapFromModuleOrNamespace : + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + msigty:TypedTree.ModuleOrNamespaceType -> + x:TypedTree.ModuleOrNamespaceExpr -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accValRemapFromModuleOrNamespaceBind : + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + msigty:TypedTree.ModuleOrNamespaceType -> + x:TypedTree.ModuleOrNamespaceBinding -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val accValRemapFromModuleOrNamespaceDefs : + g:TcGlobals.TcGlobals -> + aenv:TypeEquivEnv -> + msigty:TypedTree.ModuleOrNamespaceType -> + mdefs:TypedTree.ModuleOrNamespaceExpr list -> + SignatureRepackageInfo * SignatureHidingInfo -> + SignatureRepackageInfo * SignatureHidingInfo + val ComputeRemappingFromImplementationToSignature : + TcGlobals.TcGlobals -> + TypedTree.ModuleOrNamespaceExpr -> + TypedTree.ModuleOrNamespaceType -> + SignatureRepackageInfo * SignatureHidingInfo + val accTyconHidingInfoAtAssemblyBoundary : + tycon:TypedTree.Tycon -> mhi:SignatureHidingInfo -> SignatureHidingInfo + val accValHidingInfoAtAssemblyBoundary : + vspec:TypedTree.Val -> mhi:SignatureHidingInfo -> SignatureHidingInfo + val accModuleOrNamespaceHidingInfoAtAssemblyBoundary : + mty:TypedTree.ModuleOrNamespaceType -> + acc:SignatureHidingInfo -> SignatureHidingInfo + val ComputeHidingInfoAtAssemblyBoundary : + TypedTree.ModuleOrNamespaceType -> + SignatureHidingInfo -> SignatureHidingInfo + val IsHidden : + setF:('a -> AbstractIL.Internal.Zset<'b>) -> + accessF:('b -> TypedTree.Accessibility) -> + remapF:('c -> 'b -> 'b) -> (('c * 'a) list -> 'b -> bool) + val IsHiddenTycon : + (Remap * SignatureHidingInfo) list -> TypedTree.Tycon -> bool + val IsHiddenTyconRepr : + (Remap * SignatureHidingInfo) list -> TypedTree.Tycon -> bool + val IsHiddenVal : + (Remap * SignatureHidingInfo) list -> TypedTree.Val -> bool + val IsHiddenRecdField : + (Remap * SignatureHidingInfo) list -> TypedTree.RecdFieldRef -> bool + val foldModuleOrNamespaceTy : + ft:(TypedTree.Entity -> 'a -> 'a) -> + fv:(TypedTree.Val -> 'a -> 'a) -> + mty:TypedTree.ModuleOrNamespaceType -> acc:'a -> 'a + val allValsOfModuleOrNamespaceTy : + m:TypedTree.ModuleOrNamespaceType -> TypedTree.Val list + val allEntitiesOfModuleOrNamespaceTy : + m:TypedTree.ModuleOrNamespaceType -> TypedTree.Entity list + val isPublicVal : lv:TypedTree.Val -> bool + val isPublicUnionCase : ucr:TypedTree.UnionCaseRef -> bool + val isPublicRecdField : rfr:TypedTree.RecdFieldRef -> bool + val isPublicTycon : tcref:TypedTree.Tycon -> bool + val freeVarsAllPublic : TypedTree.FreeVars -> bool + val freeTyvarsAllPublic : TypedTree.FreeTyvars -> bool + val ( |LinearMatchExpr|_| ) : + TypedTree.Expr -> + (SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * + TypedTree.DecisionTreeTarget * TypedTree.Expr * + SyntaxTree.DebugPointForTarget * Range.range * TypedTree.TType) option + val rebuildLinearMatchExpr : + (SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * + TypedTree.DecisionTreeTarget * TypedTree.Expr * + SyntaxTree.DebugPointForTarget * Range.range * TypedTree.TType) -> + TypedTree.Expr + val ( |LinearOpExpr|_| ) : + TypedTree.Expr -> + (TypedTree.TOp * TypedTree.TypeInst * TypedTree.Expr list * + TypedTree.Expr * Range.range) option + val rebuildLinearOpExpr : + (TypedTree.TOp * TypedTree.TypeInst * TypedTree.Expr list * TypedTree.Expr * + Range.range) -> TypedTree.Expr + val emptyFreeVars : TypedTree.FreeVars + val unionFreeVars : + TypedTree.FreeVars -> TypedTree.FreeVars -> TypedTree.FreeVars + val inline accFreeTyvars : + opts:FreeVarOptions -> + f:(FreeVarOptions -> 'a -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars) -> + v:'a -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeVarsInTy : + opts:FreeVarOptions -> + ty:TypedTree.TType -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeVarsInTys : + opts:FreeVarOptions -> + tys:TypedTree.TType list -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreevarsInTycon : + opts:FreeVarOptions -> + tcref:TypedTree.TyconRef -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreevarsInVal : + opts:FreeVarOptions -> + v:TypedTree.Val -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeVarsInTraitSln : + opts:FreeVarOptions -> + tys:TypedTree.TraitConstraintSln -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeVarsInTraitInfo : + opts:FreeVarOptions -> + tys:TypedTree.TraitConstraintInfo -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val boundLocalVal : + opts:FreeVarOptions -> + v:TypedTree.Val -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val boundProtect : fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accUsesFunctionLocalConstructs : + flg:bool -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val bound_rethrow : fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accUsesRethrow : + flg:bool -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val boundLocalVals : + opts:FreeVarOptions -> + vs:TypedTree.Val list -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val bindLhs : + opts:FreeVarOptions -> + bind:TypedTree.Binding -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val freeVarsCacheCompute : + opts:FreeVarOptions -> cache:Lib.cache<'a> -> f:(unit -> 'a) -> 'a + val tryGetFreeVarsCacheValue : + opts:FreeVarOptions -> cache:Lib.cache<'a> -> Lib.NonNullSlot<'a> voption + val accBindRhs : + opts:FreeVarOptions -> + TypedTree.Binding -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInSwitchCases : + FreeVarOptions -> + TypedTree.DecisionTreeCase list -> + TypedTree.DecisionTree option -> + TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInSwitchCase : + opts:FreeVarOptions -> + TypedTree.DecisionTreeCase -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInTest : + opts:FreeVarOptions -> + discrim:TypedTree.DecisionTreeTest -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInDecisionTree : + FreeVarOptions -> + TypedTree.DecisionTree -> TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInValFlags : + opts:FreeVarOptions -> + flag:TypedTree.ValUseFlag -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeLocalVal : + opts:FreeVarOptions -> + v:TypedTree.Val -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accLocalTyconRepr : + opts:FreeVarOptions -> + b:TypedTree.Tycon -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accUsedRecdOrUnionTyconRepr : + opts:FreeVarOptions -> + tc:TypedTree.Tycon -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeUnionCaseRef : + opts:FreeVarOptions -> + ucref:TypedTree.UnionCaseRef -> + fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeRecdFieldRef : + opts:FreeVarOptions -> + rfref:TypedTree.RecdFieldRef -> + fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeExnRef : _exnc:'a -> fvs:'b -> 'b + val accFreeValRef : + opts:FreeVarOptions -> + vref:TypedTree.ValRef -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInMethod : + opts:FreeVarOptions -> + TypedTree.ObjExprMethod -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInMethods : + opts:FreeVarOptions -> + methods:TypedTree.ObjExprMethod list -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInInterfaceImpl : + opts:FreeVarOptions -> + ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInExpr : + opts:FreeVarOptions -> + x:TypedTree.Expr -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInExprLinear : + opts:FreeVarOptions -> + x:TypedTree.Expr -> + acc:TypedTree.FreeVars -> + contf:(TypedTree.FreeVars -> TypedTree.FreeVars) -> + TypedTree.FreeVars + val accFreeInExprNonLinear : + opts:FreeVarOptions -> + x:TypedTree.Expr -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInOp : + opts:FreeVarOptions -> + op:TypedTree.TOp -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInTargets : + FreeVarOptions -> + TypedTree.DecisionTreeTarget array -> + TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInTarget : + opts:FreeVarOptions -> + TypedTree.DecisionTreeTarget -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInFlatExprs : + opts:FreeVarOptions -> + exprs:TypedTree.Exprs -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInExprs : + FreeVarOptions -> + TypedTree.Exprs -> TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInSlotSig : + opts:FreeVarOptions -> + TypedTree.SlotSig -> acc:TypedTree.FreeVars -> TypedTree.FreeVars + val freeInDecisionTree : + opts:FreeVarOptions -> dtree:TypedTree.DecisionTree -> TypedTree.FreeVars + val freeInExpr : FreeVarOptions -> TypedTree.Expr -> TypedTree.FreeVars + val accFreeInModuleOrNamespace : + opts:FreeVarOptions -> + mexpr:TypedTree.ModuleOrNamespaceExpr -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInModuleOrNamespaceBind : + opts:FreeVarOptions -> + mbind:TypedTree.ModuleOrNamespaceBinding -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val accFreeInModuleOrNamespaces : + opts:FreeVarOptions -> + mexprs:TypedTree.ModuleOrNamespaceExpr list -> + acc:TypedTree.FreeVars -> TypedTree.FreeVars + val freeInBindingRhs : + FreeVarOptions -> TypedTree.Binding -> TypedTree.FreeVars + val freeInModuleOrNamespace : + FreeVarOptions -> TypedTree.ModuleOrNamespaceExpr -> TypedTree.FreeVars + val stripLambda : + expr:TypedTree.Expr * ty:TypedTree.TType -> + TypedTree.Val list list * TypedTree.Expr * TypedTree.TType + val stripLambdaN : + n:int -> + expr:TypedTree.Expr -> TypedTree.Val list list * TypedTree.Expr * int + val tryStripLambdaN : + n:int -> + expr:TypedTree.Expr -> (TypedTree.Val list list * TypedTree.Expr) option + val stripTopLambda : + TypedTree.Expr * TypedTree.TType -> + TypedTree.Typars * TypedTree.Val list list * TypedTree.Expr * + TypedTree.TType + [] + type AllowTypeDirectedDetupling = + | Yes + | No + val InferArityOfExpr : + TcGlobals.TcGlobals -> + AllowTypeDirectedDetupling -> + TypedTree.TType -> + TypedTree.Attrib list list list -> + TypedTree.Attribs -> TypedTree.Expr -> TypedTree.ValReprInfo + val InferArityOfExprBinding : + TcGlobals.TcGlobals -> + AllowTypeDirectedDetupling -> + TypedTree.Val -> TypedTree.Expr -> TypedTree.ValReprInfo + val underlyingTypeOfEnumTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val setValHasNoArity : TypedTree.Val -> TypedTree.Val + val normalizeEnumTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + type StaticOptimizationAnswer = + | Yes = 1y + | No = -1y + | Unknown = 0y + val decideStaticOptimizationConstraint : + g:TcGlobals.TcGlobals -> + c:TypedTree.StaticOptimization -> + haveWitnesses:bool -> StaticOptimizationAnswer + val DecideStaticOptimizations : + TcGlobals.TcGlobals -> + TypedTree.StaticOptimization list -> + haveWitnesses:bool -> StaticOptimizationAnswer + val mkStaticOptimizationExpr : + TcGlobals.TcGlobals -> + TypedTree.StaticOptimization list * TypedTree.Expr * TypedTree.Expr * + Range.range -> TypedTree.Expr + type ValCopyFlag = + | CloneAll + | CloneAllAndMarkExprValsAsCompilerGenerated + | OnlyCloneExprVals + val fixValCopyFlagForQuotations : _arg1:ValCopyFlag -> ValCopyFlag + val markAsCompGen : compgen:ValCopyFlag -> d:TypedTree.Val -> TypedTree.Val + val bindLocalVal : + v:TypedTree.Val -> v':TypedTree.Val -> tmenv:Remap -> Remap + val bindLocalVals : + vs:TypedTree.Val list -> vs':TypedTree.Val list -> tmenv:Remap -> Remap + val bindTycon : + tc:TypedTree.Tycon -> tc':TypedTree.Tycon -> tyenv:Remap -> Remap + val bindTycons : + tcs:Lib.NonNullSlot list -> + tcs':Lib.NonNullSlot list -> tyenv:Remap -> Remap + val remapAttribKind : + tmenv:Remap -> k:TypedTree.AttribKind -> TypedTree.AttribKind + val tmenvCopyRemapAndBindTypars : + remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> + tmenv:Remap -> tps:TypedTree.Typar list -> TypedTree.Typar list * Remap + val remapAttrib : + TcGlobals.TcGlobals -> Remap -> TypedTree.Attrib -> TypedTree.Attrib + val remapAttribExpr : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> TypedTree.AttribExpr -> TypedTree.AttribExpr + val remapAttribs : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> xs:TypedTree.Attrib list -> TypedTree.Attrib list + val remapPossibleForallTy : + TcGlobals.TcGlobals -> Remap -> TypedTree.TType -> TypedTree.TType + val remapArgData : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> argInfo:TypedTree.ArgReprInfo -> TypedTree.ArgReprInfo + val remapValReprInfo : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> TypedTree.ValReprInfo -> TypedTree.ValReprInfo + val remapValData : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> d:TypedTree.ValData -> TypedTree.ValData + val remapParentRef : + tyenv:Remap -> p:TypedTree.ParentRef -> TypedTree.ParentRef + val mapImmediateValsAndTycons : + ft:(TypedTree.Entity -> TypedTree.Entity) -> + fv:(TypedTree.Val -> TypedTree.Val) -> + x:TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespaceType + val copyVal : compgen:ValCopyFlag -> v:TypedTree.Val -> TypedTree.Val + val fixupValData : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> tmenv:Remap -> v2:TypedTree.Val -> unit + val copyAndRemapAndBindVals : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> vs:TypedTree.Val list -> TypedTree.Val list * Remap + val copyAndRemapAndBindVal : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> v:TypedTree.Val -> TypedTree.Val * Remap + val remapExpr : + TcGlobals.TcGlobals -> + ValCopyFlag -> Remap -> TypedTree.Expr -> TypedTree.Expr + val remapTarget : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + TypedTree.DecisionTreeTarget -> TypedTree.DecisionTreeTarget + val remapLinearExpr : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + expr:TypedTree.Expr -> + contf:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr + val remapConstraint : + tyenv:Remap -> + c:TypedTree.StaticOptimization -> TypedTree.StaticOptimization + val remapOp : tmenv:Remap -> op:TypedTree.TOp -> TypedTree.TOp + val remapValFlags : + tmenv:Remap -> x:TypedTree.ValUseFlag -> TypedTree.ValUseFlag + val remapExprs : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> es:TypedTree.Exprs -> TypedTree.Exprs + val remapFlatExprs : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> es:TypedTree.Expr list -> TypedTree.Expr list + val remapDecisionTree : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree + val copyAndRemapAndBindBinding : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> bind:TypedTree.Binding -> TypedTree.Binding * Remap + val copyAndRemapAndBindBindings : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> binds:TypedTree.Bindings -> TypedTree.Bindings * Remap + val remapAndRenameBinds : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenvinner:Remap -> + binds:TypedTree.Bindings -> + vs':TypedTree.Val list -> TypedTree.Bindings + val remapAndRenameBind : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenvinner:Remap -> + TypedTree.Binding -> v':TypedTree.Val -> TypedTree.Binding + val remapMethod : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod + val remapInterfaceImpl : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> + TypedTree.TType * TypedTree.ObjExprMethod list + val remapRecdField : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> x:TypedTree.RecdField -> TypedTree.RecdField + val remapRecdFields : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> x:TypedTree.TyconRecdFields -> TypedTree.TyconRecdFields + val remapUnionCase : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> x:TypedTree.UnionCase -> TypedTree.UnionCase + val remapUnionCases : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> x:TypedTree.TyconUnionData -> TypedTree.TyconUnionData + val remapFsObjData : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> + x:TypedTree.TyconObjModelData -> TypedTree.TyconObjModelData + val remapTyconRepr : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> + repr:TypedTree.TyconRepresentation -> TypedTree.TyconRepresentation + val remapTyconAug : + tmenv:Remap -> + x:TypedTree.TyconAugmentation -> TypedTree.TyconAugmentation + val remapTyconExnInfo : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> inp:TypedTree.ExceptionInfo -> TypedTree.ExceptionInfo + val remapMemberInfo : + g:TcGlobals.TcGlobals -> + m:Range.range -> + topValInfo:TypedTree.ValReprInfo option -> + ty:TypedTree.TType -> + ty':TypedTree.TType -> + tmenv:Remap -> + x:TypedTree.ValMemberInfo -> TypedTree.ValMemberInfo + val copyAndRemapAndBindModTy : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + mty:TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType * Remap + val remapModTy : + g:TcGlobals.TcGlobals -> + _compgen:ValCopyFlag -> + tmenv:Remap -> + mty:TypedTree.ModuleOrNamespaceType -> + TypedTree.ModuleOrNamespaceType + val renameTycon : + g:TcGlobals.TcGlobals -> + tyenv:Remap -> x:TypedTree.Entity -> TypedTree.Entity + val renameVal : tmenv:Remap -> x:TypedTree.Val -> TypedTree.Val + val copyTycon : + compgen:ValCopyFlag -> tycon:TypedTree.Tycon -> TypedTree.Tycon + val copyAndRemapAndBindTyconsAndVals : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + tycons:TypedTree.Entity list -> + vs:TypedTree.Val list -> + TypedTree.Tycon list * TypedTree.Val list * Remap + val allTyconsOfTycon : tycon:TypedTree.Tycon -> seq + val allEntitiesOfModDef : + mdef:TypedTree.ModuleOrNamespaceExpr -> seq + val allValsOfModDef : TypedTree.ModuleOrNamespaceExpr -> seq + val remapAndBindModuleOrNamespaceExprWithSig : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig * Remap + val remapModuleOrNamespaceExprWithSig : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig + val copyAndRemapModDef : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + mdef:TypedTree.ModuleOrNamespaceExpr -> + TypedTree.ModuleOrNamespaceExpr + val remapAndRenameModDefs : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + x:TypedTree.ModuleOrNamespaceExpr list -> + TypedTree.ModuleOrNamespaceExpr list + val remapAndRenameModDef : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + mdef:TypedTree.ModuleOrNamespaceExpr -> + TypedTree.ModuleOrNamespaceExpr + val remapAndRenameModBind : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + x:TypedTree.ModuleOrNamespaceBinding -> + TypedTree.ModuleOrNamespaceBinding + val remapImplFile : + g:TcGlobals.TcGlobals -> + compgen:ValCopyFlag -> + tmenv:Remap -> + mv:TypedTree.TypedImplFile -> TypedTree.TypedImplFile * Remap + val copyModuleOrNamespaceType : + TcGlobals.TcGlobals -> + ValCopyFlag -> + TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespaceType + val copyExpr : + TcGlobals.TcGlobals -> ValCopyFlag -> TypedTree.Expr -> TypedTree.Expr + val copyImplFile : + TcGlobals.TcGlobals -> + ValCopyFlag -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile + val instExpr : + TcGlobals.TcGlobals -> TyparInst -> TypedTree.Expr -> TypedTree.Expr + val remarkExpr : Range.range -> TypedTree.Expr -> TypedTree.Expr + val remarkObjExprMethod : + m:Range.range -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod + val remarkInterfaceImpl : + m:Range.range -> + ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> + TypedTree.TType * TypedTree.ObjExprMethod list + val remarkExprs : m:Range.range -> es:TypedTree.Exprs -> TypedTree.Exprs + val remarkFlatExprs : + m:Range.range -> es:TypedTree.Expr list -> TypedTree.Expr list + val remarkDecisionTree : + m:Range.range -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree + val remarkBinds : + m:Range.range -> binds:TypedTree.Bindings -> TypedTree.Bindings + val remarkBind : m:Range.range -> TypedTree.Binding -> TypedTree.Binding + val isRecdOrStructFieldDefinitelyMutable : f:TypedTree.RecdField -> bool + val isUnionCaseDefinitelyMutable : uc:TypedTree.UnionCase -> bool + val isUnionCaseRefDefinitelyMutable : TypedTree.UnionCaseRef -> bool + val isRecdOrUnionOrStructTyconRefDefinitelyMutable : + TypedTree.TyconRef -> bool + val isExnDefinitelyMutable : TypedTree.TyconRef -> bool + val isUnionCaseFieldMutable : + TcGlobals.TcGlobals -> TypedTree.UnionCaseRef -> int -> bool + val isExnFieldMutable : TypedTree.TyconRef -> int -> bool + val useGenuineField : TypedTree.Tycon -> TypedTree.RecdField -> bool + val ComputeFieldName : TypedTree.Tycon -> TypedTree.RecdField -> string + val isQuotedExprTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val destQuotedExprTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkQuotedExprTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkRawQuotedExprTy : TcGlobals.TcGlobals -> TypedTree.TType + val mkAnyTupledTy : + TcGlobals.TcGlobals -> + TypedTree.TupInfo -> TypedTree.TType list -> TypedTree.TType + val mkAnyAnonRecdTy : + TcGlobals.TcGlobals -> + TypedTree.AnonRecdTypeInfo -> TypedTree.TType list -> TypedTree.TType + val mkRefTupledTy : + TcGlobals.TcGlobals -> TypedTree.TType list -> TypedTree.TType + val mkRefTupledVarsTy : + TcGlobals.TcGlobals -> TypedTree.Val list -> TypedTree.TType + val mkMethodTy : + TcGlobals.TcGlobals -> + TypedTree.TType list list -> TypedTree.TType -> TypedTree.TType + val mkArrayType : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkByteArrayTy : TcGlobals.TcGlobals -> TypedTree.TType + val GenWitnessArgTys : + TcGlobals.TcGlobals -> + TypedTree.TraitWitnessInfo -> TypedTree.TType list list + val GenWitnessTy : + TcGlobals.TcGlobals -> TypedTree.TraitWitnessInfo -> TypedTree.TType + val GenWitnessTys : + TcGlobals.TcGlobals -> TraitWitnessInfos -> TypedTree.TType list + val tyOfExpr : TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType + val primMkApp : + (TypedTree.Expr * TypedTree.TType) -> + TypedTree.TypeInst -> TypedTree.Exprs -> Range.range -> TypedTree.Expr + val isExpansiveUnderInstantiation : + g:TcGlobals.TcGlobals -> + fty0:TypedTree.TType -> + tyargs:'a list -> pargs:'b list -> argsl:'c list -> bool + val mkExprAppAux : + g:TcGlobals.TcGlobals -> + f:TypedTree.Expr -> + fty:TypedTree.TType -> + argsl:TypedTree.Expr list -> m:Range.range -> TypedTree.Expr + val mkAppsAux : + g:TcGlobals.TcGlobals -> + f:TypedTree.Expr -> + fty:TypedTree.TType -> + tyargsl:TypedTree.TType list list -> + argsl:TypedTree.Expr list -> m:Range.range -> TypedTree.Expr + val mkApps : + TcGlobals.TcGlobals -> + (TypedTree.Expr * TypedTree.TType) * TypedTree.TType list list * + TypedTree.Expr list * Range.range -> TypedTree.Expr + val mkTyAppExpr : + Range.range -> + TypedTree.Expr * TypedTree.TType -> + TypedTree.TType list -> TypedTree.Expr + val accTargetsOfDecisionTree : + TypedTree.DecisionTree -> int list -> int list + val mapTargetsOfDecisionTree : + f:(int -> int) -> tree:TypedTree.DecisionTree -> TypedTree.DecisionTree + val mapTargetsOfDecisionTreeCase : + f:(int -> int) -> TypedTree.DecisionTreeCase -> TypedTree.DecisionTreeCase + val eliminateDeadTargetsFromMatch : + tree:TypedTree.DecisionTree -> + targets:'a [] -> TypedTree.DecisionTree * 'a [] + val targetOfSuccessDecisionTree : tree:TypedTree.DecisionTree -> int option + val decisionTreeHasNonTrivialBindings : tree:TypedTree.DecisionTree -> bool + val foldLinearBindingTargetsOfMatch : + tree:TypedTree.DecisionTree -> + targets:TypedTree.DecisionTreeTarget [] -> + TypedTree.DecisionTree * TypedTree.DecisionTreeTarget [] + val simplifyTrivialMatch : + spBind:SyntaxTree.DebugPointForBinding -> + exprm:Range.range -> + matchm:Range.range -> + ty:TypedTree.TType -> + tree:TypedTree.DecisionTree -> + targets:TypedTree.DecisionTreeTarget [] -> TypedTree.Expr + val mkAndSimplifyMatch : + SyntaxTree.DebugPointForBinding -> + Range.range -> + Range.range -> + TypedTree.TType -> + TypedTree.DecisionTree -> + TypedTree.DecisionTreeTarget list -> TypedTree.Expr + type Mutates = + | AddressOfOp + | DefinitelyMutates + | PossiblyMutates + | NeverMutates + exception DefensiveCopyWarning of string * Range.range + val isRecdOrStructTyconRefAssumedImmutable : + TcGlobals.TcGlobals -> TypedTree.TyconRef -> bool + val isTyconRefReadOnly : + g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool + val isTyconRefAssumedReadOnly : + g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> bool + val isRecdOrStructTyconRefReadOnlyAux : + g:TcGlobals.TcGlobals -> + m:Range.range -> isInref:bool -> tcref:TypedTree.TyconRef -> bool + val isRecdOrStructTyconRefReadOnly : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool + val isRecdOrStructTyReadOnlyAux : + g:TcGlobals.TcGlobals -> + m:Range.range -> isInref:bool -> ty:TypedTree.TType -> bool + val isRecdOrStructTyReadOnly : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val CanTakeAddressOf : + g:TcGlobals.TcGlobals -> + m:Range.range -> + isInref:bool -> ty:TypedTree.TType -> mut:Mutates -> bool + val CanTakeAddressOfImmutableVal : + g:TcGlobals.TcGlobals -> + m:Range.range -> vref:TypedTree.ValRef -> mut:Mutates -> bool + val MustTakeAddressOfVal : + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val MustTakeAddressOfByrefGet : + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool + val CanTakeAddressOfByrefGet : + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> mut:Mutates -> bool + val MustTakeAddressOfRecdField : rfref:TypedTree.RecdField -> bool + val MustTakeAddressOfRecdFieldRef : rfref:TypedTree.RecdFieldRef -> bool + val CanTakeAddressOfRecdFieldRef : + g:TcGlobals.TcGlobals -> + m:Range.range -> + rfref:TypedTree.RecdFieldRef -> + tinst:TypedTree.TType list -> mut:Mutates -> bool + val CanTakeAddressOfUnionFieldRef : + g:TcGlobals.TcGlobals -> + m:Range.range -> + uref:TypedTree.UnionCaseRef -> + cidx:int -> tinst:TypedTree.TType list -> mut:Mutates -> bool + val mkDerefAddrExpr : + mAddrGet:Range.range -> + expr:TypedTree.Expr -> + mExpr:Range.range -> exprTy:TypedTree.TType -> TypedTree.Expr + val mkExprAddrOfExprAux : + TcGlobals.TcGlobals -> + bool -> + bool -> + Mutates -> + TypedTree.Expr -> + TypedTree.ValRef option -> + Range.range -> + (TypedTree.Val * TypedTree.Expr) option * TypedTree.Expr * + bool * bool + val mkExprAddrOfExpr : + TcGlobals.TcGlobals -> + bool -> + bool -> + Mutates -> + TypedTree.Expr -> + TypedTree.ValRef option -> + Range.range -> + (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr * bool * + bool + val mkTupleFieldGet : + TcGlobals.TcGlobals -> + TypedTree.TupInfo * TypedTree.Expr * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkAnonRecdFieldGet : + TcGlobals.TcGlobals -> + TypedTree.AnonRecdTypeInfo * TypedTree.Expr * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkRecdFieldGet : + TcGlobals.TcGlobals -> + TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * + Range.range -> TypedTree.Expr + val mkUnionCaseFieldGetUnproven : + TcGlobals.TcGlobals -> + TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * + Range.range -> TypedTree.Expr + val mkArray : + TypedTree.TType * TypedTree.Exprs * Range.range -> TypedTree.Expr + val IterateRecursiveFixups : + TcGlobals.TcGlobals -> + TypedTree.Val option -> + (TypedTree.Val option -> TypedTree.Expr -> + (TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr -> unit) -> + TypedTree.Expr * (TypedTree.Expr -> TypedTree.Expr) -> + TypedTree.Expr -> unit + val JoinTyparStaticReq : + SyntaxTree.TyparStaticReq -> + SyntaxTree.TyparStaticReq -> SyntaxTree.TyparStaticReq + type ExprFolder<'State> = + { exprIntercept: + ('State -> TypedTree.Expr -> 'State) -> + ('State -> TypedTree.Expr -> 'State) -> 'State -> TypedTree.Expr -> + 'State + valBindingSiteIntercept: 'State -> bool * TypedTree.Val -> 'State + nonRecBindingsIntercept: 'State -> TypedTree.Binding -> 'State + recBindingsIntercept: 'State -> TypedTree.Bindings -> 'State + dtreeIntercept: 'State -> TypedTree.DecisionTree -> 'State + targetIntercept: + ('State -> TypedTree.Expr -> 'State) -> 'State -> + TypedTree.DecisionTreeTarget -> 'State option + tmethodIntercept: + ('State -> TypedTree.Expr -> 'State) -> 'State -> + TypedTree.ObjExprMethod -> 'State option } + val ExprFolder0 : ExprFolder<'State> + type ExprFolders<'State> = + class + new : folders:ExprFolder<'State> -> ExprFolders<'State> + member FoldExpr : ('State -> TypedTree.Expr -> 'State) + member FoldImplFile : ('State -> TypedTree.TypedImplFile -> 'State) + end + val FoldExpr : ExprFolder<'State> -> ('State -> TypedTree.Expr -> 'State) + val FoldImplFile : + ExprFolder<'State> -> ('State -> TypedTree.TypedImplFile -> 'State) + val ExprStats : TypedTree.Expr -> string + val mkString : + TcGlobals.TcGlobals -> Range.range -> string -> TypedTree.Expr + val mkBool : TcGlobals.TcGlobals -> Range.range -> bool -> TypedTree.Expr + val mkByte : TcGlobals.TcGlobals -> Range.range -> byte -> TypedTree.Expr + val mkUInt16 : + TcGlobals.TcGlobals -> Range.range -> uint16 -> TypedTree.Expr + val mkTrue : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkFalse : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkUnit : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkInt32 : TcGlobals.TcGlobals -> Range.range -> int32 -> TypedTree.Expr + val mkInt : TcGlobals.TcGlobals -> Range.range -> int32 -> TypedTree.Expr + val mkZero : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkOne : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkTwo : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkMinusOne : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val destInt32 : TypedTree.Expr -> int32 option + val isIDelegateEventType : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val destIDelegateEventType : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkIEventType : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.TType -> TypedTree.TType + val mkIObservableType : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkIObserverType : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkRefCellContentsRef : TcGlobals.TcGlobals -> TypedTree.RecdFieldRef + val mkSequential : + SyntaxTree.DebugPointAtSequential -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCompGenSequential : + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkSequentials : + SyntaxTree.DebugPointAtSequential -> + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr list -> TypedTree.Expr + val mkGetArg0 : Range.range -> TypedTree.TType -> TypedTree.Expr + val mkAnyTupled : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TupInfo -> + TypedTree.Expr list -> TypedTree.TypeInst -> TypedTree.Expr + val mkRefTupled : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr list -> TypedTree.TypeInst -> TypedTree.Expr + val mkRefTupledNoTypes : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr list -> TypedTree.Expr + val mkRefTupledVars : + TcGlobals.TcGlobals -> Range.range -> TypedTree.Val list -> TypedTree.Expr + val inversePerm : sigma:int array -> int [] + val permute : sigma:int [] -> data:'T [] -> 'T [] + val existsR : a:int -> b:int -> pred:(int -> bool) -> bool + val liftAllBefore : sigma:int array -> int + val permuteExprList : + sigma:int [] -> + exprs:TypedTree.Expr list -> + ty:TypedTree.TType list -> + names:string list -> TypedTree.Binding list * TypedTree.Expr list + val mkRecordExpr : + TcGlobals.TcGlobals -> + TypedTree.RecordConstructionInfo * TypedTree.TyconRef * + TypedTree.TypeInst * TypedTree.RecdFieldRef list * TypedTree.Expr list * + Range.range -> TypedTree.Expr + val mkAnonRecd : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.AnonRecdTypeInfo -> + SyntaxTree.Ident [] -> + TypedTree.Expr list -> TypedTree.TType list -> TypedTree.Expr + val mkRefCell : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkRefCellGet : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkRefCellSet : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkNil : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCons : + TcGlobals.TcGlobals -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCompGenLocalAndInvisibleBind : + TcGlobals.TcGlobals -> + string -> + Range.range -> + TypedTree.Expr -> TypedTree.Val * TypedTree.Expr * TypedTree.Binding + val box : AbstractIL.IL.ILInstr + val isinst : AbstractIL.IL.ILInstr + val unbox : AbstractIL.IL.ILInstr + val mkUnbox : + TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr + val mkBox : + TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr + val mkIsInst : + TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr + val mspec_Type_GetTypeFromHandle : + TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mspec_String_Length : + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mspec_String_Concat2 : + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mspec_String_Concat3 : + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mspec_String_Concat4 : + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mspec_String_Concat_Array : + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val fspec_Missing_Value : TcGlobals.TcGlobals -> AbstractIL.IL.ILFieldSpec + val mkInitializeArrayMethSpec : + TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec + val mkInvalidCastExnNewobj : TcGlobals.TcGlobals -> AbstractIL.IL.ILInstr + val typedExprForIntrinsic : + _g:'a -> + m:Range.range -> + TcGlobals.IntrinsicValRef -> TypedTree.Expr * TypedTree.TType + val mkCallGetGenericComparer : + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkCallGetGenericEREqualityComparer : + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkCallGetGenericPEREqualityComparer : + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkCallUnbox : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallUnboxFast : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallTypeTest : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallTypeOf : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCallTypeDefOf : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCallDispose : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeq : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallCreateInstance : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCallGetQuerySourceAsEnumerable : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallNewQuerySource : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallCreateEvent : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGenericComparisonWithComparerOuter : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGenericEqualityEROuter : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGenericEqualityWithComparerOuter : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGenericHashWithComparerOuter : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallEqualsOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallNotEqualsOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallLessThanOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallLessThanOrEqualsOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGreaterThanOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallGreaterThanOrEqualsOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallAdditionOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSubtractionOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallMultiplyOperator : + TcGlobals.TcGlobals -> + Range.range -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> + rty:TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallDivisionOperator : + TcGlobals.TcGlobals -> + Range.range -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> + rty:TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallModulusOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallDefaultOf : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCallBitwiseAndOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallBitwiseOrOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallBitwiseXorOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallShiftLeftOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallShiftRightOperator : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallUnaryNegOperator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallUnaryNotOperator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallAdditionChecked : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSubtractionChecked : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallMultiplyChecked : + TcGlobals.TcGlobals -> + Range.range -> + ty1:TypedTree.TType -> + ty2:TypedTree.TType -> + rty:TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallUnaryNegChecked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToByteChecked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToSByteChecked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt16Checked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt16Checked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToIntChecked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt32Checked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt32Checked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt64Checked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt64Checked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToIntPtrChecked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUIntPtrChecked : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToByteOperator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToSByteOperator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt16Operator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt16Operator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToIntOperator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt32Operator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt32Operator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToInt64Operator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUInt64Operator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToSingleOperator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToDoubleOperator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToIntPtrOperator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToUIntPtrOperator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToCharOperator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallToEnumOperator : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallArrayLength : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallArrayGet : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray2DGet : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray3DGet : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray4DGet : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArraySet : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray2DSet : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray3DSet : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallArray4DSet : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallHash : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallBox : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallIsNull : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallIsNotNull : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallRaise : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallNewDecimal : + g:TcGlobals.TcGlobals -> + m:Range.range -> + e1:TypedTree.Expr * e2:TypedTree.Expr * e3:TypedTree.Expr * + e4:TypedTree.Expr * e5:TypedTree.Expr -> TypedTree.Expr + val mkCallNewFormat : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.TType -> + formatStringExpr:TypedTree.Expr -> TypedTree.Expr + val tryMkCallBuiltInWitness : + TcGlobals.TcGlobals -> + TypedTree.TraitConstraintInfo -> + TypedTree.Expr list -> Range.range -> TypedTree.Expr option + val tryMkCallCoreFunctionAsBuiltInWitness : + TcGlobals.TcGlobals -> + TcGlobals.IntrinsicValRef -> + TypedTree.TType list -> + TypedTree.Expr list -> Range.range -> TypedTree.Expr option + val TryEliminateDesugaredConstants : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Const -> TypedTree.Expr option + val mkSeqTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkIEnumeratorTy : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType + val mkCallSeqCollect : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqUsing : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqDelay : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqAppend : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqGenerated : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqFinally : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqOfFunctions : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqToArray : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqToList : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqMap : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqSingleton : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallSeqEmpty : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr + val mkCall_sprintf : + g:TcGlobals.TcGlobals -> + m:Range.range -> + funcTy:TypedTree.TType -> + fmtExpr:TypedTree.Expr -> + fillExprs:TypedTree.Expr list -> TypedTree.Expr + val mkCallDeserializeQuotationFSharp20Plus : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallDeserializeQuotationFSharp40Plus : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkCallCastQuotation : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallLiftValue : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallLiftValueWithName : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> string -> TypedTree.Expr -> TypedTree.Expr + val mkCallLiftValueWithDefn : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallCheckThis : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCallFailInit : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkCallFailStaticInit : + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr + val mkCallQuoteToLinqLambdaExpression : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkOptionToNullable : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkOptionDefaultValue : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkLazyDelayed : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkLazyForce : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkGetString : + g:TcGlobals.TcGlobals -> + m:Range.range -> + e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr + val mkGetStringChar : + (TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr -> + TypedTree.Expr) + val mkGetStringLength : + g:TcGlobals.TcGlobals -> + m:Range.range -> e:TypedTree.Expr -> TypedTree.Expr + val mkStaticCall_String_Concat2 : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkStaticCall_String_Concat3 : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkStaticCall_String_Concat4 : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkStaticCall_String_Concat_Array : + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val mkDecr : + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val mkIncr : + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val mkLdlen : + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val mkLdelem : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkILAsmCeq : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkILAsmClt : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkNull : Range.range -> TypedTree.TType -> TypedTree.Expr + val mkThrow : + Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val destThrow : + _arg1:TypedTree.Expr -> + (Range.range * TypedTree.TType * TypedTree.Expr) option + val isThrow : TypedTree.Expr -> bool + val mkReraiseLibCall : + TcGlobals.TcGlobals -> TypedTree.TType -> Range.range -> TypedTree.Expr + val mkReraise : Range.range -> TypedTree.TType -> TypedTree.Expr + val tnameCompilationSourceNameAttr : string + val tnameCompilationArgumentCountsAttr : string + val tnameCompilationMappingAttr : string + val tnameSourceConstructFlags : string + val tref_CompilationArgumentCountsAttr : + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef + val tref_CompilationMappingAttr : + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef + val tref_CompilationSourceNameAttr : + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef + val tref_SourceConstructFlags : + g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef + val mkCompilationMappingAttrPrim : + g:TcGlobals.TcGlobals -> + k:int32 -> nums:int32 list -> AbstractIL.IL.ILAttribute + val mkCompilationMappingAttr : + TcGlobals.TcGlobals -> int32 -> AbstractIL.IL.ILAttribute + val mkCompilationMappingAttrWithSeqNum : + TcGlobals.TcGlobals -> int32 -> int32 -> AbstractIL.IL.ILAttribute + val mkCompilationMappingAttrWithVariantNumAndSeqNum : + TcGlobals.TcGlobals -> + int32 -> int32 -> int32 -> AbstractIL.IL.ILAttribute + val mkCompilationArgumentCountsAttr : + TcGlobals.TcGlobals -> int32 list -> AbstractIL.IL.ILAttribute + val mkCompilationSourceNameAttr : + TcGlobals.TcGlobals -> string -> AbstractIL.IL.ILAttribute + val mkCompilationMappingAttrForQuotationResource : + TcGlobals.TcGlobals -> + string * AbstractIL.IL.ILTypeRef list -> AbstractIL.IL.ILAttribute + val isTypeProviderAssemblyAttr : cattr:AbstractIL.IL.ILAttribute -> bool + val TryDecodeTypeProviderAssemblyAttr : + AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option + val tname_SignatureDataVersionAttr : string + val tnames_SignatureDataVersionAttr : string list * string + val tref_SignatureDataVersionAttr : unit -> AbstractIL.IL.ILTypeRef + val mkSignatureDataVersionAttr : + TcGlobals.TcGlobals -> + AbstractIL.IL.ILVersionInfo -> AbstractIL.IL.ILAttribute + val tname_AutoOpenAttr : string + val IsSignatureDataVersionAttr : AbstractIL.IL.ILAttribute -> bool + val TryFindAutoOpenAttr : + AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option + val tname_InternalsVisibleToAttr : string + val TryFindInternalsVisibleToAttr : + AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option + val IsMatchingSignatureDataVersionAttr : + AbstractIL.IL.ILGlobals -> + AbstractIL.IL.ILVersionInfo -> AbstractIL.IL.ILAttribute -> bool + val mkCompilerGeneratedAttr : + TcGlobals.TcGlobals -> int32 -> AbstractIL.IL.ILAttribute + val untupledToRefTupled : + g:TcGlobals.TcGlobals -> + vs:TypedTree.Val list -> + TypedTree.Val * (TypedTree.Expr -> TypedTree.Expr) + val AdjustArityOfLambdaBody : + TcGlobals.TcGlobals -> + int -> + TypedTree.Val list -> + TypedTree.Expr -> TypedTree.Val list * TypedTree.Expr + val MultiLambdaToTupledLambda : + TcGlobals.TcGlobals -> + TypedTree.Val list -> TypedTree.Expr -> TypedTree.Val * TypedTree.Expr + val ( |RefTuple|_| ) : expr:TypedTree.Expr -> TypedTree.Exprs option + val MultiLambdaToTupledLambdaIfNeeded : + g:TcGlobals.TcGlobals -> + vs:TypedTree.Val list * arg:TypedTree.Expr -> + body:TypedTree.Expr -> + (TypedTree.Val * TypedTree.Expr) list * TypedTree.Expr + val MakeApplicationAndBetaReduceAux : + g:TcGlobals.TcGlobals -> + f:TypedTree.Expr * fty:TypedTree.TType * + tyargsl:TypedTree.TType list list * argsl:TypedTree.Expr list * + m:Range.range -> TypedTree.Expr + val MakeApplicationAndBetaReduce : + TcGlobals.TcGlobals -> + TypedTree.Expr * TypedTree.TType * TypedTree.TType list list * + TypedTree.Expr list * Range.range -> TypedTree.Expr + val MakeArgsForTopArgs : + _g:'a -> + m:Range.range -> + argtysl:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> + tpenv:(TypedTree.Typar * TypedTree.TType) list -> + TypedTree.Val list list + val AdjustValForExpectedArity : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.ValRef -> + TypedTree.ValUseFlag -> + TypedTree.ValReprInfo -> TypedTree.Expr * TypedTree.TType + val IsSubsumptionExpr : g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> bool + val stripTupledFunTy : + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType -> TypedTree.TTypes list * TypedTree.TType + val ( |ExprValWithPossibleTypeInst|_| ) : + TypedTree.Expr -> + (TypedTree.ValRef * TypedTree.ValUseFlag * TypedTree.TypeInst * + Range.range) option + val mkCoerceIfNeeded : + TcGlobals.TcGlobals -> + tgtTy:TypedTree.TType -> + srcTy:TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr + val mkCompGenLetIn : + Range.range -> + string -> + TypedTree.TType -> + TypedTree.Expr -> + (TypedTree.Val * TypedTree.Expr -> TypedTree.Expr) -> + TypedTree.Expr + val AdjustPossibleSubsumptionExpr : + TcGlobals.TcGlobals -> + TypedTree.Expr -> + TypedTree.Expr list -> (TypedTree.Expr * TypedTree.Expr list) option + val NormalizeAndAdjustPossibleSubsumptionExprs : + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr + val etaExpandTypeLambda : + g:TcGlobals.TcGlobals -> + m:Range.range -> + tps:TypedTree.Typar list -> + tm:TypedTree.Expr * ty:TypedTree.TType -> TypedTree.Expr + val AdjustValToTopVal : + TypedTree.Val -> TypedTree.ParentRef -> TypedTree.ValReprInfo -> unit + val LinearizeTopMatchAux : + g:TcGlobals.TcGlobals -> + parent:TypedTree.ParentRef -> + spBind:SyntaxTree.DebugPointForBinding * m:Range.range * + tree:TypedTree.DecisionTree * targets:TypedTree.DecisionTreeTarget [] * + m2:Range.range * ty:TypedTree.TType -> TypedTree.Expr + val LinearizeTopMatch : + TcGlobals.TcGlobals -> + TypedTree.ParentRef -> TypedTree.Expr -> TypedTree.Expr + val commaEncs : strs:seq -> string + val angleEnc : str:string -> string + val ticksAndArgCountTextOfTyconRef : TypedTree.TyconRef -> string + val typarEnc : + _g:'a -> + gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> + typar:TypedTree.Typar -> string + val typeEnc : + g:TcGlobals.TcGlobals -> + gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> + ty:TypedTree.TType -> string + val tyargsEnc : + g:TcGlobals.TcGlobals -> + gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> + args:TypedTree.TypeInst -> string + val XmlDocArgsEnc : + TcGlobals.TcGlobals -> + TypedTree.Typar list * TypedTree.Typar list -> + TypedTree.TType list -> string + val buildAccessPath : TypedTree.CompilationPath option -> string + val prependPath : path:string -> name:string -> string + val XmlDocSigOfVal : + TcGlobals.TcGlobals -> full:bool -> string -> TypedTree.Val -> string + val BuildXmlDocSig : prefix:string -> paths:string list -> string + val XmlDocSigOfUnionCase : (string list -> string) + val XmlDocSigOfField : (string list -> string) + val XmlDocSigOfProperty : (string list -> string) + val XmlDocSigOfTycon : (string list -> string) + val XmlDocSigOfSubModul : (string list -> string) + val XmlDocSigOfEntity : TypedTree.EntityRef -> string + val enum_CompilationRepresentationAttribute_Static : int + val enum_CompilationRepresentationAttribute_Instance : int + val enum_CompilationRepresentationAttribute_StaticInstanceMask : int + val enum_CompilationRepresentationAttribute_ModuleSuffix : int + val enum_CompilationRepresentationAttribute_PermitNull : int + val HasUseNullAsTrueValueAttribute : + g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> bool + val TyconHasUseNullAsTrueValueAttribute : + TcGlobals.TcGlobals -> TypedTree.Tycon -> bool + val CanHaveUseNullAsTrueValueAttribute : + TcGlobals.TcGlobals -> TypedTree.Tycon -> bool + val IsUnionTypeWithNullAsTrueValue : + TcGlobals.TcGlobals -> TypedTree.Tycon -> bool + val TyconCompilesInstanceMembersAsStatic : + g:TcGlobals.TcGlobals -> tycon:TypedTree.Tycon -> bool + val TcrefCompilesInstanceMembersAsStatic : + g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> bool + val isNonNullableStructTyparTy : + TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isReferenceTyparTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val TypeNullNever : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val TypeNullIsExtraValue : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val TypeNullIsTrueValue : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val TypeNullNotLiked : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val TypeSatisfiesNullConstraint : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val TypeHasDefaultValue : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val ( |SpecialComparableHeadType|_| ) : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes option + val ( |SpecialEquatableHeadType|_| ) : + TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes option + val ( |SpecialNotEquatableHeadType|_| ) : + TcGlobals.TcGlobals -> TypedTree.TType -> unit option + val canUseTypeTestFast : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val canUseUnboxFast : + TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool + val mkIsInstConditional : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> + TypedTree.Val -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkNullTest : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkNonNullTest : + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val mkNonNullCond : + TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val mkIfThen : + TcGlobals.TcGlobals -> + Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr + val ModuleNameIsMangled : + TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool + val CompileAsEvent : TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool + val MemberIsCompiledAsInstance : + TcGlobals.TcGlobals -> + TypedTree.TyconRef -> + bool -> TypedTree.ValMemberInfo -> TypedTree.Attrib list -> bool + val isSealedTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val isComInteropTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool + val ValSpecIsCompiledAsInstance : + TcGlobals.TcGlobals -> TypedTree.Val -> bool + val ValRefIsCompiledAsInstanceMember : + TcGlobals.TcGlobals -> TypedTree.ValRef -> bool + val GetMemberCallInfo : + TcGlobals.TcGlobals -> + TypedTree.ValRef * TypedTree.ValUseFlag -> + int * bool * bool * bool * bool * bool * bool * bool + val TryGetActivePatternInfo : + TypedTree.ValRef -> PrettyNaming.ActivePatternInfo option + type ActivePatternElemRef with + member Name : string + val mkChoiceTyconRef : + g:TcGlobals.TcGlobals -> m:Range.range -> n:int -> TypedTree.EntityRef + val mkChoiceTy : + g:TcGlobals.TcGlobals -> + m:Range.range -> tinst:TypedTree.TType list -> TypedTree.TType + val mkChoiceCaseRef : + TcGlobals.TcGlobals -> Range.range -> int -> int -> TypedTree.UnionCaseRef + type ActivePatternInfo with + member Names : string list + type ActivePatternInfo with + member + ResultType : TcGlobals.TcGlobals -> + Range.range -> TypedTree.TType list -> TypedTree.TType + type ActivePatternInfo with + member + OverallType : TcGlobals.TcGlobals -> + Range.range -> + TypedTree.TType -> + TypedTree.TType list -> TypedTree.TType + val doesActivePatternHaveFreeTypars : + TcGlobals.TcGlobals -> TypedTree.ValRef -> bool + [] + type ExprRewritingEnv = + { PreIntercept: + ((TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr -> + TypedTree.Expr option) option + PostTransform: TypedTree.Expr -> TypedTree.Expr option + PreInterceptBinding: + ((TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Binding -> + TypedTree.Binding option) option + IsUnderQuotations: bool } + val rewriteBind : + env:ExprRewritingEnv -> bind:TypedTree.Binding -> TypedTree.Binding + val rewriteBindStructure : + env:ExprRewritingEnv -> TypedTree.Binding -> TypedTree.Binding + val rewriteBinds : + env:ExprRewritingEnv -> + binds:TypedTree.Binding list -> TypedTree.Binding list + val RewriteExpr : ExprRewritingEnv -> TypedTree.Expr -> TypedTree.Expr + val preRewriteExpr : + env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr option + val postRewriteExpr : + env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr + val rewriteExprStructure : + env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr + val rewriteLinearExpr : + env:ExprRewritingEnv -> + expr:TypedTree.Expr -> + contf:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr + val rewriteExprs : + env:ExprRewritingEnv -> exprs:TypedTree.Exprs -> TypedTree.Exprs + val rewriteFlatExprs : + env:ExprRewritingEnv -> exprs:TypedTree.Expr list -> TypedTree.Expr list + val RewriteDecisionTree : + env:ExprRewritingEnv -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree + val rewriteTarget : + env:ExprRewritingEnv -> + TypedTree.DecisionTreeTarget -> TypedTree.DecisionTreeTarget + val rewriteTargets : + env:ExprRewritingEnv -> + targets:TypedTree.DecisionTreeTarget array -> + TypedTree.DecisionTreeTarget list + val rewriteObjExprOverride : + env:ExprRewritingEnv -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod + val rewriteObjExprInterfaceImpl : + env:ExprRewritingEnv -> + ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> + TypedTree.TType * TypedTree.ObjExprMethod list + val rewriteModuleOrNamespaceExpr : + env:ExprRewritingEnv -> + x:TypedTree.ModuleOrNamespaceExprWithSig -> + TypedTree.ModuleOrNamespaceExprWithSig + val rewriteModuleOrNamespaceDefs : + env:ExprRewritingEnv -> + x:TypedTree.ModuleOrNamespaceExpr list -> + TypedTree.ModuleOrNamespaceExpr list + val rewriteModuleOrNamespaceDef : + env:ExprRewritingEnv -> + x:TypedTree.ModuleOrNamespaceExpr -> TypedTree.ModuleOrNamespaceExpr + val rewriteModuleOrNamespaceBinding : + env:ExprRewritingEnv -> + x:TypedTree.ModuleOrNamespaceBinding -> + TypedTree.ModuleOrNamespaceBinding + val rewriteModuleOrNamespaceBindings : + env:ExprRewritingEnv -> + mbinds:TypedTree.ModuleOrNamespaceBinding list -> + TypedTree.ModuleOrNamespaceBinding list + val RewriteImplFile : + ExprRewritingEnv -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile + val MakeExportRemapping : + TypedTree.CcuThunk -> TypedTree.ModuleOrNamespace -> Remap + val remapEntityDataToNonLocal : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> d:TypedTree.Entity -> TypedTree.Entity + val remapTyconToNonLocal : + g:TcGlobals.TcGlobals -> + tmenv:Remap -> x:TypedTree.Entity -> TypedTree.Entity + val remapValToNonLocal : + g:TcGlobals.TcGlobals -> tmenv:Remap -> inp:TypedTree.Val -> TypedTree.Val + val ApplyExportRemappingToEntity : + TcGlobals.TcGlobals -> Remap -> TypedTree.Entity -> TypedTree.Entity + val isCompiledConstraint : cx:TypedTree.TyparConstraint -> bool + val IsGenericValWithGenericConstraints : + TcGlobals.TcGlobals -> TypedTree.Val -> bool + type Entity with + member HasInterface : TcGlobals.TcGlobals -> TypedTree.TType -> bool + type Entity with + member + HasOverride : TcGlobals.TcGlobals -> + string -> TypedTree.TType list -> bool + type Entity with + member + HasMember : TcGlobals.TcGlobals -> + string -> TypedTree.TType list -> bool + type EntityRef with + member HasInterface : TcGlobals.TcGlobals -> TypedTree.TType -> bool + type EntityRef with + member + HasOverride : TcGlobals.TcGlobals -> + string -> TypedTree.TType list -> bool + type EntityRef with + member + HasMember : TcGlobals.TcGlobals -> + string -> TypedTree.TType list -> bool + val mkFastForLoop : + TcGlobals.TcGlobals -> + SyntaxTree.DebugPointAtFor * Range.range * TypedTree.Val * + TypedTree.Expr * bool * TypedTree.Expr * TypedTree.Expr -> + TypedTree.Expr + val IsSimpleSyntacticConstantExpr : + TcGlobals.TcGlobals -> TypedTree.Expr -> bool + val EvalArithBinOp : + opInt8:(sbyte -> sbyte -> sbyte) * opInt16:(int16 -> int16 -> int16) * + opInt32:(int32 -> int32 -> int32) * opInt64:(int64 -> int64 -> int64) * + opUInt8:(byte -> byte -> byte) * opUInt16:(uint16 -> uint16 -> uint16) * + opUInt32:(uint32 -> uint32 -> uint32) * + opUInt64:(uint64 -> uint64 -> uint64) -> + arg1:TypedTree.Expr -> arg2:TypedTree.Expr -> TypedTree.Expr + val EvalAttribArgExpr : + g:TcGlobals.TcGlobals -> x:TypedTree.Expr -> TypedTree.Expr + val EvaledAttribExprEquality : + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr -> bool + val ( |ConstToILFieldInit|_| ) : + TypedTree.Const -> AbstractIL.IL.ILFieldInit option + val EvalLiteralExprOrAttribArg : + TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr + val GetTypeOfIntrinsicMemberInCompiledForm : + TcGlobals.TcGlobals -> + TypedTree.ValRef -> + TypedTree.Typar list * TypedTree.TraitWitnessInfo list * + (TypedTree.TType * TypedTree.ArgReprInfo) list list * + TypedTree.TType option * TypedTree.ArgReprInfo + val mkCompiledTuple : + TcGlobals.TcGlobals -> + bool -> + TypedTree.TType list * TypedTree.Expr list * Range.range -> + TypedTree.EntityRef * TypedTree.TType list * TypedTree.Expr list * + Range.range + val mkILMethodSpecForTupleItem : + _g:TcGlobals.TcGlobals -> + ty:AbstractIL.IL.ILType -> n:int -> AbstractIL.IL.ILMethodSpec + val mkILFieldSpecForTupleItem : + ty:AbstractIL.IL.ILType -> n:int -> AbstractIL.IL.ILFieldSpec + val mkGetTupleItemN : + TcGlobals.TcGlobals -> + Range.range -> + int -> + AbstractIL.IL.ILType -> + bool -> TypedTree.Expr -> TypedTree.TType -> TypedTree.Expr + val ( |Int32Expr|_| ) : TypedTree.Expr -> int32 option + val ( |TryFinally|_| ) : + expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option + val ( |WhileLoopForCompiledForEachExpr|_| ) : + expr:TypedTree.Expr -> + (TypedTree.Expr * TypedTree.Expr * Range.range) option + val ( |Let|_| ) : + expr:TypedTree.Expr -> + (TypedTree.Val * TypedTree.Expr * SyntaxTree.DebugPointForBinding * + TypedTree.Expr) option + val ( |RangeInt32Step|_| ) : + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> (TypedTree.Expr * int * TypedTree.Expr) option + val ( |GetEnumeratorCall|_| ) : + expr:TypedTree.Expr -> TypedTree.ValRef option + val ( |CompiledForEachExpr|_| ) : + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> + (TypedTree.TType * TypedTree.Expr * TypedTree.Val * TypedTree.Expr * + (Range.range * Range.range * SyntaxTree.DebugPointAtFor * Range.range * + SyntaxTree.DebugPointAtWhile * Range.range)) option + val ( |CompiledInt32RangeForEachExpr|_| ) : + g:TcGlobals.TcGlobals -> + expr:TypedTree.Expr -> + (TypedTree.Expr * int * TypedTree.Expr * TypedTree.Val * + TypedTree.Expr * + (Range.range * Range.range * SyntaxTree.DebugPointAtFor * Range.range * + SyntaxTree.DebugPointAtWhile * Range.range)) option + type OptimizeForExpressionOptions = + | OptimizeIntRangesOnly + | OptimizeAllForExpressions + val DetectAndOptimizeForExpression : + TcGlobals.TcGlobals -> + OptimizeForExpressionOptions -> TypedTree.Expr -> TypedTree.Expr + val ( |InnerExprPat| ) : TypedTree.Expr -> TypedTree.Expr + val BindUnitVars : + TcGlobals.TcGlobals -> + (TypedTree.Val list * TypedTree.ArgReprInfo list * TypedTree.Expr) -> + TypedTree.Val list * TypedTree.Expr + val isThreadOrContextStatic : + TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool + val mkUnitDelayLambda : + TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr + val ( |ValApp|_| ) : + TcGlobals.TcGlobals -> + TypedTree.ValRef -> + TypedTree.Expr -> + (TypedTree.TypeInst * TypedTree.Exprs * Range.range) option + val CombineCcuContentFragments : + Range.range -> + TypedTree.ModuleOrNamespaceType list -> TypedTree.ModuleOrNamespaceType + type TraitWitnessInfoHashMap<'T> = + System.Collections.Immutable.ImmutableDictionary + val EmptyTraitWitnessInfoHashMap : + TcGlobals.TcGlobals -> TraitWitnessInfoHashMap<'T> + val ( |WhileExpr|_| ) : + TypedTree.Expr -> + (SyntaxTree.DebugPointAtWhile * TypedTree.SpecialWhileLoopMarker * + TypedTree.Expr * TypedTree.Expr * Range.range) option + val ( |TryFinallyExpr|_| ) : + TypedTree.Expr -> + (SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally * + TypedTree.TType * TypedTree.Expr * TypedTree.Expr * Range.range) option + val ( |ForLoopExpr|_| ) : + TypedTree.Expr -> + (SyntaxTree.DebugPointAtFor * TypedTree.ForLoopStyle * TypedTree.Expr * + TypedTree.Expr * TypedTree.Val * TypedTree.Expr * Range.range) option + val ( |TryWithExpr|_| ) : + TypedTree.Expr -> + (SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith * + TypedTree.TType * TypedTree.Expr * TypedTree.Val * TypedTree.Expr * + TypedTree.Val * TypedTree.Expr * Range.range) option + val mkLabelled : + Range.range -> + AbstractIL.IL.ILCodeLabel -> TypedTree.Expr -> TypedTree.Expr + end + +namespace FSharp.Compiler + module internal TypedTreePickle = begin + val verbose : bool + val ffailwith : fileName:System.String -> str:System.String -> 'a + [] + type PickledDataWithReferences<'RawData> = + { RawData: 'RawData + FixupThunks: TypedTree.CcuThunk [] } + with + member Fixup : (string -> TypedTree.CcuThunk) -> 'RawData + member OptionalFixup : (string -> TypedTree.CcuThunk option) -> 'RawData + end + [] + type Table<'T> = + { name: string + tbl: System.Collections.Generic.Dictionary<'T,int> + mutable rows: ResizeArray<'T> + mutable count: int } + with + static member Create : n:string -> Table<'a> when 'a : equality + member Add : x:'T -> int + member FindOrAdd : x:'T -> int + member AsArray : 'T [] + member Size : int + end + [] + type InputTable<'T> = + { itbl_name: string + itbl_rows: 'T array } + val new_itbl : n:string -> r:'a array -> InputTable<'a> + [] + type NodeOutTable<'Data,'Node> = + { NodeStamp: 'Node -> TypedTree.Stamp + NodeName: 'Node -> string + GetRange: 'Node -> Range.range + Deref: 'Node -> 'Data + Name: string + Table: Table } + with + static member + Create : stampF:('a -> TypedTree.Stamp) * nameF:('a -> string) * + rangeF:('a -> Range.range) * derefF:('a -> 'b) * nm:string -> + NodeOutTable<'b,'a> + member Size : int + end + [] + type WriterState = + { os: AbstractIL.Internal.ByteBuffer + oscope: TypedTree.CcuThunk + occus: Table + oentities: NodeOutTable + otypars: NodeOutTable + ovals: NodeOutTable + oanoninfos: + NodeOutTable + ostrings: Table + opubpaths: Table + onlerefs: Table + osimpletys: Table + oglobals: TcGlobals.TcGlobals + mutable isStructThisArgPos: bool + ofile: string + oInMem: bool } + val pfailwith : st:WriterState -> str:System.String -> 'a + [] + type NodeInTable<'Data,'Node> = + { LinkNode: 'Node -> 'Data -> unit + IsLinked: 'Node -> bool + Name: string + Nodes: 'Node [] } + with + static member + Create : mkEmpty:(unit -> 'a) * lnk:('a -> 'b -> unit) * + isLinked:('a -> bool) * nm:string * n:int -> + NodeInTable<'b,'a> + member Get : n:int -> 'Node + member Count : int + end + [] + type ReaderState = + { is: AbstractIL.Internal.ByteStream + iilscope: AbstractIL.IL.ILScopeRef + iccus: InputTable + ientities: NodeInTable + itypars: NodeInTable + ivals: NodeInTable + ianoninfos: + NodeInTable + istrings: InputTable + ipubpaths: InputTable + inlerefs: InputTable + isimpletys: InputTable + ifile: string + iILModule: AbstractIL.IL.ILModuleDef option } + val ufailwith : st:ReaderState -> str:System.String -> 'a + type 'T pickler = 'T -> WriterState -> unit + val p_byte : int -> WriterState -> unit + val p_bool : bool -> WriterState -> unit + val prim_p_int32 : i:int -> st:WriterState -> unit + val p_int32 : n:int -> st:WriterState -> unit + val space : unit + val p_space : n:int -> unit -> st:WriterState -> unit + val p_used_space1 : f:(WriterState -> unit) -> st:WriterState -> unit + val p_bytes : s:byte [] -> st:WriterState -> unit + val p_prim_string : s:string -> st:WriterState -> unit + val p_int : int -> WriterState -> unit + val p_int8 : i:sbyte -> st:WriterState -> unit + val p_uint8 : i:byte -> st:WriterState -> unit + val p_int16 : i:int16 -> st:WriterState -> unit + val p_uint16 : x:uint16 -> st:WriterState -> unit + val p_uint32 : x:uint32 -> st:WriterState -> unit + val p_int64 : i:int64 -> st:WriterState -> unit + val p_uint64 : x:uint64 -> st:WriterState -> unit + val bits_of_float32 : x:float32 -> int + val bits_of_float : x:float -> int64 + val p_single : i:float32 -> st:WriterState -> unit + val p_double : i:float -> st:WriterState -> unit + val p_ieee64 : i:float -> st:WriterState -> unit + val p_char : i:char -> st:WriterState -> unit + val inline p_tup2 : + ('T1 -> WriterState -> unit) -> + ('T2 -> WriterState -> unit) -> ('T1 * 'T2 -> WriterState -> unit) + val inline p_tup3 : + ('T1 -> WriterState -> unit) -> + ('T2 -> WriterState -> unit) -> + ('T3 -> WriterState -> unit) -> + ('T1 * 'T2 * 'T3 -> WriterState -> unit) + val inline p_tup4 : + ('T1 -> WriterState -> unit) -> + ('T2 -> WriterState -> unit) -> + ('T3 -> WriterState -> unit) -> + ('T4 -> WriterState -> unit) -> + ('T1 * 'T2 * 'T3 * 'T4 -> WriterState -> unit) + val inline p_tup5 : + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e -> st:WriterState -> unit + val inline p_tup6 : + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f -> + st:WriterState -> unit + val inline p_tup7 : + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + p7:('g -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g -> + st:WriterState -> unit + val inline p_tup8 : + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + p7:('g -> WriterState -> unit) -> + p8:('h -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * x8:'h -> + st:WriterState -> unit + val inline p_tup9 : + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + p7:('g -> WriterState -> unit) -> + p8:('h -> WriterState -> unit) -> + p9:('i -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * x8:'h * + x9:'i -> st:WriterState -> unit + val inline p_tup10 : + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + p7:('g -> WriterState -> unit) -> + p8:('h -> WriterState -> unit) -> + p9:('i -> WriterState -> unit) -> + p10:('j -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * + x8:'h * x9:'i * x10:'j -> st:WriterState -> unit + val inline p_tup11 : + p1:('a -> WriterState -> unit) -> + p2:('b -> WriterState -> unit) -> + p3:('c -> WriterState -> unit) -> + p4:('d -> WriterState -> unit) -> + p5:('e -> WriterState -> unit) -> + p6:('f -> WriterState -> unit) -> + p7:('g -> WriterState -> unit) -> + p8:('h -> WriterState -> unit) -> + p9:('i -> WriterState -> unit) -> + p10:('j -> WriterState -> unit) -> + p11:('k -> WriterState -> unit) -> + a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * + x8:'h * x9:'i * x10:'j * x11:'k -> + st:WriterState -> unit + val u_byte : ReaderState -> int + type unpickler<'T> = ReaderState -> 'T + val u_bool : ReaderState -> bool + val prim_u_int32 : st:ReaderState -> int + val u_int32 : st:ReaderState -> int + val u_byte_memory : st:ReaderState -> AbstractIL.Internal.ReadOnlyByteMemory + val u_bytes : st:ReaderState -> byte [] + val u_prim_string : st:ReaderState -> string + val u_int : ReaderState -> int + val u_int8 : st:ReaderState -> sbyte + val u_uint8 : st:ReaderState -> byte + val u_int16 : st:ReaderState -> int16 + val u_uint16 : st:ReaderState -> uint16 + val u_uint32 : st:ReaderState -> uint32 + val u_int64 : st:ReaderState -> int64 + val u_uint64 : st:ReaderState -> uint64 + val float32_of_bits : x:int32 -> float32 + val float_of_bits : x:int64 -> float + val u_single : st:ReaderState -> float32 + val u_double : st:ReaderState -> float + val u_ieee64 : st:ReaderState -> float + val u_char : st:ReaderState -> char + val u_space : n:int -> st:ReaderState -> unit + val u_used_space1 : f:(ReaderState -> 'a) -> st:ReaderState -> 'a option + val inline u_tup2 : + (ReaderState -> 'T2) -> (ReaderState -> 'T3) -> (ReaderState -> 'T2 * 'T3) + val inline u_tup3 : + (ReaderState -> 'T2) -> + (ReaderState -> 'T3) -> + (ReaderState -> 'T4) -> (ReaderState -> 'T2 * 'T3 * 'T4) + val inline u_tup4 : + (ReaderState -> 'T2) -> + (ReaderState -> 'T3) -> + (ReaderState -> 'T4) -> + (ReaderState -> 'T5) -> (ReaderState -> 'T2 * 'T3 * 'T4 * 'T5) + val inline u_tup5 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> st:ReaderState -> 'a * 'b * 'c * 'd * 'e + val inline u_tup6 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f + val inline u_tup7 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f * 'g + val inline u_tup8 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h + val inline u_tup9 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i + val inline u_tup10 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j + val inline u_tup11 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j * + 'k + val inline u_tup12 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j * + 'k * 'l + val inline u_tup13 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + p13:(ReaderState -> 'm) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * + 'j * 'k * 'l * 'm + val inline u_tup14 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + p13:(ReaderState -> 'm) -> + p14:(ReaderState -> 'n) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * + 'j * 'k * 'l * 'm * 'n + val inline u_tup15 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + p13:(ReaderState -> 'm) -> + p14:(ReaderState -> 'n) -> + p15:(ReaderState -> 'o) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * + 'j * 'k * 'l * 'm * 'n * 'o + val inline u_tup16 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + p13:(ReaderState -> 'm) -> + p14:(ReaderState -> 'n) -> + p15:(ReaderState -> 'o) -> + p16:(ReaderState -> 'p) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * + 'i * 'j * 'k * 'l * 'm * 'n * 'o * 'p + val inline u_tup17 : + p1:(ReaderState -> 'a) -> + p2:(ReaderState -> 'b) -> + p3:(ReaderState -> 'c) -> + p4:(ReaderState -> 'd) -> + p5:(ReaderState -> 'e) -> + p6:(ReaderState -> 'f) -> + p7:(ReaderState -> 'g) -> + p8:(ReaderState -> 'h) -> + p9:(ReaderState -> 'i) -> + p10:(ReaderState -> 'j) -> + p11:(ReaderState -> 'k) -> + p12:(ReaderState -> 'l) -> + p13:(ReaderState -> 'm) -> + p14:(ReaderState -> 'n) -> + p15:(ReaderState -> 'o) -> + p16:(ReaderState -> 'p) -> + p17:(ReaderState -> 'q) -> + st:ReaderState -> + 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * + 'i * 'j * 'k * 'l * 'm * 'n * 'o * 'p * + 'q + val p_osgn_ref : + _ctxt:string -> + outMap:NodeOutTable<'a,'b> -> x:'b -> st:WriterState -> unit + val p_osgn_decl : + outMap:NodeOutTable<'a,'b> -> + p:('a -> WriterState -> unit) -> x:'b -> st:WriterState -> unit + val u_osgn_ref : inMap:NodeInTable<'a,'b> -> st:ReaderState -> 'b + val u_osgn_decl : + inMap:NodeInTable<'a,'b> -> u:(ReaderState -> 'a) -> st:ReaderState -> 'b + val encode_uniq : tbl:Table<'a> -> key:'a -> int + val lookup_uniq : st:ReaderState -> tbl:InputTable<'a> -> n:int -> 'a + val p_array_core : f:('T -> 'a -> unit) -> x:'T [] -> st:'a -> unit + val p_array : ('T -> WriterState -> unit) -> ('T [] -> WriterState -> unit) + val p_array_ext : + extraf:(WriterState -> unit) option -> + f:('T -> WriterState -> unit) -> x:'T [] -> st:WriterState -> unit + val p_list_core : f:('T -> 'a -> unit) -> xs:'T list -> st:'a -> unit + val p_list : + f:('a -> WriterState -> unit) -> x:'a list -> st:WriterState -> unit + val p_list_ext : + extraf:(WriterState -> unit) option -> + f:('a -> WriterState -> unit) -> x:'a list -> st:WriterState -> unit + val p_List : + f:('T -> WriterState -> unit) -> x:'T list -> st:WriterState -> unit + val p_wrap : f:('T -> 'U) -> p:'U pickler -> x:'T -> st:WriterState -> unit + val p_option : + f:('a -> WriterState -> unit) -> x:'a option -> st:WriterState -> unit + val private p_lazy_impl : + p:('a -> WriterState -> unit) -> v:'a -> st:WriterState -> unit + val p_lazy : + ('T -> WriterState -> unit) -> (System.Lazy<'T> -> WriterState -> unit) + val p_maybe_lazy : + p:('a -> WriterState -> unit) -> + x:Lib.MaybeLazy<'a> -> st:WriterState -> unit + val p_hole : + unit -> (('a -> WriterState -> 'b) -> unit) * ('a -> WriterState -> 'b) + val p_hole2 : + unit -> + (('a -> 'b -> WriterState -> 'c) -> unit) * + ('a -> 'b -> WriterState -> 'c) + val u_array_core : f:('a -> 'b) -> n:int -> st:'a -> 'b [] + val u_array : (ReaderState -> 'T) -> (ReaderState -> 'T []) + val u_array_ext : + extraf:(ReaderState -> 'a) -> + f:(ReaderState -> 'b) -> st:ReaderState -> 'a option * 'b [] + val u_list_core : f:('a -> 'b) -> n:int -> st:'a -> 'b list + val u_list : f:(ReaderState -> 'a) -> st:ReaderState -> 'a list + val u_list_ext : + extra:(ReaderState -> 'a) -> + f:(ReaderState -> 'b) -> st:ReaderState -> 'a option * 'b list + val u_List : f:(ReaderState -> 'a) -> st:ReaderState -> 'a list + val u_array_revi : f:(ReaderState -> int -> 'a) -> st:ReaderState -> 'a [] + val u_list_revi : f:(ReaderState -> int -> 'a) -> st:ReaderState -> 'a list + val u_wrap : f:('U -> 'T) -> u:unpickler<'U> -> st:ReaderState -> 'T + val u_option : f:(ReaderState -> 'a) -> st:ReaderState -> 'a option + val u_lazy : (ReaderState -> 'T) -> (ReaderState -> System.Lazy<'T>) + val u_hole : unit -> ((ReaderState -> 'a) -> unit) * (ReaderState -> 'a) + val encode_string : stringTab:Table<'a> -> x:'a -> int + val decode_string : x:'a -> 'a + val lookup_string : + st:ReaderState -> stringTab:InputTable<'a> -> x:int -> 'a + val u_encoded_string : (ReaderState -> string) + val u_string : ReaderState -> string + val u_strings : (ReaderState -> string list) + val u_ints : (ReaderState -> int list) + val p_encoded_string : (string -> WriterState -> unit) + val p_string : string -> WriterState -> unit + val p_strings : (string list -> WriterState -> unit) + val p_ints : (int list -> WriterState -> unit) + val encode_ccuref : ccuTab:Table -> x:TypedTree.CcuThunk -> int + val decode_ccuref : x:'a -> 'a + val lookup_ccuref : st:ReaderState -> ccuTab:InputTable<'a> -> x:int -> 'a + val u_encoded_ccuref : st:ReaderState -> string + val u_ccuref : st:ReaderState -> TypedTree.CcuThunk + val p_encoded_ccuref : x:string -> st:WriterState -> unit + val p_ccuref : s:TypedTree.CcuThunk -> st:WriterState -> unit + val decode_pubpath : + st:ReaderState -> + stringTab:InputTable -> a:int [] -> TypedTree.PublicPath + val lookup_pubpath : + st:ReaderState -> pubpathTab:InputTable<'a> -> x:int -> 'a + val u_encoded_pubpath : (ReaderState -> int []) + val u_pubpath : st:ReaderState -> TypedTree.PublicPath + val encode_pubpath : + stringTab:Table -> + pubpathTab:Table -> TypedTree.PublicPath -> int + val p_encoded_pubpath : (int [] -> WriterState -> unit) + val p_pubpath : x:TypedTree.PublicPath -> st:WriterState -> unit + val decode_nleref : + st:ReaderState -> + ccuTab:InputTable -> + stringTab:InputTable -> + a:int * b:int [] -> TypedTree.NonLocalEntityRef + val lookup_nleref : + st:ReaderState -> nlerefTab:InputTable<'a> -> x:int -> 'a + val u_encoded_nleref : (ReaderState -> int * int []) + val u_nleref : st:ReaderState -> TypedTree.NonLocalEntityRef + val encode_nleref : + ccuTab:Table -> + stringTab:Table -> + nlerefTab:Table -> + thisCcu:TypedTree.CcuThunk -> + nleref:TypedTree.NonLocalEntityRef -> int + val p_encoded_nleref : (int * int [] -> WriterState -> unit) + val p_nleref : x:TypedTree.NonLocalEntityRef -> st:WriterState -> unit + val decode_simpletyp : + st:ReaderState -> + _ccuTab:'a -> + _stringTab:'b -> + nlerefTab:InputTable -> + a:int -> TypedTree.TType + val lookup_simpletyp : + st:ReaderState -> simpleTyTab:InputTable<'a> -> x:int -> 'a + val u_encoded_simpletyp : st:ReaderState -> int + val u_encoded_anoninfo : st:ReaderState -> int + val u_simpletyp : st:ReaderState -> TypedTree.TType + val encode_simpletyp : + ccuTab:Table -> + stringTab:Table -> + nlerefTab:Table -> + simpleTyTab:Table -> + thisCcu:TypedTree.CcuThunk -> a:TypedTree.NonLocalEntityRef -> int + val p_encoded_simpletyp : x:int -> st:WriterState -> unit + val p_encoded_anoninfo : x:int -> st:WriterState -> unit + val p_simpletyp : x:TypedTree.NonLocalEntityRef -> st:WriterState -> unit + val pickleObjWithDanglingCcus : + inMem:bool -> + file:string -> + TcGlobals.TcGlobals -> + scope:TypedTree.CcuThunk -> + ('T -> WriterState -> unit) -> 'T -> byte [] + val check : + ilscope:AbstractIL.IL.ILScopeRef -> inMap:NodeInTable<'a,'b> -> unit + val unpickleObjWithDanglingCcus : + file:string -> + viewedScope:AbstractIL.IL.ILScopeRef -> + ilModule:AbstractIL.IL.ILModuleDef option -> + (ReaderState -> 'T) -> + AbstractIL.Internal.ReadOnlyByteMemory -> + PickledDataWithReferences<'T> + val p_ILPublicKey : x:AbstractIL.IL.PublicKey -> st:WriterState -> unit + val p_ILVersion : x:AbstractIL.IL.ILVersionInfo -> st:WriterState -> unit + val p_ILModuleRef : x:AbstractIL.IL.ILModuleRef -> st:WriterState -> unit + val p_ILAssemblyRef : + x:AbstractIL.IL.ILAssemblyRef -> st:WriterState -> unit + val p_ILScopeRef : x:AbstractIL.IL.ILScopeRef -> st:WriterState -> unit + val u_ILPublicKey : st:ReaderState -> AbstractIL.IL.PublicKey + val u_ILVersion : st:ReaderState -> AbstractIL.IL.ILVersionInfo + val u_ILModuleRef : st:ReaderState -> AbstractIL.IL.ILModuleRef + val u_ILAssemblyRef : st:ReaderState -> AbstractIL.IL.ILAssemblyRef + val u_ILScopeRef : st:ReaderState -> AbstractIL.IL.ILScopeRef + val p_ILHasThis : x:AbstractIL.IL.ILThisConvention -> st:WriterState -> unit + val p_ILArrayShape : AbstractIL.IL.ILArrayShape pickler + val p_ILType : ty:AbstractIL.IL.ILType -> st:WriterState -> unit + val p_ILTypes : tys:AbstractIL.IL.ILType list -> (WriterState -> unit) + val p_ILBasicCallConv : + x:AbstractIL.IL.ILArgConvention -> st:WriterState -> unit + val p_ILCallConv : AbstractIL.IL.ILCallingConv -> st:WriterState -> unit + val p_ILCallSig : + x:AbstractIL.IL.ILCallingSignature -> st:WriterState -> unit + val p_ILTypeRef : x:AbstractIL.IL.ILTypeRef -> st:WriterState -> unit + val p_ILTypeSpec : a:AbstractIL.IL.ILTypeSpec -> st:WriterState -> unit + val u_ILBasicCallConv : st:ReaderState -> AbstractIL.IL.ILArgConvention + val u_ILHasThis : st:ReaderState -> AbstractIL.IL.ILThisConvention + val u_ILCallConv : st:ReaderState -> AbstractIL.IL.ILCallingConv + val u_ILTypeRef : st:ReaderState -> AbstractIL.IL.ILTypeRef + val u_ILArrayShape : unpickler + val u_ILType : st:ReaderState -> AbstractIL.IL.ILType + val u_ILTypes : st:ReaderState -> AbstractIL.IL.ILType list + val u_ILCallSig : (ReaderState -> AbstractIL.IL.ILCallingSignature) + val u_ILTypeSpec : st:ReaderState -> AbstractIL.IL.ILTypeSpec + val p_ILMethodRef : x:AbstractIL.IL.ILMethodRef -> st:WriterState -> unit + val p_ILFieldRef : x:AbstractIL.IL.ILFieldRef -> st:WriterState -> unit + val p_ILMethodSpec : x:AbstractIL.IL.ILMethodSpec -> st:WriterState -> unit + val p_ILFieldSpec : x:AbstractIL.IL.ILFieldSpec -> st:WriterState -> unit + val p_ILBasicType : x:AbstractIL.IL.ILBasicType -> st:WriterState -> unit + val p_ILVolatility : x:AbstractIL.IL.ILVolatility -> st:WriterState -> unit + val p_ILReadonly : x:AbstractIL.IL.ILReadonly -> st:WriterState -> unit + val u_ILMethodRef : st:ReaderState -> AbstractIL.IL.ILMethodRef + val u_ILFieldRef : st:ReaderState -> AbstractIL.IL.ILFieldRef + val u_ILMethodSpec : st:ReaderState -> AbstractIL.IL.ILMethodSpec + val u_ILFieldSpec : st:ReaderState -> AbstractIL.IL.ILFieldSpec + val u_ILBasicType : st:ReaderState -> AbstractIL.IL.ILBasicType + val u_ILVolatility : st:ReaderState -> AbstractIL.IL.ILVolatility + val u_ILReadonly : st:ReaderState -> AbstractIL.IL.ILReadonly + [] + val itag_nop : int = 0 + [] + val itag_ldarg : int = 1 + [] + val itag_ldnull : int = 2 + [] + val itag_ilzero : int = 3 + [] + val itag_call : int = 4 + [] + val itag_add : int = 5 + [] + val itag_sub : int = 6 + [] + val itag_mul : int = 7 + [] + val itag_div : int = 8 + [] + val itag_div_un : int = 9 + [] + val itag_rem : int = 10 + [] + val itag_rem_un : int = 11 + [] + val itag_and : int = 12 + [] + val itag_or : int = 13 + [] + val itag_xor : int = 14 + [] + val itag_shl : int = 15 + [] + val itag_shr : int = 16 + [] + val itag_shr_un : int = 17 + [] + val itag_neg : int = 18 + [] + val itag_not : int = 19 + [] + val itag_conv : int = 20 + [] + val itag_conv_un : int = 21 + [] + val itag_conv_ovf : int = 22 + [] + val itag_conv_ovf_un : int = 23 + [] + val itag_callvirt : int = 24 + [] + val itag_ldobj : int = 25 + [] + val itag_ldstr : int = 26 + [] + val itag_castclass : int = 27 + [] + val itag_isinst : int = 28 + [] + val itag_unbox : int = 29 + [] + val itag_throw : int = 30 + [] + val itag_ldfld : int = 31 + [] + val itag_ldflda : int = 32 + [] + val itag_stfld : int = 33 + [] + val itag_ldsfld : int = 34 + [] + val itag_ldsflda : int = 35 + [] + val itag_stsfld : int = 36 + [] + val itag_stobj : int = 37 + [] + val itag_box : int = 38 + [] + val itag_newarr : int = 39 + [] + val itag_ldlen : int = 40 + [] + val itag_ldelema : int = 41 + [] + val itag_ckfinite : int = 42 + [] + val itag_ldtoken : int = 43 + [] + val itag_add_ovf : int = 44 + [] + val itag_add_ovf_un : int = 45 + [] + val itag_mul_ovf : int = 46 + [] + val itag_mul_ovf_un : int = 47 + [] + val itag_sub_ovf : int = 48 + [] + val itag_sub_ovf_un : int = 49 + [] + val itag_ceq : int = 50 + [] + val itag_cgt : int = 51 + [] + val itag_cgt_un : int = 52 + [] + val itag_clt : int = 53 + [] + val itag_clt_un : int = 54 + [] + val itag_ldvirtftn : int = 55 + [] + val itag_localloc : int = 56 + [] + val itag_rethrow : int = 57 + [] + val itag_sizeof : int = 58 + [] + val itag_ldelem_any : int = 59 + [] + val itag_stelem_any : int = 60 + [] + val itag_unbox_any : int = 61 + [] + val itag_ldlen_multi : int = 62 + [] + val itag_initobj : int = 63 + [] + val itag_initblk : int = 64 + [] + val itag_cpobj : int = 65 + [] + val itag_cpblk : int = 66 + val simple_instrs : (int * AbstractIL.IL.ILInstr) list + val encode_table : + System.Collections.Generic.Dictionary + val encode_instr : si:AbstractIL.IL.ILInstr -> int + val isNoArgInstr : s:AbstractIL.IL.ILInstr -> bool + val decoders : (int * (ReaderState -> AbstractIL.IL.ILInstr)) list + val decode_tab : (ReaderState -> AbstractIL.IL.ILInstr) [] + val p_ILInstr : x:AbstractIL.IL.ILInstr -> st:WriterState -> unit + val u_ILInstr : st:ReaderState -> AbstractIL.IL.ILInstr + val p_Map_core : + pk:('a -> 'b -> unit) -> + pv:('c -> 'b -> unit) -> xs:Map<'a,'c> -> st:'b -> unit + when 'a : comparison + val p_Map : + pk:('a -> WriterState -> unit) -> + pv:('b -> WriterState -> unit) -> x:Map<'a,'b> -> st:WriterState -> unit + when 'a : comparison + val p_qlist : + pv:('a -> WriterState -> unit) -> Internal.Utilities.QueueList<'a> pickler + val p_namemap : + ('T -> WriterState -> unit) -> (Map -> WriterState -> unit) + val u_Map_core : + uk:('a -> 'b) -> uv:('a -> 'c) -> n:int -> st:'a -> Map<'b,'c> + when 'b : comparison + val u_Map : + uk:(ReaderState -> 'a) -> + uv:(ReaderState -> 'b) -> st:ReaderState -> Map<'a,'b> + when 'a : comparison + val u_qlist : + uv:(ReaderState -> 'a) -> unpickler> + val u_namemap : (ReaderState -> 'T) -> (ReaderState -> Map) + val p_pos : x:Range.pos -> st:WriterState -> unit + val p_range : x:Range.range -> st:WriterState -> unit + val p_dummy_range : _x:Range.range -> _st:WriterState -> unit + val p_ident : x:SyntaxTree.Ident -> st:WriterState -> unit + val p_xmldoc : doc:XmlDoc.XmlDoc -> st:WriterState -> unit + val u_pos : st:ReaderState -> Range.pos + val u_range : st:ReaderState -> Range.range + val u_dummy_range : _st:ReaderState -> Range.range + val u_ident : st:ReaderState -> SyntaxTree.Ident + val u_xmldoc : st:ReaderState -> XmlDoc.XmlDoc + val p_local_item_ref : + ctxt:string -> tab:NodeOutTable<'a,'b> -> st:'b -> (WriterState -> unit) + val p_tcref : string -> (TypedTree.EntityRef -> WriterState -> unit) + val p_ucref : (TypedTree.UnionCaseRef -> WriterState -> unit) + val p_rfref : TypedTree.RecdFieldRef -> st:WriterState -> unit + val p_tpref : x:TypedTree.Typar -> st:WriterState -> unit + val u_local_item_ref : tab:NodeInTable<'a,'b> -> st:ReaderState -> 'b + val u_tcref : (ReaderState -> TypedTree.EntityRef) + val u_ucref : (ReaderState -> TypedTree.UnionCaseRef) + val u_rfref : st:ReaderState -> TypedTree.RecdFieldRef + val u_tpref : st:ReaderState -> TypedTree.Typar + val p_ty2 : (bool -> TypedTree.TType -> WriterState -> unit) + val fill_p_ty2 : ((bool -> TypedTree.TType -> WriterState -> unit) -> unit) + val p_ty : (TypedTree.TType -> WriterState -> unit) + val p_tys : (TypedTree.TType list -> WriterState -> unit) + val p_attribs : (TypedTree.Attribs -> WriterState -> unit) + val fill_p_attribs : ((TypedTree.Attribs -> WriterState -> unit) -> unit) + val checkForInRefStructThisArg : + st:WriterState -> ty:TypedTree.TType -> bool + val p_nonlocal_val_ref : + nlv:TypedTree.NonLocalValOrMemberRef -> st:WriterState -> unit + val p_vref : string -> (TypedTree.ValRef -> WriterState -> unit) + val p_vrefs : ctxt:string -> (TypedTree.ValRef list -> WriterState -> unit) + val u_ty : (ReaderState -> TypedTree.TType) + val fill_u_ty : ((ReaderState -> TypedTree.TType) -> unit) + val u_tys : (ReaderState -> TypedTree.TType list) + val u_attribs : (ReaderState -> TypedTree.Attrib list) + val fill_u_attribs : ((ReaderState -> TypedTree.Attrib list) -> unit) + val u_nonlocal_val_ref : st:ReaderState -> TypedTree.NonLocalValOrMemberRef + val u_vref : (ReaderState -> TypedTree.ValRef) + val u_vrefs : (ReaderState -> TypedTree.ValRef list) + val p_kind : x:TypedTree.TyparKind -> st:WriterState -> unit + val p_member_kind : x:SyntaxTree.MemberKind -> st:WriterState -> unit + val u_kind : st:ReaderState -> TypedTree.TyparKind + val u_member_kind : st:ReaderState -> SyntaxTree.MemberKind + val p_MemberFlags : x:SyntaxTree.MemberFlags -> st:WriterState -> unit + val u_MemberFlags : st:ReaderState -> SyntaxTree.MemberFlags + val u_expr_fwd : (ReaderState -> TypedTree.Expr) + val fill_u_Expr_hole : ((ReaderState -> TypedTree.Expr) -> unit) + val p_expr_fwd : (TypedTree.Expr -> WriterState -> unit) + val fill_p_Expr_hole : ((TypedTree.Expr -> WriterState -> unit) -> unit) + val p_anonInfo_data : + anonInfo:TypedTree.AnonRecdTypeInfo -> st:WriterState -> unit + val p_anonInfo : x:TypedTree.AnonRecdTypeInfo -> st:WriterState -> unit + val p_trait_sln : sln:TypedTree.TraitConstraintSln -> st:WriterState -> unit + val p_trait : TypedTree.TraitConstraintInfo -> st:WriterState -> unit + val u_anonInfo_data : st:ReaderState -> TypedTree.AnonRecdTypeInfo + val u_anonInfo : st:ReaderState -> TypedTree.AnonRecdTypeInfo + val u_trait_sln : st:ReaderState -> TypedTree.TraitConstraintSln + val u_trait : st:ReaderState -> TypedTree.TraitConstraintInfo + val p_rational : q:Rational.Rational -> st:WriterState -> unit + val p_measure_con : tcref:TypedTree.EntityRef -> st:WriterState -> unit + val p_measure_var : v:TypedTree.Typar -> st:WriterState -> unit + val p_measure_one : (WriterState -> unit) + val p_measure_varcon : unt:TypedTree.Measure -> st:WriterState -> unit + val p_measure_pospower : + unt:TypedTree.Measure -> n:int -> st:WriterState -> unit + val p_measure_intpower : + unt:TypedTree.Measure -> n:int -> st:WriterState -> unit + val p_measure_power : + unt:TypedTree.Measure -> q:Rational.Rational -> st:WriterState -> unit + val p_normalized_measure : unt:TypedTree.Measure -> st:WriterState -> unit + val p_measure_expr : unt:TypedTree.Measure -> st:WriterState -> unit + val u_rational : st:ReaderState -> Rational.Rational + val u_measure_expr : st:ReaderState -> TypedTree.Measure + val p_tyar_constraint : + x:TypedTree.TyparConstraint -> st:WriterState -> unit + val p_tyar_constraints : + (TypedTree.TyparConstraint list -> WriterState -> unit) + val u_tyar_constraint : st:ReaderState -> (int -> TypedTree.TyparConstraint) + val u_tyar_constraints : (ReaderState -> TypedTree.TyparConstraint list) + val p_tyar_spec_data : x:TypedTree.Typar -> st:WriterState -> unit + val p_tyar_spec : x:TypedTree.Typar -> st:WriterState -> unit + val p_tyar_specs : (TypedTree.Typar list -> WriterState -> unit) + val u_tyar_spec_data : st:ReaderState -> TypedTree.Typar + val u_tyar_spec : st:ReaderState -> TypedTree.Typar + val u_tyar_specs : (ReaderState -> TypedTree.Typar list) + val p_binds : (TypedTree.Bindings -> WriterState -> unit) + val fill_p_binds : ((TypedTree.Bindings -> WriterState -> unit) -> unit) + val p_targets : (TypedTree.DecisionTreeTarget array -> WriterState -> unit) + val fill_p_targets : + ((TypedTree.DecisionTreeTarget array -> WriterState -> unit) -> unit) + val p_Exprs : (TypedTree.Exprs -> WriterState -> unit) + val fill_p_Exprs : ((TypedTree.Exprs -> WriterState -> unit) -> unit) + val p_constraints : + (TypedTree.StaticOptimization list -> WriterState -> unit) + val fill_p_constraints : + ((TypedTree.StaticOptimization list -> WriterState -> unit) -> unit) + val p_Vals : (TypedTree.Val list -> WriterState -> unit) + val fill_p_Vals : ((TypedTree.Val list -> WriterState -> unit) -> unit) + val u_binds : (ReaderState -> TypedTree.Bindings) + val fill_u_binds : ((ReaderState -> TypedTree.Bindings) -> unit) + val u_targets : (ReaderState -> TypedTree.DecisionTreeTarget array) + val fill_u_targets : + ((ReaderState -> TypedTree.DecisionTreeTarget array) -> unit) + val u_Exprs : (ReaderState -> TypedTree.Exprs) + val fill_u_Exprs : ((ReaderState -> TypedTree.Exprs) -> unit) + val u_constraints : (ReaderState -> TypedTree.StaticOptimization list) + val fill_u_constraints : + ((ReaderState -> TypedTree.StaticOptimization list) -> unit) + val u_Vals : (ReaderState -> TypedTree.Val list) + val fill_u_Vals : ((ReaderState -> TypedTree.Val list) -> unit) + val p_ArgReprInfo : x:TypedTree.ArgReprInfo -> st:WriterState -> unit + val p_TyparReprInfo : TypedTree.TyparReprInfo -> st:WriterState -> unit + val p_ValReprInfo : TypedTree.ValReprInfo -> st:WriterState -> unit + val u_ArgReprInfo : st:ReaderState -> TypedTree.ArgReprInfo + val u_TyparReprInfo : st:ReaderState -> TypedTree.TyparReprInfo + val u_ValReprInfo : st:ReaderState -> TypedTree.ValReprInfo + val p_ranges : + x:(Range.range * Range.range) option -> st:WriterState -> unit + val p_istype : x:TypedTree.ModuleOrNamespaceKind -> st:WriterState -> unit + val p_cpath : TypedTree.CompilationPath -> st:WriterState -> unit + val u_ranges : st:ReaderState -> (Range.range * Range.range) option + val u_istype : st:ReaderState -> TypedTree.ModuleOrNamespaceKind + val u_cpath : st:ReaderState -> TypedTree.CompilationPath + val dummy : x:'a -> 'a + val p_tycon_repr : x:TypedTree.TyconRepresentation -> st:WriterState -> bool + val p_tycon_objmodel_data : + x:TypedTree.TyconObjModelData -> st:WriterState -> unit + val p_attribs_ext : + f:(WriterState -> unit) option -> + x:TypedTree.Attrib list -> st:WriterState -> unit + val p_unioncase_spec : x:TypedTree.UnionCase -> st:WriterState -> unit + val p_exnc_spec_data : x:TypedTree.Entity -> st:WriterState -> unit + val p_exnc_repr : x:TypedTree.ExceptionInfo -> st:WriterState -> unit + val p_exnc_spec : x:TypedTree.Entity -> st:WriterState -> unit + val p_access : TypedTree.Accessibility -> st:WriterState -> unit + val p_recdfield_spec : x:TypedTree.RecdField -> st:WriterState -> unit + val p_rfield_table : x:TypedTree.TyconRecdFields -> st:WriterState -> unit + val p_entity_spec_data : x:TypedTree.Entity -> st:WriterState -> unit + val p_tcaug : p:TypedTree.TyconAugmentation -> st:WriterState -> unit + val p_entity_spec : x:TypedTree.Entity -> st:WriterState -> unit + val p_parentref : x:TypedTree.ParentRef -> st:WriterState -> unit + val p_attribkind : x:TypedTree.AttribKind -> st:WriterState -> unit + val p_attrib : TypedTree.Attrib -> st:WriterState -> unit + val p_attrib_expr : TypedTree.AttribExpr -> st:WriterState -> unit + val p_attrib_arg : TypedTree.AttribNamedArg -> st:WriterState -> unit + val p_member_info : x:TypedTree.ValMemberInfo -> st:WriterState -> unit + val p_tycon_objmodel_kind : + x:TypedTree.TyconObjModelKind -> st:WriterState -> unit + val p_mustinline : x:TypedTree.ValInline -> st:WriterState -> unit + val p_basethis : x:TypedTree.ValBaseOrThisInfo -> st:WriterState -> unit + val p_vrefFlags : x:TypedTree.ValUseFlag -> st:WriterState -> unit + val p_ValData : x:TypedTree.Val -> st:WriterState -> unit + val p_Val : x:TypedTree.Val -> st:WriterState -> unit + val p_modul_typ : + x:TypedTree.ModuleOrNamespaceType -> st:WriterState -> unit + val u_tycon_repr : st:ReaderState -> (bool -> TypedTree.TyconRepresentation) + val u_tycon_objmodel_data : st:ReaderState -> TypedTree.TyconObjModelData + val u_attribs_ext : + extraf:(ReaderState -> 'a) -> + st:ReaderState -> 'a option * TypedTree.Attrib list + val u_unioncase_spec : st:ReaderState -> TypedTree.UnionCase + val u_exnc_spec_data : st:ReaderState -> TypedTree.Entity + val u_exnc_repr : st:ReaderState -> TypedTree.ExceptionInfo + val u_exnc_spec : st:ReaderState -> TypedTree.Tycon + val u_access : st:ReaderState -> TypedTree.Accessibility + val u_recdfield_spec : st:ReaderState -> TypedTree.RecdField + val u_rfield_table : st:ReaderState -> TypedTree.TyconRecdFields + val u_entity_spec_data : st:ReaderState -> TypedTree.Entity + val u_tcaug : st:ReaderState -> TypedTree.TyconAugmentation + val u_entity_spec : st:ReaderState -> TypedTree.Tycon + val u_parentref : st:ReaderState -> TypedTree.ParentRef + val u_attribkind : st:ReaderState -> TypedTree.AttribKind + val u_attrib : st:ReaderState -> TypedTree.Attrib + val u_attrib_expr : st:ReaderState -> TypedTree.AttribExpr + val u_attrib_arg : st:ReaderState -> TypedTree.AttribNamedArg + val u_member_info : st:ReaderState -> TypedTree.ValMemberInfo + val u_tycon_objmodel_kind : st:ReaderState -> TypedTree.TyconObjModelKind + val u_mustinline : st:ReaderState -> TypedTree.ValInline + val u_basethis : st:ReaderState -> TypedTree.ValBaseOrThisInfo + val u_vrefFlags : st:ReaderState -> TypedTree.ValUseFlag + val u_ValData : st:ReaderState -> TypedTree.Val + val u_Val : st:ReaderState -> TypedTree.Val + val u_modul_typ : st:ReaderState -> TypedTree.ModuleOrNamespaceType + val p_const : (TypedTree.Const -> WriterState -> unit) + val u_const : (ReaderState -> TypedTree.Const) + val p_dtree : x:TypedTree.DecisionTree -> st:WriterState -> unit + val p_dtree_case : TypedTree.DecisionTreeCase -> st:WriterState -> unit + val p_dtree_discrim : x:TypedTree.DecisionTreeTest -> st:WriterState -> unit + val p_target : TypedTree.DecisionTreeTarget -> st:WriterState -> unit + val p_bind : TypedTree.Binding -> st:WriterState -> unit + val p_lval_op_kind : x:TypedTree.LValueOperation -> st:WriterState -> unit + val p_recdInfo : + x:TypedTree.RecordConstructionInfo -> st:WriterState -> unit + val u_dtree : st:ReaderState -> TypedTree.DecisionTree + val u_dtree_case : st:ReaderState -> TypedTree.DecisionTreeCase + val u_dtree_discrim : st:ReaderState -> TypedTree.DecisionTreeTest + val u_target : st:ReaderState -> TypedTree.DecisionTreeTarget + val u_bind : st:ReaderState -> TypedTree.Binding + val u_lval_op_kind : st:ReaderState -> TypedTree.LValueOperation + val p_op : x:TypedTree.TOp -> st:WriterState -> unit + val u_op : st:ReaderState -> TypedTree.TOp + val p_expr : (TypedTree.Expr -> WriterState -> unit) + val u_expr : (ReaderState -> TypedTree.Expr) + val p_static_optimization_constraint : + x:TypedTree.StaticOptimization -> st:WriterState -> unit + val p_slotparam : TypedTree.SlotParam -> st:WriterState -> unit + val p_slotsig : TypedTree.SlotSig -> st:WriterState -> unit + val p_method : TypedTree.ObjExprMethod -> st:WriterState -> unit + val p_methods : x:TypedTree.ObjExprMethod list -> st:WriterState -> unit + val p_intf : + TypedTree.TType * TypedTree.ObjExprMethod list -> st:WriterState -> unit + val p_intfs : + x:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> + st:WriterState -> unit + val u_static_optimization_constraint : + st:ReaderState -> TypedTree.StaticOptimization + val u_slotparam : st:ReaderState -> TypedTree.SlotParam + val u_slotsig : st:ReaderState -> TypedTree.SlotSig + val u_method : st:ReaderState -> TypedTree.ObjExprMethod + val u_methods : st:ReaderState -> TypedTree.ObjExprMethod list + val u_intf : + st:ReaderState -> TypedTree.TType * TypedTree.ObjExprMethod list + val u_intfs : + st:ReaderState -> (TypedTree.TType * TypedTree.ObjExprMethod list) list + val pickleModuleOrNamespace : + mspec:TypedTree.Entity -> st:WriterState -> unit + val pickleCcuInfo : (TypedTree.PickledCcuInfo -> WriterState -> unit) + val unpickleModuleOrNamespace : st:ReaderState -> TypedTree.Tycon + val unpickleCcuInfo : ReaderState -> TypedTree.PickledCcuInfo + end + +namespace FSharp.Compiler + module internal Import = begin + type AssemblyLoader = + interface + abstract member + FindCcuFromAssemblyRef : AbstractIL.Internal.Library.CompilationThreadToken * + Range.range * AbstractIL.IL.ILAssemblyRef -> + TypedTree.CcuResolutionResult + abstract member + GetProvidedAssemblyInfo : AbstractIL.Internal.Library.CompilationThreadToken * + Range.range * + Tainted -> + bool * + ExtensionTyping.ProvidedAssemblyStaticLinkingMap option + abstract member + RecordGeneratedTypeRoot : ExtensionTyping.ProviderGeneratedType -> + unit + end + [] + type ImportMap = + class + new : g:TcGlobals.TcGlobals * assemblyLoader:AssemblyLoader -> ImportMap + member + ILTypeRefToTyconRefCache : System.Collections.Concurrent.ConcurrentDictionary + member assemblyLoader : AssemblyLoader + member g : TcGlobals.TcGlobals + end + val CanImportILScopeRef : + env:ImportMap -> m:Range.range -> scoref:AbstractIL.IL.ILScopeRef -> bool + val ImportTypeRefData : + env:ImportMap -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef * path:string [] * + typeName:System.String -> TypedTree.EntityRef + val ImportILTypeRefUncached : + env:ImportMap -> + m:Range.range -> tref:AbstractIL.IL.ILTypeRef -> TypedTree.EntityRef + val ImportILTypeRef : + ImportMap -> Range.range -> AbstractIL.IL.ILTypeRef -> TypedTree.TyconRef + val CanImportILTypeRef : + ImportMap -> Range.range -> AbstractIL.IL.ILTypeRef -> bool + val ImportTyconRefApp : + env:ImportMap -> + tcref:TypedTree.EntityRef -> + tyargs:TypedTree.TType list -> TypedTree.TType + val ImportILType : + ImportMap -> + Range.range -> + TypedTree.TType list -> AbstractIL.IL.ILType -> TypedTree.TType + val CanImportILType : + ImportMap -> Range.range -> AbstractIL.IL.ILType -> bool + val ImportProvidedNamedType : + ImportMap -> + Range.range -> + Tainted -> TypedTree.TyconRef + val ImportProvidedTypeAsILType : + ImportMap -> + Range.range -> + Tainted -> AbstractIL.IL.ILType + val ImportProvidedType : + ImportMap -> + Range.range -> Tainted -> TypedTree.TType + val ImportProvidedMethodBaseAsILMethodRef : + ImportMap -> + Range.range -> + Tainted -> + AbstractIL.IL.ILMethodRef + val ImportILGenericParameters : + (unit -> ImportMap) -> + Range.range -> + AbstractIL.IL.ILScopeRef -> + TypedTree.TType list -> + AbstractIL.IL.ILGenericParameterDefs -> TypedTree.Typar list + val multisetDiscriminateAndMap : + nodef:('Key -> ('Key list * 'Value) list -> 'a) -> + tipf:('Value -> 'a) -> items:('Key list * 'Value) list -> 'a list + when 'Key : equality + val ImportILTypeDef : + amap:(unit -> ImportMap) -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef -> + cpath:TypedTree.CompilationPath -> + enc:AbstractIL.IL.ILTypeDef list -> + nm:string -> tdef:AbstractIL.IL.ILTypeDef -> TypedTree.Entity + val ImportILTypeDefList : + amap:(unit -> ImportMap) -> + m:Range.range -> + cpath:TypedTree.CompilationPath -> + enc:AbstractIL.IL.ILTypeDef list -> + items:(string list * + (string * + Lazy)) list -> + TypedTree.ModuleOrNamespaceType + val ImportILTypeDefs : + amap:(unit -> ImportMap) -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef -> + cpath:TypedTree.CompilationPath -> + enc:AbstractIL.IL.ILTypeDef list -> + tdefs:AbstractIL.IL.ILTypeDefs -> + TypedTree.ModuleOrNamespaceType + val ImportILAssemblyMainTypeDefs : + amap:(unit -> ImportMap) -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef -> + modul:AbstractIL.IL.ILModuleDef -> TypedTree.ModuleOrNamespaceType + val ImportILAssemblyExportedType : + amap:(unit -> ImportMap) -> + m:Range.range -> + auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) -> + scoref:AbstractIL.IL.ILScopeRef -> + exportedType:AbstractIL.IL.ILExportedTypeOrForwarder -> + TypedTree.ModuleOrNamespaceType list + val ImportILAssemblyExportedTypes : + amap:(unit -> ImportMap) -> + m:Range.range -> + auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) -> + scoref:AbstractIL.IL.ILScopeRef -> + exportedTypes:AbstractIL.IL.ILExportedTypesAndForwarders -> + TypedTree.ModuleOrNamespaceType list + val ImportILAssemblyTypeDefs : + amap:(unit -> ImportMap) * m:Range.range * + auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) * + aref:AbstractIL.IL.ILAssemblyRef * mainmod:AbstractIL.IL.ILModuleDef -> + TypedTree.ModuleOrNamespaceType + val ImportILAssemblyTypeForwarders : + (unit -> ImportMap) * Range.range * + AbstractIL.IL.ILExportedTypesAndForwarders -> + Map<(string [] * string),Lazy> + val ImportILAssembly : + (unit -> ImportMap) * Range.range * + (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) * + AbstractIL.IL.ILScopeRef * sourceDir:string * filename:string option * + AbstractIL.IL.ILModuleDef * IEvent -> TypedTree.CcuThunk + end + +namespace FSharp.Compiler + module internal Infos = begin + val ImportILType : + scoref:AbstractIL.IL.ILScopeRef -> + amap:Import.ImportMap -> + m:Range.range -> + importInst:TypedTree.TType list -> + ilty:AbstractIL.IL.ILType -> TypedTree.TType + val CanImportILType : + scoref:AbstractIL.IL.ILScopeRef -> + amap:Import.ImportMap -> + m:Range.range -> ilty:AbstractIL.IL.ILType -> bool + val isExnDeclTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val GetSuperTypeOfType : + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ty:TypedTree.TType -> TypedTree.TType option + val mkSystemCollectionsGenericIListTy : + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + [] + type SkipUnrefInterfaces = + | Yes + | No + val GetImmediateInterfacesOfType : + skipUnref:SkipUnrefInterfaces -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ty:TypedTree.TType -> TypedTree.TType list + [] + type AllowMultiIntfInstantiations = + | Yes + | No + val private FoldHierarchyOfTypeAux : + followInterfaces:bool -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + skipUnref:SkipUnrefInterfaces -> + visitor:(TypedTree.TType -> 'a -> 'a) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ty:TypedTree.TType -> acc:'a -> 'a + val FoldPrimaryHierarchyOfType : + f:(TypedTree.TType -> 'a -> 'a) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> acc:'a -> 'a + val FoldEntireHierarchyOfType : + f:(TypedTree.TType -> 'a -> 'a) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> acc:'a -> 'a + val IterateEntireHierarchyOfType : + f:(TypedTree.TType -> unit) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> unit + val ExistsInEntireHierarchyOfType : + f:(TypedTree.TType -> bool) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> bool + val SearchEntireHierarchyOfType : + f:(TypedTree.TType -> bool) -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> ty:TypedTree.TType -> TypedTree.TType option + val AllSuperTypesOfType : + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> TypedTree.TType list + val AllInterfacesOfType : + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + allowMultiIntfInst:AllowMultiIntfInstantiations -> + ty:TypedTree.TType -> TypedTree.TType list + val HaveSameHeadType : + g:TcGlobals.TcGlobals -> + ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool + val HasHeadType : + g:TcGlobals.TcGlobals -> + tcref:TypedTree.TyconRef -> ty2:TypedTree.TType -> bool + val ExistsSameHeadTypeInHierarchy : + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + typeToSearchFrom:TypedTree.TType -> + typeToLookFor:TypedTree.TType -> bool + val ExistsHeadTypeInEntireHierarchy : + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + typeToSearchFrom:TypedTree.TType -> + tcrefToLookFor:TypedTree.TyconRef -> bool + val ImportILTypeFromMetadata : + amap:Import.ImportMap -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef -> + tinst:TypedTree.TType list -> + minst:TypedTree.TType list -> + ilty:AbstractIL.IL.ILType -> TypedTree.TType + val ImportILTypeFromMetadataWithAttributes : + amap:Import.ImportMap -> + m:Range.range -> + scoref:AbstractIL.IL.ILScopeRef -> + tinst:TypedTree.TType list -> + minst:TypedTree.TType list -> + ilty:AbstractIL.IL.ILType -> + cattrs:AbstractIL.IL.ILAttributes -> TypedTree.TType + val ImportParameterTypeFromMetadata : + amap:Import.ImportMap -> + m:Range.range -> + ilty:AbstractIL.IL.ILType -> + cattrs:AbstractIL.IL.ILAttributes -> + scoref:AbstractIL.IL.ILScopeRef -> + tinst:TypedTree.TType list -> + mist:TypedTree.TType list -> TypedTree.TType + val ImportReturnTypeFromMetadata : + amap:Import.ImportMap -> + m:Range.range -> + ilty:AbstractIL.IL.ILType -> + cattrs:AbstractIL.IL.ILAttributes -> + scoref:AbstractIL.IL.ILScopeRef -> + tinst:TypedTree.TType list -> + minst:TypedTree.TType list -> TypedTree.TType option + val CopyTyparConstraints : + m:Range.range -> + tprefInst:TypedTreeOps.TyparInst -> + tporig:TypedTree.Typar -> TypedTree.TyparConstraint list + val FixupNewTypars : + m:Range.range -> + formalEnclosingTypars:TypedTree.Typars -> + tinst:TypedTree.TType list -> + tpsorig:TypedTree.Typars -> + tps:TypedTree.Typars -> TypedTreeOps.TyparInst * TypedTree.TTypes + type ValRef with + member IsFSharpEventProperty : g:TcGlobals.TcGlobals -> bool + type ValRef with + member IsVirtualMember : bool + type ValRef with + member IsDispatchSlotMember : bool + type ValRef with + member IsDefiniteFSharpOverrideMember : bool + type ValRef with + member + IsFSharpExplicitInterfaceImplementation : g:TcGlobals.TcGlobals -> bool + type ValRef with + member ImplementedSlotSignatures : TypedTree.SlotSig list + val GetCompiledReturnTyOfProvidedMethodInfo : + amap:Import.ImportMap -> + m:Range.range -> + mi:Tainted -> + TypedTree.TType option + val ReparentSlotSigToUseMethodTypars : + g:TcGlobals.TcGlobals -> + m:Range.range -> + ovByMethValRef:TypedTree.ValRef -> + slotsig:TypedTree.SlotSig -> TypedTree.SlotSig + val MakeSlotParam : + ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo -> TypedTree.SlotParam + val MakeSlotSig : + nm:string * ty:TypedTree.TType * ctps:TypedTree.Typars * + mtps:TypedTree.Typars * paraml:TypedTree.SlotParam list list * + retTy:TypedTree.TType option -> TypedTree.SlotSig + val private AnalyzeTypeOfMemberVal : + isCSharpExt:bool -> + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType * vref:TypedTree.ValRef -> + TypedTree.Typar list * TypedTree.Typars * TypedTree.TType option * + TypedTree.TType list + val private GetObjTypeOfInstanceExtensionMethod : + g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> TypedTree.TType + val private GetArgInfosOfMember : + isCSharpExt:bool -> + g:TcGlobals.TcGlobals -> + vref:TypedTree.ValRef -> + (TypedTree.TType * TypedTree.ArgReprInfo) list list + val private CombineMethInsts : + ttps:TypedTree.Typars -> + mtps:TypedTree.Typars -> + tinst:TypedTree.TTypes -> + minst:TypedTree.TTypes -> (TypedTree.Typar * TypedTree.TType) list + val private GetInstantiationForMemberVal : + g:TcGlobals.TcGlobals -> + isCSharpExt:bool -> + ty:TypedTree.TType * vref:TypedTree.ValRef * + methTyArgs:TypedTree.TypeInst -> + (TypedTree.Typar * TypedTree.TType) list + val private GetInstantiationForPropertyVal : + g:TcGlobals.TcGlobals -> + ty:TypedTree.TType * vref:TypedTree.ValRef -> + (TypedTree.Typar * TypedTree.TType) list + type ExtensionMethodPriority = uint64 + type OptionalArgCallerSideValue = + | Constant of AbstractIL.IL.ILFieldInit + | DefaultValue + | MissingValue + | WrapperForIDispatch + | WrapperForIUnknown + | PassByRef of TypedTree.TType * OptionalArgCallerSideValue + type OptionalArgInfo = + | NotOptional + | CalleeSide + | CallerSide of OptionalArgCallerSideValue + with + static member + FieldInitForDefaultParameterValueAttrib : attrib:TypedTree.Attrib -> + AbstractIL.IL.ILFieldInit option + static member + FromILParameter : g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> + ilScope:AbstractIL.IL.ILScopeRef -> + ilTypeInst:TypedTree.TType list -> + ilParam:AbstractIL.IL.ILParameter -> + OptionalArgInfo + static member + ValueOfDefaultParameterValueAttrib : TypedTree.Attrib -> + TypedTree.Expr option + member IsOptional : bool + end + type CallerInfo = + | NoCallerInfo + | CallerLineNumber + | CallerMemberName + | CallerFilePath + with + override ToString : unit -> string + end + [] + type ReflectedArgInfo = + | None + | Quote of bool + with + member AutoQuote : bool + end + [] + type ParamNameAndType = + | ParamNameAndType of SyntaxTree.Ident option * TypedTree.TType + with + static member + FromArgInfo : ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo -> + ParamNameAndType + static member + FromMember : isCSharpExtMem:bool -> + g:TcGlobals.TcGlobals -> + vref:TypedTree.ValRef -> ParamNameAndType list list + static member + Instantiate : inst:TypedTreeOps.TyparInst -> + p:ParamNameAndType -> ParamNameAndType + static member + InstantiateCurried : inst:TypedTreeOps.TyparInst -> + paramTypes:ParamNameAndType list list -> + ParamNameAndType list list + end + [] + type ParamData = + | ParamData of + isParamArray: bool * isInArg: bool * isOut: bool * + optArgInfo: OptionalArgInfo * callerInfo: CallerInfo * + nameOpt: SyntaxTree.Ident option * reflArgInfo: ReflectedArgInfo * + ttype: TypedTree.TType + type ILFieldInit with + static member + FromProvidedObj : m:Range.range -> v:obj -> AbstractIL.IL.ILFieldInit + val OptionalArgInfoOfProvidedParameter : + amap:Import.ImportMap -> + m:Range.range -> + provParam:Tainted -> + OptionalArgInfo + val GetAndSanityCheckProviderMethod : + m:Range.range -> + mi:Tainted<'T> -> + get:('T -> ExtensionTyping.ProvidedMethodInfo) -> + err:(string * string -> int * string) -> + Tainted + when 'T :> ExtensionTyping.ProvidedMemberInfo + val ArbitraryMethodInfoOfPropertyInfo : + pi:Tainted -> + m:Range.range -> Tainted + [] + type ILTypeInfo = + | ILTypeInfo of + TcGlobals.TcGlobals * TypedTree.TType * AbstractIL.IL.ILTypeRef * + AbstractIL.IL.ILTypeDef + with + static member + FromType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> ILTypeInfo + member Instantiate : inst:TypedTreeOps.TyparInst -> ILTypeInfo + member ILScopeRef : AbstractIL.IL.ILScopeRef + member ILTypeRef : AbstractIL.IL.ILTypeRef + member IsValueType : bool + member Name : string + member RawMetadata : AbstractIL.IL.ILTypeDef + member TcGlobals : TcGlobals.TcGlobals + member ToAppType : TypedTree.TType + member ToType : TypedTree.TType + member TyconRefOfRawMetadata : TypedTree.TyconRef + member TypeInstOfRawMetadata : TypedTree.TypeInst + end + [] + type ILMethInfo = + | ILMethInfo of + g: TcGlobals.TcGlobals * ilApparentType: TypedTree.TType * + ilDeclaringTyconRefOpt: TypedTree.TyconRef option * + ilMethodDef: AbstractIL.IL.ILMethodDef * + ilGenericMethodTyArgs: TypedTree.Typars + with + member + GetCompiledReturnTy : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> + TypedTree.TType option + member + GetFSharpReturnTy : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> TypedTree.TType + member + GetObjArgTypes : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> TypedTree.TType list + member + GetParamNamesAndTypes : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> + ParamNameAndType list + member + GetParamTypes : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> TypedTree.TType list + member + GetRawArgTypes : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> TypedTree.TType list + member IsDllImport : g:TcGlobals.TcGlobals -> bool + member IsReadOnly : g:TcGlobals.TcGlobals -> bool + member ApparentEnclosingAppType : TypedTree.TType + member ApparentEnclosingType : TypedTree.TType + member DeclaringTyconRef : TypedTree.TyconRef + member DeclaringTypeInst : TypedTree.TType list + member FormalMethodTypars : TypedTree.Typars + member ILExtensionMethodDeclaringTyconRef : TypedTree.TyconRef option + member ILMethodRef : AbstractIL.IL.ILMethodRef + member ILName : string + member IsAbstract : bool + member IsClassConstructor : bool + member IsConstructor : bool + member IsFinal : bool + member IsILExtensionMethod : bool + member IsInstance : bool + member IsNewSlot : bool + member IsProtectedAccessibility : bool + member IsStatic : bool + member IsVirtual : bool + member MetadataScope : AbstractIL.IL.ILScopeRef + member NumParams : int + member ParamMetadata : AbstractIL.IL.ILParameter list + member RawMetadata : AbstractIL.IL.ILMethodDef + member TcGlobals : TcGlobals.TcGlobals + end + [] + type MethInfo = + | FSMeth of + tcGlobals: TcGlobals.TcGlobals * enclosingType: TypedTree.TType * + valRef: TypedTree.ValRef * + extensionMethodPriority: ExtensionMethodPriority option + | ILMeth of + tcGlobals: TcGlobals.TcGlobals * ilMethInfo: ILMethInfo * + extensionMethodPriority: ExtensionMethodPriority option + | DefaultStructCtor of + tcGlobals: TcGlobals.TcGlobals * structTy: TypedTree.TType + | ProvidedMeth of + amap: Import.ImportMap * + methodBase: Tainted * + extensionMethodPriority: ExtensionMethodPriority option * m: Range.range + with + static member + CreateILExtensionMeth : amap:Import.ImportMap * m:Range.range * + apparentTy:TypedTree.TType * + declaringTyconRef:TypedTree.TyconRef * + extMethPri:ExtensionMethodPriority option * + md:AbstractIL.IL.ILMethodDef -> MethInfo + static member + CreateILMeth : amap:Import.ImportMap * m:Range.range * + ty:TypedTree.TType * md:AbstractIL.IL.ILMethodDef -> + MethInfo + static member + MethInfosUseIdenticalDefinitions : x1:MethInfo -> x2:MethInfo -> bool + member + AdjustUserTypeInstForFSharpStyleIndexedExtensionMembers : tyargs:TypedTree.TType list -> + TypedTree.TType list + member ComputeHashCode : unit -> int + member + GetCompiledReturnTy : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> + TypedTree.TType option + member + GetFSharpReturnTy : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> TypedTree.TType + member + GetFormalTyparsOfDeclaringType : m:Range.range -> TypedTree.Typar list + member + GetObjArgTypes : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TypeInst -> TypedTree.TType list + member + GetParamAttribs : amap:Import.ImportMap * m:Range.range -> + (bool * bool * bool * OptionalArgInfo * CallerInfo * + ReflectedArgInfo) list list + member + GetParamDatas : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> ParamData list list + member + GetParamTypes : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> + TypedTree.TType list list + member + GetSlotSig : amap:Import.ImportMap * m:Range.range -> + TypedTree.SlotSig + member + HasParamArrayArg : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TType list -> bool + member + Instantiate : amap:Import.ImportMap * m:Range.range * + inst:TypedTreeOps.TyparInst -> MethInfo + member + IsReadOnlyExtensionMember : amap:Import.ImportMap * m:Range.range -> + bool + member + ObjArgNeedsAddress : amap:Import.ImportMap * m:Range.range -> bool + override ToString : unit -> string + member + TryObjArgByrefType : amap:Import.ImportMap * m:Range.range * + minst:TypedTree.TypeInst -> + TypedTree.TType option + member ApparentEnclosingAppType : TypedTree.TType + member ApparentEnclosingTyconRef : TypedTree.TyconRef + member ApparentEnclosingType : TypedTree.TType + member ArbitraryValRef : TypedTree.ValRef option + member DebuggerDisplayName : string + member DeclaringTyconRef : TypedTree.TyconRef + member DeclaringTypeInst : TypedTree.TType list + member DisplayName : string + member ExtensionMemberPriority : ExtensionMethodPriority + member ExtensionMemberPriorityOption : ExtensionMethodPriority option + member FormalMethodInst : TypedTree.TypeInst + member FormalMethodTyparInst : TypedTreeOps.TyparInst + member FormalMethodTypars : TypedTree.Typars + member GenericArity : int + member HasDirectXmlComment : bool + member ImplementedSlotSignatures : TypedTree.SlotSig list + member IsAbstract : bool + member IsCSharpStyleExtensionMember : bool + member IsClassConstructor : bool + member IsConstructor : bool + member IsCurried : bool + member IsDefiniteFSharpOverride : bool + member IsDispatchSlot : bool + member IsExtensionMember : bool + member IsFSharpEventPropertyMethod : bool + member IsFSharpExplicitInterfaceImplementation : bool + member IsFSharpStyleExtensionMember : bool + member IsFinal : bool + member IsILMethod : bool + member IsInstance : bool + member IsNewSlot : bool + member IsNullary : bool + member IsProtectedAccessibility : bool + member IsReadOnly : bool + member IsStruct : bool + member IsVirtual : bool + member LogicalName : string + member NumArgs : int list + member + ProvidedStaticParameterInfo : (Tainted * + Tainted []) option + member TcGlobals : TcGlobals.TcGlobals + member XmlDoc : XmlDoc.XmlDoc + end + [] + type ILFieldInfo = + | ILFieldInfo of + ilTypeInfo: ILTypeInfo * ilFieldDef: AbstractIL.IL.ILFieldDef + | ProvidedField of + amap: Import.ImportMap * + providedField: Tainted * + range: Range.range + with + static member + ILFieldInfosUseIdenticalDefinitions : x1:ILFieldInfo -> + x2:ILFieldInfo -> bool + member ComputeHashCode : unit -> int + member + FieldType : amap:Import.ImportMap * m:Range.range -> TypedTree.TType + override ToString : unit -> string + member ApparentEnclosingAppType : TypedTree.TType + member ApparentEnclosingTyconRef : TypedTree.TyconRef + member ApparentEnclosingType : TypedTree.TType + member DeclaringTyconRef : TypedTree.TyconRef + member FieldName : string + member ILFieldRef : AbstractIL.IL.ILFieldRef + member ILFieldType : AbstractIL.IL.ILType + member ILTypeRef : AbstractIL.IL.ILTypeRef + member IsInitOnly : bool + member IsSpecialName : bool + member IsStatic : bool + member IsValueType : bool + member LiteralValue : AbstractIL.IL.ILFieldInit option + member ScopeRef : AbstractIL.IL.ILScopeRef + member TcGlobals : TcGlobals.TcGlobals + member TypeInst : TypedTree.TypeInst + end + [] + type RecdFieldInfo = + | RecdFieldInfo of + typeInst: TypedTree.TypeInst * recdFieldRef: TypedTree.RecdFieldRef + with + override ToString : unit -> string + member DeclaringType : TypedTree.TType + member FieldType : TypedTree.TType + member IsStatic : bool + member LiteralValue : TypedTree.Const option + member Name : string + member RecdField : TypedTree.RecdField + member RecdFieldRef : TypedTree.RecdFieldRef + member Tycon : TypedTree.Entity + member TyconRef : TypedTree.TyconRef + member TypeInst : TypedTree.TypeInst + end + [] + type UnionCaseInfo = + | UnionCaseInfo of TypedTree.TypeInst * TypedTree.UnionCaseRef + with + member GetTyparInst : m:Range.range -> TypedTreeOps.TyparInst + override ToString : unit -> string + member Name : string + member Tycon : TypedTree.Entity + member TyconRef : TypedTree.TyconRef + member TypeInst : TypedTree.TypeInst + member UnionCase : TypedTree.UnionCase + member UnionCaseRef : TypedTree.UnionCaseRef + end + [] + type ILPropInfo = + | ILPropInfo of + ilTypeInfo: ILTypeInfo * ilPropertyDef: AbstractIL.IL.ILPropertyDef + with + member + GetParamNamesAndTypes : amap:Import.ImportMap * m:Range.range -> + ParamNameAndType list + member + GetParamTypes : amap:Import.ImportMap * m:Range.range -> + TypedTree.TType list + member + GetPropertyType : amap:Import.ImportMap * m:Range.range -> + TypedTree.TType + override ToString : unit -> string + member ApparentEnclosingAppType : TypedTree.TType + member ApparentEnclosingType : TypedTree.TType + member GetterMethod : ILMethInfo + member HasGetter : bool + member HasSetter : bool + member ILTypeInfo : ILTypeInfo + member IsNewSlot : bool + member IsStatic : bool + member IsVirtual : bool + member PropertyName : string + member RawMetadata : AbstractIL.IL.ILPropertyDef + member SetterMethod : ILMethInfo + member TcGlobals : TcGlobals.TcGlobals + end + [] + type PropInfo = + | FSProp of + tcGlobals: TcGlobals.TcGlobals * apparentEnclTy: TypedTree.TType * + getter: TypedTree.ValRef option * setter: TypedTree.ValRef option + | ILProp of ilPropInfo: ILPropInfo + | ProvidedProp of + amap: Import.ImportMap * + providedProp: Tainted * + range: Range.range + with + static member + PropInfosUseIdenticalDefinitions : x1:PropInfo -> x2:PropInfo -> bool + member ComputeHashCode : unit -> int + member DropGetter : unit -> PropInfo + member DropSetter : unit -> PropInfo + member + GetParamDatas : amap:Import.ImportMap * m:Range.range -> + ParamData list + member + GetParamNamesAndTypes : amap:Import.ImportMap * m:Range.range -> + ParamNameAndType list + member + GetParamTypes : amap:Import.ImportMap * m:Range.range -> + TypedTree.TType list + member + GetPropertyType : amap:Import.ImportMap * m:Range.range -> + TypedTree.TType + override ToString : unit -> string + member ApparentEnclosingAppType : TypedTree.TType + member ApparentEnclosingTyconRef : TypedTree.TyconRef + member ApparentEnclosingType : TypedTree.TType + member ArbitraryValRef : TypedTree.ValRef option + member DeclaringTyconRef : TypedTree.EntityRef + member GetterMethod : MethInfo + member HasDirectXmlComment : bool + member HasGetter : bool + member HasSetter : bool + member ImplementedSlotSignatures : TypedTree.SlotSig list + member IsDefiniteFSharpOverride : bool + member IsDispatchSlot : bool + member IsExtensionMember : bool + member IsFSharpEventProperty : bool + member IsFSharpExplicitInterfaceImplementation : bool + member IsIndexer : bool + member IsNewSlot : bool + member IsStatic : bool + member IsValueType : bool + member IsVirtualProperty : bool + member PropertyName : string + member SetterMethod : MethInfo + member TcGlobals : TcGlobals.TcGlobals + member XmlDoc : XmlDoc.XmlDoc + end + [] + type ILEventInfo = + | ILEventInfo of + ilTypeInfo: ILTypeInfo * ilEventDef: AbstractIL.IL.ILEventDef + with + override ToString : unit -> string + member AddMethod : ILMethInfo + member ApparentEnclosingAppType : TypedTree.TType + member ApparentEnclosingType : TypedTree.TType + member DeclaringTyconRef : TypedTree.TyconRef + member ILTypeInfo : ILTypeInfo + member IsStatic : bool + member Name : string + member RawMetadata : AbstractIL.IL.ILEventDef + member RemoveMethod : ILMethInfo + member TcGlobals : TcGlobals.TcGlobals + member TypeRef : AbstractIL.IL.ILTypeRef + end + exception BadEventTransformation of Range.range + val private tyConformsToIDelegateEvent : + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val nonStandardEventError : nm:System.String -> m:Range.range -> exn + val FindDelegateTypeOfPropertyEvent : + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + nm:System.String -> + m:Range.range -> ty:TypedTree.TType -> TypedTree.TType + [] + type EventInfo = + | FSEvent of + tcGlobals: TcGlobals.TcGlobals * propInfo: PropInfo * + addMethod: TypedTree.ValRef * removeMethod: TypedTree.ValRef + | ILEvent of ilEventInfo: ILEventInfo + | ProvidedEvent of + amap: Import.ImportMap * + providedEvent: Tainted * + range: Range.range + with + static member + EventInfosUseIdenticalDefinitions : x1:EventInfo -> + x2:EventInfo -> bool + member ComputeHashCode : unit -> int + member + GetDelegateType : amap:Import.ImportMap * m:Range.range -> + TypedTree.TType + override ToString : unit -> string + member AddMethod : MethInfo + member ApparentEnclosingAppType : TypedTree.TType + member ApparentEnclosingTyconRef : TypedTree.TyconRef + member ApparentEnclosingType : TypedTree.TType + member ArbitraryValRef : TypedTree.ValRef option + member DeclaringTyconRef : TypedTree.EntityRef + member EventName : string + member HasDirectXmlComment : bool + member IsExtensionMember : bool + member IsStatic : bool + member IsValueType : bool + member RemoveMethod : MethInfo + member TcGlobals : TcGlobals.TcGlobals + member XmlDoc : XmlDoc.XmlDoc + end + val stripByrefTy : + g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType + type CompiledSig = + | CompiledSig of + argTys: TypedTree.TType list list * returnTy: TypedTree.TType option * + formalMethTypars: TypedTree.Typars * + formalMethTyparInst: TypedTreeOps.TyparInst + val CompiledSigOfMeth : + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> m:Range.range -> minfo:MethInfo -> CompiledSig + val MethInfosEquivByPartialSig : + erasureFlag:TypedTreeOps.Erasure -> + ignoreFinal:bool -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool + val MethInfosEquivByNameAndPartialSig : + erasureFlag:TypedTreeOps.Erasure -> + ignoreFinal:bool -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool + val PropInfosEquivByNameAndPartialSig : + erasureFlag:TypedTreeOps.Erasure -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> pinfo:PropInfo -> pinfo2:PropInfo -> bool + val MethInfosEquivByNameAndSig : + erasureFlag:TypedTreeOps.Erasure -> + ignoreFinal:bool -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool + val PropInfosEquivByNameAndSig : + erasureFlag:TypedTreeOps.Erasure -> + g:TcGlobals.TcGlobals -> + amap:Import.ImportMap -> + m:Range.range -> pinfo:PropInfo -> pinfo2:PropInfo -> bool + val SettersOfPropInfos : + pinfos:PropInfo list -> (MethInfo * PropInfo option) list + val GettersOfPropInfos : + pinfos:PropInfo list -> (MethInfo * PropInfo option) list + end + namespace FSharp.Compiler - module internal AccessibilityLogic = - [] + module internal AccessibilityLogic = begin + [] type AccessorDomain = | AccessibleFrom of - TypedTree.CompilationPath list * TypedTree.TyconRef option + cpaths: TypedTree.CompilationPath list * + tyconRefOpt: TypedTree.TyconRef option | AccessibleFromEverywhere | AccessibleFromSomeFSharpCode | AccessibleFromSomewhere with static member - CustomEquals: g:TcGlobals.TcGlobals * ad1:AccessorDomain * + CustomEquals : g:TcGlobals.TcGlobals * ad1:AccessorDomain * ad2:AccessorDomain -> bool - static member CustomGetHashCode: ad:AccessorDomain -> int - - val IsAccessible: + static member CustomGetHashCode : ad:AccessorDomain -> int + end + val IsAccessible : ad:AccessorDomain -> taccess:TypedTree.Accessibility -> bool - val private IsILMemberAccessible: + val private IsILMemberAccessible : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> tcrefOfViewedItem:TypedTree.TyconRef -> ad:AccessorDomain -> access:AbstractIL.IL.ILMemberAccess -> bool - val private IsILTypeDefAccessible: + val private IsILTypeDefAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> encTyconRefOpt:TypedTree.TyconRef option -> tdef:AbstractIL.IL.ILTypeDef -> bool - val private IsTyconAccessibleViaVisibleTo: + val private IsTyconAccessibleViaVisibleTo : ad:AccessorDomain -> tcrefOfViewedItem:TypedTree.TyconRef -> bool - val private IsILTypeInfoAccessible: + val private IsILTypeInfoAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> tcrefOfViewedItem:TypedTree.TyconRef -> bool - val private IsILTypeAndMemberAccessible: + val private IsILTypeAndMemberAccessible : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> @@ -41,107 +25117,107 @@ namespace FSharp.Compiler ad:AccessorDomain -> ty:Infos.ILTypeInfo -> access:AbstractIL.IL.ILMemberAccess -> bool - val IsEntityAccessible: + val IsEntityAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool - val CheckTyconAccessible: + val CheckTyconAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool - val IsTyconReprAccessible: + val IsTyconReprAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool - val CheckTyconReprAccessible: + val CheckTyconReprAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool - val IsTypeAccessible: + val IsTypeAccessible : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> ty:TypedTree.TType -> bool - val IsTypeInstAccessible: + val IsTypeInstAccessible : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> tinst:TypedTree.TypeInst -> bool - val IsProvidedMemberAccessible: + val IsProvidedMemberAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> ty:TypedTree.TType -> access:AbstractIL.IL.ILMemberAccess -> bool - val ComputeILAccess: + val ComputeILAccess : isPublic:bool -> isFamily:bool -> isFamilyOrAssembly:bool -> isFamilyAndAssembly:bool -> AbstractIL.IL.ILMemberAccess - val IsILFieldInfoAccessible: + val IsILFieldInfoAccessible : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> x:Infos.ILFieldInfo -> bool - val GetILAccessOfILEventInfo: + val GetILAccessOfILEventInfo : Infos.ILEventInfo -> AbstractIL.IL.ILMemberAccess - val IsILEventInfoAccessible: + val IsILEventInfoAccessible : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> einfo:Infos.ILEventInfo -> bool - val private IsILMethInfoAccessible: + val private IsILMethInfoAccessible : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> adType:AccessorDomain -> ad:AccessorDomain -> ilminfo:Infos.ILMethInfo -> bool - val GetILAccessOfILPropInfo: + val GetILAccessOfILPropInfo : Infos.ILPropInfo -> AbstractIL.IL.ILMemberAccess - val IsILPropInfoAccessible: + val IsILPropInfoAccessible : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> pinfo:Infos.ILPropInfo -> bool - val IsValAccessible: ad:AccessorDomain -> vref:TypedTree.ValRef -> bool - val CheckValAccessible: + val IsValAccessible : ad:AccessorDomain -> vref:TypedTree.ValRef -> bool + val CheckValAccessible : m:Range.range -> ad:AccessorDomain -> vref:TypedTree.ValRef -> unit - val IsUnionCaseAccessible: + val IsUnionCaseAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> ucref:TypedTree.UnionCaseRef -> bool - val CheckUnionCaseAccessible: + val CheckUnionCaseAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> ucref:TypedTree.UnionCaseRef -> bool - val IsRecdFieldAccessible: + val IsRecdFieldAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> rfref:TypedTree.RecdFieldRef -> bool - val CheckRecdFieldAccessible: + val CheckRecdFieldAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> rfref:TypedTree.RecdFieldRef -> bool - val CheckRecdFieldInfoAccessible: + val CheckRecdFieldInfoAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> rfinfo:Infos.RecdFieldInfo -> unit - val CheckILFieldInfoAccessible: + val CheckILFieldInfoAccessible : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> finfo:Infos.ILFieldInfo -> unit - val IsTypeAndMethInfoAccessible: + val IsTypeAndMethInfoAccessible : amap:Import.ImportMap -> m:Range.range -> accessDomainTy:AccessorDomain -> ad:AccessorDomain -> _arg1:Infos.MethInfo -> bool - val IsMethInfoAccessible: + val IsMethInfoAccessible : amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> minfo:Infos.MethInfo -> bool - val IsPropInfoAccessible: + val IsPropInfoAccessible : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ad:AccessorDomain -> _arg1:Infos.PropInfo -> bool - val IsFieldInfoAccessible: + val IsFieldInfoAccessible : ad:AccessorDomain -> rfref:Infos.RecdFieldInfo -> bool - + end namespace FSharp.Compiler - module internal AttributeChecking = + module internal AttributeChecking = begin exception ObsoleteWarning of string * Range.range exception ObsoleteError of string * Range.range - val fail: unit -> 'a - val private evalILAttribElem: e:AbstractIL.IL.ILAttribElem -> obj - val private evalFSharpAttribArg: + val fail : unit -> 'a + val private evalILAttribElem : e:AbstractIL.IL.ILAttribElem -> obj + val private evalFSharpAttribArg : g:TcGlobals.TcGlobals -> e:TypedTree.Expr -> obj type AttribInfo = | FSAttribInfo of TcGlobals.TcGlobals * TypedTree.Attrib @@ -149,33 +25225,33 @@ namespace FSharp.Compiler TcGlobals.TcGlobals * Import.ImportMap * AbstractIL.IL.ILScopeRef * AbstractIL.IL.ILAttribute * Range.range with - member ConstructorArguments: (TypedTree.TType * obj) list - member NamedArguments: (TypedTree.TType * string * bool * obj) list - member Range: Range.range - member TyconRef: TypedTree.TyconRef - - val AttribInfosOfIL: + member ConstructorArguments : (TypedTree.TType * obj) list + member NamedArguments : (TypedTree.TType * string * bool * obj) list + member Range : Range.range + member TyconRef : TypedTree.TyconRef + end + val AttribInfosOfIL : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> scoref:AbstractIL.IL.ILScopeRef -> m:Range.range -> attribs:AbstractIL.IL.ILAttributes -> AttribInfo list - val AttribInfosOfFS: + val AttribInfosOfFS : g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> AttribInfo list - val GetAttribInfosOfEntity: + val GetAttribInfosOfEntity : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> tcref:TypedTree.TyconRef -> AttribInfo list - val GetAttribInfosOfMethod: + val GetAttribInfosOfMethod : amap:Import.ImportMap -> m:Range.range -> minfo:Infos.MethInfo -> AttribInfo list - val GetAttribInfosOfProp: + val GetAttribInfosOfProp : amap:Import.ImportMap -> m:Range.range -> pinfo:Infos.PropInfo -> AttribInfo list - val GetAttribInfosOfEvent: + val GetAttribInfosOfEvent : amap:Import.ImportMap -> m:Range.range -> einfo:Infos.EventInfo -> AttribInfo list - val TryBindTyconRefAttribute: + val TryBindTyconRefAttribute : g:TcGlobals.TcGlobals -> m:Range.range -> TcGlobals.BuiltinAttribInfo -> @@ -185,14 +25261,14 @@ namespace FSharp.Compiler f2:(TypedTree.Attrib -> 'a option) -> f3:(obj option list * (string * obj option) list -> 'a option) -> 'a option - val BindMethInfoAttributes: + val BindMethInfoAttributes : m:Range.range -> minfo:Infos.MethInfo -> f1:(AbstractIL.IL.ILAttributes -> 'a) -> f2:(TypedTree.Attrib list -> 'a) -> f3:(Tainted -> 'a) -> 'a - val TryBindMethInfoAttribute: + val TryBindMethInfoAttribute : g:TcGlobals.TcGlobals -> m:Range.range -> TcGlobals.BuiltinAttribInfo -> @@ -202,86 +25278,86 @@ namespace FSharp.Compiler f2:(TypedTree.Attrib -> 'a option) -> f3:(obj option list * (string * obj option) list -> 'a option) -> 'a option - val TryFindMethInfoStringAttribute: + val TryFindMethInfoStringAttribute : g:TcGlobals.TcGlobals -> m:Range.range -> attribSpec:TcGlobals.BuiltinAttribInfo -> minfo:Infos.MethInfo -> string option - val MethInfoHasAttribute: + val MethInfoHasAttribute : g:TcGlobals.TcGlobals -> m:Range.range -> attribSpec:TcGlobals.BuiltinAttribInfo -> minfo:Infos.MethInfo -> bool - val private CheckILAttributes: + val private CheckILAttributes : g:TcGlobals.TcGlobals -> isByrefLikeTyconRef:bool -> cattrs:AbstractIL.IL.ILAttributes -> m:Range.range -> ErrorLogger.OperationResult - val langVersionPrefix: string - val CheckFSharpAttributes: + val langVersionPrefix : string + val CheckFSharpAttributes : g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> m:Range.range -> ErrorLogger.OperationResult - val private CheckProvidedAttributes: + val private CheckProvidedAttributes : g:TcGlobals.TcGlobals -> m:Range.range -> provAttribs:Tainted -> ErrorLogger.OperationResult - val CheckILAttributesForUnseen: + val CheckILAttributesForUnseen : g:TcGlobals.TcGlobals -> cattrs:AbstractIL.IL.ILAttributes -> _m:'a -> bool - val CheckFSharpAttributesForHidden: + val CheckFSharpAttributesForHidden : g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> bool - val CheckFSharpAttributesForObsolete: + val CheckFSharpAttributesForObsolete : g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> bool - val CheckFSharpAttributesForUnseen: + val CheckFSharpAttributesForUnseen : g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> _m:'a -> bool - val CheckProvidedAttributesForUnseen: + val CheckProvidedAttributesForUnseen : provAttribs:Tainted -> m:Range.range -> bool - val CheckPropInfoAttributes: + val CheckPropInfoAttributes : pinfo:Infos.PropInfo -> m:Range.range -> ErrorLogger.OperationResult - val CheckILFieldAttributes: + val CheckILFieldAttributes : g:TcGlobals.TcGlobals -> finfo:Infos.ILFieldInfo -> m:Range.range -> unit - val CheckMethInfoAttributes: + val CheckMethInfoAttributes : g:TcGlobals.TcGlobals -> m:Range.range -> tyargsOpt:'a option -> minfo:Infos.MethInfo -> ErrorLogger.OperationResult - val MethInfoIsUnseen: + val MethInfoIsUnseen : g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType -> minfo:Infos.MethInfo -> bool - val PropInfoIsUnseen: m:'a -> pinfo:Infos.PropInfo -> bool - val CheckEntityAttributes: + val PropInfoIsUnseen : m:'a -> pinfo:Infos.PropInfo -> bool + val CheckEntityAttributes : g:TcGlobals.TcGlobals -> x:TypedTree.TyconRef -> m:Range.range -> ErrorLogger.OperationResult - val CheckUnionCaseAttributes: + val CheckUnionCaseAttributes : g:TcGlobals.TcGlobals -> x:TypedTree.UnionCaseRef -> m:Range.range -> ErrorLogger.OperationResult - val CheckRecdFieldAttributes: + val CheckRecdFieldAttributes : g:TcGlobals.TcGlobals -> x:TypedTree.RecdFieldRef -> m:Range.range -> ErrorLogger.OperationResult - val CheckValAttributes: + val CheckValAttributes : g:TcGlobals.TcGlobals -> x:TypedTree.ValRef -> m:Range.range -> ErrorLogger.OperationResult - val CheckRecdFieldInfoAttributes: + val CheckRecdFieldInfoAttributes : g:TcGlobals.TcGlobals -> x:Infos.RecdFieldInfo -> m:Range.range -> ErrorLogger.OperationResult - val IsSecurityAttribute: + val IsSecurityAttribute : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> casmap:System.Collections.Generic.Dictionary -> TypedTree.Attrib -> m:Range.range -> bool - val IsSecurityCriticalAttribute: + val IsSecurityCriticalAttribute : g:TcGlobals.TcGlobals -> TypedTree.Attrib -> bool - + end namespace FSharp.Compiler - module internal TypeRelations = - val TypeDefinitelySubsumesTypeNoCoercion: + module internal TypeRelations = begin + val TypeDefinitelySubsumesTypeNoCoercion : ndeep:int -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> @@ -289,139 +25365,139 @@ namespace FSharp.Compiler type CanCoerce = | CanCoerce | NoCoerce - val TypesFeasiblyEquivalent: + val TypesFeasiblyEquivalent : stripMeasures:bool -> ndeep:int -> g:TcGlobals.TcGlobals -> amap:'a -> m:Range.range -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool - val TypesFeasiblyEquiv: + val TypesFeasiblyEquiv : ndeep:int -> g:TcGlobals.TcGlobals -> amap:'a -> m:Range.range -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool - val TypesFeasiblyEquivStripMeasures: + val TypesFeasiblyEquivStripMeasures : g:TcGlobals.TcGlobals -> amap:'a -> m:Range.range -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool - val TypeFeasiblySubsumesType: + val TypeFeasiblySubsumesType : ndeep:int -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ty1:TypedTree.TType -> canCoerce:CanCoerce -> ty2:TypedTree.TType -> bool - val ChooseTyparSolutionAndRange: + val ChooseTyparSolutionAndRange : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> tp:TypedTree.Typar -> TypedTree.TType * Range.range - val ChooseTyparSolution: + val ChooseTyparSolution : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> tp:TypedTree.Typar -> TypedTree.TType - val IterativelySubstituteTyparSolutions: + val IterativelySubstituteTyparSolutions : g:TcGlobals.TcGlobals -> tps:TypedTree.Typars -> solutions:TypedTree.TTypes -> TypedTree.TypeInst - val ChooseTyparSolutionsForFreeChoiceTypars: + val ChooseTyparSolutionsForFreeChoiceTypars : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> e:TypedTree.Expr -> TypedTree.Expr - val tryDestTopLambda: + val tryDestTopLambda : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> TypedTree.ValReprInfo -> e:TypedTree.Expr * ty:TypedTree.TType -> (TypedTree.Typars * TypedTree.Val option * TypedTree.Val option * TypedTree.Val list list * TypedTree.Expr * TypedTree.TType) option - val destTopLambda: + val destTopLambda : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> topValInfo:TypedTree.ValReprInfo -> e:TypedTree.Expr * ty:TypedTree.TType -> TypedTree.Typars * TypedTree.Val option * TypedTree.Val option * TypedTree.Val list list * TypedTree.Expr * TypedTree.TType - val IteratedAdjustArityOfLambdaBody: + val IteratedAdjustArityOfLambdaBody : g:TcGlobals.TcGlobals -> arities:int list -> vsl:TypedTree.Val list list -> body:TypedTree.Expr -> TypedTree.Val list list * TypedTree.Expr - val IteratedAdjustArityOfLambda: + val IteratedAdjustArityOfLambda : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> topValInfo:TypedTree.ValReprInfo -> e:TypedTree.Expr -> TypedTree.Typars * TypedTree.Val option * TypedTree.Val option * TypedTree.Val list list * TypedTree.Expr * TypedTree.TType - val FindUniqueFeasibleSupertype: + val FindUniqueFeasibleSupertype : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> TypedTree.TType option - + end namespace FSharp.Compiler - module internal InfoReader = - val SelectImmediateMemberVals: + module internal InfoReader = begin + val SelectImmediateMemberVals : g:TcGlobals.TcGlobals -> optFilter:string option -> f:(TypedTree.ValMemberInfo -> TypedTree.ValRef -> 'a option) -> tcref:TypedTree.TyconRef -> 'a list - val private checkFilter: optFilter:string option -> nm:string -> bool - val TrySelectMemberVal: + val private checkFilter : optFilter:string option -> nm:string -> bool + val TrySelectMemberVal : g:TcGlobals.TcGlobals -> optFilter:string option -> ty:TypedTree.TType -> pri:Infos.ExtensionMethodPriority option -> _membInfo:'a -> vref:TypedTree.ValRef -> Infos.MethInfo option - val GetImmediateIntrinsicMethInfosOfTypeAux: + val GetImmediateIntrinsicMethInfosOfTypeAux : optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> origTy:TypedTree.TType -> metadataTy:TypedTree.TType -> Infos.MethInfo list - val GetImmediateIntrinsicMethInfosOfType: + val GetImmediateIntrinsicMethInfosOfType : optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list type PropertyCollector = - - new: g:TcGlobals.TcGlobals * amap:Import.ImportMap * m:Range.range * + class + new : g:TcGlobals.TcGlobals * amap:Import.ImportMap * m:Range.range * ty:TypedTree.TType * optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> PropertyCollector - member Close: unit -> Infos.PropInfo list + member Close : unit -> Infos.PropInfo list member - Collect: membInfo:TypedTree.ValMemberInfo * vref:TypedTree.ValRef -> + Collect : membInfo:TypedTree.ValMemberInfo * vref:TypedTree.ValRef -> unit - - val GetImmediateIntrinsicPropInfosOfTypeAux: + end + val GetImmediateIntrinsicPropInfosOfTypeAux : optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> origTy:TypedTree.TType -> metadataTy:TypedTree.TType -> Infos.PropInfo list - val GetImmediateIntrinsicPropInfosOfType: + val GetImmediateIntrinsicPropInfosOfType : optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list - val IsIndexerType: + val IsIndexerType : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> ty:TypedTree.TType -> bool - val GetMostSpecificItemsByType: + val GetMostSpecificItemsByType : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> f:('a -> (TypedTree.TType * Range.range) option) -> xs:'a list -> 'a list - val GetMostSpecificMethodInfosByMethInfoSig: + val GetMostSpecificMethodInfosByMethInfoSig : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ty:TypedTree.TType * minfo:Infos.MethInfo -> minfos:(TypedTree.TType * Infos.MethInfo) list -> (TypedTree.TType * Infos.MethInfo) list - val FilterMostSpecificMethInfoSets: + val FilterMostSpecificMethInfoSets : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> @@ -436,29 +25512,29 @@ namespace FSharp.Compiler | EventItem of Infos.EventInfo list | ILFieldItem of Infos.ILFieldInfo list type InfoReader = - - new: g:TcGlobals.TcGlobals * amap:Import.ImportMap -> InfoReader + class + new : g:TcGlobals.TcGlobals * amap:Import.ImportMap -> InfoReader member - GetEntireTypeHierarchy: allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * + GetEntireTypeHierarchy : allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * m:Range.range * ty:TypedTree.TType -> TypedTree.TType list member - GetEventInfosOfType: optFilter:string option * + GetEventInfosOfType : optFilter:string option * ad:AccessibilityLogic.AccessorDomain * m:Range.range * ty:TypedTree.TType -> Infos.EventInfo list member - GetILFieldInfosOfType: optFilter:string option * + GetILFieldInfosOfType : optFilter:string option * ad:AccessibilityLogic.AccessorDomain * m:Range.range * ty:TypedTree.TType -> Infos.ILFieldInfo list member - GetImmediateIntrinsicEventsOfType: optFilter:string option * + GetImmediateIntrinsicEventsOfType : optFilter:string option * ad:AccessibilityLogic.AccessorDomain * m:Range.range * ty:TypedTree.TType -> Infos.EventInfo list member - GetIntrinsicMostSpecificOverrideMethodSetsOfType: optFilter:string option * + GetIntrinsicMostSpecificOverrideMethodSetsOfType : optFilter:string option * ad:AccessibilityLogic.AccessorDomain * allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * m:Range.range * @@ -466,306 +25542,306 @@ namespace FSharp.Compiler AbstractIL.Internal.Library.NameMultiMap member - GetPrimaryTypeHierarchy: allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * + GetPrimaryTypeHierarchy : allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * m:Range.range * ty:TypedTree.TType -> TypedTree.TType list member - GetRawIntrinsicMethodSetsOfType: optFilter:string option * + GetRawIntrinsicMethodSetsOfType : optFilter:string option * ad:AccessibilityLogic.AccessorDomain * allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * m:Range.range * ty:TypedTree.TType -> Infos.MethInfo list list member - GetRawIntrinsicPropertySetsOfType: optFilter:string option * + GetRawIntrinsicPropertySetsOfType : optFilter:string option * ad:AccessibilityLogic.AccessorDomain * allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * m:Range.range * ty:TypedTree.TType -> Infos.PropInfo list list member - GetRecordOrClassFieldsOfType: optFilter:string option * + GetRecordOrClassFieldsOfType : optFilter:string option * ad:AccessibilityLogic.AccessorDomain * m:Range.range * ty:TypedTree.TType -> Infos.RecdFieldInfo list member - IsLanguageFeatureRuntimeSupported: langFeature:Features.LanguageFeature -> + IsLanguageFeatureRuntimeSupported : langFeature:Features.LanguageFeature -> bool member - TryFindNamedItemOfType: nm:string * + TryFindNamedItemOfType : nm:string * ad:AccessibilityLogic.AccessorDomain * m:Range.range * ty:TypedTree.TType -> HierarchyItem option member - TryFindRecdOrClassFieldInfoOfType: nm:string * m:Range.range * + TryFindRecdOrClassFieldInfoOfType : nm:string * m:Range.range * ty:TypedTree.TType -> Infos.RecdFieldInfo voption - member amap: Import.ImportMap - member g: TcGlobals.TcGlobals - - val private tryLanguageFeatureRuntimeErrorAux: + member amap : Import.ImportMap + member g : TcGlobals.TcGlobals + end + val private tryLanguageFeatureRuntimeErrorAux : infoReader:InfoReader -> langFeature:Features.LanguageFeature -> m:Range.range -> error:(exn -> unit) -> bool - val checkLanguageFeatureRuntimeError: + val checkLanguageFeatureRuntimeError : infoReader:InfoReader -> langFeature:Features.LanguageFeature -> m:Range.range -> unit - val checkLanguageFeatureRuntimeErrorRecover: + val checkLanguageFeatureRuntimeErrorRecover : infoReader:InfoReader -> langFeature:Features.LanguageFeature -> m:Range.range -> unit - val tryLanguageFeatureRuntimeErrorRecover: + val tryLanguageFeatureRuntimeErrorRecover : infoReader:InfoReader -> langFeature:Features.LanguageFeature -> m:Range.range -> bool - val GetIntrinsicConstructorInfosOfTypeAux: + val GetIntrinsicConstructorInfosOfTypeAux : infoReader:InfoReader -> m:Range.range -> origTy:TypedTree.TType -> metadataTy:TypedTree.TType -> Infos.MethInfo list - val GetIntrinsicConstructorInfosOfType: + val GetIntrinsicConstructorInfosOfType : infoReader:InfoReader -> m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list type FindMemberFlag = | IgnoreOverrides | PreferOverrides type private IndexedList<'T> = - - new: itemLists:'T list list * + class + new : itemLists:'T list list * itemsByName:AbstractIL.Internal.Library.NameMultiMap<'T> -> IndexedList<'T> - member AddItems: items:'T list * nmf:('T -> string) -> IndexedList<'T> + member AddItems : items:'T list * nmf:('T -> string) -> IndexedList<'T> member - FilterNewItems: keepTest:('a -> 'T -> bool) -> + FilterNewItems : keepTest:('a -> 'T -> bool) -> nmf:('a -> string) -> itemsToAdd:'a list -> 'a list - member ItemsWithName: nm:string -> 'T list - member Items: 'T list list - static member Empty: IndexedList<'T> - - val private FilterItemsInSubTypesBasedOnItemsInSuperTypes: + member ItemsWithName : nm:string -> 'T list + member Items : 'T list list + static member Empty : IndexedList<'T> + end + val private FilterItemsInSubTypesBasedOnItemsInSuperTypes : nmf:('a -> string) -> keepTest:('a -> 'a -> bool) -> itemLists:'a list list -> 'a list list - val private FilterItemsInSuperTypesBasedOnItemsInSubTypes: + val private FilterItemsInSuperTypesBasedOnItemsInSubTypes : nmf:('a -> string) -> keepTest:('a -> 'a list -> bool) -> itemLists:'a list list -> 'a list list - val private ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes: + val private ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes : nmf:('a -> string) -> equivTest:('a -> 'a -> bool) -> itemLists:'a list list -> 'a list list - val private FilterOverrides: + val private FilterOverrides : findFlag:FindMemberFlag -> isVirt:('a -> bool) * isNewSlot:('a -> bool) * isDefiniteOverride:('a -> bool) * isFinal:('a -> bool) * equivSigs:('a -> 'a -> bool) * nmf:('a -> string) -> items:'a list list -> 'a list list - val private FilterOverridesOfMethInfos: + val private FilterOverridesOfMethInfos : findFlag:FindMemberFlag -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> minfos:Infos.MethInfo list list -> Infos.MethInfo list list - val private FilterOverridesOfPropInfos: + val private FilterOverridesOfPropInfos : findFlag:FindMemberFlag -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> props:Infos.PropInfo list list -> Infos.PropInfo list list - val ExcludeHiddenOfMethInfos: + val ExcludeHiddenOfMethInfos : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> minfos:Infos.MethInfo list list -> Infos.MethInfo list - val ExcludeHiddenOfPropInfos: + val ExcludeHiddenOfPropInfos : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> pinfos:Infos.PropInfo list list -> Infos.PropInfo list - val GetIntrinsicMethInfoSetsOfType: + val GetIntrinsicMethInfoSetsOfType : infoReader:InfoReader -> optFilter:string option -> ad:AccessibilityLogic.AccessorDomain -> allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> findFlag:FindMemberFlag -> m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list list - val GetIntrinsicPropInfoSetsOfType: + val GetIntrinsicPropInfoSetsOfType : infoReader:InfoReader -> optFilter:string option -> ad:AccessibilityLogic.AccessorDomain -> allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> findFlag:FindMemberFlag -> m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list list - val GetIntrinsicMethInfosOfType: + val GetIntrinsicMethInfosOfType : infoReader:InfoReader -> optFilter:string option -> ad:AccessibilityLogic.AccessorDomain -> allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> findFlag:FindMemberFlag -> m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list - val GetIntrinsicPropInfosOfType: + val GetIntrinsicPropInfosOfType : infoReader:InfoReader -> optFilter:string option -> ad:AccessibilityLogic.AccessorDomain -> allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> findFlag:FindMemberFlag -> m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list - val TryFindIntrinsicNamedItemOfType: + val TryFindIntrinsicNamedItemOfType : infoReader:InfoReader -> nm:string * ad:AccessibilityLogic.AccessorDomain -> findFlag:FindMemberFlag -> m:Range.range -> ty:TypedTree.TType -> HierarchyItem option - val TryFindIntrinsicMethInfo: + val TryFindIntrinsicMethInfo : infoReader:InfoReader -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> nm:string -> ty:TypedTree.TType -> Infos.MethInfo list - val TryFindPropInfo: + val TryFindPropInfo : infoReader:InfoReader -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> nm:string -> ty:TypedTree.TType -> Infos.PropInfo list - val GetIntrinisicMostSpecificOverrideMethInfoSetsOfType: + val GetIntrinisicMostSpecificOverrideMethInfoSetsOfType : infoReader:InfoReader -> m:Range.range -> ty:TypedTree.TType -> AbstractIL.Internal.Library.NameMultiMap - [] + [] type SigOfFunctionForDelegate = | SigOfFunctionForDelegate of Infos.MethInfo * TypedTree.TType list * TypedTree.TType * TypedTree.TType - val GetSigOfFunctionForDelegate: + val GetSigOfFunctionForDelegate : infoReader:InfoReader -> delty:TypedTree.TType -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> SigOfFunctionForDelegate - val TryDestStandardDelegateType: + val TryDestStandardDelegateType : infoReader:InfoReader -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> delTy:TypedTree.TType -> (TypedTree.TType * TypedTree.TType) option - val IsStandardEventInfo: + val IsStandardEventInfo : infoReader:InfoReader -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> einfo:Infos.EventInfo -> bool - val ArgsTypOfEventInfo: + val ArgsTypOfEventInfo : infoReader:InfoReader -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> einfo:Infos.EventInfo -> TypedTree.TType - val PropTypOfEventInfo: + val PropTypOfEventInfo : infoReader:InfoReader -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> einfo:Infos.EventInfo -> TypedTree.TType - + end namespace FSharp.Compiler - module internal NicePrint = - module PrintUtilities = - val bracketIfL: + module internal NicePrint = begin + module PrintUtilities = begin + val bracketIfL : x:bool -> lyt:Internal.Utilities.StructuredFormat.Layout -> Internal.Utilities.StructuredFormat.Layout - val squareAngleL: + val squareAngleL : x:Internal.Utilities.StructuredFormat.Layout -> Internal.Utilities.StructuredFormat.Layout - val angleL: + val angleL : x:Internal.Utilities.StructuredFormat.Layout -> Internal.Utilities.StructuredFormat.Layout - val braceL: + val braceL : x:Internal.Utilities.StructuredFormat.Layout -> Internal.Utilities.StructuredFormat.Layout - val braceBarL: + val braceBarL : x:Internal.Utilities.StructuredFormat.Layout -> Internal.Utilities.StructuredFormat.Layout - val comment: str:string -> Internal.Utilities.StructuredFormat.Layout - val layoutsL: ls:Layout.layout list -> Layout.layout - val suppressInheritanceAndInterfacesForTyInSimplifiedDisplays: + val comment : str:string -> Internal.Utilities.StructuredFormat.Layout + val layoutsL : ls:Layout.layout list -> Layout.layout + val suppressInheritanceAndInterfacesForTyInSimplifiedDisplays : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ty:TypedTree.TType -> bool - val applyMaxMembers: + val applyMaxMembers : maxMembers:int option -> allDecls:Internal.Utilities.StructuredFormat.Layout list -> Internal.Utilities.StructuredFormat.Layout list - val adjustILName: n:string -> string - val shrinkOverloads: + val adjustILName : n:string -> string + val shrinkOverloads : layoutFunction:('a -> Internal.Utilities.StructuredFormat.Layout) -> resultFunction:('a -> Internal.Utilities.StructuredFormat.Layout -> 'b) -> group:'a list -> 'b list - val layoutTyconRefImpl: + val layoutTyconRefImpl : isAttribute:bool -> denv:TypedTreeOps.DisplayEnv -> tcref:TypedTree.TyconRef -> Internal.Utilities.StructuredFormat.Layout - val layoutBuiltinAttribute: + val layoutBuiltinAttribute : denv:TypedTreeOps.DisplayEnv -> attrib:TcGlobals.BuiltinAttribInfo -> Internal.Utilities.StructuredFormat.Layout - - module private PrintIL = - val fullySplitILTypeRef: tref:AbstractIL.IL.ILTypeRef -> string list - val layoutILTypeRefName: + end + module private PrintIL = begin + val fullySplitILTypeRef : tref:AbstractIL.IL.ILTypeRef -> string list + val layoutILTypeRefName : denv:TypedTreeOps.DisplayEnv -> path:string list -> Internal.Utilities.StructuredFormat.Layout - val layoutILTypeRef: + val layoutILTypeRef : denv:TypedTreeOps.DisplayEnv -> tref:AbstractIL.IL.ILTypeRef -> Internal.Utilities.StructuredFormat.Layout - val layoutILArrayShape: + val layoutILArrayShape : AbstractIL.IL.ILArrayShape -> Internal.Utilities.StructuredFormat.Layout - val paramsL: ps:Layout.layout list -> Layout.layout - val pruneParams: - Name:string -> + val paramsL : ps:Layout.layout list -> Layout.layout + val pruneParams : + className:string -> ilTyparSubst:Layout.layout list -> Layout.layout list - val layoutILType: + val layoutILType : denv:TypedTreeOps.DisplayEnv -> ilTyparSubst:Layout.layout list -> ty:AbstractIL.IL.ILType -> Layout.layout - val layoutILCallingSignature: + val layoutILCallingSignature : denv:TypedTreeOps.DisplayEnv -> ilTyparSubst:Layout.layout list -> cons:string option -> signature:AbstractIL.IL.ILCallingSignature -> Layout.layout - val layoutILFieldInit: + val layoutILFieldInit : x:AbstractIL.IL.ILFieldInit option -> Internal.Utilities.StructuredFormat.Layout - val layoutILEnumDefParts: + val layoutILEnumDefParts : nm:string -> litVal:AbstractIL.IL.ILFieldInit option -> Internal.Utilities.StructuredFormat.Layout - - module private PrintTypes = - val layoutConst: + end + module private PrintTypes = begin + val layoutConst : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> c:TypedTree.Const -> Internal.Utilities.StructuredFormat.Layout - val layoutAccessibility: + val layoutAccessibility : denv:TypedTreeOps.DisplayEnv -> accessibility:TypedTree.Accessibility -> itemL:Internal.Utilities.StructuredFormat.Layout -> Internal.Utilities.StructuredFormat.Layout - val layoutTyconRef: + val layoutTyconRef : denv:TypedTreeOps.DisplayEnv -> tycon:TypedTree.TyconRef -> Internal.Utilities.StructuredFormat.Layout - val layoutMemberFlags: + val layoutMemberFlags : memFlags:SyntaxTree.MemberFlags -> Internal.Utilities.StructuredFormat.Layout - val layoutAttribArg: + val layoutAttribArg : denv:TypedTreeOps.DisplayEnv -> arg:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val layoutAttribArgs: + val layoutAttribArgs : denv:TypedTreeOps.DisplayEnv -> args:TypedTree.AttribExpr list -> Internal.Utilities.StructuredFormat.Layout - val layoutAttrib: + val layoutAttrib : denv:TypedTreeOps.DisplayEnv -> TypedTree.Attrib -> Internal.Utilities.StructuredFormat.Layout - val layoutILAttribElement: + val layoutILAttribElement : denv:TypedTreeOps.DisplayEnv -> arg:AbstractIL.IL.ILAttribElem -> Internal.Utilities.StructuredFormat.Layout - val layoutILAttrib: + val layoutILAttrib : denv:TypedTreeOps.DisplayEnv -> ty:AbstractIL.IL.ILType * args:AbstractIL.IL.ILAttribElem list -> Internal.Utilities.StructuredFormat.Layout - val layoutAttribs: + val layoutAttribs : denv:TypedTreeOps.DisplayEnv -> isValue:bool -> ty:TypedTree.TType -> @@ -773,38 +25849,38 @@ namespace FSharp.Compiler attrs:TypedTree.Attrib list -> restL:Internal.Utilities.StructuredFormat.Layout -> Internal.Utilities.StructuredFormat.Layout - val layoutTyparAttribs: + val layoutTyparAttribs : denv:TypedTreeOps.DisplayEnv -> kind:TypedTree.TyparKind -> attrs:TypedTree.Attrib list -> restL:Internal.Utilities.StructuredFormat.Layout -> Internal.Utilities.StructuredFormat.Layout - val layoutTyparRef: + val layoutTyparRef : denv:TypedTreeOps.DisplayEnv -> typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val layoutTyparRefWithInfo: + val layoutTyparRefWithInfo : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val layoutConstraintsWithInfo: + val layoutConstraintsWithInfo : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> cxs:(TypedTree.Typar * TypedTree.TyparConstraint) list -> Internal.Utilities.StructuredFormat.Layout - val layoutConstraintWithInfo: + val layoutConstraintWithInfo : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> tp:TypedTree.Typar * tpc:TypedTree.TyparConstraint -> Internal.Utilities.StructuredFormat.Layout list - val layoutTraitWithInfo: + val layoutTraitWithInfo : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> TypedTree.TraitConstraintInfo -> Internal.Utilities.StructuredFormat.Layout - val layoutMeasure: + val layoutMeasure : denv:TypedTreeOps.DisplayEnv -> unt:TypedTree.Measure -> Internal.Utilities.StructuredFormat.Layout - val layoutTypeAppWithInfoAndPrec: + val layoutTypeAppWithInfoAndPrec : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> tcL:Internal.Utilities.StructuredFormat.Layout -> @@ -812,57 +25888,57 @@ namespace FSharp.Compiler prefix:bool -> args:TypedTree.TType list -> Internal.Utilities.StructuredFormat.Layout - val layoutTypeWithInfoAndPrec: + val layoutTypeWithInfoAndPrec : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> prec:int -> ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val layoutTypesWithInfoAndPrec: + val layoutTypesWithInfoAndPrec : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> prec:int -> sep:Internal.Utilities.StructuredFormat.Layout -> typl:TypedTree.TType list -> Internal.Utilities.StructuredFormat.Layout - val layoutReturnType: + val layoutReturnType : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> rty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val layoutTypeWithInfo: + val layoutTypeWithInfo : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val layoutType: + val layoutType : denv:TypedTreeOps.DisplayEnv -> ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val layoutArgInfos: + val layoutArgInfos : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> Internal.Utilities.StructuredFormat.Layout list - val layoutGenericParameterTypes: + val layoutGenericParameterTypes : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> _arg1:TypedTree.TType list -> Internal.Utilities.StructuredFormat.Layout - val layoutTopType: + val layoutTopType : denv:TypedTreeOps.DisplayEnv -> env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> rty:TypedTree.TType -> cxs:(TypedTree.Typar * TypedTree.TyparConstraint) list -> Internal.Utilities.StructuredFormat.Layout - val layoutTyparDecls: + val layoutTyparDecls : denv:TypedTreeOps.DisplayEnv -> nmL:Internal.Utilities.StructuredFormat.Layout -> prefix:bool -> typars:TypedTree.Typars -> Internal.Utilities.StructuredFormat.Layout - val layoutTyparConstraint: + val layoutTyparConstraint : denv:TypedTreeOps.DisplayEnv -> tp:TypedTree.Typar * tpc:TypedTree.TyparConstraint -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfInstAndSig: + val prettyLayoutOfInstAndSig : denv:TypedTreeOps.DisplayEnv -> typarInst:TypedTreeOps.TyparInst * tys:TypedTree.TTypes * retTy:TypedTree.TType -> @@ -870,20 +25946,20 @@ namespace FSharp.Compiler (Internal.Utilities.StructuredFormat.Layout list * Internal.Utilities.StructuredFormat.Layout) * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfTopTypeInfoAux: + val prettyLayoutOfTopTypeInfoAux : denv:TypedTreeOps.DisplayEnv -> prettyArgInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> prettyRetTy:TypedTree.TType -> cxs:TypedTreeOps.TyparConstraintsWithTypars -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfUncurriedSig: + val prettyLayoutOfUncurriedSig : denv:TypedTreeOps.DisplayEnv -> typarInst:TypedTreeOps.TyparInst -> argInfos:TypedTreeOps.UncurriedArgInfos -> retTy:TypedTree.TType -> TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfCurriedMemberSig: + val prettyLayoutOfCurriedMemberSig : denv:TypedTreeOps.DisplayEnv -> typarInst:TypedTreeOps.TyparInst -> argInfos:TypedTreeOps.CurriedArgInfos -> @@ -891,12 +25967,12 @@ namespace FSharp.Compiler parentTyparTys:TypedTree.TTypes -> TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout - val prettyArgInfos: + val prettyArgInfos : denv:TypedTreeOps.DisplayEnv -> allTyparInst:TypedTreeOps.TyparInst -> _arg1:(TypedTree.TType * TypedTree.ArgReprInfo) list -> (TypedTree.TType * TypedTree.ArgReprInfo) list - val prettyLayoutOfMemberSigCore: + val prettyLayoutOfMemberSigCore : denv:TypedTreeOps.DisplayEnv -> memberToParentInst:(TypedTree.Typar * TypedTree.TType) list -> typarInst:TypedTreeOps.TyparInst * methTypars:TypedTree.Typars * @@ -904,7 +25980,7 @@ namespace FSharp.Compiler retTy:TypedTree.TType -> TypedTreeOps.TyparInst * TypedTree.Typars * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMemberType: + val prettyLayoutOfMemberType : denv:TypedTreeOps.DisplayEnv -> v:TypedTree.ValRef -> typarInst:TypedTreeOps.TyparInst -> @@ -912,13 +25988,13 @@ namespace FSharp.Compiler retTy:TypedTree.TType -> TypedTreeOps.TyparInst * TypedTree.Typars * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMemberSig: + val prettyLayoutOfMemberSig : denv:TypedTreeOps.DisplayEnv -> memberToParentInst:(TypedTree.Typar * TypedTree.TType) list * nm:string * methTypars:TypedTree.Typars * argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list * retTy:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutsOfUnresolvedOverloading: + val prettyLayoutsOfUnresolvedOverloading : denv:TypedTreeOps.DisplayEnv -> argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list -> retTy:TypedTree.TType -> @@ -926,86 +26002,86 @@ namespace FSharp.Compiler Internal.Utilities.StructuredFormat.Layout * Internal.Utilities.StructuredFormat.Layout * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfType: + val prettyLayoutOfType : denv:TypedTreeOps.DisplayEnv -> ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfTypeNoConstraints: + val prettyLayoutOfTypeNoConstraints : denv:TypedTreeOps.DisplayEnv -> ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val layoutAssemblyName: _denv:'a -> ty:TypedTree.TType -> string - - module private PrintTastMemberOrVals = - val prettyLayoutOfMemberShortOption: + val layoutAssemblyName : _denv:'a -> ty:TypedTree.TType -> string + end + module private PrintTastMemberOrVals = begin + val prettyLayoutOfMemberShortOption : denv:TypedTreeOps.DisplayEnv -> typarInst:TypedTreeOps.TyparInst -> v:TypedTree.Val -> short:bool -> TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMember: + val prettyLayoutOfMember : denv:TypedTreeOps.DisplayEnv -> typarInst:TypedTreeOps.TyparInst -> v:TypedTree.Val -> TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMemberNoInstShort: + val prettyLayoutOfMemberNoInstShort : denv:TypedTreeOps.DisplayEnv -> v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val layoutOfLiteralValue: + val layoutOfLiteralValue : literalValue:TypedTree.Const -> Internal.Utilities.StructuredFormat.Layout - val layoutNonMemberVal: + val layoutNonMemberVal : denv:TypedTreeOps.DisplayEnv -> tps:TypedTree.Typar list * v:TypedTree.Val * tau:TypedTree.TType * cxs:TypedTreeOps.TyparConstraintsWithTypars -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfValOrMember: + val prettyLayoutOfValOrMember : denv:TypedTreeOps.DisplayEnv -> typarInst:TypedTreeOps.TyparInst -> v:TypedTree.Val -> TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfValOrMemberNoInst: + val prettyLayoutOfValOrMemberNoInst : denv:TypedTreeOps.DisplayEnv -> v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - - val layoutTyparConstraint: + end + val layoutTyparConstraint : denv:TypedTreeOps.DisplayEnv -> TypedTree.Typar * TypedTree.TyparConstraint -> Internal.Utilities.StructuredFormat.Layout - val outputType: + val outputType : denv:TypedTreeOps.DisplayEnv -> os:System.Text.StringBuilder -> x:TypedTree.TType -> unit - val layoutType: + val layoutType : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val outputTypars: + val outputTypars : denv:TypedTreeOps.DisplayEnv -> nm:Layout.TaggedText -> os:System.Text.StringBuilder -> x:TypedTree.Typars -> unit - val outputTyconRef: + val outputTyconRef : denv:TypedTreeOps.DisplayEnv -> os:System.Text.StringBuilder -> x:TypedTree.TyconRef -> unit - val layoutTyconRef: + val layoutTyconRef : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TyconRef -> Internal.Utilities.StructuredFormat.Layout - val layoutConst: + val layoutConst : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> c:TypedTree.Const -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMemberSig: + val prettyLayoutOfMemberSig : denv:TypedTreeOps.DisplayEnv -> (TypedTree.Typar * TypedTree.TType) list * string * TypedTree.Typars * (TypedTree.TType * TypedTree.ArgReprInfo) list list * TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfUncurriedSig: + val prettyLayoutOfUncurriedSig : denv:TypedTreeOps.DisplayEnv -> argInfos:TypedTreeOps.TyparInst -> tau:TypedTreeOps.UncurriedArgInfos -> (TypedTree.TType -> TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout) - val prettyLayoutsOfUnresolvedOverloading: + val prettyLayoutsOfUnresolvedOverloading : denv:TypedTreeOps.DisplayEnv -> argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list -> retTy:TypedTree.TType -> @@ -1013,35 +26089,35 @@ namespace FSharp.Compiler Internal.Utilities.StructuredFormat.Layout * Internal.Utilities.StructuredFormat.Layout * Internal.Utilities.StructuredFormat.Layout - module InfoMemberPrinting = - val layoutParamData: + module InfoMemberPrinting = begin + val layoutParamData : denv:TypedTreeOps.DisplayEnv -> Infos.ParamData -> Internal.Utilities.StructuredFormat.Layout - val formatParamDataToBuffer: + val formatParamDataToBuffer : denv:TypedTreeOps.DisplayEnv -> os:System.Text.StringBuilder -> pd:Infos.ParamData -> unit - val private layoutMethInfoFSharpStyleCore: + val private layoutMethInfoFSharpStyleCore : amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> minfo:Infos.MethInfo -> minst:TypedTree.TType list -> Internal.Utilities.StructuredFormat.Layout - val private layoutMethInfoCSharpStyle: + val private layoutMethInfoCSharpStyle : amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> minfo:Infos.MethInfo -> minst:TypedTree.TType list -> Internal.Utilities.StructuredFormat.Layout - val prettifyILMethInfo: + val prettifyILMethInfo : amap:Import.ImportMap -> m:Range.range -> minfo:Infos.MethInfo -> typarInst:TypedTreeOps.TyparInst -> ilMethInfo:Infos.ILMethInfo -> TypedTreeOps.TyparInst * Infos.MethInfo * TypedTree.TType list - val prettyLayoutOfMethInfoFreeStyle: + val prettyLayoutOfMethInfoFreeStyle : amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> @@ -1049,75 +26125,75 @@ namespace FSharp.Compiler methInfo:Infos.MethInfo -> TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfPropInfoFreeStyle: + val prettyLayoutOfPropInfoFreeStyle : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> pinfo:Infos.PropInfo -> Internal.Utilities.StructuredFormat.Layout - val formatMethInfoToBufferFreeStyle: + val formatMethInfoToBufferFreeStyle : amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> os:System.Text.StringBuilder -> minfo:Infos.MethInfo -> unit - val layoutMethInfoFSharpStyle: + val layoutMethInfoFSharpStyle : amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> minfo:Infos.MethInfo -> Internal.Utilities.StructuredFormat.Layout - - module private TastDefinitionPrinting = - val layoutExtensionMember: + end + module private TastDefinitionPrinting = begin + val layoutExtensionMember : denv:TypedTreeOps.DisplayEnv -> v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val layoutExtensionMembers: + val layoutExtensionMembers : denv:TypedTreeOps.DisplayEnv -> vs:TypedTree.Val list -> Internal.Utilities.StructuredFormat.Layout - val layoutRecdField: + val layoutRecdField : addAccess:bool -> denv:TypedTreeOps.DisplayEnv -> fld:TypedTree.RecdField -> Internal.Utilities.StructuredFormat.Layout - val layoutUnionOrExceptionField: + val layoutUnionOrExceptionField : denv:TypedTreeOps.DisplayEnv -> isGenerated:('a -> TypedTree.RecdField -> bool) -> i:'a -> fld:TypedTree.RecdField -> Internal.Utilities.StructuredFormat.Layout - val isGeneratedUnionCaseField: pos:int -> f:TypedTree.RecdField -> bool - val isGeneratedExceptionField: pos:'a -> f:TypedTree.RecdField -> bool - val layoutUnionCaseFields: + val isGeneratedUnionCaseField : pos:int -> f:TypedTree.RecdField -> bool + val isGeneratedExceptionField : pos:'a -> f:TypedTree.RecdField -> bool + val layoutUnionCaseFields : denv:TypedTreeOps.DisplayEnv -> isUnionCase:bool -> fields:TypedTree.RecdField list -> Internal.Utilities.StructuredFormat.Layout - val layoutUnionCase: + val layoutUnionCase : denv:TypedTreeOps.DisplayEnv -> prefixL:Internal.Utilities.StructuredFormat.Layout -> ucase:TypedTree.UnionCase -> Internal.Utilities.StructuredFormat.Layout - val layoutUnionCases: + val layoutUnionCases : denv:TypedTreeOps.DisplayEnv -> ucases:TypedTree.UnionCase list -> Internal.Utilities.StructuredFormat.Layout list - val breakTypeDefnEqn: repr:TypedTree.TyconRepresentation -> bool - val layoutILFieldInfo: + val breakTypeDefnEqn : repr:TypedTree.TyconRepresentation -> bool + val layoutILFieldInfo : denv:TypedTreeOps.DisplayEnv -> amap:Import.ImportMap -> m:Range.range -> e:Infos.ILFieldInfo -> Internal.Utilities.StructuredFormat.Layout - val layoutEventInfo: + val layoutEventInfo : denv:TypedTreeOps.DisplayEnv -> amap:Import.ImportMap -> m:Range.range -> e:Infos.EventInfo -> Internal.Utilities.StructuredFormat.Layout - val layoutPropInfo: + val layoutPropInfo : denv:TypedTreeOps.DisplayEnv -> amap:Import.ImportMap -> m:Range.range -> p:Infos.PropInfo -> Internal.Utilities.StructuredFormat.Layout - val layoutTycon: + val layoutTycon : denv:TypedTreeOps.DisplayEnv -> infoReader:InfoReader.InfoReader -> ad:AccessibilityLogic.AccessorDomain -> @@ -1126,19 +26202,19 @@ namespace FSharp.Compiler typewordL:Internal.Utilities.StructuredFormat.Layout -> tycon:TypedTree.Tycon -> Internal.Utilities.StructuredFormat.Layout - val layoutExnDefn: + val layoutExnDefn : denv:TypedTreeOps.DisplayEnv -> exnc:TypedTree.Entity -> Internal.Utilities.StructuredFormat.Layout - val layoutTyconDefns: + val layoutTyconDefns : denv:TypedTreeOps.DisplayEnv -> infoReader:InfoReader.InfoReader -> ad:AccessibilityLogic.AccessorDomain -> m:Range.range -> tycons:TypedTree.Tycon list -> Internal.Utilities.StructuredFormat.Layout - - module private InferredSigPrinting = - val layoutInferredSigOfModuleExpr: + end + module private InferredSigPrinting = begin + val layoutInferredSigOfModuleExpr : showHeader:bool -> denv:TypedTreeOps.DisplayEnv -> infoReader:InfoReader.InfoReader -> @@ -1146,46 +26222,46 @@ namespace FSharp.Compiler m:Range.range -> expr:TypedTree.ModuleOrNamespaceExprWithSig -> Internal.Utilities.StructuredFormat.Layout - - module private PrintData = - val dataExprL: + end + module private PrintData = begin + val dataExprL : denv:TypedTreeOps.DisplayEnv -> expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val dataExprWrapL: + val dataExprWrapL : denv:TypedTreeOps.DisplayEnv -> isAtomic:bool -> expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val dataExprsL: + val dataExprsL : denv:TypedTreeOps.DisplayEnv -> xs:TypedTree.Exprs -> Internal.Utilities.StructuredFormat.Layout list - - val dataExprL: + end + val dataExprL : denv:TypedTreeOps.DisplayEnv -> expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val outputValOrMember: + val outputValOrMember : denv:TypedTreeOps.DisplayEnv -> os:System.Text.StringBuilder -> x:TypedTree.Val -> unit - val stringValOrMember: + val stringValOrMember : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.Val -> string - val layoutQualifiedValOrMember: + val layoutQualifiedValOrMember : denv:TypedTreeOps.DisplayEnv -> typarInst:TypedTreeOps.TyparInst -> v:TypedTree.Val -> TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout - val outputQualifiedValOrMember: + val outputQualifiedValOrMember : denv:TypedTreeOps.DisplayEnv -> os:System.Text.StringBuilder -> v:TypedTree.Val -> unit - val outputQualifiedValSpec: + val outputQualifiedValSpec : denv:TypedTreeOps.DisplayEnv -> os:System.Text.StringBuilder -> v:TypedTree.Val -> unit - val stringOfQualifiedValOrMember: + val stringOfQualifiedValOrMember : denv:TypedTreeOps.DisplayEnv -> v:TypedTree.Val -> string - val formatMethInfoToBufferFreeStyle: + val formatMethInfoToBufferFreeStyle : amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> buf:System.Text.StringBuilder -> d:Infos.MethInfo -> unit - val prettyLayoutOfMethInfoFreeStyle: + val prettyLayoutOfMethInfoFreeStyle : amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> @@ -1193,76 +26269,64 @@ namespace FSharp.Compiler minfo:Infos.MethInfo -> TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfPropInfoFreeStyle: + val prettyLayoutOfPropInfoFreeStyle : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> d:Infos.PropInfo -> Internal.Utilities.StructuredFormat.Layout - val stringOfMethInfo: + val stringOfMethInfo : amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> d:Infos.MethInfo -> string - val stringOfParamData: + val stringOfParamData : denv:TypedTreeOps.DisplayEnv -> paramData:Infos.ParamData -> string - val layoutOfParamData: + val layoutOfParamData : denv:TypedTreeOps.DisplayEnv -> paramData:Infos.ParamData -> Internal.Utilities.StructuredFormat.Layout - val outputExnDef: - denv:TypedTreeOps.DisplayEnv -> - os:System.Text.StringBuilder -> x:TypedTree.Entity -> unit - val layoutExnDef: + val layoutExnDef : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.Entity -> Internal.Utilities.StructuredFormat.Layout - val stringOfTyparConstraints: + val stringOfTyparConstraints : denv:TypedTreeOps.DisplayEnv -> x:(TypedTree.Typar * TypedTree.TyparConstraint) list -> string - val outputTycon: - denv:TypedTreeOps.DisplayEnv -> - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - os:System.Text.StringBuilder -> x:TypedTree.Tycon -> unit - val layoutTycon: + val layoutTycon : denv:TypedTreeOps.DisplayEnv -> infoReader:InfoReader.InfoReader -> ad:AccessibilityLogic.AccessorDomain -> m:Range.range -> x:TypedTree.Tycon -> Internal.Utilities.StructuredFormat.Layout - val layoutUnionCases: + val layoutUnionCases : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.RecdField list -> Internal.Utilities.StructuredFormat.Layout - val outputUnionCases: - denv:TypedTreeOps.DisplayEnv -> - os:System.Text.StringBuilder -> x:TypedTree.RecdField list -> unit - val isGeneratedUnionCaseField: pos:int -> f:TypedTree.RecdField -> bool - val isGeneratedExceptionField: pos:'a -> f:TypedTree.RecdField -> bool - val stringOfTyparConstraint: + val isGeneratedUnionCaseField : pos:int -> f:TypedTree.RecdField -> bool + val isGeneratedExceptionField : pos:'a -> f:TypedTree.RecdField -> bool + val stringOfTyparConstraint : denv:TypedTreeOps.DisplayEnv -> TypedTree.Typar * TypedTree.TyparConstraint -> string - val stringOfTy: denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> string - val prettyLayoutOfType: + val stringOfTy : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> string + val prettyLayoutOfType : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfTypeNoCx: + val prettyLayoutOfTypeNoCx : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val prettyStringOfTy: + val prettyStringOfTy : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> string - val prettyStringOfTyNoCx: + val prettyStringOfTyNoCx : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> string - val stringOfRecdField: + val stringOfRecdField : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.RecdField -> string - val stringOfUnionCase: + val stringOfUnionCase : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.UnionCase -> string - val stringOfExnDef: + val stringOfExnDef : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.Entity -> string - val stringOfFSAttrib: + val stringOfFSAttrib : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.Attrib -> string - val stringOfILAttrib: + val stringOfILAttrib : denv:TypedTreeOps.DisplayEnv -> AbstractIL.IL.ILType * AbstractIL.IL.ILAttribElem list -> string - val layoutInferredSigOfModuleExpr: + val layoutInferredSigOfModuleExpr : showHeader:bool -> denv:TypedTreeOps.DisplayEnv -> infoReader:InfoReader.InfoReader -> @@ -1270,189 +26334,189 @@ namespace FSharp.Compiler m:Range.range -> expr:TypedTree.ModuleOrNamespaceExprWithSig -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfValOrMember: + val prettyLayoutOfValOrMember : denv:TypedTreeOps.DisplayEnv -> typarInst:TypedTreeOps.TyparInst -> v:TypedTree.Val -> TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfValOrMemberNoInst: + val prettyLayoutOfValOrMemberNoInst : denv:TypedTreeOps.DisplayEnv -> v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMemberNoInstShort: + val prettyLayoutOfMemberNoInstShort : denv:TypedTreeOps.DisplayEnv -> v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfInstAndSig: + val prettyLayoutOfInstAndSig : denv:TypedTreeOps.DisplayEnv -> TypedTreeOps.TyparInst * TypedTree.TTypes * TypedTree.TType -> TypedTreeOps.TyparInst * (TypedTree.TTypes * TypedTree.TType) * (Internal.Utilities.StructuredFormat.Layout list * Internal.Utilities.StructuredFormat.Layout) * Internal.Utilities.StructuredFormat.Layout - val minimalStringsOfTwoTypes: + val minimalStringsOfTwoTypes : denv:TypedTreeOps.DisplayEnv -> t1:TypedTree.TType -> t2:TypedTree.TType -> string * string * string - val minimalStringsOfTwoValues: + val minimalStringsOfTwoValues : denv:TypedTreeOps.DisplayEnv -> v1:TypedTree.Val -> v2:TypedTree.Val -> string * string - val minimalStringOfType: + val minimalStringOfType : denv:TypedTreeOps.DisplayEnv -> ty:TypedTree.TType -> string - + end namespace FSharp.Compiler - module internal AugmentWithHashCompare = - val mkIComparableCompareToSlotSig: + module internal AugmentWithHashCompare = begin + val mkIComparableCompareToSlotSig : g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkGenericIComparableCompareToSlotSig: + val mkGenericIComparableCompareToSlotSig : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.SlotSig - val mkIStructuralComparableCompareToSlotSig: + val mkIStructuralComparableCompareToSlotSig : g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkGenericIEquatableEqualsSlotSig: + val mkGenericIEquatableEqualsSlotSig : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.SlotSig - val mkIStructuralEquatableEqualsSlotSig: + val mkIStructuralEquatableEqualsSlotSig : g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkIStructuralEquatableGetHashCodeSlotSig: + val mkIStructuralEquatableGetHashCodeSlotSig : g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkGetHashCodeSlotSig: g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkEqualsSlotSig: g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkThisTy: + val mkGetHashCodeSlotSig : g:TcGlobals.TcGlobals -> TypedTree.SlotSig + val mkEqualsSlotSig : g:TcGlobals.TcGlobals -> TypedTree.SlotSig + val mkThisTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkCompareObjTy: + val mkCompareObjTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkCompareTy: + val mkCompareTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkCompareWithComparerTy: + val mkCompareWithComparerTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkEqualsObjTy: + val mkEqualsObjTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkEqualsTy: + val mkEqualsTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkEqualsWithComparerTy: + val mkEqualsWithComparerTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkHashTy: + val mkHashTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkHashWithComparerTy: + val mkHashWithComparerTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkRelBinOp: + val mkRelBinOp : g:TcGlobals.TcGlobals -> op:AbstractIL.IL.ILInstr -> m:Range.range -> e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkClt: + val mkClt : g:TcGlobals.TcGlobals -> m:Range.range -> e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkCgt: + val mkCgt : g:TcGlobals.TcGlobals -> m:Range.range -> e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkILLangPrimTy: g:TcGlobals.TcGlobals -> AbstractIL.IL.ILType - val mkILCallGetComparer: + val mkILLangPrimTy : g:TcGlobals.TcGlobals -> AbstractIL.IL.ILType + val mkILCallGetComparer : g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.Expr - val mkILCallGetEqualityComparer: + val mkILCallGetEqualityComparer : g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.Expr - val mkThisVar: + val mkThisVar : g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val mkShl: + val mkShl : g:TcGlobals.TcGlobals -> m:Range.range -> acce:TypedTree.Expr -> n:int -> TypedTree.Expr - val mkShr: + val mkShr : g:TcGlobals.TcGlobals -> m:Range.range -> acce:TypedTree.Expr -> n:int -> TypedTree.Expr - val mkAdd: + val mkAdd : g:TcGlobals.TcGlobals -> m:Range.range -> e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkAddToHashAcc: + val mkAddToHashAcc : g:TcGlobals.TcGlobals -> m:Range.range -> e:TypedTree.Expr -> accv:TypedTree.ValRef -> acce:TypedTree.Expr -> TypedTree.Expr - val mkCombineHashGenerators: + val mkCombineHashGenerators : g:TcGlobals.TcGlobals -> m:Range.range -> exprs:TypedTree.Expr list -> accv:TypedTree.ValRef -> acce:TypedTree.Expr -> TypedTree.Expr - val mkThatAddrLocal: + val mkThatAddrLocal : g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val mkThatAddrLocalIfNeeded: + val mkThatAddrLocalIfNeeded : g:TcGlobals.TcGlobals -> m:Range.range -> tcve:TypedTree.Expr -> ty:TypedTree.TType -> TypedTree.Val option * TypedTree.Expr - val mkThisVarThatVar: + val mkThisVarThatVar : g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Val * TypedTree.Expr * TypedTree.Expr - val mkThatVarBind: + val mkThatVarBind : g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType -> thataddrv:TypedTree.Val -> expr:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr - val mkBindThatAddr: + val mkBindThatAddr : g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType -> thataddrv:TypedTree.Val -> thatv:TypedTree.Val -> thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val mkBindThatAddrIfNeeded: + val mkBindThatAddrIfNeeded : m:Range.range -> thataddrvOpt:TypedTree.Val option -> thatv:TypedTree.Val -> expr:TypedTree.Expr -> TypedTree.Expr - val mkDerefThis: + val mkDerefThis : g:TcGlobals.TcGlobals -> m:Range.range -> thisv:TypedTree.Val -> thise:TypedTree.Expr -> TypedTree.Expr - val mkCompareTestConjuncts: + val mkCompareTestConjuncts : g:TcGlobals.TcGlobals -> m:Range.range -> exprs:TypedTree.Expr list -> TypedTree.Expr - val mkEqualsTestConjuncts: + val mkEqualsTestConjuncts : g:TcGlobals.TcGlobals -> m:Range.range -> exprs:TypedTree.Expr list -> TypedTree.Expr - val mkMinimalTy: + val mkMinimalTy : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> TypedTree.TType list * TypedTree.TType - val mkBindNullComparison: + val mkBindNullComparison : g:TcGlobals.TcGlobals -> m:Range.range -> thise:TypedTree.Expr -> thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val mkBindThisNullEquals: + val mkBindThisNullEquals : g:TcGlobals.TcGlobals -> m:Range.range -> thise:TypedTree.Expr -> thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val mkBindThatNullEquals: + val mkBindThatNullEquals : g:TcGlobals.TcGlobals -> m:Range.range -> thise:TypedTree.Expr -> thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val mkBindNullHash: + val mkBindNullHash : g:TcGlobals.TcGlobals -> m:Range.range -> thise:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val mkRecdCompare: + val mkRecdCompare : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> tycon:TypedTree.Tycon -> TypedTree.Val * TypedTree.Val * TypedTree.Expr - val mkRecdCompareWithComparer: + val mkRecdCompareWithComparer : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> tycon:TypedTree.Tycon -> _thisv:'a * thise:TypedTree.Expr -> 'b * thate:TypedTree.Expr -> compe:TypedTree.Expr -> TypedTree.Expr - val mkRecdEquality: + val mkRecdEquality : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> tycon:TypedTree.Tycon -> TypedTree.Val * TypedTree.Val * TypedTree.Expr - val mkRecdEqualityWithComparer: + val mkRecdEqualityWithComparer : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> tycon:TypedTree.Tycon -> @@ -1460,11 +26524,11 @@ namespace FSharp.Compiler thatobje:TypedTree.Expr -> thatv:TypedTree.Val * thate:TypedTree.Expr -> compe:TypedTree.Expr -> TypedTree.Expr - val mkExnEquality: + val mkExnEquality : g:TcGlobals.TcGlobals -> exnref:TypedTree.TyconRef -> exnc:TypedTree.Tycon -> TypedTree.Val * TypedTree.Val * TypedTree.Expr - val mkExnEqualityWithComparer: + val mkExnEqualityWithComparer : g:TcGlobals.TcGlobals -> exnref:TypedTree.TyconRef -> exnc:TypedTree.Tycon -> @@ -1472,24 +26536,24 @@ namespace FSharp.Compiler thatobje:TypedTree.Expr -> thatv:TypedTree.Val * thate:TypedTree.Expr -> compe:TypedTree.Expr -> TypedTree.Expr - val mkUnionCompare: + val mkUnionCompare : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> tycon:TypedTree.Tycon -> TypedTree.Val * TypedTree.Val * TypedTree.Expr - val mkUnionCompareWithComparer: + val mkUnionCompareWithComparer : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> tycon:TypedTree.Tycon -> _thisv:'a * thise:TypedTree.Expr -> _thatobjv:'b * thatcaste:TypedTree.Expr -> compe:TypedTree.Expr -> TypedTree.Expr - val mkUnionEquality: + val mkUnionEquality : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> tycon:TypedTree.Tycon -> TypedTree.Val * TypedTree.Val * TypedTree.Expr - val mkUnionEqualityWithComparer: + val mkUnionEqualityWithComparer : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> tycon:TypedTree.Tycon -> @@ -1497,46 +26561,46 @@ namespace FSharp.Compiler thatobje:TypedTree.Expr -> thatv:TypedTree.Val * thate:TypedTree.Expr -> compe:TypedTree.Expr -> TypedTree.Expr - val mkRecdHashWithComparer: + val mkRecdHashWithComparer : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> tycon:TypedTree.Tycon -> compe:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr - val mkExnHashWithComparer: + val mkExnHashWithComparer : g:TcGlobals.TcGlobals -> exnref:TypedTree.TyconRef -> exnc:TypedTree.Tycon -> compe:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr - val mkUnionHashWithComparer: + val mkUnionHashWithComparer : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> tycon:TypedTree.Tycon -> compe:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr - val isNominalExnc: exnc:TypedTree.Tycon -> bool - val isTrueFSharpStructTycon: _g:'a -> tycon:TypedTree.Tycon -> bool - val canBeAugmentedWithEquals: g:'a -> tycon:TypedTree.Tycon -> bool - val canBeAugmentedWithCompare: g:'a -> tycon:TypedTree.Tycon -> bool - val getAugmentationAttribs: + val isNominalExnc : exnc:TypedTree.Tycon -> bool + val isTrueFSharpStructTycon : _g:'a -> tycon:TypedTree.Tycon -> bool + val canBeAugmentedWithEquals : g:'a -> tycon:TypedTree.Tycon -> bool + val canBeAugmentedWithCompare : g:'a -> tycon:TypedTree.Tycon -> bool + val getAugmentationAttribs : g:TcGlobals.TcGlobals -> tycon:TypedTree.Tycon -> bool * bool * bool option * bool option * bool option * bool option * bool option * bool option * bool option - val CheckAugmentationAttribs: + val CheckAugmentationAttribs : bool -> TcGlobals.TcGlobals -> Import.ImportMap -> TypedTree.Tycon -> unit - val TyconIsCandidateForAugmentationWithCompare: + val TyconIsCandidateForAugmentationWithCompare : TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val TyconIsCandidateForAugmentationWithEquals: + val TyconIsCandidateForAugmentationWithEquals : TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val TyconIsCandidateForAugmentationWithHash: + val TyconIsCandidateForAugmentationWithHash : TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val slotImplMethod: + val slotImplMethod : final:bool * c:TypedTree.TyconRef * slotsig:TypedTree.SlotSig -> TypedTree.ValMemberInfo - val nonVirtualMethod: c:TypedTree.TyconRef -> TypedTree.ValMemberInfo - val unitArg: TypedTree.ArgReprInfo list list - val unaryArg: TypedTree.ArgReprInfo list list - val tupArg: TypedTree.ArgReprInfo list list - val mkValSpec: + val nonVirtualMethod : c:TypedTree.TyconRef -> TypedTree.ValMemberInfo + val unitArg : TypedTree.ArgReprInfo list list + val unaryArg : TypedTree.ArgReprInfo list list + val tupArg : TypedTree.ArgReprInfo list list + val mkValSpec : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> tmty:TypedTree.TType -> @@ -1545,76 +26609,76 @@ namespace FSharp.Compiler methn:string -> ty:TypedTree.TType -> argData:TypedTree.ArgReprInfo list list -> TypedTree.Val - val MakeValsForCompareAugmentation: + val MakeValsForCompareAugmentation : TcGlobals.TcGlobals -> TypedTree.TyconRef -> TypedTree.Val * TypedTree.Val - val MakeValsForCompareWithComparerAugmentation: + val MakeValsForCompareWithComparerAugmentation : TcGlobals.TcGlobals -> TypedTree.TyconRef -> TypedTree.Val - val MakeValsForEqualsAugmentation: + val MakeValsForEqualsAugmentation : TcGlobals.TcGlobals -> TypedTree.TyconRef -> TypedTree.Val * TypedTree.Val - val MakeValsForEqualityWithComparerAugmentation: + val MakeValsForEqualityWithComparerAugmentation : TcGlobals.TcGlobals -> TypedTree.TyconRef -> TypedTree.Val * TypedTree.Val * TypedTree.Val - val MakeBindingsForCompareAugmentation: + val MakeBindingsForCompareAugmentation : TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list - val MakeBindingsForCompareWithComparerAugmentation: + val MakeBindingsForCompareWithComparerAugmentation : TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list - val MakeBindingsForEqualityWithComparerAugmentation: + val MakeBindingsForEqualityWithComparerAugmentation : TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list - val MakeBindingsForEqualsAugmentation: + val MakeBindingsForEqualsAugmentation : TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list - val TypeDefinitelyHasEquality: + val TypeDefinitelyHasEquality : TcGlobals.TcGlobals -> TypedTree.TType -> bool - + end namespace FSharp.Compiler - module internal NameResolution = + module internal NameResolution = begin type NameResolver = - - new: g:TcGlobals.TcGlobals * amap:Import.ImportMap * + class + new : g:TcGlobals.TcGlobals * amap:Import.ImportMap * infoReader:InfoReader.InfoReader * instantiationGenerator:(Range.range -> TypedTree.Typars -> TypedTree.TypeInst) -> NameResolver - member InfoReader: InfoReader.InfoReader + member InfoReader : InfoReader.InfoReader member - InstantiationGenerator: (Range.range -> TypedTree.Typars -> + InstantiationGenerator : (Range.range -> TypedTree.Typars -> TypedTree.TypeInst) - member amap: Import.ImportMap - member g: TcGlobals.TcGlobals - member languageSupportsNameOf: bool - - val UnionCaseRefsInTycon: + member amap : Import.ImportMap + member g : TcGlobals.TcGlobals + member languageSupportsNameOf : bool + end + val UnionCaseRefsInTycon : modref:TypedTree.ModuleOrNamespaceRef -> tycon:TypedTree.Tycon -> TypedTree.UnionCaseRef list - val UnionCaseRefsInModuleOrNamespace: + val UnionCaseRefsInModuleOrNamespace : modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.UnionCaseRef list - val TryFindTypeWithUnionCase: + val TryFindTypeWithUnionCase : modref:TypedTree.ModuleOrNamespaceRef -> id:SyntaxTree.Ident -> TypedTree.Entity option - val TryFindTypeWithRecdField: + val TryFindTypeWithRecdField : modref:TypedTree.ModuleOrNamespaceRef -> id:SyntaxTree.Ident -> TypedTree.Entity option - val ActivePatternElemsOfValRef: + val ActivePatternElemsOfValRef : vref:TypedTree.ValRef -> TypedTree.ActivePatternElemRef list - val TryMkValRefInModRef: + val TryMkValRefInModRef : modref:TypedTree.EntityRef -> vspec:TypedTree.Val -> TypedTree.ValRef option - val ActivePatternElemsOfVal: + val ActivePatternElemsOfVal : modref:TypedTree.EntityRef -> vspec:TypedTree.Val -> TypedTree.ActivePatternElemRef list - val ActivePatternElemsOfModuleOrNamespace: + val ActivePatternElemsOfModuleOrNamespace : TypedTree.ModuleOrNamespaceRef -> AbstractIL.Internal.Library.NameMap - val ( |AbbrevOrAppTy|_| ): TypedTree.TType -> TypedTree.TyconRef option - [] + val ( |AbbrevOrAppTy|_| ) : TypedTree.TType -> TypedTree.TyconRef option + [] type ArgumentContainer = | Method of Infos.MethInfo | Type of TypedTree.TyconRef - val emptyTypeInst: TypedTree.TypeInst + val emptyTypeInst : TypedTree.TypeInst type EnclosingTypeInst = TypedTree.TypeInst - val emptyEnclosingTypeInst: EnclosingTypeInst - [] + val emptyEnclosingTypeInst : EnclosingTypeInst + [] type Item = | Value of TypedTree.ValRef | UnionCase of Infos.UnionCaseInfo * hasRequireQualifiedAccessAttr: bool @@ -1648,18 +26712,18 @@ namespace FSharp.Compiler | UnqualifiedType of TypedTree.TyconRef list with static member - MakeCtorGroup: nm:string * minfos:Infos.MethInfo list -> Item + MakeCtorGroup : nm:string * minfos:Infos.MethInfo list -> Item static member - MakeMethGroup: nm:string * minfos:Infos.MethInfo list -> Item - member DisplayName: string - - val valRefHash: vref:TypedTree.ValRef -> int - [] + MakeMethGroup : nm:string * minfos:Infos.MethInfo list -> Item + member DisplayName : string + end + val valRefHash : vref:TypedTree.ValRef -> int + [] type ItemWithInst = { Item: Item TyparInst: TypedTreeOps.TyparInst } - val ItemWithNoInst: Item -> ItemWithInst - val ( |ItemWithInst| ): ItemWithInst -> Item * TypedTreeOps.TyparInst + val ItemWithNoInst : Item -> ItemWithInst + val ( |ItemWithInst| ) : ItemWithInst -> Item * TypedTreeOps.TyparInst type FieldResolution = | FieldResolution of Infos.RecdFieldInfo * bool type ExtensionMember = | FSExtMem of TypedTree.ValRef * Infos.ExtensionMethodPriority @@ -1667,19 +26731,19 @@ namespace FSharp.Compiler TypedTree.TyconRef * Infos.MethInfo * Infos.ExtensionMethodPriority with static member - Comparer: g:TcGlobals.TcGlobals -> + Comparer : g:TcGlobals.TcGlobals -> System.Collections.Generic.IEqualityComparer static member - Equality: g:TcGlobals.TcGlobals -> + Equality : g:TcGlobals.TcGlobals -> e1:ExtensionMember -> e2:ExtensionMember -> bool - static member Hash: e1:ExtensionMember -> int - member Priority: Infos.ExtensionMethodPriority - + static member Hash : e1:ExtensionMember -> int + member Priority : Infos.ExtensionMethodPriority + end type FullyQualifiedFlag = | FullyQualified | OpenQualified type UnqualifiedItems = AbstractIL.Internal.Library.LayeredMap - [] + [] type NameResolutionEnv = { eDisplayEnv: TypedTreeOps.DisplayEnv eUnqualifiedItems: UnqualifiedItems @@ -1708,59 +26772,59 @@ namespace FSharp.Compiler eUnindexedExtensionMembers: ExtensionMember list eTypars: AbstractIL.Internal.Library.NameMap } with - static member Empty: g:TcGlobals.TcGlobals -> NameResolutionEnv - member FindUnqualifiedItem: string -> Item + static member Empty : g:TcGlobals.TcGlobals -> NameResolutionEnv + member FindUnqualifiedItem : string -> Item member - ModulesAndNamespaces: fq:FullyQualifiedFlag -> + ModulesAndNamespaces : fq:FullyQualifiedFlag -> AbstractIL.Internal.Library.NameMultiMap member - TyconsByAccessNames: fq:FullyQualifiedFlag -> + TyconsByAccessNames : fq:FullyQualifiedFlag -> AbstractIL.Internal.Library.LayeredMultiMap member - TyconsByDemangledNameAndArity: fq:FullyQualifiedFlag -> + TyconsByDemangledNameAndArity : fq:FullyQualifiedFlag -> AbstractIL.Internal.Library.LayeredMap - member DisplayEnv: TypedTreeOps.DisplayEnv - - [] + member DisplayEnv : TypedTreeOps.DisplayEnv + end + [] type ResultCollectionSettings = | AllResults | AtMostOneResult - val NextExtensionMethodPriority: unit -> uint64 - val IsTyconRefUsedForCSharpStyleExtensionMembers: + val NextExtensionMethodPriority : unit -> uint64 + val IsTyconRefUsedForCSharpStyleExtensionMembers : g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool - val IsTypeUsedForCSharpStyleExtensionMembers: + val IsTypeUsedForCSharpStyleExtensionMembers : g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType -> bool - val IsMethInfoPlainCSharpStyleExtensionMember: + val IsMethInfoPlainCSharpStyleExtensionMember : g:TcGlobals.TcGlobals -> m:Range.range -> isEnclExtTy:bool -> minfo:Infos.MethInfo -> bool - val private GetCSharpStyleIndexedExtensionMembersForTyconRef: + val private GetCSharpStyleIndexedExtensionMembersForTyconRef : amap:Import.ImportMap -> m:Range.range -> tcrefOfStaticClass:TypedTree.TyconRef -> Choice<(TypedTree.TyconRef * ExtensionMember),ExtensionMember> list - val IntrinsicPropInfosOfTypeInScope: + val IntrinsicPropInfosOfTypeInScope : infoReader:InfoReader.InfoReader -> optFilter:string option -> ad:AccessibilityLogic.AccessorDomain -> findFlag:InfoReader.FindMemberFlag -> m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list - val SelectPropInfosFromExtMembers: + val SelectPropInfosFromExtMembers : infoReader:InfoReader.InfoReader -> ad:AccessibilityLogic.AccessorDomain -> optFilter:string option -> declaringTy:TypedTree.TType -> m:Range.range -> extMemInfos:seq -> Infos.PropInfo list - val ExtensionPropInfosOfTypeInScope: + val ExtensionPropInfosOfTypeInScope : ResultCollectionSettings -> InfoReader.InfoReader -> NameResolutionEnv -> string option -> AccessibilityLogic.AccessorDomain -> Range.range -> TypedTree.TType -> Infos.PropInfo list - val AllPropInfosOfTypeInScope: + val AllPropInfosOfTypeInScope : ResultCollectionSettings -> InfoReader.InfoReader -> NameResolutionEnv -> @@ -1768,32 +26832,32 @@ namespace FSharp.Compiler AccessibilityLogic.AccessorDomain -> InfoReader.FindMemberFlag -> Range.range -> TypedTree.TType -> Infos.PropInfo list - val IntrinsicMethInfosOfType: + val IntrinsicMethInfosOfType : infoReader:InfoReader.InfoReader -> optFilter:string option -> ad:AccessibilityLogic.AccessorDomain -> allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> findFlag:InfoReader.FindMemberFlag -> m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list - val TrySelectExtensionMethInfoOfILExtMem: + val TrySelectExtensionMethInfoOfILExtMem : Range.range -> Import.ImportMap -> TypedTree.TType -> TypedTree.TyconRef * Infos.MethInfo * Infos.ExtensionMethodPriority -> Infos.MethInfo option - val SelectMethInfosFromExtMembers: + val SelectMethInfosFromExtMembers : infoReader:InfoReader.InfoReader -> optFilter:string option -> apparentTy:TypedTree.TType -> m:Range.range -> extMemInfos:seq -> Infos.MethInfo list - val ExtensionMethInfosOfTypeInScope: + val ExtensionMethInfosOfTypeInScope : collectionSettings:ResultCollectionSettings -> infoReader:InfoReader.InfoReader -> nenv:NameResolutionEnv -> optFilter:string option -> m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list - val AllMethInfosOfTypeInScope: + val AllMethInfosOfTypeInScope : ResultCollectionSettings -> InfoReader.InfoReader -> NameResolutionEnv -> @@ -1801,180 +26865,180 @@ namespace FSharp.Compiler AccessibilityLogic.AccessorDomain -> InfoReader.FindMemberFlag -> Range.range -> TypedTree.TType -> Infos.MethInfo list - [] + [] type BulkAdd = | Yes | No - val AddValRefsToItems: + val AddValRefsToItems : bulkAddMode:BulkAdd -> eUnqualifiedItems:UnqualifiedItems -> vrefs:TypedTree.ValRef [] -> UnqualifiedItems - val AddValRefToExtensionMembers: + val AddValRefToExtensionMembers : pri:Infos.ExtensionMethodPriority -> eIndexedExtensionMembers:TypedTreeOps.TyconRefMultiMap -> vref:TypedTree.ValRef -> TypedTreeOps.TyconRefMultiMap - val AddFakeNamedValRefToNameEnv: + val AddFakeNamedValRefToNameEnv : string -> NameResolutionEnv -> TypedTree.ValRef -> NameResolutionEnv - val AddFakeNameToNameEnv: + val AddFakeNameToNameEnv : string -> NameResolutionEnv -> Item -> NameResolutionEnv - val AddValRefsToActivePatternsNameEnv: + val AddValRefsToActivePatternsNameEnv : ePatItems:Map -> vref:TypedTree.ValRef -> Map - val AddValRefsToNameEnvWithPriority: + val AddValRefsToNameEnvWithPriority : bulkAddMode:BulkAdd -> pri:Infos.ExtensionMethodPriority -> nenv:NameResolutionEnv -> vrefs:TypedTree.ValRef [] -> NameResolutionEnv - val AddValRefToNameEnv: + val AddValRefToNameEnv : NameResolutionEnv -> TypedTree.ValRef -> NameResolutionEnv - val AddActivePatternResultTagsToNameEnv: + val AddActivePatternResultTagsToNameEnv : PrettyNaming.ActivePatternInfo -> NameResolutionEnv -> TypedTree.TType -> Range.range -> NameResolutionEnv - val GeneralizeUnionCaseRef: + val GeneralizeUnionCaseRef : ucref:TypedTree.UnionCaseRef -> Infos.UnionCaseInfo - val AddTyconsByDemangledNameAndArity: + val AddTyconsByDemangledNameAndArity : bulkAddMode:BulkAdd -> tcrefs:TypedTree.TyconRef [] -> tab:AbstractIL.Internal.Library.LayeredMap -> AbstractIL.Internal.Library.LayeredMap - val AddTyconByAccessNames: + val AddTyconByAccessNames : bulkAddMode:BulkAdd -> tcrefs:TypedTree.TyconRef [] -> tab:AbstractIL.Internal.Library.LayeredMultiMap -> AbstractIL.Internal.Library.LayeredMultiMap - val AddRecdField: + val AddRecdField : rfref:TypedTree.RecdFieldRef -> tab:AbstractIL.Internal.Library.NameMultiMap -> Map - val AddUnionCases1: + val AddUnionCases1 : tab:Map -> ucrefs:TypedTree.UnionCaseRef list -> Map - val AddUnionCases2: + val AddUnionCases2 : bulkAddMode:BulkAdd -> eUnqualifiedItems:UnqualifiedItems -> ucrefs:TypedTree.UnionCaseRef list -> Map type TypeNameResolutionFlag = | ResolveTypeNamesToCtors | ResolveTypeNamesToTypeRefs - [] + [] type TypeNameResolutionStaticArgsInfo = | Indefinite | Definite of int with static member - FromTyArgs: numTyArgs:int -> TypeNameResolutionStaticArgsInfo - member MangledNameForType: nm:string -> string - member HasNoStaticArgsInfo: bool - member NumStaticArgs: int - static member DefiniteEmpty: TypeNameResolutionStaticArgsInfo - - [] + FromTyArgs : numTyArgs:int -> TypeNameResolutionStaticArgsInfo + member MangledNameForType : nm:string -> string + member HasNoStaticArgsInfo : bool + member NumStaticArgs : int + static member DefiniteEmpty : TypeNameResolutionStaticArgsInfo + end + [] type TypeNameResolutionInfo = | TypeNameResolutionInfo of TypeNameResolutionFlag * TypeNameResolutionStaticArgsInfo with static member - ResolveToTypeRefs: TypeNameResolutionStaticArgsInfo -> + ResolveToTypeRefs : TypeNameResolutionStaticArgsInfo -> TypeNameResolutionInfo - member DropStaticArgsInfo: TypeNameResolutionInfo - member ResolutionFlag: TypeNameResolutionFlag - member StaticArgsInfo: TypeNameResolutionStaticArgsInfo - static member Default: TypeNameResolutionInfo - - [] + member DropStaticArgsInfo : TypeNameResolutionInfo + member ResolutionFlag : TypeNameResolutionFlag + member StaticArgsInfo : TypeNameResolutionStaticArgsInfo + static member Default : TypeNameResolutionInfo + end + [] type PermitDirectReferenceToGeneratedType = | Yes | No - val CheckForDirectReferenceToGeneratedType: + val CheckForDirectReferenceToGeneratedType : tcref:TypedTree.TyconRef * genOk:PermitDirectReferenceToGeneratedType * m:Range.range -> unit - val AddEntityForProvidedType: + val AddEntityForProvidedType : amap:Import.ImportMap * modref:TypedTree.ModuleOrNamespaceRef * resolutionEnvironment:ExtensionTyping.ResolutionEnvironment * st:Tainted * m:Range.range -> TypedTree.EntityRef - val ResolveProvidedTypeNameInEntity: + val ResolveProvidedTypeNameInEntity : amap:Import.ImportMap * m:Range.range * typeName:string * modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.EntityRef list - val LookupTypeNameInEntityHaveArity: + val LookupTypeNameInEntityHaveArity : nm:string -> staticResInfo:TypeNameResolutionStaticArgsInfo -> mty:TypedTree.ModuleOrNamespaceType -> TypedTree.Tycon option - val LookupTypeNameNoArity: + val LookupTypeNameNoArity : nm:string -> byDemangledNameAndArity:AbstractIL.Internal.Library.LayeredMap -> byAccessNames:AbstractIL.Internal.Library.LayeredMultiMap -> 'a list - val LookupTypeNameInEntityNoArity: + val LookupTypeNameInEntityNoArity : _m:'a -> nm:string -> mtyp:TypedTree.ModuleOrNamespaceType -> TypedTree.Tycon list - val LookupTypeNameInEntityMaybeHaveArity: + val LookupTypeNameInEntityMaybeHaveArity : amap:Import.ImportMap * m:Range.range * ad:AccessibilityLogic.AccessorDomain * nm:string * staticResInfo:TypeNameResolutionStaticArgsInfo * modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.EntityRef list - val GetNestedTyconRefsOfType: + val GetNestedTyconRefsOfType : infoReader:InfoReader.InfoReader -> amap:Import.ImportMap -> ad:AccessibilityLogic.AccessorDomain * optFilter:string option * staticResInfo:TypeNameResolutionStaticArgsInfo * checkForGenerated:bool * m:Range.range -> ty:TypedTree.TType -> TypedTree.TypeInst * TypedTree.EntityRef list - val MakeNestedType: + val MakeNestedType : ncenv:NameResolver -> tinst:TypedTree.TType list -> m:Range.range -> tcrefNested:TypedTree.TyconRef -> TypedTree.TType - val GetNestedTypesOfType: + val GetNestedTypesOfType : ad:AccessibilityLogic.AccessorDomain * ncenv:NameResolver * optFilter:string option * staticResInfo:TypeNameResolutionStaticArgsInfo * checkForGenerated:bool * m:Range.range -> ty:TypedTree.TType -> TypedTree.TType list - val ChooseMethInfosForNameEnv: + val ChooseMethInfosForNameEnv : g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType -> minfos:Infos.MethInfo list -> System.Collections.Generic.KeyValuePair list - val ChoosePropInfosForNameEnv: + val ChoosePropInfosForNameEnv : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> pinfos:Infos.PropInfo list -> System.Collections.Generic.KeyValuePair list - val ChooseFSharpFieldInfosForNameEnv: + val ChooseFSharpFieldInfosForNameEnv : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> rfinfos:Infos.RecdFieldInfo list -> System.Collections.Generic.KeyValuePair list - val ChooseILFieldInfosForNameEnv: + val ChooseILFieldInfosForNameEnv : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> finfos:Infos.ILFieldInfo list -> System.Collections.Generic.KeyValuePair list - val ChooseEventInfosForNameEnv: + val ChooseEventInfosForNameEnv : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> einfos:Infos.EventInfo list -> System.Collections.Generic.KeyValuePair list - val AddStaticContentOfTypeToNameEnv: + val AddStaticContentOfTypeToNameEnv : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> ad:AccessibilityLogic.AccessorDomain -> m:Range.range -> nenv:NameResolutionEnv -> ty:TypedTree.TType -> NameResolutionEnv - val private AddNestedTypesOfTypeToNameEnv: + val private AddNestedTypesOfTypeToNameEnv : infoReader:InfoReader.InfoReader -> amap:Import.ImportMap -> ad:AccessibilityLogic.AccessorDomain -> m:Range.range -> nenv:NameResolutionEnv -> ty:TypedTree.TType -> NameResolutionEnv - val private AddTyconRefsWithEnclosingTypeInstToNameEnv: + val private AddTyconRefsWithEnclosingTypeInstToNameEnv : bulkAddMode:BulkAdd -> ownDefinition:bool -> g:TcGlobals.TcGlobals -> @@ -1985,11 +27049,11 @@ namespace FSharp.Compiler nenv:NameResolutionEnv -> tinstEnclosing:TypedTree.TypeInst * tcrefs:TypedTree.TyconRef list -> NameResolutionEnv - val private AddStaticPartsOfTypeToNameEnv: + val private AddStaticPartsOfTypeToNameEnv : amap:Import.ImportMap -> m:Range.range -> nenv:NameResolutionEnv -> ty:TypedTree.TType -> NameResolutionEnv - val private AddStaticPartsOfTyconRefToNameEnv: + val private AddStaticPartsOfTyconRefToNameEnv : bulkAddMode:BulkAdd -> ownDefinition:bool -> g:TcGlobals.TcGlobals -> @@ -1998,9 +27062,9 @@ namespace FSharp.Compiler nenv:NameResolutionEnv -> tinstOpt:TypedTree.TypeInst option -> tcref:TypedTree.TyconRef -> NameResolutionEnv - val private CanAutoOpenTyconRef: + val private CanAutoOpenTyconRef : g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool - val private AddPartsOfTyconRefToNameEnv: + val private AddPartsOfTyconRefToNameEnv : bulkAddMode:BulkAdd -> ownDefinition:bool -> g:TcGlobals.TcGlobals -> @@ -2009,7 +27073,7 @@ namespace FSharp.Compiler m:Range.range -> nenv:NameResolutionEnv -> tcref:TypedTree.TyconRef -> NameResolutionEnv - val AddTyconRefsToNameEnv: + val AddTyconRefsToNameEnv : BulkAdd -> bool -> TcGlobals.TcGlobals -> @@ -2019,15 +27083,15 @@ namespace FSharp.Compiler bool -> NameResolutionEnv -> TypedTree.TyconRef list -> NameResolutionEnv - val AddExceptionDeclsToNameEnv: + val AddExceptionDeclsToNameEnv : BulkAdd -> NameResolutionEnv -> TypedTree.TyconRef -> NameResolutionEnv - val AddModuleAbbrevToNameEnv: + val AddModuleAbbrevToNameEnv : SyntaxTree.Ident -> NameResolutionEnv -> TypedTree.ModuleOrNamespaceRef list -> NameResolutionEnv - val MakeNestedModuleRefs: + val MakeNestedModuleRefs : modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.EntityRef list - val AddModuleOrNamespaceRefsToNameEnv: + val AddModuleOrNamespaceRefsToNameEnv : TcGlobals.TcGlobals -> Import.ImportMap -> Range.range -> @@ -2035,7 +27099,7 @@ namespace FSharp.Compiler AccessibilityLogic.AccessorDomain -> NameResolutionEnv -> TypedTree.ModuleOrNamespaceRef list -> NameResolutionEnv - val AddModuleOrNamespaceContentsToNameEnv: + val AddModuleOrNamespaceContentsToNameEnv : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> ad:AccessibilityLogic.AccessorDomain -> @@ -2043,7 +27107,7 @@ namespace FSharp.Compiler root:bool -> nenv:NameResolutionEnv -> modref:TypedTree.ModuleOrNamespaceRef -> NameResolutionEnv - val AddModuleOrNamespaceRefsContentsToNameEnv: + val AddModuleOrNamespaceRefsContentsToNameEnv : TcGlobals.TcGlobals -> Import.ImportMap -> AccessibilityLogic.AccessorDomain -> @@ -2051,13 +27115,13 @@ namespace FSharp.Compiler bool -> NameResolutionEnv -> TypedTree.EntityRef list -> NameResolutionEnv - val AddTypeContentsToNameEnv: + val AddTypeContentsToNameEnv : TcGlobals.TcGlobals -> Import.ImportMap -> AccessibilityLogic.AccessorDomain -> Range.range -> NameResolutionEnv -> TypedTree.TType -> NameResolutionEnv - val AddModuleOrNamespaceRefContentsToNameEnv: + val AddModuleOrNamespaceRefContentsToNameEnv : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> ad:AccessibilityLogic.AccessorDomain -> @@ -2065,7 +27129,7 @@ namespace FSharp.Compiler root:bool -> nenv:NameResolutionEnv -> modref:TypedTree.EntityRef -> NameResolutionEnv - val AddModuleOrNamespaceRefToNameEnv: + val AddModuleOrNamespaceRefToNameEnv : TcGlobals.TcGlobals -> Import.ImportMap -> Range.range -> @@ -2075,76 +27139,76 @@ namespace FSharp.Compiler type CheckForDuplicateTyparFlag = | CheckForDuplicateTypars | NoCheckForDuplicateTypars - val AddDeclaredTyparsToNameEnv: + val AddDeclaredTyparsToNameEnv : CheckForDuplicateTyparFlag -> NameResolutionEnv -> TypedTree.Typar list -> NameResolutionEnv - val FreshenTycon: + val FreshenTycon : ncenv:NameResolver -> m:Range.range -> tcref:TypedTree.TyconRef -> TypedTree.TType - val FreshenTyconWithEnclosingTypeInst: + val FreshenTyconWithEnclosingTypeInst : ncenv:NameResolver -> m:Range.range -> tinstEnclosing:TypedTree.TypeInst -> tcref:TypedTree.TyconRef -> TypedTree.TType - val FreshenUnionCaseRef: + val FreshenUnionCaseRef : ncenv:NameResolver -> m:Range.range -> ucref:TypedTree.UnionCaseRef -> Infos.UnionCaseInfo - val FreshenRecdFieldRef: + val FreshenRecdFieldRef : NameResolver -> Range.range -> TypedTree.RecdFieldRef -> Infos.RecdFieldInfo - val ResolveUnqualifiedItem: + val ResolveUnqualifiedItem : ncenv:NameResolver -> nenv:NameResolutionEnv -> m:Range.range -> res:Item -> Item - val OneResult: + val OneResult : res:AbstractIL.Internal.Library.ResultOrException<'a> -> AbstractIL.Internal.Library.ResultOrException<'a list> - val OneSuccess: + val OneSuccess : x:'a -> AbstractIL.Internal.Library.ResultOrException<'a list> - val AddResults: + val AddResults : res1:AbstractIL.Internal.Library.ResultOrException<'a list> -> res2:AbstractIL.Internal.Library.ResultOrException<'a list> -> AbstractIL.Internal.Library.ResultOrException<'a list> - val NoResultsOrUsefulErrors: + val NoResultsOrUsefulErrors : AbstractIL.Internal.Library.ResultOrException<'a list> - val CollectResults: + val CollectResults : f:('a -> AbstractIL.Internal.Library.ResultOrException<'b>) -> _arg1:'a list -> AbstractIL.Internal.Library.ResultOrException<'b list> - val CollectAtMostOneResult: + val CollectAtMostOneResult : f:('a -> AbstractIL.Internal.Library.ResultOrException<'b>) -> inputs:'a list -> AbstractIL.Internal.Library.ResultOrException<'b list> - val CollectResults2: + val CollectResults2 : resultCollectionSettings:ResultCollectionSettings -> f:('a -> AbstractIL.Internal.Library.ResultOrException<'b>) -> ('a list -> AbstractIL.Internal.Library.ResultOrException<'b list>) - val MapResults: + val MapResults : f:('a -> 'b) -> _arg1:AbstractIL.Internal.Library.ResultOrException<'a list> -> AbstractIL.Internal.Library.ResultOrException<'b list> - val AtMostOneResult: + val AtMostOneResult : m:Range.range -> res:AbstractIL.Internal.Library.ResultOrException<'a list> -> AbstractIL.Internal.Library.ResultOrException<'a> - val AtMostOneResultQuery: + val AtMostOneResultQuery : query2:(unit -> AbstractIL.Internal.Library.ResultOrException<'a list>) -> res1:AbstractIL.Internal.Library.ResultOrException<'a list> -> AbstractIL.Internal.Library.ResultOrException<'a list> - val inline ( +++ ): + val inline ( +++ ) : res1:AbstractIL.Internal.Library.ResultOrException<'a list> -> query2:(unit -> AbstractIL.Internal.Library.ResultOrException<'a list>) -> AbstractIL.Internal.Library.ResultOrException<'a list> - val LookupTypeNameInEnvHaveArity: + val LookupTypeNameInEnvHaveArity : fq:FullyQualifiedFlag -> nm:string -> numTyArgs:int -> nenv:NameResolutionEnv -> TypedTree.TyconRef option - val LookupTypeNameInEnvNoArity: + val LookupTypeNameInEnvNoArity : FullyQualifiedFlag -> string -> NameResolutionEnv -> TypedTree.TyconRef list - val LookupTypeNameInEnvMaybeHaveArity: + val LookupTypeNameInEnvMaybeHaveArity : fq:FullyQualifiedFlag -> nm:string -> typeNameResInfo:TypeNameResolutionInfo -> nenv:NameResolutionEnv -> TypedTree.TyconRef list - [] + [] type ItemOccurence = | Binding | Use @@ -2163,95 +27227,95 @@ namespace FSharp.Compiler IsOwnNamespace: bool } with static member - Create: target:SyntaxTree.SynOpenDeclTarget * + Create : target:SyntaxTree.SynOpenDeclTarget * modules:TypedTree.ModuleOrNamespaceRef list * types:TypedTree.TType list * appliedScope:Range.range * isOwnNamespace:bool -> OpenDeclaration - + end type FormatStringCheckContext = { SourceText: Text.ISourceText LineStartPositions: int [] } type ITypecheckResultsSink = interface abstract member - NotifyEnvWithScope: Range.range * NameResolutionEnv * + NotifyEnvWithScope : Range.range * NameResolutionEnv * AccessibilityLogic.AccessorDomain -> unit abstract member - NotifyExprHasType: TypedTree.TType * NameResolutionEnv * + NotifyExprHasType : TypedTree.TType * NameResolutionEnv * AccessibilityLogic.AccessorDomain * Range.range -> unit abstract member - NotifyFormatSpecifierLocation: Range.range * int -> unit + NotifyFormatSpecifierLocation : Range.range * int -> unit abstract member - NotifyMethodGroupNameResolution: Range.pos * Item * Item * + NotifyMethodGroupNameResolution : Range.pos * Item * Item * TypedTreeOps.TyparInst * ItemOccurence * NameResolutionEnv * AccessibilityLogic.AccessorDomain * Range.range * bool -> unit abstract member - NotifyNameResolution: Range.pos * Item * TypedTreeOps.TyparInst * + NotifyNameResolution : Range.pos * Item * TypedTreeOps.TyparInst * ItemOccurence * NameResolutionEnv * AccessibilityLogic.AccessorDomain * Range.range * bool -> unit - abstract member NotifyOpenDeclaration: OpenDeclaration -> unit - abstract member CurrentSourceText: Text.ISourceText option + abstract member NotifyOpenDeclaration : OpenDeclaration -> unit + abstract member CurrentSourceText : Text.ISourceText option abstract member - FormatStringCheckContext: FormatStringCheckContext option - - val ( |ValRefOfProp|_| ): pi:Infos.PropInfo -> TypedTree.ValRef option - val ( |ValRefOfMeth|_| ): mi:Infos.MethInfo -> TypedTree.ValRef option - val ( |ValRefOfEvent|_| ): evt:Infos.EventInfo -> TypedTree.ValRef option - val ( |RecordFieldUse|_| ): + FormatStringCheckContext : FormatStringCheckContext option + end + val ( |ValRefOfProp|_| ) : pi:Infos.PropInfo -> TypedTree.ValRef option + val ( |ValRefOfMeth|_| ) : mi:Infos.MethInfo -> TypedTree.ValRef option + val ( |ValRefOfEvent|_| ) : evt:Infos.EventInfo -> TypedTree.ValRef option + val ( |RecordFieldUse|_| ) : item:Item -> (string * TypedTree.TyconRef) option - val ( |UnionCaseFieldUse|_| ): + val ( |UnionCaseFieldUse|_| ) : item:Item -> (int * TypedTree.UnionCaseRef) option - val ( |ILFieldUse|_| ): item:Item -> Infos.ILFieldInfo option - val ( |PropertyUse|_| ): item:Item -> Infos.PropInfo option - val ( |FSharpPropertyUse|_| ): item:Item -> TypedTree.ValRef option - val ( |MethodUse|_| ): item:Item -> Infos.MethInfo option - val ( |FSharpMethodUse|_| ): item:Item -> TypedTree.ValRef option - val ( |EntityUse|_| ): item:Item -> TypedTree.TyconRef option - val ( |EventUse|_| ): item:Item -> Infos.EventInfo option - val ( |FSharpEventUse|_| ): item:Item -> TypedTree.ValRef option - val ( |UnionCaseUse|_| ): item:Item -> TypedTree.UnionCaseRef option - val ( |ValUse|_| ): item:Item -> TypedTree.ValRef option - val ( |ActivePatternCaseUse|_| ): + val ( |ILFieldUse|_| ) : item:Item -> Infos.ILFieldInfo option + val ( |PropertyUse|_| ) : item:Item -> Infos.PropInfo option + val ( |FSharpPropertyUse|_| ) : item:Item -> TypedTree.ValRef option + val ( |MethodUse|_| ) : item:Item -> Infos.MethInfo option + val ( |FSharpMethodUse|_| ) : item:Item -> TypedTree.ValRef option + val ( |EntityUse|_| ) : item:Item -> TypedTree.TyconRef option + val ( |EventUse|_| ) : item:Item -> Infos.EventInfo option + val ( |FSharpEventUse|_| ) : item:Item -> TypedTree.ValRef option + val ( |UnionCaseUse|_| ) : item:Item -> TypedTree.UnionCaseRef option + val ( |ValUse|_| ) : item:Item -> TypedTree.ValRef option + val ( |ActivePatternCaseUse|_| ) : item:Item -> (Range.range * Range.range * int) option - val tyconRefDefnHash: + val tyconRefDefnHash : _g:TcGlobals.TcGlobals -> eref1:TypedTree.EntityRef -> int - val tyconRefDefnEq: + val tyconRefDefnEq : g:TcGlobals.TcGlobals -> eref1:TypedTree.EntityRef -> eref2:TypedTree.EntityRef -> bool - val valRefDefnHash: _g:TcGlobals.TcGlobals -> vref1:TypedTree.ValRef -> int - val valRefDefnEq: + val valRefDefnHash : _g:TcGlobals.TcGlobals -> vref1:TypedTree.ValRef -> int + val valRefDefnEq : g:TcGlobals.TcGlobals -> vref1:TypedTree.ValRef -> vref2:TypedTree.ValRef -> bool - val unionCaseRefDefnEq: + val unionCaseRefDefnEq : g:TcGlobals.TcGlobals -> uc1:TypedTree.UnionCaseRef -> uc2:TypedTree.UnionCaseRef -> bool - val ItemsAreEffectivelyEqual: TcGlobals.TcGlobals -> Item -> Item -> bool - val ItemsAreEffectivelyEqualHash: TcGlobals.TcGlobals -> Item -> int + val ItemsAreEffectivelyEqual : TcGlobals.TcGlobals -> Item -> Item -> bool + val ItemsAreEffectivelyEqualHash : TcGlobals.TcGlobals -> Item -> int [] type CapturedNameResolution = - - new: i:Item * tpinst:TypedTreeOps.TyparInst * io:ItemOccurence * + class + new : i:Item * tpinst:TypedTreeOps.TyparInst * io:ItemOccurence * nre:NameResolutionEnv * ad:AccessibilityLogic.AccessorDomain * m:Range.range -> CapturedNameResolution - member DebugToString: unit -> string - member AccessorDomain: AccessibilityLogic.AccessorDomain - member DisplayEnv: TypedTreeOps.DisplayEnv - member Item: Item - member ItemOccurence: ItemOccurence - member ItemWithInst: ItemWithInst - member NameResolutionEnv: NameResolutionEnv - member Pos: Range.pos - member Range: Range.range - - [] + member DebugToString : unit -> string + member AccessorDomain : AccessibilityLogic.AccessorDomain + member DisplayEnv : TypedTreeOps.DisplayEnv + member Item : Item + member ItemOccurence : ItemOccurence + member ItemWithInst : ItemWithInst + member NameResolutionEnv : NameResolutionEnv + member Pos : Range.pos + member Range : Range.range + end + [] type TcResolutions = - - new: capturedEnvs:ResizeArray * capturedExprTypes:ResizeArray -> TcResolutions member - CapturedEnvs: ResizeArray member - CapturedExpressionTypings: ResizeArray member - CapturedMethodGroupResolutions: ResizeArray - member CapturedNameResolutions: ResizeArray - static member Empty: TcResolutions - - [] + CapturedMethodGroupResolutions : ResizeArray + member CapturedNameResolutions : ResizeArray + static member Empty : TcResolutions + end + [] type TcSymbolUseData = { Item: Item ItemOccurence: ItemOccurence DisplayEnv: TypedTreeOps.DisplayEnv Range: Range.range } - [] + [] type TcSymbolUses = - - new: g:TcGlobals.TcGlobals * + class + new : g:TcGlobals.TcGlobals * capturedNameResolutions:ResizeArray * formatSpecifierLocations:(Range.range * int) [] -> TcSymbolUses member - GetFormatSpecifierLocationsAndArity: unit -> (Range.range * int) [] - member GetUsesOfSymbol: Item -> TcSymbolUseData [] - member AllUsesOfSymbols: TcSymbolUseData [] [] - static member Empty: TcSymbolUses - + GetFormatSpecifierLocationsAndArity : unit -> (Range.range * int) [] + member GetUsesOfSymbol : Item -> TcSymbolUseData [] + member AllUsesOfSymbols : TcSymbolUseData [] [] + static member Empty : TcSymbolUses + end type TcResultsSinkImpl = - + class interface ITypecheckResultsSink - new: tcGlobals:TcGlobals.TcGlobals * ?sourceText:Text.ISourceText -> + new : tcGlobals:TcGlobals.TcGlobals * ?sourceText:Text.ISourceText -> TcResultsSinkImpl - member GetFormatSpecifierLocations: unit -> (Range.range * int) [] - member GetOpenDeclarations: unit -> OpenDeclaration [] - member GetResolutions: unit -> TcResolutions - member GetSymbolUses: unit -> TcSymbolUses - + member GetFormatSpecifierLocations : unit -> (Range.range * int) [] + member GetOpenDeclarations : unit -> OpenDeclaration [] + member GetResolutions : unit -> TcResolutions + member GetSymbolUses : unit -> TcSymbolUses + end type TcResultsSink = { mutable CurrentSink: ITypecheckResultsSink option } with - static member WithSink: ITypecheckResultsSink -> TcResultsSink - static member NoSink: TcResultsSink - - val WithNewTypecheckResultsSink: + static member WithSink : ITypecheckResultsSink -> TcResultsSink + static member NoSink : TcResultsSink + end + val WithNewTypecheckResultsSink : ITypecheckResultsSink * TcResultsSink -> System.IDisposable - val TemporarilySuspendReportingTypecheckResultsToSink: + val TemporarilySuspendReportingTypecheckResultsToSink : TcResultsSink -> System.IDisposable - val CallEnvSink: + val CallEnvSink : TcResultsSink -> Range.range * NameResolutionEnv * AccessibilityLogic.AccessorDomain -> unit - val CallNameResolutionSink: + val CallNameResolutionSink : TcResultsSink -> Range.range * NameResolutionEnv * Item * TypedTreeOps.TyparInst * ItemOccurence * AccessibilityLogic.AccessorDomain -> unit - val CallMethodGroupNameResolutionSink: + val CallMethodGroupNameResolutionSink : TcResultsSink -> Range.range * NameResolutionEnv * Item * Item * TypedTreeOps.TyparInst * ItemOccurence * AccessibilityLogic.AccessorDomain -> unit - val CallNameResolutionSinkReplacing: + val CallNameResolutionSinkReplacing : TcResultsSink -> Range.range * NameResolutionEnv * Item * TypedTreeOps.TyparInst * ItemOccurence * AccessibilityLogic.AccessorDomain -> unit - val CallExprHasTypeSink: + val CallExprHasTypeSink : TcResultsSink -> Range.range * NameResolutionEnv * TypedTree.TType * AccessibilityLogic.AccessorDomain -> unit - val CallOpenDeclarationSink: TcResultsSink -> OpenDeclaration -> unit + val CallOpenDeclarationSink : TcResultsSink -> OpenDeclaration -> unit type ResultTyparChecker = | ResultTyparChecker of (unit -> bool) - val CheckAllTyparsInferrable: + val CheckAllTyparsInferrable : amap:Import.ImportMap -> m:Range.range -> item:Item -> bool type ResolutionInfo = | ResolutionInfo of @@ -2340,26 +27404,26 @@ namespace FSharp.Compiler tinstEnclosing: EnclosingTypeInst with static member - SendEntityPathToSink: sink:TcResultsSink * ncenv:NameResolver * + SendEntityPathToSink : sink:TcResultsSink * ncenv:NameResolver * nenv:NameResolutionEnv * occ:ItemOccurence * ad:AccessibilityLogic.AccessorDomain * ResolutionInfo * typarChecker:ResultTyparChecker -> unit member - AddEntity: info:(Range.range * TypedTree.EntityRef) -> ResolutionInfo - member AddWarning: f:(ResultTyparChecker -> unit) -> ResolutionInfo + AddEntity : info:(Range.range * TypedTree.EntityRef) -> ResolutionInfo + member AddWarning : f:(ResultTyparChecker -> unit) -> ResolutionInfo member - WithEnclosingTypeInst: tinstEnclosing:EnclosingTypeInst -> + WithEnclosingTypeInst : tinstEnclosing:EnclosingTypeInst -> ResolutionInfo - member EnclosingTypeInst: EnclosingTypeInst - static member Empty: ResolutionInfo - - val CheckForTypeLegitimacyAndMultipleGenericTypeAmbiguities: + member EnclosingTypeInst : EnclosingTypeInst + static member Empty : ResolutionInfo + end + val CheckForTypeLegitimacyAndMultipleGenericTypeAmbiguities : tcrefs:(ResolutionInfo * TypedTree.TyconRef) list * typeNameResInfo:TypeNameResolutionInfo * genOk:PermitDirectReferenceToGeneratedType * m:Range.range -> (ResolutionInfo * TypedTree.TyconRef) list - val ResolveLongIdentAsModuleOrNamespace: + val ResolveLongIdentAsModuleOrNamespace : TcResultsSink -> ResultCollectionSettings -> Import.ImportMap -> @@ -2374,7 +27438,7 @@ namespace FSharp.Compiler AbstractIL.Internal.Library.ResultOrException<(int * TypedTree.ModuleOrNamespaceRef * TypedTree.ModuleOrNamespaceType) list> - val ResolveLongIdentAsModuleOrNamespaceThen: + val ResolveLongIdentAsModuleOrNamespaceThen : sink:TcResultsSink -> atMostOne:ResultCollectionSettings -> amap:Import.ImportMap -> @@ -2391,7 +27455,7 @@ namespace FSharp.Compiler SyntaxTree.Ident -> SyntaxTree.Ident list -> AbstractIL.Internal.Library.ResultOrException<'a>) -> AbstractIL.Internal.Library.ResultOrException<'a list> - val private ResolveObjectConstructorPrim: + val private ResolveObjectConstructorPrim : ncenv:NameResolver -> edenv:TypedTreeOps.DisplayEnv -> resInfo:'a -> @@ -2399,7 +27463,7 @@ namespace FSharp.Compiler ad:AccessibilityLogic.AccessorDomain -> ty:TypedTree.TType -> AbstractIL.Internal.Library.ResultOrException<'a * Item> - val ResolveObjectConstructor: + val ResolveObjectConstructor : NameResolver -> TypedTreeOps.DisplayEnv -> Range.range -> @@ -2407,36 +27471,36 @@ namespace FSharp.Compiler TypedTree.TType -> AbstractIL.Internal.Library.ResultOrException exception IndeterminateType of Range.range - [] + [] type LookupKind = | RecdField | Pattern | Expr | Type | Ctor - val TryFindUnionCaseOfType: + val TryFindUnionCaseOfType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> nm:string -> Infos.UnionCaseInfo voption - val TryFindAnonRecdFieldOfType: + val TryFindAnonRecdFieldOfType : TcGlobals.TcGlobals -> TypedTree.TType -> string -> Item option - val CoreDisplayName: pinfo:Infos.PropInfo -> string - val DecodeFSharpEvent: + val CoreDisplayName : pinfo:Infos.PropInfo -> string + val DecodeFSharpEvent : pinfos:Infos.PropInfo list -> ad:AccessibilityLogic.AccessorDomain -> g:TcGlobals.TcGlobals -> ncenv:NameResolver -> m:Range.range -> Item option - val GetRecordLabelsForType: + val GetRecordLabelsForType : g:TcGlobals.TcGlobals -> nenv:NameResolutionEnv -> ty:TypedTree.TType -> System.Collections.Generic.HashSet - val CheckNestedTypesOfType: + val CheckNestedTypesOfType : ncenv:NameResolver -> resInfo:ResolutionInfo -> ad:AccessibilityLogic.AccessorDomain -> nm:string -> typeNameResInfo:TypeNameResolutionInfo -> m:Range.range -> ty:TypedTree.TType -> TypedTree.TType list - val ResolveLongIdentInTypePrim: + val ResolveLongIdentInTypePrim : ncenv:NameResolver -> nenv:NameResolutionEnv -> lookupKind:LookupKind -> @@ -2452,7 +27516,7 @@ namespace FSharp.Compiler AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * Item * SyntaxTree.Ident list) list> - val ResolveLongIdentInNestedTypes: + val ResolveLongIdentInNestedTypes : ncenv:NameResolver -> nenv:NameResolutionEnv -> lookupKind:LookupKind -> @@ -2469,7 +27533,7 @@ namespace FSharp.Compiler AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * Item * SyntaxTree.Ident list) list> - val ResolveLongIdentInType: + val ResolveLongIdentInType : TcResultsSink -> NameResolver -> NameResolutionEnv -> @@ -2480,7 +27544,7 @@ namespace FSharp.Compiler InfoReader.FindMemberFlag -> TypeNameResolutionInfo -> TypedTree.TType -> Item * SyntaxTree.Ident list - val private ResolveLongIdentInTyconRef: + val private ResolveLongIdentInTyconRef : ncenv:NameResolver -> nenv:NameResolutionEnv -> lookupKind:LookupKind -> @@ -2495,7 +27559,7 @@ namespace FSharp.Compiler AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * Item * SyntaxTree.Ident list) list> - val private ResolveLongIdentInTyconRefs: + val private ResolveLongIdentInTyconRefs : atMostOne:ResultCollectionSettings -> ncenv:NameResolver -> nenv:NameResolutionEnv -> @@ -2511,13 +27575,13 @@ namespace FSharp.Compiler AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * Item * SyntaxTree.Ident list) list> - val ( |AccessibleEntityRef|_| ): + val ( |AccessibleEntityRef|_| ) : amap:Import.ImportMap -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> modref:TypedTree.ModuleOrNamespaceRef -> mspec:TypedTree.Entity -> TypedTree.EntityRef option - val ResolveExprLongIdentInModuleOrNamespace: + val ResolveExprLongIdentInModuleOrNamespace : ncenv:NameResolver -> nenv:NameResolutionEnv -> typeNameResInfo:TypeNameResolutionInfo -> @@ -2532,17 +27596,17 @@ namespace FSharp.Compiler AbstractIL.Internal.Library.ResultOrException - val ChooseTyconRefInExpr: + val ChooseTyconRefInExpr : ncenv:NameResolver * m:Range.range * ad:AccessibilityLogic.AccessorDomain * nenv:NameResolutionEnv * id:SyntaxTree.Ident * typeNameResInfo:TypeNameResolutionInfo * tcrefs:(ResolutionInfo * TypedTree.TyconRef) list -> AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * Item) list> - val ResolveUnqualifiedTyconRefs: + val ResolveUnqualifiedTyconRefs : nenv:NameResolutionEnv -> tcrefs:TypedTree.TyconRef list -> (ResolutionInfo * TypedTree.TyconRef) list - val ResolveExprLongIdentPrim: + val ResolveExprLongIdentPrim : sink:TcResultsSink -> ncenv:NameResolver -> first:bool -> @@ -2557,7 +27621,7 @@ namespace FSharp.Compiler AbstractIL.Internal.Library.ResultOrException - val ResolveExprLongIdent: + val ResolveExprLongIdent : TcResultsSink -> NameResolver -> Range.range -> @@ -2568,7 +27632,7 @@ namespace FSharp.Compiler AbstractIL.Internal.Library.ResultOrException - val ResolvePatternLongIdentInModuleOrNamespace: + val ResolvePatternLongIdentInModuleOrNamespace : ncenv:NameResolver -> nenv:NameResolutionEnv -> numTyArgsOpt:TypeNameResolutionInfo -> @@ -2587,7 +27651,7 @@ namespace FSharp.Compiler type WarnOnUpperFlag = | WarnOnUpperCase | AllIdsOK - val ResolvePatternLongIdentPrim: + val ResolvePatternLongIdentPrim : sink:TcResultsSink -> ncenv:NameResolver -> fullyQualified:FullyQualifiedFlag -> @@ -2599,7 +27663,7 @@ namespace FSharp.Compiler numTyArgsOpt:TypeNameResolutionInfo -> id:SyntaxTree.Ident -> rest:SyntaxTree.Ident list -> Item - val ResolvePatternLongIdent: + val ResolvePatternLongIdent : TcResultsSink -> NameResolver -> WarnOnUpperFlag -> @@ -2608,10 +27672,10 @@ namespace FSharp.Compiler AccessibilityLogic.AccessorDomain -> NameResolutionEnv -> TypeNameResolutionInfo -> SyntaxTree.Ident list -> Item - val ResolveNestedTypeThroughAbbreviation: + val ResolveNestedTypeThroughAbbreviation : ncenv:NameResolver -> tcref:TypedTree.TyconRef -> m:Range.range -> TypedTree.TyconRef - val ResolveTypeLongIdentInTyconRefPrim: + val ResolveTypeLongIdentInTyconRefPrim : ncenv:NameResolver -> typeNameResInfo:TypeNameResolutionInfo -> ad:AccessibilityLogic.AccessorDomain -> @@ -2624,7 +27688,7 @@ namespace FSharp.Compiler rest:SyntaxTree.Ident list -> AbstractIL.Internal.Library.ResultOrException - val ResolveTypeLongIdentInTyconRef: + val ResolveTypeLongIdentInTyconRef : TcResultsSink -> NameResolver -> NameResolutionEnv -> @@ -2633,13 +27697,13 @@ namespace FSharp.Compiler Range.range -> TypedTree.TyconRef -> SyntaxTree.Ident list -> TypedTree.TyconRef - val SuggestTypeLongIdentInModuleOrNamespace: + val SuggestTypeLongIdentInModuleOrNamespace : depth:int -> modref:TypedTree.ModuleOrNamespaceRef -> amap:Import.ImportMap -> ad:AccessibilityLogic.AccessorDomain -> m:Range.range -> id:SyntaxTree.Ident -> exn - val private ResolveTypeLongIdentInModuleOrNamespace: + val private ResolveTypeLongIdentInModuleOrNamespace : sink:TcResultsSink -> nenv:NameResolutionEnv -> ncenv:NameResolver -> @@ -2655,7 +27719,7 @@ namespace FSharp.Compiler rest:SyntaxTree.Ident list -> AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * TypedTree.EntityRef) list> - val ResolveTypeLongIdentPrim: + val ResolveTypeLongIdentPrim : sink:TcResultsSink -> ncenv:NameResolver -> occurence:ItemOccurence -> @@ -2670,7 +27734,7 @@ namespace FSharp.Compiler genOk:PermitDirectReferenceToGeneratedType -> AbstractIL.Internal.Library.ResultOrException - val ResolveTypeLongIdentAux: + val ResolveTypeLongIdentAux : sink:TcResultsSink -> ncenv:NameResolver -> occurence:ItemOccurence -> @@ -2682,7 +27746,7 @@ namespace FSharp.Compiler genOk:PermitDirectReferenceToGeneratedType -> AbstractIL.Internal.Library.ResultOrException - val ResolveTypeLongIdent: + val ResolveTypeLongIdent : TcResultsSink -> NameResolver -> ItemOccurence -> @@ -2694,7 +27758,7 @@ namespace FSharp.Compiler PermitDirectReferenceToGeneratedType -> AbstractIL.Internal.Library.ResultOrException - val ResolveFieldInModuleOrNamespace: + val ResolveFieldInModuleOrNamespace : ncenv:NameResolver -> nenv:NameResolutionEnv -> ad:AccessibilityLogic.AccessorDomain -> @@ -2708,18 +27772,18 @@ namespace FSharp.Compiler AbstractIL.Internal.Library.ResultOrException - val SuggestOtherLabelsOfSameRecordType: + val SuggestOtherLabelsOfSameRecordType : g:TcGlobals.TcGlobals -> nenv:NameResolutionEnv -> ty:TypedTree.TType -> id:SyntaxTree.Ident -> allFields:SyntaxTree.Ident list -> System.Collections.Generic.HashSet - val SuggestLabelsOfRelatedRecords: + val SuggestLabelsOfRelatedRecords : g:TcGlobals.TcGlobals -> nenv:NameResolutionEnv -> id:SyntaxTree.Ident -> allFields:SyntaxTree.Ident list -> exn - val ResolveFieldPrim: + val ResolveFieldPrim : sink:TcResultsSink -> ncenv:NameResolver -> nenv:NameResolutionEnv -> @@ -2728,7 +27792,7 @@ namespace FSharp.Compiler mp:SyntaxTree.Ident list * id:SyntaxTree.Ident -> allFields:SyntaxTree.Ident list -> (ResolutionInfo * FieldResolution) list - val ResolveField: + val ResolveField : TcResultsSink -> NameResolver -> NameResolutionEnv -> @@ -2736,7 +27800,7 @@ namespace FSharp.Compiler TypedTree.TType -> SyntaxTree.Ident list * SyntaxTree.Ident -> SyntaxTree.Ident list -> FieldResolution list - val private ResolveExprDotLongIdent: + val private ResolveExprDotLongIdent : ncenv:NameResolver -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> @@ -2747,21 +27811,21 @@ namespace FSharp.Compiler typeNameResInfo:TypeNameResolutionInfo -> findFlag:InfoReader.FindMemberFlag -> ResolutionInfo * Item * SyntaxTree.Ident list - val ComputeItemRange: + val ComputeItemRange : wholem:Range.range -> lid:SyntaxTree.Ident list -> rest:'a list -> Range.range - val FilterMethodGroups: + val FilterMethodGroups : ncenv:NameResolver -> itemRange:Range.range -> item:Item -> staticOnly:bool -> Item - val NeedsWorkAfterResolution: namedItem:Item -> bool - [] + val NeedsWorkAfterResolution : namedItem:Item -> bool + [] type AfterResolution = | DoNothing | RecordResolution of Item option * (TypedTreeOps.TyparInst -> unit) * (Infos.MethInfo * Infos.PropInfo option * TypedTreeOps.TyparInst -> unit) * (unit -> unit) - val ResolveLongIdentAsExprAndComputeRange: + val ResolveLongIdentAsExprAndComputeRange : TcResultsSink -> NameResolver -> Range.range -> @@ -2774,8 +27838,8 @@ namespace FSharp.Compiler Range.range * SyntaxTree.Ident list * AfterResolution> - val ( |NonOverridable|_| ): namedItem:Item -> unit option - val ResolveExprDotLongIdentAndComputeRange: + val ( |NonOverridable|_| ) : namedItem:Item -> unit option + val ResolveExprDotLongIdentAndComputeRange : TcResultsSink -> NameResolver -> Range.range -> @@ -2788,62 +27852,62 @@ namespace FSharp.Compiler bool -> Item * Range.range * SyntaxTree.Ident list * AfterResolution - val FakeInstantiationGenerator: + val FakeInstantiationGenerator : Range.range -> TypedTree.Typar list -> TypedTree.TType list - val ItemForModuleOrNamespaceRef: v:TypedTree.ModuleOrNamespaceRef -> Item - val ItemForPropInfo: pinfo:Infos.PropInfo -> Item - val IsTyconUnseenObsoleteSpec: + val ItemForModuleOrNamespaceRef : v:TypedTree.ModuleOrNamespaceRef -> Item + val ItemForPropInfo : pinfo:Infos.PropInfo -> Item + val IsTyconUnseenObsoleteSpec : ad:AccessibilityLogic.AccessorDomain -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> x:TypedTree.TyconRef -> allowObsolete:bool -> bool - val IsTyconUnseen: + val IsTyconUnseen : ad:AccessibilityLogic.AccessorDomain -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> x:TypedTree.TyconRef -> bool - val IsValUnseen: + val IsValUnseen : ad:AccessibilityLogic.AccessorDomain -> g:TcGlobals.TcGlobals -> m:'a -> v:TypedTree.ValRef -> bool - val IsUnionCaseUnseen: + val IsUnionCaseUnseen : ad:AccessibilityLogic.AccessorDomain -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> ucref:TypedTree.UnionCaseRef -> bool - val ItemIsUnseen: + val ItemIsUnseen : ad:AccessibilityLogic.AccessorDomain -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> item:Item -> bool - val ItemOfTyconRef: + val ItemOfTyconRef : ncenv:NameResolver -> m:Range.range -> x:TypedTree.TyconRef -> Item - val ItemOfTy: g:TcGlobals.TcGlobals -> x:TypedTree.TType -> Item - val IsInterestingModuleName: nm:string -> bool - val PartialResolveLookupInModuleOrNamespaceAsModuleOrNamespaceThen: + val ItemOfTy : g:TcGlobals.TcGlobals -> x:TypedTree.TType -> Item + val IsInterestingModuleName : nm:string -> bool + val PartialResolveLookupInModuleOrNamespaceAsModuleOrNamespaceThen : f:(TypedTree.ModuleOrNamespaceRef -> 'a list) -> plid:string list -> modref:TypedTree.ModuleOrNamespaceRef -> 'a list - val PartialResolveLongIdentAsModuleOrNamespaceThen: + val PartialResolveLongIdentAsModuleOrNamespaceThen : nenv:NameResolutionEnv -> plid:string list -> f:(TypedTree.ModuleOrNamespaceRef -> 'a list) -> 'a list - val ResolveRecordOrClassFieldsOfType: + val ResolveRecordOrClassFieldsOfType : NameResolver -> Range.range -> AccessibilityLogic.AccessorDomain -> TypedTree.TType -> bool -> Item list - [] + [] type ResolveCompletionTargets = | All of (Infos.MethInfo -> TypedTree.TType -> bool) | SettablePropertiesAndFields with - member ResolveAll: bool - - val ResolveCompletionsInType: + member ResolveAll : bool + end + val ResolveCompletionsInType : NameResolver -> NameResolutionEnv -> ResolveCompletionTargets -> Range.range -> AccessibilityLogic.AccessorDomain -> bool -> TypedTree.TType -> Item list - val ResolvePartialLongIdentInType: + val ResolvePartialLongIdentInType : ncenv:NameResolver -> nenv:NameResolutionEnv -> isApplicableMeth:ResolveCompletionTargets -> @@ -2851,24 +27915,24 @@ namespace FSharp.Compiler ad:AccessibilityLogic.AccessorDomain -> statics:bool -> plid:string list -> ty:TypedTree.TType -> Item list - val InfosForTyconConstructors: + val InfosForTyconConstructors : ncenv:NameResolver -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> tcref:TypedTree.TyconRef -> Item list - val inline notFakeContainerModule: + val inline notFakeContainerModule : tyconNames:System.Collections.Generic.HashSet<'a> -> nm:'a -> bool - val getFakeContainerModulesFromTycons: + val getFakeContainerModulesFromTycons : tycons:#seq -> System.Collections.Generic.HashSet - val getFakeContainerModulesFromTyconRefs: + val getFakeContainerModulesFromTyconRefs : tyconRefs:#seq -> System.Collections.Generic.HashSet - val private EntityRefContainsSomethingAccessible: + val private EntityRefContainsSomethingAccessible : ncenv:NameResolver -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> modref:TypedTree.ModuleOrNamespaceRef -> bool - val ResolvePartialLongIdentInModuleOrNamespace: + val ResolvePartialLongIdentInModuleOrNamespace : ncenv:NameResolver -> nenv:NameResolutionEnv -> isApplicableMeth:ResolveCompletionTargets -> @@ -2876,11 +27940,11 @@ namespace FSharp.Compiler ad:AccessibilityLogic.AccessorDomain -> modref:TypedTree.ModuleOrNamespaceRef -> plid:string list -> allowObsolete:bool -> Item list - val TryToResolveLongIdentAsType: + val TryToResolveLongIdentAsType : NameResolver -> NameResolutionEnv -> Range.range -> string list -> TypedTree.TType option - val ResolvePartialLongIdentPrim: + val ResolvePartialLongIdentPrim : ncenv:NameResolver -> nenv:NameResolutionEnv -> isApplicableMeth:ResolveCompletionTargets -> @@ -2888,81 +27952,81 @@ namespace FSharp.Compiler m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> plid:string list -> allowObsolete:bool -> Item list - val ResolvePartialLongIdent: + val ResolvePartialLongIdent : NameResolver -> NameResolutionEnv -> (Infos.MethInfo -> TypedTree.TType -> bool) -> Range.range -> AccessibilityLogic.AccessorDomain -> string list -> bool -> Item list - val ResolvePartialLongIdentInModuleOrNamespaceForRecordFields: + val ResolvePartialLongIdentInModuleOrNamespaceForRecordFields : ncenv:NameResolver -> nenv:'a -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> modref:TypedTree.ModuleOrNamespaceRef -> plid:string list -> allowObsolete:bool -> Item list - val ResolvePartialLongIdentToClassOrRecdFields: + val ResolvePartialLongIdentToClassOrRecdFields : NameResolver -> NameResolutionEnv -> Range.range -> AccessibilityLogic.AccessorDomain -> string list -> bool -> Item list - val ResolvePartialLongIdentToClassOrRecdFieldsImpl: + val ResolvePartialLongIdentToClassOrRecdFieldsImpl : ncenv:NameResolver -> nenv:NameResolutionEnv -> fullyQualified:FullyQualifiedFlag -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> plid:string list -> allowObsolete:bool -> Item list - val ResolveCompletionsInTypeForItem: + val ResolveCompletionsInTypeForItem : ncenv:NameResolver -> nenv:NameResolutionEnv -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> statics:bool -> ty:TypedTree.TType -> item:Item -> seq - val ResolvePartialLongIdentInTypeForItem: + val ResolvePartialLongIdentInTypeForItem : ncenv:NameResolver -> nenv:NameResolutionEnv -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> statics:bool -> plid:string list -> item:Item -> ty:TypedTree.TType -> seq - val ResolvePartialLongIdentInModuleOrNamespaceForItem: + val ResolvePartialLongIdentInModuleOrNamespaceForItem : ncenv:NameResolver -> nenv:NameResolutionEnv -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> modref:TypedTree.ModuleOrNamespaceRef -> plid:string list -> item:Item -> seq - val PartialResolveLookupInModuleOrNamespaceAsModuleOrNamespaceThenLazy: + val PartialResolveLookupInModuleOrNamespaceAsModuleOrNamespaceThenLazy : f:(TypedTree.ModuleOrNamespaceRef -> seq<'a>) -> plid:string list -> modref:TypedTree.ModuleOrNamespaceRef -> seq<'a> - val PartialResolveLongIdentAsModuleOrNamespaceThenLazy: + val PartialResolveLongIdentAsModuleOrNamespaceThenLazy : nenv:NameResolutionEnv -> plid:string list -> f:(TypedTree.ModuleOrNamespaceRef -> seq<'a>) -> seq<'a> - val GetCompletionForItem: + val GetCompletionForItem : ncenv:NameResolver -> nenv:NameResolutionEnv -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> plid:string list -> item:Item -> seq - val IsItemResolvable: + val IsItemResolvable : NameResolver -> NameResolutionEnv -> Range.range -> AccessibilityLogic.AccessorDomain -> string list -> Item -> bool - val GetVisibleNamespacesAndModulesAtPoint: + val GetVisibleNamespacesAndModulesAtPoint : NameResolver -> NameResolutionEnv -> Range.range -> AccessibilityLogic.AccessorDomain -> TypedTree.ModuleOrNamespaceRef list - + end namespace FSharp.Compiler - module internal SignatureConformance = + module internal SignatureConformance = begin exception RequiredButNotSpecified of TypedTreeOps.DisplayEnv * TypedTree.ModuleOrNamespaceRef * string * @@ -2989,34 +28053,34 @@ namespace FSharp.Compiler TypedTreeOps.DisplayEnv * TypedTree.TType * Range.range type Checker = - - new: g:TcGlobals.TcGlobals * amap:Import.ImportMap * + class + new : g:TcGlobals.TcGlobals * amap:Import.ImportMap * denv:TypedTreeOps.DisplayEnv * remapInfo:TypedTreeOps.SignatureRepackageInfo * checkingSig:bool -> Checker member - CheckSignature: aenv:TypedTreeOps.TypeEquivEnv -> + CheckSignature : aenv:TypedTreeOps.TypeEquivEnv -> implModRef:TypedTree.ModuleOrNamespaceRef -> signModType:TypedTree.ModuleOrNamespaceType -> bool member - CheckTypars: m:Range.range -> + CheckTypars : m:Range.range -> aenv:TypedTreeOps.TypeEquivEnv -> implTypars:TypedTree.Typars -> signTypars:TypedTree.Typars -> bool - - val CheckNamesOfModuleOrNamespaceContents: + end + val CheckNamesOfModuleOrNamespaceContents : denv:TypedTreeOps.DisplayEnv -> implModRef:TypedTree.ModuleOrNamespaceRef -> signModType:TypedTree.ModuleOrNamespaceType -> bool - val CheckNamesOfModuleOrNamespace: + val CheckNamesOfModuleOrNamespace : denv:TypedTreeOps.DisplayEnv -> implModRef:TypedTree.ModuleOrNamespaceRef -> signModType:TypedTree.ModuleOrNamespaceType -> bool - + end namespace FSharp.Compiler - module internal MethodOverrides = + module internal MethodOverrides = begin type OverrideCanImplement = | CanImplementAnyInterfaceSlot | CanImplementAnyClassHierarchySlot @@ -3028,25 +28092,25 @@ namespace FSharp.Compiler (TypedTree.Typars * TypedTreeOps.TyparInst) * TypedTree.TType list list * TypedTree.TType option * bool * bool with - member ArgTypes: TypedTree.TType list list - member BoundingTyconRef: TypedTree.TyconRef - member CanImplement: OverrideCanImplement - member IsCompilerGenerated: bool - member IsFakeEventProperty: bool - member LogicalName: string - member Range: Range.range - member ReturnType: TypedTree.TType option - + member ArgTypes : TypedTree.TType list list + member BoundingTyconRef : TypedTree.TyconRef + member CanImplement : OverrideCanImplement + member IsCompilerGenerated : bool + member IsFakeEventProperty : bool + member LogicalName : string + member Range : Range.range + member ReturnType : TypedTree.TType option + end type RequiredSlot = | RequiredSlot of Infos.MethInfo * isOptional: bool | DefaultInterfaceImplementationSlot of Infos.MethInfo * isOptional: bool * possiblyNoMostSpecific: bool with - member HasDefaultInterfaceImplementation: bool - member IsOptional: bool - member MethodInfo: Infos.MethInfo - member PossiblyNoMostSpecificImplementation: bool - + member HasDefaultInterfaceImplementation : bool + member IsOptional : bool + member MethodInfo : Infos.MethInfo + member PossiblyNoMostSpecificImplementation : bool + end type SlotImplSet = | SlotImplSet of RequiredSlot list * @@ -3058,33 +28122,33 @@ namespace FSharp.Compiler Infos.MethInfo option * TcGlobals.TcGlobals * Import.ImportMap * Range.range - module DispatchSlotChecking = - val PrintOverrideToBuffer: + module DispatchSlotChecking = begin + val PrintOverrideToBuffer : denv:TypedTreeOps.DisplayEnv -> os:System.Text.StringBuilder -> OverrideInfo -> unit - val PrintMethInfoSigToBuffer: + val PrintMethInfoSigToBuffer : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> os:System.Text.StringBuilder -> minfo:Infos.MethInfo -> unit - val FormatOverride: + val FormatOverride : denv:TypedTreeOps.DisplayEnv -> d:OverrideInfo -> string - val FormatMethInfoSig: + val FormatMethInfoSig : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> d:Infos.MethInfo -> string - val GetInheritedMemberOverrideInfo: + val GetInheritedMemberOverrideInfo : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> parentType:OverrideCanImplement -> minfo:Infos.MethInfo -> OverrideInfo - val GetTypeMemberOverrideInfo: + val GetTypeMemberOverrideInfo : g:TcGlobals.TcGlobals -> reqdTy:TypedTree.TType -> overrideBy:TypedTree.ValRef -> OverrideInfo - val GetObjectExprOverrideInfo: + val GetObjectExprOverrideInfo : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> implty:TypedTree.TType * id:SyntaxTree.Ident * @@ -3094,67 +28158,67 @@ namespace FSharp.Compiler OverrideInfo * (TypedTree.Val option * TypedTree.Val * TypedTree.Val list list * TypedTree.Attribs * TypedTree.Expr) - val IsNameMatch: + val IsNameMatch : dispatchSlot:Infos.MethInfo -> overrideBy:OverrideInfo -> bool - val IsImplMatch: + val IsImplMatch : g:TcGlobals.TcGlobals -> dispatchSlot:Infos.MethInfo -> overrideBy:OverrideInfo -> bool - val IsTyparKindMatch: Infos.CompiledSig -> OverrideInfo -> bool - val IsSigPartialMatch: + val IsTyparKindMatch : Infos.CompiledSig -> OverrideInfo -> bool + val IsSigPartialMatch : g:TcGlobals.TcGlobals -> dispatchSlot:Infos.MethInfo -> compiledSig:Infos.CompiledSig -> OverrideInfo -> bool - val IsPartialMatch: + val IsPartialMatch : g:TcGlobals.TcGlobals -> dispatchSlot:Infos.MethInfo -> compiledSig:Infos.CompiledSig -> overrideBy:OverrideInfo -> bool - val ReverseTyparRenaming: + val ReverseTyparRenaming : g:TcGlobals.TcGlobals -> tinst:(TypedTree.Typar * TypedTree.TType) list -> (TypedTree.Typar * TypedTree.TType) list - val ComposeTyparInsts: + val ComposeTyparInsts : inst1:('a * TypedTree.TType) list -> inst2:TypedTreeOps.TyparInst -> ('a * TypedTree.TType) list - val IsSigExactMatch: + val IsSigExactMatch : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> dispatchSlot:Infos.MethInfo -> OverrideInfo -> bool - val IsExactMatch: + val IsExactMatch : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> dispatchSlot:Infos.MethInfo -> overrideBy:OverrideInfo -> bool - val OverrideImplementsDispatchSlot: + val OverrideImplementsDispatchSlot : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> dispatchSlot:Infos.MethInfo -> availPriorOverride:OverrideInfo -> bool - val DispatchSlotIsAlreadyImplemented: + val DispatchSlotIsAlreadyImplemented : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> availPriorOverridesKeyed:AbstractIL.Internal.Library.NameMultiMap -> dispatchSlot:Infos.MethInfo -> bool - val CheckDispatchSlotsAreImplemented: + val CheckDispatchSlotsAreImplemented : denv:TypedTreeOps.DisplayEnv * infoReader:InfoReader.InfoReader * m:Range.range * nenv:NameResolution.NameResolutionEnv * sink:NameResolution.TcResultsSink * isOverallTyAbstract:bool * reqdTy:TypedTree.TType * dispatchSlots:RequiredSlot list * availPriorOverrides:OverrideInfo list * overrides:OverrideInfo list -> bool - val GetMostSpecificOverrideInterfaceMethodSets: + val GetMostSpecificOverrideInterfaceMethodSets : infoReader:InfoReader.InfoReader -> allReqdTys:(TypedTree.TType * Range.range) list -> Map - val GetMostSpecificOverrideInterfaceMethodsByMethod: + val GetMostSpecificOverrideInterfaceMethodsByMethod : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> mostSpecificOverrides:AbstractIL.Internal.Library.NameMultiMap -> minfo:Infos.MethInfo -> (TypedTree.TType * Infos.MethInfo) list - val GetInterfaceDispatchSlots: + val GetInterfaceDispatchSlots : infoReader:InfoReader.InfoReader -> ad:AccessibilityLogic.AccessorDomain -> m:Range.range -> @@ -3162,11 +28226,11 @@ namespace FSharp.Compiler mostSpecificOverrides:AbstractIL.Internal.Library.NameMultiMap -> interfaceTy:TypedTree.TType -> RequiredSlot list - val GetClassDispatchSlots: + val GetClassDispatchSlots : infoReader:InfoReader.InfoReader -> ad:AccessibilityLogic.AccessorDomain -> m:Range.range -> reqdTy:TypedTree.TType -> RequiredSlot list - val GetDispatchSlotSet: + val GetDispatchSlotSet : infoReader:InfoReader.InfoReader -> ad:AccessibilityLogic.AccessorDomain -> m:Range.range -> @@ -3176,53 +28240,53 @@ namespace FSharp.Compiler reqdTy:TypedTree.TType -> impliedTys:seq -> (TypedTree.TType * RequiredSlot list) list - val CheckOverridesAreAllUsedOnce: + val CheckOverridesAreAllUsedOnce : denv:TypedTreeOps.DisplayEnv * g:TcGlobals.TcGlobals * amap:Import.ImportMap * isObjExpr:bool * reqdTy:TypedTree.TType * dispatchSlotsKeyed:AbstractIL.Internal.Library.NameMultiMap * availPriorOverrides:OverrideInfo list * overrides:OverrideInfo list -> unit - val GetSlotImplSets: + val GetSlotImplSets : infoReader:InfoReader.InfoReader -> denv:TypedTreeOps.DisplayEnv -> ad:AccessibilityLogic.AccessorDomain -> isObjExpr:bool -> allReqdTys:(TypedTree.TType * Range.range) list -> SlotImplSet list - val CheckImplementationRelationAtEndOfInferenceScope: + val CheckImplementationRelationAtEndOfInferenceScope : infoReader:InfoReader.InfoReader * denv:TypedTreeOps.DisplayEnv * nenv:NameResolution.NameResolutionEnv * sink:NameResolution.TcResultsSink * tycon:TypedTree.Tycon * isImplementation:bool -> unit - - val FinalTypeDefinitionChecksAtEndOfInferenceScope: + end + val FinalTypeDefinitionChecksAtEndOfInferenceScope : infoReader:InfoReader.InfoReader * nenv:NameResolution.NameResolutionEnv * sink:NameResolution.TcResultsSink * isImplementation:bool * denv:TypedTreeOps.DisplayEnv -> tycon:TypedTree.Tycon -> unit - val GetAbstractMethInfosForSynMethodDecl: + val GetAbstractMethInfosForSynMethodDecl : infoReader:InfoReader.InfoReader * ad:AccessibilityLogic.AccessorDomain * memberName:SyntaxTree.Ident * bindm:Range.range * typToSearchForAbstractMembers:(TypedTree.TType * SlotImplSet option) * valSynData:SyntaxTree.SynValInfo -> Infos.MethInfo list * Infos.MethInfo list - val GetAbstractPropInfosForSynPropertyDecl: + val GetAbstractPropInfosForSynPropertyDecl : infoReader:InfoReader.InfoReader * ad:AccessibilityLogic.AccessorDomain * memberName:SyntaxTree.Ident * bindm:Range.range * typToSearchForAbstractMembers:(TypedTree.TType * SlotImplSet option) * _k:'a * _valSynData:'b -> Infos.PropInfo list - + end namespace FSharp.Compiler - module internal MethodCalls = + module internal MethodCalls = begin type CallerArg<'T> = | CallerArg of ty: TypedTree.TType * range: Range.range * isOpt: bool * exprInfo: 'T with - member CallerArgumentType: TypedTree.TType - member Expr: 'T - member IsExplicitOptional: bool - member Range: Range.range - + member CallerArgumentType : TypedTree.TType + member Expr : 'T + member IsExplicitOptional : bool + member Range : Range.range + end type CalledArg = { Position: struct (int * int) IsParamArray: bool @@ -3233,7 +28297,7 @@ namespace FSharp.Compiler ReflArgInfo: Infos.ReflectedArgInfo NameOpt: SyntaxTree.Ident option CalledArgumentType: TypedTree.TType } - val CalledArg: + val CalledArg : pos:struct (int * int) * isParamArray:bool * optArgInfo:Infos.OptionalArgInfo * callerInfo:Infos.CallerInfo * isInArg:bool * isOutArg:bool * nameOpt:SyntaxTree.Ident option * @@ -3244,8 +28308,8 @@ namespace FSharp.Compiler CalledArg: CalledArg CallerArg: CallerArg<'T> } with - member Position: struct (int * int) - + member Position : struct (int * int) + end type AssignedItemSetterTarget = | AssignedPropSetter of Infos.PropInfo * Infos.MethInfo * TypedTree.TypeInst @@ -3257,32 +28321,32 @@ namespace FSharp.Compiler type CallerNamedArg<'T> = | CallerNamedArg of SyntaxTree.Ident * CallerArg<'T> with - member CallerArg: CallerArg<'T> - member Ident: SyntaxTree.Ident - member Name: string - - [] + member CallerArg : CallerArg<'T> + member Ident : SyntaxTree.Ident + member Name : string + end + [] type CallerArgs<'T> = { Unnamed: CallerArg<'T> list list Named: CallerNamedArg<'T> list list } with - member ArgumentNamesAndTypes: (string option * TypedTree.TType) list - member CallerArgCounts: int * int + member ArgumentNamesAndTypes : (string option * TypedTree.TType) list + member CallerArgCounts : int * int member - CurriedCallerArgs: (CallerArg<'T> list * CallerNamedArg<'T> list) list - static member Empty: CallerArgs<'T> - - val AdjustCalledArgTypeForLinqExpressionsAndAutoQuote: + CurriedCallerArgs : (CallerArg<'T> list * CallerNamedArg<'T> list) list + static member Empty : CallerArgs<'T> + end + val AdjustCalledArgTypeForLinqExpressionsAndAutoQuote : infoReader:InfoReader.InfoReader -> callerArgTy:TypedTree.TType -> calledArg:CalledArg -> m:Range.range -> TypedTree.TType - val AdjustCalledArgTypeForOptionals: + val AdjustCalledArgTypeForOptionals : g:TcGlobals.TcGlobals -> enforceNullableOptionalsKnownTypes:bool -> calledArg:CalledArg -> calledArgTy:TypedTree.TType -> callerArg:CallerArg<'a> -> TypedTree.TType - val AdjustCalledArgType: + val AdjustCalledArgType : infoReader:InfoReader.InfoReader -> isConstraint:bool -> enforceNullableOptionalsKnownTypes:bool -> @@ -3294,18 +28358,18 @@ namespace FSharp.Compiler ParamArrayCallerArgs: CallerArg<'T> list AssignedNamedArgs: AssignedCalledArg<'T> list } with - member NumAssignedNamedArgs: int - member NumUnnamedCalledArgs: int - member NumUnnamedCallerArgs: int - - val MakeCalledArgs: + member NumAssignedNamedArgs : int + member NumUnnamedCalledArgs : int + member NumUnnamedCallerArgs : int + end + val MakeCalledArgs : amap:Import.ImportMap -> m:Range.range -> minfo:Infos.MethInfo -> minst:TypedTree.TType list -> CalledArg list list type CalledMeth<'T> = - - new: infoReader:InfoReader.InfoReader * + class + new : infoReader:InfoReader.InfoReader * nameEnv:NameResolution.NameResolutionEnv option * isCheckingAttributeCall:bool * freshenMethInfo:(Range.range -> Infos.MethInfo -> @@ -3316,76 +28380,76 @@ namespace FSharp.Compiler callerObjArgTys:TypedTree.TType list * callerArgs:CallerArgs<'T> * allowParamArgs:bool * allowOutAndOptArgs:bool * tyargsOpt:TypedTree.TType option -> CalledMeth<'T> - static member GetMethod: x:CalledMeth<'T> -> Infos.MethInfo - member CalledObjArgTys: m:Range.range -> TypedTree.TType list - member GetParamArrayElementType: unit -> TypedTree.TType - member HasCorrectObjArgs: m:Range.range -> bool + static member GetMethod : x:CalledMeth<'T> -> Infos.MethInfo + member CalledObjArgTys : m:Range.range -> TypedTree.TType list + member GetParamArrayElementType : unit -> TypedTree.TType + member HasCorrectObjArgs : m:Range.range -> bool member - IsAccessible: m:Range.range * ad:AccessibilityLogic.AccessorDomain -> + IsAccessible : m:Range.range * ad:AccessibilityLogic.AccessorDomain -> bool member - IsCandidate: m:Range.range * ad:AccessibilityLogic.AccessorDomain -> + IsCandidate : m:Range.range * ad:AccessibilityLogic.AccessorDomain -> bool - override ToString: unit -> string - member AllCalledArgs: CalledArg list list - member AllUnnamedCalledArgs: CalledArg list - member ArgSets: CalledMethArgSet<'T> list - member AssignedItemSetters: AssignedItemSetter<'T> list - member AssignedNamedArgs: AssignedCalledArg<'T> list list - member AssignedUnnamedArgs: AssignedCalledArg<'T> list list - member AssignsAllNamedArgs: bool - member AssociatedPropertyInfo: Infos.PropInfo option - member AttributeAssignedNamedArgs: CallerNamedArg<'T> list - member CalledReturnTypeAfterByrefDeref: TypedTree.TType - member CalledReturnTypeAfterOutArgTupling: TypedTree.TType - member CalledTyArgs: TypedTree.TType list - member CalledTyparInst: TypedTreeOps.TyparInst - member CallerObjArgTys: TypedTree.TType list - member CallerTyArgs: TypedTree.TType list - member HasCorrectArity: bool - member HasCorrectGenericArity: bool - member HasOptArgs: bool - member HasOutArgs: bool - member Method: Infos.MethInfo - member NumArgSets: int - member NumAssignedProps: int - member NumCalledTyArgs: int - member NumCallerTyArgs: int - member ParamArrayCalledArgOpt: CalledArg option - member ParamArrayCallerArgs: CallerArg<'T> list option - member TotalNumAssignedNamedArgs: int - member TotalNumUnnamedCalledArgs: int - member TotalNumUnnamedCallerArgs: int - member UnassignedNamedArgs: CallerNamedArg<'T> list - member UnnamedCalledOptArgs: CalledArg list - member UnnamedCalledOutArgs: CalledArg list - member UsesParamArrayConversion: bool - member amap: Import.ImportMap - member infoReader: InfoReader.InfoReader - - val NamesOfCalledArgs: calledArgs:CalledArg list -> SyntaxTree.Ident list + override ToString : unit -> string + member AllCalledArgs : CalledArg list list + member AllUnnamedCalledArgs : CalledArg list + member ArgSets : CalledMethArgSet<'T> list + member AssignedItemSetters : AssignedItemSetter<'T> list + member AssignedNamedArgs : AssignedCalledArg<'T> list list + member AssignedUnnamedArgs : AssignedCalledArg<'T> list list + member AssignsAllNamedArgs : bool + member AssociatedPropertyInfo : Infos.PropInfo option + member AttributeAssignedNamedArgs : CallerNamedArg<'T> list + member CalledReturnTypeAfterByrefDeref : TypedTree.TType + member CalledReturnTypeAfterOutArgTupling : TypedTree.TType + member CalledTyArgs : TypedTree.TType list + member CalledTyparInst : TypedTreeOps.TyparInst + member CallerObjArgTys : TypedTree.TType list + member CallerTyArgs : TypedTree.TType list + member HasCorrectArity : bool + member HasCorrectGenericArity : bool + member HasOptArgs : bool + member HasOutArgs : bool + member Method : Infos.MethInfo + member NumArgSets : int + member NumAssignedProps : int + member NumCalledTyArgs : int + member NumCallerTyArgs : int + member ParamArrayCalledArgOpt : CalledArg option + member ParamArrayCallerArgs : CallerArg<'T> list option + member TotalNumAssignedNamedArgs : int + member TotalNumUnnamedCalledArgs : int + member TotalNumUnnamedCallerArgs : int + member UnassignedNamedArgs : CallerNamedArg<'T> list + member UnnamedCalledOptArgs : CalledArg list + member UnnamedCalledOutArgs : CalledArg list + member UsesParamArrayConversion : bool + member amap : Import.ImportMap + member infoReader : InfoReader.InfoReader + end + val NamesOfCalledArgs : calledArgs:CalledArg list -> SyntaxTree.Ident list type ArgumentAnalysis = | NoInfo | ArgDoesNotMatch | CallerLambdaHasArgTypes of TypedTree.TType list | CalledArgMatchesType of TypedTree.TType - val InferLambdaArgsForLambdaPropagation: + val InferLambdaArgsForLambdaPropagation : origRhsExpr:SyntaxTree.SynExpr -> int - val ExamineArgumentForLambdaPropagation: + val ExamineArgumentForLambdaPropagation : infoReader:InfoReader.InfoReader -> arg:AssignedCalledArg -> ArgumentAnalysis - val ExamineMethodForLambdaPropagation: + val ExamineMethodForLambdaPropagation : x:CalledMeth -> (ArgumentAnalysis list list * (SyntaxTree.Ident * ArgumentAnalysis) list list) option - val IsBaseCall: objArgs:TypedTree.Expr list -> bool - val ComputeConstrainedCallInfo: + val IsBaseCall : objArgs:TypedTree.Expr list -> bool + val ComputeConstrainedCallInfo : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> objArgs:TypedTree.Expr list * minfo:Infos.MethInfo -> TypedTree.TType option - val TakeObjAddrForMethodCall: + val TakeObjAddrForMethodCall : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> minfo:Infos.MethInfo -> @@ -3394,7 +28458,7 @@ namespace FSharp.Compiler objArgs:TypedTree.Expr list -> f:(TypedTree.TType option -> TypedTree.Expr list -> TypedTree.Expr * 'a) -> TypedTree.Expr * 'a - val BuildILMethInfoCall: + val BuildILMethInfoCall : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> @@ -3404,30 +28468,30 @@ namespace FSharp.Compiler minst:TypedTree.TType list -> direct:bool -> args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType - val BuildFSharpMethodApp: + val BuildFSharpMethodApp : g:TcGlobals.TcGlobals -> m:Range.range -> vref:TypedTree.ValRef -> vexp:TypedTree.Expr -> vexprty:TypedTree.TType -> args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType - val BuildFSharpMethodCall: + val BuildFSharpMethodCall : g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType * vref:TypedTree.ValRef -> valUseFlags:TypedTree.ValUseFlag -> minst:TypedTree.TType list -> args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType - val MakeMethInfoCall: + val MakeMethInfoCall : amap:Import.ImportMap -> m:Range.range -> minfo:Infos.MethInfo -> minst:TypedTree.TType list -> args:TypedTree.Exprs -> TypedTree.Expr - val TryImportProvidedMethodBaseAsLibraryIntrinsic: + val TryImportProvidedMethodBaseAsLibraryIntrinsic : amap:Import.ImportMap * m:Range.range * mbase:Tainted -> TypedTree.ValRef option - val BuildMethodCall: + val BuildMethodCall : tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TType list -> Range.range -> TypedTree.Expr * TypedTree.TType) -> g:TcGlobals.TcGlobals -> @@ -3441,14 +28505,14 @@ namespace FSharp.Compiler objArgs:TypedTree.Expr list -> args:TypedTree.Expr list -> TypedTree.Expr * TypedTree.TType - val BuildObjCtorCall: + val BuildObjCtorCall : g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.Expr - val BuildNewDelegateExpr: + val BuildNewDelegateExpr : eventInfoOpt:Infos.EventInfo option * g:TcGlobals.TcGlobals * amap:Import.ImportMap * delegateTy:TypedTree.TType * invokeMethInfo:Infos.MethInfo * delArgTys:TypedTree.TType list * f:TypedTree.Expr * fty:TypedTree.TType * m:Range.range -> TypedTree.Expr - val CoerceFromFSharpFuncToDelegate: + val CoerceFromFSharpFuncToDelegate : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> infoReader:InfoReader.InfoReader -> @@ -3457,7 +28521,7 @@ namespace FSharp.Compiler m:Range.range -> callerArgExpr:TypedTree.Expr -> delegateTy:TypedTree.TType -> TypedTree.Expr - val AdjustCallerArgExprForCoercions: + val AdjustCallerArgExprForCoercions : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> infoReader:InfoReader.InfoReader -> @@ -3469,8 +28533,8 @@ namespace FSharp.Compiler m:Range.range -> callerArgExpr:TypedTree.Expr -> 'a option * TypedTree.Expr - val emptyPreBinder: e:TypedTree.Expr -> TypedTree.Expr - val GetDefaultExpressionForCallerSideOptionalArg: + val emptyPreBinder : e:TypedTree.Expr -> TypedTree.Expr + val GetDefaultExpressionForCallerSideOptionalArg : tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> g:TcGlobals.TcGlobals -> calledArg:CalledArg -> @@ -3479,12 +28543,12 @@ namespace FSharp.Compiler eCallerMemberName:string option -> mMethExpr:Range.range -> (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr - val GetDefaultExpressionForCalleeSideOptionalArg: + val GetDefaultExpressionForCalleeSideOptionalArg : g:TcGlobals.TcGlobals -> calledArg:CalledArg -> eCallerMemberName:string option -> mMethExpr:Range.range -> TypedTree.Expr - val GetDefaultExpressionForOptionalArg: + val GetDefaultExpressionForOptionalArg : tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> g:TcGlobals.TcGlobals -> calledArg:CalledArg -> @@ -3493,18 +28557,18 @@ namespace FSharp.Compiler mMethExpr:Range.range -> (TypedTree.Expr -> TypedTree.Expr) * AssignedCalledArg - val MakeNullableExprIfNeeded: + val MakeNullableExprIfNeeded : infoReader:InfoReader.InfoReader -> calledArgTy:TypedTree.TType -> callerArgTy:TypedTree.TType -> callerArgExpr:TypedTree.Expr -> m:Range.range -> TypedTree.Expr - val AdjustCallerArgForOptional: + val AdjustCallerArgForOptional : tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> eCallerMemberName:string option -> infoReader:InfoReader.InfoReader -> assignedArg:AssignedCalledArg -> AssignedCalledArg - val AdjustCallerArgsForOptionals: + val AdjustCallerArgsForOptionals : tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> eCallerMemberName:string option -> infoReader:InfoReader.InfoReader -> @@ -3515,13 +28579,13 @@ namespace FSharp.Compiler (TypedTree.Expr -> TypedTree.Expr) * AssignedCalledArg list * AssignedCalledArg list - val AdjustOutCallerArgs: + val AdjustOutCallerArgs : g:TcGlobals.TcGlobals -> calledMeth:CalledMeth<'a> -> mMethExpr:Range.range -> AssignedCalledArg list * TypedTree.Expr list * TypedTree.Binding list - val AdjustParamArrayCallerArgs: + val AdjustParamArrayCallerArgs : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> infoReader:InfoReader.InfoReader -> @@ -3529,7 +28593,7 @@ namespace FSharp.Compiler calledMeth:CalledMeth -> mMethExpr:Range.range -> 'a option list * AssignedCalledArg list - val AdjustCallerArgs: + val AdjustCallerArgs : tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> eCallerMemberName:string option -> infoReader:InfoReader.InfoReader -> @@ -3544,18 +28608,18 @@ namespace FSharp.Compiler TypedTree.Expr list * (TypedTree.Expr -> TypedTree.Expr) * 'c option list * TypedTree.Expr list * TypedTree.Binding list - module ProvidedMethodCalls = - val private convertConstExpr: + module ProvidedMethodCalls = begin + val private convertConstExpr : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> constant:Tainted -> TypedTree.Expr - val eraseSystemType: + val eraseSystemType : amap:Import.ImportMap * m:Range.range * inputType:Tainted -> Tainted - val convertProvidedExpressionToExprAndWitness: + val convertProvidedExpressionToExprAndWitness : tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TType list -> Range.range -> TypedTree.Expr * TypedTree.TType) -> @@ -3567,7 +28631,7 @@ namespace FSharp.Compiler expr:Tainted -> Tainted option * (TypedTree.Expr * TypedTree.TType) - val TranslateInvokerExpressionForProvidedMethodCall: + val TranslateInvokerExpressionForProvidedMethodCall : tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TType list -> Range.range -> TypedTree.Expr * TypedTree.TType) -> @@ -3578,7 +28642,7 @@ namespace FSharp.Compiler objArgs:TypedTree.Expr list * allArgs:TypedTree.Exprs * m:Range.range -> Tainted option * (TypedTree.Expr * TypedTree.TType) - val BuildInvokerExpressionForProvidedMethodCall: + val BuildInvokerExpressionForProvidedMethodCall : tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TType list -> Range.range -> TypedTree.Expr * TypedTree.TType) -> @@ -3589,24 +28653,24 @@ namespace FSharp.Compiler m:Range.range -> Tainted option * TypedTree.Expr * TypedTree.TType - - val RecdFieldInstanceChecks: + end + val RecdFieldInstanceChecks : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> ad:AccessibilityLogic.AccessorDomain -> m:Range.range -> rfinfo:Infos.RecdFieldInfo -> unit - val ILFieldStaticChecks: + val ILFieldStaticChecks : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> infoReader:InfoReader.InfoReader -> ad:AccessibilityLogic.AccessorDomain -> m:Range.range -> finfo:Infos.ILFieldInfo -> unit - val ILFieldInstanceChecks: + val ILFieldInstanceChecks : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> ad:AccessibilityLogic.AccessorDomain -> m:Range.range -> finfo:Infos.ILFieldInfo -> unit - val MethInfoChecks: + val MethInfoChecks : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> isInstance:bool -> @@ -3617,31 +28681,31 @@ namespace FSharp.Compiler exception FieldNotMutable of TypedTreeOps.DisplayEnv * TypedTree.RecdFieldRef * Range.range - val CheckRecdFieldMutation: + val CheckRecdFieldMutation : m:Range.range -> denv:TypedTreeOps.DisplayEnv -> rfinfo:Infos.RecdFieldInfo -> unit - val GenWitnessExpr: + val GenWitnessExpr : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> m:Range.range -> traitInfo:TypedTree.TraitConstraintInfo -> argExprs:TypedTree.Expr list -> TypedTree.Expr option - val GenWitnessExprLambda: + val GenWitnessExprLambda : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> m:Range.range -> traitInfo:TypedTree.TraitConstraintInfo -> Choice - val GenWitnessArgs: + val GenWitnessArgs : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> m:Range.range -> traitInfos:TypedTree.TraitConstraintInfo list -> Choice list - + end namespace FSharp.Compiler - module internal PatternMatchCompilation = + module internal PatternMatchCompilation = begin exception MatchIncomplete of bool * (string * bool) option * Range.range exception RuleNeverMatched of Range.range exception EnumMatchIncomplete of bool * (string * bool) option * Range.range @@ -3651,7 +28715,7 @@ namespace FSharp.Compiler | Throw | Rethrow | FailFilter - [] + [] type Pattern = | TPat_const of TypedTree.Const * Range.range | TPat_wild of Range.range @@ -3677,32 +28741,32 @@ namespace FSharp.Compiler Range.range | TPat_error of Range.range with - member Range: Range.range - + member Range : Range.range + end and PatternValBinding = | PBind of TypedTree.Val * TypedTreeOps.TypeScheme and TypedMatchClause = | TClause of Pattern * TypedTree.Expr option * TypedTree.DecisionTreeTarget * Range.range with - member BoundVals: TypedTree.Val list - member GuardExpr: TypedTree.Expr option - member Pattern: Pattern - member Range: Range.range - member Target: TypedTree.DecisionTreeTarget - - val debug: bool + member BoundVals : TypedTree.Val list + member GuardExpr : TypedTree.Expr option + member Pattern : Pattern + member Range : Range.range + member Target : TypedTree.DecisionTreeTarget + end + val debug : bool type SubExprOfInput = | SubExpr of (TypedTreeOps.TyparInst -> TypedTree.Expr -> TypedTree.Expr) * (TypedTree.Expr * TypedTree.Val) - val BindSubExprOfInput: + val BindSubExprOfInput : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> gtps:TypedTree.Typar list -> PatternValBinding -> m:Range.range -> SubExprOfInput -> TypedTree.Val * TypedTree.Expr - val GetSubExprOfInput: + val GetSubExprOfInput : g:TcGlobals.TcGlobals -> gtps:'a list * tyargs:TypedTree.TType list * tinst:TypedTreeOps.TyparInst -> SubExprOfInput -> TypedTree.Expr @@ -3716,23 +28780,23 @@ namespace FSharp.Compiler | PathArray of Path * TypedTree.TType * int * int | PathExnConstr of Path * TypedTree.TyconRef * int | PathEmpty of TypedTree.TType - val pathEq: p1:Path -> p2:Path -> bool + val pathEq : p1:Path -> p2:Path -> bool type RefutedSet = | RefutedInvestigation of Path * TypedTree.DecisionTreeTest list | RefutedWhenClause - val notNullText: string - val otherSubtypeText: string - val ilFieldToTastConst: AbstractIL.IL.ILFieldInit -> TypedTree.Const + val notNullText : string + val otherSubtypeText : string + val ilFieldToTastConst : AbstractIL.IL.ILFieldInit -> TypedTree.Const exception CannotRefute - val RefuteDiscrimSet: + val RefuteDiscrimSet : g:TcGlobals.TcGlobals -> m:Range.range -> path:Path -> discrims:TypedTree.DecisionTreeTest list -> TypedTree.Expr * bool - val CombineRefutations: + val CombineRefutations : g:TcGlobals.TcGlobals -> r1:TypedTree.Expr -> r2:TypedTree.Expr -> TypedTree.Expr - val ShowCounterExample: + val ShowCounterExample : g:TcGlobals.TcGlobals -> denv:TypedTreeOps.DisplayEnv -> m:Range.range -> @@ -3744,56 +28808,56 @@ namespace FSharp.Compiler | Frontier of RuleNumber * Actives * TypedTreeOps.ValMap type InvestigationPoint = | Investigation of RuleNumber * TypedTree.DecisionTreeTest * Path - val isMemOfActives: p1:Path -> actives:Active list -> bool - val lookupActive: x:Path -> l:Active list -> SubExprOfInput * Pattern - val removeActive: x:Path -> l:Active list -> Active list - val getDiscrimOfPattern: + val isMemOfActives : p1:Path -> actives:Active list -> bool + val lookupActive : x:Path -> l:Active list -> SubExprOfInput * Pattern + val removeActive : x:Path -> l:Active list -> Active list + val getDiscrimOfPattern : g:TcGlobals.TcGlobals -> tpinst:TypedTreeOps.TyparInst -> t:Pattern -> TypedTree.DecisionTreeTest option - val constOfDiscrim: discrim:TypedTree.DecisionTreeTest -> TypedTree.Const - val constOfCase: c:TypedTree.DecisionTreeCase -> TypedTree.Const - val discrimsEq: + val constOfDiscrim : discrim:TypedTree.DecisionTreeTest -> TypedTree.Const + val constOfCase : c:TypedTree.DecisionTreeCase -> TypedTree.Const + val discrimsEq : g:TcGlobals.TcGlobals -> d1:TypedTree.DecisionTreeTest -> d2:TypedTree.DecisionTreeTest -> bool - val isDiscrimSubsumedBy: + val isDiscrimSubsumedBy : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> d1:TypedTree.DecisionTreeTest -> d2:TypedTree.DecisionTreeTest -> bool - val chooseSimultaneousEdgeSet: + val chooseSimultaneousEdgeSet : prevOpt:'a option -> f:('a option -> 'b -> 'a option) -> l:'b list -> 'a list * 'b list - val canCompactConstantClass: c:TypedTree.Const -> bool - val discrimsHaveSameSimultaneousClass: + val canCompactConstantClass : c:TypedTree.Const -> bool + val discrimsHaveSameSimultaneousClass : g:TcGlobals.TcGlobals -> d1:TypedTree.DecisionTreeTest -> d2:TypedTree.DecisionTreeTest -> bool - val canInvestigate: pat:Pattern -> bool - val ChooseInvestigationPointLeftToRight: frontiers:Frontier list -> Active - val ( |ConstNeedsDefaultCase|_| ): c:TypedTree.Const -> unit option - val BuildSwitch: + val canInvestigate : pat:Pattern -> bool + val ChooseInvestigationPointLeftToRight : frontiers:Frontier list -> Active + val ( |ConstNeedsDefaultCase|_| ) : c:TypedTree.Const -> unit option + val BuildSwitch : inpExprOpt:'a option -> g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> edges:TypedTree.DecisionTreeCase list -> dflt:TypedTree.DecisionTree option -> m:Range.range -> TypedTree.DecisionTree - val layoutPat: pat:Pattern -> Internal.Utilities.StructuredFormat.Layout - val layoutPath: _p:'a -> Internal.Utilities.StructuredFormat.Layout - val layoutActive: Active -> Internal.Utilities.StructuredFormat.Layout - val layoutFrontier: Frontier -> Internal.Utilities.StructuredFormat.Layout - val mkFrontiers: + val layoutPat : pat:Pattern -> Internal.Utilities.StructuredFormat.Layout + val layoutPath : _p:'a -> Internal.Utilities.StructuredFormat.Layout + val layoutActive : Active -> Internal.Utilities.StructuredFormat.Layout + val layoutFrontier : Frontier -> Internal.Utilities.StructuredFormat.Layout + val mkFrontiers : investigations:(Actives * TypedTreeOps.ValMap) list -> i:RuleNumber -> Frontier list - val getRuleIndex: Frontier -> RuleNumber - val isPatternPartial: p:Pattern -> bool - val erasePartialPatterns: inpp:Pattern -> Pattern - val erasePartials: inps:Pattern list -> Pattern list + val getRuleIndex : Frontier -> RuleNumber + val isPatternPartial : p:Pattern -> bool + val erasePartialPatterns : inpp:Pattern -> Pattern + val erasePartials : inps:Pattern list -> Pattern list type EdgeDiscrim = | EdgeDiscrim of int * TypedTree.DecisionTreeTest * Range.range - val getDiscrim: EdgeDiscrim -> TypedTree.DecisionTreeTest - val CompilePatternBasic: + val getDiscrim : EdgeDiscrim -> TypedTree.DecisionTreeTest + val CompilePatternBasic : g:TcGlobals.TcGlobals -> denv:TypedTreeOps.DisplayEnv -> amap:Import.ImportMap -> @@ -3814,8 +28878,8 @@ namespace FSharp.Compiler resultTy:TypedTree.TType -> TypedTree.DecisionTree * TypedTree.DecisionTreeTarget list - val isPartialOrWhenClause: c:TypedMatchClause -> bool - val CompilePattern: + val isPartialOrWhenClause : c:TypedMatchClause -> bool + val CompilePattern : TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv -> Import.ImportMap -> @@ -3833,52 +28897,52 @@ namespace FSharp.Compiler TypedTree.TType -> TypedTree.DecisionTree * TypedTree.DecisionTreeTarget list - + end namespace FSharp.Compiler - module internal ConstraintSolver = - val compgenId: SyntaxTree.Ident - val NewCompGenTypar: + module internal ConstraintSolver = begin + val compgenId : SyntaxTree.Ident + val NewCompGenTypar : kind:TypedTree.TyparKind * rigid:TypedTree.TyparRigidity * staticReq:SyntaxTree.TyparStaticReq * dynamicReq:TypedTree.TyparDynamicReq * error:bool -> TypedTree.Typar - val AnonTyparId: m:Range.range -> SyntaxTree.Ident - val NewAnonTypar: + val AnonTyparId : m:Range.range -> SyntaxTree.Ident + val NewAnonTypar : TypedTree.TyparKind * Range.range * TypedTree.TyparRigidity * SyntaxTree.TyparStaticReq * TypedTree.TyparDynamicReq -> TypedTree.Typar - val NewNamedInferenceMeasureVar: + val NewNamedInferenceMeasureVar : _m:'a * rigid:TypedTree.TyparRigidity * var:SyntaxTree.TyparStaticReq * id:SyntaxTree.Ident -> TypedTree.Typar - val NewInferenceMeasurePar: unit -> TypedTree.Typar - val NewErrorTypar: unit -> TypedTree.Typar - val NewErrorMeasureVar: unit -> TypedTree.Typar - val NewInferenceType: unit -> TypedTree.TType - val NewErrorType: unit -> TypedTree.TType - val NewErrorMeasure: unit -> TypedTree.Measure - val NewByRefKindInferenceType: + val NewInferenceMeasurePar : unit -> TypedTree.Typar + val NewErrorTypar : unit -> TypedTree.Typar + val NewErrorMeasureVar : unit -> TypedTree.Typar + val NewInferenceType : unit -> TypedTree.TType + val NewErrorType : unit -> TypedTree.TType + val NewErrorMeasure : unit -> TypedTree.Measure + val NewByRefKindInferenceType : TcGlobals.TcGlobals -> Range.range -> TypedTree.TType - val NewInferenceTypes: 'a list -> TypedTree.TType list - val FreshenAndFixupTypars: + val NewInferenceTypes : 'a list -> TypedTree.TType list + val FreshenAndFixupTypars : Range.range -> TypedTree.TyparRigidity -> TypedTree.Typars -> TypedTree.TType list -> TypedTree.Typar list -> TypedTree.Typar list * TypedTreeOps.TyparInst * TypedTree.TTypes - val FreshenTypeInst: + val FreshenTypeInst : Range.range -> TypedTree.Typar list -> TypedTree.Typar list * TypedTreeOps.TyparInst * TypedTree.TTypes - val FreshMethInst: + val FreshMethInst : m:Range.range -> fctps:TypedTree.Typars -> tinst:TypedTree.TType list -> tpsorig:TypedTree.Typar list -> TypedTree.Typar list * TypedTreeOps.TyparInst * TypedTree.TTypes - val FreshenTypars: + val FreshenTypars : Range.range -> TypedTree.Typar list -> TypedTree.TType list - val FreshenMethInfo: Range.range -> Infos.MethInfo -> TypedTree.TTypes - [] + val FreshenMethInfo : Range.range -> Infos.MethInfo -> TypedTree.TTypes + [] type ContextInfo = | NoContext | IfExpression of Range.range @@ -3984,7 +29048,7 @@ namespace FSharp.Compiler type TcValF = TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TType list -> Range.range -> TypedTree.Expr * TypedTree.TType - [] + [] type ConstraintSolverState = { g: TcGlobals.TcGlobals amap: Import.ImportMap @@ -3996,9 +29060,9 @@ namespace FSharp.Compiler Range.range)> } with static member - New: TcGlobals.TcGlobals * Import.ImportMap * InfoReader.InfoReader * + New : TcGlobals.TcGlobals * Import.ImportMap * InfoReader.InfoReader * TcValF -> ConstraintSolverState - + end type ConstraintSolverEnv = { SolverState: ConstraintSolverState eContextInfo: ContextInfo @@ -4007,51 +29071,51 @@ namespace FSharp.Compiler EquivEnv: TypedTreeOps.TypeEquivEnv DisplayEnv: TypedTreeOps.DisplayEnv } with - override ToString: unit -> string - member InfoReader: InfoReader.InfoReader - member amap: Import.ImportMap - member g: TcGlobals.TcGlobals - - val MakeConstraintSolverEnv: + override ToString : unit -> string + member InfoReader : InfoReader.InfoReader + member amap : Import.ImportMap + member g : TcGlobals.TcGlobals + end + val MakeConstraintSolverEnv : contextInfo:ContextInfo -> css:ConstraintSolverState -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> ConstraintSolverEnv - val occursCheck: + val occursCheck : g:TcGlobals.TcGlobals -> un:TypedTree.Typar -> ty:TypedTree.TType -> bool type PermitWeakResolution = | Yes | No with - member Permit: bool - - val isNativeIntegerTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isSignedIntegerTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isUnsignedIntegerTy: + member Permit : bool + end + val isNativeIntegerTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isSignedIntegerTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isUnsignedIntegerTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsIntegerOrIntegerEnumTy: + val IsIntegerOrIntegerEnumTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isIntegerTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isStringTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isCharTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isBoolTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isFpTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isDecimalTy: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsNonDecimalNumericOrIntegralEnumType: + val isIntegerTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isStringTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isCharTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isBoolTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isFpTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val isDecimalTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsNonDecimalNumericOrIntegralEnumType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsNumericOrIntegralEnumType: + val IsNumericOrIntegralEnumType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsNonDecimalNumericType: + val IsNonDecimalNumericType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsNumericType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsRelationalType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsCharOrStringType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsAddSubModType: + val IsNumericType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsRelationalType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsCharOrStringType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsAddSubModType : nm:string -> g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsBitwiseOpType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsBinaryOpOtherArgType: + val IsBitwiseOpType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsBinaryOpOtherArgType : g:TcGlobals.TcGlobals -> permitWeakResolution:PermitWeakResolution -> ty:TypedTree.TType -> bool - val IsSignType: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val IsSignType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool type TraitConstraintSolution = | TTraitUnsolved | TTraitBuiltIn @@ -4059,37 +29123,37 @@ namespace FSharp.Compiler | TTraitSolvedRecdProp of Infos.RecdFieldInfo * bool | TTraitSolvedAnonRecdProp of TypedTree.AnonRecdTypeInfo * TypedTree.TypeInst * int - val BakedInTraitConstraintNames: Set - [] + val BakedInTraitConstraintNames : Set + [] type Trace = { mutable actions: ((unit -> unit) * (unit -> unit)) list } with - static member New: unit -> Trace - member Push: f:(unit -> unit) -> undo:(unit -> unit) -> unit - member Undo: unit -> unit - + static member New : unit -> Trace + member Push : f:(unit -> unit) -> undo:(unit -> unit) -> unit + member Undo : unit -> unit + end type OptionalTrace = | NoTrace | WithTrace of Trace with - member AddFromReplay: source:Trace -> unit + member AddFromReplay : source:Trace -> unit member - CollectThenUndoOrCommit: predicate:('a -> bool) -> + CollectThenUndoOrCommit : predicate:('a -> bool) -> f:(Trace -> 'a) -> 'a - member Exec: f:(unit -> unit) -> undo:(unit -> unit) -> unit - member HasTrace: bool - - val CollectThenUndo: f:(Trace -> 'a) -> 'a - val FilterEachThenUndo: + member Exec : f:(unit -> unit) -> undo:(unit -> unit) -> unit + member HasTrace : bool + end + val CollectThenUndo : f:(Trace -> 'a) -> 'a + val FilterEachThenUndo : f:(Trace -> 'a -> ErrorLogger.OperationResult<'b>) -> meths:'a list -> ('a * exn list * Trace) list - val ShowAccessDomain: ad:AccessibilityLogic.AccessorDomain -> string + val ShowAccessDomain : ad:AccessibilityLogic.AccessorDomain -> string exception NonRigidTypar of displayEnv: TypedTreeOps.DisplayEnv * string option * Range.range * TypedTree.TType * TypedTree.TType * Range.range exception AbortForFailedOverloadResolution - val inline TryD_IgnoreAbortForFailedOverloadResolution: + val inline TryD_IgnoreAbortForFailedOverloadResolution : f1:(unit -> ErrorLogger.OperationResult) -> f2:(exn -> ErrorLogger.OperationResult) -> ErrorLogger.OperationResult @@ -4102,139 +29166,139 @@ namespace FSharp.Compiler callerArg: MethodCalls.CallerArg exception LocallyAbortOperationThatLosesAbbrevs - val localAbortD: ErrorLogger.OperationResult - val PreferUnifyTypar: v1:TypedTree.Typar -> v2:TypedTree.Typar -> bool - val FindPreferredTypar: + val localAbortD : ErrorLogger.OperationResult + val PreferUnifyTypar : v1:TypedTree.Typar -> v2:TypedTree.Typar -> bool + val FindPreferredTypar : vs:(TypedTree.Typar * 'a) list -> (TypedTree.Typar * 'a) list - val SubstMeasure: r:TypedTree.Typar -> ms:TypedTree.Measure -> unit - val TransactStaticReq: + val SubstMeasure : r:TypedTree.Typar -> ms:TypedTree.Measure -> unit + val TransactStaticReq : csenv:ConstraintSolverEnv -> trace:OptionalTrace -> tpr:TypedTree.Typar -> req:SyntaxTree.TyparStaticReq -> ErrorLogger.OperationResult - val SolveTypStaticReqTypar: + val SolveTypStaticReqTypar : csenv:ConstraintSolverEnv -> trace:OptionalTrace -> req:SyntaxTree.TyparStaticReq -> tpr:TypedTree.Typar -> ErrorLogger.OperationResult - val SolveTypStaticReq: + val SolveTypStaticReq : csenv:ConstraintSolverEnv -> trace:OptionalTrace -> req:SyntaxTree.TyparStaticReq -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val TransactDynamicReq: + val TransactDynamicReq : trace:OptionalTrace -> tpr:TypedTree.Typar -> req:TypedTree.TyparDynamicReq -> ErrorLogger.OperationResult - val SolveTypDynamicReq: + val SolveTypDynamicReq : csenv:ConstraintSolverEnv -> trace:OptionalTrace -> req:TypedTree.TyparDynamicReq -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val TransactIsCompatFlex: + val TransactIsCompatFlex : trace:OptionalTrace -> tpr:TypedTree.Typar -> req:bool -> ErrorLogger.OperationResult - val SolveTypIsCompatFlex: + val SolveTypIsCompatFlex : csenv:ConstraintSolverEnv -> trace:OptionalTrace -> req:bool -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SubstMeasureWarnIfRigid: + val SubstMeasureWarnIfRigid : csenv:ConstraintSolverEnv -> trace:OptionalTrace -> v:TypedTree.Typar -> ms:TypedTree.Measure -> ErrorLogger.OperationResult - val UnifyMeasureWithOne: + val UnifyMeasureWithOne : csenv:ConstraintSolverEnv -> trace:OptionalTrace -> ms:TypedTree.Measure -> ErrorLogger.OperationResult - val UnifyMeasures: + val UnifyMeasures : csenv:ConstraintSolverEnv -> trace:OptionalTrace -> ms1:TypedTree.Measure -> ms2:TypedTree.Measure -> ErrorLogger.OperationResult - val SimplifyMeasure: + val SimplifyMeasure : g:TcGlobals.TcGlobals -> vars:TypedTree.Typar list -> ms:TypedTree.Measure -> TypedTree.Typar list * TypedTree.Typar option - val SimplifyMeasuresInType: + val SimplifyMeasuresInType : g:TcGlobals.TcGlobals -> resultFirst:bool -> TypedTree.Typar list * TypedTree.Typar list -> ty:TypedTree.TType -> TypedTree.Typar list * TypedTree.Typar list - val SimplifyMeasuresInTypes: + val SimplifyMeasuresInTypes : g:TcGlobals.TcGlobals -> TypedTree.Typar list * TypedTree.Typar list -> tys:TypedTree.TypeInst -> TypedTree.Typar list * TypedTree.Typar list - val SimplifyMeasuresInConstraint: + val SimplifyMeasuresInConstraint : g:TcGlobals.TcGlobals -> TypedTree.Typar list * TypedTree.Typar list -> c:TypedTree.TyparConstraint -> TypedTree.Typar list * TypedTree.Typar list - val SimplifyMeasuresInConstraints: + val SimplifyMeasuresInConstraints : g:TcGlobals.TcGlobals -> TypedTree.Typar list * TypedTree.Typar list -> cs:TypedTree.TyparConstraint list -> TypedTree.Typar list * TypedTree.Typar list - val GetMeasureVarGcdInType: + val GetMeasureVarGcdInType : v:TypedTree.Typar -> ty:TypedTree.TType -> Rational.Rational - val GetMeasureVarGcdInTypes: + val GetMeasureVarGcdInTypes : v:TypedTree.Typar -> tys:TypedTree.TypeInst -> Rational.Rational - val NormalizeExponentsInTypeScheme: + val NormalizeExponentsInTypeScheme : uvars:TypedTree.Typar list -> ty:TypedTree.TType -> TypedTree.Typar list - val SimplifyMeasuresInTypeScheme: + val SimplifyMeasuresInTypeScheme : TcGlobals.TcGlobals -> bool -> TypedTree.Typar list -> TypedTree.TType -> TypedTree.TyparConstraint list -> TypedTree.Typar list - val freshMeasure: unit -> TypedTree.Measure - val CheckWarnIfRigid: + val freshMeasure : unit -> TypedTree.Measure + val CheckWarnIfRigid : csenv:ConstraintSolverEnv -> ty1:TypedTree.TType -> r:TypedTree.Typar -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTyparEqualsTypePart1: + val SolveTyparEqualsTypePart1 : csenv:ConstraintSolverEnv -> m2:Range.range -> trace:OptionalTrace -> ty1:TypedTree.TType -> r:TypedTree.Typar -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTyparEqualsTypePart2: + val SolveTyparEqualsTypePart2 : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> r:TypedTree.Typar -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val solveTypMeetsTyparConstraints: + val solveTypMeetsTyparConstraints : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty:TypedTree.TType -> r:TypedTree.Typar -> ErrorLogger.OperationResult - val SolveTyparEqualsType: + val SolveTyparEqualsType : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty1:TypedTree.TType -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTyparsEqualTypes: + val SolveTyparsEqualTypes : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> tptys:TypedTree.TType list -> tys:TypedTree.TType list -> ErrorLogger.OperationResult - val SolveAnonInfoEqualsAnonInfo: + val SolveAnonInfoEqualsAnonInfo : csenv:ConstraintSolverEnv -> m2:Range.range -> anonInfo1:TypedTree.AnonRecdTypeInfo -> anonInfo2:TypedTree.AnonRecdTypeInfo -> ErrorLogger.OperationResult - val SolveTypeEqualsType: + val SolveTypeEqualsType : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> @@ -4243,14 +29307,14 @@ namespace FSharp.Compiler TypedTree.TraitConstraintSln) option -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeEqualsTypeKeepAbbrevs: + val SolveTypeEqualsTypeKeepAbbrevs : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> ErrorLogger.OperationResult - val private SolveTypeEqualsTypeKeepAbbrevsWithCxsln: + val private SolveTypeEqualsTypeKeepAbbrevsWithCxsln : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> @@ -4259,7 +29323,7 @@ namespace FSharp.Compiler TypedTree.TraitConstraintSln) option -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeEqualsTypeEqns: + val SolveTypeEqualsTypeEqns : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> @@ -4268,7 +29332,7 @@ namespace FSharp.Compiler TypedTree.TraitConstraintSln) option -> origl1:TypedTree.TypeInst -> origl2:TypedTree.TypeInst -> ErrorLogger.OperationResult - val SolveFunTypeEqn: + val SolveFunTypeEqn : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> @@ -4279,7 +29343,7 @@ namespace FSharp.Compiler d2:TypedTree.TType -> r1:TypedTree.TType -> r2:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeSubsumesType: + val SolveTypeSubsumesType : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> @@ -4288,7 +29352,7 @@ namespace FSharp.Compiler TypedTree.TraitConstraintSln) option -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeSubsumesTypeKeepAbbrevs: + val SolveTypeSubsumesTypeKeepAbbrevs : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> @@ -4297,22 +29361,22 @@ namespace FSharp.Compiler TypedTree.TraitConstraintSln) option -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTyparSubtypeOfType: + val SolveTyparSubtypeOfType : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> tp:TypedTree.Typar -> ty1:TypedTree.TType -> ErrorLogger.OperationResult - val DepthCheck: + val DepthCheck : ndeep:int -> m:Range.range -> ErrorLogger.OperationResult - val SolveDimensionlessNumericType: + val SolveDimensionlessNumericType : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveMemberConstraint: + val SolveMemberConstraint : csenv:ConstraintSolverEnv -> ignoreUnresolvedOverload:bool -> permitWeakResolution:PermitWeakResolution -> @@ -4321,59 +29385,59 @@ namespace FSharp.Compiler trace:OptionalTrace -> traitInfo:TypedTree.TraitConstraintInfo -> ErrorLogger.OperationResult - val RecordMemberConstraintSolution: + val RecordMemberConstraintSolution : css:ConstraintSolverState -> m:Range.range -> trace:OptionalTrace -> traitInfo:TypedTree.TraitConstraintInfo -> res:TraitConstraintSolution -> ErrorLogger.OperationResult - val MemberConstraintSolutionOfMethInfo: + val MemberConstraintSolutionOfMethInfo : css:ConstraintSolverState -> m:Range.range -> minfo:Infos.MethInfo -> minst:TypedTree.TypeInst -> TypedTree.TraitConstraintSln - val TransactMemberConstraintSolution: + val TransactMemberConstraintSolution : traitInfo:TypedTree.TraitConstraintInfo -> trace:OptionalTrace -> sln:TypedTree.TraitConstraintSln -> unit - val GetRelevantMethodsForTrait: + val GetRelevantMethodsForTrait : csenv:ConstraintSolverEnv -> permitWeakResolution:PermitWeakResolution -> nm:string -> TypedTree.TraitConstraintInfo -> Infos.MethInfo list - val GetSupportOfMemberConstraint: + val GetSupportOfMemberConstraint : csenv:ConstraintSolverEnv -> TypedTree.TraitConstraintInfo -> TypedTree.Typar list - val SupportOfMemberConstraintIsFullySolved: + val SupportOfMemberConstraintIsFullySolved : csenv:ConstraintSolverEnv -> TypedTree.TraitConstraintInfo -> bool - val GetFreeTyparsOfMemberConstraint: + val GetFreeTyparsOfMemberConstraint : csenv:ConstraintSolverEnv -> TypedTree.TraitConstraintInfo -> TypedTree.Typar list - val MemberConstraintIsReadyForWeakResolution: + val MemberConstraintIsReadyForWeakResolution : csenv:ConstraintSolverEnv -> traitInfo:TypedTree.TraitConstraintInfo -> bool - val MemberConstraintIsReadyForStrongResolution: + val MemberConstraintIsReadyForStrongResolution : csenv:ConstraintSolverEnv -> traitInfo:TypedTree.TraitConstraintInfo -> bool - val MemberConstraintSupportIsReadyForDeterminingOverloads: + val MemberConstraintSupportIsReadyForDeterminingOverloads : csenv:ConstraintSolverEnv -> traitInfo:TypedTree.TraitConstraintInfo -> bool - val SolveRelevantMemberConstraints: + val SolveRelevantMemberConstraints : csenv:ConstraintSolverEnv -> ndeep:int -> permitWeakResolution:PermitWeakResolution -> trace:OptionalTrace -> tps:TypedTree.Typar list -> ErrorLogger.OperationResult - val SolveRelevantMemberConstraintsForTypar: + val SolveRelevantMemberConstraintsForTypar : csenv:ConstraintSolverEnv -> ndeep:int -> permitWeakResolution:PermitWeakResolution -> trace:OptionalTrace -> tp:TypedTree.Typar -> ErrorLogger.OperationResult - val CanonicalizeRelevantMemberConstraints: + val CanonicalizeRelevantMemberConstraints : csenv:ConstraintSolverEnv -> ndeep:int -> trace:OptionalTrace -> tps:TypedTree.Typar list -> ErrorLogger.OperationResult - val AddMemberConstraint: + val AddMemberConstraint : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> @@ -4382,7 +29446,7 @@ namespace FSharp.Compiler support:TypedTree.Typar list -> frees:TypedTree.Typar list -> ErrorLogger.OperationResult - val AddConstraint: + val AddConstraint : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> @@ -4390,32 +29454,32 @@ namespace FSharp.Compiler tp:TypedTree.Typar -> newConstraint:TypedTree.TyparConstraint -> ErrorLogger.OperationResult - val SolveTypeSupportsNull: + val SolveTypeSupportsNull : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeSupportsComparison: + val SolveTypeSupportsComparison : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeSupportsEquality: + val SolveTypeSupportsEquality : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeIsEnum: + val SolveTypeIsEnum : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty:TypedTree.TType -> underlying:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeIsDelegate: + val SolveTypeIsDelegate : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> @@ -4423,44 +29487,44 @@ namespace FSharp.Compiler ty:TypedTree.TType -> aty:TypedTree.TType -> bty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeIsNonNullableValueType: + val SolveTypeIsNonNullableValueType : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeIsUnmanaged: + val SolveTypeIsUnmanaged : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeChoice: + val SolveTypeChoice : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty:TypedTree.TType -> tys:TypedTree.TTypes -> ErrorLogger.OperationResult - val SolveTypeIsReferenceType: + val SolveTypeIsReferenceType : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeRequiresDefaultConstructor: + val SolveTypeRequiresDefaultConstructor : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> origTy:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeRequiresDefaultValue: + val SolveTypeRequiresDefaultValue : csenv:ConstraintSolverEnv -> ndeep:int -> m2:Range.range -> trace:OptionalTrace -> origTy:TypedTree.TType -> ErrorLogger.OperationResult - val CanMemberSigsMatchUpToCheck: + val CanMemberSigsMatchUpToCheck : csenv:ConstraintSolverEnv -> permitOptArgs:bool -> alwaysCheckReturn:bool -> @@ -4474,7 +29538,7 @@ namespace FSharp.Compiler reqdRetTyOpt:TypedTree.TType option -> calledMeth:MethodCalls.CalledMeth<'a> -> ErrorLogger.ImperativeOperationResult - val private SolveTypeSubsumesTypeWithWrappedContextualReport: + val private SolveTypeSubsumesTypeWithWrappedContextualReport : csenv:ConstraintSolverEnv -> ndeep:int -> m:Range.range -> @@ -4484,7 +29548,7 @@ namespace FSharp.Compiler ty1:TypedTree.TType -> ty2:TypedTree.TType -> wrapper:(exn -> #exn) -> ErrorLogger.OperationResult - val private SolveTypeSubsumesTypeWithReport: + val private SolveTypeSubsumesTypeWithReport : csenv:ConstraintSolverEnv -> ndeep:int -> m:Range.range -> @@ -4493,7 +29557,7 @@ namespace FSharp.Compiler TypedTree.TraitConstraintSln) option -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> ErrorLogger.OperationResult - val private SolveTypeEqualsTypeWithReport: + val private SolveTypeEqualsTypeWithReport : csenv:ConstraintSolverEnv -> ndeep:int -> m:Range.range -> @@ -4502,7 +29566,7 @@ namespace FSharp.Compiler TypedTree.TraitConstraintSln) option -> actual:TypedTree.TType -> expected:TypedTree.TType -> ErrorLogger.OperationResult - val ArgsMustSubsumeOrConvert: + val ArgsMustSubsumeOrConvert : csenv:ConstraintSolverEnv -> ndeep:int -> trace:OptionalTrace -> @@ -4512,21 +29576,21 @@ namespace FSharp.Compiler calledArg:MethodCalls.CalledArg -> callerArg:MethodCalls.CallerArg<'T> -> ErrorLogger.OperationResult - val MustUnify: + val MustUnify : csenv:ConstraintSolverEnv -> ndeep:int -> trace:OptionalTrace -> cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> ErrorLogger.OperationResult - val MustUnifyInsideUndo: + val MustUnifyInsideUndo : csenv:ConstraintSolverEnv -> ndeep:int -> trace:Trace -> cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> ErrorLogger.OperationResult - val ArgsMustSubsumeOrConvertInsideUndo: + val ArgsMustSubsumeOrConvertInsideUndo : csenv:ConstraintSolverEnv -> ndeep:int -> trace:Trace -> @@ -4536,7 +29600,7 @@ namespace FSharp.Compiler calledArg:MethodCalls.CalledArg -> MethodCalls.CallerArg -> ErrorLogger.OperationResult - val TypesMustSubsumeOrConvertInsideUndo: + val TypesMustSubsumeOrConvertInsideUndo : csenv:ConstraintSolverEnv -> ndeep:int -> trace:OptionalTrace -> @@ -4545,33 +29609,33 @@ namespace FSharp.Compiler calledArgTy:TypedTree.TType -> callerArgTy:TypedTree.TType -> ErrorLogger.OperationResult - val ArgsEquivInsideUndo: + val ArgsEquivInsideUndo : csenv:ConstraintSolverEnv -> isConstraint:bool -> calledArg:MethodCalls.CalledArg -> MethodCalls.CallerArg<'c> -> ErrorLogger.OperationResult - val ReportNoCandidatesError: + val ReportNoCandidatesError : csenv:ConstraintSolverEnv -> nUnnamedCallerArgs:System.Int32 * nNamedCallerArgs:int -> methodName:System.String -> ad:AccessibilityLogic.AccessorDomain -> calledMethGroup:MethodCalls.CalledMeth<'d> list -> isSequential:('d -> bool) -> ErrorLogger.OperationResult<'e> - val ReportNoCandidatesErrorExpr: + val ReportNoCandidatesErrorExpr : csenv:ConstraintSolverEnv -> System.Int32 * int -> methodName:System.String -> ad:AccessibilityLogic.AccessorDomain -> calledMethGroup:MethodCalls.CalledMeth list -> ErrorLogger.OperationResult<'f> - val ReportNoCandidatesErrorSynExpr: + val ReportNoCandidatesErrorSynExpr : csenv:ConstraintSolverEnv -> System.Int32 * int -> methodName:System.String -> ad:AccessibilityLogic.AccessorDomain -> calledMethGroup:MethodCalls.CalledMeth list -> ErrorLogger.OperationResult<'g> - val ResolveOverloading: + val ResolveOverloading : csenv:ConstraintSolverEnv -> trace:OptionalTrace -> methodName:string -> @@ -4584,7 +29648,7 @@ namespace FSharp.Compiler reqdRetTyOpt:TypedTree.TType option -> MethodCalls.CalledMeth option * ErrorLogger.OperationResult - val ResolveOverloadingForCall: + val ResolveOverloadingForCall : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> @@ -4598,7 +29662,7 @@ namespace FSharp.Compiler reqdRetTyOpt:TypedTree.TType option -> MethodCalls.CalledMeth option * ErrorLogger.OperationResult - val UnifyUniqueOverloading: + val UnifyUniqueOverloading : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> @@ -4607,102 +29671,102 @@ namespace FSharp.Compiler AccessibilityLogic.AccessorDomain -> MethodCalls.CalledMeth list -> TypedTree.TType -> ErrorLogger.OperationResult - val EliminateConstraintsForGeneralizedTypars: + val EliminateConstraintsForGeneralizedTypars : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.Typars -> unit - val AddCxTypeEqualsType: + val AddCxTypeEqualsType : ContextInfo -> TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> TypedTree.TType -> TypedTree.TType -> unit - val UndoIfFailed: f:(Trace -> ErrorLogger.OperationResult<'a>) -> bool - val UndoIfFailedOrWarnings: + val UndoIfFailed : f:(Trace -> ErrorLogger.OperationResult<'a>) -> bool + val UndoIfFailedOrWarnings : f:(Trace -> ErrorLogger.OperationResult<'a>) -> bool - val AddCxTypeEqualsTypeUndoIfFailed: + val AddCxTypeEqualsTypeUndoIfFailed : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> TypedTree.TType -> TypedTree.TType -> bool - val AddCxTypeEqualsTypeUndoIfFailedOrWarnings: + val AddCxTypeEqualsTypeUndoIfFailedOrWarnings : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> TypedTree.TType -> TypedTree.TType -> bool - val AddCxTypeEqualsTypeMatchingOnlyUndoIfFailed: + val AddCxTypeEqualsTypeMatchingOnlyUndoIfFailed : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> TypedTree.TType -> TypedTree.TType -> bool - val AddCxTypeMustSubsumeTypeUndoIfFailed: + val AddCxTypeMustSubsumeTypeUndoIfFailed : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> TypedTree.TType -> TypedTree.TType -> bool - val AddCxTypeMustSubsumeTypeMatchingOnlyUndoIfFailed: + val AddCxTypeMustSubsumeTypeMatchingOnlyUndoIfFailed : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> TypedTree.TType -> TypedTree.TType -> bool - val AddCxTypeMustSubsumeType: + val AddCxTypeMustSubsumeType : ContextInfo -> TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.TType -> TypedTree.TType -> unit - val AddCxMethodConstraint: + val AddCxMethodConstraint : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.TraitConstraintInfo -> unit - val AddCxTypeMustSupportNull: + val AddCxTypeMustSupportNull : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeMustSupportComparison: + val AddCxTypeMustSupportComparison : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeMustSupportEquality: + val AddCxTypeMustSupportEquality : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeMustSupportDefaultCtor: + val AddCxTypeMustSupportDefaultCtor : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeIsReferenceType: + val AddCxTypeIsReferenceType : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeIsValueType: + val AddCxTypeIsValueType : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeIsUnmanaged: + val AddCxTypeIsUnmanaged : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeIsEnum: + val AddCxTypeIsEnum : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.TType -> TypedTree.TType -> unit - val AddCxTypeIsDelegate: + val AddCxTypeIsDelegate : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> OptionalTrace -> TypedTree.TType -> TypedTree.TType -> TypedTree.TType -> unit - val AddCxTyparDefaultsTo: + val AddCxTyparDefaultsTo : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> ContextInfo -> TypedTree.Typar -> int -> TypedTree.TType -> unit - val SolveTypeAsError: + val SolveTypeAsError : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> TypedTree.TType -> unit - val ApplyTyparDefaultAtPriority: + val ApplyTyparDefaultAtPriority : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> priority:int -> TypedTree.Typar -> unit - val CreateCodegenState: + val CreateCodegenState : tcVal:TcValF -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> ConstraintSolverState - val CodegenWitnessExprForTraitConstraint: + val CodegenWitnessExprForTraitConstraint : TcValF -> TcGlobals.TcGlobals -> Import.ImportMap -> @@ -4710,7 +29774,7 @@ namespace FSharp.Compiler TypedTree.TraitConstraintInfo -> TypedTree.Expr list -> ErrorLogger.OperationResult - val CodegenWitnessesForTyparInst: + val CodegenWitnessesForTyparInst : TcValF -> TcGlobals.TcGlobals -> Import.ImportMap -> @@ -4719,7 +29783,7 @@ namespace FSharp.Compiler TypedTree.TType list -> ErrorLogger.OperationResult list> - val CodegenWitnessArgForTraitConstraint: + val CodegenWitnessArgForTraitConstraint : TcValF -> TcGlobals.TcGlobals -> Import.ImportMap -> @@ -4727,46 +29791,46 @@ namespace FSharp.Compiler TypedTree.TraitConstraintInfo -> ErrorLogger.OperationResult> - val ChooseTyparSolutionAndSolve: + val ChooseTyparSolutionAndSolve : ConstraintSolverState -> TypedTreeOps.DisplayEnv -> TypedTree.Typar -> unit - val CheckDeclaredTypars: + val CheckDeclaredTypars : TypedTreeOps.DisplayEnv -> ConstraintSolverState -> Range.range -> TypedTree.Typar list -> TypedTree.Typar list -> unit - val CanonicalizePartialInferenceProblem: + val CanonicalizePartialInferenceProblem : ConstraintSolverState -> TypedTreeOps.DisplayEnv -> Range.range -> TypedTree.Typar list -> unit - val IsApplicableMethApprox: + val IsApplicableMethApprox : TcGlobals.TcGlobals -> Import.ImportMap -> Range.range -> Infos.MethInfo -> TypedTree.TType -> bool - + end namespace FSharp.Compiler - module internal CheckFormatStrings = + module internal CheckFormatStrings = begin type FormatItem = | Simple of TypedTree.TType | FuncAndVal - val copyAndFixupFormatTypar: + val copyAndFixupFormatTypar : m:Range.range -> tp:TypedTree.Typar -> TypedTree.TType - val lowestDefaultPriority: int - val mkFlexibleFormatTypar: + val lowestDefaultPriority : int + val mkFlexibleFormatTypar : m:Range.range -> tys:TypedTree.TTypes -> dflt:TypedTree.TType -> TypedTree.TType - val mkFlexibleIntFormatTypar: + val mkFlexibleIntFormatTypar : g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.TType - val mkFlexibleDecimalFormatTypar: + val mkFlexibleDecimalFormatTypar : g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.TType - val mkFlexibleFloatFormatTypar: + val mkFlexibleFloatFormatTypar : g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.TType type FormatInfoRegister = { mutable leftJustify: bool mutable numPrefixIfPos: char option mutable addZeros: bool mutable precision: bool } - val newInfo: unit -> FormatInfoRegister - val parseFormatStringInternal: + val newInfo : unit -> FormatInfoRegister + val parseFormatStringInternal : m:Range.range -> fragRanges:Range.range list -> g:TcGlobals.TcGlobals -> @@ -4778,7 +29842,7 @@ namespace FSharp.Compiler printerResidueTy:TypedTree.TType -> TypedTree.TType list * (Range.range * int) list * string * TypedTree.TType [] - val ParseFormatString: + val ParseFormatString : m:Range.range -> fragmentRanges:Range.range list -> g:TcGlobals.TcGlobals -> @@ -4792,17 +29856,17 @@ namespace FSharp.Compiler TypedTree.TType list * TypedTree.TType * TypedTree.TType * TypedTree.TType [] * (Range.range * int) list * string - val TryCountFormatStringArguments: + val TryCountFormatStringArguments : m:Range.range -> g:TcGlobals.TcGlobals -> isInterpolated:bool -> fmt:string -> printerArgTy:TypedTree.TType -> printerResidueTy:TypedTree.TType -> int option - + end namespace FSharp.Compiler - module internal FindUnsolved = + module internal FindUnsolved = begin type env = | Nix type cenv = { g: TcGlobals.TcGlobals @@ -4810,105 +29874,105 @@ namespace FSharp.Compiler denv: TypedTreeOps.DisplayEnv mutable unsolved: TypedTree.Typars } with - override ToString: unit -> string - - val accTy: cenv:cenv -> _env:'a -> ty:TypedTree.TType -> unit - val accTypeInst: cenv:cenv -> env:'a -> tyargs:TypedTree.TType list -> unit - val accExpr: cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit - val accMethods: + override ToString : unit -> string + end + val accTy : cenv:cenv -> _env:'a -> ty:TypedTree.TType -> unit + val accTypeInst : cenv:cenv -> env:'a -> tyargs:TypedTree.TType list -> unit + val accExpr : cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit + val accMethods : cenv:cenv -> env:env -> baseValOpt:TypedTree.Val option -> l:TypedTree.ObjExprMethod list -> unit - val accMethod: + val accMethod : cenv:cenv -> env:env -> _baseValOpt:TypedTree.Val option -> TypedTree.ObjExprMethod -> unit - val accIntfImpls: + val accIntfImpls : cenv:cenv -> env:env -> baseValOpt:TypedTree.Val option -> l:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> unit - val accIntfImpl: + val accIntfImpl : cenv:cenv -> env:env -> baseValOpt:TypedTree.Val option -> ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> unit - val accOp: + val accOp : cenv:cenv -> env:env -> op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * _m:Range.range -> unit - val accTraitInfo: + val accTraitInfo : cenv:cenv -> env:env -> TypedTree.TraitConstraintInfo -> unit - val accLambdas: + val accLambdas : cenv:cenv -> env:env -> topValInfo:TypedTree.ValReprInfo -> e:TypedTree.Expr -> ety:TypedTree.TType -> unit - val accExprs: cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> unit - val accTargets: + val accExprs : cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> unit + val accTargets : cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> targets:TypedTree.DecisionTreeTarget array -> unit - val accTarget: + val accTarget : cenv:cenv -> env:env -> _m:Range.range -> _ty:TypedTree.TType -> TypedTree.DecisionTreeTarget -> unit - val accDTree: cenv:cenv -> env:env -> x:TypedTree.DecisionTree -> unit - val accSwitch: + val accDTree : cenv:cenv -> env:env -> x:TypedTree.DecisionTree -> unit + val accSwitch : cenv:cenv -> env:env -> e:TypedTree.Expr * cases:TypedTree.DecisionTreeCase list * dflt:TypedTree.DecisionTree option * _m:Range.range -> unit - val accDiscrim: + val accDiscrim : cenv:cenv -> env:env -> d:TypedTree.DecisionTreeTest -> unit - val accAttrib: cenv:cenv -> env:env -> TypedTree.Attrib -> unit - val accAttribs: + val accAttrib : cenv:cenv -> env:env -> TypedTree.Attrib -> unit + val accAttribs : cenv:cenv -> env:env -> attribs:TypedTree.Attrib list -> unit - val accValReprInfo: cenv:cenv -> env:env -> TypedTree.ValReprInfo -> unit - val accArgReprInfo: + val accValReprInfo : cenv:cenv -> env:env -> TypedTree.ValReprInfo -> unit + val accArgReprInfo : cenv:cenv -> env:env -> argInfo:TypedTree.ArgReprInfo -> unit - val accVal: cenv:cenv -> env:env -> v:TypedTree.Val -> unit - val accBind: cenv:cenv -> env:env -> bind:TypedTree.Binding -> unit - val accBinds: cenv:cenv -> env:env -> xs:TypedTree.Bindings -> unit - val accTyconRecdField: + val accVal : cenv:cenv -> env:env -> v:TypedTree.Val -> unit + val accBind : cenv:cenv -> env:env -> bind:TypedTree.Binding -> unit + val accBinds : cenv:cenv -> env:env -> xs:TypedTree.Bindings -> unit + val accTyconRecdField : cenv:cenv -> env:env -> _tycon:'a -> rfield:TypedTree.RecdField -> unit - val accTycon: cenv:cenv -> env:env -> tycon:TypedTree.Tycon -> unit - val accTycons: cenv:cenv -> env:env -> tycons:TypedTree.Tycon list -> unit - val accModuleOrNamespaceExpr: + val accTycon : cenv:cenv -> env:env -> tycon:TypedTree.Tycon -> unit + val accTycons : cenv:cenv -> env:env -> tycons:TypedTree.Tycon list -> unit + val accModuleOrNamespaceExpr : cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExprWithSig -> unit - val accModuleOrNamespaceDefs: + val accModuleOrNamespaceDefs : cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr list -> unit - val accModuleOrNamespaceDef: + val accModuleOrNamespaceDef : cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr -> unit - val accModuleOrNamespaceBinds: + val accModuleOrNamespaceBinds : cenv:cenv -> env:env -> xs:TypedTree.ModuleOrNamespaceBinding list -> unit - val accModuleOrNamespaceBind: + val accModuleOrNamespaceBind : cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceBinding -> unit - val UnsolvedTyparsOfModuleDef: + val UnsolvedTyparsOfModuleDef : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> denv:TypedTreeOps.DisplayEnv -> mdef:TypedTree.ModuleOrNamespaceExpr * extraAttribs:TypedTree.Attrib list -> TypedTree.Typar list - + end namespace FSharp.Compiler - module internal QuotationTranslator = - val verboseCReflect: bool - [] + module internal QuotationTranslator = begin + val verboseCReflect : bool + [] type IsReflectedDefinition = | Yes | No - [] + [] type QuotationSerializationFormat = { SupportsWitnesses: bool SupportsDeserializeEx: bool } - [] + [] type QuotationGenerationScope = { g: TcGlobals.TcGlobals amap: Import.ImportMap @@ -4924,18 +29988,18 @@ namespace FSharp.Compiler mutable emitDebugInfoInQuotations: bool } with static member - ComputeQuotationFormat: TcGlobals.TcGlobals -> + ComputeQuotationFormat : TcGlobals.TcGlobals -> QuotationSerializationFormat static member - Create: TcGlobals.TcGlobals * Import.ImportMap * TypedTree.CcuThunk * + Create : TcGlobals.TcGlobals * Import.ImportMap * TypedTree.CcuThunk * ConstraintSolver.TcValF * IsReflectedDefinition -> QuotationGenerationScope member - Close: unit -> + Close : unit -> AbstractIL.IL.ILTypeRef list * (TypedTree.TType * Range.range) list * (TypedTree.Expr * Range.range) list - + end type QuotationTranslationEnv = { vs: TypedTreeOps.ValMap numValsInScope: int @@ -4946,82 +30010,82 @@ namespace FSharp.Compiler substVals: TypedTreeOps.ValMap } with static member - CreateEmpty: g:TcGlobals.TcGlobals -> QuotationTranslationEnv - member BindTypar: v:TypedTree.Typar -> QuotationTranslationEnv - member BindTypars: vs:TypedTree.Typar list -> QuotationTranslationEnv + CreateEmpty : g:TcGlobals.TcGlobals -> QuotationTranslationEnv + member BindTypar : v:TypedTree.Typar -> QuotationTranslationEnv + member BindTypars : vs:TypedTree.Typar list -> QuotationTranslationEnv member - BindWitnessInfo: witnessInfo:TypedTree.TraitWitnessInfo -> + BindWitnessInfo : witnessInfo:TypedTree.TraitWitnessInfo -> QuotationTranslationEnv member - BindWitnessInfos: witnessInfos:TypedTree.TraitWitnessInfo list -> + BindWitnessInfos : witnessInfos:TypedTree.TraitWitnessInfo list -> QuotationTranslationEnv - - val BindFormalTypars: + end + val BindFormalTypars : env:QuotationTranslationEnv -> vs:TypedTree.Typar list -> QuotationTranslationEnv - val BindVal: + val BindVal : env:QuotationTranslationEnv -> v:TypedTree.Val -> QuotationTranslationEnv - val BindIsInstVal: + val BindIsInstVal : env:QuotationTranslationEnv -> v:TypedTree.Val -> ty:TypedTree.TType * e:TypedTree.Expr -> QuotationTranslationEnv - val BindSubstVal: + val BindSubstVal : env:QuotationTranslationEnv -> v:TypedTree.Val -> e:TypedTree.Expr -> QuotationTranslationEnv - val BindVals: + val BindVals : env:QuotationTranslationEnv -> vs:TypedTree.Val list -> QuotationTranslationEnv - val BindFlatVals: + val BindFlatVals : env:QuotationTranslationEnv -> vs:TypedTree.Val list -> QuotationTranslationEnv exception InvalidQuotedTerm of exn exception IgnoringPartOfQuotedTermWarning of string * Range.range - val wfail: e:exn -> 'a - val ( |ModuleValueOrMemberUse|_| ): + val wfail : e:exn -> 'a + val ( |ModuleValueOrMemberUse|_| ) : TcGlobals.TcGlobals -> TypedTree.Expr -> (TypedTree.ValRef * TypedTree.ValUseFlag * TypedTree.Expr * TypedTree.TType * TypedTree.TypeInst * TypedTree.Expr list) option - val ( |SimpleArrayLoopUpperBound|_| ): TypedTree.Expr -> unit option - val ( |SimpleArrayLoopBody|_| ): + val ( |SimpleArrayLoopUpperBound|_| ) : TypedTree.Expr -> unit option + val ( |SimpleArrayLoopBody|_| ) : TcGlobals.TcGlobals -> TypedTree.Expr -> (TypedTree.Expr * TypedTree.TType * TypedTree.Expr) option - val ( |ObjectInitializationCheck|_| ): + val ( |ObjectInitializationCheck|_| ) : TcGlobals.TcGlobals -> TypedTree.Expr -> unit option - val isSplice: TcGlobals.TcGlobals -> TypedTree.ValRef -> bool - val EmitDebugInfoIfNecessary: + val isSplice : TcGlobals.TcGlobals -> TypedTree.ValRef -> bool + val EmitDebugInfoIfNecessary : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> astExpr:QuotationPickler.ExprData -> QuotationPickler.ExprData - val ConvExpr: + val ConvExpr : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> expr:TypedTree.Expr -> QuotationPickler.ExprData - val GetWitnessArgs: + val GetWitnessArgs : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> tps:TypedTree.Typars -> tyargs:TypedTree.TType list -> QuotationPickler.ExprData list - val ConvWitnessInfo: + val ConvWitnessInfo : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> traitInfo:TypedTree.TraitConstraintInfo -> QuotationPickler.ExprData - val private ConvExprCore: + val private ConvExprCore : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> expr:TypedTree.Expr -> QuotationPickler.ExprData - val ConvLdfld: + val ConvLdfld : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> fspec:AbstractIL.IL.ILFieldSpec -> enclTypeArgs:TypedTree.TypeInst -> args:TypedTree.Exprs -> QuotationPickler.ExprData - val ConvUnionFieldGet: + val ConvUnionFieldGet : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> @@ -5029,39 +30093,39 @@ namespace FSharp.Compiler n:int -> tyargs:TypedTree.TypeInst -> e:TypedTree.Expr -> QuotationPickler.ExprData - val ConvClassOrRecdFieldGet: + val ConvClassOrRecdFieldGet : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> rfref:TypedTree.RecdFieldRef -> tyargs:TypedTree.TypeInst -> args:TypedTree.Exprs -> QuotationPickler.ExprData - val private ConvClassOrRecdFieldGetCore: + val private ConvClassOrRecdFieldGetCore : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> rfref:TypedTree.RecdFieldRef -> tyargs:TypedTree.TypeInst -> args:TypedTree.Exprs -> QuotationPickler.ExprData - val ConvLetBind: + val ConvLetBind : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> bind:TypedTree.Binding -> (QuotationPickler.VarData * QuotationPickler.ExprData) option * QuotationTranslationEnv - val ConvLValueArgs: + val ConvLValueArgs : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> args:TypedTree.Exprs -> QuotationPickler.ExprData list - val ConvLValueExpr: + val ConvLValueExpr : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> expr:TypedTree.Expr -> QuotationPickler.ExprData - val ConvLValueExprCore: + val ConvLValueExprCore : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> expr:TypedTree.Expr -> QuotationPickler.ExprData - val ConvObjectModelCall: + val ConvObjectModelCall : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> @@ -5070,7 +30134,7 @@ namespace FSharp.Compiler QuotationPickler.TypeData * string * TypedTree.TypeInst * int * TypedTree.Expr list * QuotationPickler.ExprData list * TypedTree.Expr list list -> QuotationPickler.ExprData - val ConvObjectModelCallCore: + val ConvObjectModelCallCore : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> @@ -5084,7 +30148,7 @@ namespace FSharp.Compiler witnessArgsR:QuotationPickler.ExprData list * untupledCurriedArgs:TypedTree.Expr list list -> QuotationPickler.ExprData - val ConvModuleValueApp: + val ConvModuleValueApp : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> @@ -5092,7 +30156,7 @@ namespace FSharp.Compiler tyargs:TypedTree.TypeInst -> witnessArgs:QuotationPickler.ExprData list -> args:TypedTree.Expr list list -> QuotationPickler.ExprData - val ConvModuleValueAppCore: + val ConvModuleValueAppCore : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> @@ -5101,107 +30165,107 @@ namespace FSharp.Compiler witnessArgsR:QuotationPickler.ExprData list -> curriedArgs:TypedTree.Expr list list -> QuotationPickler.ExprData - val ConvExprs: + val ConvExprs : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> args:TypedTree.Exprs -> QuotationPickler.ExprData list - val ConvValRef: + val ConvValRef : holeOk:bool -> cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> vref:TypedTree.ValRef -> tyargs:TypedTree.TypeInst -> QuotationPickler.ExprData - val private ConvValRefCore: + val private ConvValRefCore : holeOk:bool -> cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> vref:TypedTree.ValRef -> tyargs:TypedTree.TypeInst -> QuotationPickler.ExprData - val ConvUnionCaseRef: + val ConvUnionCaseRef : cenv:QuotationGenerationScope -> ucref:TypedTree.UnionCaseRef -> m:Range.range -> QuotationPickler.NamedTypeData * string - val ConvRecdFieldRef: + val ConvRecdFieldRef : cenv:QuotationGenerationScope -> rfref:TypedTree.RecdFieldRef -> m:Range.range -> QuotationPickler.NamedTypeData * string - val ConvVal: + val ConvVal : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> v:TypedTree.Val -> QuotationPickler.VarData - val ConvTyparRef: + val ConvTyparRef : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> tp:TypedTree.Typar -> int - val FilterMeasureTyargs: tys:TypedTree.TType list -> TypedTree.TType list - val ConvType: + val FilterMeasureTyargs : tys:TypedTree.TType list -> TypedTree.TType list + val ConvType : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> ty:TypedTree.TType -> QuotationPickler.TypeData - val ConvTypes: + val ConvTypes : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> tys:TypedTree.TType list -> QuotationPickler.TypeData list - val ConvConst: + val ConvConst : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> c:TypedTree.Const -> ty:TypedTree.TType -> QuotationPickler.ExprData - val ConvDecisionTree: + val ConvDecisionTree : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> tgs:TypedTree.DecisionTreeTarget array -> typR:QuotationPickler.TypeData -> x:TypedTree.DecisionTree -> QuotationPickler.ExprData - val IsILTypeRefStaticLinkLocal: + val IsILTypeRefStaticLinkLocal : cenv:QuotationGenerationScope -> m:Range.range -> tr:AbstractIL.IL.ILTypeRef -> bool - val ConvILTypeRefUnadjusted: + val ConvILTypeRefUnadjusted : cenv:QuotationGenerationScope -> m:Range.range -> tr:AbstractIL.IL.ILTypeRef -> QuotationPickler.NamedTypeData - val ConvILTypeRef: + val ConvILTypeRef : cenv:QuotationGenerationScope -> tr:AbstractIL.IL.ILTypeRef -> QuotationPickler.NamedTypeData - val ConvVoidType: + val ConvVoidType : cenv:QuotationGenerationScope -> m:Range.range -> QuotationPickler.TypeData - val ConvILType: + val ConvILType : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> m:Range.range -> ty:AbstractIL.IL.ILType -> QuotationPickler.TypeData - val TryElimErasableTyconRef: + val TryElimErasableTyconRef : cenv:QuotationGenerationScope -> m:Range.range -> tcref:TypedTree.TyconRef -> TypedTree.TType option - val ConvTyconRef: + val ConvTyconRef : cenv:QuotationGenerationScope -> tcref:TypedTree.TyconRef -> m:Range.range -> QuotationPickler.NamedTypeData - val ConvReturnType: + val ConvReturnType : cenv:QuotationGenerationScope -> envinner:QuotationTranslationEnv -> m:Range.range -> retTy:TypedTree.TType option -> QuotationPickler.TypeData - val ConvExprPublic: + val ConvExprPublic : QuotationGenerationScope -> suppressWitnesses:bool -> TypedTree.Expr -> QuotationPickler.ExprData - val ConvMethodBase: + val ConvMethodBase : cenv:QuotationGenerationScope -> env:QuotationTranslationEnv -> methName:string * v:TypedTree.Val -> QuotationPickler.MethodBaseData - val ConvReflectedDefinition: + val ConvReflectedDefinition : QuotationGenerationScope -> string -> TypedTree.Val -> TypedTree.Expr -> QuotationPickler.MethodBaseData * QuotationPickler.ExprData - + end namespace FSharp.Compiler - module internal PostTypeCheckSemanticChecks = + module internal PostTypeCheckSemanticChecks = begin type env = { boundTyparNames: string list boundTypars: TypedTreeOps.TyparMap @@ -5215,13 +30279,13 @@ namespace FSharp.Compiler returnScope: int isInAppExpr: bool } with - override ToString: unit -> string - - val BindTypar: env:env -> tp:TypedTree.Typar -> env - val BindTypars: + override ToString : unit -> string + end + val BindTypar : env:env -> tp:TypedTree.Typar -> env + val BindTypars : g:TcGlobals.TcGlobals -> env:env -> tps:TypedTree.Typar list -> env - val BindArgVals: env:env -> vs:TypedTree.Val list -> env - [] + val BindArgVals : env:env -> vs:TypedTree.Val list -> env + [] type LimitFlags = | None = 0 | ByRef = 1 @@ -5229,17 +30293,17 @@ namespace FSharp.Compiler | ByRefOfStackReferringSpanLike = 5 | SpanLike = 8 | StackReferringSpanLike = 16 - [] + [] type Limit = { scope: int flags: LimitFlags } with - member IsLocal: bool - - val inline HasLimitFlag: targetLimit:LimitFlags -> limit:Limit -> bool - val NoLimit: Limit - val CombineTwoLimits: limit1:Limit -> limit2:Limit -> Limit - val CombineLimits: limits:Limit list -> Limit + member IsLocal : bool + end + val inline HasLimitFlag : targetLimit:LimitFlags -> limit:Limit -> bool + val NoLimit : Limit + val CombineTwoLimits : limit1:Limit -> limit2:Limit -> Limit + val CombineLimits : limits:Limit list -> Limit type cenv = { boundVals: System.Collections.Generic.Dictionary limitVals: System.Collections.Generic.Dictionary @@ -5258,20 +30322,20 @@ namespace FSharp.Compiler mutable entryPointGiven: bool tcVal: ConstraintSolver.TcValF } with - override ToString: unit -> string - - val IsValArgument: env:env -> v:TypedTree.Val -> bool - val IsValLocal: env:env -> v:TypedTree.Val -> bool - val GetLimitVal: + override ToString : unit -> string + end + val IsValArgument : env:env -> v:TypedTree.Val -> bool + val IsValLocal : env:env -> v:TypedTree.Val -> bool + val GetLimitVal : cenv:cenv -> env:env -> m:Range.range -> v:TypedTree.Val -> Limit - val GetLimitValByRef: + val GetLimitValByRef : cenv:cenv -> env:env -> m:Range.range -> v:TypedTree.Val -> Limit - val LimitVal: cenv:cenv -> v:TypedTree.Val -> limit:Limit -> unit - val BindVal: cenv:cenv -> env:env -> v:TypedTree.Val -> unit - val BindVals: cenv:cenv -> env:env -> vs:TypedTree.Val list -> unit - val RecordAnonRecdInfo: + val LimitVal : cenv:cenv -> v:TypedTree.Val -> limit:Limit -> unit + val BindVal : cenv:cenv -> env:env -> v:TypedTree.Val -> unit + val BindVals : cenv:cenv -> env:env -> vs:TypedTree.Val list -> unit + val RecordAnonRecdInfo : cenv:cenv -> anonInfo:TypedTree.AnonRecdTypeInfo -> unit - val CheckTypeDeep: + val CheckTypeDeep : cenv:cenv -> (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * @@ -5279,21 +30343,21 @@ namespace FSharp.Compiler (env * TypedTree.Typar -> unit) option -> g:TcGlobals.TcGlobals -> env:env -> isInner:bool -> ty:TypedTree.TType -> unit - val CheckTypesDeep: + val CheckTypesDeep : cenv:cenv -> (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * (TypedTree.TraitConstraintSln -> unit) option * (env * TypedTree.Typar -> unit) option -> g:TcGlobals.TcGlobals -> env:env -> tys:TypedTree.TypeInst -> unit - val CheckTypesDeepNoInner: + val CheckTypesDeepNoInner : cenv:cenv -> (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * (TypedTree.TraitConstraintSln -> unit) option * (env * TypedTree.Typar -> unit) option -> g:TcGlobals.TcGlobals -> env:env -> tys:TypedTree.TypeInst -> unit - val CheckTypeConstraintDeep: + val CheckTypeConstraintDeep : cenv:cenv -> (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * @@ -5301,7 +30365,7 @@ namespace FSharp.Compiler (env * TypedTree.Typar -> unit) option -> g:TcGlobals.TcGlobals -> env:env -> x:TypedTree.TyparConstraint -> unit - val CheckTraitInfoDeep: + val CheckTraitInfoDeep : cenv:cenv -> (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * @@ -5309,41 +30373,41 @@ namespace FSharp.Compiler (env * TypedTree.Typar -> unit) option -> g:TcGlobals.TcGlobals -> env:env -> TypedTree.TraitConstraintInfo -> unit - val CheckForByrefLikeType: + val CheckForByrefLikeType : cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> check:(unit -> unit) -> unit - val CheckForByrefType: + val CheckForByrefType : cenv:cenv -> env:env -> ty:TypedTree.TType -> check:(unit -> unit) -> unit - val CheckEscapes: + val CheckEscapes : cenv:cenv -> allowProtected:bool -> m:Range.range -> syntacticArgs:TypedTree.Val list -> body:TypedTree.Expr -> TypedTree.FreeVars option - val AccessInternalsVisibleToAsInternal: + val AccessInternalsVisibleToAsInternal : thisCompPath:TypedTree.CompilationPath -> internalsVisibleToPaths:TypedTree.CompilationPath list -> access:TypedTree.Accessibility -> TypedTree.Accessibility - val CheckTypeForAccess: + val CheckTypeForAccess : cenv:cenv -> env:env -> objName:(unit -> System.String) -> valAcc:TypedTree.Accessibility -> m:Range.range -> ty:TypedTree.TType -> unit - val WarnOnWrongTypeForAccess: + val WarnOnWrongTypeForAccess : cenv:cenv -> env:env -> objName:(unit -> System.String) -> valAcc:TypedTree.Accessibility -> m:Range.range -> ty:TypedTree.TType -> unit - [] + [] type PermitByRefType = | None | NoInnerByRefLike | SpanLike | All - [] + [] type PermitByRefExpr = | YesTupleOfArgs of int | Yes @@ -5351,83 +30415,83 @@ namespace FSharp.Compiler | YesReturnableNonLocal | No with - member Disallow: bool - member PermitOnlyReturnable: bool - member PermitOnlyReturnableNonLocal: bool - - val inline IsLimitEscapingScope: + member Disallow : bool + member PermitOnlyReturnable : bool + member PermitOnlyReturnableNonLocal : bool + end + val inline IsLimitEscapingScope : env:env -> context:PermitByRefExpr -> limit:Limit -> bool - val mkArgsPermit: n:int -> PermitByRefExpr - val mkArgsForAppliedVal: + val mkArgsPermit : n:int -> PermitByRefExpr + val mkArgsForAppliedVal : isBaseCall:bool -> vref:TypedTree.ValRef -> argsl:'a list -> PermitByRefExpr list - val mkArgsForAppliedExpr: + val mkArgsForAppliedExpr : isBaseCall:bool -> argsl:'a list -> x:TypedTree.Expr -> PermitByRefExpr list - val CheckTypeAux: + val CheckTypeAux : permitByRefLike:PermitByRefType -> cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> onInnerByrefError:(unit -> unit) -> unit - val CheckType: + val CheckType : permitByRefLike:PermitByRefType -> cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit - val CheckTypeNoByrefs: + val CheckTypeNoByrefs : cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit - val CheckTypePermitSpanLike: + val CheckTypePermitSpanLike : cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit - val CheckTypePermitAllByrefs: + val CheckTypePermitAllByrefs : cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit - val CheckTypeNoInnerByrefs: + val CheckTypeNoInnerByrefs : cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit - val CheckTypeInstNoByrefs: + val CheckTypeInstNoByrefs : cenv:cenv -> env:env -> m:Range.range -> tyargs:TypedTree.TType list -> unit - val CheckTypeInstPermitAllByrefs: + val CheckTypeInstPermitAllByrefs : cenv:cenv -> env:env -> m:Range.range -> tyargs:TypedTree.TType list -> unit - val CheckTypeInstNoInnerByrefs: + val CheckTypeInstNoInnerByrefs : cenv:cenv -> env:env -> m:Range.range -> tyargs:TypedTree.TType list -> unit - val ( |OptionalCoerce| ): _arg1:TypedTree.Expr -> TypedTree.Expr - val CheckNoReraise: + val ( |OptionalCoerce| ) : _arg1:TypedTree.Expr -> TypedTree.Expr + val CheckNoReraise : cenv:cenv -> freesOpt:TypedTree.FreeVars option -> body:TypedTree.Expr -> unit - val isSpliceOperator: g:TcGlobals.TcGlobals -> v:TypedTree.ValRef -> bool + val isSpliceOperator : g:TcGlobals.TcGlobals -> v:TypedTree.ValRef -> bool type TTypeEquality = | ExactlyEqual | FeasiblyEqual | NotEqual - val compareTypesWithRegardToTypeVariablesAndMeasures: + val compareTypesWithRegardToTypeVariablesAndMeasures : g:TcGlobals.TcGlobals -> amap:'a -> m:Range.range -> typ1:TypedTree.TType -> typ2:TypedTree.TType -> TTypeEquality - val CheckMultipleInterfaceInstantiations: + val CheckMultipleInterfaceInstantiations : cenv:cenv -> typ:TypedTree.TType -> interfaces:TypedTree.TType list -> isObjectExpression:bool -> m:Range.range -> unit - val CheckExprNoByrefs: cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit - val CheckValRef: + val CheckExprNoByrefs : cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit + val CheckValRef : cenv:cenv -> env:env -> v:TypedTree.ValRef -> m:Range.range -> context:PermitByRefExpr -> unit - val CheckValUse: + val CheckValUse : cenv:cenv -> env:env -> vref:TypedTree.ValRef * vFlags:TypedTree.ValUseFlag * m:Range.range -> context:PermitByRefExpr -> Limit - val CheckForOverAppliedExceptionRaisingPrimitive: + val CheckForOverAppliedExceptionRaisingPrimitive : cenv:cenv -> expr:TypedTree.Expr -> unit - val CheckCallLimitArgs: + val CheckCallLimitArgs : cenv:cenv -> env:env -> m:Range.range -> returnTy:TypedTree.TType -> limitArgs:Limit -> context:PermitByRefExpr -> Limit - val CheckCall: + val CheckCall : cenv:cenv -> env:env -> m:Range.range -> @@ -5435,7 +30499,7 @@ namespace FSharp.Compiler args:TypedTree.Expr list -> contexts:PermitByRefExpr list -> context:PermitByRefExpr -> Limit - val CheckCallWithReceiver: + val CheckCallWithReceiver : cenv:cenv -> env:env -> m:Range.range -> @@ -5443,40 +30507,40 @@ namespace FSharp.Compiler args:TypedTree.Expr list -> contexts:PermitByRefExpr list -> context:PermitByRefExpr -> Limit - val CheckExprLinear: + val CheckExprLinear : cenv:cenv -> env:env -> expr:TypedTree.Expr -> context:PermitByRefExpr -> contf:(Limit -> Limit) -> Limit - val CheckExpr: + val CheckExpr : cenv:cenv -> env:env -> origExpr:TypedTree.Expr -> context:PermitByRefExpr -> Limit - val CheckMethods: + val CheckMethods : cenv:cenv -> env:env -> baseValOpt:TypedTree.Val option -> methods:TypedTree.ObjExprMethod list -> unit - val CheckMethod: + val CheckMethod : cenv:cenv -> env:env -> baseValOpt:TypedTree.Val option -> TypedTree.ObjExprMethod -> unit - val CheckInterfaceImpls: + val CheckInterfaceImpls : cenv:cenv -> env:env -> baseValOpt:TypedTree.Val option -> l:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> unit - val CheckInterfaceImpl: + val CheckInterfaceImpl : cenv:cenv -> env:env -> baseValOpt:TypedTree.Val option -> _ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> unit - val CheckExprOp: + val CheckExprOp : cenv:cenv -> env:env -> op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * m:Range.range -> context:PermitByRefExpr -> expr:TypedTree.Expr -> Limit - val CheckLambdas: + val CheckLambdas : isTop:bool -> memInfo:TypedTree.ValMemberInfo option -> cenv:cenv -> @@ -5487,83 +30551,83 @@ namespace FSharp.Compiler e:TypedTree.Expr -> mOrig:Range.range -> ety:TypedTree.TType -> context:PermitByRefExpr -> Limit - val CheckExprs: + val CheckExprs : cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> contexts:PermitByRefExpr list -> Limit - val CheckExprsNoByRefLike: + val CheckExprsNoByRefLike : cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> Limit - val CheckExprsPermitByRefLike: + val CheckExprsPermitByRefLike : cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> Limit - val CheckExprsPermitReturnableByRef: + val CheckExprsPermitReturnableByRef : cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> Limit - val CheckExprPermitByRefLike: + val CheckExprPermitByRefLike : cenv:cenv -> env:env -> expr:TypedTree.Expr -> Limit - val CheckExprPermitReturnableByRef: + val CheckExprPermitReturnableByRef : cenv:cenv -> env:env -> expr:TypedTree.Expr -> Limit - val CheckDecisionTreeTargets: + val CheckDecisionTreeTargets : cenv:cenv -> env:env -> targets:TypedTree.DecisionTreeTarget array -> context:PermitByRefExpr -> Limit - val CheckDecisionTreeTarget: + val CheckDecisionTreeTarget : cenv:cenv -> env:env -> context:PermitByRefExpr -> TypedTree.DecisionTreeTarget -> Limit - val CheckDecisionTree: + val CheckDecisionTree : cenv:cenv -> env:env -> x:TypedTree.DecisionTree -> unit - val CheckDecisionTreeSwitch: + val CheckDecisionTreeSwitch : cenv:cenv -> env:env -> e:TypedTree.Expr * cases:TypedTree.DecisionTreeCase list * dflt:TypedTree.DecisionTree option * m:Range.range -> unit - val CheckDecisionTreeTest: + val CheckDecisionTreeTest : cenv:cenv -> env:env -> m:Range.range -> discrim:TypedTree.DecisionTreeTest -> unit - val CheckAttrib: cenv:cenv -> env:env -> TypedTree.Attrib -> unit - val CheckAttribExpr: cenv:cenv -> env:env -> TypedTree.AttribExpr -> unit - val CheckAttribArgExpr: cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit - val CheckAttribs: cenv:cenv -> env:env -> attribs:TypedTree.Attribs -> unit - val CheckValInfo: cenv:cenv -> env:env -> TypedTree.ValReprInfo -> unit - val CheckArgInfo: + val CheckAttrib : cenv:cenv -> env:env -> TypedTree.Attrib -> unit + val CheckAttribExpr : cenv:cenv -> env:env -> TypedTree.AttribExpr -> unit + val CheckAttribArgExpr : cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit + val CheckAttribs : cenv:cenv -> env:env -> attribs:TypedTree.Attribs -> unit + val CheckValInfo : cenv:cenv -> env:env -> TypedTree.ValReprInfo -> unit + val CheckArgInfo : cenv:cenv -> env:env -> argInfo:TypedTree.ArgReprInfo -> unit - val CheckValSpecAux: + val CheckValSpecAux : permitByRefLike:PermitByRefType -> cenv:cenv -> env:env -> v:TypedTree.Val -> onInnerByrefError:(unit -> unit) -> unit - val CheckValSpec: + val CheckValSpec : permitByRefLike:PermitByRefType -> cenv:cenv -> env:env -> v:TypedTree.Val -> unit - val AdjustAccess: + val AdjustAccess : isHidden:bool -> cpath:(unit -> TypedTree.CompilationPath) -> access:TypedTree.Accessibility -> TypedTree.Accessibility - val CheckBinding: + val CheckBinding : cenv:cenv -> env:env -> alwaysCheckNoReraise:bool -> context:PermitByRefExpr -> TypedTree.Binding -> Limit - val CheckBindings: cenv:cenv -> env:env -> xs:TypedTree.Bindings -> unit - val CheckModuleBinding: cenv:cenv -> env:env -> TypedTree.Binding -> unit - val CheckModuleBindings: + val CheckBindings : cenv:cenv -> env:env -> xs:TypedTree.Bindings -> unit + val CheckModuleBinding : cenv:cenv -> env:env -> TypedTree.Binding -> unit + val CheckModuleBindings : cenv:cenv -> env:env -> binds:TypedTree.Binding list -> unit - val CheckRecdField: + val CheckRecdField : isUnion:bool -> cenv:cenv -> env:env -> tycon:TypedTree.Tycon -> rfield:TypedTree.RecdField -> unit - val CheckEntityDefn: cenv:cenv -> env:env -> tycon:TypedTree.Entity -> unit - val CheckEntityDefns: + val CheckEntityDefn : cenv:cenv -> env:env -> tycon:TypedTree.Entity -> unit + val CheckEntityDefns : cenv:cenv -> env:env -> tycons:TypedTree.Entity list -> unit - val CheckModuleExpr: + val CheckModuleExpr : cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExprWithSig -> unit - val CheckDefnsInModule: + val CheckDefnsInModule : cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr list -> unit - val CheckNothingAfterEntryPoint: cenv:cenv -> m:Range.range -> unit - val CheckDefnInModule: + val CheckNothingAfterEntryPoint : cenv:cenv -> m:Range.range -> unit + val CheckDefnInModule : cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr -> unit - val CheckModuleSpec: + val CheckModuleSpec : cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceBinding -> unit - val CheckTopImpl: + val CheckTopImpl : g:TcGlobals.TcGlobals * amap:Import.ImportMap * reportErrors:bool * infoReader:InfoReader.InfoReader * internalsVisibleToPaths:TypedTree.CompilationPath list * @@ -5573,14 +30637,14 @@ namespace FSharp.Compiler extraAttribs:TypedTree.Attribs * (bool * bool) * isInternalTestSpanStackReferring:bool -> bool * TypedTree.StampMap - + end namespace FSharp.Compiler - module internal CheckExpressions = - val mkNilListPat: + module internal CheckExpressions = begin + val mkNilListPat : g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType -> PatternMatchCompilation.Pattern - val mkConsListPat: + val mkConsListPat : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> ph:PatternMatchCompilation.Pattern -> @@ -5698,23 +30762,23 @@ namespace FSharp.Compiler type SafeInitData = | SafeInitField of TypedTree.RecdFieldRef * TypedTree.RecdField | NoSafeInitInfo - [] + [] type CtorInfo = { ctorShapeCounter: int safeThisValOpt: TypedTree.Val option safeInitInfo: SafeInitData ctorIsImplicit: bool } - [] + [] type UngeneralizableItem = - - new: computeFreeTyvars:(unit -> TypedTree.FreeTyvars) -> + class + new : computeFreeTyvars:(unit -> TypedTree.FreeTyvars) -> UngeneralizableItem - member GetFreeTyvars: unit -> TypedTree.FreeTyvars - member CachedFreeLocalTycons: TypedTree.FreeTycons - member CachedFreeTraitSolutions: TypedTree.FreeLocals - member WillNeverHaveFreeTypars: bool - - [] + member GetFreeTyvars : unit -> TypedTree.FreeTyvars + member CachedFreeLocalTycons : TypedTree.FreeTycons + member CachedFreeTraitSolutions : TypedTree.FreeLocals + member WillNeverHaveFreeTypars : bool + end + [] type TcEnv = { eNameResEnv: NameResolution.NameResolutionEnv eUngeneralizableItems: UngeneralizableItem list @@ -5729,68 +30793,68 @@ namespace FSharp.Compiler eCtorInfo: CtorInfo option eCallerMemberName: string option } with - override ToString: unit -> string - member AccessRights: AccessibilityLogic.AccessorDomain - member DisplayEnv: TypedTreeOps.DisplayEnv - member NameEnv: NameResolution.NameResolutionEnv - - val ComputeAccessRights: + override ToString : unit -> string + member AccessRights : AccessibilityLogic.AccessorDomain + member DisplayEnv : TypedTreeOps.DisplayEnv + member NameEnv : NameResolution.NameResolutionEnv + end + val ComputeAccessRights : eAccessPath:TypedTree.CompilationPath -> eInternalsVisibleCompPaths:TypedTree.CompilationPath list -> eFamilyType:TypedTree.TyconRef option -> AccessibilityLogic.AccessorDomain - val InitialExplicitCtorInfo: + val InitialExplicitCtorInfo : safeThisValOpt:TypedTree.Val option * safeInitInfo:SafeInitData -> CtorInfo - val InitialImplicitCtorInfo: unit -> CtorInfo - val EnterFamilyRegion: tcref:TypedTree.TyconRef -> env:TcEnv -> TcEnv - val ExitFamilyRegion: env:TcEnv -> TcEnv - val AreWithinCtorShape: env:TcEnv -> bool - val AreWithinImplicitCtor: env:TcEnv -> bool - val GetCtorShapeCounter: env:TcEnv -> int - val GetRecdInfo: env:TcEnv -> TypedTree.RecordConstructionInfo - val AdjustCtorShapeCounter: f:(int -> int) -> env:TcEnv -> TcEnv - val ExitCtorShapeRegion: env:TcEnv -> TcEnv - val addFreeItemOfTy: + val InitialImplicitCtorInfo : unit -> CtorInfo + val EnterFamilyRegion : tcref:TypedTree.TyconRef -> env:TcEnv -> TcEnv + val ExitFamilyRegion : env:TcEnv -> TcEnv + val AreWithinCtorShape : env:TcEnv -> bool + val AreWithinImplicitCtor : env:TcEnv -> bool + val GetCtorShapeCounter : env:TcEnv -> int + val GetRecdInfo : env:TcEnv -> TypedTree.RecordConstructionInfo + val AdjustCtorShapeCounter : f:(int -> int) -> env:TcEnv -> TcEnv + val ExitCtorShapeRegion : env:TcEnv -> TcEnv + val addFreeItemOfTy : ty:TypedTree.TType -> eUngeneralizableItems:UngeneralizableItem list -> UngeneralizableItem list - val addFreeItemOfModuleTy: + val addFreeItemOfModuleTy : TypedTree.ModuleOrNamespaceType -> UngeneralizableItem list -> UngeneralizableItem list - val AddValMapToNameEnv: + val AddValMapToNameEnv : vs:AbstractIL.Internal.Library.NameMap -> nenv:NameResolution.NameResolutionEnv -> NameResolution.NameResolutionEnv - val AddValListToNameEnv: + val AddValListToNameEnv : vs:TypedTree.Val list -> nenv:NameResolution.NameResolutionEnv -> NameResolution.NameResolutionEnv - val AddLocalValPrimitive: v:TypedTree.Val -> TcEnv -> TcEnv - val AddLocalValMap: + val AddLocalValPrimitive : v:TypedTree.Val -> TcEnv -> TcEnv + val AddLocalValMap : tcSink:NameResolution.TcResultsSink -> scopem:Range.range -> vals:AbstractIL.Internal.Library.NameMap -> env:TcEnv -> TcEnv - val AddLocalVals: + val AddLocalVals : tcSink:NameResolution.TcResultsSink -> scopem:Range.range -> vals:TypedTree.Val list -> env:TcEnv -> TcEnv - val AddLocalVal: + val AddLocalVal : NameResolution.TcResultsSink -> scopem:Range.range -> v:TypedTree.Val -> TcEnv -> TcEnv - val AddDeclaredTypars: + val AddDeclaredTypars : check:NameResolution.CheckForDuplicateTyparFlag -> typars:TypedTree.Typar list -> env:TcEnv -> TcEnv type UnscopedTyparEnv = | UnscopedTyparEnv of AbstractIL.Internal.Library.NameMap - val emptyUnscopedTyparEnv: UnscopedTyparEnv - val AddUnscopedTypar: + val emptyUnscopedTyparEnv : UnscopedTyparEnv + val AddUnscopedTypar : n:string -> p:TypedTree.Typar -> UnscopedTyparEnv -> UnscopedTyparEnv - val TryFindUnscopedTypar: + val TryFindUnscopedTypar : n:string -> UnscopedTyparEnv -> TypedTree.Typar option - val HideUnscopedTypars: + val HideUnscopedTypars : typars:TypedTree.Typar list -> UnscopedTyparEnv -> UnscopedTyparEnv - [] + [] type TcFileState = { g: TcGlobals.TcGlobals mutable recUses: @@ -5825,7 +30889,7 @@ namespace FSharp.Compiler TypedTree.Expr * UnscopedTyparEnv } with static member - Create: g:TcGlobals.TcGlobals * isScript:bool * + Create : g:TcGlobals.TcGlobals * isScript:bool * niceNameGen:CompilerGlobalState.NiceNameGenerator * amap:Import.ImportMap * topCcu:TypedTree.CcuThunk * isSig:bool * haveSig:bool * @@ -5856,51 +30920,51 @@ namespace FSharp.Compiler SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv) -> TcFileState - override ToString: unit -> string - + override ToString : unit -> string + end type cenv = TcFileState - val CopyAndFixupTypars: + val CopyAndFixupTypars : m:Range.range -> rigid:TypedTree.TyparRigidity -> tpsorig:TypedTree.Typars -> TypedTree.Typars * TypedTreeOps.TyparInst * TypedTree.TType list - val UnifyTypes: + val UnifyTypes : cenv:TcFileState -> env:TcEnv -> m:Range.range -> actualTy:TypedTree.TType -> expectedTy:TypedTree.TType -> unit - val MakeInnerEnvWithAcc: + val MakeInnerEnvWithAcc : addOpenToNameEnv:bool -> env:TcEnv -> nm:SyntaxTree.Ident -> mtypeAcc:TypedTree.ModuleOrNamespaceType ref -> modKind:TypedTree.ModuleOrNamespaceKind -> TcEnv - val MakeInnerEnv: + val MakeInnerEnv : addOpenToNameEnv:bool -> env:TcEnv -> nm:SyntaxTree.Ident -> modKind:TypedTree.ModuleOrNamespaceKind -> TcEnv * TypedTree.ModuleOrNamespaceType ref - val MakeInnerEnvForTyconRef: + val MakeInnerEnvForTyconRef : env:TcEnv -> tcref:TypedTree.TyconRef -> isExtrinsicExtension:bool -> TcEnv - val MakeInnerEnvForMember: env:TcEnv -> v:TypedTree.Val -> TcEnv - val GetCurrAccumulatedModuleOrNamespaceType: + val MakeInnerEnvForMember : env:TcEnv -> v:TypedTree.Val -> TcEnv + val GetCurrAccumulatedModuleOrNamespaceType : env:TcEnv -> TypedTree.ModuleOrNamespaceType - val SetCurrAccumulatedModuleOrNamespaceType: + val SetCurrAccumulatedModuleOrNamespaceType : env:TcEnv -> x:TypedTree.ModuleOrNamespaceType -> unit - val LocateEnv: + val LocateEnv : ccu:TypedTree.CcuThunk -> env:TcEnv -> enclosingNamespacePath:SyntaxTree.Ident list -> TcEnv - val ShrinkContext: + val ShrinkContext : env:TcEnv -> oldRange:Range.range -> newRange:Range.range -> TcEnv - val UnifyRefTupleType: + val UnifyRefTupleType : contextInfo:ConstraintSolver.ContextInfo -> cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> m:Range.range -> ty:TypedTree.TType -> ps:'a list -> TypedTree.TTypes - val UnifyTupleTypeAndInferCharacteristics: + val UnifyTupleTypeAndInferCharacteristics : contextInfo:ConstraintSolver.ContextInfo -> cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> @@ -5908,7 +30972,7 @@ namespace FSharp.Compiler knownTy:TypedTree.TType -> isExplicitStruct:bool -> ps:'a list -> TypedTree.TupInfo * TypedTree.TTypes - val UnifyAnonRecdTypeAndInferCharacteristics: + val UnifyAnonRecdTypeAndInferCharacteristics : contextInfo:ConstraintSolver.ContextInfo -> cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> @@ -5917,75 +30981,75 @@ namespace FSharp.Compiler isExplicitStruct:bool -> unsortedNames:SyntaxTree.Ident [] -> TypedTree.AnonRecdTypeInfo * TypedTree.TType list - val UnifyFunctionTypeUndoIfFailed: + val UnifyFunctionTypeUndoIfFailed : cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> m:Range.range -> ty:TypedTree.TType -> (TypedTree.TType * TypedTree.TType) voption - val UnifyFunctionType: + val UnifyFunctionType : extraInfo:Range.range option -> cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> mFunExpr:Range.range -> ty:TypedTree.TType -> TypedTree.TType * TypedTree.TType - val ReportImplicitlyIgnoredBoolExpression: + val ReportImplicitlyIgnoredBoolExpression : denv:TypedTreeOps.DisplayEnv -> m:Range.range -> ty:TypedTree.TType -> expr:TypedTree.Expr -> exn - val UnifyUnitType: + val UnifyUnitType : cenv:TcFileState -> env:TcEnv -> m:Range.range -> ty:TypedTree.TType -> expr:TypedTree.Expr -> bool - val TryUnifyUnitTypeWithoutWarning: + val TryUnifyUnitTypeWithoutWarning : cenv:TcFileState -> env:TcEnv -> m:Range.range -> ty:TypedTree.TType -> bool - module AttributeTargets = - val FieldDecl: System.AttributeTargets - val FieldDeclRestricted: System.AttributeTargets - val UnionCaseDecl: System.AttributeTargets - val TyconDecl: System.AttributeTargets - val ExnDecl: System.AttributeTargets - val ModuleDecl: System.AttributeTargets - val Top: System.AttributeTargets - - val ForNewConstructors: + module AttributeTargets = begin + val FieldDecl : System.AttributeTargets + val FieldDeclRestricted : System.AttributeTargets + val UnionCaseDecl : System.AttributeTargets + val TyconDecl : System.AttributeTargets + val ExnDecl : System.AttributeTargets + val ModuleDecl : System.AttributeTargets + val Top : System.AttributeTargets + end + val ForNewConstructors : tcSink:NameResolution.TcResultsSink -> env:TcEnv -> mObjTy:Range.range -> methodName:string -> meths:Infos.MethInfo list -> NameResolution.AfterResolution - val TcSynRationalConst: c:SyntaxTree.SynRationalConst -> Rational.Rational - val TcConst: + val TcSynRationalConst : c:SyntaxTree.SynRationalConst -> Rational.Rational + val TcConst : cenv:TcFileState -> ty:TypedTree.TType -> m:Range.range -> env:TcEnv -> c:SyntaxTree.SynConst -> TypedTree.Const - val TcFieldInit: + val TcFieldInit : Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const - val AdjustValSynInfoInSignature: + val AdjustValSynInfoInSignature : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo type PartialValReprInfo = | PartialValReprInfo of curriedArgInfos: TypedTree.ArgReprInfo list list * returnInfo: TypedTree.ArgReprInfo - val TranslateTopArgSynInfo: + val TranslateTopArgSynInfo : isArg:bool -> m:Range.range -> tcAttributes:(SyntaxTree.SynAttribute list -> TypedTree.Attribs) -> SyntaxTree.SynArgInfo -> TypedTree.ArgReprInfo - val TranslateTopValSynInfo: + val TranslateTopValSynInfo : Range.range -> tcAttributes:(System.AttributeTargets -> SyntaxTree.SynAttribute list -> TypedTree.Attribs) -> synValInfo:SyntaxTree.SynValInfo -> PartialValReprInfo - val TranslatePartialArity: + val TranslatePartialArity : tps:TypedTree.Typar list -> PartialValReprInfo -> TypedTree.ValReprInfo - val ComputeLogicalName: + val ComputeLogicalName : id:SyntaxTree.Ident -> memberFlags:SyntaxTree.MemberFlags -> string type PreValMemberInfo = | PreValMemberInfo of memberInfo: TypedTree.ValMemberInfo * logicalName: string * compiledName: string - val MakeMemberDataAndMangledNameForMemberVal: + val MakeMemberDataAndMangledNameForMemberVal : g:TcGlobals.TcGlobals * tcref:TypedTree.TyconRef * isExtrinsic:bool * attrs:TypedTree.Attribs * optImplSlotTys:TypedTree.TType list * memberFlags:SyntaxTree.MemberFlags * valSynData:SyntaxTree.SynValInfo * @@ -5998,11 +31062,11 @@ namespace FSharp.Compiler | ExplicitTyparInfo of rigidCopyOfDeclaredTypars: TypedTree.Typars * declaredTypars: TypedTree.Typars * infer: bool - val permitInferTypars: ExplicitTyparInfo - val dontInferTypars: ExplicitTyparInfo + val permitInferTypars : ExplicitTyparInfo + val dontInferTypars : ExplicitTyparInfo type ArgAndRetAttribs = | ArgAndRetAttribs of TypedTree.Attribs list list * TypedTree.Attribs - val noArgOrRetAttribs: ArgAndRetAttribs + val noArgOrRetAttribs : ArgAndRetAttribs type DeclKind = | ModuleOrMemberBinding | IntrinsicExtensionBinding @@ -6012,18 +31076,18 @@ namespace FSharp.Compiler | ExpressionBinding with static member - AllowedAttribTargets: SyntaxTree.MemberFlags option -> + AllowedAttribTargets : SyntaxTree.MemberFlags option -> DeclKind -> System.AttributeTargets - static member CanGeneralizeConstrainedTypars: DeclKind -> bool - static member CanOverrideOrImplement: DeclKind -> OverridesOK - static member ConvertToLinearBindings: DeclKind -> bool - static member ImplicitlyStatic: DeclKind -> bool - static member IsAccessModifierPermitted: DeclKind -> bool - static member IsModuleOrMemberOrExtensionBinding: DeclKind -> bool - static member MustHaveArity: DeclKind -> bool - member CanBeDllImport: bool - - [] + static member CanGeneralizeConstrainedTypars : DeclKind -> bool + static member CanOverrideOrImplement : DeclKind -> OverridesOK + static member ConvertToLinearBindings : DeclKind -> bool + static member ImplicitlyStatic : DeclKind -> bool + static member IsAccessModifierPermitted : DeclKind -> bool + static member IsModuleOrMemberOrExtensionBinding : DeclKind -> bool + static member MustHaveArity : DeclKind -> bool + member CanBeDllImport : bool + end + [] type PrelimValScheme1 = | PrelimValScheme1 of id: SyntaxTree.Ident * explicitTyparInfo: ExplicitTyparInfo * @@ -6031,9 +31095,9 @@ namespace FSharp.Compiler bool * TypedTree.ValInline * TypedTree.ValBaseOrThisInfo * ArgAndRetAttribs * SyntaxTree.SynAccess option * bool with - member Ident: SyntaxTree.Ident - member Type: TypedTree.TType - + member Ident : SyntaxTree.Ident + member Type : TypedTree.TType + end type PrelimValScheme2 = | PrelimValScheme2 of SyntaxTree.Ident * TypedTreeOps.TypeScheme * PartialValReprInfo option * @@ -6050,18 +31114,18 @@ namespace FSharp.Compiler visibility: SyntaxTree.SynAccess option * compgen: bool * isIncrClass: bool * isTyFunc: bool * hasDeclaredTypars: bool with - member GeneralizedTypars: TypedTree.Typars - member TypeScheme: TypedTreeOps.TypeScheme - member ValReprInfo: TypedTree.ValReprInfo option - + member GeneralizedTypars : TypedTree.Typars + member TypeScheme : TypedTreeOps.TypeScheme + member ValReprInfo : TypedTree.ValReprInfo option + end type TcPatPhase2Input = | TcPatPhase2Input of AbstractIL.Internal.Library.NameMap * bool with - member RightPath: TcPatPhase2Input - - [] + member RightPath : TcPatPhase2Input + end + [] type CheckedBindingInfo = | CheckedBindingInfo of inlineFlag: TypedTree.ValInline * valAttribs: TypedTree.Attribs * @@ -6075,29 +31139,29 @@ namespace FSharp.Compiler spBind: SyntaxTree.DebugPointForBinding * isCompilerGenerated: bool * literalValue: TypedTree.Const option * isFixed: bool with - member Expr: TypedTree.Expr - member SeqPoint: SyntaxTree.DebugPointForBinding - - val GeneralizedTypeForTypeScheme: + member Expr : TypedTree.Expr + member SeqPoint : SyntaxTree.DebugPointForBinding + end + val GeneralizedTypeForTypeScheme : typeScheme:TypedTreeOps.TypeScheme -> TypedTree.TType - val NonGenericTypeScheme: ty:TypedTree.TType -> TypedTreeOps.TypeScheme - val UpdateAccModuleOrNamespaceType: + val NonGenericTypeScheme : ty:TypedTree.TType -> TypedTreeOps.TypeScheme + val UpdateAccModuleOrNamespaceType : cenv:TcFileState -> env:TcEnv -> f:(bool -> TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespaceType) -> unit - val PublishModuleDefn: + val PublishModuleDefn : cenv:TcFileState -> env:TcEnv -> mspec:TypedTree.Tycon -> unit - val PublishTypeDefn: + val PublishTypeDefn : cenv:TcFileState -> env:TcEnv -> mspec:TypedTree.Tycon -> unit - val PublishValueDefnPrim: + val PublishValueDefnPrim : cenv:TcFileState -> env:TcEnv -> vspec:TypedTree.Val -> unit - val PublishValueDefn: + val PublishValueDefn : cenv:TcFileState -> env:TcEnv -> declKind:DeclKind -> vspec:TypedTree.Val -> unit - val CombineVisibilityAttribs: + val CombineVisibilityAttribs : vis1:'a option -> vis2:'a option -> m:Range.range -> 'a option - val ComputeAccessAndCompPath: + val ComputeAccessAndCompPath : env:TcEnv -> declKindOpt:DeclKind option -> m:Range.range -> @@ -6105,12 +31169,12 @@ namespace FSharp.Compiler overrideVis:TypedTree.Accessibility option -> actualParent:TypedTree.ParentRef -> TypedTree.Accessibility * TypedTree.CompilationPath option - val CheckForAbnormalOperatorNames: + val CheckForAbnormalOperatorNames : cenv:TcFileState -> idRange:Range.range -> coreDisplayName:string -> memberInfoOpt:TypedTree.ValMemberInfo option -> unit - val MakeAndPublishVal: + val MakeAndPublishVal : cenv:TcFileState -> env:TcEnv -> altActualParent:TypedTree.ParentRef * inSig:bool * declKind:DeclKind * @@ -6118,7 +31182,7 @@ namespace FSharp.Compiler attrs:TypedTree.Attribs * doc:XmlDoc.XmlDoc * konst:TypedTree.Const option * isGeneratedEventVal:bool -> TypedTree.Val - val MakeAndPublishVals: + val MakeAndPublishVals : cenv:TcFileState -> env:TcEnv -> altActualParent:TypedTree.ParentRef * inSig:bool * declKind:DeclKind * @@ -6126,117 +31190,117 @@ namespace FSharp.Compiler attrs:TypedTree.Attribs * doc:XmlDoc.XmlDoc * literalValue:TypedTree.Const option -> Map<'a,(TypedTree.Val * TypedTreeOps.TypeScheme)> - when 'a: comparison - val MakeAndPublishBaseVal: + when 'a : comparison + val MakeAndPublishBaseVal : cenv:TcFileState -> env:TcEnv -> SyntaxTree.Ident option -> TypedTree.TType -> TypedTree.Val option - val MakeAndPublishSafeThisVal: + val MakeAndPublishSafeThisVal : cenv:TcFileState -> env:TcEnv -> thisIdOpt:SyntaxTree.Ident option -> thisTy:TypedTree.TType -> TypedTree.Val option - val AdjustAndForgetUsesOfRecValue: + val AdjustAndForgetUsesOfRecValue : cenv:TcFileState -> vrefTgt:TypedTree.ValRef -> valScheme:ValScheme -> unit - val AdjustRecType: vspec:TypedTree.Val -> vscheme:ValScheme -> unit - val RecordUseOfRecValue: + val AdjustRecType : vspec:TypedTree.Val -> vscheme:ValScheme -> unit + val RecordUseOfRecValue : cenv:TcFileState -> vrec:TypedTree.ValRecursiveScopeInfo -> vrefTgt:TypedTree.ValRef -> vexp:TypedTree.Expr -> m:Range.range -> TypedTree.Expr - [] + [] type RecursiveUseFixupPoints = | RecursiveUseFixupPoints of (TypedTree.Expr ref * Range.range) list - val GetAllUsesOfRecValue: + val GetAllUsesOfRecValue : cenv:TcFileState -> vrefTgt:TypedTree.Val -> RecursiveUseFixupPoints - val ChooseCanonicalDeclaredTyparsAfterInference: + val ChooseCanonicalDeclaredTyparsAfterInference : g:TcGlobals.TcGlobals -> denv:TypedTreeOps.DisplayEnv -> declaredTypars:TypedTree.Typar list -> m:Range.range -> TypedTree.Typars - val ChooseCanonicalValSchemeAfterInference: + val ChooseCanonicalValSchemeAfterInference : g:TcGlobals.TcGlobals -> denv:TypedTreeOps.DisplayEnv -> vscheme:ValScheme -> m:Range.range -> ValScheme - val PlaceTyparsInDeclarationOrder: + val PlaceTyparsInDeclarationOrder : declaredTypars:TypedTree.Typar list -> generalizedTypars:TypedTree.Typar list -> TypedTree.Typar list - val SetTyparRigid: + val SetTyparRigid : TypedTreeOps.DisplayEnv -> Range.range -> TypedTree.Typar -> unit - val GeneralizeVal: + val GeneralizeVal : cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> enclosingDeclaredTypars:TypedTree.Typar list -> generalizedTyparsForThisBinding:TypedTree.Typar list -> PrelimValScheme1 -> PrelimValScheme2 - val GeneralizeVals: + val GeneralizeVals : cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> enclosingDeclaredTypars:TypedTree.Typar list -> generalizedTypars:TypedTree.Typar list -> types:AbstractIL.Internal.Library.NameMap -> Map - val DontGeneralizeVals: + val DontGeneralizeVals : types:AbstractIL.Internal.Library.NameMap -> Map - val InferGenericArityFromTyScheme: + val InferGenericArityFromTyScheme : TypedTreeOps.TypeScheme -> partialValReprInfo:PartialValReprInfo -> TypedTree.ValReprInfo - val ComputeIsTyFunc: + val ComputeIsTyFunc : id:SyntaxTree.Ident * hasDeclaredTypars:bool * arityInfo:TypedTree.ValReprInfo option -> bool - val UseSyntacticArity: + val UseSyntacticArity : declKind:DeclKind -> typeScheme:TypedTreeOps.TypeScheme -> partialValReprInfo:PartialValReprInfo -> TypedTree.ValReprInfo option - val CombineSyntacticAndInferredArities: + val CombineSyntacticAndInferredArities : g:TcGlobals.TcGlobals -> declKind:DeclKind -> rhsExpr:TypedTree.Expr -> prelimScheme:PrelimValScheme2 -> PartialValReprInfo option - val BuildValScheme: + val BuildValScheme : declKind:DeclKind -> partialArityInfoOpt:PartialValReprInfo option -> prelimScheme:PrelimValScheme2 -> ValScheme - val UseCombinedArity: + val UseCombinedArity : g:TcGlobals.TcGlobals -> declKind:DeclKind -> rhsExpr:TypedTree.Expr -> prelimScheme:PrelimValScheme2 -> ValScheme - val UseNoArity: prelimScheme:PrelimValScheme2 -> ValScheme - val MakeAndPublishSimpleVals: + val UseNoArity : prelimScheme:PrelimValScheme2 -> ValScheme + val MakeAndPublishSimpleVals : cenv:TcFileState -> env:TcEnv -> names:AbstractIL.Internal.Library.NameMap -> Map * Map - val MakeAndPublishSimpleValsForMergedScope: + val MakeAndPublishSimpleValsForMergedScope : cenv:TcFileState -> env:TcEnv -> m:Range.range -> names:AbstractIL.Internal.Library.NameMap -> TcEnv * Map * Map - val FreshenTyconRef: + val FreshenTyconRef : m:Range.range -> rigid:TypedTree.TyparRigidity -> tcref:TypedTree.TyconRef -> declaredTyconTypars:TypedTree.Typar list -> TypedTree.TType * TypedTree.Typar list * TypedTreeOps.TyparInst * TypedTree.TType - val FreshenPossibleForallTy: + val FreshenPossibleForallTy : g:TcGlobals.TcGlobals -> m:Range.range -> rigid:TypedTree.TyparRigidity -> ty:TypedTree.TType -> TypedTree.Typar list * TypedTree.Typar list * TypedTree.TType list * TypedTree.TType - val FreshenTyconRef2: + val FreshenTyconRef2 : m:Range.range -> tcref:TypedTree.TyconRef -> TypedTree.Typars * TypedTreeOps.TyparInst * TypedTree.TType list * TypedTree.TType - val FreshenAbstractSlot: + val FreshenAbstractSlot : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> @@ -6244,7 +31308,7 @@ namespace FSharp.Compiler absMethInfo:Infos.MethInfo -> bool * TypedTree.Typars * TypedTree.TType list list * TypedTree.TType - val BuildFieldMap: + val BuildFieldMap : cenv:TcFileState -> env:TcEnv -> isPartial:bool -> @@ -6253,7 +31317,7 @@ namespace FSharp.Compiler m:Range.range -> TypedTree.TypeInst * TypedTree.TyconRef * Map * (string * 'a) list - val ApplyUnionCaseOrExn: + val ApplyUnionCaseOrExn : makerForUnionCase:(TypedTree.UnionCaseRef * TypedTree.TypeInst -> 'a) * makerForExnTag:(TypedTree.TyconRef -> 'a) -> m:Range.range -> @@ -6262,7 +31326,7 @@ namespace FSharp.Compiler overallTy:TypedTree.TType -> item:NameResolution.Item -> 'a * TypedTree.TType list * SyntaxTree.Ident list - val ApplyUnionCaseOrExnTypes: + val ApplyUnionCaseOrExnTypes : m:Range.range -> cenv:TcFileState -> env:TcEnv -> @@ -6270,7 +31334,7 @@ namespace FSharp.Compiler c:NameResolution.Item -> (Range.range -> TypedTree.Exprs -> TypedTree.Expr) * TypedTree.TType list * SyntaxTree.Ident list - val ApplyUnionCaseOrExnTypesForPat: + val ApplyUnionCaseOrExnTypesForPat : m:Range.range -> cenv:TcFileState -> env:TcEnv -> @@ -6279,9 +31343,9 @@ namespace FSharp.Compiler (Range.range -> PatternMatchCompilation.Pattern list -> PatternMatchCompilation.Pattern) * TypedTree.TType list * SyntaxTree.Ident list - val UnionCaseOrExnCheck: + val UnionCaseOrExnCheck : env:TcEnv -> numArgTys:int -> numArgs:int -> m:Range.range -> unit - val TcUnionCaseOrExnField: + val TcUnionCaseOrExnField : cenv:TcFileState -> env:TcEnv -> ty1:TypedTree.TType -> @@ -6293,43 +31357,43 @@ namespace FSharp.Compiler type GeneralizeConstrainedTyparOptions = | CanGeneralizeConstrainedTypars | DoNotGeneralizeConstrainedTypars - module GeneralizationHelpers = - val ComputeUngeneralizableTypars: + module GeneralizationHelpers = begin + val ComputeUngeneralizableTypars : env:TcEnv -> Internal.Utilities.Collections.Tagged.Set> - val ComputeUnabstractableTycons: env:TcEnv -> TypedTree.FreeTycons - val ComputeUnabstractableTraitSolutions: + val ComputeUnabstractableTycons : env:TcEnv -> TypedTree.FreeTycons + val ComputeUnabstractableTraitSolutions : env:TcEnv -> TypedTree.FreeLocals - val IsGeneralizableValue: + val IsGeneralizableValue : g:TcGlobals.TcGlobals -> t:TypedTree.Expr -> bool - val CanGeneralizeConstrainedTyparsForDecl: + val CanGeneralizeConstrainedTyparsForDecl : declKind:DeclKind -> GeneralizeConstrainedTyparOptions - val TrimUngeneralizableTypars: + val TrimUngeneralizableTypars : genConstrainedTyparFlag:GeneralizeConstrainedTyparOptions -> inlineFlag:TypedTree.ValInline -> generalizedTypars:TypedTree.Typar list -> freeInEnv:AbstractIL.Internal.Zset -> TypedTree.Typar list * AbstractIL.Internal.Zset - val CondenseTypars: + val CondenseTypars : cenv:TcFileState * denv:TypedTreeOps.DisplayEnv * generalizedTypars:TypedTree.Typars * tauTy:TypedTree.TType * m:Range.range -> TypedTree.Typar list - val ComputeAndGeneralizeGenericTypars: + val ComputeAndGeneralizeGenericTypars : cenv:TcFileState * denv:TypedTreeOps.DisplayEnv * m:Range.range * freeInEnv:TypedTree.FreeTypars * canInferTypars:bool * genConstrainedTyparFlag:GeneralizeConstrainedTyparOptions * inlineFlag:TypedTree.ValInline * exprOpt:TypedTree.Expr option * allDeclaredTypars:TypedTree.Typars * maxInferredTypars:TypedTree.Typars * tauTy:TypedTree.TType * resultFirst:bool -> TypedTree.Typars - val CheckDeclaredTyparsPermitted: + val CheckDeclaredTyparsPermitted : memFlagsOpt:SyntaxTree.MemberFlags option * declaredTypars:'a list * m:Range.range -> unit - val ComputeCanInferExtraGeneralizableTypars: + val ComputeCanInferExtraGeneralizableTypars : parentRef:TypedTree.ParentRef * canInferTypars:bool * memFlagsOpt:SyntaxTree.MemberFlags option -> bool - - val ComputeInlineFlag: + end + val ComputeInlineFlag : memFlagsOption:SyntaxTree.MemberFlags option -> isInline:bool -> isMutable:bool -> m:Range.range -> TypedTree.ValInline type NormalizedBindingRhs = @@ -6337,7 +31401,7 @@ namespace FSharp.Compiler simplePats: SyntaxTree.SynSimplePats list * returnTyOpt: SyntaxTree.SynBindingReturnInfo option * rhsExpr: SyntaxTree.SynExpr - val PushOnePatternToRhs: + val PushOnePatternToRhs : cenv:cenv -> isMember:bool -> p:SyntaxTree.SynPat -> NormalizedBindingRhs -> NormalizedBindingRhs @@ -6356,13 +31420,13 @@ namespace FSharp.Compiler type IsObjExprBinding = | ObjExprBinding | ValOrMemberBinding - module BindingNormalization = - val private PushMultiplePatternsToRhs: + module BindingNormalization = begin + val private PushMultiplePatternsToRhs : cenv:cenv -> isMember:bool -> ps:SyntaxTree.SynPat list -> NormalizedBindingRhs -> NormalizedBindingRhs - val private MakeNormalizedStaticOrValBinding: + val private MakeNormalizedStaticOrValBinding : cenv:cenv -> isObjExprBinding:IsObjExprBinding -> id:SyntaxTree.Ident -> @@ -6372,7 +31436,7 @@ namespace FSharp.Compiler rhsExpr:NormalizedBindingRhs -> valSynData:SyntaxTree.SynValData -> NormalizedBindingPatternInfo - val private MakeNormalizedInstanceMemberBinding: + val private MakeNormalizedInstanceMemberBinding : cenv:cenv -> thisId:SyntaxTree.Ident -> memberId:SyntaxTree.Ident -> @@ -6384,7 +31448,7 @@ namespace FSharp.Compiler rhsExpr:NormalizedBindingRhs -> valSynData:SyntaxTree.SynValData -> NormalizedBindingPatternInfo - val private NormalizeStaticMemberBinding: + val private NormalizeStaticMemberBinding : cenv:cenv -> memberFlags:SyntaxTree.MemberFlags -> valSynData:SyntaxTree.SynValData -> @@ -6395,7 +31459,7 @@ namespace FSharp.Compiler m:Range.range -> rhsExpr:NormalizedBindingRhs -> NormalizedBindingPatternInfo - val private NormalizeInstanceMemberBinding: + val private NormalizeInstanceMemberBinding : cenv:cenv -> memberFlags:SyntaxTree.MemberFlags -> valSynData:SyntaxTree.SynValData -> @@ -6408,7 +31472,7 @@ namespace FSharp.Compiler m:Range.range -> rhsExpr:NormalizedBindingRhs -> NormalizedBindingPatternInfo - val private NormalizeBindingPattern: + val private NormalizeBindingPattern : cenv:TcFileState -> nameResolver:NameResolution.NameResolver -> isObjExprBinding:IsObjExprBinding -> @@ -6416,32 +31480,32 @@ namespace FSharp.Compiler valSynData:SyntaxTree.SynValData -> pat:SyntaxTree.SynPat -> rhsExpr:NormalizedBindingRhs -> NormalizedBindingPatternInfo - val NormalizeBinding: + val NormalizeBinding : isObjExprBinding:IsObjExprBinding -> cenv:TcFileState -> env:TcEnv -> binding:SyntaxTree.SynBinding -> NormalizedBinding - - module EventDeclarationNormalization = - val ConvertSynInfo: + end + module EventDeclarationNormalization = begin + val ConvertSynInfo : m:Range.range -> SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo - val ConvertMemberFlags: + val ConvertMemberFlags : memberFlags:SyntaxTree.MemberFlags -> SyntaxTree.MemberFlags - val private ConvertMemberFlagsOpt: + val private ConvertMemberFlagsOpt : m:Range.range -> memberFlagsOpt:SyntaxTree.MemberFlags option -> SyntaxTree.MemberFlags option - val private ConvertSynData: + val private ConvertSynData : m:Range.range -> valSynData:SyntaxTree.SynValData -> SyntaxTree.SynValData - val private RenameBindingPattern: + val private RenameBindingPattern : f:(string -> string) -> declPattern:SyntaxTree.SynPat -> SyntaxTree.SynPat - val GenerateExtraBindings: + val GenerateExtraBindings : cenv:TcFileState -> bindingAttribs:TypedTree.Attribs * binding:NormalizedBinding -> NormalizedBinding list - - val FreshenObjectArgType: + end + val FreshenObjectArgType : cenv:TcFileState -> m:Range.range -> rigid:TypedTree.TyparRigidity -> @@ -6450,13 +31514,13 @@ namespace FSharp.Compiler declaredTyconTypars:TypedTree.Typar list -> TypedTree.TType * TypedTree.Typar list * TypedTreeOps.TyparInst * TypedTree.TType * TypedTree.TType - val TcValEarlyGeneralizationConsistencyCheck: + val TcValEarlyGeneralizationConsistencyCheck : cenv:TcFileState -> env:TcEnv -> v:TypedTree.Val * vrec:TypedTree.ValRecursiveScopeInfo * tinst:TypedTree.TType list * vty:TypedTree.TType * tau:TypedTree.TType * m:Range.range -> unit - val TcVal: + val TcVal : checkAttributes:bool -> cenv:TcFileState -> env:TcEnv -> @@ -6469,7 +31533,7 @@ namespace FSharp.Compiler m:Range.range -> TypedTree.Typar list * TypedTree.Expr * bool * TypedTree.TType * TypedTree.TType list * 'a - val LightweightTcValForUsingInBuildMethodCall: + val LightweightTcValForUsingInBuildMethodCall : g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> vrefFlags:TypedTree.ValUseFlag -> @@ -6479,28 +31543,28 @@ namespace FSharp.Compiler | ApplicableExpr of cenv * TypedTree.Expr * bool with member - SupplyArgument: e2:TypedTree.Expr * m:Range.range -> ApplicableExpr - member Expr: TypedTree.Expr - member Range: Range.range - member Type: TypedTree.TType - - val MakeApplicableExprNoFlex: + SupplyArgument : e2:TypedTree.Expr * m:Range.range -> ApplicableExpr + member Expr : TypedTree.Expr + member Range : Range.range + member Type : TypedTree.TType + end + val MakeApplicableExprNoFlex : cenv:cenv -> expr:TypedTree.Expr -> ApplicableExpr - val MakeApplicableExprWithFlex: + val MakeApplicableExprWithFlex : cenv:TcFileState -> env:TcEnv -> expr:TypedTree.Expr -> ApplicableExpr - val TcRuntimeTypeTest: + val TcRuntimeTypeTest : isCast:bool -> isOperator:bool -> cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> m:Range.range -> tgtTy:TypedTree.TType -> srcTy:TypedTree.TType -> unit - val TcStaticUpcast: + val TcStaticUpcast : cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> m:Range.range -> tgtTy:TypedTree.TType -> srcTy:TypedTree.TType -> unit - val BuildPossiblyConditionalMethodCall: + val BuildPossiblyConditionalMethodCall : cenv:TcFileState -> env:TcEnv -> isMutable:TypedTreeOps.Mutates -> @@ -6511,60 +31575,60 @@ namespace FSharp.Compiler minst:TypedTree.TType list -> objArgs:TypedTree.Expr list -> args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType - val TryFindIntrinsicOrExtensionMethInfo: + val TryFindIntrinsicOrExtensionMethInfo : collectionSettings:NameResolution.ResultCollectionSettings -> cenv:cenv -> env:TcEnv -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> nm:string -> ty:TypedTree.TType -> Infos.MethInfo list - val TryFindFSharpSignatureInstanceGetterProperty: + val TryFindFSharpSignatureInstanceGetterProperty : cenv:cenv -> env:TcEnv -> m:Range.range -> nm:string -> ty:TypedTree.TType -> sigTys:TypedTree.TType list -> Infos.PropInfo option - val BuildDisposableCleanup: + val BuildDisposableCleanup : cenv:cenv -> env:TcEnv -> m:Range.range -> v:TypedTree.Val -> TypedTree.Expr - val BuildOffsetToStringData: + val BuildOffsetToStringData : cenv:cenv -> env:TcEnv -> m:Range.range -> TypedTree.Expr - val BuildILFieldGet: + val BuildILFieldGet : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> objExpr:TypedTree.Expr -> finfo:Infos.ILFieldInfo -> TypedTree.Expr - val private CheckFieldLiteralArg: + val private CheckFieldLiteralArg : finfo:Infos.ILFieldInfo -> argExpr:TypedTree.Expr -> m:Range.range -> unit - val BuildILFieldSet: + val BuildILFieldSet : g:TcGlobals.TcGlobals -> m:Range.range -> objExpr:TypedTree.Expr -> finfo:Infos.ILFieldInfo -> argExpr:TypedTree.Expr -> TypedTree.Expr - val BuildILStaticFieldSet: + val BuildILStaticFieldSet : m:Range.range -> finfo:Infos.ILFieldInfo -> argExpr:TypedTree.Expr -> TypedTree.Expr - val BuildRecdFieldSet: + val BuildRecdFieldSet : g:TcGlobals.TcGlobals -> m:Range.range -> objExpr:TypedTree.Expr -> rfinfo:Infos.RecdFieldInfo -> argExpr:TypedTree.Expr -> TypedTree.Expr - val ( |BinOpExpr|_| ): + val ( |BinOpExpr|_| ) : SyntaxTree.SynExpr -> (SyntaxTree.Ident * SyntaxTree.SynExpr * SyntaxTree.SynExpr) option - val ( |SimpleEqualsExpr|_| ): + val ( |SimpleEqualsExpr|_| ) : e:SyntaxTree.SynExpr -> (SyntaxTree.SynExpr * SyntaxTree.SynExpr) option - val TryGetNamedArg: + val TryGetNamedArg : e:SyntaxTree.SynExpr -> (bool * SyntaxTree.Ident * SyntaxTree.SynExpr) option - val inline IsNamedArg: e:SyntaxTree.SynExpr -> bool - val GetMethodArgs: + val inline IsNamedArg : e:SyntaxTree.SynExpr -> bool + val GetMethodArgs : arg:SyntaxTree.SynExpr -> SyntaxTree.SynExpr list * (bool * SyntaxTree.Ident * SyntaxTree.SynExpr) list - val CompilePatternForMatch: + val CompilePatternForMatch : cenv:TcFileState -> env:TcEnv -> mExpr:Range.range -> @@ -6576,7 +31640,7 @@ namespace FSharp.Compiler clauses:PatternMatchCompilation.TypedMatchClause list -> inputTy:TypedTree.TType -> resultTy:TypedTree.TType -> TypedTree.Expr - val CompilePatternForMatchClauses: + val CompilePatternForMatchClauses : cenv:TcFileState -> env:TcEnv -> mExpr:Range.range -> @@ -6588,7 +31652,7 @@ namespace FSharp.Compiler resultTy:TypedTree.TType -> tclauses:PatternMatchCompilation.TypedMatchClause list -> TypedTree.Val * TypedTree.Expr - val AnalyzeArbitraryExprAsEnumerable: + val AnalyzeArbitraryExprAsEnumerable : cenv:cenv -> env:TcEnv -> localAlloc:bool -> @@ -6598,7 +31662,7 @@ namespace FSharp.Compiler TypedTree.Val * TypedTree.Expr * TypedTree.TType * TypedTree.TType * TypedTree.Expr * TypedTree.TType * TypedTree.Expr * TypedTree.TType * TypedTree.Expr - val ConvertArbitraryExprToEnumerable: + val ConvertArbitraryExprToEnumerable : cenv:cenv -> ty:TypedTree.TType -> env:TcEnv -> expr:TypedTree.Expr -> TypedTree.Expr * TypedTree.TType @@ -6611,7 +31675,7 @@ namespace FSharp.Compiler type PreInitializationGraphEliminationBinding = { FixupPoints: RecursiveUseFixupPoints Binding: TypedTree.Binding } - val EliminateInitializationGraphs: + val EliminateInitializationGraphs : g:TcGlobals.TcGlobals -> mustHaveArity:bool -> denv:TypedTreeOps.DisplayEnv -> @@ -6623,10 +31687,10 @@ namespace FSharp.Compiler TypedTree.Binding list) -> 'Binding list -> 'Result list) -> bindsm:Range.range -> 'Result list - val CheckAndRewriteObjectCtor: + val CheckAndRewriteObjectCtor : g:TcGlobals.TcGlobals -> env:TcEnv -> ctorLambdaExpr:TypedTree.Expr -> TypedTree.Expr - val buildApp: + val buildApp : cenv:TcFileState -> expr:ApplicableExpr -> resultTy:TypedTree.TType -> @@ -6639,7 +31703,7 @@ namespace FSharp.Compiler | DelayedDotLookup of SyntaxTree.Ident list * Range.range | DelayedDot | DelayedSet of SyntaxTree.SynExpr * Range.range - val MakeDelayedSet: e:SyntaxTree.SynExpr * m:Range.range -> DelayedItem + val MakeDelayedSet : e:SyntaxTree.SynExpr * m:Range.range -> DelayedItem type NewSlotsOK = | NewSlotsOK | NoNewSlots @@ -6659,9 +31723,9 @@ namespace FSharp.Compiler type ContainerInfo = | ContainerInfo of TypedTree.ParentRef * MemberOrValContainerInfo option with - member ParentRef: TypedTree.ParentRef - - val ExprContainerInfo: ContainerInfo + member ParentRef : TypedTree.ParentRef + end + val ExprContainerInfo : ContainerInfo type NormalizedRecBindingDefn = | NormalizedRecBindingDefn of containerInfo: ContainerInfo * newslotsOk: NewSlotsOK * @@ -6689,14 +31753,14 @@ namespace FSharp.Compiler safeInitInfo: SafeInitData * visibility: SyntaxTree.SynAccess option * ty: TypedTree.TType * declKind: DeclKind with - member ContainerInfo: ContainerInfo - member DeclKind: DeclKind - member DeclaredTypars: TypedTree.Typars - member EnclosingDeclaredTypars: TypedTree.Typars - member ExplicitTyparInfo: ExplicitTyparInfo - member Index: int - member Val: TypedTree.Val - + member ContainerInfo : ContainerInfo + member DeclKind : DeclKind + member DeclaredTypars : TypedTree.Typars + member EnclosingDeclaredTypars : TypedTree.Typars + member ExplicitTyparInfo : ExplicitTyparInfo + member Index : int + member Val : TypedTree.Val + end type PreCheckingRecursiveBinding = { SyntacticBinding: NormalizedBinding RecBindingInfo: RecursiveBindingInfo } @@ -6709,16 +31773,16 @@ namespace FSharp.Compiler CheckedBinding: CheckedBindingInfo RecBindingInfo: RecursiveBindingInfo } with - member GeneralizedTypars: TypedTree.Typars - + member GeneralizedTypars : TypedTree.Typars + end type PostSpecialValsRecursiveBinding = { ValScheme: ValScheme Binding: TypedTree.Binding } - val CanInferExtraGeneralizedTyparsForRecBinding: + val CanInferExtraGeneralizedTyparsForRecBinding : pgrbind:PreGeneralizationRecursiveBinding -> bool - val GetInstanceMemberThisVariable: + val GetInstanceMemberThisVariable : vspec:TypedTree.Val * expr:TypedTree.Expr -> TypedTree.Val option - val TcTyparConstraint: + val TcTyparConstraint : ridx:int -> cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> @@ -6727,7 +31791,7 @@ namespace FSharp.Compiler env:TcEnv -> tpenv:UnscopedTyparEnv -> c:SyntaxTree.SynTypeConstraint -> UnscopedTyparEnv - val TcPseudoMemberSpec: + val TcPseudoMemberSpec : cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> env:TcEnv -> @@ -6736,7 +31800,7 @@ namespace FSharp.Compiler memSpfn:SyntaxTree.SynMemberSig -> m:Range.range -> TypedTree.TraitConstraintInfo * UnscopedTyparEnv - val TcValSpec: + val TcValSpec : cenv:TcFileState -> TcEnv -> DeclKind -> @@ -6748,27 +31812,27 @@ namespace FSharp.Compiler SyntaxTree.SynValSig -> TypedTree.Attrib list -> ValSpecResult list * UnscopedTyparEnv - val TcTyparOrMeasurePar: + val TcTyparOrMeasurePar : optKind:TypedTree.TyparKind option -> cenv:TcFileState -> env:TcEnv -> newOk:ImplicitlyBoundTyparsAllowed -> tpenv:UnscopedTyparEnv -> SyntaxTree.SynTypar -> TypedTree.Typar * UnscopedTyparEnv - val TcTypar: + val TcTypar : cenv:TcFileState -> env:TcEnv -> newOk:ImplicitlyBoundTyparsAllowed -> tpenv:UnscopedTyparEnv -> tp:SyntaxTree.SynTypar -> TypedTree.Typar * UnscopedTyparEnv - val TcTyparDecl: + val TcTyparDecl : cenv:TcFileState -> env:TcEnv -> SyntaxTree.SynTyparDecl -> TypedTree.Typar - val TcTyparDecls: + val TcTyparDecls : cenv:TcFileState -> env:TcEnv -> synTypars:SyntaxTree.SynTyparDecl list -> TypedTree.Typar list - val TcTypeOrMeasure: + val TcTypeOrMeasure : optKind:TypedTree.TyparKind option -> cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> @@ -6777,7 +31841,7 @@ namespace FSharp.Compiler env:TcEnv -> tpenv:UnscopedTyparEnv -> ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv - val TcType: + val TcType : cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> checkCxs:CheckConstraints -> @@ -6785,7 +31849,7 @@ namespace FSharp.Compiler env:TcEnv -> tpenv:UnscopedTyparEnv -> ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv - val TcMeasure: + val TcMeasure : cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> checkCxs:CheckConstraints -> @@ -6794,14 +31858,14 @@ namespace FSharp.Compiler tpenv:UnscopedTyparEnv -> SyntaxTree.SynType -> m:Range.range -> TypedTree.Measure * UnscopedTyparEnv - val TcAnonTypeOrMeasure: + val TcAnonTypeOrMeasure : optKind:TypedTree.TyparKind option -> _cenv:TcFileState -> rigid:TypedTree.TyparRigidity -> dyn:TypedTree.TyparDynamicReq -> newOk:ImplicitlyBoundTyparsAllowed -> m:Range.range -> TypedTree.Typar - val TcTypes: + val TcTypes : cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> checkCxs:CheckConstraints -> @@ -6810,7 +31874,7 @@ namespace FSharp.Compiler tpenv:UnscopedTyparEnv -> args:SyntaxTree.SynType list -> TypedTree.TType list * UnscopedTyparEnv - val TcTypesAsTuple: + val TcTypesAsTuple : cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> checkCxs:CheckConstraints -> @@ -6819,7 +31883,7 @@ namespace FSharp.Compiler tpenv:UnscopedTyparEnv -> args:(bool * SyntaxTree.SynType) list -> m:Range.range -> TypedTree.TTypes * UnscopedTyparEnv - val TcMeasuresAsTuple: + val TcMeasuresAsTuple : cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> checkCxs:CheckConstraints -> @@ -6828,7 +31892,7 @@ namespace FSharp.Compiler tpenv:UnscopedTyparEnv -> args:(bool * SyntaxTree.SynType) list -> m:Range.range -> TypedTree.Measure * UnscopedTyparEnv - val TcTypesOrMeasures: + val TcTypesOrMeasures : optKinds:TypedTree.TyparKind list option -> cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> @@ -6838,7 +31902,7 @@ namespace FSharp.Compiler tpenv:UnscopedTyparEnv -> args:SyntaxTree.SynType list -> m:Range.range -> TypedTree.TType list * UnscopedTyparEnv - val TcTyparConstraints: + val TcTyparConstraints : cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> checkCxs:CheckConstraints -> @@ -6847,7 +31911,7 @@ namespace FSharp.Compiler tpenv:UnscopedTyparEnv -> synConstraints:SyntaxTree.SynTypeConstraint list -> UnscopedTyparEnv - val TcStaticConstantParameter: + val TcStaticConstantParameter : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> @@ -6856,7 +31920,7 @@ namespace FSharp.Compiler idOpt:SyntaxTree.Ident option -> container:NameResolution.ArgumentContainer -> obj * UnscopedTyparEnv - val CrackStaticConstantArgs: + val CrackStaticConstantArgs : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> @@ -6864,7 +31928,7 @@ namespace FSharp.Compiler args:SyntaxTree.SynType list * container:NameResolution.ArgumentContainer * containerName:System.String * m:Range.range -> obj [] - val TcProvidedTypeAppToStaticConstantArgs: + val TcProvidedTypeAppToStaticConstantArgs : cenv:TcFileState -> env:TcEnv -> optGeneratedTypePath:string list option -> @@ -6874,14 +31938,14 @@ namespace FSharp.Compiler m:Range.range -> bool * Tainted * (unit -> unit) - val TryTcMethodAppToStaticConstantArgs: + val TryTcMethodAppToStaticConstantArgs : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> minfos:Infos.MethInfo list * argsOpt:(SyntaxTree.SynType list * 'a) option * mExprAndArg:Range.range * mItem:Range.range -> Infos.MethInfo option - val TcProvidedMethodAppToStaticConstantArgs: + val TcProvidedMethodAppToStaticConstantArgs : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> @@ -6890,14 +31954,14 @@ namespace FSharp.Compiler staticParams:Tainted [] * args:SyntaxTree.SynType list * m:Range.range -> Tainted - val TcProvidedTypeApp: + val TcProvidedTypeApp : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> tcref:TypedTree.TyconRef -> args:SyntaxTree.SynType list -> m:Range.range -> TypedTree.TType * UnscopedTyparEnv - val TcTypeApp: + val TcTypeApp : cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> checkCxs:CheckConstraints -> @@ -6909,7 +31973,7 @@ namespace FSharp.Compiler pathTypeArgs:NameResolution.EnclosingTypeInst -> synArgTys:SyntaxTree.SynType list -> TypedTree.TType * UnscopedTyparEnv - val TcTypeOrMeasureAndRecover: + val TcTypeOrMeasureAndRecover : optKind:TypedTree.TyparKind option -> cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> @@ -6918,7 +31982,7 @@ namespace FSharp.Compiler env:TcEnv -> tpenv:UnscopedTyparEnv -> ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv - val TcTypeAndRecover: + val TcTypeAndRecover : cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> checkCxs:CheckConstraints -> @@ -6926,7 +31990,7 @@ namespace FSharp.Compiler env:TcEnv -> tpenv:UnscopedTyparEnv -> ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv - val TcNestedTypeApplication: + val TcNestedTypeApplication : cenv:TcFileState -> newOk:ImplicitlyBoundTyparsAllowed -> checkCxs:CheckConstraints -> @@ -6938,13 +32002,13 @@ namespace FSharp.Compiler pathTypeArgs:NameResolution.EnclosingTypeInst -> tyargs:SyntaxTree.SynType list -> TypedTree.TType * UnscopedTyparEnv - val TryAdjustHiddenVarNameToCompGenName: + val TryAdjustHiddenVarNameToCompGenName : cenv:TcFileState -> env:TcEnv -> id:SyntaxTree.Ident -> altNameRefCellOpt:Ref option -> SyntaxTree.Ident option - val TcSimplePat: + val TcSimplePat : optArgsOK:bool -> checkCxs:CheckConstraints -> cenv:TcFileState -> @@ -6956,8 +32020,8 @@ namespace FSharp.Compiler string * (UnscopedTyparEnv * Map * Set) - val ValidateOptArgOrder: spats:SyntaxTree.SynSimplePats -> unit - val TcSimplePats: + val ValidateOptArgOrder : spats:SyntaxTree.SynSimplePats -> unit + val TcSimplePats : cenv:TcFileState -> optArgsOK:bool -> checkCxs:CheckConstraints -> @@ -6969,7 +32033,7 @@ namespace FSharp.Compiler string list * (UnscopedTyparEnv * Map * Set) - val TcSimplePatsOfUnknownType: + val TcSimplePatsOfUnknownType : cenv:TcFileState -> optArgsOK:bool -> checkCxs:CheckConstraints -> @@ -6978,7 +32042,7 @@ namespace FSharp.Compiler spats:SyntaxTree.SynSimplePats -> string list * (UnscopedTyparEnv * Map * Set) - val TcPatBindingName: + val TcPatBindingName : cenv:TcFileState -> env:TcEnv -> id:SyntaxTree.Ident -> @@ -6995,7 +32059,7 @@ namespace FSharp.Compiler (TcPatPhase2Input -> PatternMatchCompilation.PatternValBinding) * Map * Set - val TcPatAndRecover: + val TcPatAndRecover : warnOnUpper:NameResolution.WarnOnUpperFlag -> cenv:TcFileState -> env:TcEnv -> @@ -7009,7 +32073,7 @@ namespace FSharp.Compiler (TcPatPhase2Input -> PatternMatchCompilation.Pattern) * (UnscopedTyparEnv * Map * Set) - val TcPat: + val TcPat : warnOnUpper:NameResolution.WarnOnUpperFlag -> cenv:TcFileState -> env:TcEnv -> @@ -7023,7 +32087,7 @@ namespace FSharp.Compiler (TcPatPhase2Input -> PatternMatchCompilation.Pattern) * (UnscopedTyparEnv * Map * Set) - val TcPatterns: + val TcPatterns : warnOnUpper:NameResolution.WarnOnUpperFlag -> cenv:TcFileState -> env:TcEnv -> @@ -7035,28 +32099,28 @@ namespace FSharp.Compiler (TcPatPhase2Input -> PatternMatchCompilation.Pattern) list * (UnscopedTyparEnv * Map * Set) - val solveTypAsError: + val solveTypAsError : cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> m:Range.range -> ty:TypedTree.TType -> unit - val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects: + val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> unit - val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects_Delayed: + val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects_Delayed : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> delayed:DelayedItem list -> unit - val UnifyTypesAndRecover: + val UnifyTypesAndRecover : cenv:TcFileState -> env:TcEnv -> m:Range.range -> expectedTy:TypedTree.TType -> actualTy:TypedTree.TType -> unit - val TcExprOfUnknownType: + val TcExprOfUnknownType : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> TypedTree.Expr * TypedTree.TType * UnscopedTyparEnv - val TcExprFlex: + val TcExprFlex : cenv:TcFileState -> flex:bool -> compat:bool -> @@ -7064,68 +32128,68 @@ namespace FSharp.Compiler env:TcEnv -> tpenv:UnscopedTyparEnv -> e:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcExpr: + val TcExpr : cenv:TcFileState -> ty:TypedTree.TType -> env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcExprNoRecover: + val TcExprNoRecover : cenv:TcFileState -> ty:TypedTree.TType -> env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcExprOfUnknownTypeThen: + val TcExprOfUnknownTypeThen : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> delayed:DelayedItem list -> TypedTree.Expr * TypedTree.TType * UnscopedTyparEnv - val TcExprThatIsCtorBody: + val TcExprThatIsCtorBody : TypedTree.Val option * SafeInitData -> cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcExprThatCanBeCtorBody: + val TcExprThatCanBeCtorBody : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcExprThatCantBeCtorBody: + val TcExprThatCantBeCtorBody : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcStmtThatCantBeCtorBody: + val TcStmtThatCantBeCtorBody : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcStmt: + val TcStmt : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> synExpr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TryTcStmt: + val TryTcStmt : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> synExpr:SyntaxTree.SynExpr -> bool * TypedTree.Expr * UnscopedTyparEnv - val TcExprThen: + val TcExprThen : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> tpenv:UnscopedTyparEnv -> synExpr:SyntaxTree.SynExpr -> delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val TcExprs: + val TcExprs : cenv:TcFileState -> env:TcEnv -> m:Range.range -> @@ -7134,21 +32198,21 @@ namespace FSharp.Compiler argTys:TypedTree.TType list -> args:SyntaxTree.SynExpr list -> TypedTree.Expr list * UnscopedTyparEnv - val CheckSuperInit: + val CheckSuperInit : cenv:TcFileState -> objTy:TypedTree.TType -> m:Range.range -> unit - val TcExprUndelayedNoType: + val TcExprUndelayedNoType : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> synExpr:SyntaxTree.SynExpr -> TypedTree.Expr * TypedTree.TType * UnscopedTyparEnv - val TcExprUndelayed: + val TcExprUndelayed : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> tpenv:UnscopedTyparEnv -> synExpr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcIteratedLambdas: + val TcIteratedLambdas : cenv:TcFileState -> isFirst:bool -> env:TcEnv -> @@ -7156,7 +32220,7 @@ namespace FSharp.Compiler takenNames:Set -> tpenv:UnscopedTyparEnv -> e:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcIndexerThen: + val TcIndexerThen : cenv:TcFileState -> env:TcEnv -> overallTy:TypedTree.TType -> @@ -7168,7 +32232,7 @@ namespace FSharp.Compiler indexArgs:SyntaxTree.SynIndexerArg list -> delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val TcNewExpr: + val TcNewExpr : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> @@ -7178,7 +32242,7 @@ namespace FSharp.Compiler arg:SyntaxTree.SynExpr -> mWholeExprOrObjTy:Range.range -> TypedTree.Expr * UnscopedTyparEnv - val TcCtorCall: + val TcCtorCall : isNaked:bool -> cenv:TcFileState -> env:TcEnv -> @@ -7193,7 +32257,7 @@ namespace FSharp.Compiler delayed:DelayedItem list -> afterTcOverloadResolutionOpt:NameResolution.AfterResolution option -> TypedTree.Expr * UnscopedTyparEnv - val TcRecordConstruction: + val TcRecordConstruction : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7202,10 +32266,10 @@ namespace FSharp.Compiler objTy:TypedTree.TType -> fldsList:seq -> m:Range.range -> TypedTree.Expr * UnscopedTyparEnv - val GetNameAndArityOfObjExprBinding: + val GetNameAndArityOfObjExprBinding : _cenv:'b -> _env:'c -> b:NormalizedBinding -> string * SyntaxTree.SynValInfo - val FreshenObjExprAbstractSlot: + val FreshenObjExprAbstractSlot : cenv:TcFileState -> env:TcEnv -> implty:TypedTree.TType -> @@ -7213,7 +32277,7 @@ namespace FSharp.Compiler bind:NormalizedBinding * bindAttribs:TypedTree.Attribs * bindName:string * absSlots:('e * Infos.MethInfo) list -> (bool * TypedTree.Typars * TypedTree.TType) option - val TcObjectExprBinding: + val TcObjectExprBinding : cenv:cenv -> env:TcEnv -> implty:TypedTree.TType -> @@ -7222,7 +32286,7 @@ namespace FSharp.Compiler bind:NormalizedBinding -> (SyntaxTree.Ident * SyntaxTree.MemberFlags * TypedTree.TType * TypedTree.Attribs * TypedTree.Expr) * UnscopedTyparEnv - val ComputeObjectExprOverrides: + val ComputeObjectExprOverrides : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> @@ -7234,9 +32298,9 @@ namespace FSharp.Compiler (TypedTree.Val option * TypedTree.Val * TypedTree.Val list list * TypedTree.Attribs * TypedTree.Expr)) list) list * UnscopedTyparEnv - val CheckSuperType: + val CheckSuperType : cenv:TcFileState -> ty:TypedTree.TType -> m:Range.range -> unit - val TcObjectExpr: + val TcObjectExpr : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7246,21 +32310,21 @@ namespace FSharp.Compiler binds:SyntaxTree.SynBinding list * extraImpls:SyntaxTree.SynInterfaceImpl list * mNewExpr:Range.range * mWholeExpr:Range.range -> TypedTree.Expr * UnscopedTyparEnv - val TcConstStringExpr: + val TcConstStringExpr : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> m:Range.range -> tpenv:UnscopedTyparEnv -> s:string -> TypedTree.Expr * UnscopedTyparEnv - val TcFormatStringExpr: + val TcFormatStringExpr : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> m:Range.range -> tpenv:UnscopedTyparEnv -> fmtString:string -> TypedTree.Expr * UnscopedTyparEnv - val TcInterpolatedStringExpr: + val TcInterpolatedStringExpr : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7268,21 +32332,21 @@ namespace FSharp.Compiler tpenv:UnscopedTyparEnv -> parts:SyntaxTree.SynInterpolatedStringPart list -> TypedTree.Expr * UnscopedTyparEnv - val TcConstExpr: + val TcConstExpr : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> m:Range.range -> tpenv:UnscopedTyparEnv -> c:SyntaxTree.SynConst -> TypedTree.Expr * UnscopedTyparEnv - val TcAssertExpr: + val TcAssertExpr : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> m:Range.range -> tpenv:UnscopedTyparEnv -> x:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcRecdExpr: + val TcRecdExpr : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7293,7 +32357,7 @@ namespace FSharp.Compiler flds:(SyntaxTree.RecordFieldName * SyntaxTree.SynExpr option * SyntaxTree.BlockSeparator option) list * mWholeExpr:Range.range -> TypedTree.Expr * UnscopedTyparEnv - val TcAnonRecdExpr: + val TcAnonRecdExpr : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7303,7 +32367,7 @@ namespace FSharp.Compiler unsortedFieldIdsAndSynExprsGiven:(SyntaxTree.Ident * SyntaxTree.SynExpr) list * mWholeExpr:Range.range -> TypedTree.Expr * UnscopedTyparEnv - val TcForEachExpr: + val TcForEachExpr : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7312,7 +32376,7 @@ namespace FSharp.Compiler bodySynExpr:SyntaxTree.SynExpr * mWholeExpr:Range.range * spForLoop:SyntaxTree.DebugPointAtFor -> TypedTree.Expr * UnscopedTyparEnv - val TcQuotationExpr: + val TcQuotationExpr : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7320,14 +32384,14 @@ namespace FSharp.Compiler _oper:SyntaxTree.SynExpr * raw:bool * ast:SyntaxTree.SynExpr * isFromQueryExpression:bool * m:Range.range -> TypedTree.Expr * UnscopedTyparEnv - val Propagate: + val Propagate : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:ApplicableExpr -> exprty:TypedTree.TType -> delayed:DelayedItem list -> unit - val PropagateThenTcDelayed: + val PropagateThenTcDelayed : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7338,7 +32402,7 @@ namespace FSharp.Compiler atomicFlag:SyntaxTree.ExprAtomicFlag -> delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val TcDelayed: + val TcDelayed : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7349,17 +32413,17 @@ namespace FSharp.Compiler atomicFlag:SyntaxTree.ExprAtomicFlag -> delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val delayRest: + val delayRest : rest:SyntaxTree.Ident list -> mPrior:Range.range -> delayed:DelayedItem list -> DelayedItem list - val TcNameOfExpr: + val TcNameOfExpr : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> synArg:SyntaxTree.SynExpr -> TypedTree.Expr - val TcNameOfExprResult: + val TcNameOfExprResult : cenv:TcFileState -> lastIdent:SyntaxTree.Ident -> m:Range.range -> TypedTree.Expr - val TcFunctionApplicationThen: + val TcFunctionApplicationThen : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7371,16 +32435,16 @@ namespace FSharp.Compiler atomicFlag:SyntaxTree.ExprAtomicFlag -> delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val GetLongIdentTypeNameInfo: + val GetLongIdentTypeNameInfo : delayed:DelayedItem list -> NameResolution.TypeNameResolutionInfo - val TcLongIdentThen: + val TcLongIdentThen : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> tpenv:UnscopedTyparEnv -> SyntaxTree.LongIdentWithDots -> delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val TcItemThen: + val TcItemThen : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7390,26 +32454,26 @@ namespace FSharp.Compiler rest:SyntaxTree.Ident list * afterResolution:NameResolution.AfterResolution -> delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val GetSynMemberApplicationArgs: + val GetSynMemberApplicationArgs : delayed:DelayedItem list -> tpenv:'f -> SyntaxTree.ExprAtomicFlag * (SyntaxTree.SynType list * Range.range) option * SyntaxTree.SynExpr list * DelayedItem list * 'f - val TcMemberTyArgsOpt: + val TcMemberTyArgsOpt : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> tyargsOpt:(SyntaxTree.SynType list * Range.range) option -> TypedTree.TType list option * UnscopedTyparEnv - val GetMemberApplicationArgs: + val GetMemberApplicationArgs : delayed:DelayedItem list -> cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> SyntaxTree.ExprAtomicFlag * TypedTree.TType list option * SyntaxTree.SynExpr list * DelayedItem list * UnscopedTyparEnv - val TcLookupThen: + val TcLookupThen : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7421,7 +32485,7 @@ namespace FSharp.Compiler delayed:DelayedItem list -> mExprAndLongId:Range.range -> TypedTree.Expr * UnscopedTyparEnv - val TcEventValueThen: + val TcEventValueThen : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7432,7 +32496,7 @@ namespace FSharp.Compiler einfo:Infos.EventInfo -> delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val TcMethodApplicationThen: + val TcMethodApplicationThen : cenv:TcFileState -> env:TcEnv -> overallTy:TypedTree.TType -> @@ -7453,10 +32517,10 @@ namespace FSharp.Compiler atomicFlag:SyntaxTree.ExprAtomicFlag -> delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val GetNewInferenceTypeForMethodArg: + val GetNewInferenceTypeForMethodArg : cenv:TcFileState -> env:'g -> tpenv:'h -> x:SyntaxTree.SynExpr -> TypedTree.TType - val TcMethodApplication: + val TcMethodApplication : isCheckingAttributeCall:bool -> cenv:TcFileState -> env:TcEnv -> @@ -7481,7 +32545,7 @@ namespace FSharp.Compiler MethodCalls.CallerNamedArg list * DelayedItem list) * UnscopedTyparEnv - val TcSetterArgExpr: + val TcSetterArgExpr : cenv:TcFileState -> env:TcEnv -> denv:TypedTreeOps.DisplayEnv -> @@ -7490,7 +32554,7 @@ namespace FSharp.Compiler MethodCalls.AssignedItemSetter -> (TypedTree.Expr -> TypedTree.Expr) option * TypedTree.Expr * Range.range - val TcUnnamedMethodArgs: + val TcUnnamedMethodArgs : cenv:TcFileState -> env:TcEnv -> lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * @@ -7502,7 +32566,7 @@ namespace FSharp.Compiler ((MethodCalls.ArgumentAnalysis [] [] * (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * UnscopedTyparEnv) - val TcUnnamedMethodArg: + val TcUnnamedMethodArg : cenv:TcFileState -> env:TcEnv -> lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * @@ -7514,7 +32578,7 @@ namespace FSharp.Compiler ((MethodCalls.ArgumentAnalysis [] [] * (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * UnscopedTyparEnv) - val TcMethodNamedArgs: + val TcMethodNamedArgs : cenv:TcFileState -> env:TcEnv -> lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * @@ -7526,7 +32590,7 @@ namespace FSharp.Compiler ((MethodCalls.ArgumentAnalysis [] [] * (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * UnscopedTyparEnv) - val TcMethodNamedArg: + val TcMethodNamedArg : cenv:TcFileState -> env:TcEnv -> lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * @@ -7538,7 +32602,7 @@ namespace FSharp.Compiler ((MethodCalls.ArgumentAnalysis [] [] * (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * UnscopedTyparEnv) - val TcMethodArg: + val TcMethodArg : cenv:TcFileState -> env:TcEnv -> lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * @@ -7551,7 +32615,7 @@ namespace FSharp.Compiler ((MethodCalls.ArgumentAnalysis [] [] * (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * UnscopedTyparEnv) - val TcNewDelegateThen: + val TcNewDelegateThen : cenv:TcFileState -> overallTy:TypedTree.TType -> env:TcEnv -> @@ -7563,11 +32627,11 @@ namespace FSharp.Compiler atomicFlag:SyntaxTree.ExprAtomicFlag -> delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val bindLetRec: + val bindLetRec : binds:TypedTree.Bindings -> m:Range.range -> e:TypedTree.Expr -> TypedTree.Expr - val CheckRecursiveBindingIds: binds:seq -> unit - val TcLinearExprs: + val CheckRecursiveBindingIds : binds:seq -> unit + val TcLinearExprs : bodyChecker:(TypedTree.TType -> TcEnv -> UnscopedTyparEnv -> SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv) -> cenv:TcFileState -> @@ -7579,7 +32643,7 @@ namespace FSharp.Compiler cont:(TypedTree.Expr * UnscopedTyparEnv -> TypedTree.Expr * UnscopedTyparEnv) -> TypedTree.Expr * UnscopedTyparEnv - val TcAndPatternCompileMatchClauses: + val TcAndPatternCompileMatchClauses : mExpr:Range.range -> matchm:Range.range -> actionOnFailure:PatternMatchCompilation.ActionOnFailure -> @@ -7591,7 +32655,7 @@ namespace FSharp.Compiler tpenv:UnscopedTyparEnv -> synClauses:SyntaxTree.SynMatchClause list -> TypedTree.Val * TypedTree.Expr * UnscopedTyparEnv - val TcMatchPattern: + val TcMatchPattern : cenv:TcFileState -> inputTy:TypedTree.TType -> env:TcEnv -> @@ -7599,7 +32663,7 @@ namespace FSharp.Compiler pat:SyntaxTree.SynPat * optWhenExpr:SyntaxTree.SynExpr option -> PatternMatchCompilation.Pattern * TypedTree.Expr option * TypedTree.Val list * TcEnv * UnscopedTyparEnv - val TcMatchClauses: + val TcMatchClauses : cenv:TcFileState -> inputTy:TypedTree.TType -> resultTy:TypedTree.TType -> @@ -7608,7 +32672,7 @@ namespace FSharp.Compiler clauses:SyntaxTree.SynMatchClause list -> PatternMatchCompilation.TypedMatchClause list * UnscopedTyparEnv - val TcMatchClause: + val TcMatchClause : cenv:TcFileState -> inputTy:TypedTree.TType -> resultTy:TypedTree.TType -> @@ -7617,21 +32681,21 @@ namespace FSharp.Compiler tpenv:UnscopedTyparEnv -> SyntaxTree.SynMatchClause -> PatternMatchCompilation.TypedMatchClause * UnscopedTyparEnv - val TcStaticOptimizationConstraint: + val TcStaticOptimizationConstraint : cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> c:SyntaxTree.SynStaticOptimizationConstraint -> TypedTree.StaticOptimization * UnscopedTyparEnv - val mkConvToNativeInt: + val mkConvToNativeInt : g:TcGlobals.TcGlobals -> e:TypedTree.Expr -> m:Range.range -> TypedTree.Expr - val TcAndBuildFixedExpr: + val TcAndBuildFixedExpr : cenv:TcFileState -> env:TcEnv -> overallPatTy:TypedTree.TType * fixedExpr:TypedTree.Expr * overallExprTy:TypedTree.TType * mBinding:Range.range -> TypedTree.Expr - val TcNormalizedBinding: + val TcNormalizedBinding : declKind:DeclKind -> cenv:cenv -> env:TcEnv -> @@ -7643,65 +32707,65 @@ namespace FSharp.Compiler ExplicitTyparInfo -> bind:NormalizedBinding -> CheckedBindingInfo * UnscopedTyparEnv - val TcLiteral: + val TcLiteral : cenv:cenv -> overallTy:TypedTree.TType -> env:TcEnv -> tpenv:UnscopedTyparEnv -> attrs:TypedTree.Attribs * synLiteralValExpr:SyntaxTree.SynExpr -> bool * TypedTree.Const option - val TcBindingTyparDecls: + val TcBindingTyparDecls : alwaysRigid:bool -> cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> SyntaxTree.SynValTyparDecls -> ExplicitTyparInfo * UnscopedTyparEnv - val TcNonrecBindingTyparDecls: + val TcNonrecBindingTyparDecls : cenv:cenv -> env:TcEnv -> tpenv:UnscopedTyparEnv -> bind:NormalizedBinding -> ExplicitTyparInfo * UnscopedTyparEnv - val TcNonRecursiveBinding: + val TcNonRecursiveBinding : declKind:DeclKind -> cenv:TcFileState -> env:TcEnv -> tpenv:UnscopedTyparEnv -> ty:TypedTree.TType -> b:SyntaxTree.SynBinding -> CheckedBindingInfo * UnscopedTyparEnv - val TcAttribute: + val TcAttribute : canFail:bool -> cenv:TcFileState -> env:TcEnv -> attrTgt:System.AttributeTargets -> synAttr:SyntaxTree.SynAttribute -> (System.AttributeTargets * TypedTree.Attrib) list * bool - val TcAttributesWithPossibleTargets: + val TcAttributesWithPossibleTargets : canFail:bool -> cenv:TcFileState -> env:TcEnv -> attrTgt:System.AttributeTargets -> synAttribs:SyntaxTree.SynAttribute list -> (System.AttributeTargets * TypedTree.Attrib) list * bool - val TcAttributesMaybeFail: + val TcAttributesMaybeFail : canFail:bool -> cenv:TcFileState -> env:TcEnv -> attrTgt:System.AttributeTargets -> synAttribs:SyntaxTree.SynAttribute list -> TypedTree.Attrib list * bool - val TcAttributesCanFail: + val TcAttributesCanFail : cenv:TcFileState -> env:TcEnv -> attrTgt:System.AttributeTargets -> synAttribs:SyntaxTree.SynAttribute list -> TypedTree.Attrib list * (unit -> TypedTree.Attribs) - val TcAttributes: + val TcAttributes : cenv:TcFileState -> env:TcEnv -> attrTgt:System.AttributeTargets -> synAttribs:SyntaxTree.SynAttribute list -> TypedTree.Attribs - val TcLetBinding: + val TcLetBinding : cenv:TcFileState -> isUse:bool -> env:TcEnv -> @@ -7713,7 +32777,7 @@ namespace FSharp.Compiler (TypedTree.Expr * TypedTree.TType -> TypedTree.Expr * TypedTree.TType) * TcEnv * UnscopedTyparEnv - val TcLetBindings: + val TcLetBindings : cenv:TcFileState -> env:TcEnv -> containerInfo:ContainerInfo -> @@ -7723,19 +32787,19 @@ namespace FSharp.Compiler scopem:Range.range -> TypedTree.ModuleOrNamespaceExpr list * TcEnv * UnscopedTyparEnv - val CheckMemberFlags: + val CheckMemberFlags : optIntfSlotTy:'a option -> newslotsOK:NewSlotsOK -> overridesOK:OverridesOK -> memberFlags:SyntaxTree.MemberFlags -> m:Range.range -> unit - val ApplyTypesFromArgumentPatterns: + val ApplyTypesFromArgumentPatterns : cenv:TcFileState * env:TcEnv * optArgsOK:bool * ty:TypedTree.TType * m:Range.range * tpenv:UnscopedTyparEnv * NormalizedBindingRhs * memberFlagsOpt:SyntaxTree.MemberFlags option -> unit - val ComputeIsComplete: + val ComputeIsComplete : enclosingDeclaredTypars:TypedTree.Typar list -> declaredTypars:TypedTree.Typar list -> ty:TypedTree.TType -> bool - val ApplyAbstractSlotInference: + val ApplyAbstractSlotInference : cenv:cenv -> envinner:TcEnv -> bindingTy:TypedTree.TType * m:Range.range * @@ -7746,11 +32810,11 @@ namespace FSharp.Compiler optIntfSlotTy:(TypedTree.TType * MethodOverrides.SlotImplSet) option * valSynData:SyntaxTree.SynValInfo * memberFlags:SyntaxTree.MemberFlags * attribs:TypedTree.Attribs -> TypedTree.TType list * TypedTree.Typars - val CheckForNonAbstractInterface: + val CheckForNonAbstractInterface : declKind:DeclKind -> tcref:TypedTree.TyconRef -> memberFlags:SyntaxTree.MemberFlags -> m:Range.range -> unit - val AnalyzeRecursiveStaticMemberOrValDecl: + val AnalyzeRecursiveStaticMemberOrValDecl : cenv:TcFileState * envinner:TcEnv * tpenv:'j * declKind:DeclKind * newslotsOK:NewSlotsOK * overridesOK:OverridesOK * tcrefContainerInfo:MemberOrValContainerInfo option * vis1:'k option * @@ -7762,7 +32826,7 @@ namespace FSharp.Compiler TcEnv * 'j * SyntaxTree.Ident * 'o option * PreValMemberInfo option * 'k option * 'k option * TypedTree.Val option * TypedTree.Typar list * TypedTree.Val option * 'n * 'm * 'l - val AnalyzeRecursiveInstanceMemberDecl: + val AnalyzeRecursiveInstanceMemberDecl : cenv:cenv * envinner:TcEnv * tpenv:'p * declKind:DeclKind * synTyparDecls:SyntaxTree.SynValTyparDecls * valSynInfo:SyntaxTree.SynValInfo * explicitTyparInfo:ExplicitTyparInfo * @@ -7776,7 +32840,7 @@ namespace FSharp.Compiler PreValMemberInfo option * 'q option * 'q option * 'r option * TypedTree.Typar list * TypedTree.Val option * ExplicitTyparInfo * NormalizedBindingRhs * TypedTree.Typars - val AnalyzeRecursiveDecl: + val AnalyzeRecursiveDecl : cenv:TcFileState * envinner:TcEnv * tpenv:UnscopedTyparEnv * declKind:DeclKind * synTyparDecls:SyntaxTree.SynValTyparDecls * declaredTypars:TypedTree.Typars * thisIdOpt:SyntaxTree.Ident option * @@ -7792,7 +32856,7 @@ namespace FSharp.Compiler SyntaxTree.SynAccess option * TypedTree.Val option * TypedTree.Typar list * TypedTree.Val option * ExplicitTyparInfo * NormalizedBindingRhs * TypedTree.Typars - val AnalyzeAndMakeAndPublishRecursiveValue: + val AnalyzeAndMakeAndPublishRecursiveValue : overridesOK:OverridesOK -> isGeneratedEventVal:bool -> cenv:TcFileState -> @@ -7801,7 +32865,7 @@ namespace FSharp.Compiler NormalizedRecBindingDefn -> (PreCheckingRecursiveBinding list * TypedTree.Val list) * (UnscopedTyparEnv * int) - val AnalyzeAndMakeAndPublishRecursiveValues: + val AnalyzeAndMakeAndPublishRecursiveValues : overridesOK:OverridesOK -> cenv:TcFileState -> env:TcEnv -> @@ -7809,7 +32873,7 @@ namespace FSharp.Compiler binds:NormalizedRecBindingDefn list -> PreCheckingRecursiveBinding list * TypedTree.Val list * (UnscopedTyparEnv * int) - val TcLetrecBinding: + val TcLetrecBinding : cenv:TcFileState * envRec:TcEnv * scopem:Range.range * extraGeneralizableTypars:TypedTree.Typars * reqdThisValTyOpt:TypedTree.TType option -> @@ -7822,7 +32886,7 @@ namespace FSharp.Compiler TcEnv * PostGeneralizationRecursiveBinding list * PreGeneralizationRecursiveBinding list * UnscopedTyparEnv * Map - val TcIncrementalLetRecGeneralization: + val TcIncrementalLetRecGeneralization : cenv:TcFileState -> scopem:Range.range -> envNonRec:TcEnv * @@ -7833,48 +32897,48 @@ namespace FSharp.Compiler TcEnv * PostGeneralizationRecursiveBinding list * PreGeneralizationRecursiveBinding list * UnscopedTyparEnv * Map - val TcLetrecComputeAndGeneralizeGenericTyparsForBinding: + val TcLetrecComputeAndGeneralizeGenericTyparsForBinding : cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> freeInEnv:Internal.Utilities.Collections.Tagged.Set> -> pgrbind:PreGeneralizationRecursiveBinding -> TypedTree.Typar list - val TcLetrecComputeSupportForBinding: + val TcLetrecComputeSupportForBinding : cenv:TcFileState -> pgrbind:PreGeneralizationRecursiveBinding -> TypedTree.Typar list - val TcLetrecGeneralizeBinding: + val TcLetrecGeneralizeBinding : cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> generalizedTypars:TypedTree.Typar list -> pgrbind:PreGeneralizationRecursiveBinding -> PostGeneralizationRecursiveBinding - val TcLetrecComputeCtorSafeThisValBind: + val TcLetrecComputeCtorSafeThisValBind : cenv:TcFileState -> safeThisValOpt:TypedTree.Val option -> TypedTree.Binding option - val MakeCheckSafeInitField: + val MakeCheckSafeInitField : g:TcGlobals.TcGlobals -> tinst:TypedTree.TypeInst -> thisValOpt:TypedTree.Val option -> rfref:TypedTree.RecdFieldRef -> reqExpr:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val MakeCheckSafeInit: + val MakeCheckSafeInit : g:TcGlobals.TcGlobals -> tinst:TypedTree.TypeInst -> safeInitInfo:SafeInitData -> reqExpr:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val TcLetrecAdjustMemberForSpecialVals: + val TcLetrecAdjustMemberForSpecialVals : cenv:TcFileState -> pgrbind:PostGeneralizationRecursiveBinding -> PostSpecialValsRecursiveBinding - val FixupLetrecBind: + val FixupLetrecBind : cenv:TcFileState -> denv:TypedTreeOps.DisplayEnv -> generalizedTyparsForRecursiveBlock:TypedTree.Typars -> bind:PostSpecialValsRecursiveBinding -> PreInitializationGraphEliminationBinding - val unionGeneralizedTypars: + val unionGeneralizedTypars : typarSets:TypedTree.Typar list list -> TypedTree.Typar list - val TcLetrec: + val TcLetrec : overridesOK:OverridesOK -> cenv:TcFileState -> env:TcEnv -> @@ -7882,15 +32946,15 @@ namespace FSharp.Compiler binds:RecDefnBindingInfo list * bindsm:Range.range * scopem:Range.range -> TypedTree.Bindings * TcEnv * UnscopedTyparEnv - val TcAndPublishValSpec: + val TcAndPublishValSpec : cenv:TcFileState * env:TcEnv * containerInfo:ContainerInfo * declKind:DeclKind * memFlagsOpt:SyntaxTree.MemberFlags option * tpenv:UnscopedTyparEnv * valSpfn:SyntaxTree.SynValSig -> TypedTree.Val list * UnscopedTyparEnv - + end namespace FSharp.Compiler - module internal CheckComputationExpressions = + module internal CheckComputationExpressions = begin type cenv = CheckExpressions.TcFileState type CompExprTranslationPass = | Initial @@ -7898,35 +32962,35 @@ namespace FSharp.Compiler type CustomOperationsMode = | Allowed | Denied - val TryFindIntrinsicOrExtensionMethInfo: + val TryFindIntrinsicOrExtensionMethInfo : collectionSettings:NameResolution.ResultCollectionSettings -> cenv:cenv -> env:CheckExpressions.TcEnv -> m:Range.range -> ad:AccessibilityLogic.AccessorDomain -> nm:string -> ty:TypedTree.TType -> Infos.MethInfo list - val IgnoreAttribute: 'a -> 'b option - val ( |ExprAsPat|_| ): f:SyntaxTree.SynExpr -> SyntaxTree.SynPat option - val ( |JoinRelation|_| ): + val IgnoreAttribute : 'a -> 'b option + val ( |ExprAsPat|_| ) : f:SyntaxTree.SynExpr -> SyntaxTree.SynPat option + val ( |JoinRelation|_| ) : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> e:SyntaxTree.SynExpr -> (SyntaxTree.SynExpr * SyntaxTree.SynExpr) option - val elimFastIntegerForLoop: + val elimFastIntegerForLoop : spBind:SyntaxTree.DebugPointAtFor * id:SyntaxTree.Ident * start:SyntaxTree.SynExpr * dir:bool * finish:SyntaxTree.SynExpr * innerExpr:SyntaxTree.SynExpr * m:Range.range -> SyntaxTree.SynExpr - val YieldFree: cenv:cenv -> expr:SyntaxTree.SynExpr -> bool - val ( |SimpleSemicolonSequence|_| ): + val YieldFree : cenv:cenv -> expr:SyntaxTree.SynExpr -> bool + val ( |SimpleSemicolonSequence|_| ) : cenv:cenv -> acceptDeprecated:bool -> cexpr:SyntaxTree.SynExpr -> SyntaxTree.SynExpr list option - val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects: + val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> tpenv:CheckExpressions.UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> unit - val TcComputationExpression: + val TcComputationExpression : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> overallTy:TypedTree.TType -> @@ -7934,18 +32998,18 @@ namespace FSharp.Compiler mWhole:Range.range * interpExpr:TypedTree.Expr * builderTy:TypedTree.TType * comp:SyntaxTree.SynExpr -> TypedTree.Expr * CheckExpressions.UnscopedTyparEnv - val mkSeqEmpty: + val mkSeqEmpty : cenv:cenv -> env:CheckExpressions.TcEnv -> m:Range.range -> genTy:TypedTree.TType -> TypedTree.Expr - val mkSeqCollect: + val mkSeqCollect : cenv:cenv -> env:CheckExpressions.TcEnv -> m:Range.range -> enumElemTy:TypedTree.TType -> genTy:TypedTree.TType -> lam:TypedTree.Expr -> enumExpr:TypedTree.Expr -> TypedTree.Expr - val mkSeqUsing: + val mkSeqUsing : cenv:cenv -> env:CheckExpressions.TcEnv -> m:Range.range -> @@ -7953,34 +33017,34 @@ namespace FSharp.Compiler genTy:TypedTree.TType -> resourceExpr:TypedTree.Expr -> lam:TypedTree.Expr -> TypedTree.Expr - val mkSeqDelay: + val mkSeqDelay : cenv:cenv -> env:CheckExpressions.TcEnv -> m:Range.range -> genTy:TypedTree.TType -> lam:TypedTree.Expr -> TypedTree.Expr - val mkSeqAppend: + val mkSeqAppend : cenv:cenv -> env:CheckExpressions.TcEnv -> m:Range.range -> genTy:TypedTree.TType -> e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkSeqFromFunctions: + val mkSeqFromFunctions : cenv:cenv -> env:CheckExpressions.TcEnv -> m:Range.range -> genTy:TypedTree.TType -> e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkSeqFinally: + val mkSeqFinally : cenv:cenv -> env:CheckExpressions.TcEnv -> m:Range.range -> genTy:TypedTree.TType -> e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkSeqExprMatchClauses: + val mkSeqExprMatchClauses : pat':PatternMatchCompilation.Pattern * vspecs:TypedTree.Val list -> innerExpr:TypedTree.Expr -> PatternMatchCompilation.TypedMatchClause list - val compileSeqExprMatchClauses: + val compileSeqExprMatchClauses : cenv:cenv -> env:CheckExpressions.TcEnv -> inputExprMark:Range.range -> @@ -7989,7 +33053,7 @@ namespace FSharp.Compiler inputExprOpt:TypedTree.Expr option -> bindPatTy:TypedTree.TType -> genInnerTy:TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val TcSequenceExpression: + val TcSequenceExpression : cenv:cenv -> env:CheckExpressions.TcEnv -> tpenv:CheckExpressions.UnscopedTyparEnv -> @@ -7997,7 +33061,7 @@ namespace FSharp.Compiler overallTy:TypedTree.TType -> m:Range.range -> TypedTree.Expr * CheckExpressions.UnscopedTyparEnv - val TcSequenceExpressionEntry: + val TcSequenceExpressionEntry : cenv:cenv -> env:CheckExpressions.TcEnv -> overallTy:TypedTree.TType -> @@ -8006,7 +33070,7 @@ namespace FSharp.Compiler comp:SyntaxTree.SynExpr -> m:Range.range -> TypedTree.Expr * CheckExpressions.UnscopedTyparEnv - val TcArrayOrListSequenceExpression: + val TcArrayOrListSequenceExpression : cenv:cenv -> env:CheckExpressions.TcEnv -> overallTy:TypedTree.TType -> @@ -8014,10 +33078,10 @@ namespace FSharp.Compiler isArray:bool * comp:SyntaxTree.SynExpr -> m:Range.range -> TypedTree.Expr * CheckExpressions.UnscopedTyparEnv - + end namespace FSharp.Compiler - module internal CheckDeclarations = + module internal CheckDeclarations = begin type cenv = CheckExpressions.TcFileState type MutRecDataForOpen = | MutRecDataForOpen of @@ -8025,7 +33089,7 @@ namespace FSharp.Compiler type MutRecDataForModuleAbbrev = | MutRecDataForModuleAbbrev of SyntaxTree.Ident * SyntaxTree.LongIdent * Range.range - [] + [] type MutRecShape<'TypeData,'LetsData,'ModuleData> = | Tycon of 'TypeData | Lets of 'LetsData @@ -8034,94 +33098,94 @@ namespace FSharp.Compiler | Open of MutRecDataForOpen and MutRecShapes<'TypeData,'LetsData,'ModuleData> = MutRecShape<'TypeData,'LetsData,'ModuleData> list - module MutRecShapes = - val map: + module MutRecShapes = begin + val map : f1:('a -> 'b) -> f2:('c -> 'd) -> f3:('e -> 'f) -> x:MutRecShape<'a,'c,'e> list -> MutRecShape<'b,'d,'f> list - val mapTycons: + val mapTycons : f1:('a -> 'b) -> xs:MutRecShape<'a,'c,'d> list -> MutRecShape<'b,'c,'d> list - val mapTyconsAndLets: + val mapTyconsAndLets : f1:('a -> 'b) -> f2:('c -> 'd) -> xs:MutRecShape<'a,'c,'e> list -> MutRecShape<'b,'d,'e> list - val mapLets: + val mapLets : f2:('a -> 'b) -> xs:MutRecShape<'c,'a,'d> list -> MutRecShape<'c,'b,'d> list - val mapModules: + val mapModules : f1:('a -> 'b) -> xs:MutRecShape<'c,'d,'a> list -> MutRecShape<'c,'d,'b> list - val mapWithEnv: + val mapWithEnv : fTycon:('Env -> 'a -> 'b) -> fLets:('Env -> 'c -> 'd) -> env:'Env -> x:MutRecShape<'a,'c,('e * 'Env)> list -> MutRecShape<'b,'d,('e * 'Env)> list - val mapTyconsWithEnv: + val mapTyconsWithEnv : f1:('a -> 'b -> 'c) -> env:'a -> xs:MutRecShape<'b,'d,('e * 'a)> list -> MutRecShape<'c,'d,('e * 'a)> list - val mapWithParent: + val mapWithParent : parent:'a -> f1:('a -> 'b -> MutRecShapes<'c,'d,'b> -> 'e * 'a) -> f2:('a -> 'c -> 'f) -> f3:('a -> 'd -> 'g) -> xs:MutRecShape<'c,'d,'b> list -> MutRecShape<'f,'g,'e> list - val computeEnvs: + val computeEnvs : f1:('a -> 'b -> 'Env) -> f2:('Env -> MutRecShape<'c,'d,'b> list -> 'a) -> env:'Env -> xs:MutRecShape<'c,'d,'b> list -> 'a * MutRecShape<'c,'d,('b * 'a)> list - val extendEnvs: + val extendEnvs : f1:('Env -> MutRecShape<'a,'b,('c * 'Env)> list -> 'Env) -> env:'Env -> xs:MutRecShape<'a,'b,('c * 'Env)> list -> 'Env * MutRecShape<'a,'b,('c * 'Env)> list - val dropEnvs: + val dropEnvs : xs:MutRecShape<'a,'b,('c * 'd)> list -> MutRecShape<'a,'b,'c> list - val expandTyconsWithEnv: + val expandTyconsWithEnv : f1:('a -> 'b -> 'c list * 'c list) -> env:'a -> xs:MutRecShape<'b,'c list,('d * 'a)> list -> MutRecShape<'b,'c list,('d * 'a)> list - val mapFoldWithEnv: + val mapFoldWithEnv : f1:('a -> 'b -> MutRecShape<'c,'d,('e * 'b)> -> MutRecShape<'f,'g,('e * 'b)> * 'a) -> z:'a -> env:'b -> xs:MutRecShape<'c,'d,('e * 'b)> list -> MutRecShape<'f,'g,('e * 'b)> list * 'a - val collectTycons: x:MutRecShape<'a,'b,'c> list -> 'a list - val topTycons: x:MutRecShape<'a,'b,'c> list -> 'a list - val iter: + val collectTycons : x:MutRecShape<'a,'b,'c> list -> 'a list + val topTycons : x:MutRecShape<'a,'b,'c> list -> 'a list + val iter : f1:('a -> unit) -> f2:('b -> unit) -> f3:('c -> unit) -> f4:(MutRecDataForOpen -> unit) -> f5:(MutRecDataForModuleAbbrev -> unit) -> x:MutRecShape<'a,'b,'c> list -> unit - val iterTycons: f1:('a -> unit) -> x:MutRecShape<'a,'b,'c> list -> unit - val iterTyconsAndLets: + val iterTycons : f1:('a -> unit) -> x:MutRecShape<'a,'b,'c> list -> unit + val iterTyconsAndLets : f1:('a -> unit) -> f2:('b -> unit) -> x:MutRecShape<'a,'b,'c> list -> unit - val iterModules: f1:('a -> unit) -> x:MutRecShape<'b,'c,'a> list -> unit - val iterWithEnv: + val iterModules : f1:('a -> unit) -> x:MutRecShape<'b,'c,'a> list -> unit + val iterWithEnv : f1:('a -> 'b -> unit) -> f2:('a -> 'c -> unit) -> f3:('a -> MutRecDataForOpen -> unit) -> f4:('a -> MutRecDataForModuleAbbrev -> unit) -> env:'a -> x:MutRecShape<'b,'c,('d * 'a)> list -> unit - val iterTyconsWithEnv: + val iterTyconsWithEnv : f1:('a -> 'b -> unit) -> env:'a -> xs:MutRecShape<'b,'c,('d * 'a)> list -> unit - - val ModuleOrNamespaceContainerInfo: + end + val ModuleOrNamespaceContainerInfo : modref:TypedTree.EntityRef -> CheckExpressions.ContainerInfo - val TyconContainerInfo: + val TyconContainerInfo : parent:TypedTree.ParentRef * tcref:TypedTree.TyconRef * declaredTyconTypars:TypedTree.Typars * safeInitInfo:CheckExpressions.SafeInitData -> @@ -8169,25 +33233,25 @@ namespace FSharp.Compiler MutRecShape list - val AddLocalExnDefnAndReport: + val AddLocalExnDefnAndReport : tcSink:NameResolution.TcResultsSink -> scopem:Range.range -> env:CheckExpressions.TcEnv -> exnc:TypedTree.Tycon -> CheckExpressions.TcEnv - val AddLocalTyconRefs: + val AddLocalTyconRefs : ownDefinition:bool -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> tcrefs:TypedTree.TyconRef list -> env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv - val AddLocalTycons: + val AddLocalTycons : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> tycons:TypedTree.Tycon list -> env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv - val AddLocalTyconsAndReport: + val AddLocalTyconsAndReport : tcSink:NameResolution.TcResultsSink -> scopem:Range.range -> g:TcGlobals.TcGlobals -> @@ -8195,13 +33259,13 @@ namespace FSharp.Compiler m:Range.range -> tycons:TypedTree.Tycon list -> env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv - val AddLocalSubModule: + val AddLocalSubModule : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> env:CheckExpressions.TcEnv -> modul:TypedTree.ModuleOrNamespace -> CheckExpressions.TcEnv - val AddLocalSubModuleAndReport: + val AddLocalSubModuleAndReport : tcSink:NameResolution.TcResultsSink -> scopem:Range.range -> g:TcGlobals.TcGlobals -> @@ -8209,27 +33273,27 @@ namespace FSharp.Compiler m:Range.range -> env:CheckExpressions.TcEnv -> modul:TypedTree.ModuleOrNamespace -> CheckExpressions.TcEnv - val BuildRootModuleType: + val BuildRootModuleType : enclosingNamespacePath:SyntaxTree.Ident list -> cpath:TypedTree.CompilationPath -> mtyp:TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespaceType * TypedTree.ModuleOrNamespace list - val BuildRootModuleExpr: + val BuildRootModuleExpr : enclosingNamespacePath:SyntaxTree.Ident list -> cpath:TypedTree.CompilationPath -> mexpr:TypedTree.ModuleOrNamespaceExpr -> TypedTree.ModuleOrNamespaceExpr - val TryStripPrefixPath: + val TryStripPrefixPath : g:TcGlobals.TcGlobals -> enclosingNamespacePath:SyntaxTree.Ident list -> (SyntaxTree.Ident * SyntaxTree.Ident list) option - val AddModuleAbbreviationAndReport: + val AddModuleAbbreviationAndReport : tcSink:NameResolution.TcResultsSink -> scopem:Range.range -> id:SyntaxTree.Ident -> modrefs:TypedTree.ModuleOrNamespaceRef list -> env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv - val OpenModuleOrNamespaceRefs: + val OpenModuleOrNamespaceRefs : tcSink:NameResolution.TcResultsSink -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> @@ -8239,7 +33303,7 @@ namespace FSharp.Compiler mvvs:TypedTree.ModuleOrNamespaceRef list -> openDeclaration:NameResolution.OpenDeclaration -> CheckExpressions.TcEnv - val OpenTypeContent: + val OpenTypeContent : tcSink:NameResolution.TcResultsSink -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> @@ -8248,17 +33312,17 @@ namespace FSharp.Compiler typ:TypedTree.TType -> openDeclaration:NameResolution.OpenDeclaration -> CheckExpressions.TcEnv - val AddRootModuleOrNamespaceRefs: + val AddRootModuleOrNamespaceRefs : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> env:CheckExpressions.TcEnv -> modrefs:TypedTree.ModuleOrNamespaceRef list -> CheckExpressions.TcEnv - val addInternalsAccessibility: + val addInternalsAccessibility : env:CheckExpressions.TcEnv -> ccu:TypedTree.CcuThunk -> CheckExpressions.TcEnv - val AddNonLocalCcu: + val AddNonLocalCcu : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> scopem:Range.range -> @@ -8267,14 +33331,14 @@ namespace FSharp.Compiler ccu:TypedTree.CcuThunk * internalsVisibleToAttributes:string list -> CheckExpressions.TcEnv - val AddLocalRootModuleOrNamespace: + val AddLocalRootModuleOrNamespace : NameResolution.TcResultsSink -> TcGlobals.TcGlobals -> Import.ImportMap -> Range.range -> CheckExpressions.TcEnv -> TypedTree.ModuleOrNamespaceType -> CheckExpressions.TcEnv - val ImplicitlyOpenOwnNamespace: + val ImplicitlyOpenOwnNamespace : tcSink:NameResolution.TcResultsSink -> g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> @@ -8282,15 +33346,15 @@ namespace FSharp.Compiler enclosingNamespacePath:SyntaxTree.Ident list -> env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv exception NotUpperCaseConstructor of Range.range - val CheckNamespaceModuleOrTypeName: + val CheckNamespaceModuleOrTypeName : g:TcGlobals.TcGlobals -> id:SyntaxTree.Ident -> unit - val CheckDuplicates: + val CheckDuplicates : idf:('a -> SyntaxTree.Ident) -> k:string -> elems:'a list -> 'a list - module TcRecdUnionAndEnumDeclarations = - val CombineReprAccess: + module TcRecdUnionAndEnumDeclarations = begin + val CombineReprAccess : parent:TypedTree.ParentRef -> vis:TypedTree.Accessibility -> TypedTree.Accessibility - val MakeRecdFieldSpec: + val MakeRecdFieldSpec : _cenv:'a -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> @@ -8300,7 +33364,7 @@ namespace FSharp.Compiler nameGenerated:bool * isMutable:bool * vol:bool * xmldoc:XmlDoc.XmlDoc * vis:SyntaxTree.SynAccess option * m:Range.range -> TypedTree.RecdField - val TcFieldDecl: + val TcFieldDecl : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> @@ -8311,31 +33375,31 @@ namespace FSharp.Compiler ty:SyntaxTree.SynType * isMutable:bool * xmldoc:XmlDoc.XmlDoc * vis:SyntaxTree.SynAccess option * m:Range.range -> TypedTree.RecdField - val TcAnonFieldDecl: + val TcAnonFieldDecl : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> tpenv:CheckExpressions.UnscopedTyparEnv -> nm:string -> SyntaxTree.SynField -> TypedTree.RecdField - val TcNamedFieldDecl: + val TcNamedFieldDecl : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> isIncrClass:bool -> tpenv:CheckExpressions.UnscopedTyparEnv -> SyntaxTree.SynField -> TypedTree.RecdField - val TcNamedFieldDecls: + val TcNamedFieldDecls : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> isIncrClass:bool -> tpenv:CheckExpressions.UnscopedTyparEnv -> fields:SyntaxTree.SynField list -> TypedTree.RecdField list - val CheckUnionCaseName: cenv:cenv -> id:SyntaxTree.Ident -> unit - val ValidateFieldNames: + val CheckUnionCaseName : cenv:cenv -> id:SyntaxTree.Ident -> unit + val ValidateFieldNames : synFields:SyntaxTree.SynField list * tastFields:TypedTree.RecdField list -> unit - val TcUnionCaseDecl: + val TcUnionCaseDecl : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> @@ -8343,7 +33407,7 @@ namespace FSharp.Compiler thisTyInst:TypedTree.TypeInst -> tpenv:CheckExpressions.UnscopedTyparEnv -> SyntaxTree.SynUnionCase -> TypedTree.UnionCase - val TcUnionCaseDecls: + val TcUnionCaseDecls : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> @@ -8352,27 +33416,27 @@ namespace FSharp.Compiler tpenv:CheckExpressions.UnscopedTyparEnv -> unionCases:SyntaxTree.SynUnionCase list -> TypedTree.UnionCase list - val TcEnumDecl: + val TcEnumDecl : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> thisTy:TypedTree.TType -> fieldTy:TypedTree.TType -> SyntaxTree.SynEnumCase -> TypedTree.RecdField - val TcEnumDecls: + val TcEnumDecls : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> thisTy:TypedTree.TType -> enumCases:SyntaxTree.SynEnumCase list -> TypedTree.TType * TypedTree.RecdField list - - val PublishInterface: + end + val PublishInterface : cenv:cenv -> denv:TypedTreeOps.DisplayEnv -> tcref:TypedTree.TyconRef -> m:Range.range -> compgen:bool -> ty':TypedTree.TType -> unit - val TcAndPublishMemberSpec: + val TcAndPublishMemberSpec : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> containerInfo:CheckExpressions.ContainerInfo -> @@ -8380,7 +33444,7 @@ namespace FSharp.Compiler tpenv:CheckExpressions.UnscopedTyparEnv -> memb:SyntaxTree.SynMemberSig -> TypedTree.Val list * CheckExpressions.UnscopedTyparEnv - val TcTyconMemberSpecs: + val TcTyconMemberSpecs : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> containerInfo:CheckExpressions.ContainerInfo -> @@ -8388,39 +33452,39 @@ namespace FSharp.Compiler tpenv:CheckExpressions.UnscopedTyparEnv -> augSpfn:SyntaxTree.SynMemberSig list -> TypedTree.Val list * CheckExpressions.UnscopedTyparEnv - val TcOpenLidAndPermitAutoResolve: + val TcOpenLidAndPermitAutoResolve : tcSink:NameResolution.TcResultsSink -> env:CheckExpressions.TcEnv -> amap:Import.ImportMap -> longId:SyntaxTree.Ident list -> (int * TypedTree.ModuleOrNamespaceRef * TypedTree.ModuleOrNamespaceType) list - val TcOpenModuleOrNamespaceDecl: + val TcOpenModuleOrNamespaceDecl : NameResolution.TcResultsSink -> TcGlobals.TcGlobals -> Import.ImportMap -> Range.range -> CheckExpressions.TcEnv -> (SyntaxTree.Ident list * Range.range) -> CheckExpressions.TcEnv - val TcOpenTypeDecl: + val TcOpenTypeDecl : cenv:cenv -> mOpenDecl:Range.range -> scopem:Range.range -> env:CheckExpressions.TcEnv -> synType:SyntaxTree.SynType * m:Range.range -> CheckExpressions.TcEnv - val TcOpenDecl: + val TcOpenDecl : cenv:CheckExpressions.TcFileState -> mOpenDecl:Range.range -> scopem:Range.range -> env:CheckExpressions.TcEnv -> target:SyntaxTree.SynOpenDeclTarget -> CheckExpressions.TcEnv exception ParameterlessStructCtor of Range.range - val MakeSafeInitField: + val MakeSafeInitField : g:TcGlobals.TcGlobals -> env:CheckExpressions.TcEnv -> m:Range.range -> isStatic:bool -> TypedTree.RecdField - module IncrClassChecking = + module IncrClassChecking = begin type IncrClassBindingGroup = | IncrClassBindingGroup of TypedTree.Binding list * bool * bool | IncrClassDo of TypedTree.Expr * bool @@ -8440,12 +33504,12 @@ namespace FSharp.Compiler NameGenerator: CompilerGlobalState.NiceNameGenerator } with member - GetNormalizedInstanceCtorDeclaredTypars: cenv:cenv -> + GetNormalizedInstanceCtorDeclaredTypars : cenv:cenv -> denv:TypedTreeOps.DisplayEnv -> m:Range.range -> TypedTree.Typar list - - val TcImplicitCtorLhs_Phase2A: + end + val TcImplicitCtorLhs_Phase2A : cenv:cenv * env:CheckExpressions.TcEnv * tpenv:CheckExpressions.UnscopedTyparEnv * tcref:TypedTree.TyconRef * vis:SyntaxTree.SynAccess option * attrs:SyntaxTree.SynAttribute list * @@ -8454,7 +33518,7 @@ namespace FSharp.Compiler safeInitInfo:CheckExpressions.SafeInitData * m:Range.range * copyOfTyconTypars:TypedTree.Typar list * objTy:TypedTree.TType * thisTy:TypedTree.TType * doc:XmlDoc.PreXmlDoc -> IncrClassCtorLhs - val private MakeIncrClassField: + val private MakeIncrClassField : g:TcGlobals.TcGlobals * cpath:TypedTree.CompilationPath * formalTyparInst:TypedTreeOps.TyparInst * v:TypedTree.Val * isStatic:bool * rfref:TypedTree.RecdFieldRef -> TypedTree.RecdField @@ -8469,12 +33533,12 @@ namespace FSharp.Compiler ValsWithRepresentation: AbstractIL.Internal.Zset } with static member - Empty: g:TcGlobals.TcGlobals * names:string list -> + Empty : g:TcGlobals.TcGlobals * names:string list -> IncrClassReprInfo static member - IsMethodRepr: cenv:cenv -> bind:TypedTree.Binding -> bool + IsMethodRepr : cenv:cenv -> bind:TypedTree.Binding -> bool member - ChooseAndAddRepresentation: cenv:cenv * env:CheckExpressions.TcEnv * + ChooseAndAddRepresentation : cenv:cenv * env:CheckExpressions.TcEnv * isStatic:bool * isCtorArg:bool * ctorInfo:IncrClassCtorLhs * staticForcedFieldVars:TypedTree.FreeLocals * @@ -8482,7 +33546,7 @@ namespace FSharp.Compiler bind:TypedTree.Binding -> IncrClassReprInfo member - ChooseRepresentation: cenv:cenv * env:CheckExpressions.TcEnv * + ChooseRepresentation : cenv:cenv * env:CheckExpressions.TcEnv * isStatic:bool * isCtorArg:bool * ctorInfo:IncrClassCtorLhs * staticForcedFieldVars:TypedTree.FreeLocals * @@ -8491,50 +33555,50 @@ namespace FSharp.Compiler bind:TypedTree.Binding -> IncrClassValRepr * Set member - FixupIncrClassExprPhase2C: cenv:CheckExpressions.TcFileState -> + FixupIncrClassExprPhase2C : cenv:CheckExpressions.TcFileState -> thisValOpt:TypedTree.Val option -> safeStaticInitInfo:CheckExpressions.SafeInitData -> thisTyInst:TypedTree.TypeInst -> expr:TypedTree.Expr -> TypedTree.Expr - member IsValRepresentedAsLocalVar: v:TypedTree.Val -> bool - member IsValRepresentedAsMethod: v:TypedTree.Val -> bool - member IsValWithRepresentation: v:TypedTree.Val -> bool - member LookupRepr: v:TypedTree.Val -> IncrClassValRepr + member IsValRepresentedAsLocalVar : v:TypedTree.Val -> bool + member IsValRepresentedAsMethod : v:TypedTree.Val -> bool + member IsValWithRepresentation : v:TypedTree.Val -> bool + member LookupRepr : v:TypedTree.Val -> IncrClassValRepr member - MakeValueAssign: thisValOpt:TypedTree.Val option -> + MakeValueAssign : thisValOpt:TypedTree.Val option -> tinst:TypedTree.TypeInst -> safeStaticInitInfo:CheckExpressions.SafeInitData -> v:TypedTree.Val -> expr:TypedTree.Expr -> m:Range.range -> TypedTree.Expr member - MakeValueGetAddress: readonly:bool -> + MakeValueGetAddress : readonly:bool -> thisValOpt:TypedTree.Val option -> tinst:TypedTree.TypeInst -> safeStaticInitInfo:CheckExpressions.SafeInitData -> v:TypedTree.Val -> m:Range.range -> TypedTree.Expr member - MakeValueLookup: thisValOpt:TypedTree.Val option -> + MakeValueLookup : thisValOpt:TypedTree.Val option -> tinst:TypedTree.TypeInst -> safeStaticInitInfo:CheckExpressions.SafeInitData -> v:TypedTree.Val -> tyargs:TypedTree.TType list -> m:Range.range -> TypedTree.Expr member - PublishIncrClassFields: cenv:cenv * denv:TypedTreeOps.DisplayEnv * + PublishIncrClassFields : cenv:cenv * denv:TypedTreeOps.DisplayEnv * cpath:TypedTree.CompilationPath * ctorInfo:IncrClassCtorLhs * safeStaticInitInfo:CheckExpressions.SafeInitData -> unit - member ValNowWithRepresentation: v:TypedTree.Val -> IncrClassReprInfo - + member ValNowWithRepresentation : v:TypedTree.Val -> IncrClassReprInfo + end type IncrClassConstructionBindingsPhase2C = | Phase2CBindings of IncrClassBindingGroup list | Phase2CCtorJustAfterSuperInit | Phase2CCtorJustAfterLastLet - val MakeCtorForIncrClassConstructionPhase2C: + val MakeCtorForIncrClassConstructionPhase2C : cenv:cenv * env:CheckExpressions.TcEnv * ctorInfo:IncrClassCtorLhs * inheritsExpr:TypedTree.Expr * inheritsIsVisible:bool * decs:IncrClassConstructionBindingsPhase2C list * @@ -8543,8 +33607,8 @@ namespace FSharp.Compiler safeStaticInitInfo:CheckExpressions.SafeInitData -> TypedTree.Expr * TypedTree.Expr option * TypedTree.Binding list * IncrClassReprInfo - - module MutRecBindingChecking = + end + module MutRecBindingChecking = begin type TyconBindingPhase2A = | Phase2AIncrClassCtor of IncrClassChecking.IncrClassCtorLhs | Phase2AInherit of @@ -8598,14 +33662,14 @@ namespace FSharp.Compiler CheckExpressions.PreInitializationGraphEliminationBinding list, (MutRecDefnsPhase2DataForModule * CheckExpressions.TcEnv)> list val TcMutRecBindings_Phase2A_CreateRecursiveValuesAndCheckArgumentPatterns - : + : cenv:cenv -> tpenv:CheckExpressions.UnscopedTyparEnv -> envMutRec:CheckExpressions.TcEnv * mutRecDefns:MutRecDefnsPhase2Info -> MutRecDefnsPhase2AData * CheckExpressions.PreCheckingRecursiveBinding list * CheckExpressions.UnscopedTyparEnv - val TcMutRecBindings_Phase2B_TypeCheckAndIncrementalGeneralization: + val TcMutRecBindings_Phase2B_TypeCheckAndIncrementalGeneralization : cenv:cenv -> tpenv:CheckExpressions.UnscopedTyparEnv -> envInitial:CheckExpressions.TcEnv -> @@ -8615,7 +33679,7 @@ namespace FSharp.Compiler MutRecDefnsPhase2BData * CheckExpressions.PostGeneralizationRecursiveBinding list * CheckExpressions.UnscopedTyparEnv - val TcMutRecBindings_Phase2C_FixupRecursiveReferences: + val TcMutRecBindings_Phase2C_FixupRecursiveReferences : cenv:cenv -> denv:TypedTreeOps.DisplayEnv * defnsBs:MutRecDefnsPhase2BData * generalizedTyparsForRecursiveBlock:TypedTree.Typar list * @@ -8624,7 +33688,7 @@ namespace FSharp.Compiler MutRecShape list - val TcMutRecBindings_Phase2D_ExtractImplicitFieldAndMethodBindings: + val TcMutRecBindings_Phase2D_ExtractImplicitFieldAndMethodBindings : cenv:cenv -> envMutRec:CheckExpressions.TcEnv -> tpenv:CheckExpressions.UnscopedTyparEnv -> @@ -8637,21 +33701,21 @@ namespace FSharp.Compiler CheckExpressions.PreInitializationGraphEliminationBinding list, (MutRecDefnsPhase2DataForModule * CheckExpressions.TcEnv)> list - val TcModuleAbbrevDecl: + val TcModuleAbbrevDecl : cenv:cenv -> scopem:Range.range -> env:CheckExpressions.TcEnv -> id:SyntaxTree.Ident * p:SyntaxTree.Ident list * m:Range.range -> CheckExpressions.TcEnv - val TcMutRecDefns_UpdateNSContents: + val TcMutRecDefns_UpdateNSContents : mutRecNSInfo:(TypedTree.ModuleOrNamespace option * TypedTree.ModuleOrNamespaceType ref) option -> unit - val TcMutRecDefns_UpdateModuleContents: + val TcMutRecDefns_UpdateModuleContents : mutRecNSInfo:(TypedTree.ModuleOrNamespace option * TypedTree.ModuleOrNamespaceType ref) option -> defns:MutRecShape<'a,'b,(MutRecDefnsPhase2DataForModule * 'c)> list -> unit - val TcMutRecDefns_ComputeEnvs: + val TcMutRecDefns_ComputeEnvs : getTyconOpt:('a -> TypedTree.Tycon option) -> getVals:('b -> TypedTree.Val list) -> cenv:cenv -> @@ -8665,7 +33729,7 @@ namespace FSharp.Compiler MutRecShape<'a,'b, (MutRecDefnsPhase2DataForModule * CheckExpressions.TcEnv)> list - val TcMutRecDefns_Phase2_Bindings: + val TcMutRecDefns_Phase2_Bindings : cenv:cenv -> envInitial:CheckExpressions.TcEnv -> tpenv:CheckExpressions.UnscopedTyparEnv -> @@ -8681,8 +33745,8 @@ namespace FSharp.Compiler (MutRecDefnsPhase2DataForModule * CheckExpressions.TcEnv)> list * CheckExpressions.TcEnv - - val TcMutRecDefns_Phase2: + end + val TcMutRecDefns_Phase2 : cenv:cenv -> envInitial:CheckExpressions.TcEnv -> bindsm:Range.range -> @@ -8696,81 +33760,81 @@ namespace FSharp.Compiler (MutRecDefnsPhase2DataForModule * CheckExpressions.TcEnv)> list * CheckExpressions.TcEnv - module AddAugmentationDeclarations = - val tcaugHasNominalInterface: + module AddAugmentationDeclarations = begin + val tcaugHasNominalInterface : g:TcGlobals.TcGlobals -> tcaug:TypedTree.TyconAugmentation -> tcref:TypedTree.TyconRef -> bool - val AddGenericCompareDeclarations: + val AddGenericCompareDeclarations : cenv:cenv -> env:CheckExpressions.TcEnv -> scSet:Set -> tycon:TypedTree.Tycon -> unit - val AddGenericEqualityWithComparerDeclarations: + val AddGenericEqualityWithComparerDeclarations : cenv:cenv -> env:CheckExpressions.TcEnv -> seSet:Set -> tycon:TypedTree.Tycon -> unit - val AddGenericCompareBindings: + val AddGenericCompareBindings : cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list - val AddGenericCompareWithComparerBindings: + val AddGenericCompareWithComparerBindings : cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list - val AddGenericEqualityWithComparerBindings: + val AddGenericEqualityWithComparerBindings : cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list - val AddGenericHashAndComparisonDeclarations: + val AddGenericHashAndComparisonDeclarations : cenv:cenv -> env:CheckExpressions.TcEnv -> scSet:Set -> seSet:Set -> tycon:TypedTree.Tycon -> unit - val AddGenericHashAndComparisonBindings: + val AddGenericHashAndComparisonBindings : cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list - val AddGenericEqualityBindings: + val AddGenericEqualityBindings : cenv:cenv -> env:CheckExpressions.TcEnv -> tycon:TypedTree.Tycon -> TypedTree.Binding list - - module TyconConstraintInference = - val InferSetOfTyconsSupportingComparable: + end + module TyconConstraintInference = begin + val InferSetOfTyconsSupportingComparable : cenv:cenv -> denv:TypedTreeOps.DisplayEnv -> tyconsWithStructuralTypes:(TypedTree.Tycon * (TypedTree.TType * 'a) list) list -> Set - val InferSetOfTyconsSupportingEquatable: + val InferSetOfTyconsSupportingEquatable : cenv:cenv -> denv:TypedTreeOps.DisplayEnv -> tyconsWithStructuralTypes:(TypedTree.Tycon * (TypedTree.TType * 'a) list) list -> Set - - val ComputeModuleName: longPath:SyntaxTree.Ident list -> SyntaxTree.Ident - val CheckForDuplicateConcreteType: + end + val ComputeModuleName : longPath:SyntaxTree.Ident list -> SyntaxTree.Ident + val CheckForDuplicateConcreteType : env:CheckExpressions.TcEnv -> nm:string -> m:Range.range -> unit - val CheckForDuplicateModule: + val CheckForDuplicateModule : env:CheckExpressions.TcEnv -> nm:string -> m:Range.range -> unit - module TcExceptionDeclarations = - val TcExnDefnCore_Phase1A: + module TcExceptionDeclarations = begin + val TcExnDefnCore_Phase1A : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> SyntaxTree.SynExceptionDefnRepr -> TypedTree.Entity - val TcExnDefnCore_Phase1G_EstablishRepresentation: + val TcExnDefnCore_Phase1G_EstablishRepresentation : cenv:cenv -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> exnc:TypedTree.Entity -> SyntaxTree.SynExceptionDefnRepr -> TypedTree.RecdField list - val private TcExnDefnCore: + val private TcExnDefnCore : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> synExnDefnRepr:SyntaxTree.SynExceptionDefnRepr -> TypedTree.Binding list * TypedTree.Entity - val TcExnDefn: + val TcExnDefn : cenv:CheckExpressions.TcFileState -> envInitial:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> SyntaxTree.SynExceptionDefn * scopem:Range.range -> TypedTree.Binding list * TypedTree.Entity * CheckExpressions.TcEnv - val TcExnSignature: + val TcExnSignature : cenv:CheckExpressions.TcFileState -> envInitial:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> @@ -8778,60 +33842,60 @@ namespace FSharp.Compiler SyntaxTree.SynExceptionSig * scopem:Range.range -> TypedTree.Binding list * TypedTree.Val list * TypedTree.EntityRef * CheckExpressions.TcEnv - - module EstablishTypeDefinitionCores = + end + module EstablishTypeDefinitionCores = begin type TypeRealizationPass = | FirstPass | SecondPass - val private ComputeTyconName: + val private ComputeTyconName : longPath:SyntaxTree.Ident list * doErase:bool * typars:TypedTree.Typars -> SyntaxTree.Ident - val private GetTyconAttribs: + val private GetTyconAttribs : g:TcGlobals.TcGlobals -> attrs:TypedTree.Attribs -> bool * bool * bool * bool * bool - val private InferTyconKind: + val private InferTyconKind : g:TcGlobals.TcGlobals -> kind:SyntaxTree.SynTypeDefnKind * attrs:TypedTree.Attribs * slotsigs:'a list * fields:'b list * inSig:bool * isConcrete:bool * m:Range.range -> SyntaxTree.SynTypeDefnKind - val private ( |TyconCoreAbbrevThatIsReallyAUnion|_| ): + val private ( |TyconCoreAbbrevThatIsReallyAUnion|_| ) : hasMeasureAttr:bool * envinner:CheckExpressions.TcEnv * id:SyntaxTree.Ident -> synTyconRepr:SyntaxTree.SynTypeDefnSimpleRepr -> (SyntaxTree.Ident * Range.range) option - val private GetStructuralElementsOfTyconDefn: + val private GetStructuralElementsOfTyconDefn : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> tpenv:CheckExpressions.UnscopedTyparEnv -> MutRecDefnsPhase1DataForTycon -> tycon:Lib.NonNullSlot -> (TypedTree.TType * Range.range) list - val ComputeModuleOrNamespaceKind: + val ComputeModuleOrNamespaceKind : g:TcGlobals.TcGlobals -> isModule:bool -> typeNames:Set<'a> -> attribs:TypedTree.Attribs -> - nm:'a -> TypedTree.ModuleOrNamespaceKind when 'a: comparison - val AdjustModuleName: + nm:'a -> TypedTree.ModuleOrNamespaceKind when 'a : comparison + val AdjustModuleName : modKind:TypedTree.ModuleOrNamespaceKind -> nm:string -> string - val InstanceMembersNeedSafeInitCheck: + val InstanceMembersNeedSafeInitCheck : cenv:cenv -> m:Range.range -> thisTy:TypedTree.TType -> bool - val ComputeInstanceSafeInitInfo: + val ComputeInstanceSafeInitInfo : cenv:cenv -> env:CheckExpressions.TcEnv -> m:Range.range -> thisTy:TypedTree.TType -> CheckExpressions.SafeInitData - val TypeNamesInMutRecDecls: + val TypeNamesInMutRecDecls : cenv:CheckExpressions.TcFileState -> env:CheckExpressions.TcEnv -> compDecls:MutRecShapes<(MutRecDefnsPhase1DataForTycon * 'MemberInfo), 'LetInfo,SyntaxTree.SynComponentInfo> -> Set - val TypeNamesInNonMutRecDecls: + val TypeNamesInNonMutRecDecls : defs:seq -> Set - val TypeNamesInNonMutRecSigDecls: + val TypeNamesInNonMutRecSigDecls : defs:seq -> Set - val TcTyconDefnCore_Phase1A_BuildInitialModule: + val TcTyconDefnCore_Phase1A_BuildInitialModule : cenv:CheckExpressions.TcFileState -> envInitial:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> @@ -8841,22 +33905,22 @@ namespace FSharp.Compiler SyntaxTree.SynComponentInfo> -> MutRecDefnsPhase2DataForModule * (TypedTree.ParentRef * Set * CheckExpressions.TcEnv) - val private TcTyconDefnCore_Phase1A_BuildInitialTycon: + val private TcTyconDefnCore_Phase1A_BuildInitialTycon : cenv:cenv -> env:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> MutRecDefnsPhase1DataForTycon -> TypedTree.Entity - val private TcTyconDefnCore_Phase1B_EstablishBasicKind: + val private TcTyconDefnCore_Phase1B_EstablishBasicKind : cenv:cenv -> inSig:bool -> envinner:CheckExpressions.TcEnv -> MutRecDefnsPhase1DataForTycon -> tycon:TypedTree.Tycon -> TypedTree.Attrib list * (unit -> TypedTree.Attribs) - val private TcTyconDefnCore_GetGenerateDeclaration_Rhs: + val private TcTyconDefnCore_GetGenerateDeclaration_Rhs : SyntaxTree.SynType -> (SyntaxTree.LongIdent * SyntaxTree.SynType list * Range.range) option - val private TcTyconDefnCore_TryAsGenerateDeclaration: + val private TcTyconDefnCore_TryAsGenerateDeclaration : cenv:cenv -> envinner:CheckExpressions.TcEnv -> tpenv:CheckExpressions.UnscopedTyparEnv -> @@ -8864,14 +33928,14 @@ namespace FSharp.Compiler (TypedTree.TyconRef * Tainted * (unit -> unit) * SyntaxTree.SynType list * Range.range) option val private - TcTyconDefnCore_Phase1C_EstablishDeclarationForGeneratedSetOfTypes: + TcTyconDefnCore_Phase1C_EstablishDeclarationForGeneratedSetOfTypes : cenv:cenv -> inSig:bool -> tycon:TypedTree.Tycon * rhsType:SyntaxTree.SynType * tcrefForContainer:TypedTree.TyconRef * theRootType:Tainted * checkTypeName:(unit -> unit) * args:'a list * m:Range.range -> unit - val private TcTyconDefnCore_Phase1C_Phase1E_EstablishAbbreviations: + val private TcTyconDefnCore_Phase1C_Phase1E_EstablishAbbreviations : cenv:cenv -> envinner:CheckExpressions.TcEnv -> inSig:bool -> @@ -8880,7 +33944,7 @@ namespace FSharp.Compiler MutRecDefnsPhase1DataForTycon -> tycon:TypedTree.Tycon -> attrs:TypedTree.Attribs -> unit val private - TcTyconDefnCore_Phase1D_Phase1F_EstablishSuperTypesAndInterfaceTypes: + TcTyconDefnCore_Phase1D_Phase1F_EstablishSuperTypesAndInterfaceTypes : cenv:CheckExpressions.TcFileState -> tpenv:CheckExpressions.UnscopedTyparEnv -> inSig:bool -> @@ -8892,7 +33956,7 @@ namespace FSharp.Compiler (TypedTree.Attribs * 'c)) option),'d, ('e * CheckExpressions.TcEnv)> list -> unit - val private TcTyconDefnCore_Phase1G_EstablishRepresentation: + val private TcTyconDefnCore_Phase1G_EstablishRepresentation : cenv:cenv -> envinner:CheckExpressions.TcEnv -> tpenv:CheckExpressions.UnscopedTyparEnv -> @@ -8901,11 +33965,11 @@ namespace FSharp.Compiler tycon:TypedTree.Tycon -> attrs:TypedTree.Attribs -> TypedTree.Val option * CheckExpressions.SafeInitData - val private TcTyconDefnCore_CheckForCyclicAbbreviations: + val private TcTyconDefnCore_CheckForCyclicAbbreviations : tycons:TypedTree.Entity list -> unit - val TcTyconDefnCore_CheckForCyclicStructsAndInheritance: + val TcTyconDefnCore_CheckForCyclicStructsAndInheritance : cenv:cenv -> tycons:TypedTree.Entity list -> unit - val TcMutRecDefns_CheckExplicitConstraints: + val TcMutRecDefns_CheckExplicitConstraints : cenv:CheckExpressions.TcFileState -> tpenv:CheckExpressions.UnscopedTyparEnv -> m:Range.range -> @@ -8915,7 +33979,7 @@ namespace FSharp.Compiler TypedTree.Tycon option),'c, ('d * CheckExpressions.TcEnv)> list -> unit - val TcMutRecDefns_Phase1: + val TcMutRecDefns_Phase1 : mkLetInfo:(CheckExpressions.ContainerInfo -> 'LetInfo -> 'a) -> cenv:cenv -> envInitial:CheckExpressions.TcEnv -> @@ -8939,9 +34003,9 @@ namespace FSharp.Compiler CheckExpressions.SafeInitData)),'a, (MutRecDefnsPhase2DataForModule * CheckExpressions.TcEnv)> list - - module TcDeclarations = - val private ComputeTyconDeclKind: + end + module TcDeclarations = begin + val private ComputeTyconDeclKind : cenv:cenv -> envForDecls:CheckExpressions.TcEnv -> tyconOpt:Lib.NonNullSlot option -> @@ -8953,23 +34017,23 @@ namespace FSharp.Compiler longPath:SyntaxTree.Ident list -> CheckExpressions.DeclKind * TypedTree.EntityRef * TypedTree.Typars - val private isAugmentationTyconDefnRepr: + val private isAugmentationTyconDefnRepr : _arg1:SyntaxTree.SynTypeDefnSimpleRepr -> bool - val private isAutoProperty: _arg1:SyntaxTree.SynMemberDefn -> bool - val private isMember: _arg1:SyntaxTree.SynMemberDefn -> bool - val private isImplicitCtor: _arg1:SyntaxTree.SynMemberDefn -> bool - val private isImplicitInherit: _arg1:SyntaxTree.SynMemberDefn -> bool - val private isAbstractSlot: _arg1:SyntaxTree.SynMemberDefn -> bool - val private isInterface: _arg1:SyntaxTree.SynMemberDefn -> bool - val private isInherit: _arg1:SyntaxTree.SynMemberDefn -> bool - val private isField: _arg1:SyntaxTree.SynMemberDefn -> bool - val private isTycon: _arg1:SyntaxTree.SynMemberDefn -> bool - val private allFalse: ps:('a -> bool) list -> x:'a -> bool - val private CheckMembersForm: ds:SyntaxTree.SynMemberDefn list -> unit - val private SplitTyconDefn: + val private isAutoProperty : _arg1:SyntaxTree.SynMemberDefn -> bool + val private isMember : _arg1:SyntaxTree.SynMemberDefn -> bool + val private isImplicitCtor : _arg1:SyntaxTree.SynMemberDefn -> bool + val private isImplicitInherit : _arg1:SyntaxTree.SynMemberDefn -> bool + val private isAbstractSlot : _arg1:SyntaxTree.SynMemberDefn -> bool + val private isInterface : _arg1:SyntaxTree.SynMemberDefn -> bool + val private isInherit : _arg1:SyntaxTree.SynMemberDefn -> bool + val private isField : _arg1:SyntaxTree.SynMemberDefn -> bool + val private isTycon : _arg1:SyntaxTree.SynMemberDefn -> bool + val private allFalse : ps:('a -> bool) list -> x:'a -> bool + val private CheckMembersForm : ds:SyntaxTree.SynMemberDefn list -> unit + val private SplitTyconDefn : SyntaxTree.SynTypeDefn -> MutRecDefnsPhase1DataForTycon * SyntaxTree.SynMemberDefn list - val TcMutRecDefinitions: + val TcMutRecDefinitions : cenv:cenv -> envInitial:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> @@ -8986,11 +34050,11 @@ namespace FSharp.Compiler (MutRecDefnsPhase2DataForModule * CheckExpressions.TcEnv)> list * CheckExpressions.TcEnv - val private SplitTyconSignature: + val private SplitTyconSignature : SyntaxTree.SynTypeDefnSig -> MutRecDefnsPhase1DataForTycon * (SyntaxTree.SynComponentInfo * SyntaxTree.SynMemberSig list) - val private TcMutRecSignatureDecls_Phase2: + val private TcMutRecSignatureDecls_Phase2 : cenv:cenv -> scopem:Range.range -> envMutRec:CheckExpressions.TcEnv -> @@ -9006,7 +34070,7 @@ namespace FSharp.Compiler MutRecShape<(TypedTree.Val list * CheckExpressions.UnscopedTyparEnv), CheckExpressions.TcEnv,('c * CheckExpressions.TcEnv)> list - val TcMutRecSignatureDecls: + val TcMutRecSignatureDecls : cenv:cenv -> envInitial:CheckExpressions.TcEnv -> parent:TypedTree.ParentRef -> @@ -9018,34 +34082,34 @@ namespace FSharp.Compiler TypedTree.ModuleOrNamespaceType ref) option -> mutRecSigs:MutRecSigsInitialData -> CheckExpressions.TcEnv - - val TcSignatureElementNonMutRec: + end + val TcSignatureElementNonMutRec : cenv:CheckExpressions.TcFileState -> parent:TypedTree.ParentRef -> typeNames:Set -> - m:Range.range -> + endm:Range.range -> env:CheckExpressions.TcEnv -> synSigDecl:SyntaxTree.SynModuleSigDecl -> AbstractIL.Internal.Library.Eventually - val TcSignatureElements: + val TcSignatureElements : cenv:CheckExpressions.TcFileState -> parent:TypedTree.ParentRef -> - m:Range.range -> + endm:Range.range -> env:CheckExpressions.TcEnv -> xml:XmlDoc.PreXmlDoc -> mutRecNSInfo:(TypedTree.ModuleOrNamespace option * TypedTree.ModuleOrNamespaceType ref) option -> defs:SyntaxTree.SynModuleSigDecl list -> AbstractIL.Internal.Library.Eventually - val TcSignatureElementsNonMutRec: + val TcSignatureElementsNonMutRec : cenv:CheckExpressions.TcFileState -> parent:TypedTree.ParentRef -> typeNames:Set -> - m:Range.range -> + endm:Range.range -> env:CheckExpressions.TcEnv -> defs:SyntaxTree.SynModuleSigDecl list -> AbstractIL.Internal.Library.Eventually - val TcSignatureElementsMutRec: + val TcSignatureElementsMutRec : cenv:CheckExpressions.TcFileState -> parent:TypedTree.ParentRef -> typeNames:Set -> @@ -9055,7 +34119,7 @@ namespace FSharp.Compiler envInitial:CheckExpressions.TcEnv -> defs:SyntaxTree.SynModuleSigDecl list -> AbstractIL.Internal.Library.Eventually - val TcModuleOrNamespaceSignatureElementsNonMutRec: + val TcModuleOrNamespaceSignatureElementsNonMutRec : cenv:CheckExpressions.TcFileState -> parent:TypedTree.ParentRef -> env:CheckExpressions.TcEnv -> @@ -9064,15 +34128,15 @@ namespace FSharp.Compiler xml:XmlDoc.PreXmlDoc -> AbstractIL.Internal.Library.Eventually - val ElimModuleDoBinding: + val ElimModuleDoBinding : bind:SyntaxTree.SynModuleDecl -> SyntaxTree.SynModuleDecl - val TcMutRecDefnsEscapeCheck: + val TcMutRecDefnsEscapeCheck : binds:MutRecShapes<(TypedTree.Tycon option * TypedTree.Binding list), TypedTree.Binding list,'a> -> env:CheckExpressions.TcEnv -> unit - val CheckLetOrDoInNamespace: + val CheckLetOrDoInNamespace : binds:SyntaxTree.SynBinding list -> m:Range.range -> unit - val TcModuleOrNamespaceElementNonMutRec: + val TcModuleOrNamespaceElementNonMutRec : cenv:cenv -> parent:TypedTree.ParentRef -> typeNames:Set -> @@ -9085,11 +34149,11 @@ namespace FSharp.Compiler TypedTree.Attrib) list) * CheckExpressions.TcEnv * CheckExpressions.TcEnv> - val TcModuleOrNamespaceElementsNonMutRec: + val TcModuleOrNamespaceElementsNonMutRec : cenv:cenv -> parent:TypedTree.ParentRef -> typeNames:Set -> - m:Range.range -> + endm:Range.range -> defsSoFar:((TypedTree.ModuleOrNamespaceExpr list -> TypedTree.ModuleOrNamespaceExpr list) * (System.AttributeTargets * TypedTree.Attrib) list) list * @@ -9100,7 +34164,7 @@ namespace FSharp.Compiler (System.AttributeTargets * TypedTree.Attrib) list) list * CheckExpressions.TcEnv> - val TcModuleOrNamespaceElementsMutRec: + val TcModuleOrNamespaceElementsMutRec : cenv:cenv -> parent:TypedTree.ParentRef -> typeNames:Set -> @@ -9115,17 +34179,17 @@ namespace FSharp.Compiler TypedTree.Attrib) list) * CheckExpressions.TcEnv * CheckExpressions.TcEnv> - val TcMutRecDefsFinish: + val TcMutRecDefsFinish : cenv:cenv -> defs:MutRecShape<(TypedTree.Tycon option * TypedTree.Binding list), TypedTree.Binding list, (MutRecDefnsPhase2DataForModule * CheckExpressions.TcEnv)> list -> m:Range.range -> TypedTree.ModuleOrNamespaceExpr - val TcModuleOrNamespaceElements: + val TcModuleOrNamespaceElements : cenv:cenv -> parent:TypedTree.ParentRef -> - m:Range.range -> + endm:Range.range -> env:CheckExpressions.TcEnv -> xml:XmlDoc.PreXmlDoc -> mutRecNSInfo:(TypedTree.ModuleOrNamespace option * @@ -9135,20 +34199,20 @@ namespace FSharp.Compiler (System.AttributeTargets * TypedTree.Attrib) list * CheckExpressions.TcEnv> - val ApplyAssemblyLevelAutoOpenAttributeToTcEnv: + val ApplyAssemblyLevelAutoOpenAttributeToTcEnv : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> ccu:TypedTree.CcuThunk -> scopem:Range.range -> env:CheckExpressions.TcEnv -> p:System.String * root:bool -> CheckExpressions.TcEnv - val AddCcuToTcEnv: + val AddCcuToTcEnv : TcGlobals.TcGlobals * Import.ImportMap * Range.range * CheckExpressions.TcEnv * assemblyName:string * ccu:TypedTree.CcuThunk * autoOpens:string list * internalsVisibleToAttributes:string list -> CheckExpressions.TcEnv - val emptyTcEnv: g:TcGlobals.TcGlobals -> CheckExpressions.TcEnv - val CreateInitialTcEnv: + val emptyTcEnv : g:TcGlobals.TcGlobals -> CheckExpressions.TcEnv + val CreateInitialTcEnv : TcGlobals.TcGlobals * Import.ImportMap * Range.range * assemblyName:string * (TypedTree.CcuThunk * string list * string list) list -> CheckExpressions.TcEnv @@ -9157,30 +34221,30 @@ namespace FSharp.Compiler { mainMethodAttrs: TypedTree.Attribs netModuleAttrs: TypedTree.Attribs assemblyAttrs: TypedTree.Attribs } - val EmptyTopAttrs: TopAttribs - val CombineTopAttrs: TopAttribs -> TopAttribs -> TopAttribs - val IterTyconsOfModuleOrNamespaceType: + val EmptyTopAttrs : TopAttribs + val CombineTopAttrs : TopAttribs -> TopAttribs -> TopAttribs + val IterTyconsOfModuleOrNamespaceType : f:(TypedTree.Entity -> unit) -> mty:TypedTree.ModuleOrNamespaceType -> unit - val ApplyDefaults: + val ApplyDefaults : cenv:cenv -> g:TcGlobals.TcGlobals -> denvAtEnd:TypedTreeOps.DisplayEnv -> m:Range.range -> mexpr:TypedTree.ModuleOrNamespaceExpr -> extraAttribs:TypedTree.Attrib list -> unit - val CheckValueRestriction: + val CheckValueRestriction : denvAtEnd:TypedTreeOps.DisplayEnv -> rootSigOpt:'a option -> implFileTypePriorToSig:TypedTree.ModuleOrNamespaceType -> m:Range.range -> unit - val SolveInternalUnknowns: + val SolveInternalUnknowns : g:TcGlobals.TcGlobals -> cenv:cenv -> denvAtEnd:TypedTreeOps.DisplayEnv -> mexpr:TypedTree.ModuleOrNamespaceExpr -> extraAttribs:TypedTree.Attrib list -> unit - val CheckModuleSignature: + val CheckModuleSignature : g:TcGlobals.TcGlobals -> cenv:cenv -> m:Range.range -> @@ -9190,10 +34254,10 @@ namespace FSharp.Compiler implFileSpecPriorToSig:Lib.NonNullSlot -> mexpr:TypedTree.ModuleOrNamespaceExpr -> TypedTree.ModuleOrNamespaceExprWithSig - val MakeInitialEnv: + val MakeInitialEnv : env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv * TypedTree.ModuleOrNamespaceType ref - val TypeCheckOneImplFile: + val TypeCheckOneImplFile : TcGlobals.TcGlobals * CompilerGlobalState.NiceNameGenerator * Import.ImportMap * TypedTree.CcuThunk * (unit -> bool) * string list option * NameResolution.TcResultsSink * bool -> @@ -9205,7 +34269,7 @@ namespace FSharp.Compiler TypedTree.ModuleOrNamespaceType * CheckExpressions.TcEnv * bool> - val TypeCheckOneSigFile: + val TypeCheckOneSigFile : TcGlobals.TcGlobals * CompilerGlobalState.NiceNameGenerator * Import.ImportMap * TypedTree.CcuThunk * (unit -> bool) * string list option * NameResolution.TcResultsSink * bool -> @@ -9214,25 +34278,25 @@ namespace FSharp.Compiler AbstractIL.Internal.Library.Eventually - + end namespace FSharp.Compiler - module internal Optimizer = - val verboseOptimizationInfo: bool - val verboseOptimizations: bool - val i_ldlen: AbstractIL.IL.ILInstr list - [] - val callSize: int = 1 - [] - val forAndWhileLoopSize: int = 5 - [] - val tryWithSize: int = 5 - [] - val tryFinallySize: int = 5 - [] - val closureTotalSize: int = 10 - [] - val methodDefnTotalSize: int = 1 + module internal Optimizer = begin + val verboseOptimizationInfo : bool + val verboseOptimizations : bool + val i_ldlen : AbstractIL.IL.ILInstr list + [] + val callSize : int = 1 + [] + val forAndWhileLoopSize : int = 5 + [] + val tryWithSize : int = 5 + [] + val tryFinallySize : int = 5 + [] + val closureTotalSize : int = 10 + [] + val methodDefnTotalSize : int = 1 type TypeValueInfo = | UnknownTypeValue type ExprValueInfo = | UnknownValue @@ -9250,19 +34314,19 @@ namespace FSharp.Compiler { ValMakesNoCriticalTailcalls: bool ValExprInfo: ExprValueInfo } type ValInfos = - - new: entries:seq -> ValInfos - member Filter: f:(TypedTree.ValRef * ValInfo -> bool) -> ValInfos + class + new : entries:seq -> ValInfos + member Filter : f:(TypedTree.ValRef * ValInfo -> bool) -> ValInfos member - Map: f:(TypedTree.ValRef * ValInfo -> TypedTree.ValRef * ValInfo) -> + Map : f:(TypedTree.ValRef * ValInfo -> TypedTree.ValRef * ValInfo) -> ValInfos member - TryFind: v:TypedTree.ValRef -> (TypedTree.ValRef * ValInfo) option + TryFind : v:TypedTree.ValRef -> (TypedTree.ValRef * ValInfo) option member - TryFindForFslib: g:TcGlobals.TcGlobals * vref:TypedTree.ValRef -> + TryFindForFslib : g:TcGlobals.TcGlobals * vref:TypedTree.ValRef -> bool * (TypedTree.ValRef * ValInfo) - member Entries: seq - + member Entries : seq + end type ModuleInfo = { ValInfos: ValInfos ModuleOrNamespaceInfos: @@ -9270,26 +34334,26 @@ namespace FSharp.Compiler and LazyModuleInfo = Lazy type ImplFileOptimizationInfo = LazyModuleInfo type CcuOptimizationInfo = LazyModuleInfo - val braceL: + val braceL : x:Internal.Utilities.StructuredFormat.Layout -> Internal.Utilities.StructuredFormat.Layout - val seqL: + val seqL : xL:('a -> Internal.Utilities.StructuredFormat.Layout) -> xs:seq<'a> -> Internal.Utilities.StructuredFormat.Layout - val namemapL: + val namemapL : xL:(string -> 'a -> Internal.Utilities.StructuredFormat.Layout) -> xmap:AbstractIL.Internal.Library.NameMap<'a> -> Internal.Utilities.StructuredFormat.Layout - val exprValueInfoL: + val exprValueInfoL : g:TcGlobals.TcGlobals -> exprVal:ExprValueInfo -> Internal.Utilities.StructuredFormat.Layout - val exprValueInfosL: + val exprValueInfosL : g:TcGlobals.TcGlobals -> vinfos:ExprValueInfo [] -> Internal.Utilities.StructuredFormat.Layout - val moduleInfoL: + val moduleInfoL : TcGlobals.TcGlobals -> LazyModuleInfo -> Internal.Utilities.StructuredFormat.Layout - val valInfoL: + val valInfoL : g:TcGlobals.TcGlobals -> x:ValInfo -> Internal.Utilities.StructuredFormat.Layout type Summary<'Info> = @@ -9298,20 +34362,20 @@ namespace FSharp.Compiler TotalSize: int HasEffect: bool MightMakeCriticalTailcall: bool } - val SizeOfValueInfos: arr:ExprValueInfo [] -> int - val SizeOfValueInfo: x:ExprValueInfo -> int - [] - val minDepthForASizeNode: int = 5 - val MakeValueInfoWithCachedSize: + val SizeOfValueInfos : arr:ExprValueInfo [] -> int + val SizeOfValueInfo : x:ExprValueInfo -> int + [] + val minDepthForASizeNode : int = 5 + val MakeValueInfoWithCachedSize : vdepth:int -> v:ExprValueInfo -> ExprValueInfo - val MakeSizedValueInfo: v:ExprValueInfo -> ExprValueInfo - val BoundValueInfoBySize: vinfo:ExprValueInfo -> ExprValueInfo - [] - val jitOptDefault: bool = true - [] - val localOptDefault: bool = true - [] - val crossModuleOptDefault: bool = true + val MakeSizedValueInfo : v:ExprValueInfo -> ExprValueInfo + val BoundValueInfoBySize : vinfo:ExprValueInfo -> ExprValueInfo + [] + val jitOptDefault : bool = true + [] + val localOptDefault : bool = true + [] + val crossModuleOptDefault : bool = true type OptimizationSettings = { abstractBigTargets: bool jitOptUser: bool option @@ -9326,22 +34390,22 @@ namespace FSharp.Compiler reportHasEffect: bool reportTotalSizes: bool } with - member EliminateImmediatelyConsumedLocals: unit -> bool - member EliminateRecdFieldGet: unit -> bool - member EliminateSequential: unit -> bool - member EliminateSwitch: unit -> bool - member EliminateTryWithAndTryFinally: unit -> bool - member EliminateTupleFieldGet: unit -> bool - member EliminateUnionCaseFieldGet: unit -> bool - member EliminateUnusedBindings: unit -> bool - member ExpandStructuralValues: unit -> bool - member InlineLambdas: unit -> bool - member KeepOptimizationValues: unit -> bool - member crossModuleOpt: unit -> bool - member jitOpt: unit -> bool - member localOpt: unit -> bool - static member Defaults: OptimizationSettings - + member EliminateImmediatelyConsumedLocals : unit -> bool + member EliminateRecdFieldGet : unit -> bool + member EliminateSequential : unit -> bool + member EliminateSwitch : unit -> bool + member EliminateTryWithAndTryFinally : unit -> bool + member EliminateTupleFieldGet : unit -> bool + member EliminateUnionCaseFieldGet : unit -> bool + member EliminateUnusedBindings : unit -> bool + member ExpandStructuralValues : unit -> bool + member InlineLambdas : unit -> bool + member KeepOptimizationValues : unit -> bool + member crossModuleOpt : unit -> bool + member jitOpt : unit -> bool + member localOpt : unit -> bool + static member Defaults : OptimizationSettings + end type cenv = { g: TcGlobals.TcGlobals TcVal: ConstraintSolver.TcValF @@ -9354,9 +34418,9 @@ namespace FSharp.Compiler emitTailcalls: bool casApplied: System.Collections.Generic.Dictionary } with - override ToString: unit -> string - - [] + override ToString : unit -> string + end + [] type IncrementalOptimizationEnv = { latestBoundId: SyntaxTree.Ident option dontInline: AbstractIL.Internal.Zset @@ -9369,27 +34433,27 @@ namespace FSharp.Compiler globalModuleInfos: AbstractIL.Internal.Library.LayeredMap } with - override ToString: unit -> string - static member Empty: IncrementalOptimizationEnv - - val IsPartialExprVal: x:ExprValueInfo -> bool - val CheckInlineValueIsComplete: + override ToString : unit -> string + static member Empty : IncrementalOptimizationEnv + end + val IsPartialExprVal : x:ExprValueInfo -> bool + val CheckInlineValueIsComplete : v:TypedTree.Val -> res:ExprValueInfo -> unit - val check: + val check : vref:TypedTree.ValRef -> res:ValInfo -> TypedTree.ValRef * ValInfo - val EmptyModuleInfo: System.Lazy - val UnionOptimizationInfos: seq -> System.Lazy - val FindOrCreateModuleInfo: + val EmptyModuleInfo : System.Lazy + val UnionOptimizationInfos : seq -> System.Lazy + val FindOrCreateModuleInfo : n:'a -> ss:Map<'a,System.Lazy> -> System.Lazy - when 'a: comparison - val FindOrCreateGlobalModuleInfo: + when 'a : comparison + val FindOrCreateGlobalModuleInfo : n:'a -> ss:AbstractIL.Internal.Library.LayeredMap<'a,System.Lazy> -> - System.Lazy when 'a: comparison - val BindValueInSubModuleFSharpCore: + System.Lazy when 'a : comparison + val BindValueInSubModuleFSharpCore : mp:string [] -> i:int -> v:TypedTree.Val -> vval:ValInfo -> ss:ModuleInfo -> ModuleInfo - val BindValueInModuleForFslib: + val BindValueInModuleForFslib : n:string -> mp:string [] -> i:int -> @@ -9397,7 +34461,7 @@ namespace FSharp.Compiler vval:ValInfo -> ss:AbstractIL.Internal.Library.NameMap -> AbstractIL.Internal.Library.NameMap - val BindValueInGlobalModuleForFslib: + val BindValueInGlobalModuleForFslib : n:'a -> mp:string [] -> i:int -> @@ -9405,91 +34469,91 @@ namespace FSharp.Compiler vval:ValInfo -> ss:AbstractIL.Internal.Library.LayeredMap<'a, System.Lazy> -> - Map<'a,System.Lazy> when 'a: comparison - val BindValueForFslib: + Map<'a,System.Lazy> when 'a : comparison + val BindValueForFslib : nlvref:TypedTree.NonLocalValOrMemberRef -> v:TypedTree.Val -> vval:ValInfo -> env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv - val UnknownValInfo: ValInfo - val mkValInfo: info:Summary -> v:TypedTree.Val -> ValInfo - val BindInternalLocalVal: + val UnknownValInfo : ValInfo + val mkValInfo : info:Summary -> v:TypedTree.Val -> ValInfo + val BindInternalLocalVal : cenv:cenv -> v:TypedTree.Val -> vval:ValInfo -> env:'a -> 'a - val BindExternalLocalVal: + val BindExternalLocalVal : cenv:cenv -> v:TypedTree.Val -> vval:ValInfo -> env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv - val BindValsInModuleOrNamespace: + val BindValsInModuleOrNamespace : cenv:cenv -> mval:LazyModuleInfo -> env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv - val inline BindInternalValToUnknown: cenv:'a -> v:'b -> env:'c -> 'c - val inline BindInternalValsToUnknown: cenv:'a -> vs:'b -> env:'c -> 'c - val BindTypeVar: + val inline BindInternalValToUnknown : cenv:'a -> v:'b -> env:'c -> 'c + val inline BindInternalValsToUnknown : cenv:'a -> vs:'b -> env:'c -> 'c + val BindTypeVar : tyv:TypedTree.Typar -> typeinfo:TypeValueInfo -> env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv - val BindTypeVarsToUnknown: + val BindTypeVarsToUnknown : tps:TypedTree.Typar list -> env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv - val BindCcu: + val BindCcu : TypedTree.CcuThunk -> LazyModuleInfo -> IncrementalOptimizationEnv -> TcGlobals.TcGlobals -> IncrementalOptimizationEnv - val GetInfoForLocalValue: + val GetInfoForLocalValue : cenv:cenv -> env:IncrementalOptimizationEnv -> v:TypedTree.Val -> m:Range.range -> ValInfo - val TryGetInfoForCcu: + val TryGetInfoForCcu : env:IncrementalOptimizationEnv -> ccu:TypedTree.CcuThunk -> LazyModuleInfo option - val TryGetInfoForEntity: sv:ModuleInfo -> n:string -> ModuleInfo option - val TryGetInfoForPath: + val TryGetInfoForEntity : sv:ModuleInfo -> n:string -> ModuleInfo option + val TryGetInfoForPath : sv:ModuleInfo -> p:string [] -> i:int -> ModuleInfo option - val TryGetInfoForNonLocalEntityRef: + val TryGetInfoForNonLocalEntityRef : env:IncrementalOptimizationEnv -> nleref:TypedTree.NonLocalEntityRef -> ModuleInfo option - val GetInfoForNonLocalVal: + val GetInfoForNonLocalVal : cenv:cenv -> env:IncrementalOptimizationEnv -> vref:TypedTree.ValRef -> ValInfo - val GetInfoForVal: + val GetInfoForVal : cenv:cenv -> env:IncrementalOptimizationEnv -> m:Range.range -> vref:TypedTree.ValRef -> ValInfo - val stripValue: _arg1:ExprValueInfo -> ExprValueInfo - val ( |StripConstValue|_| ): ev:ExprValueInfo -> TypedTree.Const option - val ( |StripLambdaValue|_| ): + val stripValue : _arg1:ExprValueInfo -> ExprValueInfo + val ( |StripConstValue|_| ) : ev:ExprValueInfo -> TypedTree.Const option + val ( |StripLambdaValue|_| ) : ev:ExprValueInfo -> (CompilerGlobalState.Unique * int * int * TypedTree.Expr * TypedTree.TType) option - val destTupleValue: ev:ExprValueInfo -> ExprValueInfo [] option - val destRecdValue: ev:ExprValueInfo -> ExprValueInfo [] option - val ( |StripUnionCaseValue|_| ): + val destTupleValue : ev:ExprValueInfo -> ExprValueInfo [] option + val destRecdValue : ev:ExprValueInfo -> ExprValueInfo [] option + val ( |StripUnionCaseValue|_| ) : ev:ExprValueInfo -> (TypedTree.UnionCaseRef * ExprValueInfo []) option - val mkBoolVal: g:TcGlobals.TcGlobals -> n:bool -> ExprValueInfo - val mkInt8Val: g:TcGlobals.TcGlobals -> n:sbyte -> ExprValueInfo - val mkInt16Val: g:TcGlobals.TcGlobals -> n:int16 -> ExprValueInfo - val mkInt32Val: g:TcGlobals.TcGlobals -> n:int32 -> ExprValueInfo - val mkInt64Val: g:TcGlobals.TcGlobals -> n:int64 -> ExprValueInfo - val mkUInt8Val: g:TcGlobals.TcGlobals -> n:byte -> ExprValueInfo - val mkUInt16Val: g:TcGlobals.TcGlobals -> n:uint16 -> ExprValueInfo - val mkUInt32Val: g:TcGlobals.TcGlobals -> n:uint32 -> ExprValueInfo - val mkUInt64Val: g:TcGlobals.TcGlobals -> n:uint64 -> ExprValueInfo - val ( |StripInt32Value|_| ): _arg1:ExprValueInfo -> int32 option - val MakeValueInfoForValue: + val mkBoolVal : g:TcGlobals.TcGlobals -> n:bool -> ExprValueInfo + val mkInt8Val : g:TcGlobals.TcGlobals -> n:sbyte -> ExprValueInfo + val mkInt16Val : g:TcGlobals.TcGlobals -> n:int16 -> ExprValueInfo + val mkInt32Val : g:TcGlobals.TcGlobals -> n:int32 -> ExprValueInfo + val mkInt64Val : g:TcGlobals.TcGlobals -> n:int64 -> ExprValueInfo + val mkUInt8Val : g:TcGlobals.TcGlobals -> n:byte -> ExprValueInfo + val mkUInt16Val : g:TcGlobals.TcGlobals -> n:uint16 -> ExprValueInfo + val mkUInt32Val : g:TcGlobals.TcGlobals -> n:uint32 -> ExprValueInfo + val mkUInt64Val : g:TcGlobals.TcGlobals -> n:uint64 -> ExprValueInfo + val ( |StripInt32Value|_| ) : _arg1:ExprValueInfo -> int32 option + val MakeValueInfoForValue : g:TcGlobals.TcGlobals -> m:Range.range -> vref:TypedTree.ValRef -> vinfo:ExprValueInfo -> ExprValueInfo - val MakeValueInfoForRecord: + val MakeValueInfoForRecord : tcref:TypedTree.TyconRef -> argvals:ExprValueInfo [] -> ExprValueInfo - val MakeValueInfoForTuple: argvals:ExprValueInfo [] -> ExprValueInfo - val MakeValueInfoForUnionCase: + val MakeValueInfoForTuple : argvals:ExprValueInfo [] -> ExprValueInfo + val MakeValueInfoForUnionCase : cspec:TypedTree.UnionCaseRef -> argvals:ExprValueInfo [] -> ExprValueInfo - val MakeValueInfoForConst: + val MakeValueInfoForConst : c:TypedTree.Const -> ty:TypedTree.TType -> ExprValueInfo - val inline IntegerUnaryOp: + val inline IntegerUnaryOp : g:TcGlobals.TcGlobals -> f8:(sbyte -> sbyte) -> f16:(int16 -> int16) -> @@ -9500,13 +34564,13 @@ namespace FSharp.Compiler fu32:(uint32 -> uint32) -> fu64:(uint64 -> uint64) -> a:ExprValueInfo -> ExprValueInfo option - val inline SignedIntegerUnaryOp: + val inline SignedIntegerUnaryOp : g:TcGlobals.TcGlobals -> f8:(sbyte -> sbyte) -> f16:(int16 -> int16) -> f32:(int32 -> int32) -> f64:(int64 -> int64) -> a:ExprValueInfo -> ExprValueInfo option - val inline IntegerBinaryOp: + val inline IntegerBinaryOp : g:TcGlobals.TcGlobals -> f8:(sbyte -> sbyte -> sbyte) -> f16:(int16 -> int16 -> int16) -> @@ -9518,275 +34582,275 @@ namespace FSharp.Compiler fu64:(uint64 -> uint64 -> uint64) -> a:ExprValueInfo -> b:ExprValueInfo -> ExprValueInfo option - val mkAssemblyCodeValueInfo: + val mkAssemblyCodeValueInfo : g:TcGlobals.TcGlobals -> instrs:AbstractIL.IL.ILInstr list -> argvals:ExprValueInfo list -> tys:TypedTree.TType list -> ExprValueInfo - [] - val localVarSize: int = 1 - val AddTotalSizes: l:Summary<'a> list -> int - val AddFunctionSizes: l:Summary<'a> list -> int - val OrEffects: l:Summary<'a> list -> bool - val OrTailcalls: l:Summary<'a> list -> bool - val OptimizeList: f:('a -> 'b * 'c) -> l:'a list -> 'b list * 'c list - val NoExprs: TypedTree.Expr list * Summary list - val CombineValueInfos: einfos:Summary<'a> list -> res:'b -> Summary<'b> - val CombineValueInfosUnknown: + [] + val localVarSize : int = 1 + val AddTotalSizes : l:Summary<'a> list -> int + val AddFunctionSizes : l:Summary<'a> list -> int + val OrEffects : l:Summary<'a> list -> bool + val OrTailcalls : l:Summary<'a> list -> bool + val OptimizeList : f:('a -> 'b * 'c) -> l:'a list -> 'b list * 'c list + val NoExprs : TypedTree.Expr list * Summary list + val CombineValueInfos : einfos:Summary<'a> list -> res:'b -> Summary<'b> + val CombineValueInfosUnknown : einfos:Summary<'a> list -> Summary - val AbstractLazyModulInfoByHiding: + val AbstractLazyModulInfoByHiding : isAssemblyBoundary:bool -> mhi:TypedTreeOps.SignatureHidingInfo -> (LazyModuleInfo -> LazyModuleInfo) - val AbstractOptimizationInfoToEssentials: + val AbstractOptimizationInfoToEssentials : (System.Lazy -> System.Lazy) - val AbstractExprInfoByVars: + val AbstractExprInfoByVars : boundVars:TypedTree.Val list * boundTyVars:TypedTree.Typar list -> ivalue:ExprValueInfo -> ExprValueInfo - val RemapOptimizationInfo: + val RemapOptimizationInfo : TcGlobals.TcGlobals -> TypedTreeOps.Remap -> (LazyModuleInfo -> LazyModuleInfo) - val AbstractAndRemapModulInfo: + val AbstractAndRemapModulInfo : msg:string -> g:TcGlobals.TcGlobals -> m:Range.range -> repackage:TypedTreeOps.SignatureRepackageInfo * hidden:TypedTreeOps.SignatureHidingInfo -> info:LazyModuleInfo -> LazyModuleInfo - [] - val suffixForVariablesThatMayNotBeEliminated: string = "$cont" - val IsTyFuncValRefExpr: _arg1:TypedTree.Expr -> bool - val IsSmallConstExpr: x:TypedTree.Expr -> bool - val ValueOfExpr: expr:TypedTree.Expr -> ExprValueInfo - val IsDiscardableEffectExpr: expr:TypedTree.Expr -> bool - val ValueIsUsedOrHasEffect: + [] + val suffixForVariablesThatMayNotBeEliminated : string = "$cont" + val IsTyFuncValRefExpr : _arg1:TypedTree.Expr -> bool + val IsSmallConstExpr : x:TypedTree.Expr -> bool + val ValueOfExpr : expr:TypedTree.Expr -> ExprValueInfo + val IsDiscardableEffectExpr : expr:TypedTree.Expr -> bool + val ValueIsUsedOrHasEffect : cenv:cenv -> fvs:(unit -> AbstractIL.Internal.Zset) -> b:TypedTree.Binding * binfo:Summary<'a> -> bool - val SplitValuesByIsUsedOrHasEffect: + val SplitValuesByIsUsedOrHasEffect : cenv:cenv -> fvs:(unit -> AbstractIL.Internal.Zset) -> x:(TypedTree.Binding * Summary<'a>) list -> TypedTree.Binding list * Summary<'a> list - val IlAssemblyCodeInstrHasEffect: i:AbstractIL.IL.ILInstr -> bool - val IlAssemblyCodeHasEffect: instrs:AbstractIL.IL.ILInstr list -> bool - val ExprHasEffect: TcGlobals.TcGlobals -> TypedTree.Expr -> bool - val ExprsHaveEffect: g:TcGlobals.TcGlobals -> exprs:TypedTree.Exprs -> bool - val BindingsHaveEffect: + val IlAssemblyCodeInstrHasEffect : i:AbstractIL.IL.ILInstr -> bool + val IlAssemblyCodeHasEffect : instrs:AbstractIL.IL.ILInstr list -> bool + val ExprHasEffect : TcGlobals.TcGlobals -> TypedTree.Expr -> bool + val ExprsHaveEffect : g:TcGlobals.TcGlobals -> exprs:TypedTree.Exprs -> bool + val BindingsHaveEffect : g:TcGlobals.TcGlobals -> binds:TypedTree.Bindings -> bool - val BindingHasEffect: + val BindingHasEffect : g:TcGlobals.TcGlobals -> bind:TypedTree.Binding -> bool - val OpHasEffect: + val OpHasEffect : g:TcGlobals.TcGlobals -> m:Range.range -> op:TypedTree.TOp -> bool - val TryEliminateBinding: + val TryEliminateBinding : cenv:cenv -> _env:'a -> TypedTree.Binding -> e2:TypedTree.Expr -> _m:'b -> TypedTree.Expr option - val TryEliminateLet: + val TryEliminateLet : cenv:cenv -> env:'a -> bind:TypedTree.Binding -> e2:TypedTree.Expr -> m:Range.range -> TypedTree.Expr * int - val ( |KnownValApp|_| ): + val ( |KnownValApp|_| ) : expr:TypedTree.Expr -> (TypedTree.ValRef * TypedTree.TType list * TypedTree.Expr list) option - val ( |TDBoolSwitch|_| ): + val ( |TDBoolSwitch|_| ) : dtree:TypedTree.DecisionTree -> (TypedTree.Expr * bool * TypedTree.DecisionTree * TypedTree.DecisionTree * Range.range) option - val ( |ConstantBoolTarget|_| ): + val ( |ConstantBoolTarget|_| ) : target:TypedTree.DecisionTreeTarget -> bool option - val CountBoolLogicTree: + val CountBoolLogicTree : TypedTree.DecisionTreeTarget [] * int * int * bool -> tree:TypedTree.DecisionTree -> int * int - val RewriteBoolLogicTree: + val RewriteBoolLogicTree : TypedTree.DecisionTreeTarget [] * TypedTree.DecisionTree * TypedTree.DecisionTree * bool -> tree:TypedTree.DecisionTree -> TypedTree.DecisionTree - val RewriteBoolLogicCase: + val RewriteBoolLogicCase : TypedTree.DecisionTreeTarget [] * TypedTree.DecisionTree * TypedTree.DecisionTree * bool -> TypedTree.DecisionTreeCase -> TypedTree.DecisionTreeCase - val CombineBoolLogic: expr:TypedTree.Expr -> TypedTree.Expr - val CanExpandStructuralBinding: v:TypedTree.Val -> bool - val ExprIsValue: _arg1:TypedTree.Expr -> bool - val MakeStructuralBindingTemp: + val CombineBoolLogic : expr:TypedTree.Expr -> TypedTree.Expr + val CanExpandStructuralBinding : v:TypedTree.Val -> bool + val ExprIsValue : _arg1:TypedTree.Expr -> bool + val MakeStructuralBindingTemp : v:TypedTree.Val -> i:'a -> arg:TypedTree.Expr -> argTy:TypedTree.TType -> TypedTree.Expr * TypedTree.Binding - val ExpandStructuralBindingRaw: + val ExpandStructuralBindingRaw : cenv:cenv -> expr:TypedTree.Expr -> TypedTree.Expr - val RearrangeTupleBindings: + val RearrangeTupleBindings : expr:TypedTree.Expr -> fin:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr option - val ExpandStructuralBinding: + val ExpandStructuralBinding : cenv:cenv -> expr:TypedTree.Expr -> TypedTree.Expr - val ( |QueryRun|_| ): + val ( |QueryRun|_| ) : g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.TType option) option - val ( |MaybeRefTupled| ): e:TypedTree.Expr -> TypedTree.Exprs - val ( |AnyInstanceMethodApp|_| ): + val ( |MaybeRefTupled| ) : e:TypedTree.Expr -> TypedTree.Exprs + val ( |AnyInstanceMethodApp|_| ) : e:TypedTree.Expr -> (TypedTree.ValRef * TypedTree.TypeInst * TypedTree.Expr * TypedTree.Exprs) option - val ( |InstanceMethodApp|_| ): + val ( |InstanceMethodApp|_| ) : g:TcGlobals.TcGlobals -> expectedValRef:TypedTree.ValRef -> e:TypedTree.Expr -> (TypedTree.TypeInst * TypedTree.Expr * TypedTree.Exprs) option - val ( |QuerySourceEnumerable|_| ): + val ( |QuerySourceEnumerable|_| ) : g:TcGlobals.TcGlobals -> _arg1:TypedTree.Expr -> (TypedTree.TType * TypedTree.Expr) option - val ( |QueryFor|_| ): + val ( |QueryFor|_| ) : g:TcGlobals.TcGlobals -> _arg1:TypedTree.Expr -> (TypedTree.TType * TypedTree.TType * TypedTree.TType * TypedTree.Expr * TypedTree.Expr) option - val ( |QueryYield|_| ): + val ( |QueryYield|_| ) : g:TcGlobals.TcGlobals -> _arg1:TypedTree.Expr -> (TypedTree.TType * TypedTree.TType * TypedTree.Expr) option - val ( |QueryYieldFrom|_| ): + val ( |QueryYieldFrom|_| ) : g:TcGlobals.TcGlobals -> _arg1:TypedTree.Expr -> (TypedTree.TType * TypedTree.TType * TypedTree.Expr) option - val ( |QuerySelect|_| ): + val ( |QuerySelect|_| ) : g:TcGlobals.TcGlobals -> _arg1:TypedTree.Expr -> (TypedTree.TType * TypedTree.TType * TypedTree.TType * TypedTree.Expr * TypedTree.Expr) option - val ( |QueryZero|_| ): + val ( |QueryZero|_| ) : g:TcGlobals.TcGlobals -> _arg1:TypedTree.Expr -> (TypedTree.TType * TypedTree.TType) option - val ( |AnyRefTupleTrans| ): + val ( |AnyRefTupleTrans| ) : e:TypedTree.Expr -> TypedTree.Exprs * (TypedTree.Exprs -> TypedTree.Expr) - val ( |AnyQueryBuilderOpTrans|_| ): + val ( |AnyQueryBuilderOpTrans|_| ) : g:TcGlobals.TcGlobals -> _arg1:TypedTree.Expr -> (TypedTree.Expr * (TypedTree.Expr -> TypedTree.Expr)) option - val tryRewriteToSeqCombinators: + val tryRewriteToSeqCombinators : g:TcGlobals.TcGlobals -> e:TypedTree.Expr -> TypedTree.Expr option - val TryDetectQueryQuoteAndRun: + val TryDetectQueryQuoteAndRun : cenv:cenv -> expr:TypedTree.Expr -> TypedTree.Expr option - val IsILMethodRefSystemStringConcat: mref:AbstractIL.IL.ILMethodRef -> bool - val IsILMethodRefSystemStringConcatArray: + val IsILMethodRefSystemStringConcat : mref:AbstractIL.IL.ILMethodRef -> bool + val IsILMethodRefSystemStringConcatArray : mref:AbstractIL.IL.ILMethodRef -> bool - val OptimizeExpr: + val OptimizeExpr : cenv:cenv -> env:IncrementalOptimizationEnv -> expr:TypedTree.Expr -> TypedTree.Expr * Summary - val OptimizeObjectExpr: + val OptimizeObjectExpr : cenv:cenv -> env:IncrementalOptimizationEnv -> ty:TypedTree.TType * baseValOpt:TypedTree.Val option * basecall:TypedTree.Expr * overrides:TypedTree.ObjExprMethod list * iimpls:(TypedTree.TType * TypedTree.ObjExprMethod list) list * m:Range.range -> TypedTree.Expr * Summary - val OptimizeMethods: + val OptimizeMethods : cenv:cenv -> env:IncrementalOptimizationEnv -> baseValOpt:TypedTree.Val option -> methods:TypedTree.ObjExprMethod list -> TypedTree.ObjExprMethod list * Summary list - val OptimizeMethod: + val OptimizeMethod : cenv:cenv -> env:IncrementalOptimizationEnv -> baseValOpt:TypedTree.Val option -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod * Summary - val OptimizeInterfaceImpls: + val OptimizeInterfaceImpls : cenv:cenv -> env:IncrementalOptimizationEnv -> baseValOpt:TypedTree.Val option -> iimpls:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> (TypedTree.TType * TypedTree.ObjExprMethod list) list * Summary list - val OptimizeInterfaceImpl: + val OptimizeInterfaceImpl : cenv:cenv -> env:IncrementalOptimizationEnv -> baseValOpt:TypedTree.Val option -> ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> (TypedTree.TType * TypedTree.ObjExprMethod list) * Summary - val MakeOptimizedSystemStringConcatCall: + val MakeOptimizedSystemStringConcatCall : cenv:cenv -> env:IncrementalOptimizationEnv -> m:Range.range -> args:TypedTree.Exprs -> TypedTree.Expr * Summary - val OptimizeExprOp: + val OptimizeExprOp : cenv:cenv -> env:IncrementalOptimizationEnv -> op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * m:Range.range -> TypedTree.Expr * Summary - val OptimizeExprOpReductions: + val OptimizeExprOpReductions : cenv:cenv -> env:IncrementalOptimizationEnv -> op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * m:Range.range -> TypedTree.Expr * Summary - val OptimizeExprOpReductionsAfter: + val OptimizeExprOpReductionsAfter : cenv:cenv -> env:IncrementalOptimizationEnv -> op:TypedTree.TOp * tyargs:TypedTree.TypeInst * argsR:TypedTree.Exprs * arginfos:Summary list * m:Range.range -> TypedTree.Expr * Summary - val OptimizeExprOpFallback: + val OptimizeExprOpFallback : cenv:cenv -> env:IncrementalOptimizationEnv -> op:TypedTree.TOp * tyargs:TypedTree.TypeInst * argsR:TypedTree.Exprs * m:Range.range -> arginfos:Summary list -> valu:ExprValueInfo -> TypedTree.Expr * Summary - val OptimizeConst: + val OptimizeConst : cenv:cenv -> env:IncrementalOptimizationEnv -> expr:TypedTree.Expr -> c:TypedTree.Const * m:Range.range * ty:TypedTree.TType -> TypedTree.Expr * Summary - val TryOptimizeRecordFieldGet: + val TryOptimizeRecordFieldGet : cenv:cenv -> _env:IncrementalOptimizationEnv -> e1info:Summary * TypedTree.RecdFieldRef * _tinst:TypedTree.TypeInst * m:Range.range -> ExprValueInfo option - val TryOptimizeTupleFieldGet: + val TryOptimizeTupleFieldGet : cenv:cenv -> _env:IncrementalOptimizationEnv -> _tupInfo:TypedTree.TupInfo * e1info:Summary * tys:TypedTree.TypeInst * n:int * m:Range.range -> ExprValueInfo option - val TryOptimizeUnionCaseGet: + val TryOptimizeUnionCaseGet : cenv:cenv -> _env:IncrementalOptimizationEnv -> e1info:Summary * cspec:TypedTree.UnionCaseRef * _tys:TypedTree.TypeInst * n:int * m:Range.range -> ExprValueInfo option - val OptimizeFastIntegerForLoop: + val OptimizeFastIntegerForLoop : cenv:cenv -> env:IncrementalOptimizationEnv -> spStart:SyntaxTree.DebugPointAtFor * v:TypedTree.Val * e1:TypedTree.Expr * dir:TypedTree.ForLoopStyle * e2:TypedTree.Expr * e3:TypedTree.Expr * m:Range.range -> TypedTree.Expr * Summary - val OptimizeLetRec: + val OptimizeLetRec : cenv:cenv -> env:IncrementalOptimizationEnv -> binds:TypedTree.Bindings * bodyExpr:TypedTree.Expr * m:Range.range -> TypedTree.Expr * Summary - val OptimizeLinearExpr: + val OptimizeLinearExpr : cenv:cenv -> env:IncrementalOptimizationEnv -> expr:TypedTree.Expr -> contf:(TypedTree.Expr * Summary -> TypedTree.Expr * Summary) -> TypedTree.Expr * Summary - val OptimizeTryFinally: + val OptimizeTryFinally : cenv:cenv -> env:IncrementalOptimizationEnv -> spTry:SyntaxTree.DebugPointAtTry * spFinally:SyntaxTree.DebugPointAtFinally * e1:TypedTree.Expr * e2:TypedTree.Expr * m:Range.range * ty:TypedTree.TType -> TypedTree.Expr * Summary - val OptimizeTryWith: + val OptimizeTryWith : cenv:cenv -> env:IncrementalOptimizationEnv -> e1:TypedTree.Expr * vf:TypedTree.Val * ef:TypedTree.Expr * @@ -9794,52 +34858,52 @@ namespace FSharp.Compiler ty:TypedTree.TType * spTry:SyntaxTree.DebugPointAtTry * spWith:SyntaxTree.DebugPointAtWith -> TypedTree.Expr * Summary - val OptimizeWhileLoop: + val OptimizeWhileLoop : cenv:cenv -> env:IncrementalOptimizationEnv -> spWhile:SyntaxTree.DebugPointAtWhile * marker:TypedTree.SpecialWhileLoopMarker * e1:TypedTree.Expr * e2:TypedTree.Expr * m:Range.range -> TypedTree.Expr * Summary - val OptimizeTraitCall: + val OptimizeTraitCall : cenv:cenv -> env:IncrementalOptimizationEnv -> traitInfo:TypedTree.TraitConstraintInfo * args:TypedTree.Exprs * m:Range.range -> TypedTree.Expr * Summary - val TryOptimizeVal: + val TryOptimizeVal : cenv:cenv -> env:IncrementalOptimizationEnv -> mustInline:bool * valInfoForVal:ExprValueInfo * m:Range.range -> TypedTree.Expr option - val TryOptimizeValInfo: + val TryOptimizeValInfo : cenv:cenv -> env:IncrementalOptimizationEnv -> m:Range.range -> vinfo:Summary -> TypedTree.Expr option - val AddValEqualityInfo: + val AddValEqualityInfo : g:TcGlobals.TcGlobals -> m:Range.range -> v:TypedTree.ValRef -> info:Summary -> Summary - val OptimizeVal: + val OptimizeVal : cenv:cenv -> env:IncrementalOptimizationEnv -> expr:TypedTree.Expr -> v:TypedTree.ValRef * m:Range.range -> TypedTree.Expr * Summary - val StripToNominalTyconRef: + val StripToNominalTyconRef : cenv:cenv -> ty:TypedTree.TType -> TypedTree.TyconRef * TypedTree.TypeInst - val CanDevirtualizeApplication: + val CanDevirtualizeApplication : cenv:cenv -> v:TypedTree.ValRef -> vref:TypedTree.ValRef -> ty:TypedTree.TType -> args:'a list -> bool - val TakeAddressOfStructArgumentIfNeeded: + val TakeAddressOfStructArgumentIfNeeded : cenv:cenv -> vref:TypedTree.ValRef -> ty:TypedTree.TType -> args:TypedTree.Expr list -> m:Range.range -> (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr list - val DevirtualizeApplication: + val DevirtualizeApplication : cenv:cenv -> env:IncrementalOptimizationEnv -> vref:TypedTree.ValRef -> @@ -9847,78 +34911,78 @@ namespace FSharp.Compiler tyargs:TypedTree.TType list -> args:TypedTree.Expr list -> m:Range.range -> TypedTree.Expr * Summary - val TryDevirtualizeApplication: + val TryDevirtualizeApplication : cenv:cenv -> env:IncrementalOptimizationEnv -> f:TypedTree.Expr * tyargs:TypedTree.TType list * args:TypedTree.Expr list * m:Range.range -> (TypedTree.Expr * Summary) option - val TryInlineApplication: + val TryInlineApplication : cenv:cenv -> env:IncrementalOptimizationEnv -> finfo:Summary -> tyargs:TypedTree.TType list * args:TypedTree.Expr list * m:Range.range -> (TypedTree.Expr * Summary) option - val OptimizeApplication: + val OptimizeApplication : cenv:cenv -> env:IncrementalOptimizationEnv -> f0:TypedTree.Expr * f0ty:TypedTree.TType * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * m:Range.range -> TypedTree.Expr * Summary - val OptimizeLambdas: + val OptimizeLambdas : vspec:TypedTree.Val option -> cenv:cenv -> env:IncrementalOptimizationEnv -> topValInfo:TypedTree.ValReprInfo -> e:TypedTree.Expr -> ety:TypedTree.TType -> TypedTree.Expr * Summary - val OptimizeExprsThenReshapeAndConsiderSplits: + val OptimizeExprsThenReshapeAndConsiderSplits : cenv:cenv -> env:IncrementalOptimizationEnv -> exprs:(ExprValueInfo * TypedTree.Expr) list -> TypedTree.Exprs * Summary list - val OptimizeExprsThenConsiderSplits: + val OptimizeExprsThenConsiderSplits : cenv:cenv -> env:IncrementalOptimizationEnv -> exprs:TypedTree.Exprs -> TypedTree.Exprs * Summary list - val OptimizeExprThenReshapeAndConsiderSplit: + val OptimizeExprThenReshapeAndConsiderSplit : cenv:cenv -> env:IncrementalOptimizationEnv -> shape:ExprValueInfo * e:TypedTree.Expr -> TypedTree.Expr * Summary - val OptimizeDecisionTreeTargets: + val OptimizeDecisionTreeTargets : cenv:cenv -> env:IncrementalOptimizationEnv -> m:Range.range -> targets:TypedTree.DecisionTreeTarget [] -> TypedTree.DecisionTreeTarget list * Summary list - val ReshapeExpr: + val ReshapeExpr : cenv:cenv -> shape:ExprValueInfo * e:TypedTree.Expr -> TypedTree.Expr - val OptimizeExprThenConsiderSplit: + val OptimizeExprThenConsiderSplit : cenv:cenv -> env:IncrementalOptimizationEnv -> e:TypedTree.Expr -> TypedTree.Expr * Summary - val ComputeSplitToMethodCondition: + val ComputeSplitToMethodCondition : flag:bool -> threshold:int -> cenv:cenv -> env:IncrementalOptimizationEnv -> e:TypedTree.Expr * einfo:Summary<'b> -> bool - val ConsiderSplitToMethod: + val ConsiderSplitToMethod : flag:bool -> threshold:int -> cenv:cenv -> env:IncrementalOptimizationEnv -> e:TypedTree.Expr * einfo:Summary -> TypedTree.Expr * Summary - val OptimizeMatch: + val OptimizeMatch : cenv:cenv -> env:IncrementalOptimizationEnv -> spMatch:SyntaxTree.DebugPointForBinding * exprm:Range.range * dtree:TypedTree.DecisionTree * targets:TypedTree.DecisionTreeTarget array * m:Range.range * ty:TypedTree.TType -> TypedTree.Expr * Summary - val OptimizeMatchPart2: + val OptimizeMatchPart2 : cenv:cenv -> spMatch:SyntaxTree.DebugPointForBinding * exprm:Range.range * dtreeR:TypedTree.DecisionTree * @@ -9926,63 +34990,63 @@ namespace FSharp.Compiler dinfo:Summary * tinfos:Summary list * m:Range.range * ty:TypedTree.TType -> TypedTree.Expr * Summary - val CombineMatchInfos: + val CombineMatchInfos : dinfo:Summary<'c> -> tinfo:Summary<'d> -> Summary - val RebuildOptimizedMatch: + val RebuildOptimizedMatch : spMatch:SyntaxTree.DebugPointForBinding * exprm:Range.range * m:Range.range * ty:TypedTree.TType * dtree:TypedTree.DecisionTree * tgs:TypedTree.DecisionTreeTarget list * dinfo:Summary * tinfos:Summary list -> TypedTree.Expr * Summary - val OptimizeDecisionTreeTarget: + val OptimizeDecisionTreeTarget : cenv:cenv -> env:IncrementalOptimizationEnv -> _m:Range.range -> TypedTree.DecisionTreeTarget -> TypedTree.DecisionTreeTarget * Summary - val OptimizeDecisionTree: + val OptimizeDecisionTree : cenv:cenv -> env:IncrementalOptimizationEnv -> m:Range.range -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree * Summary - val TryOptimizeDecisionTreeTest: + val TryOptimizeDecisionTreeTest : cenv:cenv -> test:TypedTree.DecisionTreeTest -> vinfo:ExprValueInfo -> bool option - val OptimizeSwitch: + val OptimizeSwitch : cenv:cenv -> env:IncrementalOptimizationEnv -> e:TypedTree.Expr * cases:TypedTree.DecisionTreeCase list * dflt:TypedTree.DecisionTree option * m:Range.range -> TypedTree.DecisionTree * Summary - val OptimizeSwitchFallback: + val OptimizeSwitchFallback : cenv:cenv -> env:IncrementalOptimizationEnv -> eR:TypedTree.Expr * einfo:Summary * cases:TypedTree.DecisionTreeCase list * dflt:TypedTree.DecisionTree option * m:Range.range -> TypedTree.DecisionTree * Summary - val OptimizeBinding: + val OptimizeBinding : cenv:cenv -> isRec:bool -> env:IncrementalOptimizationEnv -> TypedTree.Binding -> (TypedTree.Binding * Summary) * IncrementalOptimizationEnv - val OptimizeBindings: + val OptimizeBindings : cenv:cenv -> isRec:bool -> env:IncrementalOptimizationEnv -> xs:TypedTree.Bindings -> (TypedTree.Binding * Summary) list * IncrementalOptimizationEnv - val OptimizeModuleExpr: + val OptimizeModuleExpr : cenv:cenv -> env:IncrementalOptimizationEnv -> x:TypedTree.ModuleOrNamespaceExprWithSig -> TypedTree.ModuleOrNamespaceExprWithSig * LazyModuleInfo - val mkValBind: bind:TypedTree.Binding -> info:'e -> TypedTree.ValRef * 'e - val OptimizeModuleDef: + val mkValBind : bind:TypedTree.Binding -> info:'e -> TypedTree.ValRef * 'e + val OptimizeModuleDef : cenv:cenv -> env:IncrementalOptimizationEnv * bindInfosColl:(TypedTree.Binding * Summary) list list -> @@ -9990,7 +35054,7 @@ namespace FSharp.Compiler (TypedTree.ModuleOrNamespaceExpr * System.Lazy) * (IncrementalOptimizationEnv * (TypedTree.Binding * Summary) list list) - val OptimizeModuleBindings: + val OptimizeModuleBindings : cenv:cenv -> env:IncrementalOptimizationEnv * bindInfosColl:(TypedTree.Binding * Summary) list list -> @@ -10000,7 +35064,7 @@ namespace FSharp.Compiler (string * LazyModuleInfo)>) list * (IncrementalOptimizationEnv * (TypedTree.Binding * Summary) list list) - val OptimizeModuleBinding: + val OptimizeModuleBinding : cenv:cenv -> env:IncrementalOptimizationEnv * bindInfosColl:(TypedTree.Binding * Summary) list list -> @@ -10010,7 +35074,7 @@ namespace FSharp.Compiler (string * LazyModuleInfo)>) * (IncrementalOptimizationEnv * (TypedTree.Binding * Summary) list list) - val OptimizeModuleDefs: + val OptimizeModuleDefs : cenv:cenv -> env:IncrementalOptimizationEnv * bindInfosColl:(TypedTree.Binding * Summary) list list -> @@ -10018,7 +35082,7 @@ namespace FSharp.Compiler (TypedTree.ModuleOrNamespaceExpr list * System.Lazy) * (IncrementalOptimizationEnv * (TypedTree.Binding * Summary) list list) - val OptimizeImplFileInternal: + val OptimizeImplFileInternal : cenv:cenv -> env:IncrementalOptimizationEnv -> isIncrementalFragment:bool -> @@ -10026,7 +35090,7 @@ namespace FSharp.Compiler TypedTree.TypedImplFile -> IncrementalOptimizationEnv * TypedTree.TypedImplFile * LazyModuleInfo * TypedTreeOps.SignatureHidingInfo - val OptimizeImplFile: + val OptimizeImplFile : OptimizationSettings * TypedTree.CcuThunk * TcGlobals.TcGlobals * ConstraintSolver.TcValF * Import.ImportMap * IncrementalOptimizationEnv * isIncrementalFragment:bool * emitTailcalls:bool * @@ -10034,32 +35098,32 @@ namespace FSharp.Compiler (IncrementalOptimizationEnv * TypedTree.TypedImplFile * LazyModuleInfo * TypedTreeOps.SignatureHidingInfo) * (bool -> TypedTree.Expr -> TypedTree.Expr) - val p_ExprValueInfo: + val p_ExprValueInfo : x:ExprValueInfo -> st:TypedTreePickle.WriterState -> unit - val p_ValInfo: v:ValInfo -> st:TypedTreePickle.WriterState -> unit - val p_ModuleInfo: x:ModuleInfo -> st:TypedTreePickle.WriterState -> unit - val p_LazyModuleInfo: + val p_ValInfo : v:ValInfo -> st:TypedTreePickle.WriterState -> unit + val p_ModuleInfo : x:ModuleInfo -> st:TypedTreePickle.WriterState -> unit + val p_LazyModuleInfo : x:LazyModuleInfo -> st:TypedTreePickle.WriterState -> unit - val p_CcuOptimizationInfo: + val p_CcuOptimizationInfo : LazyModuleInfo -> TypedTreePickle.WriterState -> unit - val u_ExprInfo: st:TypedTreePickle.ReaderState -> ExprValueInfo - val u_ValInfo: st:TypedTreePickle.ReaderState -> ValInfo - val u_ModuleInfo: st:TypedTreePickle.ReaderState -> ModuleInfo - val u_LazyModuleInfo: st:TypedTreePickle.ReaderState -> LazyModuleInfo - val u_CcuOptimizationInfo: TypedTreePickle.ReaderState -> LazyModuleInfo - + val u_ExprInfo : st:TypedTreePickle.ReaderState -> ExprValueInfo + val u_ValInfo : st:TypedTreePickle.ReaderState -> ValInfo + val u_ModuleInfo : st:TypedTreePickle.ReaderState -> ModuleInfo + val u_LazyModuleInfo : st:TypedTreePickle.ReaderState -> LazyModuleInfo + val u_CcuOptimizationInfo : TypedTreePickle.ReaderState -> LazyModuleInfo + end namespace FSharp.Compiler - module internal Detuple = - val ( |TyappAndApp|_| ): + module internal Detuple = begin + val ( |TyappAndApp|_| ) : e:TypedTree.Expr -> (TypedTree.Expr * TypedTree.TType * TypedTree.TType list * TypedTree.Exprs * Range.range) option - module GlobalUsageAnalysis = - val bindAccBounds: + module GlobalUsageAnalysis = begin + val bindAccBounds : vals:AbstractIL.Internal.Zset<'a> -> _isInDTree:'b * v:'a -> AbstractIL.Internal.Zset<'a> - val GetValsBoundInExpr: + val GetValsBoundInExpr : TypedTree.Expr -> AbstractIL.Internal.Zset type accessor = | TupleGet of int * TypedTree.TType list type Results = @@ -10073,23 +35137,23 @@ namespace FSharp.Compiler AbstractIL.Internal.Zmap TopLevelBindings: AbstractIL.Internal.Zset IterationIsAtTopLevel: bool } - val z0: Results - val logUse: + val z0 : Results + val logUse : f:TypedTree.Val -> accessor list * TypedTree.TType list * TypedTree.Expr list -> z:Results -> Results - val logBinding: z:Results -> isInDTree:bool * v:TypedTree.Val -> Results - val logNonRecBinding: z:Results -> bind:TypedTree.Binding -> Results - val logRecBindings: z:Results -> binds:TypedTree.Bindings -> Results - val foldUnderLambda: + val logBinding : z:Results -> isInDTree:bool * v:TypedTree.Val -> Results + val logNonRecBinding : z:Results -> bind:TypedTree.Binding -> Results + val logRecBindings : z:Results -> binds:TypedTree.Bindings -> Results + val foldUnderLambda : f:(Results -> 'a -> Results) -> z:Results -> x:'a -> Results - val UsageFolders: + val UsageFolders : g:TcGlobals.TcGlobals -> TypedTreeOps.ExprFolder - val GetUsageInfoOfImplFile: + val GetUsageInfoOfImplFile : TcGlobals.TcGlobals -> TypedTree.TypedImplFile -> Results - - val internalError: str:string -> 'a - val mkLocalVal: + end + val internalError : str:string -> 'a + val mkLocalVal : m:Range.range -> name:string -> ty:TypedTree.TType -> @@ -10097,30 +35161,30 @@ namespace FSharp.Compiler type TupleStructure = | UnknownTS | TupleTS of TupleStructure list - val ValReprInfoForTS: ts:TupleStructure -> TypedTree.ArgReprInfo list list - val andTS: ts:TupleStructure -> tsB:TupleStructure -> TupleStructure - val checkTS: _arg1:TupleStructure -> TupleStructure - val uncheckedExprTS: expr:TypedTree.Expr -> TupleStructure - val uncheckedTypeTS: + val ValReprInfoForTS : ts:TupleStructure -> TypedTree.ArgReprInfo list list + val andTS : ts:TupleStructure -> tsB:TupleStructure -> TupleStructure + val checkTS : _arg1:TupleStructure -> TupleStructure + val uncheckedExprTS : expr:TypedTree.Expr -> TupleStructure + val uncheckedTypeTS : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TupleStructure - val exprTS: exprs:TypedTree.Expr -> TupleStructure - val typeTS: g:TcGlobals.TcGlobals -> tys:TypedTree.TType -> TupleStructure - val rebuildTS: + val exprTS : exprs:TypedTree.Expr -> TupleStructure + val typeTS : g:TcGlobals.TcGlobals -> tys:TypedTree.TType -> TupleStructure + val rebuildTS : g:TcGlobals.TcGlobals -> m:Range.range -> ts:TupleStructure -> vs:TypedTree.Val list -> TypedTree.Expr type CallPattern = TupleStructure list - val callPatternOrder: (CallPattern -> CallPattern -> int) - val argsCP: exprs:TypedTree.Expr list -> TupleStructure list - val noArgsCP: 'a list - val inline isTrivialCP: xs:'a list -> bool - val minimalCallPattern: + val callPatternOrder : (CallPattern -> CallPattern -> int) + val argsCP : exprs:TypedTree.Expr list -> TupleStructure list + val noArgsCP : 'a list + val inline isTrivialCP : xs:'a list -> bool + val minimalCallPattern : callPattern:TupleStructure list -> TupleStructure list - val commonCallPattern: + val commonCallPattern : callPatterns:TupleStructure list list -> TupleStructure list - val siteCP: + val siteCP : _accessors:'a * _inst:'b * args:TypedTree.Expr list -> TupleStructure list - val sitesCPs: + val sitesCPs : sites:('a * 'b * TypedTree.Expr list) list -> TupleStructure list list type TransformedFormal = | SameArg @@ -10129,7 +35193,7 @@ namespace FSharp.Compiler { transformCallPattern: CallPattern transformedFormals: TransformedFormal list transformedVal: TypedTree.Val } - val mkTransform: + val mkTransform : g:TcGlobals.TcGlobals -> f:TypedTree.Val -> m:Range.range -> @@ -10139,27 +35203,27 @@ namespace FSharp.Compiler callPattern:TupleStructure list * tyfringes:(TypedTree.TType list * TypedTree.Val list) list -> Transform - val zipTupleStructureAndType: + val zipTupleStructureAndType : g:TcGlobals.TcGlobals -> ts:TupleStructure -> ty:TypedTree.TType -> TupleStructure * TypedTree.TType list - val zipTupleStructuresAndTypes: + val zipTupleStructuresAndTypes : g:TcGlobals.TcGlobals -> tss:TupleStructure list -> tys:TypedTree.TTypes -> TupleStructure list * TypedTree.TType list - val zipCallPatternArgTys: + val zipCallPatternArgTys : m:Range.range -> g:TcGlobals.TcGlobals -> callPattern:TupleStructure list -> vss:TypedTree.Val list list -> TupleStructure list * (TypedTree.TType list * TypedTree.Val list) list - val decideFormalSuggestedCP: + val decideFormalSuggestedCP : g:TcGlobals.TcGlobals -> z:GlobalUsageAnalysis.Results -> tys:TypedTree.TType list -> vss:TypedTree.Val list list -> TupleStructure list - val decideTransform: + val decideTransform : g:TcGlobals.TcGlobals -> z:GlobalUsageAnalysis.Results -> v:TypedTree.Val -> @@ -10167,9 +35231,9 @@ namespace FSharp.Compiler m:Range.range * tps:TypedTree.Typar list * vss:TypedTree.Val list list * rty:TypedTree.TType -> (TypedTree.Val * Transform) option - val eligibleVal: + val eligibleVal : g:TcGlobals.TcGlobals -> m:Range.range -> v:TypedTree.Val -> bool - val determineTransforms: + val determineTransforms : g:TcGlobals.TcGlobals -> z:GlobalUsageAnalysis.Results -> AbstractIL.Internal.Zmap @@ -10177,163 +35241,163 @@ namespace FSharp.Compiler { transforms: AbstractIL.Internal.Zmap ccu: TypedTree.CcuThunk g: TcGlobals.TcGlobals } - val hasTransfrom: penv:penv -> f:TypedTree.Val -> Transform option + val hasTransfrom : penv:penv -> f:TypedTree.Val -> Transform option type env = { eg: TcGlobals.TcGlobals prefix: string m: Range.range } with - override ToString: unit -> string - - val suffixE: env:env -> s:string -> env - val rangeE: env:env -> m:Range.range -> env - val push: b:'a -> bs:'a list -> 'a list - val pushL: xs:'a list -> bs:'a list -> 'a list - val newLocal: + override ToString : unit -> string + end + val suffixE : env:env -> s:string -> env + val rangeE : env:env -> m:Range.range -> env + val push : b:'a -> bs:'a list -> 'a list + val pushL : xs:'a list -> bs:'a list -> 'a list + val newLocal : env:env -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val newLocalN: + val newLocalN : env:env -> i:'a -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val noEffectExpr: + val noEffectExpr : env:env -> bindings:TypedTree.Binding list -> x:TypedTree.Expr -> TypedTree.Binding list * TypedTree.Expr - val buildProjections: + val buildProjections : env:env -> bindings:TypedTree.Binding list -> x:TypedTree.Expr -> xtys:TypedTree.TType list -> TypedTree.Binding list * TypedTree.Expr list - val collapseArg: + val collapseArg : env:env -> bindings:TypedTree.Binding list -> ts:TupleStructure -> x:TypedTree.Expr -> TypedTree.Binding list * TypedTree.Expr list - val collapseArgs: + val collapseArgs : env:env -> bindings:TypedTree.Binding list -> n:int -> callPattern:TupleStructure list -> args:TypedTree.Exprs -> TypedTree.Binding list * TypedTree.Expr list - val mkLets: + val mkLets : binds:TypedTree.Binding list -> body:TypedTree.Expr -> TypedTree.Expr - val fixupApp: + val fixupApp : penv:penv -> fx:TypedTree.Expr * fty:TypedTree.TType * tys:TypedTree.TypeInst * args:TypedTree.Exprs * m:Range.range -> TypedTree.Expr - val transFormal: + val transFormal : ybi:TransformedFormal -> xi:TypedTree.Val list -> TypedTree.Val list list - val transRebind: + val transRebind : ybi:TransformedFormal -> xi:TypedTree.Val list -> TypedTree.Binding list - val passBind: penv:penv -> TypedTree.Binding -> TypedTree.Binding - val passBinds: + val passBind : penv:penv -> TypedTree.Binding -> TypedTree.Binding + val passBinds : penv:penv -> binds:TypedTree.Binding list -> TypedTree.Binding list - val passBindRhs: + val passBindRhs : conv:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Binding -> TypedTree.Binding - val preInterceptExpr: + val preInterceptExpr : penv:penv -> conv:(TypedTree.Expr -> TypedTree.Expr) -> expr:TypedTree.Expr -> TypedTree.Expr option - val postTransformExpr: + val postTransformExpr : penv:penv -> expr:TypedTree.Expr -> TypedTree.Expr option - val passImplFile: + val passImplFile : penv:penv -> assembly:TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val DetupleImplFile: + val DetupleImplFile : TypedTree.CcuThunk -> TcGlobals.TcGlobals -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile - + end namespace FSharp.Compiler - module internal InnerLambdasToTopLevelFuncs = - val verboseTLR: bool - val internalError: str:string -> 'a - module Zmap = - val force: + module internal InnerLambdasToTopLevelFuncs = begin + val verboseTLR : bool + val internalError : str:string -> 'a + module Zmap = begin + val force : k:'a -> mp:AbstractIL.Internal.Zmap<'a,'b> -> str:string * soK:('a -> string) -> 'b - + end type Tree<'T> = | TreeNode of Tree<'T> list | LeafNode of 'T - val fringeTR: tr:Tree<'a> -> 'a list - val emptyTR: Tree<'a> - val destApp: + val fringeTR : tr:Tree<'a> -> 'a list + val emptyTR : Tree<'a> + val destApp : f:TypedTree.Expr * fty:TypedTree.TType * tys:TypedTree.TType list * args:'a * m:'b -> TypedTree.Expr * TypedTree.TType * TypedTree.TType list * 'a * 'b - val showTyparSet: tps:AbstractIL.Internal.Zset -> string - val isDelayedRepr: f:TypedTree.Val -> e:TypedTree.Expr -> bool - val mkLocalNameTypeArity: + val showTyparSet : tps:AbstractIL.Internal.Zset -> string + val isDelayedRepr : f:TypedTree.Val -> e:TypedTree.Expr -> bool + val mkLocalNameTypeArity : compgen:bool -> m:Range.range -> name:string -> ty:TypedTree.TType -> topValInfo:TypedTree.ValReprInfo option -> TypedTree.Val - val GetValsBoundUnderMustInline: + val GetValsBoundUnderMustInline : xinfo:Detuple.GlobalUsageAnalysis.Results -> AbstractIL.Internal.Zset - val IsRefusedTLR: g:TcGlobals.TcGlobals -> f:TypedTree.Val -> bool - val IsMandatoryTopLevel: f:TypedTree.Val -> bool - val IsMandatoryNonTopLevel: + val IsRefusedTLR : g:TcGlobals.TcGlobals -> f:TypedTree.Val -> bool + val IsMandatoryTopLevel : f:TypedTree.Val -> bool + val IsMandatoryNonTopLevel : g:TcGlobals.TcGlobals -> f:TypedTree.Val -> bool - module Pass1_DetermineTLRAndArities = - val GetMaxNumArgsAtUses: + module Pass1_DetermineTLRAndArities = begin + val GetMaxNumArgsAtUses : xinfo:Detuple.GlobalUsageAnalysis.Results -> f:TypedTree.Val -> int - val SelectTLRVals: + val SelectTLRVals : g:TcGlobals.TcGlobals -> xinfo:Detuple.GlobalUsageAnalysis.Results -> f:TypedTree.Val -> e:TypedTree.Expr -> (TypedTree.Val * int) option - val IsValueRecursionFree: + val IsValueRecursionFree : xinfo:Detuple.GlobalUsageAnalysis.Results -> f:TypedTree.Val -> bool - val DumpArity: arityM:AbstractIL.Internal.Zmap -> unit - val DetermineTLRAndArities: + val DumpArity : arityM:AbstractIL.Internal.Zmap -> unit + val DetermineTLRAndArities : g:TcGlobals.TcGlobals -> expr:TypedTree.TypedImplFile -> AbstractIL.Internal.Zset * AbstractIL.Internal.Zset * AbstractIL.Internal.Zmap - + end type BindingGroupSharingSameReqdItems = - - new: bindings:TypedTree.Bindings -> BindingGroupSharingSameReqdItems - member Contains: v:TypedTree.Val -> bool - override ToString: unit -> string - member IsEmpty: bool - member Pairs: (TypedTree.Val * BindingGroupSharingSameReqdItems) list - member Vals: TypedTree.Vals - - val fclassOrder: + class + new : bindings:TypedTree.Bindings -> BindingGroupSharingSameReqdItems + member Contains : v:TypedTree.Val -> bool + override ToString : unit -> string + member IsEmpty : bool + member Pairs : (TypedTree.Val * BindingGroupSharingSameReqdItems) list + member Vals : TypedTree.Vals + end + val fclassOrder : System.Collections.Generic.IComparer type ReqdItem = | ReqdSubEnv of TypedTree.Val | ReqdVal of TypedTree.Val with - override ToString: unit -> string - - val reqdItemOrder: System.Collections.Generic.IComparer + override ToString : unit -> string + end + val reqdItemOrder : System.Collections.Generic.IComparer type ReqdItemsForDefn = { reqdTypars: AbstractIL.Internal.Zset reqdItems: AbstractIL.Internal.Zset m: Range.range } with static member - Initial: typars:TypedTree.Typar list -> + Initial : typars:TypedTree.Typar list -> m:Range.range -> ReqdItemsForDefn member - Extend: typars:TypedTree.Typar list * items:ReqdItem list -> + Extend : typars:TypedTree.Typar list * items:ReqdItem list -> ReqdItemsForDefn - override ToString: unit -> string - member ReqdSubEnvs: TypedTree.Val list - member ReqdVals: TypedTree.Val list - + override ToString : unit -> string + member ReqdSubEnvs : TypedTree.Val list + member ReqdVals : TypedTree.Val list + end type Generators = AbstractIL.Internal.Zset - val IsArityMet: + val IsArityMet : vref:TypedTree.ValRef -> wf:int -> tys:TypedTree.TypeInst -> args:'a list -> bool - module Pass2_DetermineReqdItems = + module Pass2_DetermineReqdItems = begin type state = { stack: (BindingGroupSharingSameReqdItems * Generators * ReqdItemsForDefn) list @@ -10345,30 +35409,30 @@ namespace FSharp.Compiler BindingGroupSharingSameReqdItems> revDeclist: BindingGroupSharingSameReqdItems list recShortCallS: AbstractIL.Internal.Zset } - val state0: state - val PushFrame: + val state0 : state + val PushFrame : fclass:BindingGroupSharingSameReqdItems -> reqdTypars0:TypedTree.Typar list * reqdVals0:Generators * m:Range.range -> state:state -> state - val SaveFrame: + val SaveFrame : fclass:BindingGroupSharingSameReqdItems -> state:state -> state - val LogRequiredFrom: + val LogRequiredFrom : gv:TypedTree.Val -> items:ReqdItem list -> state:state -> state - val LogShortCall: gv:TypedTree.Val -> state:state -> state - val FreeInBindings: bs:TypedTree.Binding list -> TypedTree.FreeVars - val ExprEnvIntercept: + val LogShortCall : gv:TypedTree.Val -> state:state -> state + val FreeInBindings : bs:TypedTree.Binding list -> TypedTree.FreeVars + val ExprEnvIntercept : tlrS:AbstractIL.Internal.Zset * arityM:AbstractIL.Internal.Zmap -> recurseF:(state -> TypedTree.Expr -> state) -> noInterceptF:(state -> TypedTree.Expr -> state) -> z:state -> expr:TypedTree.Expr -> state - val CloseReqdTypars: + val CloseReqdTypars : fclassM:AbstractIL.Internal.Zmap -> reqdItemsMap:AbstractIL.Internal.Zmap<'a,ReqdItemsForDefn> -> AbstractIL.Internal.Zmap<'a,ReqdItemsForDefn> - val DumpReqdValMap: + val DumpReqdValMap : reqdItemsMap:seq> -> unit - val DetermineReqdItems: + val DetermineReqdItems : tlrS:AbstractIL.Internal.Zset * arityM:AbstractIL.Internal.Zmap -> expr:TypedTree.TypedImplFile -> @@ -10378,14 +35442,14 @@ namespace FSharp.Compiler BindingGroupSharingSameReqdItems> * BindingGroupSharingSameReqdItems list * AbstractIL.Internal.Zset - + end type PackedReqdItems = { ep_etps: TypedTree.Typars ep_aenvs: TypedTree.Val list ep_pack: TypedTree.Bindings ep_unpack: TypedTree.Bindings } exception AbortTLR of Range.range - val FlatEnvPacks: + val FlatEnvPacks : g:TcGlobals.TcGlobals -> fclassM:AbstractIL.Internal.Zmap -> @@ -10395,11 +35459,11 @@ namespace FSharp.Compiler ReqdItemsForDefn> -> AbstractIL.Internal.Zmap - val DumpEnvPackM: + val DumpEnvPackM : g:TcGlobals.TcGlobals -> envPackM:seq> -> unit - val ChooseReqdItemPackings: + val ChooseReqdItemPackings : g:TcGlobals.TcGlobals -> fclassM:AbstractIL.Internal.Zmap -> @@ -10409,17 +35473,17 @@ namespace FSharp.Compiler ReqdItemsForDefn> -> AbstractIL.Internal.Zmap - val MakeSimpleArityInfo: + val MakeSimpleArityInfo : tps:TypedTree.Typar list -> n:int -> TypedTree.ValReprInfo - val CreateNewValuesForTLR: + val CreateNewValuesForTLR : g:TcGlobals.TcGlobals -> tlrS:AbstractIL.Internal.Zset -> arityM:AbstractIL.Internal.Zmap -> fclassM:AbstractIL.Internal.Zmap -> envPackM:AbstractIL.Internal.Zmap<'a,PackedReqdItems> -> AbstractIL.Internal.Zmap - module Pass4_RewriteAssembly = - [] + module Pass4_RewriteAssembly = begin + [] type RewriteContext = { ccu: TypedTree.CcuThunk g: TcGlobals.TcGlobals @@ -10442,136 +35506,136 @@ namespace FSharp.Compiler { rws_mustinline: bool rws_innerLevel: int rws_preDecs: Tree } - val rewriteState0: RewriteState - val EnterInner: z:RewriteState -> RewriteState - val ExitInner: z:RewriteState -> RewriteState - val EnterMustInline: + val rewriteState0 : RewriteState + val EnterInner : z:RewriteState -> RewriteState + val ExitInner : z:RewriteState -> RewriteState + val EnterMustInline : b:bool -> z:RewriteState -> f:(RewriteState -> 'a * RewriteState) -> RewriteState * 'a - val ExtractPreDecs: + val ExtractPreDecs : z:RewriteState -> LiftedDeclaration list * RewriteState - val PopPreDecs: z:RewriteState -> RewriteState * Tree - val SetPreDecs: + val PopPreDecs : z:RewriteState -> RewriteState * Tree + val SetPreDecs : z:RewriteState -> pdt:Tree -> RewriteState - val LiftTopBinds: _isRec:'a -> _penv:'b -> z:'c -> binds:'d -> 'c * 'd - val MakePreDec: + val LiftTopBinds : _isRec:'a -> _penv:'b -> z:'c -> binds:'d -> 'c * 'd + val MakePreDec : m:Range.range -> isRec:IsRecursive * binds:TypedTree.Bindings -> expr:TypedTree.Expr -> TypedTree.Expr - val MakePreDecs: + val MakePreDecs : m:Range.range -> preDecs:(IsRecursive * TypedTree.Bindings) list -> expr:TypedTree.Expr -> TypedTree.Expr - val RecursivePreDecs: + val RecursivePreDecs : pdsA:Tree<'a * 'b list> -> pdsB:Tree<'a * 'b list> -> Tree - val ConvertBind: + val ConvertBind : g:TcGlobals.TcGlobals -> TypedTree.Binding -> TypedTree.Binding - val TransTLRBindings: + val TransTLRBindings : penv:RewriteContext -> binds:TypedTree.Bindings -> TypedTree.Binding list * TypedTree.Binding list - val GetAEnvBindings: + val GetAEnvBindings : penv:RewriteContext -> fc:BindingGroupSharingSameReqdItems -> TypedTree.Binding list - val TransBindings: + val TransBindings : xisRec:IsRecursive -> penv:RewriteContext -> binds:TypedTree.Bindings -> TypedTree.Binding list * TypedTree.Binding list - val TransApp: + val TransApp : penv:RewriteContext -> fx:TypedTree.Expr * fty:TypedTree.TType * tys:TypedTree.TypeInst * args:TypedTree.Expr list * m:Range.range -> TypedTree.Expr - val TransExpr: + val TransExpr : penv:RewriteContext -> z:RewriteState -> expr:TypedTree.Expr -> TypedTree.Expr * RewriteState - val TransLinearExpr: + val TransLinearExpr : penv:RewriteContext -> z:RewriteState -> expr:TypedTree.Expr -> contf:(TypedTree.Expr * RewriteState -> TypedTree.Expr * RewriteState) -> TypedTree.Expr * RewriteState - val TransMethod: + val TransMethod : penv:RewriteContext -> z:RewriteState -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod * RewriteState - val TransBindingRhs: + val TransBindingRhs : penv:RewriteContext -> z:RewriteState -> TypedTree.Binding -> TypedTree.Binding * RewriteState - val TransDecisionTree: + val TransDecisionTree : penv:RewriteContext -> z:RewriteState -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree * RewriteState - val TransDecisionTreeTarget: + val TransDecisionTreeTarget : penv:RewriteContext -> z:RewriteState -> TypedTree.DecisionTreeTarget -> TypedTree.DecisionTreeTarget * RewriteState - val TransValBinding: + val TransValBinding : penv:RewriteContext -> z:RewriteState -> bind:TypedTree.Binding -> TypedTree.Binding * RewriteState - val TransValBindings: + val TransValBindings : penv:RewriteContext -> z:RewriteState -> binds:TypedTree.Binding list -> TypedTree.Binding list * RewriteState - val TransModuleExpr: + val TransModuleExpr : penv:RewriteContext -> z:RewriteState -> x:TypedTree.ModuleOrNamespaceExprWithSig -> TypedTree.ModuleOrNamespaceExprWithSig * RewriteState - val TransModuleDefs: + val TransModuleDefs : penv:RewriteContext -> z:RewriteState -> x:TypedTree.ModuleOrNamespaceExpr list -> TypedTree.ModuleOrNamespaceExpr list * RewriteState - val TransModuleDef: + val TransModuleDef : penv:RewriteContext -> z:RewriteState -> x:TypedTree.ModuleOrNamespaceExpr -> TypedTree.ModuleOrNamespaceExpr * RewriteState - val TransModuleBindings: + val TransModuleBindings : penv:RewriteContext -> z:RewriteState -> binds:TypedTree.ModuleOrNamespaceBinding list -> TypedTree.ModuleOrNamespaceBinding list * RewriteState - val TransModuleBinding: + val TransModuleBinding : penv:RewriteContext -> z:RewriteState -> x:TypedTree.ModuleOrNamespaceBinding -> TypedTree.ModuleOrNamespaceBinding * RewriteState - val TransImplFile: + val TransImplFile : penv:RewriteContext -> z:RewriteState -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile * RewriteState - - val RecreateUniqueBounds: + end + val RecreateUniqueBounds : g:TcGlobals.TcGlobals -> expr:TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val MakeTLRDecisions: + val MakeTLRDecisions : TypedTree.CcuThunk -> TcGlobals.TcGlobals -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile - + end namespace FSharp.Compiler - module internal LowerCallsAndSeqs = - val InterceptExpr: + module internal LowerCallsAndSeqs = begin + val InterceptExpr : g:TcGlobals.TcGlobals -> cont:(TypedTree.Expr -> TypedTree.Expr) -> expr:TypedTree.Expr -> TypedTree.Expr option - val LowerImplFile: + val LowerImplFile : g:TcGlobals.TcGlobals -> assembly:TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val mkLambdaNoType: + val mkLambdaNoType : g:TcGlobals.TcGlobals -> m:Range.range -> uv:TypedTree.Val -> e:TypedTree.Expr -> TypedTree.Expr - val callNonOverloadedMethod: + val callNonOverloadedMethod : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> m:Range.range -> @@ -10586,33 +35650,33 @@ namespace FSharp.Compiler significantClose: bool stateVars: TypedTree.ValRef list asyncVars: TypedTree.FreeVars } - val isVarFreeInExpr: v:TypedTree.Val -> e:TypedTree.Expr -> bool - val ( |Seq|_| ): + val isVarFreeInExpr : v:TypedTree.Val -> e:TypedTree.Expr -> bool + val ( |Seq|_| ) : g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.TType) option - val IsPossibleSequenceExpr: + val IsPossibleSequenceExpr : g:TcGlobals.TcGlobals -> overallExpr:TypedTree.Expr -> bool - val ConvertSequenceExprToObject: + val ConvertSequenceExprToObject : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> overallExpr:TypedTree.Expr -> (TypedTree.ValRef * TypedTree.ValRef * TypedTree.ValRef * TypedTree.ValRef list * TypedTree.Expr * TypedTree.Expr * TypedTree.Expr * TypedTree.TType * Range.range) option - + end namespace FSharp.Compiler - module internal AutoBox = + module internal AutoBox = begin type cenv = { g: TcGlobals.TcGlobals amap: Import.ImportMap } with - override ToString: unit -> string - - val DecideEscapes: + override ToString : unit -> string + end + val DecideEscapes : syntacticArgs:TypedTree.Val list -> body:TypedTree.Expr -> AbstractIL.Internal.Zset - val DecideLambda: + val DecideLambda : exprF:(AbstractIL.Internal.Zset -> TypedTree.Expr -> AbstractIL.Internal.Zset) option -> cenv:cenv -> @@ -10621,7 +35685,7 @@ namespace FSharp.Compiler ety:TypedTree.TType -> z:AbstractIL.Internal.Zset -> AbstractIL.Internal.Zset - val DecideExprOp: + val DecideExprOp : exprF:(AbstractIL.Internal.Zset -> TypedTree.Expr -> AbstractIL.Internal.Zset) -> noInterceptF:(AbstractIL.Internal.Zset -> @@ -10631,7 +35695,7 @@ namespace FSharp.Compiler expr:TypedTree.Expr -> op:TypedTree.TOp * tyargs:'a list * args:TypedTree.Expr list -> AbstractIL.Internal.Zset - val DecideExpr: + val DecideExpr : cenv:cenv -> exprF:(AbstractIL.Internal.Zset -> TypedTree.Expr -> AbstractIL.Internal.Zset) -> @@ -10640,79 +35704,79 @@ namespace FSharp.Compiler AbstractIL.Internal.Zset) -> z:AbstractIL.Internal.Zset -> expr:TypedTree.Expr -> AbstractIL.Internal.Zset - val DecideBinding: + val DecideBinding : cenv:cenv -> z:AbstractIL.Internal.Zset -> TypedTree.Binding -> AbstractIL.Internal.Zset - val DecideBindings: + val DecideBindings : cenv:cenv -> z:AbstractIL.Internal.Zset -> binds:TypedTree.Binding list -> AbstractIL.Internal.Zset - val DecideImplFile: + val DecideImplFile : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> implFile:TypedTree.TypedImplFile -> AbstractIL.Internal.Zset - val TransformExpr: + val TransformExpr : g:TcGlobals.TcGlobals -> nvs:TypedTreeOps.ValMap<'a * TypedTree.Expr> -> exprF:(TypedTree.Expr -> TypedTree.Expr) -> expr:TypedTree.Expr -> TypedTree.Expr option - val TransformBinding: + val TransformBinding : g:TcGlobals.TcGlobals -> nvs:TypedTreeOps.ValMap -> exprF:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Binding -> TypedTree.Binding option - val TransformImplFile: + val TransformImplFile : g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> implFile:TypedTree.TypedImplFile -> TypedTree.TypedImplFile - + end namespace FSharp.Compiler - module internal IlxGen = - val IsNonErasedTypar: tp:TypedTree.Typar -> bool - val DropErasedTypars: tps:TypedTree.Typar list -> TypedTree.Typar list - val DropErasedTyargs: tys:TypedTree.TType list -> TypedTree.TType list - val AddNonUserCompilerGeneratedAttribs: + module internal IlxGen = begin + val IsNonErasedTypar : tp:TypedTree.Typar -> bool + val DropErasedTypars : tps:TypedTree.Typar list -> TypedTree.Typar list + val DropErasedTyargs : tys:TypedTree.TType list -> TypedTree.TType list + val AddNonUserCompilerGeneratedAttribs : g:TcGlobals.TcGlobals -> mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef - val debugDisplayMethodName: string - val useHiddenInitCode: bool - val iLdcZero: AbstractIL.IL.ILInstr - val iLdcInt64: i:int64 -> AbstractIL.IL.ILInstr - val iLdcDouble: i:double -> AbstractIL.IL.ILInstr - val iLdcSingle: i:single -> AbstractIL.IL.ILInstr - val mkLdfldMethodDef: + val debugDisplayMethodName : string + val useHiddenInitCode : bool + val iLdcZero : AbstractIL.IL.ILInstr + val iLdcInt64 : i:int64 -> AbstractIL.IL.ILInstr + val iLdcDouble : i:double -> AbstractIL.IL.ILInstr + val iLdcSingle : i:single -> AbstractIL.IL.ILInstr + val mkLdfldMethodDef : ilMethName:string * reprAccess:AbstractIL.IL.ILMemberAccess * isStatic:bool * ilTy:AbstractIL.IL.ILType * ilFieldName:string * ilPropType:AbstractIL.IL.ILType -> AbstractIL.IL.ILMethodDef - val ChooseParamNames: + val ChooseParamNames : fieldNamesAndTypes:(string * string * 'a) list -> (string * string * 'a) list - val CheckCodeDoesSomething: code:AbstractIL.IL.ILCode -> bool - val ChooseFreeVarNames: + val CheckCodeDoesSomething : code:AbstractIL.IL.ILCode -> bool + val ChooseFreeVarNames : takenNames:string list -> ts:string list -> string list - val IsILTypeByref: _arg1:AbstractIL.IL.ILType -> bool - val mainMethName: string + val IsILTypeByref : _arg1:AbstractIL.IL.ILType -> bool + val mainMethName : string type AttributeDecoder = - - new: namedArgs:TypedTree.AttribNamedArg list -> AttributeDecoder - member FindBool: x:string -> dflt:bool -> bool - member FindInt16: x:string -> dflt:int16 -> int16 - member FindInt32: x:string -> dflt:int32 -> int32 - member FindString: x:string -> dflt:string -> string - member FindTypeName: x:string -> dflt:string -> string - - val mutable reports: (System.IO.TextWriter -> unit) - val AddReport: f:(System.IO.TextWriter -> unit) -> unit - val ReportStatistics: System.IO.TextWriter -> unit - val NewCounter: nm:string -> (unit -> unit) - val CountClosure: (unit -> unit) - val CountMethodDef: (unit -> unit) - val CountStaticFieldDef: (unit -> unit) - val CountCallFuncInstructions: (unit -> unit) + class + new : namedArgs:TypedTree.AttribNamedArg list -> AttributeDecoder + member FindBool : x:string -> dflt:bool -> bool + member FindInt16 : x:string -> dflt:int16 -> int16 + member FindInt32 : x:string -> dflt:int32 -> int32 + member FindString : x:string -> dflt:string -> string + member FindTypeName : x:string -> dflt:string -> string + end + val mutable reports : (System.IO.TextWriter -> unit) + val AddReport : f:(System.IO.TextWriter -> unit) -> unit + val ReportStatistics : System.IO.TextWriter -> unit + val NewCounter : nm:string -> (unit -> unit) + val CountClosure : (unit -> unit) + val CountMethodDef : (unit -> unit) + val CountStaticFieldDef : (unit -> unit) + val CountCallFuncInstructions : (unit -> unit) type IlxGenIntraAssemblyInfo = { StaticFieldInfo: System.Collections.Generic.Dictionary] + [] type IlxGenOptions = { fragName: string generateFilterBlocks: bool @@ -10735,7 +35799,7 @@ namespace FSharp.Compiler isInteractive: bool isInteractiveItExpr: bool alwaysCallVirt: bool } - [] + [] type cenv = { g: TcGlobals.TcGlobals amap: Import.ImportMap @@ -10749,13 +35813,13 @@ namespace FSharp.Compiler mutable exprRecursionDepth: int delayedGenMethods: System.Collections.Generic.Queue<(cenv -> unit)> } with - override ToString: unit -> string - - val mkTypeOfExpr: + override ToString : unit -> string + end + val mkTypeOfExpr : cenv:cenv -> m:Range.range -> ilty:AbstractIL.IL.ILType -> TypedTree.Expr - val mkGetNameExpr: + val mkGetNameExpr : cenv:cenv -> ilt:AbstractIL.IL.ILType -> m:Range.range -> TypedTree.Expr - val useCallVirt: + val useCallVirt : cenv:cenv -> boxity:AbstractIL.IL.ILBoxity -> mspec:AbstractIL.IL.ILMethodSpec -> isBaseCall:bool -> bool @@ -10765,202 +35829,202 @@ namespace FSharp.Compiler Namespace: string option Enclosing: string list QualifiedNameOfFile: string } - val mkTopName: ns:string option -> n:string -> string - val CompLocForFragment: + val mkTopName : ns:string option -> n:string -> string + val CompLocForFragment : fragName:string -> ccu:TypedTree.CcuThunk -> CompileLocation - val CompLocForCcu: ccu:TypedTree.CcuThunk -> CompileLocation - val CompLocForSubModuleOrNamespace: + val CompLocForCcu : ccu:TypedTree.CcuThunk -> CompileLocation + val CompLocForSubModuleOrNamespace : cloc:CompileLocation -> submod:TypedTree.ModuleOrNamespace -> CompileLocation - val CompLocForFixedPath: + val CompLocForFixedPath : fragName:string -> qname:string -> TypedTree.CompilationPath -> CompileLocation - val CompLocForFixedModule: + val CompLocForFixedModule : fragName:string -> qname:string -> mspec:TypedTree.ModuleOrNamespace -> CompileLocation - val NestedTypeRefForCompLoc: + val NestedTypeRefForCompLoc : cloc:CompileLocation -> n:string -> AbstractIL.IL.ILTypeRef - val CleanUpGeneratedTypeName: nm:string -> string - val TypeNameForInitClass: cloc:CompileLocation -> string - val TypeNameForImplicitMainMethod: cloc:CompileLocation -> string - val TypeNameForPrivateImplementationDetails: cloc:CompileLocation -> string - val CompLocForInitClass: cloc:CompileLocation -> CompileLocation - val CompLocForImplicitMainMethod: cloc:CompileLocation -> CompileLocation - val CompLocForPrivateImplementationDetails: + val CleanUpGeneratedTypeName : nm:string -> string + val TypeNameForInitClass : cloc:CompileLocation -> string + val TypeNameForImplicitMainMethod : cloc:CompileLocation -> string + val TypeNameForPrivateImplementationDetails : cloc:CompileLocation -> string + val CompLocForInitClass : cloc:CompileLocation -> CompileLocation + val CompLocForImplicitMainMethod : cloc:CompileLocation -> CompileLocation + val CompLocForPrivateImplementationDetails : cloc:CompileLocation -> CompileLocation - val TypeRefForCompLoc: cloc:CompileLocation -> AbstractIL.IL.ILTypeRef - val mkILTyForCompLoc: cloc:CompileLocation -> AbstractIL.IL.ILType - val ComputeMemberAccess: hidden:bool -> AbstractIL.IL.ILMemberAccess - val ComputePublicTypeAccess: unit -> AbstractIL.IL.ILTypeDefAccess - val ComputeTypeAccess: + val TypeRefForCompLoc : cloc:CompileLocation -> AbstractIL.IL.ILTypeRef + val mkILTyForCompLoc : cloc:CompileLocation -> AbstractIL.IL.ILType + val ComputeMemberAccess : hidden:bool -> AbstractIL.IL.ILMemberAccess + val ComputePublicTypeAccess : unit -> AbstractIL.IL.ILTypeDefAccess + val ComputeTypeAccess : tref:AbstractIL.IL.ILTypeRef -> hidden:bool -> AbstractIL.IL.ILTypeDefAccess - [] + [] type TypeReprEnv = - - new: reprs:Map * count:int -> TypeReprEnv - static member ForTycon: tycon:TypedTree.Tycon -> TypeReprEnv - static member ForTyconRef: tycon:TypedTree.TyconRef -> TypeReprEnv - static member ForTypars: tps:TypedTree.Typar list -> TypeReprEnv - member Add: tps:TypedTree.Typar list -> TypeReprEnv - member AddOne: tp:TypedTree.Typar -> TypeReprEnv - member Item: tp:TypedTree.Typar * m:Range.range -> uint16 - member Count: int - static member Empty: TypeReprEnv - - val GenTyconRef: tcref:TypedTree.TyconRef -> TypedTree.CompiledTypeRepr + class + new : reprs:Map * count:int -> TypeReprEnv + static member ForTycon : tycon:TypedTree.Tycon -> TypeReprEnv + static member ForTyconRef : tycon:TypedTree.TyconRef -> TypeReprEnv + static member ForTypars : tps:TypedTree.Typar list -> TypeReprEnv + member Add : tps:TypedTree.Typar list -> TypeReprEnv + member AddOne : tp:TypedTree.Typar -> TypeReprEnv + member Item : tp:TypedTree.Typar * m:Range.range -> uint16 + member Count : int + static member Empty : TypeReprEnv + end + val GenTyconRef : tcref:TypedTree.TyconRef -> TypedTree.CompiledTypeRepr type VoidNotOK = | VoidNotOK | VoidOK - val voidCheck: + val voidCheck : m:Range.range -> g:TcGlobals.TcGlobals -> permits:VoidNotOK -> ty:TypedTree.TType -> unit type PtrsOK = | PtrTypesOK | PtrTypesNotOK - val GenReadOnlyAttributeIfNecessary: + val GenReadOnlyAttributeIfNecessary : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> AbstractIL.IL.ILAttribute option - val GenReadOnlyModReqIfNecessary: + val GenReadOnlyModReqIfNecessary : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> ilTy:AbstractIL.IL.ILType -> AbstractIL.IL.ILType - val GenTypeArgAux: + val GenTypeArgAux : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> tyarg:TypedTree.TType -> AbstractIL.IL.ILType - val GenTypeArgsAux: + val GenTypeArgsAux : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> tyargs:TypedTree.TType list -> AbstractIL.IL.ILType list - val GenTyAppAux: + val GenTyAppAux : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> repr:TypedTree.CompiledTypeRepr -> tinst:TypedTree.TType list -> AbstractIL.IL.ILType - val GenILTyAppAux: + val GenILTyAppAux : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> tref:AbstractIL.IL.ILTypeRef * boxity:AbstractIL.IL.ILBoxity * ilTypeOpt:AbstractIL.IL.ILType option -> tinst:TypedTree.TType list -> AbstractIL.IL.ILType - val GenNamedTyAppAux: + val GenNamedTyAppAux : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> ptrsOK:PtrsOK -> tcref:TypedTree.TyconRef -> tinst:TypedTree.TType list -> AbstractIL.IL.ILType - val GenTypeAux: + val GenTypeAux : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> voidOK:VoidNotOK -> ptrsOK:PtrsOK -> ty:TypedTree.TType -> AbstractIL.IL.ILType - val GenUnionCaseRef: + val GenUnionCaseRef : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> i:int -> fspecs:TypedTree.RecdField [] -> AbstractIL.Extensions.ILX.Types.IlxUnionField [] - val GenUnionRef: + val GenUnionRef : amap:Import.ImportMap -> m:Range.range -> tcref:TypedTree.TyconRef -> AbstractIL.Extensions.ILX.Types.IlxUnionRef - val ComputeUnionHasHelpers: + val ComputeUnionHasHelpers : g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> AbstractIL.Extensions.ILX.Types.IlxUnionHasHelpers - val GenUnionSpec: + val GenUnionSpec : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> tcref:TypedTree.TyconRef -> tyargs:TypedTree.TypeInst -> AbstractIL.Extensions.ILX.Types.IlxUnionSpec - val GenUnionCaseSpec: + val GenUnionCaseSpec : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> ucref:TypedTree.UnionCaseRef -> tyargs:TypedTree.TypeInst -> AbstractIL.Extensions.ILX.Types.IlxUnionSpec * int - val GenType: + val GenType : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> ty:TypedTree.TType -> AbstractIL.IL.ILType - val GenTypes: + val GenTypes : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> tys:TypedTree.TType list -> AbstractIL.IL.ILType list - val GenTypePermitVoid: + val GenTypePermitVoid : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> ty:TypedTree.TType -> AbstractIL.IL.ILType - val GenTypesPermitVoid: + val GenTypesPermitVoid : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> tys:TypedTree.TType list -> AbstractIL.IL.ILType list - val GenTyApp: + val GenTyApp : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> repr:TypedTree.CompiledTypeRepr -> tyargs:TypedTree.TType list -> AbstractIL.IL.ILType - val GenNamedTyApp: + val GenNamedTyApp : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> tcref:TypedTree.TyconRef -> tinst:TypedTree.TType list -> AbstractIL.IL.ILType - val GenReturnType: + val GenReturnType : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> returnTyOpt:TypedTree.TType option -> AbstractIL.IL.ILType - val GenParamType: + val GenParamType : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> isSlotSig:bool -> ty:TypedTree.TType -> AbstractIL.IL.ILType - val GenParamTypes: + val GenParamTypes : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> isSlotSig:bool -> tys:TypedTree.TType list -> AbstractIL.IL.ILType list - val GenTypeArgs: + val GenTypeArgs : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> tyargs:TypedTree.TypeInst -> AbstractIL.IL.ILGenericArgs - val GenTypePermitVoidAux: + val GenTypePermitVoidAux : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> ty:TypedTree.TType -> AbstractIL.IL.ILType - val GenFieldSpecForStaticField: + val GenFieldSpecForStaticField : isInteractive:bool * g:TcGlobals.TcGlobals * ilContainerTy:AbstractIL.IL.ILType * vspec:TypedTree.Val * nm:string * m:Range.range * cloc:CompileLocation * ilTy:AbstractIL.IL.ILType -> AbstractIL.IL.ILFieldSpec - val GenRecdFieldRef: + val GenRecdFieldRef : m:Range.range -> cenv:cenv -> tyenv:TypeReprEnv -> rfref:TypedTree.RecdFieldRef -> tyargs:TypedTree.TType list -> AbstractIL.IL.ILFieldSpec - val GenExnType: + val GenExnType : amap:Import.ImportMap -> m:Range.range -> tyenv:TypeReprEnv -> ecref:TypedTree.TyconRef -> AbstractIL.IL.ILType type ArityInfo = int list - [] + [] type IlxClosureInfo = { cloExpr: TypedTree.Expr cloName: string @@ -10978,7 +36042,7 @@ namespace FSharp.Compiler localTypeFuncContractFreeTypars: TypedTree.Typar list localTypeFuncDirectILGenericParams: AbstractIL.IL.ILGenericParameterDefs localTypeFuncInternalFreeTypars: TypedTree.Typar list } - [] + [] type ValStorage = | Null | StaticField of @@ -11005,27 +36069,27 @@ namespace FSharp.Compiler | NamedLocalIlxClosureInfoGenerator of (IlxGenEnv -> IlxClosureInfo) | NamedLocalIlxClosureInfoGenerated of IlxClosureInfo with - override ToString: unit -> string - + override ToString : unit -> string + end and ModuleStorage = { Vals: Lazy> SubModules: Lazy> } with - override ToString: unit -> string - + override ToString : unit -> string + end and BranchCallItem = | BranchCallClosure of ArityInfo | BranchCallMethod of ArityInfo * (TypedTree.TType * TypedTree.ArgReprInfo) list list * TypedTree.Typars * int * int * int with - override ToString: unit -> string - + override ToString : unit -> string + end and Mark = | Mark of AbstractIL.IL.ILCodeLabel with - member CodeLabel: AbstractIL.IL.ILCodeLabel - + member CodeLabel : AbstractIL.IL.ILCodeLabel + end and sequel = | EndFilter | LeaveHandler of (bool * int * Mark) @@ -11054,45 +36118,45 @@ namespace FSharp.Compiler withinSEH: bool isInLoop: bool } with - override ToString: unit -> string - - val discard: sequel - val discardAndReturnVoid: sequel - val SetIsInLoop: isInLoop:bool -> eenv:IlxGenEnv -> IlxGenEnv - val ReplaceTyenv: tyenv:TypeReprEnv -> eenv:IlxGenEnv -> IlxGenEnv - val EnvForTypars: tps:TypedTree.Typar list -> eenv:IlxGenEnv -> IlxGenEnv - val AddTyparsToEnv: + override ToString : unit -> string + end + val discard : sequel + val discardAndReturnVoid : sequel + val SetIsInLoop : isInLoop:bool -> eenv:IlxGenEnv -> IlxGenEnv + val ReplaceTyenv : tyenv:TypeReprEnv -> eenv:IlxGenEnv -> IlxGenEnv + val EnvForTypars : tps:TypedTree.Typar list -> eenv:IlxGenEnv -> IlxGenEnv + val AddTyparsToEnv : typars:TypedTree.Typar list -> eenv:IlxGenEnv -> IlxGenEnv - val AddSignatureRemapInfo: + val AddSignatureRemapInfo : _msg:'a -> rpi:TypedTreeOps.SignatureRepackageInfo * mhi:TypedTreeOps.SignatureHidingInfo -> eenv:IlxGenEnv -> IlxGenEnv - val OutputStorage: pps:System.IO.TextWriter -> s:ValStorage -> unit - val AddStorageForVal: + val OutputStorage : pps:System.IO.TextWriter -> s:ValStorage -> unit + val AddStorageForVal : g:TcGlobals.TcGlobals -> v:TypedTree.Val * s:Lazy -> eenv:IlxGenEnv -> IlxGenEnv - val AddStorageForLocalVals: + val AddStorageForLocalVals : g:TcGlobals.TcGlobals -> vals:(TypedTree.Val * ValStorage) list -> eenv:IlxGenEnv -> IlxGenEnv - val AddStorageForLocalWitness: + val AddStorageForLocalWitness : eenv:IlxGenEnv -> w:TypedTree.TraitWitnessInfo * s:ValStorage -> IlxGenEnv - val AddStorageForLocalWitnesses: + val AddStorageForLocalWitnesses : witnesses:(TypedTree.TraitWitnessInfo * ValStorage) list -> eenv:IlxGenEnv -> IlxGenEnv - val StorageForVal: + val StorageForVal : g:TcGlobals.TcGlobals -> m:Range.range -> v:TypedTree.Val -> eenv:IlxGenEnv -> ValStorage - val StorageForValRef: + val StorageForValRef : g:TcGlobals.TcGlobals -> m:Range.range -> v:TypedTree.ValRef -> eenv:IlxGenEnv -> ValStorage - val ComputeGenerateWitnesses: + val ComputeGenerateWitnesses : g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> bool - val TryStorageForWitness: + val TryStorageForWitness : _g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> w:TypedTree.TraitWitnessInfo -> ValStorage option - val IsValRefIsDllImport: + val IsValRefIsDllImport : g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val GetMethodSpecForMemberVal: + val GetMethodSpecForMemberVal : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> memberInfo:TypedTree.ValMemberInfo -> @@ -11102,13 +36166,13 @@ namespace FSharp.Compiler TypedTreeOps.CurriedArgInfos * TypedTree.ArgReprInfo list * TypedTree.ArgReprInfo * TypedTreeOps.TraitWitnessInfos * TypedTree.TType list * TypedTree.TType option - val ComputeFieldSpecForVal: + val ComputeFieldSpecForVal : optIntraAssemblyInfo:IlxGenIntraAssemblyInfo option * isInteractive:bool * g:TcGlobals.TcGlobals * ilTyForProperty:AbstractIL.IL.ILType * vspec:TypedTree.Val * nm:string * m:Range.range * cloc:CompileLocation * ilTy:AbstractIL.IL.ILType * ilGetterMethRef:AbstractIL.IL.ILMethodRef -> AbstractIL.IL.ILFieldSpec - val ComputeStorageForFSharpValue: + val ComputeStorageForFSharpValue : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> cloc:CompileLocation -> @@ -11117,158 +36181,158 @@ namespace FSharp.Compiler isInteractive:bool -> returnTy:TypedTree.TType -> vref:TypedTree.ValRef -> m:Range.range -> ValStorage - val ComputeStorageForFSharpMember: + val ComputeStorageForFSharpMember : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> topValInfo:TypedTree.ValReprInfo -> memberInfo:TypedTree.ValMemberInfo -> vref:TypedTree.ValRef -> m:Range.range -> ValStorage - val ComputeStorageForFSharpFunctionOrFSharpExtensionMember: + val ComputeStorageForFSharpFunctionOrFSharpExtensionMember : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> cloc:CompileLocation -> topValInfo:TypedTree.ValReprInfo -> vref:TypedTree.ValRef -> m:Range.range -> ValStorage - val IsFSharpValCompiledAsMethod: + val IsFSharpValCompiledAsMethod : TcGlobals.TcGlobals -> TypedTree.Val -> bool - val ComputeStorageForTopVal: + val ComputeStorageForTopVal : amap:Import.ImportMap * g:TcGlobals.TcGlobals * optIntraAssemblyInfo:IlxGenIntraAssemblyInfo option * isInteractive:bool * optShadowLocal:OptionalShadowLocal * vref:TypedTree.ValRef * cloc:CompileLocation -> ValStorage - val ComputeAndAddStorageForLocalTopVal: + val ComputeAndAddStorageForLocalTopVal : amap:Import.ImportMap * g:TcGlobals.TcGlobals * intraAssemblyFieldTable:IlxGenIntraAssemblyInfo * isInteractive:bool * optShadowLocal:OptionalShadowLocal -> cloc:CompileLocation -> v:TypedTree.Val -> eenv:IlxGenEnv -> IlxGenEnv - val ComputeStorageForNonLocalTopVal: + val ComputeStorageForNonLocalTopVal : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> cloc:CompileLocation -> modref:TypedTree.EntityRef -> v:TypedTree.Val -> ValStorage - val AddStorageForNonLocalModuleOrNamespaceRef: + val AddStorageForNonLocalModuleOrNamespaceRef : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> cloc:CompileLocation -> acc:IlxGenEnv -> modref:TypedTree.ModuleOrNamespaceRef -> modul:TypedTree.ModuleOrNamespace -> IlxGenEnv - val AddStorageForExternalCcu: + val AddStorageForExternalCcu : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> ccu:TypedTree.CcuThunk -> IlxGenEnv - val AddBindingsForLocalModuleType: + val AddBindingsForLocalModuleType : allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> cloc:CompileLocation -> eenv:'a -> mty:TypedTree.ModuleOrNamespaceType -> 'a - val AddExternalCcusToIlxGenEnv: + val AddExternalCcusToIlxGenEnv : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> ccus:TypedTree.CcuThunk list -> IlxGenEnv - val AddBindingsForTycon: + val AddBindingsForTycon : allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> cloc:CompileLocation -> tycon:TypedTree.Tycon -> eenv:'a -> 'a - val AddBindingsForModuleDefs: + val AddBindingsForModuleDefs : allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> cloc:CompileLocation -> eenv:'a -> mdefs:TypedTree.ModuleOrNamespaceExpr list -> 'a - val AddBindingsForModuleDef: + val AddBindingsForModuleDef : allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> cloc:CompileLocation -> eenv:'a -> x:TypedTree.ModuleOrNamespaceExpr -> 'a - val AddBindingsForModule: + val AddBindingsForModule : allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> cloc:CompileLocation -> x:TypedTree.ModuleOrNamespaceBinding -> eenv:'a -> 'a - val AddBindingsForModuleTopVals: + val AddBindingsForModuleTopVals : _g:'a -> allocVal:('b -> 'c -> 'c) -> _cloc:'d -> eenv:'c -> vs:'b list -> 'c - val AddIncrementalLocalAssemblyFragmentToIlxGenEnv: + val AddIncrementalLocalAssemblyFragmentToIlxGenEnv : amap:Import.ImportMap * isIncrementalFragment:bool * g:TcGlobals.TcGlobals * ccu:TypedTree.CcuThunk * fragName:string * intraAssemblyInfo:IlxGenIntraAssemblyInfo * eenv:IlxGenEnv * typedImplFiles:TypedTree.TypedImplFile list -> IlxGenEnv - val GenILSourceMarker: + val GenILSourceMarker : g:TcGlobals.TcGlobals -> m:Range.range -> AbstractIL.IL.ILSourceMarker - val GenPossibleILSourceMarker: + val GenPossibleILSourceMarker : cenv:cenv -> m:Range.range -> AbstractIL.IL.ILSourceMarker option - val HashRangeSorted: + val HashRangeSorted : ht:System.Collections.Generic.IDictionary<'a,(int * 'b)> -> 'b list - val MergeOptions: + val MergeOptions : m:Range.range -> o1:'a option -> o2:'a option -> 'a option - val MergePropertyPair: + val MergePropertyPair : m:Range.range -> pd:AbstractIL.IL.ILPropertyDef -> pdef:AbstractIL.IL.ILPropertyDef -> AbstractIL.IL.ILPropertyDef type PropKey = | PropKey of string * AbstractIL.IL.ILTypes * AbstractIL.IL.ILThisConvention - val AddPropertyDefToHash: + val AddPropertyDefToHash : m:Range.range -> ht:System.Collections.Generic.Dictionary -> pdef:AbstractIL.IL.ILPropertyDef -> unit - val MergePropertyDefs: + val MergePropertyDefs : m:Range.range -> ilPropertyDefs:#AbstractIL.IL.ILPropertyDef list -> AbstractIL.IL.ILPropertyDef list type TypeDefBuilder = - - new: tdef:AbstractIL.IL.ILTypeDef * + class + new : tdef:AbstractIL.IL.ILTypeDef * tdefDiscards:((AbstractIL.IL.ILMethodDef -> bool) * (AbstractIL.IL.ILPropertyDef -> bool)) option -> TypeDefBuilder - member AddEventDef: edef:AbstractIL.IL.ILEventDef -> unit - member AddFieldDef: ilFieldDef:AbstractIL.IL.ILFieldDef -> unit - member AddMethodDef: ilMethodDef:AbstractIL.IL.ILMethodDef -> unit + member AddEventDef : edef:AbstractIL.IL.ILEventDef -> unit + member AddFieldDef : ilFieldDef:AbstractIL.IL.ILFieldDef -> unit + member AddMethodDef : ilMethodDef:AbstractIL.IL.ILMethodDef -> unit member - AddOrMergePropertyDef: pdef:AbstractIL.IL.ILPropertyDef * + AddOrMergePropertyDef : pdef:AbstractIL.IL.ILPropertyDef * m:Range.range -> unit - member Close: unit -> AbstractIL.IL.ILTypeDef - member GetCurrentFields: unit -> seq + member Close : unit -> AbstractIL.IL.ILTypeDef + member GetCurrentFields : unit -> seq member - PrependInstructionsToSpecificMethodDef: cond:(AbstractIL.IL.ILMethodDef -> + PrependInstructionsToSpecificMethodDef : cond:(AbstractIL.IL.ILMethodDef -> bool) * instrs:AbstractIL.IL.ILInstr list * tag:AbstractIL.IL.ILSourceMarker option -> unit - member NestedTypeDefs: TypeDefsBuilder - + member NestedTypeDefs : TypeDefsBuilder + end and TypeDefsBuilder = - - new: unit -> TypeDefsBuilder + class + new : unit -> TypeDefsBuilder member - AddTypeDef: tdef:AbstractIL.IL.ILTypeDef * eliminateIfEmpty:bool * + AddTypeDef : tdef:AbstractIL.IL.ILTypeDef * eliminateIfEmpty:bool * addAtEnd:bool * tdefDiscards:((AbstractIL.IL.ILMethodDef -> bool) * (AbstractIL.IL.ILPropertyDef -> bool)) option -> unit - member Close: unit -> AbstractIL.IL.ILTypeDef list + member Close : unit -> AbstractIL.IL.ILTypeDef list member - FindNestedTypeDefBuilder: tref:AbstractIL.IL.ILTypeRef -> + FindNestedTypeDefBuilder : tref:AbstractIL.IL.ILTypeRef -> TypeDefBuilder - member FindNestedTypeDefsBuilder: path:string list -> TypeDefsBuilder - member FindTypeDefBuilder: nm:string -> TypeDefBuilder - + member FindNestedTypeDefsBuilder : path:string list -> TypeDefsBuilder + member FindTypeDefBuilder : nm:string -> TypeDefBuilder + end type AnonTypeGenerationTable = - - new: unit -> AnonTypeGenerationTable + class + new : unit -> AnonTypeGenerationTable member - Table: System.Collections.Generic.Dictionary - + end type AssemblyBuilder = - - new: cenv:cenv * anonTypeTable:AnonTypeGenerationTable -> + class + new : cenv:cenv * anonTypeTable:AnonTypeGenerationTable -> AssemblyBuilder member - AddEventDef: tref:AbstractIL.IL.ILTypeRef * + AddEventDef : tref:AbstractIL.IL.ILTypeRef * edef:AbstractIL.IL.ILEventDef -> unit member - AddExplicitInitToSpecificMethodDef: cond:(AbstractIL.IL.ILMethodDef -> + AddExplicitInitToSpecificMethodDef : cond:(AbstractIL.IL.ILMethodDef -> bool) * tref:AbstractIL.IL.ILTypeRef * fspec:AbstractIL.IL.ILFieldSpec * @@ -11277,136 +36341,136 @@ namespace FSharp.Compiler seqpt:AbstractIL.IL.ILInstr list -> unit member - AddFieldDef: tref:AbstractIL.IL.ILTypeRef * + AddFieldDef : tref:AbstractIL.IL.ILTypeRef * ilFieldDef:AbstractIL.IL.ILFieldDef -> unit - member AddInitializeScriptsInOrderToEntryPoint: unit -> unit + member AddInitializeScriptsInOrderToEntryPoint : unit -> unit member - AddMethodDef: tref:AbstractIL.IL.ILTypeRef * + AddMethodDef : tref:AbstractIL.IL.ILTypeRef * ilMethodDef:AbstractIL.IL.ILMethodDef -> unit member - AddOrMergePropertyDef: tref:AbstractIL.IL.ILTypeRef * + AddOrMergePropertyDef : tref:AbstractIL.IL.ILTypeRef * pdef:AbstractIL.IL.ILPropertyDef * m:Range.range -> unit member - AddReflectedDefinition: vspec:TypedTree.Val * expr:TypedTree.Expr -> + AddReflectedDefinition : vspec:TypedTree.Val * expr:TypedTree.Expr -> unit member - AddScriptInitFieldSpec: fieldSpec:AbstractIL.IL.ILFieldSpec * + AddScriptInitFieldSpec : fieldSpec:AbstractIL.IL.ILFieldSpec * range:Range.range -> unit member - AddTypeDef: tref:AbstractIL.IL.ILTypeRef * + AddTypeDef : tref:AbstractIL.IL.ILTypeRef * tdef:AbstractIL.IL.ILTypeDef * eliminateIfEmpty:bool * addAtEnd:bool * tdefDiscards:((AbstractIL.IL.ILMethodDef -> bool) * (AbstractIL.IL.ILPropertyDef -> bool)) option -> unit member - Close: unit -> + Close : unit -> AbstractIL.IL.ILTypeDef list * ((string * TypedTree.Val) * TypedTree.Expr) list member - GenerateAnonType: genToStringMethod:(AbstractIL.IL.ILType -> + GenerateAnonType : genToStringMethod:(AbstractIL.IL.ILType -> #seq) * anonInfo:TypedTree.AnonRecdTypeInfo -> unit member - GenerateRawDataValueType: cloc:CompileLocation * size:int -> + GenerateRawDataValueType : cloc:CompileLocation * size:int -> AbstractIL.IL.ILTypeSpec member - GetCurrentFields: tref:AbstractIL.IL.ILTypeRef -> + GetCurrentFields : tref:AbstractIL.IL.ILTypeRef -> seq member - GetExplicitEntryPointInfo: unit -> AbstractIL.IL.ILTypeRef option - member GrabExtraBindingsToGenerate: unit -> TypedTree.Binding list + GetExplicitEntryPointInfo : unit -> AbstractIL.IL.ILTypeRef option + member GrabExtraBindingsToGenerate : unit -> TypedTree.Binding list member - LookupAnonType: genToStringMethod:(AbstractIL.IL.ILType -> + LookupAnonType : genToStringMethod:(AbstractIL.IL.ILType -> #seq) * anonInfo:TypedTree.AnonRecdTypeInfo -> AbstractIL.IL.ILMethodRef * AbstractIL.IL.ILMethodRef [] * AbstractIL.IL.ILType member - ReplaceNameOfReflectedDefinition: vspec:TypedTree.Val * + ReplaceNameOfReflectedDefinition : vspec:TypedTree.Val * newName:string -> unit - member cenv: cenv - - val pop: i:int -> Pops - val Push: tys:Pushes -> Pushes - val Push0: Pushes - val FeeFee: cenv:cenv -> int - val FeeFeeInstr: + member cenv : cenv + end + val pop : i:int -> Pops + val Push : tys:Pushes -> Pushes + val Push0 : Pushes + val FeeFee : cenv:cenv -> int + val FeeFeeInstr : cenv:cenv -> doc:AbstractIL.IL.ILSourceDocument -> AbstractIL.IL.ILInstr type CodeGenBuffer = - - new: m:Range.range * mgbuf:AssemblyBuilder * methodName:string * + class + new : m:Range.range * mgbuf:AssemblyBuilder * methodName:string * alreadyUsedArgs:int -> CodeGenBuffer member - AllocLocal: ranges:(string * (Mark * Mark)) list * + AllocLocal : ranges:(string * (Mark * Mark)) list * ty:AbstractIL.IL.ILType * isFixed:bool -> int - member AssertEmptyStack: unit -> unit + member AssertEmptyStack : unit -> unit member - Close: unit -> + Close : unit -> ((string * (Mark * Mark)) list * AbstractIL.IL.ILType * bool) list * int * System.Collections.Generic.Dictionary * AbstractIL.IL.ILInstr [] * AbstractIL.IL.ILExceptionSpec list * bool - member DoPops: n:Pops -> unit - member DoPushes: pushes:Pushes -> unit + member DoPops : n:Pops -> unit + member DoPushes : pushes:Pushes -> unit member - EmitExceptionClause: clause:AbstractIL.IL.ILExceptionSpec -> unit + EmitExceptionClause : clause:AbstractIL.IL.ILExceptionSpec -> unit member - EmitInstr: pops:Pops * pushes:Pushes * i:AbstractIL.IL.ILInstr -> + EmitInstr : pops:Pops * pushes:Pushes * i:AbstractIL.IL.ILInstr -> unit member - EmitInstrs: pops:Pops * pushes:Pushes * is:AbstractIL.IL.ILInstr list -> + EmitInstrs : pops:Pops * pushes:Pushes * is:AbstractIL.IL.ILInstr list -> unit - member EmitSeqPoint: src:Range.range -> unit - member EmitStartOfHiddenCode: unit -> unit - member private EnsureNopBetweenDebugPoints: unit -> unit - member GenerateDelayMark: _nm:'b -> Mark - member GetCurrentStack: unit -> AbstractIL.IL.ILType list - member GetLastDebugPoint: unit -> Range.range option - member Mark: s:'a -> Mark - member - ReallocLocal: cond:(int -> + member EmitSeqPoint : src:Range.range -> unit + member EmitStartOfHiddenCode : unit -> unit + member private EnsureNopBetweenDebugPoints : unit -> unit + member GenerateDelayMark : _nm:'b -> Mark + member GetCurrentStack : unit -> AbstractIL.IL.ILType list + member GetLastDebugPoint : unit -> Range.range option + member Mark : s:'a -> Mark + member + ReallocLocal : cond:(int -> (string * (Mark * Mark)) list * AbstractIL.IL.ILType * bool -> bool) * ranges:(string * (Mark * Mark)) list * ty:AbstractIL.IL.ILType * isFixed:bool -> int * bool member - SetCodeLabelToCodeLabel: lab1:AbstractIL.IL.ILCodeLabel * + SetCodeLabelToCodeLabel : lab1:AbstractIL.IL.ILCodeLabel * lab2:AbstractIL.IL.ILCodeLabel -> unit - member SetCodeLabelToPC: lab:AbstractIL.IL.ILCodeLabel * pc:int -> unit - member SetMark: mark1:Mark * mark2:Mark -> unit - member SetMarkToHere: Mark -> unit - member SetStack: s:AbstractIL.IL.ILType list -> unit - member MethodName: string - member PreallocatedArgCount: int - member mgbuf: AssemblyBuilder - - module CG = - val EmitInstr: + member SetCodeLabelToPC : lab:AbstractIL.IL.ILCodeLabel * pc:int -> unit + member SetMark : mark1:Mark * mark2:Mark -> unit + member SetMarkToHere : Mark -> unit + member SetStack : s:AbstractIL.IL.ILType list -> unit + member MethodName : string + member PreallocatedArgCount : int + member mgbuf : AssemblyBuilder + end + module CG = begin + val EmitInstr : cgbuf:CodeGenBuffer -> pops:Pops -> pushes:Pushes -> i:AbstractIL.IL.ILInstr -> unit - val EmitInstrs: + val EmitInstrs : cgbuf:CodeGenBuffer -> pops:Pops -> pushes:Pushes -> is:AbstractIL.IL.ILInstr list -> unit - val EmitSeqPoint: cgbuf:CodeGenBuffer -> src:Range.range -> unit - val GenerateDelayMark: cgbuf:CodeGenBuffer -> nm:'a -> Mark - val SetMark: cgbuf:CodeGenBuffer -> m1:Mark -> m2:Mark -> unit - val SetMarkToHere: cgbuf:CodeGenBuffer -> m1:Mark -> unit - val SetStack: cgbuf:CodeGenBuffer -> s:AbstractIL.IL.ILType list -> unit - val GenerateMark: cgbuf:CodeGenBuffer -> s:'a -> Mark - - val GenString: cenv:cenv -> cgbuf:CodeGenBuffer -> s:string -> unit - val GenConstArray: + val EmitSeqPoint : cgbuf:CodeGenBuffer -> src:Range.range -> unit + val GenerateDelayMark : cgbuf:CodeGenBuffer -> nm:'a -> Mark + val SetMark : cgbuf:CodeGenBuffer -> m1:Mark -> m2:Mark -> unit + val SetMarkToHere : cgbuf:CodeGenBuffer -> m1:Mark -> unit + val SetStack : cgbuf:CodeGenBuffer -> s:AbstractIL.IL.ILType list -> unit + val GenerateMark : cgbuf:CodeGenBuffer -> s:'a -> Mark + end + val GenString : cenv:cenv -> cgbuf:CodeGenBuffer -> s:string -> unit + val GenConstArray : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> ilElementType:AbstractIL.IL.ILType -> data:'a [] -> write:(AbstractIL.Internal.ByteBuffer -> 'a -> unit) -> unit - val CodeGenThen: + val CodeGenThen : cenv:cenv -> mgbuf:AssemblyBuilder -> entryPointInfo:(TypedTree.ValRef * BranchCallItem) list * @@ -11416,139 +36480,139 @@ namespace FSharp.Compiler System.Collections.Generic.Dictionary * AbstractIL.IL.ILInstr [] * AbstractIL.IL.ILExceptionSpec list * AbstractIL.IL.ILLocalDebugInfo list * bool - val CodeGenMethod: + val CodeGenMethod : cenv:cenv -> mgbuf:AssemblyBuilder -> entryPointInfo:(TypedTree.ValRef * BranchCallItem) list * methodName:string * eenv:IlxGenEnv * alreadyUsedArgs:int * codeGenFunction:(CodeGenBuffer -> IlxGenEnv -> unit) * m:Range.range -> AbstractIL.IL.ILInstr [] * AbstractIL.IL.ILMethodBody - val StartDelayedLocalScope: nm:string -> cgbuf:CodeGenBuffer -> Mark * Mark - val StartLocalScope: nm:string -> cgbuf:CodeGenBuffer -> Mark * Mark - val LocalScope: + val StartDelayedLocalScope : nm:string -> cgbuf:CodeGenBuffer -> Mark * Mark + val StartLocalScope : nm:string -> cgbuf:CodeGenBuffer -> Mark * Mark + val LocalScope : nm:string -> cgbuf:CodeGenBuffer -> f:(Mark * Mark -> 'a) -> 'a - val compileSequenceExpressions: bool + val compileSequenceExpressions : bool type EmitDebugPointState = | SPAlways | SPSuppress - val BindingEmitsNoCode: + val BindingEmitsNoCode : g:TcGlobals.TcGlobals -> b:TypedTree.Binding -> bool - val ComputeDebugPointForBinding: + val ComputeDebugPointForBinding : g:TcGlobals.TcGlobals -> TypedTree.Binding -> bool * Range.range option * EmitDebugPointState - val BindingEmitsDebugPoint: + val BindingEmitsDebugPoint : g:TcGlobals.TcGlobals -> bind:TypedTree.Binding -> bool - val BindingIsInvisible: TypedTree.Binding -> bool - val BindingEmitsHiddenCode: TypedTree.Binding -> bool - val FirstEmittedCodeWillBeDebugPoint: + val BindingIsInvisible : TypedTree.Binding -> bool + val BindingEmitsHiddenCode : TypedTree.Binding -> bool + val FirstEmittedCodeWillBeDebugPoint : g:TcGlobals.TcGlobals -> sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool - val EmitDebugPointForWholeExpr: + val EmitDebugPointForWholeExpr : g:TcGlobals.TcGlobals -> sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool - val EmitHiddenCodeMarkerForWholeExpr: + val EmitHiddenCodeMarkerForWholeExpr : g:TcGlobals.TcGlobals -> sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool - val RangeOfDebugPointForWholeExpr: + val RangeOfDebugPointForWholeExpr : g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> Range.range - val DoesGenExprStartWithDebugPoint: + val DoesGenExprStartWithDebugPoint : g:TcGlobals.TcGlobals -> sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool - val ProcessDebugPointForExpr: + val ProcessDebugPointForExpr : cenv:cenv -> cgbuf:CodeGenBuffer -> sp:EmitDebugPointState -> expr:TypedTree.Expr -> unit - val GenExpr: + val GenExpr : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> sp:EmitDebugPointState -> expr:TypedTree.Expr -> sequel:sequel -> unit - val ProcessDelayedGenMethods: cenv:cenv -> unit - val GenExprWithStackGuard: + val ProcessDelayedGenMethods : cenv:cenv -> unit + val GenExprWithStackGuard : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> sp:EmitDebugPointState -> expr:TypedTree.Expr -> sequel:sequel -> unit - val GenExprPreSteps: + val GenExprPreSteps : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> sp:EmitDebugPointState -> expr:TypedTree.Expr -> sequel:sequel -> bool - val GenExprAux: + val GenExprAux : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> sp:EmitDebugPointState -> expr:TypedTree.Expr -> sequel:sequel -> unit - val GenExprs: + val GenExprs : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> es:TypedTree.Expr list -> unit - val CodeGenMethodForExpr: + val CodeGenMethodForExpr : cenv:cenv -> mgbuf:AssemblyBuilder -> spReq:EmitDebugPointState * entryPointInfo:(TypedTree.ValRef * BranchCallItem) list * methodName:string * eenv:IlxGenEnv * alreadyUsedArgs:int * expr0:TypedTree.Expr * sequel0:sequel -> AbstractIL.IL.ILMethodBody - val sequelAfterDiscard: sequel:sequel -> sequel option - val sequelIgnoringEndScopesAndDiscard: sequel:sequel -> sequel - val sequelIgnoreEndScopes: sequel:sequel -> sequel - val GenSequelEndScopes: cgbuf:CodeGenBuffer -> sequel:sequel -> unit - val StringOfSequel: sequel:sequel -> string - val GenSequel: + val sequelAfterDiscard : sequel:sequel -> sequel option + val sequelIgnoringEndScopesAndDiscard : sequel:sequel -> sequel + val sequelIgnoreEndScopes : sequel:sequel -> sequel + val GenSequelEndScopes : cgbuf:CodeGenBuffer -> sequel:sequel -> unit + val StringOfSequel : sequel:sequel -> string + val GenSequel : cenv:cenv -> cloc:CompileLocation -> cgbuf:CodeGenBuffer -> sequel:sequel -> unit - val GenConstant: + val GenConstant : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> c:TypedTree.Const * m:Range.range * ty:TypedTree.TType -> sequel:sequel -> unit - val GenUnitTy: + val GenUnitTy : cenv:cenv -> eenv:IlxGenEnv -> m:Range.range -> AbstractIL.IL.ILType - val GenUnit: + val GenUnit : cenv:cenv -> eenv:IlxGenEnv -> m:Range.range -> cgbuf:CodeGenBuffer -> unit - val GenUnitThenSequel: + val GenUnitThenSequel : cenv:cenv -> eenv:IlxGenEnv -> m:Range.range -> cloc:CompileLocation -> cgbuf:CodeGenBuffer -> sequel:sequel -> unit - val GenAllocTuple: + val GenAllocTuple : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> tupInfo:TypedTree.TupInfo * args:TypedTree.Exprs * argtys:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenGetTupleField: + val GenGetTupleField : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> tupInfo:TypedTree.TupInfo * e:TypedTree.Expr * tys:TypedTree.TypeInst * n:int * m:Range.range -> sequel:sequel -> unit - val GenAllocExn: + val GenAllocExn : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> c:TypedTree.TyconRef * args:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit - val GenAllocUnionCaseCore: + val GenAllocUnionCaseCore : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> c:TypedTree.UnionCaseRef * tyargs:TypedTree.TypeInst * n:int * m:Range.range -> unit - val GenAllocUnionCase: + val GenAllocUnionCase : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> c:TypedTree.UnionCaseRef * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit - val GenLinearExpr: + val GenLinearExpr : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> @@ -11556,150 +36620,150 @@ namespace FSharp.Compiler expr:TypedTree.Expr -> sequel:sequel -> preSteps:bool -> contf:(FakeUnit -> FakeUnit) -> FakeUnit - val GenAllocRecd: + val GenAllocRecd : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> ctorInfo:TypedTree.RecordConstructionInfo -> tcref:TypedTree.TyconRef * argtys:TypedTree.TypeInst * args:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit - val GenAllocAnonRecd: + val GenAllocAnonRecd : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> anonInfo:TypedTree.AnonRecdTypeInfo * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit - val GenGetAnonRecdField: + val GenGetAnonRecdField : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> anonInfo:TypedTree.AnonRecdTypeInfo * e:TypedTree.Expr * tyargs:TypedTree.TypeInst * n:int * m:Range.range -> sequel:sequel -> unit - val GenNewArraySimple: + val GenNewArraySimple : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> elems:TypedTree.Expr list * elemTy:TypedTree.TType * m:Range.range -> sequel:sequel -> unit - val GenNewArray: + val GenNewArray : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> elems:TypedTree.Expr list * elemTy:TypedTree.TType * m:Range.range -> sequel:sequel -> unit - val GenCoerce: + val GenCoerce : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e:TypedTree.Expr * tgty:TypedTree.TType * m:Range.range * srcty:TypedTree.TType -> sequel:sequel -> unit - val GenReraise: + val GenReraise : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> rtnty:TypedTree.TType * m:Range.range -> sequel:sequel -> unit - val GenGetExnField: + val GenGetExnField : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e:TypedTree.Expr * ecref:TypedTree.TyconRef * fieldNum:int * m:Range.range -> sequel:sequel -> unit - val GenSetExnField: + val GenSetExnField : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e:TypedTree.Expr * ecref:TypedTree.TyconRef * fieldNum:int * e2:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val UnionCodeGen: + val UnionCodeGen : cgbuf:CodeGenBuffer -> AbstractIL.Extensions.ILX.EraseUnions.ICodeGen - val GenUnionCaseProof: + val GenUnionCaseProof : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenGetUnionCaseField: + val GenGetUnionCaseField : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * tyargs:TypedTree.TypeInst * n:int * m:Range.range -> sequel:sequel -> unit - val GenGetUnionCaseFieldAddr: + val GenGetUnionCaseFieldAddr : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * tyargs:TypedTree.TypeInst * n:int * m:Range.range -> sequel:sequel -> unit - val GenGetUnionCaseTag: + val GenGetUnionCaseTag : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e:TypedTree.Expr * tcref:TypedTree.TyconRef * tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenSetUnionCaseField: + val GenSetUnionCaseField : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * tyargs:TypedTree.TypeInst * n:int * e2:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val GenGetRecdFieldAddr: + val GenGetRecdFieldAddr : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e:TypedTree.Expr * f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenGetStaticFieldAddr: + val GenGetStaticFieldAddr : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenGetRecdField: + val GenGetRecdField : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e:TypedTree.Expr * f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenSetRecdField: + val GenSetRecdField : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e1:TypedTree.Expr * f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * e2:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val GenGetStaticField: + val GenGetStaticField : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenSetStaticField: + val GenSetStaticField : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * e2:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val mk_field_pops: isStatic:bool -> n:int -> Pops - val GenFieldGet: + val mk_field_pops : isStatic:bool -> n:int -> Pops + val GenFieldGet : isStatic:bool -> cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> rfref:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * m:Range.range -> unit - val GenFieldStore: + val GenFieldStore : isStatic:bool -> cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> rfref:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenUntupledArgsDiscardingLoneUnit: + val GenUntupledArgsDiscardingLoneUnit : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> @@ -11707,67 +36771,67 @@ namespace FSharp.Compiler numObjArgs:int -> curriedArgInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> args:TypedTree.Expr list -> unit - val GenUntupledArgExpr: + val GenUntupledArgExpr : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> m:Range.range -> argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list -> expr:TypedTree.Expr -> unit - val GenWitnessArgFromTraitInfo: + val GenWitnessArgFromTraitInfo : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> m:Range.range -> traitInfo:TypedTree.TraitConstraintInfo -> unit - val GenWitnessArgFromWitnessInfo: + val GenWitnessArgFromWitnessInfo : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> m:Range.range -> witnessInfo:TypedTree.TraitWitnessInfo -> unit - val GenWitnessArgsFromWitnessInfos: + val GenWitnessArgsFromWitnessInfos : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> m:Range.range -> witnessInfos:seq -> unit - val GenWitnessArgs: + val GenWitnessArgs : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> m:Range.range -> tps:TypedTree.Typars -> tyargs:TypedTree.TType list -> unit - val GenApp: + val GenApp : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> f:TypedTree.Expr * fty:TypedTree.TType * tyargs:TypedTree.TypeInst * curriedArgs:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit - val CanTailcall: + val CanTailcall : hasStructObjArg:bool * ccallInfo:TypedTree.TType option * withinSEH:bool * hasByrefArg:bool * mustGenerateUnitAfterCall:bool * isDllImport:bool * isSelfInit:bool * makesNoCriticalTailcalls:bool * sequel:sequel -> AbstractIL.IL.ILTailcall - val GenNamedLocalTyFuncCall: + val GenNamedLocalTyFuncCall : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> ty:TypedTree.TType -> cloinfo:IlxClosureInfo -> tyargs:TypedTree.TypeInst -> m:Range.range -> TypedTree.TType - val GenCurriedArgsAndIndirectCall: + val GenCurriedArgsAndIndirectCall : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> functy:TypedTree.TType * tyargs:TypedTree.TypeInst * curriedArgs:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit - val GenIndirectCall: + val GenIndirectCall : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> functy:TypedTree.TType * tyargs:TypedTree.TType list * curriedArgs:TypedTree.Expr list * m:Range.range -> sequel:sequel -> unit - val GenTry: + val GenTry : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> @@ -11777,7 +36841,7 @@ namespace FSharp.Compiler int * IlxGenEnv * (AbstractIL.IL.ILType list * int list) * (AbstractIL.IL.ILCodeLabel * AbstractIL.IL.ILCodeLabel) * Mark * AbstractIL.IL.ILType - val GenTryWith: + val GenTryWith : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> @@ -11785,34 +36849,34 @@ namespace FSharp.Compiler vh:TypedTree.Val * eh:TypedTree.Expr * m:Range.range * resty:TypedTree.TType * spTry:SyntaxTree.DebugPointAtTry * spWith:SyntaxTree.DebugPointAtWith -> sequel:sequel -> unit - val GenTryFinally: + val GenTryFinally : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> bodyExpr:TypedTree.Expr * handlerExpr:TypedTree.Expr * m:Range.range * resty:TypedTree.TType * spTry:SyntaxTree.DebugPointAtTry * spFinally:SyntaxTree.DebugPointAtFinally -> sequel:sequel -> unit - val GenForLoop: + val GenForLoop : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> spFor:SyntaxTree.DebugPointAtFor * v:TypedTree.Val * e1:TypedTree.Expr * dir:TypedTree.ForLoopStyle * e2:TypedTree.Expr * loopBody:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val GenWhileLoop: + val GenWhileLoop : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> spWhile:SyntaxTree.DebugPointAtWhile * e1:TypedTree.Expr * e2:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val GenAsmCode: + val GenAsmCode : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> il:AbstractIL.IL.ILInstr list * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * returnTys:TypedTree.TTypes * m:Range.range -> sequel:sequel -> unit - val GenQuotation: + val GenQuotation : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> @@ -11822,7 +36886,7 @@ namespace FSharp.Compiler (AbstractIL.IL.ILTypeRef list * TypedTree.TTypes * TypedTree.Exprs * QuotationPickler.ExprData)) option ref * m:Range.range * ety:TypedTree.TType -> sequel:sequel -> unit - val GenILCall: + val GenILCall : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> @@ -11831,67 +36895,67 @@ namespace FSharp.Compiler ilMethRef:AbstractIL.IL.ILMethodRef * enclArgTys:TypedTree.TypeInst * methArgTys:TypedTree.TypeInst * argExprs:TypedTree.Exprs * returnTys:TypedTree.TTypes * m:Range.range -> sequel:sequel -> unit - val CommitCallSequel: + val CommitCallSequel : cenv:cenv -> eenv:IlxGenEnv -> m:Range.range -> cloc:CompileLocation -> cgbuf:CodeGenBuffer -> mustGenerateUnitAfterCall:bool -> sequel:sequel -> unit - val MakeNotSupportedExnExpr: + val MakeNotSupportedExnExpr : cenv:cenv -> eenv:IlxGenEnv -> argExpr:TypedTree.Expr * m:Range.range -> TypedTree.Expr - val GenTraitCall: + val GenTraitCall : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> traitInfo:TypedTree.TraitConstraintInfo * argExprs:TypedTree.Exprs * m:Range.range -> expr:TypedTree.Expr -> sequel:sequel -> unit - val GenGetAddrOfRefCellField: + val GenGetAddrOfRefCellField : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> e:TypedTree.Expr * ty:TypedTree.TType * m:Range.range -> sequel:sequel -> unit - val GenGetValAddr: + val GenGetValAddr : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> v:TypedTree.ValRef * m:Range.range -> sequel:sequel -> unit - val GenGetByref: + val GenGetByref : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> v:TypedTree.ValRef * m:Range.range -> sequel:sequel -> unit - val GenSetByref: + val GenSetByref : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> v:TypedTree.ValRef * e:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val GenDefaultValue: + val GenDefaultValue : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> ty:TypedTree.TType * m:Range.range -> unit - val GenGenericParam: + val GenGenericParam : cenv:cenv -> eenv:IlxGenEnv -> tp:TypedTree.Typar -> AbstractIL.IL.ILGenericParameterDef - val GenSlotParam: + val GenSlotParam : m:Range.range -> cenv:cenv -> eenv:IlxGenEnv -> TypedTree.SlotParam -> AbstractIL.IL.ILParameter - val GenFormalSlotsig: + val GenFormalSlotsig : m:Range.range -> cenv:cenv -> eenv:IlxGenEnv -> TypedTree.SlotSig -> AbstractIL.IL.ILType * AbstractIL.IL.ILParameter list * AbstractIL.IL.ILReturn - val instSlotParam: + val instSlotParam : inst:TypedTreeOps.TyparInst -> TypedTree.SlotParam -> TypedTree.SlotParam - val GenActualSlotsig: + val GenActualSlotsig : m:Range.range -> cenv:cenv -> eenv:IlxGenEnv -> @@ -11899,9 +36963,9 @@ namespace FSharp.Compiler methTyparsOfOverridingMethod:TypedTree.Typars -> methodParams:TypedTree.Val list -> AbstractIL.IL.ILParameter list * AbstractIL.IL.ILReturn - val GenNameOfOverridingMethod: + val GenNameOfOverridingMethod : cenv:cenv -> useMethodImpl:bool * slotsig:TypedTree.SlotSig -> string - val GenMethodImpl: + val GenMethodImpl : cenv:cenv -> eenv:IlxGenEnv -> useMethodImpl:bool * TypedTree.SlotSig -> @@ -11909,17 +36973,17 @@ namespace FSharp.Compiler string * (AbstractIL.IL.ILType * TypedTree.Typar list -> AbstractIL.IL.ILMethodImplDef) - val bindBaseOrThisVarOpt: + val bindBaseOrThisVarOpt : cenv:cenv -> eenv:IlxGenEnv -> baseValOpt:TypedTree.Val option -> IlxGenEnv - val fixupVirtualSlotFlags: + val fixupVirtualSlotFlags : mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef - val renameMethodDef: + val renameMethodDef : nameOfOverridingMethod:string -> mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef - val fixupMethodImplFlags: + val fixupMethodImplFlags : mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef - val GenObjectMethod: + val GenObjectMethod : cenv:cenv -> eenvinner:IlxGenEnv -> cgbuf:CodeGenBuffer -> @@ -11929,7 +36993,7 @@ namespace FSharp.Compiler (AbstractIL.IL.ILType * TypedTree.Typar list -> AbstractIL.IL.ILMethodImplDef) * TypedTree.Typars) * AbstractIL.IL.ILMethodDef) list - val GenObjectExpr: + val GenObjectExpr : cenv:cenv -> cgbuf:CodeGenBuffer -> eenvouter:IlxGenEnv -> @@ -11938,7 +37002,7 @@ namespace FSharp.Compiler basecall:TypedTree.Expr * overrides:TypedTree.ObjExprMethod list * interfaceImpls:(TypedTree.TType * TypedTree.ObjExprMethod list) list * m:Range.range -> sequel:sequel -> unit - val GenSequenceExpr: + val GenSequenceExpr : cenv:cenv -> cgbuf:CodeGenBuffer -> eenvouter:IlxGenEnv -> @@ -11947,7 +37011,7 @@ namespace FSharp.Compiler generateNextExpr:TypedTree.Expr * closeExpr:TypedTree.Expr * checkCloseExpr:TypedTree.Expr * seqElemTy:TypedTree.TType * m:Range.range -> sequel:sequel -> unit - val GenClosureTypeDefs: + val GenClosureTypeDefs : cenv:cenv -> tref:AbstractIL.IL.ILTypeRef * ilGenParams:AbstractIL.IL.ILGenericParameterDefs * @@ -11960,7 +37024,7 @@ namespace FSharp.Compiler ilIntfTys:AbstractIL.IL.ILType list * cloSpec:AbstractIL.Extensions.ILX.Types.IlxClosureSpec option -> AbstractIL.IL.ILTypeDef list - val GenStaticDelegateClosureTypeDefs: + val GenStaticDelegateClosureTypeDefs : cenv:cenv -> tref:AbstractIL.IL.ILTypeRef * ilGenParams:AbstractIL.IL.ILGenericParameterDefs * @@ -11973,40 +37037,40 @@ namespace FSharp.Compiler ilIntfTys:AbstractIL.IL.ILType list * staticCloInfo:AbstractIL.Extensions.ILX.Types.IlxClosureSpec option -> AbstractIL.IL.ILTypeDef list - val GenGenericParams: + val GenGenericParams : cenv:cenv -> eenv:IlxGenEnv -> tps:TypedTree.Typar list -> AbstractIL.IL.ILGenericParameterDefs - val GenGenericArgs: + val GenGenericArgs : m:Range.range -> tyenv:TypeReprEnv -> tps:TypedTree.Typar list -> AbstractIL.IL.ILGenericArgs - val GenLambdaClosure: + val GenLambdaClosure : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> isLocalTypeFunc:bool -> thisVars:TypedTree.ValRef list -> expr:TypedTree.Expr -> IlxClosureInfo * Range.range - val GenClosureAlloc: + val GenClosureAlloc : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> cloinfo:IlxClosureInfo * m:Range.range -> unit - val GenLambda: + val GenLambda : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> isLocalTypeFunc:bool -> thisVars:TypedTree.ValRef list -> expr:TypedTree.Expr -> sequel:sequel -> unit - val GenTypeOfVal: + val GenTypeOfVal : cenv:cenv -> eenv:IlxGenEnv -> v:TypedTree.Val -> AbstractIL.IL.ILType - val GenFreevar: + val GenFreevar : cenv:cenv -> m:Range.range -> eenvouter:IlxGenEnv -> tyenvinner:TypeReprEnv -> fv:TypedTree.Val -> AbstractIL.IL.ILType - val GetIlxClosureFreeVars: + val GetIlxClosureFreeVars : cenv:cenv -> m:Range.range -> thisVars:TypedTree.ValRef list -> @@ -12019,7 +37083,7 @@ namespace FSharp.Compiler AbstractIL.IL.ILTypeRef * AbstractIL.Extensions.ILX.Types.IlxClosureFreeVar [] * IlxGenEnv - val GetIlxClosureInfo: + val GetIlxClosureInfo : cenv:cenv -> m:Range.range -> isLocalTypeFunc:bool -> @@ -12028,9 +37092,9 @@ namespace FSharp.Compiler eenvouter:IlxGenEnv -> expr:TypedTree.Expr -> IlxClosureInfo * TypedTree.Expr * IlxGenEnv - val IsNamedLocalTypeFuncVal: + val IsNamedLocalTypeFuncVal : g:TcGlobals.TcGlobals -> v:TypedTree.Val -> expr:TypedTree.Expr -> bool - val GenNamedLocalTypeFuncContractInfo: + val GenNamedLocalTypeFuncContractInfo : cenv:cenv -> eenv:IlxGenEnv -> m:Range.range -> @@ -12038,20 +37102,20 @@ namespace FSharp.Compiler AbstractIL.IL.ILGenericParameterDef list * AbstractIL.IL.ILGenericParameterDefs * AbstractIL.IL.ILTypeSpec * AbstractIL.IL.ILType - val GenDelegateExpr: + val GenDelegateExpr : cenv:cenv -> cgbuf:CodeGenBuffer -> eenvouter:IlxGenEnv -> expr:TypedTree.Expr -> TypedTree.ObjExprMethod * m:Range.range -> sequel:sequel -> unit - val GenStaticOptimization: + val GenStaticOptimization : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> constraints:TypedTree.StaticOptimization list * e2:TypedTree.Expr * e3:TypedTree.Expr * _m:Range.range -> sequel:sequel -> unit - val IsSequelImmediate: sequel:sequel -> bool - val GenJoinPoint: + val IsSequelImmediate : sequel:sequel -> bool + val GenJoinPoint : cenv:cenv -> cgbuf:CodeGenBuffer -> pos:string -> @@ -12060,7 +37124,7 @@ namespace FSharp.Compiler m:Range.range -> sequel:sequel -> sequel * Mark * AbstractIL.IL.ILType list * sequel - val GenDecisionTreeAndTargets: + val GenDecisionTreeAndTargets : cenv:cenv -> cgbuf:CodeGenBuffer -> stackAtTargets:AbstractIL.IL.ILType list -> @@ -12069,7 +37133,7 @@ namespace FSharp.Compiler targets:TypedTree.DecisionTreeTarget array -> repeatSP:(unit -> unit) -> sequel:sequel -> contf:(FakeUnit -> FakeUnit) -> FakeUnit - val GenPostponedDecisionTreeTargets: + val GenPostponedDecisionTreeTargets : cenv:cenv -> cgbuf:CodeGenBuffer -> targetInfos:System.Collections.Generic.KeyValuePair list -> stackAtTargets:AbstractIL.IL.ILType list -> sequel:sequel -> contf:(FakeUnit -> FakeUnit) -> FakeUnit - val TryFindTargetInfo: + val TryFindTargetInfo : targetInfos:Lib.IntMap<'a * 'b> -> n:int -> 'a option - val GenDecisionTreeAndTargetsInner: + val GenDecisionTreeAndTargetsInner : cenv:cenv -> cgbuf:CodeGenBuffer -> inplabOpt:Mark option -> @@ -12115,8 +37179,8 @@ namespace FSharp.Compiler TypedTree.Bindings * Mark * Mark) * bool)> -> FakeUnit) -> FakeUnit - val GetTarget: targets:'c [] -> n:int -> 'c - val GenDecisionTreeSuccess: + val GetTarget : targets:'c [] -> n:int -> 'c + val GenDecisionTreeSuccess : cenv:cenv -> cgbuf:CodeGenBuffer -> inplabOpt:Mark option -> @@ -12147,7 +37211,7 @@ namespace FSharp.Compiler Mark) * bool)> * (IlxGenEnv * EmitDebugPointState * TypedTree.Expr * sequel) option - val GenDecisionTreeTarget: + val GenDecisionTreeTarget : cenv:cenv -> cgbuf:CodeGenBuffer -> stackAtTargets:AbstractIL.IL.ILType list -> @@ -12155,10 +37219,10 @@ namespace FSharp.Compiler eenvAtTarget:IlxGenEnv * successExpr:TypedTree.Expr * spTarget:SyntaxTree.DebugPointForTarget * repeatSP:(unit -> unit) * vs:TypedTree.Val list * binds:TypedTree.Bindings * startScope:Mark * - Scope:Mark -> + endScope:Mark -> sequel:sequel -> IlxGenEnv * EmitDebugPointState * TypedTree.Expr * sequel - val GenDecisionTreeSwitch: + val GenDecisionTreeSwitch : cenv:cenv -> cgbuf:CodeGenBuffer -> inplabOpt:Mark option -> @@ -12192,7 +37256,7 @@ namespace FSharp.Compiler Mark * Mark) * bool)> -> FakeUnit) -> FakeUnit - val GenDecisionTreeCases: + val GenDecisionTreeCases : cenv:cenv -> cgbuf:CodeGenBuffer -> stackAtTargets:AbstractIL.IL.ILType list -> @@ -12223,8 +37287,8 @@ namespace FSharp.Compiler Mark * Mark) * bool)> -> FakeUnit) -> FakeUnit - val ( |BoolExpr|_| ): _arg42:TypedTree.Expr -> bool option - val GenDecisionTreeTest: + val ( |BoolExpr|_| ) : _arg42:TypedTree.Expr -> bool option + val GenDecisionTreeTest : cenv:cenv -> cloc:CompileLocation -> cgbuf:CodeGenBuffer -> @@ -12261,50 +37325,50 @@ namespace FSharp.Compiler Mark * Mark) * bool)> -> FakeUnit) -> FakeUnit - val GenLetRecFixup: + val GenLetRecFixup : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> ilxCloSpec:AbstractIL.Extensions.ILX.Types.IlxClosureSpec * e:TypedTree.Expr * ilField:AbstractIL.IL.ILFieldSpec * e2:TypedTree.Expr * _m:'d -> unit - val GenLetRecBindings: + val GenLetRecBindings : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> allBinds:TypedTree.Bindings * m:Range.range -> unit - val GenLetRec: + val GenLetRec : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> binds:TypedTree.Bindings * body:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val GenDebugPointForBind: + val GenDebugPointForBind : cenv:cenv -> cgbuf:CodeGenBuffer -> bind:TypedTree.Binding -> EmitDebugPointState - val GenBinding: + val GenBinding : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> bind:TypedTree.Binding -> unit - val ComputeMemberAccessRestrictedBySig: + val ComputeMemberAccessRestrictedBySig : eenv:IlxGenEnv -> vspec:TypedTree.Val -> AbstractIL.IL.ILMemberAccess - val ComputeMethodAccessRestrictedBySig: + val ComputeMethodAccessRestrictedBySig : eenv:IlxGenEnv -> vspec:TypedTree.Val -> AbstractIL.IL.ILMemberAccess - val GenBindingAfterDebugPoint: + val GenBindingAfterDebugPoint : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> sp:EmitDebugPointState -> TypedTree.Binding -> startScopeMarkOpt:Mark option -> unit - val GenMarshal: + val GenMarshal : cenv:cenv -> attribs:TypedTree.Attrib list -> AbstractIL.IL.ILNativeType option * TypedTree.Attrib list - val GenParamAttribs: + val GenParamAttribs : cenv:cenv -> paramTy:TypedTree.TType -> attribs:TypedTree.Attribs -> bool * bool * bool * AbstractIL.IL.ILFieldInit option * AbstractIL.IL.ILNativeType option * TypedTree.Attribs - val GenParams: + val GenParams : cenv:cenv -> eenv:IlxGenEnv -> m:Range.range -> @@ -12314,13 +37378,13 @@ namespace FSharp.Compiler methArgTys:TypedTree.TType list -> implValsOpt:TypedTree.Val list option -> AbstractIL.IL.ILParameter list - val GenReturnInfo: + val GenReturnInfo : cenv:cenv -> eenv:IlxGenEnv -> returnTy:TypedTree.TType option -> ilRetTy:AbstractIL.IL.ILType -> retInfo:TypedTree.ArgReprInfo -> AbstractIL.IL.ILReturn - val GenPropertyForMethodDef: + val GenPropertyForMethodDef : compileAsInstance:bool -> tref:AbstractIL.IL.ILTypeRef -> mdef:AbstractIL.IL.ILMethodDef -> @@ -12330,7 +37394,7 @@ namespace FSharp.Compiler ilPropTy:AbstractIL.IL.ILType -> ilAttrs:AbstractIL.IL.ILAttributes -> compiledName:string option -> AbstractIL.IL.ILPropertyDef - val GenEventForProperty: + val GenEventForProperty : cenv:cenv -> eenvForMeth:IlxGenEnv -> mspec:AbstractIL.IL.ILMethodSpec -> @@ -12338,21 +37402,21 @@ namespace FSharp.Compiler ilAttrsThatGoOnPrimaryItem:AbstractIL.IL.ILAttribute list -> m:Range.range -> returnTy:TypedTree.TType -> AbstractIL.IL.ILEventDef - val ComputeUseMethodImpl: + val ComputeUseMethodImpl : cenv:cenv -> v:TypedTree.Val * slotsig:TypedTree.SlotSig -> bool - val ComputeMethodImplNameFixupForMemberBinding: + val ComputeMethodImplNameFixupForMemberBinding : cenv:cenv -> v:TypedTree.Val * memberInfo:TypedTree.ValMemberInfo -> string option - val ComputeFlagFixupsForMemberBinding: + val ComputeFlagFixupsForMemberBinding : cenv:cenv -> v:TypedTree.Val * memberInfo:TypedTree.ValMemberInfo -> (#AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef) list - val ComputeMethodImplAttribs: + val ComputeMethodImplAttribs : cenv:cenv -> _v:TypedTree.Val -> attrs:TypedTree.Attribs -> bool * bool * bool * bool * TypedTree.Attrib list - val DelayGenMethodForBinding: + val DelayGenMethodForBinding : cenv:cenv -> mgbuf:AssemblyBuilder -> eenv:IlxGenEnv -> @@ -12363,7 +37427,7 @@ namespace FSharp.Compiler TypedTree.ArgReprInfo * TypedTree.ValReprInfo * TypedTree.Val option * TypedTree.Val option * TypedTree.Typars * TypedTree.Val list * TypedTree.Expr * TypedTree.TType -> unit - val GenMethodForBinding: + val GenMethodForBinding : cenv:cenv -> mgbuf:AssemblyBuilder -> eenv:IlxGenEnv -> @@ -12378,20 +37442,20 @@ namespace FSharp.Compiler baseValOpt:TypedTree.Val option * methLambdaTypars:TypedTree.Typars * methLambdaVars:TypedTree.Val list * methLambdaBody:TypedTree.Expr * returnTy:TypedTree.TType -> unit - val GenPInvokeMethod: + val GenPInvokeMethod : nm:string * dll:string * namedArgs:TypedTree.AttribNamedArg list -> bool * AbstractIL.IL.MethodBody - val GenBindings: + val GenBindings : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> binds:TypedTree.Bindings -> unit - val GenSetVal: + val GenSetVal : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> vref:TypedTree.ValRef * e:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val GenGetValRefAndSequel: + val GenGetValRefAndSequel : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> @@ -12399,35 +37463,35 @@ namespace FSharp.Compiler v:TypedTree.ValRef -> storeSequel:(TypedTree.TypeInst * TypedTree.Exprs * Range.range * sequel) option -> unit - val GenGetVal: + val GenGetVal : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> v:TypedTree.ValRef * m:Range.range -> sequel:sequel -> unit - val GenBindingRhs: + val GenBindingRhs : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> sp:EmitDebugPointState -> vspec:TypedTree.Val -> e:TypedTree.Expr -> unit - val CommitStartScope: + val CommitStartScope : cgbuf:CodeGenBuffer -> startScopeMarkOpt:Mark option -> unit - val EmitInitLocal: + val EmitInitLocal : cgbuf:CodeGenBuffer -> ty:AbstractIL.IL.ILType -> idx:int -> unit - val EmitSetLocal: cgbuf:CodeGenBuffer -> idx:int -> unit - val EmitGetLocal: + val EmitSetLocal : cgbuf:CodeGenBuffer -> idx:int -> unit + val EmitGetLocal : cgbuf:CodeGenBuffer -> ty:AbstractIL.IL.ILType -> idx:int -> unit - val EmitSetStaticField: + val EmitSetStaticField : cgbuf:CodeGenBuffer -> fspec:AbstractIL.IL.ILFieldSpec -> unit - val EmitGetStaticFieldAddr: + val EmitGetStaticFieldAddr : cgbuf:CodeGenBuffer -> ty:AbstractIL.IL.ILType -> fspec:AbstractIL.IL.ILFieldSpec -> unit - val EmitGetStaticField: + val EmitGetStaticField : cgbuf:CodeGenBuffer -> ty:AbstractIL.IL.ILType -> fspec:AbstractIL.IL.ILFieldSpec -> unit - val GenSetStorage: + val GenSetStorage : m:Range.range -> cgbuf:CodeGenBuffer -> storage:ValStorage -> unit - val CommitGetStorageSequel: + val CommitGetStorageSequel : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> @@ -12436,7 +37500,7 @@ namespace FSharp.Compiler localCloInfo:Ref option -> storeSequel:(TypedTree.TType list * TypedTree.Expr list * Range.range * sequel) option -> unit - val GenGetStorageAndSequel: + val GenGetStorageAndSequel : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> @@ -12445,11 +37509,11 @@ namespace FSharp.Compiler storage:ValStorage -> storeSequel:(TypedTree.TType list * TypedTree.Expr list * Range.range * sequel) option -> unit - val GenGetLocalVals: + val GenGetLocalVals : cenv:cenv -> cgbuf:CodeGenBuffer -> eenvouter:IlxGenEnv -> m:Range.range -> fvs:TypedTree.Val list -> unit - val GenGetLocalVal: + val GenGetLocalVal : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> @@ -12457,7 +37521,7 @@ namespace FSharp.Compiler vspec:TypedTree.Val -> storeSequel:(TypedTree.TType list * TypedTree.Expr list * Range.range * sequel) option -> unit - val GenGetLocalVRef: + val GenGetLocalVRef : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> @@ -12465,78 +37529,78 @@ namespace FSharp.Compiler vref:TypedTree.ValRef -> storeSequel:(TypedTree.TType list * TypedTree.Expr list * Range.range * sequel) option -> unit - val GenStoreVal: + val GenStoreVal : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> m:Range.range -> vspec:TypedTree.Val -> unit - val AllocLocal: + val AllocLocal : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> compgen:bool -> v:string * ty:AbstractIL.IL.ILType * isFixed:bool -> Mark * Mark -> int * bool * IlxGenEnv - val AllocLocalVal: + val AllocLocalVal : cenv:cenv -> cgbuf:CodeGenBuffer -> v:TypedTree.Val -> eenv:IlxGenEnv -> repr:TypedTree.Expr option -> Mark * Mark -> ValStorage option * IlxGenEnv - val AllocStorageForBind: + val AllocStorageForBind : cenv:cenv -> cgbuf:CodeGenBuffer -> Mark * Mark -> eenv:IlxGenEnv -> bind:TypedTree.Binding -> IlxGenEnv - val AllocStorageForBinds: + val AllocStorageForBinds : cenv:cenv -> cgbuf:CodeGenBuffer -> Mark * Mark -> eenv:IlxGenEnv -> binds:TypedTree.Bindings -> IlxGenEnv - val AllocValForBind: + val AllocValForBind : cenv:cenv -> cgbuf:CodeGenBuffer -> Mark * Mark -> eenv:IlxGenEnv -> TypedTree.Binding -> ValStorage option * IlxGenEnv - val AllocTopValWithinExpr: + val AllocTopValWithinExpr : cenv:cenv -> cgbuf:CodeGenBuffer -> cloc:CompileLocation -> Mark * Mark -> v:TypedTree.Val -> eenv:IlxGenEnv -> IlxGenEnv - val EmitSaveStack: + val EmitSaveStack : cenv:cenv -> cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> m:Range.range -> Mark * Mark -> (AbstractIL.IL.ILType list * int list) * IlxGenEnv - val EmitRestoreStack: + val EmitRestoreStack : cgbuf:CodeGenBuffer -> savedStack:AbstractIL.IL.ILType list * savedStackLocals:int list -> unit - val GenAttribArg: + val GenAttribArg : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> x:TypedTree.Expr -> ilArgTy:AbstractIL.IL.ILType -> AbstractIL.IL.ILAttribElem - val GenAttr: + val GenAttr : amap:Import.ImportMap -> g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> TypedTree.Attrib -> AbstractIL.IL.ILAttribute - val GenAttrs: + val GenAttrs : cenv:cenv -> eenv:IlxGenEnv -> attrs:TypedTree.Attribs -> AbstractIL.IL.ILAttribute list - val GenCompilationArgumentCountsAttr: + val GenCompilationArgumentCountsAttr : cenv:cenv -> v:TypedTree.Val -> AbstractIL.IL.ILAttribute list - val CreatePermissionSets: + val CreatePermissionSets : cenv:cenv -> eenv:IlxGenEnv -> securityAttributes:TypedTree.Attrib list -> AbstractIL.IL.ILSecurityDecl list - val GenTypeDefForCompLoc: + val GenTypeDefForCompLoc : cenv:cenv * eenv:IlxGenEnv * mgbuf:AssemblyBuilder * cloc:CompileLocation * hidden:bool * attribs:TypedTree.Attribs * initTrigger:AbstractIL.IL.ILTypeInit * eliminateIfEmpty:bool * addAtEnd:bool -> unit - val GenModuleExpr: + val GenModuleExpr : cenv:cenv -> cgbuf:CodeGenBuffer -> qname:SyntaxTree.QualifiedNameOfFile -> @@ -12544,7 +37608,7 @@ namespace FSharp.Compiler AbstractIL.IL.ILInstr list -> AbstractIL.IL.ILInstr list -> unit)> -> eenv:IlxGenEnv -> x:TypedTree.ModuleOrNamespaceExprWithSig -> unit - val GenModuleDefs: + val GenModuleDefs : cenv:cenv -> cgbuf:CodeGenBuffer -> qname:SyntaxTree.QualifiedNameOfFile -> @@ -12553,7 +37617,7 @@ namespace FSharp.Compiler AbstractIL.IL.ILInstr list -> unit)> -> eenv:IlxGenEnv -> mdefs:TypedTree.ModuleOrNamespaceExpr list -> unit - val GenModuleDef: + val GenModuleDef : cenv:cenv -> cgbuf:CodeGenBuffer -> qname:SyntaxTree.QualifiedNameOfFile -> @@ -12561,7 +37625,7 @@ namespace FSharp.Compiler AbstractIL.IL.ILInstr list -> AbstractIL.IL.ILInstr list -> unit)> -> eenv:IlxGenEnv -> x:TypedTree.ModuleOrNamespaceExpr -> unit - val GenModuleBinding: + val GenModuleBinding : cenv:cenv -> cgbuf:CodeGenBuffer -> qname:SyntaxTree.QualifiedNameOfFile -> @@ -12570,60 +37634,60 @@ namespace FSharp.Compiler AbstractIL.IL.ILInstr list -> unit)> -> eenv:IlxGenEnv -> m:Range.range -> x:TypedTree.ModuleOrNamespaceBinding -> unit - val GenImplFile: + val GenImplFile : cenv:cenv -> mgbuf:AssemblyBuilder -> mainInfoOpt:TypedTree.Attribs option -> eenv:IlxGenEnv -> implFile:TypedTree.TypedImplFileAfterOptimization -> IlxGenEnv - val GenForceWholeFileInitializationAsPartOfCCtor: + val GenForceWholeFileInitializationAsPartOfCCtor : cenv:cenv -> mgbuf:AssemblyBuilder -> lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> AbstractIL.IL.ILInstr list -> AbstractIL.IL.ILInstr list -> unit)> -> tref:AbstractIL.IL.ILTypeRef -> m:Range.range -> unit - val GenEqualsOverrideCallingIComparable: + val GenEqualsOverrideCallingIComparable : cenv:cenv -> tcref:TypedTree.TyconRef * ilThisTy:AbstractIL.IL.ILType * _ilThatTy:'f -> AbstractIL.IL.ILMethodDef - val GenFieldInit: + val GenFieldInit : m:Range.range -> c:TypedTree.Const -> AbstractIL.IL.ILFieldInit - val GenWitnessParams: + val GenWitnessParams : cenv:cenv -> eenv:IlxGenEnv -> m:Range.range -> witnessInfos:TypedTreeOps.TraitWitnessInfos -> AbstractIL.IL.ILParameter list - val GenAbstractBinding: + val GenAbstractBinding : cenv:cenv -> eenv:IlxGenEnv -> tref:AbstractIL.IL.ILTypeRef -> vref:TypedTree.ValRef -> AbstractIL.IL.ILMethodDef list * AbstractIL.IL.ILPropertyDef list * AbstractIL.IL.ILEventDef list - val GenToStringMethod: + val GenToStringMethod : cenv:cenv -> eenv:IlxGenEnv -> ilThisTy:AbstractIL.IL.ILType -> m:Range.range -> AbstractIL.IL.ILMethodDef list - val GenTypeDef: + val GenTypeDef : cenv:cenv -> mgbuf:AssemblyBuilder -> lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> AbstractIL.IL.ILInstr list -> AbstractIL.IL.ILInstr list -> unit)> -> eenv:IlxGenEnv -> m:Range.range -> tycon:TypedTree.Tycon -> unit - val GenExnDef: + val GenExnDef : cenv:cenv -> mgbuf:AssemblyBuilder -> eenv:IlxGenEnv -> m:Range.range -> exnc:TypedTree.Tycon -> unit - val CodegenAssembly: + val CodegenAssembly : cenv:cenv -> eenv:IlxGenEnv -> mgbuf:AssemblyBuilder -> implFiles:TypedTree.TypedImplFileAfterOptimization list -> unit - val GetEmptyIlxGenEnv: + val GetEmptyIlxGenEnv : g:TcGlobals.TcGlobals -> ccu:TypedTree.CcuThunk -> IlxGenEnv type IlxGenResults = { ilTypeDefs: AbstractIL.IL.ILTypeDef list @@ -12632,7 +37696,7 @@ namespace FSharp.Compiler topAssemblyAttrs: TypedTree.Attribs permissionSets: AbstractIL.IL.ILSecurityDecl list quotationResourceInfo: (AbstractIL.IL.ILTypeRef list * byte []) list } - val GenerateCode: + val GenerateCode : cenv:cenv * anonTypeTable:AnonTypeGenerationTable * eenv:IlxGenEnv * TypedTree.TypedAssemblyAfterOptimization * assemAttribs:TypedTree.Attribs * moduleAttribs:TypedTree.Attribs -> IlxGenResults @@ -12642,151 +37706,154 @@ namespace FSharp.Compiler AbstractIL.IL.ILMethodRef -> System.Reflection.MethodInfo LookupTypeRef: AbstractIL.IL.ILTypeRef -> System.Type LookupType: AbstractIL.IL.ILType -> System.Type } - val defaultOf: (System.Type -> obj) - val LookupGeneratedValue: + val defaultOf : (System.Type -> obj) + val LookupGeneratedValue : amap:Import.ImportMap -> ctxt:ExecutionContext -> eenv:IlxGenEnv -> v:TypedTree.Val -> (obj * System.Type) option - val SetGeneratedValue: + val SetGeneratedValue : ctxt:ExecutionContext -> g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> isForced:bool -> v:TypedTree.Val -> value:obj -> unit - val ClearGeneratedValue: + val ClearGeneratedValue : ctxt:ExecutionContext -> g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> v:TypedTree.Val -> unit type IlxAssemblyGenerator = - - new: Import.ImportMap * TcGlobals.TcGlobals * ConstraintSolver.TcValF * + class + new : Import.ImportMap * TcGlobals.TcGlobals * ConstraintSolver.TcValF * TypedTree.CcuThunk -> IlxAssemblyGenerator - member AddExternalCcus: TypedTree.CcuThunk list -> unit + member AddExternalCcus : TypedTree.CcuThunk list -> unit member - AddIncrementalLocalAssemblyFragment: isIncrementalFragment:bool * + AddIncrementalLocalAssemblyFragment : isIncrementalFragment:bool * fragName:string * typedImplFiles:TypedTree.TypedImplFile list -> unit - member ClearGeneratedValue: ExecutionContext * TypedTree.Val -> unit + member ClearGeneratedValue : ExecutionContext * TypedTree.Val -> unit member - ForceSetGeneratedValue: ExecutionContext * TypedTree.Val * obj -> + ForceSetGeneratedValue : ExecutionContext * TypedTree.Val * obj -> unit member - GenerateCode: IlxGenOptions * + GenerateCode : IlxGenOptions * TypedTree.TypedAssemblyAfterOptimization * TypedTree.Attribs * TypedTree.Attribs -> IlxGenResults member - LookupGeneratedValue: ExecutionContext * TypedTree.Val -> + LookupGeneratedValue : ExecutionContext * TypedTree.Val -> (obj * System.Type) option - - + end + end namespace FSharp.Compiler - module internal DotNetFrameworkDependencies = + module internal DotNetFrameworkDependencies = begin type private TypeInThisAssembly - val fSharpCompilerLocation: string - val inline ifEmptyUse: alternative:string -> filename:string -> string - val getFSharpCoreLibraryName: string - val getFsiLibraryName: string - val getDefaultFSharpCoreLocation: string - val getDefaultFsiLibraryLocation: string - val implementationAssemblyDir: string - val getDefaultSystemValueTupleReference: unit -> string option - val zeroVersion: System.Version - val version: string option - val frameworkRefsPackDirectoryRoot: string option - val netcoreTfm: string option - val getWindowsDesktopTfm: unit -> string - val executionTfm: string - val executionRid: string - val isInReferenceAssemblyPackDirectory: filename:string -> bool - val frameworkRefsPackDirectory: string option - val getDependenciesOf: + val fSharpCompilerLocation : string + val inline ifEmptyUse : alternative:string -> filename:string -> string + val getFSharpCoreLibraryName : string + val getFsiLibraryName : string + val getDefaultFSharpCoreLocation : string + val getDefaultFsiLibraryLocation : string + val implementationAssemblyDir : string + val getDefaultSystemValueTupleReference : unit -> string option + val zeroVersion : System.Version + val version : string option + val frameworkRefsPackDirectoryRoot : string option + val netcoreTfm : string option + val getWindowsDesktopTfm : unit -> string + val executionTfm : string + val executionRid : string + val isInReferenceAssemblyPackDirectory : filename:string -> bool + val frameworkRefsPackDirectory : string option + val getDependenciesOf : assemblyReferences:string list -> System.Collections.Generic.Dictionary - val getDesktopDefaultReferences: useFsiAuxLib:bool -> string list - val fetchPathsForDefaultReferencesForScriptsAndOutOfProjectSources: + val getDesktopDefaultReferences : useFsiAuxLib:bool -> string list + val fetchPathsForDefaultReferencesForScriptsAndOutOfProjectSources : useFsiAuxLib:bool -> useSdkRefs:bool -> assumeDotNetFramework:bool -> string list - val defaultReferencesForScriptsAndOutOfProjectSources: + val defaultReferencesForScriptsAndOutOfProjectSources : useFsiAuxLib:bool -> assumeDotNetFramework:bool -> useSdkRefs:bool -> string list - val systemAssemblies: System.Collections.Generic.HashSet - val basicReferencesForScriptLoadClosure: + val systemAssemblies : System.Collections.Generic.HashSet + val basicReferencesForScriptLoadClosure : useFsiAuxLib:bool -> useSdkRefs:bool -> assumeDotNetFramework:bool -> string list - + end namespace Microsoft.DotNet.DependencyManager type AssemblyResolutionProbe = delegate of Unit -> seq type AssemblyResolveHandlerCoreclr = - + class interface System.IDisposable - new: assemblyProbingPaths:AssemblyResolutionProbe -> + new : assemblyProbingPaths:AssemblyResolutionProbe -> AssemblyResolveHandlerCoreclr - + end type AssemblyResolveHandlerDeskTop = - + class interface System.IDisposable - new: assemblyProbingPaths:AssemblyResolutionProbe -> + new : assemblyProbingPaths:AssemblyResolutionProbe -> AssemblyResolveHandlerDeskTop - + end type AssemblyResolveHandler = - + class interface System.IDisposable - new: assemblyProbingPaths:AssemblyResolutionProbe -> + new : assemblyProbingPaths:AssemblyResolutionProbe -> AssemblyResolveHandler - + end namespace Microsoft.DotNet.DependencyManager type NativeResolutionProbe = delegate of Unit -> seq type NativeAssemblyLoadContext = - + class inherit System.Runtime.Loader.AssemblyLoadContext - new: unit -> NativeAssemblyLoadContext + new : unit -> NativeAssemblyLoadContext override - Load: _path:System.Reflection.AssemblyName -> + Load : _path:System.Reflection.AssemblyName -> System.Reflection.Assembly - member LoadNativeLibrary: path:string -> System.IntPtr - static member NativeLoadContext: NativeAssemblyLoadContext - + member LoadNativeLibrary : path:string -> System.IntPtr + static member NativeLoadContext : NativeAssemblyLoadContext + end type NativeDllResolveHandlerCoreClr = - + class interface System.IDisposable - new: nativeProbingRoots:NativeResolutionProbe -> + new : nativeProbingRoots:NativeResolutionProbe -> NativeDllResolveHandlerCoreClr - + end type NativeDllResolveHandler = - + class interface System.IDisposable - new: _nativeProbingRoots:NativeResolutionProbe -> NativeDllResolveHandler - member internal RefreshPathsInEnvironment: seq -> unit - + new : _nativeProbingRoots:NativeResolutionProbe -> NativeDllResolveHandler + member internal RefreshPathsInEnvironment : seq -> unit + end namespace Microsoft.DotNet.DependencyManager - module ReflectionHelper = - val dependencyManagerPattern: string - val dependencyManagerAttributeName: string - val resolveDependenciesMethodName: string - val namePropertyName: string - val keyPropertyName: string - val helpMessagesPropertyName: string - val arrEmpty: string [] - val seqEmpty: seq - val assemblyHasAttribute: + module Option = begin + val ofString : s:string -> string option + end + module ReflectionHelper = begin + val dependencyManagerPattern : string + val dependencyManagerAttributeName : string + val resolveDependenciesMethodName : string + val namePropertyName : string + val keyPropertyName : string + val helpMessagesPropertyName : string + val arrEmpty : string [] + val seqEmpty : seq + val assemblyHasAttribute : theAssembly:System.Reflection.Assembly -> attributeName:string -> bool - val getAttributeNamed: + val getAttributeNamed : theType:System.Type -> attributeName:string -> obj option - val getInstanceProperty<'treturn>: + val getInstanceProperty<'treturn> : theType:System.Type -> propertyName:string -> System.Reflection.PropertyInfo option - val getInstanceMethod<'treturn>: + val getInstanceMethod<'treturn> : theType:System.Type -> parameterTypes:System.Type array -> methodName:string -> System.Reflection.MethodInfo option - val stripTieWrapper: e:System.Exception -> exn - - [] + val stripTieWrapper : e:System.Exception -> exn + end + [] type ErrorReportType = | Warning | Error @@ -12794,112 +37861,112 @@ namespace Microsoft.DotNet.DependencyManager delegate of ErrorReportType * int * string -> unit type IResolveDependenciesResult = interface - abstract member Resolutions: seq - abstract member Roots: seq - abstract member SourceFiles: seq - abstract member StdError: string [] - abstract member StdOut: string [] - abstract member Success: bool - - [] + abstract member Resolutions : seq + abstract member Roots : seq + abstract member SourceFiles : seq + abstract member StdError : string [] + abstract member StdOut : string [] + abstract member Success : bool + end + [] type IDependencyManagerProvider = interface abstract member - ResolveDependencies: scriptDir:string * mainScriptName:string * + ResolveDependencies : scriptDir:string * mainScriptName:string * scriptName:string * scriptExt:string * packageManagerTextLines:seq * tfm:string * rid:string -> IResolveDependenciesResult - abstract member HelpMessages: string [] - abstract member Key: string - abstract member Name: string - + abstract member HelpMessages : string [] + abstract member Key : string + abstract member Name : string + end type ReflectionDependencyManagerProvider = - + class interface IDependencyManagerProvider - new: theType:System.Type * nameProperty:System.Reflection.PropertyInfo * + new : theType:System.Type * nameProperty:System.Reflection.PropertyInfo * keyProperty:System.Reflection.PropertyInfo * helpMessagesProperty:System.Reflection.PropertyInfo option * resolveDeps:System.Reflection.MethodInfo option * resolveDepsEx:System.Reflection.MethodInfo option * outputDir:string option -> ReflectionDependencyManagerProvider static member - InstanceMaker: theType:System.Type * outputDir:string option -> + InstanceMaker : theType:System.Type * outputDir:string option -> (unit -> IDependencyManagerProvider) option static member - MakeResultFromFields: success:bool * stdOut:string array * + MakeResultFromFields : success:bool * stdOut:string array * stdError:string array * resolutions:seq * sourceFiles:seq * roots:seq -> IResolveDependenciesResult static member - MakeResultFromObject: result:obj -> IResolveDependenciesResult - + MakeResultFromObject : result:obj -> IResolveDependenciesResult + end type DependencyProvider = - + class interface System.IDisposable - new: unit -> DependencyProvider - new: nativeProbingRoots:NativeResolutionProbe -> DependencyProvider - new: assemblyProbingPaths:AssemblyResolutionProbe * + new : unit -> DependencyProvider + new : nativeProbingRoots:NativeResolutionProbe -> DependencyProvider + new : assemblyProbingPaths:AssemblyResolutionProbe * nativeProbingRoots:NativeResolutionProbe -> DependencyProvider member - CreatePackageManagerUnknownError: seq * string * string * + CreatePackageManagerUnknownError : seq * string * string * ResolvingErrorReport -> int * string member - GetRegisteredDependencyManagerHelpText: seq * string * + GetRegisteredDependencyManagerHelpText : seq * string * ResolvingErrorReport -> string [] member - Resolve: packageManager:IDependencyManagerProvider * scriptExt:string * + Resolve : packageManager:IDependencyManagerProvider * scriptExt:string * packageManagerTextLines:seq * reportError:ResolvingErrorReport * executionTfm:string * executionRid:string * implicitIncludeDir:string * mainScriptName:string * fileName:string -> IResolveDependenciesResult member - TryFindDependencyManagerByKey: compilerTools:seq * + TryFindDependencyManagerByKey : compilerTools:seq * outputDir:string * reportError:ResolvingErrorReport * key:string -> IDependencyManagerProvider member - TryFindDependencyManagerInPath: compilerTools:seq * + TryFindDependencyManagerInPath : compilerTools:seq * outputDir:string * reportError:ResolvingErrorReport * path:string -> string * IDependencyManagerProvider - + end namespace FSharp.Compiler - module internal CompilerConfig = - val ( ++ ): x:'a list -> s:'a -> 'a list - val FSharpSigFileSuffixes: string list - val mlCompatSuffixes: string list - val FSharpImplFileSuffixes: string list - val FSharpScriptFileSuffixes: string list - val doNotRequireNamespaceOrModuleSuffixes: string list - val FSharpLightSyntaxFileSuffixes: string list + module internal CompilerConfig = begin + val ( ++ ) : x:'a list -> s:'a -> 'a list + val FSharpSigFileSuffixes : string list + val mlCompatSuffixes : string list + val FSharpImplFileSuffixes : string list + val FSharpScriptFileSuffixes : string list + val doNotRequireNamespaceOrModuleSuffixes : string list + val FSharpLightSyntaxFileSuffixes : string list exception FileNameNotResolved of string * string * Range.range exception LoadedSourceNotFoundIgnoring of string * Range.range - val TryResolveFileUsingPaths: + val TryResolveFileUsingPaths : paths:string list * m:Range.range * name:string -> string option - val ResolveFileUsingPaths: + val ResolveFileUsingPaths : paths:string list * m:Range.range * name:string -> string - val GetWarningNumber: m:Range.range * warningNumber:string -> int32 option - val ComputeMakePathAbsolute: + val GetWarningNumber : m:Range.range * warningNumber:string -> int32 option + val ComputeMakePathAbsolute : implicitIncludeDir:string -> path:string -> string - [] + [] type CompilerTarget = | WinExe | ConsoleExe | Dll | Module with - member IsExe: bool - - [] + member IsExe : bool + end + [] type ResolveAssemblyReferenceMode = | Speculative | ReportErrors - [] + [] type CopyFSharpCoreFlag = | Yes | No @@ -12909,71 +37976,71 @@ namespace FSharp.Compiler | VersionNone with member - GetVersionInfo: implicitIncludeDir:string -> + GetVersionInfo : implicitIncludeDir:string -> AbstractIL.IL.ILVersionInfo - member GetVersionString: implicitIncludeDir:string -> string - + member GetVersionString : implicitIncludeDir:string -> string + end type IRawFSharpAssemblyData = interface abstract member - GetAutoOpenAttributes: AbstractIL.IL.ILGlobals -> string list + GetAutoOpenAttributes : AbstractIL.IL.ILGlobals -> string list abstract member - GetInternalsVisibleToAttributes: AbstractIL.IL.ILGlobals -> + GetInternalsVisibleToAttributes : AbstractIL.IL.ILGlobals -> string list abstract member - GetRawFSharpOptimizationData: Range.range * ilShortAssemName:string * + GetRawFSharpOptimizationData : Range.range * ilShortAssemName:string * fileName:string -> (string * (unit -> AbstractIL.Internal.ReadOnlyByteMemory)) list abstract member - GetRawFSharpSignatureData: Range.range * ilShortAssemName:string * + GetRawFSharpSignatureData : Range.range * ilShortAssemName:string * fileName:string -> (string * (unit -> AbstractIL.Internal.ReadOnlyByteMemory)) list abstract member - GetRawTypeForwarders: unit -> + GetRawTypeForwarders : unit -> AbstractIL.IL.ILExportedTypesAndForwarders abstract member - HasMatchingFSharpSignatureDataAttribute: AbstractIL.IL.ILGlobals -> + HasMatchingFSharpSignatureDataAttribute : AbstractIL.IL.ILGlobals -> bool abstract member - TryGetILModuleDef: unit -> AbstractIL.IL.ILModuleDef option - abstract member HasAnyFSharpSignatureDataAttribute: bool - abstract member ILAssemblyRefs: AbstractIL.IL.ILAssemblyRef list - abstract member ILScopeRef: AbstractIL.IL.ILScopeRef - abstract member ShortAssemblyName: string - + TryGetILModuleDef : unit -> AbstractIL.IL.ILModuleDef option + abstract member HasAnyFSharpSignatureDataAttribute : bool + abstract member ILAssemblyRefs : AbstractIL.IL.ILAssemblyRef list + abstract member ILScopeRef : AbstractIL.IL.ILScopeRef + abstract member ShortAssemblyName : string + end type TimeStampCache = - - new: defaultTimeStamp:System.DateTime -> TimeStampCache - member GetFileTimeStamp: string -> System.DateTime + class + new : defaultTimeStamp:System.DateTime -> TimeStampCache + member GetFileTimeStamp : string -> System.DateTime member - GetProjectReferenceTimeStamp: IProjectReference * + GetProjectReferenceTimeStamp : IProjectReference * AbstractIL.Internal.Library.CompilationThreadToken -> System.DateTime - + end and IProjectReference = interface abstract member - EvaluateRawContents: AbstractIL.Internal.Library.CompilationThreadToken -> + EvaluateRawContents : AbstractIL.Internal.Library.CompilationThreadToken -> AbstractIL.Internal.Library.Cancellable abstract member - TryGetLogicalTimeStamp: TimeStampCache * + TryGetLogicalTimeStamp : TimeStampCache * AbstractIL.Internal.Library.CompilationThreadToken -> System.DateTime option - abstract member FileName: string - + abstract member FileName : string + end type AssemblyReference = | AssemblyReference of Range.range * string * IProjectReference option with - member SimpleAssemblyNameIs: string -> bool - override ToString: unit -> string - member ProjectReference: IProjectReference option - member Range: Range.range - member Text: string - + member SimpleAssemblyNameIs : string -> bool + override ToString : unit -> string + member ProjectReference : IProjectReference option + member Range : Range.range + member Text : string + end type UnresolvedAssemblyReference = | UnresolvedAssemblyReference of string * AssemblyReference list type ResolvedExtensionReference = @@ -13007,23 +38074,23 @@ namespace FSharp.Compiler Range: Range.range } with static member - AddLineWithKey: string -> + AddLineWithKey : string -> Directive -> string -> Range.range -> Map -> Map static member - RemoveUnprocessedLines: string -> + RemoveUnprocessedLines : string -> Map -> Map static member - SetLinesAsProcessed: string -> + SetLinesAsProcessed : string -> Map -> Map - static member StripDependencyManagerKey: string -> string -> string - - [] + static member StripDependencyManagerKey : string -> string -> string + end + [] type TcConfigBuilder = { mutable primaryAssembly: AbstractIL.IL.PrimaryAssembly mutable noFeedback: bool @@ -13148,7 +38215,7 @@ namespace FSharp.Compiler mutable langVersion: Features.LanguageVersion } with static member - CreateNew: legacyReferenceResolver:ReferenceResolver.Resolver * + CreateNew : legacyReferenceResolver:ReferenceResolver.Resolver * defaultFSharpBinariesDir:string * reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * implicitIncludeDir:string * isInteractive:bool * @@ -13157,205 +38224,205 @@ namespace FSharp.Compiler tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot -> TcConfigBuilder static member - SplitCommandLineResourceInfo: string -> + SplitCommandLineResourceInfo : string -> string * string * AbstractIL.IL.ILResourceAccess - member AddCompilerToolsByPath: string -> unit + member AddCompilerToolsByPath : string -> unit member - AddDependencyManagerText: packageManager:Microsoft.DotNet.DependencyManager.IDependencyManagerProvider * + AddDependencyManagerText : packageManager:Microsoft.DotNet.DependencyManager.IDependencyManagerProvider * lt:Directive * m:Range.range * path:string -> unit - member AddEmbeddedResource: string -> unit - member AddEmbeddedSourceFile: string -> unit - member AddIncludePath: Range.range * string * string -> unit + member AddEmbeddedResource : string -> unit + member AddEmbeddedSourceFile : string -> unit + member AddIncludePath : Range.range * string * string -> unit member - AddLoadedSource: m:Range.range * originalPath:string * + AddLoadedSource : m:Range.range * originalPath:string * pathLoadedFrom:string -> unit - member AddPathMapping: oldPrefix:string * newPrefix:string -> unit + member AddPathMapping : oldPrefix:string * newPrefix:string -> unit member - AddReferenceDirective: dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider * + AddReferenceDirective : dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider * m:Range.range * path:string * directive:Directive -> unit - member AddReferencedAssemblyByPath: Range.range * string -> unit - member DecideNames: string list -> string * string option * string - member GetNativeProbingRoots: unit -> seq - member RemoveReferencedAssemblyByPath: Range.range * string -> unit + member AddReferencedAssemblyByPath : Range.range * string -> unit + member DecideNames : string list -> string * string option * string + member GetNativeProbingRoots : unit -> seq + member RemoveReferencedAssemblyByPath : Range.range * string -> unit member - ResolveSourceFile: m:Range.range * nm:string * pathLoadedFrom:string -> + ResolveSourceFile : m:Range.range * nm:string * pathLoadedFrom:string -> string - member TurnWarningOff: Range.range * string -> unit - member TurnWarningOn: Range.range * string -> unit - static member Initial: TcConfigBuilder - - [] + member TurnWarningOff : Range.range * string -> unit + member TurnWarningOn : Range.range * string -> unit + static member Initial : TcConfigBuilder + end + [] type TcConfig = - - private new: data:TcConfigBuilder * validate:bool -> TcConfig - static member Create: TcConfigBuilder * validate:bool -> TcConfig - member CloneToBuilder: unit -> TcConfigBuilder + class + private new : data:TcConfigBuilder * validate:bool -> TcConfig + static member Create : TcConfigBuilder * validate:bool -> TcConfig + member CloneToBuilder : unit -> TcConfigBuilder member - ComputeCanContainEntryPoint: sourceFiles:string list -> + ComputeCanContainEntryPoint : sourceFiles:string list -> bool list * bool - member ComputeLightSyntaxInitialStatus: string -> bool - member CoreLibraryDllReference: unit -> AssemblyReference - member GetAvailableLoadedSources: unit -> (Range.range * string) list - member GetNativeProbingRoots: unit -> seq - member GetSearchPathsForLibraryFiles: unit -> string list - member GetTargetFrameworkDirectories: unit -> string list - member IsSystemAssembly: string -> bool - member MakePathAbsolute: string -> string - member PrimaryAssemblyDllReference: unit -> AssemblyReference - member - ResolveSourceFile: Range.range * filename:string * + member ComputeLightSyntaxInitialStatus : string -> bool + member CoreLibraryDllReference : unit -> AssemblyReference + member GetAvailableLoadedSources : unit -> (Range.range * string) list + member GetNativeProbingRoots : unit -> seq + member GetSearchPathsForLibraryFiles : unit -> string list + member GetTargetFrameworkDirectories : unit -> string list + member IsSystemAssembly : string -> bool + member MakePathAbsolute : string -> string + member PrimaryAssemblyDllReference : unit -> AssemblyReference + member + ResolveSourceFile : Range.range * filename:string * pathLoadedFrom:string -> string - member GenerateOptimizationData: bool - member GenerateSignatureData: bool - member alwaysCallVirt: bool - member baseAddress: int32 option - member checkOverflow: bool - member checksumAlgorithm: AbstractIL.ILPdbWriter.HashAlgorithm - member clrRoot: string option - member compilerToolPaths: string list - member compilingFslib: bool - member conditionalCompilationDefines: string list - member container: string option - member continueAfterParseFailure: bool - member copyFSharpCore: CopyFSharpCoreFlag - member debugSymbolFile: string option - member debuginfo: bool - member delaysign: bool - member deterministic: bool - member doDetuple: bool - member doFinalSimplify: bool - member doTLR: bool - member dumpDebugInfo: bool - member embedAllSource: bool - member embedResources: string list - member embedSourceList: string list - member embeddedPDB: bool - member emitDebugInfoInQuotations: bool - member emitTailcalls: bool - member errorSeverityOptions: ErrorLogger.FSharpErrorSeverityOptions - member errorStyle: ErrorLogger.ErrorStyle - member extraOptimizationIterations: int - member extraStaticLinkRoots: string list - member flatErrors: bool - member framework: bool - member fsharpBinariesDir: string - member generateFilterBlocks: bool - member ignoreSymbolStoreSequencePoints: bool - member implicitIncludeDir: string - member implicitOpens: string list - member implicitlyResolveAssemblies: bool - member importAllReferencesOnly: bool - member includes: string list - member includewin32manifest: bool - member inputCodePage: int option - member internConstantStrings: bool - member internalTestSpanStackReferring: bool - member isInteractive: bool - member isInvalidationSupported: bool - member jitTracking: bool - member knownUnresolvedReferences: UnresolvedAssemblyReference list - member langVersion: Features.LanguageVersion - member lcid: int option - member legacyReferenceResolver: ReferenceResolver.Resolver - member light: bool option - member linkResources: string list - member loadedSources: (Range.range * string * string) list - member maxErrors: int - member metadataVersion: string option - member mlCompatibility: bool - member noConditionalErasure: bool - member noDebugData: bool - member noFeedback: bool - member noSignatureData: bool - member onlyEssentialOptimizationData: bool - member openDebugInformationForLaterStaticLinking: bool - member optSettings: Optimizer.OptimizationSettings - member optsOn: bool - member outputDir: string option - member outputFile: string option - member packageManagerLines: Map - member parseOnly: bool - member pathMap: Internal.Utilities.PathMap - member pause: bool - member platform: AbstractIL.IL.ILPlatform option - member portablePDB: bool - member prefer32Bit: bool - member preferredUiLang: string option - member primaryAssembly: AbstractIL.IL.PrimaryAssembly - member printAst: bool - member printSignature: bool - member printSignatureFile: string - member productNameForBannerText: string - member publicsign: bool - member reduceMemoryUsage: AbstractIL.ILBinaryReader.ReduceMemoryFlag - member referencedDLLs: AssemblyReference list - member reportNumDecls: bool - member resolutionEnvironment: ReferenceResolver.ResolutionEnvironment - member shadowCopyReferences: bool - member showBanner: bool - member showExtensionTypeMessages: bool - member showFullPaths: bool - member showLoadedAssemblies: bool - member showOptimizationData: bool - member showReferenceResolutions: bool - member showTerms: bool - member showTimes: bool - member signer: string option - member simulateException: string option - member sourceLink: string - member stackReserveSize: int32 option - member standalone: bool - member stats: bool - member subsystemVersion: int * int - member target: CompilerTarget - member targetFrameworkVersion: string - member testFlagEmitFeeFeeAs100001: bool - member testInteractionParser: bool - member tokenizeOnly: bool - member - tryGetMetadataSnapshot: AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot - member typeCheckOnly: bool - member useFsiAuxLib: bool - member useHighEntropyVA: bool - member useIncrementalBuilder: bool - member useOptimizationDataFile: bool - member useSdkRefs: bool - member useSimpleResolution: bool - member utf8output: bool - member version: VersionFlag - member win32manifest: string - member win32res: string - member writeTermsToFiles: bool - member xmlDocOutputFile: string option - - [] + member GenerateOptimizationData : bool + member GenerateSignatureData : bool + member alwaysCallVirt : bool + member baseAddress : int32 option + member checkOverflow : bool + member checksumAlgorithm : AbstractIL.ILPdbWriter.HashAlgorithm + member clrRoot : string option + member compilerToolPaths : string list + member compilingFslib : bool + member conditionalCompilationDefines : string list + member container : string option + member continueAfterParseFailure : bool + member copyFSharpCore : CopyFSharpCoreFlag + member debugSymbolFile : string option + member debuginfo : bool + member delaysign : bool + member deterministic : bool + member doDetuple : bool + member doFinalSimplify : bool + member doTLR : bool + member dumpDebugInfo : bool + member embedAllSource : bool + member embedResources : string list + member embedSourceList : string list + member embeddedPDB : bool + member emitDebugInfoInQuotations : bool + member emitTailcalls : bool + member errorSeverityOptions : ErrorLogger.FSharpErrorSeverityOptions + member errorStyle : ErrorLogger.ErrorStyle + member extraOptimizationIterations : int + member extraStaticLinkRoots : string list + member flatErrors : bool + member framework : bool + member fsharpBinariesDir : string + member generateFilterBlocks : bool + member ignoreSymbolStoreSequencePoints : bool + member implicitIncludeDir : string + member implicitOpens : string list + member implicitlyResolveAssemblies : bool + member importAllReferencesOnly : bool + member includes : string list + member includewin32manifest : bool + member inputCodePage : int option + member internConstantStrings : bool + member internalTestSpanStackReferring : bool + member isInteractive : bool + member isInvalidationSupported : bool + member jitTracking : bool + member knownUnresolvedReferences : UnresolvedAssemblyReference list + member langVersion : Features.LanguageVersion + member lcid : int option + member legacyReferenceResolver : ReferenceResolver.Resolver + member light : bool option + member linkResources : string list + member loadedSources : (Range.range * string * string) list + member maxErrors : int + member metadataVersion : string option + member mlCompatibility : bool + member noConditionalErasure : bool + member noDebugData : bool + member noFeedback : bool + member noSignatureData : bool + member onlyEssentialOptimizationData : bool + member openDebugInformationForLaterStaticLinking : bool + member optSettings : Optimizer.OptimizationSettings + member optsOn : bool + member outputDir : string option + member outputFile : string option + member packageManagerLines : Map + member parseOnly : bool + member pathMap : Internal.Utilities.PathMap + member pause : bool + member platform : AbstractIL.IL.ILPlatform option + member portablePDB : bool + member prefer32Bit : bool + member preferredUiLang : string option + member primaryAssembly : AbstractIL.IL.PrimaryAssembly + member printAst : bool + member printSignature : bool + member printSignatureFile : string + member productNameForBannerText : string + member publicsign : bool + member reduceMemoryUsage : AbstractIL.ILBinaryReader.ReduceMemoryFlag + member referencedDLLs : AssemblyReference list + member reportNumDecls : bool + member resolutionEnvironment : ReferenceResolver.ResolutionEnvironment + member shadowCopyReferences : bool + member showBanner : bool + member showExtensionTypeMessages : bool + member showFullPaths : bool + member showLoadedAssemblies : bool + member showOptimizationData : bool + member showReferenceResolutions : bool + member showTerms : bool + member showTimes : bool + member signer : string option + member simulateException : string option + member sourceLink : string + member stackReserveSize : int32 option + member standalone : bool + member stats : bool + member subsystemVersion : int * int + member target : CompilerTarget + member targetFrameworkVersion : string + member testFlagEmitFeeFeeAs100001 : bool + member testInteractionParser : bool + member tokenizeOnly : bool + member + tryGetMetadataSnapshot : AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot + member typeCheckOnly : bool + member useFsiAuxLib : bool + member useHighEntropyVA : bool + member useIncrementalBuilder : bool + member useOptimizationDataFile : bool + member useSdkRefs : bool + member useSimpleResolution : bool + member utf8output : bool + member version : VersionFlag + member win32manifest : string + member win32res : string + member writeTermsToFiles : bool + member xmlDocOutputFile : string option + end + [] type TcConfigProvider = | TcConfigProvider of (AbstractIL.Internal.Library.CompilationThreadToken -> TcConfig) with static member - BasedOnMutableBuilder: TcConfigBuilder -> TcConfigProvider - static member Constant: TcConfig -> TcConfigProvider + BasedOnMutableBuilder : TcConfigBuilder -> TcConfigProvider + static member Constant : TcConfig -> TcConfigProvider member - Get: AbstractIL.Internal.Library.CompilationThreadToken -> TcConfig - - val GetFSharpCoreLibraryName: unit -> string - + Get : AbstractIL.Internal.Library.CompilationThreadToken -> TcConfig + end + val GetFSharpCoreLibraryName : unit -> string + end namespace FSharp.Compiler - module internal CompilerImports = - val ( ++ ): x:'a list -> s:'a -> 'a list - val IsSignatureDataResource: AbstractIL.IL.ILResource -> bool - val IsOptimizationDataResource: AbstractIL.IL.ILResource -> bool - val GetSignatureDataResourceName: AbstractIL.IL.ILResource -> string - val GetOptimizationDataResourceName: r:AbstractIL.IL.ILResource -> string - val IsReflectedDefinitionsResource: AbstractIL.IL.ILResource -> bool - val MakeILResource: + module internal CompilerImports = begin + val ( ++ ) : x:'a list -> s:'a -> 'a list + val IsSignatureDataResource : AbstractIL.IL.ILResource -> bool + val IsOptimizationDataResource : AbstractIL.IL.ILResource -> bool + val GetSignatureDataResourceName : AbstractIL.IL.ILResource -> string + val GetOptimizationDataResourceName : r:AbstractIL.IL.ILResource -> string + val IsReflectedDefinitionsResource : AbstractIL.IL.ILResource -> bool + val MakeILResource : rName:string -> bytes:byte [] -> AbstractIL.IL.ILResource - val PickleToResource: + val PickleToResource : inMem:bool -> file:string -> g:TcGlobals.TcGlobals -> @@ -13363,33 +38430,33 @@ namespace FSharp.Compiler rName:string -> p:TypedTreePickle.pickler<'a> -> x:'a -> AbstractIL.IL.ILResource - val GetSignatureData: + val GetSignatureData : file:string * ilScopeRef:AbstractIL.IL.ILScopeRef * ilModule:AbstractIL.IL.ILModuleDef option * byteReader:(unit -> AbstractIL.Internal.ReadOnlyByteMemory) -> TypedTreePickle.PickledDataWithReferences - val WriteSignatureData: + val WriteSignatureData : CompilerConfig.TcConfig * TcGlobals.TcGlobals * TypedTreeOps.Remap * TypedTree.CcuThunk * filename:string * inMem:bool -> AbstractIL.IL.ILResource - val GetOptimizationData: + val GetOptimizationData : file:string * ilScopeRef:AbstractIL.IL.ILScopeRef * ilModule:AbstractIL.IL.ILModuleDef option * byteReader:(unit -> AbstractIL.Internal.ReadOnlyByteMemory) -> TypedTreePickle.PickledDataWithReferences - val WriteOptimizationData: + val WriteOptimizationData : TcGlobals.TcGlobals * filename:string * inMem:bool * TypedTree.CcuThunk * Optimizer.CcuOptimizationInfo -> AbstractIL.IL.ILResource exception AssemblyNotResolved of string * Range.range exception MSBuildReferenceResolutionWarning of string * string * Range.range exception MSBuildReferenceResolutionError of string * string * Range.range - val OpenILBinary: + val OpenILBinary : filename:string * reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * pdbDirPath:string option * shadowCopyReferences:bool * tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot -> AbstractIL.ILBinaryReader.ILModuleReader - [] + [] type ResolveAssemblyReferenceMode = | Speculative | ReportErrors @@ -13406,14 +38473,14 @@ namespace FSharp.Compiler mutable ilAssemblyRef: AbstractIL.IL.ILAssemblyRef option } with member - GetILAssemblyRef: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + GetILAssemblyRef : ctok:AbstractIL.Internal.Library.CompilationThreadToken * reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot -> AbstractIL.Internal.Library.Cancellable - override ToString: unit -> string - member ProjectReference: CompilerConfig.IProjectReference option - - [] + override ToString : unit -> string + member ProjectReference : CompilerConfig.IProjectReference option + end + [] type ImportedBinary = { FileName: string RawMetadata: CompilerConfig.IRawFSharpAssemblyData @@ -13423,7 +38490,7 @@ namespace FSharp.Compiler ExtensionTyping.ProvidedAssemblyStaticLinkingMap option ILAssemblyRefs: AbstractIL.IL.ILAssemblyRef list ILScopeRef: AbstractIL.IL.ILScopeRef } - [] + [] type ImportedAssembly = { ILScopeRef: AbstractIL.IL.ILScopeRef FSharpViewOfMetadata: TypedTree.CcuThunk @@ -13440,140 +38507,140 @@ namespace FSharp.Compiler | ReturnNone type TcConfig with member - TryResolveLibWithDirectories: r:CompilerConfig.AssemblyReference -> + TryResolveLibWithDirectories : r:CompilerConfig.AssemblyReference -> AssemblyResolution option type TcConfig with member - ResolveLibWithDirectories: ccuLoadFailureAction:CcuLoadFailureAction * + ResolveLibWithDirectories : ccuLoadFailureAction:CcuLoadFailureAction * r:CompilerConfig.AssemblyReference -> AssemblyResolution option type TcConfig with member - MsBuildResolve: references:(string * string) [] * + MsBuildResolve : references:(string * string) [] * mode:ResolveAssemblyReferenceMode * errorAndWarningRange:Range.range * showMessages:bool -> ReferenceResolver.ResolvedFile [] type TcConfig with static member - TryResolveLibsUsingMSBuildRules: tcConfig:CompilerConfig.TcConfig * + TryResolveLibsUsingMSBuildRules : tcConfig:CompilerConfig.TcConfig * originalReferences:CompilerConfig.AssemblyReference list * errorAndWarningRange:Range.range * mode:ResolveAssemblyReferenceMode -> AssemblyResolution list * CompilerConfig.UnresolvedAssemblyReference list - [] + [] type TcAssemblyResolutions = - - new: tcConfig:CompilerConfig.TcConfig * results:AssemblyResolution list * + class + new : tcConfig:CompilerConfig.TcConfig * results:AssemblyResolution list * unresolved:CompilerConfig.UnresolvedAssemblyReference list -> TcAssemblyResolutions static member - BuildFromPriorResolutions: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + BuildFromPriorResolutions : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfig:CompilerConfig.TcConfig * AssemblyResolution list * CompilerConfig.UnresolvedAssemblyReference list -> TcAssemblyResolutions static member - GetAllDllReferences: tcConfig:CompilerConfig.TcConfig -> + GetAllDllReferences : tcConfig:CompilerConfig.TcConfig -> CompilerConfig.AssemblyReference list static member - GetAssemblyResolutionInformation: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + GetAssemblyResolutionInformation : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfig:CompilerConfig.TcConfig -> AssemblyResolution list * CompilerConfig.UnresolvedAssemblyReference list static member - ResolveAssemblyReferences: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + ResolveAssemblyReferences : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfig:CompilerConfig.TcConfig * assemblyList:CompilerConfig.AssemblyReference list * knownUnresolved:CompilerConfig.UnresolvedAssemblyReference list -> TcAssemblyResolutions static member - SplitNonFoundationalResolutions: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + SplitNonFoundationalResolutions : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfig:CompilerConfig.TcConfig -> AssemblyResolution list * AssemblyResolution list * CompilerConfig.UnresolvedAssemblyReference list member - AddResolutionResults: newResults:AssemblyResolution list -> + AddResolutionResults : newResults:AssemblyResolution list -> TcAssemblyResolutions member - AddUnresolvedReferences: newUnresolved:CompilerConfig.UnresolvedAssemblyReference list -> + AddUnresolvedReferences : newUnresolved:CompilerConfig.UnresolvedAssemblyReference list -> TcAssemblyResolutions - member GetAssemblyResolutions: unit -> AssemblyResolution list + member GetAssemblyResolutions : unit -> AssemblyResolution list member - GetUnresolvedReferences: unit -> + GetUnresolvedReferences : unit -> CompilerConfig.UnresolvedAssemblyReference list member - TryFindByExactILAssemblyRef: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + TryFindByExactILAssemblyRef : ctok:AbstractIL.Internal.Library.CompilationThreadToken * assemblyRef:AbstractIL.IL.ILAssemblyRef -> AssemblyResolution option member - TryFindByOriginalReference: assemblyReference:CompilerConfig.AssemblyReference -> + TryFindByOriginalReference : assemblyReference:CompilerConfig.AssemblyReference -> AssemblyResolution option member - TryFindByOriginalReferenceText: nm:string -> + TryFindByOriginalReferenceText : nm:string -> AssemblyResolution option - member TryFindByResolvedPath: nm:string -> AssemblyResolution option + member TryFindByResolvedPath : nm:string -> AssemblyResolution option member - TryFindBySimpleAssemblyName: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + TryFindBySimpleAssemblyName : ctok:AbstractIL.Internal.Library.CompilationThreadToken * simpleAssemName:string -> AssemblyResolution option - - val GetNameOfILModule: m:AbstractIL.IL.ILModuleDef -> string - val MakeScopeRefForILModule: + end + val GetNameOfILModule : m:AbstractIL.IL.ILModuleDef -> string + val MakeScopeRefForILModule : ilModule:AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILScopeRef - val GetCustomAttributesOfILModule: + val GetCustomAttributesOfILModule : ilModule:AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILAttribute list - val GetAutoOpenAttributes: + val GetAutoOpenAttributes : ilg:AbstractIL.IL.ILGlobals -> ilModule:AbstractIL.IL.ILModuleDef -> string list - val GetInternalsVisibleToAttributes: + val GetInternalsVisibleToAttributes : ilg:AbstractIL.IL.ILGlobals -> ilModule:AbstractIL.IL.ILModuleDef -> string list type RawFSharpAssemblyDataBackedByFileOnDisk = - + class interface CompilerConfig.IRawFSharpAssemblyData - new: ilModule:AbstractIL.IL.ILModuleDef * + new : ilModule:AbstractIL.IL.ILModuleDef * ilAssemblyRefs:AbstractIL.IL.ILAssemblyRef list -> RawFSharpAssemblyDataBackedByFileOnDisk - - [] + end + [] type TcImportsSafeDisposal = - + class interface System.IDisposable - new: disposeActions:ResizeArray<(unit -> unit)> * + new : disposeActions:ResizeArray<(unit -> unit)> * disposeTypeProviderActions:ResizeArray<(unit -> unit)> -> TcImportsSafeDisposal - override Finalize: unit -> unit - + override Finalize : unit -> unit + end type TcImportsDllInfoHack = { FileName: string } and TcImportsWeakHack = - - new: tcImports:System.WeakReference -> TcImportsWeakHack - member SetDllInfos: value:ImportedBinary list -> unit - member SystemRuntimeContainsType: typeName:string -> bool - member Base: TcImportsWeakHack option - - [] + class + new : tcImports:System.WeakReference -> TcImportsWeakHack + member SetDllInfos : value:ImportedBinary list -> unit + member SystemRuntimeContainsType : typeName:string -> bool + member Base : TcImportsWeakHack option + end + [] and TcImports = - + class interface System.IDisposable - new: tcConfigP:CompilerConfig.TcConfigProvider * + new : tcConfigP:CompilerConfig.TcConfigProvider * initialResolutions:TcAssemblyResolutions * importsBase:TcImports option * ilGlobalsOpt:AbstractIL.IL.ILGlobals option * dependencyProviderOpt:Microsoft.DotNet.DependencyManager.DependencyProvider option -> TcImports static member - BuildFrameworkTcImports: AbstractIL.Internal.Library.CompilationThreadToken * + BuildFrameworkTcImports : AbstractIL.Internal.Library.CompilationThreadToken * CompilerConfig.TcConfigProvider * AssemblyResolution list * AssemblyResolution list -> AbstractIL.Internal.Library.Cancellable static member - BuildNonFrameworkTcImports: AbstractIL.Internal.Library.CompilationThreadToken * + BuildNonFrameworkTcImports : AbstractIL.Internal.Library.CompilationThreadToken * CompilerConfig.TcConfigProvider * TcGlobals.TcGlobals * TcImports * AssemblyResolution list * @@ -13581,49 +38648,49 @@ namespace FSharp.Compiler Microsoft.DotNet.DependencyManager.DependencyProvider -> AbstractIL.Internal.Library.Cancellable static member - BuildTcImports: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + BuildTcImports : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfigP:CompilerConfig.TcConfigProvider * dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> AbstractIL.Internal.Library.Cancellable - member AllAssemblyResolutions: unit -> AssemblyResolution list - member private AttachDisposeAction: action:(unit -> unit) -> unit + member AllAssemblyResolutions : unit -> AssemblyResolution list + member private AttachDisposeAction : action:(unit -> unit) -> unit member - private AttachDisposeTypeProviderAction: action:(unit -> unit) -> + private AttachDisposeTypeProviderAction : action:(unit -> unit) -> unit member - FindCcu: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + FindCcu : ctok:AbstractIL.Internal.Library.CompilationThreadToken * m:Range.range * assemblyName:string * lookupOnly:bool -> TypedTree.CcuResolutionResult member - FindCcuFromAssemblyRef: AbstractIL.Internal.Library.CompilationThreadToken * + FindCcuFromAssemblyRef : AbstractIL.Internal.Library.CompilationThreadToken * Range.range * AbstractIL.IL.ILAssemblyRef -> TypedTree.CcuResolutionResult member - FindCcuInfo: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + FindCcuInfo : ctok:AbstractIL.Internal.Library.CompilationThreadToken * m:Range.range * assemblyName:string * lookupOnly:bool -> AvailableImportedAssembly member - FindDllInfo: AbstractIL.Internal.Library.CompilationThreadToken * + FindDllInfo : AbstractIL.Internal.Library.CompilationThreadToken * Range.range * string -> ImportedBinary - member GetCcusExcludingBase: unit -> TypedTree.CcuThunk list - member GetCcusInDeclOrder: unit -> TypedTree.CcuThunk list - member GetDllInfos: unit -> ImportedBinary list - member GetImportMap: unit -> Import.ImportMap - member GetImportedAssemblies: unit -> ImportedAssembly list + member GetCcusExcludingBase : unit -> TypedTree.CcuThunk list + member GetCcusInDeclOrder : unit -> TypedTree.CcuThunk list + member GetDllInfos : unit -> ImportedBinary list + member GetImportMap : unit -> Import.ImportMap + member GetImportedAssemblies : unit -> ImportedAssembly list member - GetProvidedAssemblyInfo: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + GetProvidedAssemblyInfo : ctok:AbstractIL.Internal.Library.CompilationThreadToken * m:Range.range * assembly:Tainted -> bool * ExtensionTyping.ProvidedAssemblyStaticLinkingMap option - member GetTcGlobals: unit -> TcGlobals.TcGlobals + member GetTcGlobals : unit -> TcGlobals.TcGlobals member - ImplicitLoadIfAllowed: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + ImplicitLoadIfAllowed : ctok:AbstractIL.Internal.Library.CompilationThreadToken * m:Range.range * assemblyName:string * lookupOnly:bool -> unit member - ImportTypeProviderExtensions: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + ImportTypeProviderExtensions : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfig:CompilerConfig.TcConfig * fileNameOfRuntimeAssembly:string * ilScopeRefOfRuntimeAssembly:AbstractIL.IL.ILScopeRef * @@ -13633,7 +38700,7 @@ namespace FSharp.Compiler m:Range.range -> Tainted list member - private InjectProvidedNamespaceOrTypeIntoEntity: typeProviderEnvironment:ExtensionTyping.ResolutionEnvironment * + private InjectProvidedNamespaceOrTypeIntoEntity : typeProviderEnvironment:ExtensionTyping.ResolutionEnvironment * tcConfig:CompilerConfig.TcConfig * m:Range.range * entity:TypedTree.Entity * @@ -13642,101 +38709,101 @@ namespace FSharp.Compiler provider:Tainted * st:Tainted option -> unit - member IsAlreadyRegistered: nm:string -> bool + member IsAlreadyRegistered : nm:string -> bool member - MkLoaderForMultiModuleILAssemblies: ctok:AbstractIL.Internal.Library.CompilationThreadToken -> + MkLoaderForMultiModuleILAssemblies : ctok:AbstractIL.Internal.Library.CompilationThreadToken -> m:Range.range -> (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) member - OpenILBinaryModule: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + OpenILBinaryModule : ctok:AbstractIL.Internal.Library.CompilationThreadToken * filename:string * m:Range.range -> AbstractIL.IL.ILModuleDef * AbstractIL.IL.ILAssemblyRef list member - PrepareToImportReferencedFSharpAssembly: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + PrepareToImportReferencedFSharpAssembly : ctok:AbstractIL.Internal.Library.CompilationThreadToken * m:Range.range * filename:string * dllinfo:ImportedBinary -> (unit -> AvailableImportedAssembly list) member - PrepareToImportReferencedILAssembly: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + PrepareToImportReferencedILAssembly : ctok:AbstractIL.Internal.Library.CompilationThreadToken * m:Range.range * filename:string * dllinfo:ImportedBinary -> (unit -> AvailableImportedAssembly list) member - RecordGeneratedTypeRoot: root:ExtensionTyping.ProviderGeneratedType -> + RecordGeneratedTypeRoot : root:ExtensionTyping.ProviderGeneratedType -> unit member - RegisterAndImportReferencedAssemblies: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + RegisterAndImportReferencedAssemblies : ctok:AbstractIL.Internal.Library.CompilationThreadToken * nms:AssemblyResolution list -> AbstractIL.Internal.Library.Cancellable member - RegisterAndPrepareToImportReferencedDll: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + RegisterAndPrepareToImportReferencedDll : ctok:AbstractIL.Internal.Library.CompilationThreadToken * r:AssemblyResolution -> AbstractIL.Internal.Library.Cancellable AvailableImportedAssembly list)> - member RegisterCcu: ccuInfo:ImportedAssembly -> unit - member RegisterDll: dllInfo:ImportedBinary -> unit + member RegisterCcu : ccuInfo:ImportedAssembly -> unit + member RegisterDll : dllInfo:ImportedBinary -> unit member - ReportUnresolvedAssemblyReferences: CompilerConfig.UnresolvedAssemblyReference list -> + ReportUnresolvedAssemblyReferences : CompilerConfig.UnresolvedAssemblyReference list -> unit member - ResolveAssemblyReference: AbstractIL.Internal.Library.CompilationThreadToken * + ResolveAssemblyReference : AbstractIL.Internal.Library.CompilationThreadToken * CompilerConfig.AssemblyReference * ResolveAssemblyReferenceMode -> AssemblyResolution list - member private SetILGlobals: ilg:AbstractIL.IL.ILGlobals -> unit - member private SetTcGlobals: g:TcGlobals.TcGlobals -> unit - member SystemRuntimeContainsType: string -> bool - override ToString: unit -> string + member private SetILGlobals : ilg:AbstractIL.IL.ILGlobals -> unit + member private SetTcGlobals : g:TcGlobals.TcGlobals -> unit + member SystemRuntimeContainsType : string -> bool + override ToString : unit -> string member - TryFindDllInfo: AbstractIL.Internal.Library.CompilationThreadToken * + TryFindDllInfo : AbstractIL.Internal.Library.CompilationThreadToken * Range.range * string * lookupOnly:bool -> ImportedBinary option member - TryFindExistingFullyQualifiedPathByExactAssemblyRef: AbstractIL.Internal.Library.CompilationThreadToken * + TryFindExistingFullyQualifiedPathByExactAssemblyRef : AbstractIL.Internal.Library.CompilationThreadToken * AbstractIL.IL.ILAssemblyRef -> string option member - TryFindExistingFullyQualifiedPathBySimpleAssemblyName: AbstractIL.Internal.Library.CompilationThreadToken * + TryFindExistingFullyQualifiedPathBySimpleAssemblyName : AbstractIL.Internal.Library.CompilationThreadToken * string -> string option member - TryFindProviderGeneratedAssemblyByName: AbstractIL.Internal.Library.CompilationThreadToken * + TryFindProviderGeneratedAssemblyByName : AbstractIL.Internal.Library.CompilationThreadToken * assemblyName:string -> System.Reflection.Assembly option member - TryResolveAssemblyReference: AbstractIL.Internal.Library.CompilationThreadToken * + TryResolveAssemblyReference : AbstractIL.Internal.Library.CompilationThreadToken * CompilerConfig.AssemblyReference * ResolveAssemblyReferenceMode -> ErrorLogger.OperationResult - member Base: TcImports option - member CcuTable: AbstractIL.Internal.Library.NameMap + member Base : TcImports option + member CcuTable : AbstractIL.Internal.Library.NameMap member - DependencyProvider: Microsoft.DotNet.DependencyManager.DependencyProvider - member DllTable: AbstractIL.Internal.Library.NameMap + DependencyProvider : Microsoft.DotNet.DependencyManager.DependencyProvider + member DllTable : AbstractIL.Internal.Library.NameMap member - ProviderGeneratedTypeRoots: ExtensionTyping.ProviderGeneratedType list - member Weak: TcImportsWeakHack - - val RequireDLL: + ProviderGeneratedTypeRoots : ExtensionTyping.ProviderGeneratedType list + member Weak : TcImportsWeakHack + end + val RequireDLL : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcImports:TcImports * tcEnv:CheckExpressions.TcEnv * thisAssemblyName:string * referenceRange:Range.range * file:string -> CheckExpressions.TcEnv * (ImportedBinary list * ImportedAssembly list) - val DefaultReferencesForScriptsAndOutOfProjectSources: bool -> string list - + val DefaultReferencesForScriptsAndOutOfProjectSources : bool -> string list + end namespace FSharp.Compiler - module internal CompilerDiagnostics = - module CompilerService = - val showAssertForUnexpectedException: bool ref - + module internal CompilerDiagnostics = begin + module CompilerService = begin + val showAssertForUnexpectedException : bool ref + end exception HashIncludeNotAllowedInNonScript of Range.range exception HashReferenceNotAllowedInNonScript of Range.range exception HashLoadedSourceHasIssues of exn list * exn list * Range.range @@ -13749,489 +38816,489 @@ namespace FSharp.Compiler Range.range exception DeprecatedCommandLineOptionNoDescription of string * Range.range exception InternalCommandLineOption of string * Range.range - val GetRangeOfDiagnostic: + val GetRangeOfDiagnostic : ErrorLogger.PhasedDiagnostic -> Range.range option - val GetDiagnosticNumber: ErrorLogger.PhasedDiagnostic -> int - val GetWarningLevel: err:ErrorLogger.PhasedDiagnostic -> int - val warningOn: + val GetDiagnosticNumber : ErrorLogger.PhasedDiagnostic -> int + val GetWarningLevel : err:ErrorLogger.PhasedDiagnostic -> int + val warningOn : err:ErrorLogger.PhasedDiagnostic -> level:int -> specificWarnOn:int list -> bool - val SplitRelatedDiagnostics: + val SplitRelatedDiagnostics : ErrorLogger.PhasedDiagnostic -> ErrorLogger.PhasedDiagnostic * ErrorLogger.PhasedDiagnostic list - val DeclareMessage: + val DeclareMessage : (string * Printf.StringFormat<'a> -> DiagnosticMessage.ResourceString<'a>) - val SeeAlsoE: unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ConstraintSolverTupleDiffLengthsE: + val SeeAlsoE : unit -> DiagnosticMessage.ResourceString<(string -> string)> + val ConstraintSolverTupleDiffLengthsE : unit -> DiagnosticMessage.ResourceString<(int -> int -> string)> - val ConstraintSolverInfiniteTypesE: + val ConstraintSolverInfiniteTypesE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val ConstraintSolverMissingConstraintE: + val ConstraintSolverMissingConstraintE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ConstraintSolverTypesNotInEqualityRelation1E: + val ConstraintSolverTypesNotInEqualityRelation1E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val ConstraintSolverTypesNotInEqualityRelation2E: + val ConstraintSolverTypesNotInEqualityRelation2E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val ConstraintSolverTypesNotInSubsumptionRelationE: + val ConstraintSolverTypesNotInSubsumptionRelationE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ErrorFromAddingTypeEquation1E: + val ErrorFromAddingTypeEquation1E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ErrorFromAddingTypeEquation2E: + val ErrorFromAddingTypeEquation2E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ErrorFromApplyingDefault1E: + val ErrorFromApplyingDefault1E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ErrorFromApplyingDefault2E: + val ErrorFromApplyingDefault2E : unit -> DiagnosticMessage.ResourceString - val ErrorsFromAddingSubsumptionConstraintE: + val ErrorsFromAddingSubsumptionConstraintE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val UpperCaseIdentifierInPatternE: + val UpperCaseIdentifierInPatternE : unit -> DiagnosticMessage.ResourceString - val NotUpperCaseConstructorE: + val NotUpperCaseConstructorE : unit -> DiagnosticMessage.ResourceString - val FunctionExpectedE: unit -> DiagnosticMessage.ResourceString - val BakedInMemberConstraintNameE: + val FunctionExpectedE : unit -> DiagnosticMessage.ResourceString + val BakedInMemberConstraintNameE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val BadEventTransformationE: + val BadEventTransformationE : unit -> DiagnosticMessage.ResourceString - val ParameterlessStructCtorE: + val ParameterlessStructCtorE : unit -> DiagnosticMessage.ResourceString - val InterfaceNotRevealedE: + val InterfaceNotRevealedE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val TyconBadArgsE: + val TyconBadArgsE : unit -> DiagnosticMessage.ResourceString<(string -> int -> int -> string)> - val IndeterminateTypeE: unit -> DiagnosticMessage.ResourceString - val NameClash1E: + val IndeterminateTypeE : unit -> DiagnosticMessage.ResourceString + val NameClash1E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val NameClash2E: + val NameClash2E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string -> string -> string)> - val Duplicate1E: + val Duplicate1E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val Duplicate2E: + val Duplicate2E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val UndefinedName2E: unit -> DiagnosticMessage.ResourceString - val FieldNotMutableE: unit -> DiagnosticMessage.ResourceString - val FieldsFromDifferentTypesE: + val UndefinedName2E : unit -> DiagnosticMessage.ResourceString + val FieldNotMutableE : unit -> DiagnosticMessage.ResourceString + val FieldsFromDifferentTypesE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val VarBoundTwiceE: + val VarBoundTwiceE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val RecursionE: + val RecursionE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string -> string)> - val InvalidRuntimeCoercionE: + val InvalidRuntimeCoercionE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val IndeterminateRuntimeCoercionE: + val IndeterminateRuntimeCoercionE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val IndeterminateStaticCoercionE: + val IndeterminateStaticCoercionE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val StaticCoercionShouldUseBoxE: + val StaticCoercionShouldUseBoxE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val TypeIsImplicitlyAbstractE: + val TypeIsImplicitlyAbstractE : unit -> DiagnosticMessage.ResourceString - val NonRigidTypar1E: + val NonRigidTypar1E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val NonRigidTypar2E: + val NonRigidTypar2E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val NonRigidTypar3E: + val NonRigidTypar3E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val OBlockEndSentenceE: unit -> DiagnosticMessage.ResourceString - val UnexpectedEndOfInputE: unit -> DiagnosticMessage.ResourceString - val UnexpectedE: + val OBlockEndSentenceE : unit -> DiagnosticMessage.ResourceString + val UnexpectedEndOfInputE : unit -> DiagnosticMessage.ResourceString + val UnexpectedE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val NONTERM_interactionE: unit -> DiagnosticMessage.ResourceString - val NONTERM_hashDirectiveE: + val NONTERM_interactionE : unit -> DiagnosticMessage.ResourceString + val NONTERM_hashDirectiveE : unit -> DiagnosticMessage.ResourceString - val NONTERM_fieldDeclE: unit -> DiagnosticMessage.ResourceString - val NONTERM_unionCaseReprE: + val NONTERM_fieldDeclE : unit -> DiagnosticMessage.ResourceString + val NONTERM_unionCaseReprE : unit -> DiagnosticMessage.ResourceString - val NONTERM_localBindingE: unit -> DiagnosticMessage.ResourceString - val NONTERM_hardwhiteLetBindingsE: + val NONTERM_localBindingE : unit -> DiagnosticMessage.ResourceString + val NONTERM_hardwhiteLetBindingsE : unit -> DiagnosticMessage.ResourceString - val NONTERM_classDefnMemberE: + val NONTERM_classDefnMemberE : unit -> DiagnosticMessage.ResourceString - val NONTERM_defnBindingsE: unit -> DiagnosticMessage.ResourceString - val NONTERM_classMemberSpfnE: + val NONTERM_defnBindingsE : unit -> DiagnosticMessage.ResourceString + val NONTERM_classMemberSpfnE : unit -> DiagnosticMessage.ResourceString - val NONTERM_valSpfnE: unit -> DiagnosticMessage.ResourceString - val NONTERM_tyconSpfnE: unit -> DiagnosticMessage.ResourceString - val NONTERM_anonLambdaExprE: + val NONTERM_valSpfnE : unit -> DiagnosticMessage.ResourceString + val NONTERM_tyconSpfnE : unit -> DiagnosticMessage.ResourceString + val NONTERM_anonLambdaExprE : unit -> DiagnosticMessage.ResourceString - val NONTERM_attrUnionCaseDeclE: + val NONTERM_attrUnionCaseDeclE : unit -> DiagnosticMessage.ResourceString - val NONTERM_cPrototypeE: unit -> DiagnosticMessage.ResourceString - val NONTERM_objectImplementationMembersE: + val NONTERM_cPrototypeE : unit -> DiagnosticMessage.ResourceString + val NONTERM_objectImplementationMembersE : unit -> DiagnosticMessage.ResourceString - val NONTERM_ifExprCasesE: unit -> DiagnosticMessage.ResourceString - val NONTERM_openDeclE: unit -> DiagnosticMessage.ResourceString - val NONTERM_fileModuleSpecE: + val NONTERM_ifExprCasesE : unit -> DiagnosticMessage.ResourceString + val NONTERM_openDeclE : unit -> DiagnosticMessage.ResourceString + val NONTERM_fileModuleSpecE : unit -> DiagnosticMessage.ResourceString - val NONTERM_patternClausesE: + val NONTERM_patternClausesE : unit -> DiagnosticMessage.ResourceString - val NONTERM_beginEndExprE: unit -> DiagnosticMessage.ResourceString - val NONTERM_recdExprE: unit -> DiagnosticMessage.ResourceString - val NONTERM_tyconDefnE: unit -> DiagnosticMessage.ResourceString - val NONTERM_exconCoreE: unit -> DiagnosticMessage.ResourceString - val NONTERM_typeNameInfoE: unit -> DiagnosticMessage.ResourceString - val NONTERM_attributeListE: + val NONTERM_beginEndExprE : unit -> DiagnosticMessage.ResourceString + val NONTERM_recdExprE : unit -> DiagnosticMessage.ResourceString + val NONTERM_tyconDefnE : unit -> DiagnosticMessage.ResourceString + val NONTERM_exconCoreE : unit -> DiagnosticMessage.ResourceString + val NONTERM_typeNameInfoE : unit -> DiagnosticMessage.ResourceString + val NONTERM_attributeListE : unit -> DiagnosticMessage.ResourceString - val NONTERM_quoteExprE: unit -> DiagnosticMessage.ResourceString - val NONTERM_typeConstraintE: + val NONTERM_quoteExprE : unit -> DiagnosticMessage.ResourceString + val NONTERM_typeConstraintE : unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_ImplementationFileE: + val NONTERM_Category_ImplementationFileE : unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_DefinitionE: + val NONTERM_Category_DefinitionE : unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_SignatureFileE: + val NONTERM_Category_SignatureFileE : unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_PatternE: + val NONTERM_Category_PatternE : unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_ExprE: + val NONTERM_Category_ExprE : unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_TypeE: + val NONTERM_Category_TypeE : unit -> DiagnosticMessage.ResourceString - val NONTERM_typeArgsActualE: + val NONTERM_typeArgsActualE : unit -> DiagnosticMessage.ResourceString - val TokenName1E: + val TokenName1E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val TokenName1TokenName2E: + val TokenName1TokenName2E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val TokenName1TokenName2TokenName3E: + val TokenName1TokenName2TokenName3E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val RuntimeCoercionSourceSealed1E: + val RuntimeCoercionSourceSealed1E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val RuntimeCoercionSourceSealed2E: + val RuntimeCoercionSourceSealed2E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val CoercionTargetSealedE: + val CoercionTargetSealedE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UpcastUnnecessaryE: unit -> DiagnosticMessage.ResourceString - val TypeTestUnnecessaryE: unit -> DiagnosticMessage.ResourceString - val OverrideDoesntOverride1E: + val UpcastUnnecessaryE : unit -> DiagnosticMessage.ResourceString + val TypeTestUnnecessaryE : unit -> DiagnosticMessage.ResourceString + val OverrideDoesntOverride1E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val OverrideDoesntOverride2E: + val OverrideDoesntOverride2E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val OverrideDoesntOverride3E: + val OverrideDoesntOverride3E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val OverrideDoesntOverride4E: + val OverrideDoesntOverride4E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UnionCaseWrongArgumentsE: + val UnionCaseWrongArgumentsE : unit -> DiagnosticMessage.ResourceString<(int -> int -> string)> - val UnionPatternsBindDifferentNamesE: + val UnionPatternsBindDifferentNamesE : unit -> DiagnosticMessage.ResourceString - val RequiredButNotSpecifiedE: + val RequiredButNotSpecifiedE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val UseOfAddressOfOperatorE: + val UseOfAddressOfOperatorE : unit -> DiagnosticMessage.ResourceString - val DefensiveCopyWarningE: + val DefensiveCopyWarningE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val DeprecatedThreadStaticBindingWarningE: + val DeprecatedThreadStaticBindingWarningE : unit -> DiagnosticMessage.ResourceString - val FunctionValueUnexpectedE: + val FunctionValueUnexpectedE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UnitTypeExpectedE: + val UnitTypeExpectedE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UnitTypeExpectedWithEqualityE: + val UnitTypeExpectedWithEqualityE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UnitTypeExpectedWithPossiblePropertySetterE: + val UnitTypeExpectedWithPossiblePropertySetterE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val UnitTypeExpectedWithPossibleAssignmentE: + val UnitTypeExpectedWithPossibleAssignmentE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val UnitTypeExpectedWithPossibleAssignmentToMutableE: + val UnitTypeExpectedWithPossibleAssignmentToMutableE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val RecursiveUseCheckedAtRuntimeE: + val RecursiveUseCheckedAtRuntimeE : unit -> DiagnosticMessage.ResourceString - val LetRecUnsound1E: + val LetRecUnsound1E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val LetRecUnsound2E: + val LetRecUnsound2E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val LetRecUnsoundInnerE: + val LetRecUnsoundInnerE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val LetRecEvaluatedOutOfOrderE: + val LetRecEvaluatedOutOfOrderE : unit -> DiagnosticMessage.ResourceString - val LetRecCheckedAtRuntimeE: + val LetRecCheckedAtRuntimeE : unit -> DiagnosticMessage.ResourceString - val SelfRefObjCtor1E: unit -> DiagnosticMessage.ResourceString - val SelfRefObjCtor2E: unit -> DiagnosticMessage.ResourceString - val VirtualAugmentationOnNullValuedTypeE: + val SelfRefObjCtor1E : unit -> DiagnosticMessage.ResourceString + val SelfRefObjCtor2E : unit -> DiagnosticMessage.ResourceString + val VirtualAugmentationOnNullValuedTypeE : unit -> DiagnosticMessage.ResourceString - val NonVirtualAugmentationOnNullValuedTypeE: + val NonVirtualAugmentationOnNullValuedTypeE : unit -> DiagnosticMessage.ResourceString - val NonUniqueInferredAbstractSlot1E: + val NonUniqueInferredAbstractSlot1E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val NonUniqueInferredAbstractSlot2E: + val NonUniqueInferredAbstractSlot2E : unit -> DiagnosticMessage.ResourceString - val NonUniqueInferredAbstractSlot3E: + val NonUniqueInferredAbstractSlot3E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val NonUniqueInferredAbstractSlot4E: + val NonUniqueInferredAbstractSlot4E : unit -> DiagnosticMessage.ResourceString - val Failure3E: unit -> DiagnosticMessage.ResourceString<(string -> string)> - val Failure4E: unit -> DiagnosticMessage.ResourceString<(string -> string)> - val MatchIncomplete1E: unit -> DiagnosticMessage.ResourceString - val MatchIncomplete2E: + val Failure3E : unit -> DiagnosticMessage.ResourceString<(string -> string)> + val Failure4E : unit -> DiagnosticMessage.ResourceString<(string -> string)> + val MatchIncomplete1E : unit -> DiagnosticMessage.ResourceString + val MatchIncomplete2E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val MatchIncomplete3E: + val MatchIncomplete3E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val MatchIncomplete4E: unit -> DiagnosticMessage.ResourceString - val RuleNeverMatchedE: unit -> DiagnosticMessage.ResourceString - val EnumMatchIncomplete1E: unit -> DiagnosticMessage.ResourceString - val ValNotMutableE: + val MatchIncomplete4E : unit -> DiagnosticMessage.ResourceString + val RuleNeverMatchedE : unit -> DiagnosticMessage.ResourceString + val EnumMatchIncomplete1E : unit -> DiagnosticMessage.ResourceString + val ValNotMutableE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ValNotLocalE: unit -> DiagnosticMessage.ResourceString - val Obsolete1E: unit -> DiagnosticMessage.ResourceString - val Obsolete2E: + val ValNotLocalE : unit -> DiagnosticMessage.ResourceString + val Obsolete1E : unit -> DiagnosticMessage.ResourceString + val Obsolete2E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ExperimentalE: + val ExperimentalE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val PossibleUnverifiableCodeE: + val PossibleUnverifiableCodeE : unit -> DiagnosticMessage.ResourceString - val DeprecatedE: + val DeprecatedE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val LibraryUseOnlyE: unit -> DiagnosticMessage.ResourceString - val MissingFieldsE: + val LibraryUseOnlyE : unit -> DiagnosticMessage.ResourceString + val MissingFieldsE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ValueRestriction1E: + val ValueRestriction1E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ValueRestriction2E: + val ValueRestriction2E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ValueRestriction3E: + val ValueRestriction3E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ValueRestriction4E: + val ValueRestriction4E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ValueRestriction5E: + val ValueRestriction5E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val RecoverableParseErrorE: + val RecoverableParseErrorE : unit -> DiagnosticMessage.ResourceString - val ReservedKeywordE: + val ReservedKeywordE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val IndentationProblemE: + val IndentationProblemE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val OverrideInIntrinsicAugmentationE: + val OverrideInIntrinsicAugmentationE : unit -> DiagnosticMessage.ResourceString - val OverrideInExtrinsicAugmentationE: + val OverrideInExtrinsicAugmentationE : unit -> DiagnosticMessage.ResourceString - val IntfImplInIntrinsicAugmentationE: + val IntfImplInIntrinsicAugmentationE : unit -> DiagnosticMessage.ResourceString - val IntfImplInExtrinsicAugmentationE: + val IntfImplInExtrinsicAugmentationE : unit -> DiagnosticMessage.ResourceString - val UnresolvedReferenceNoRangeE: + val UnresolvedReferenceNoRangeE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UnresolvedPathReferenceNoRangeE: + val UnresolvedPathReferenceNoRangeE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val HashIncludeNotAllowedInNonScriptE: + val HashIncludeNotAllowedInNonScriptE : unit -> DiagnosticMessage.ResourceString - val HashReferenceNotAllowedInNonScriptE: + val HashReferenceNotAllowedInNonScriptE : unit -> DiagnosticMessage.ResourceString - val HashDirectiveNotAllowedInNonScriptE: + val HashDirectiveNotAllowedInNonScriptE : unit -> DiagnosticMessage.ResourceString - val FileNameNotResolvedE: + val FileNameNotResolvedE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val AssemblyNotResolvedE: + val AssemblyNotResolvedE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val HashLoadedSourceHasIssues1E: + val HashLoadedSourceHasIssues1E : unit -> DiagnosticMessage.ResourceString - val HashLoadedSourceHasIssues2E: + val HashLoadedSourceHasIssues2E : unit -> DiagnosticMessage.ResourceString - val HashLoadedScriptConsideredSourceE: + val HashLoadedScriptConsideredSourceE : unit -> DiagnosticMessage.ResourceString - val InvalidInternalsVisibleToAssemblyName1E: + val InvalidInternalsVisibleToAssemblyName1E : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val InvalidInternalsVisibleToAssemblyName2E: + val InvalidInternalsVisibleToAssemblyName2E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val LoadedSourceNotFoundIgnoringE: + val LoadedSourceNotFoundIgnoringE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val MSBuildReferenceResolutionErrorE: + val MSBuildReferenceResolutionErrorE : unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val TargetInvocationExceptionWrapperE: + val TargetInvocationExceptionWrapperE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val getErrorString: key:string -> string - val ( |InvalidArgument|_| ): exn:exn -> string option - val OutputPhasedErrorR: + val getErrorString : key:string -> string + val ( |InvalidArgument|_| ) : exn:exn -> string option + val OutputPhasedErrorR : os:System.Text.StringBuilder -> err:ErrorLogger.PhasedDiagnostic -> canSuggestNames:bool -> unit - val OutputPhasedDiagnostic: + val OutputPhasedDiagnostic : System.Text.StringBuilder -> ErrorLogger.PhasedDiagnostic -> flattenErrors:bool -> suggestNames:bool -> unit - val SanitizeFileName: + val SanitizeFileName : fileName:string -> implicitIncludeDir:string -> string - [] + [] type DiagnosticLocation = { Range: Range.range File: string TextRepresentation: string IsEmpty: bool } - [] + [] type DiagnosticCanonicalInformation = { ErrorNumber: int Subcategory: string TextRepresentation: string } - [] + [] type DiagnosticDetailedInfo = { Location: DiagnosticLocation option Canonical: DiagnosticCanonicalInformation Message: string } - [] + [] type Diagnostic = | Short of bool * string | Long of bool * DiagnosticDetailedInfo - val CollectDiagnostic: + val CollectDiagnostic : implicitIncludeDir:string * showFullPaths:bool * flattenErrors:bool * errorStyle:ErrorLogger.ErrorStyle * isError:bool * ErrorLogger.PhasedDiagnostic * suggestNames:bool -> seq - val OutputDiagnostic: + val OutputDiagnostic : implicitIncludeDir:string * showFullPaths:bool * flattenErrors:bool * errorStyle:ErrorLogger.ErrorStyle * isError:bool -> System.Text.StringBuilder -> ErrorLogger.PhasedDiagnostic -> unit - val OutputDiagnosticContext: + val OutputDiagnosticContext : prefix:string -> fileLineFunction:(string -> int -> string) -> System.Text.StringBuilder -> ErrorLogger.PhasedDiagnostic -> unit - val ReportWarning: + val ReportWarning : ErrorLogger.FSharpErrorSeverityOptions -> ErrorLogger.PhasedDiagnostic -> bool - val ReportWarningAsError: + val ReportWarningAsError : ErrorLogger.FSharpErrorSeverityOptions -> ErrorLogger.PhasedDiagnostic -> bool type ErrorLoggerFilteringByScopedPragmas = - + class inherit ErrorLogger.ErrorLogger - new: checkFile:bool * scopedPragmas:SyntaxTree.ScopedPragma list * + new : checkFile:bool * scopedPragmas:SyntaxTree.ScopedPragma list * errorLogger:ErrorLogger.ErrorLogger -> ErrorLoggerFilteringByScopedPragmas override - DiagnosticSink: phasedError:ErrorLogger.PhasedDiagnostic * + DiagnosticSink : phasedError:ErrorLogger.PhasedDiagnostic * isError:bool -> unit - override ErrorCount: int - - val GetErrorLoggerFilteringByScopedPragmas: + override ErrorCount : int + end + val GetErrorLoggerFilteringByScopedPragmas : checkFile:bool * SyntaxTree.ScopedPragma list * ErrorLogger.ErrorLogger -> ErrorLogger.ErrorLogger - + end namespace FSharp.Compiler - module internal ParseAndCheckInputs = - val CanonicalizeFilename: filename:string -> string - val IsScript: string -> bool - val QualFileNameOfModuleName: + module internal ParseAndCheckInputs = begin + val CanonicalizeFilename : filename:string -> string + val IsScript : string -> bool + val QualFileNameOfModuleName : m:Range.range -> filename:string -> modname:SyntaxTree.Ident list -> SyntaxTree.QualifiedNameOfFile - val QualFileNameOfFilename: + val QualFileNameOfFilename : m:Range.range -> filename:string -> SyntaxTree.QualifiedNameOfFile - val ComputeQualifiedNameOfFileFromUniquePath: + val ComputeQualifiedNameOfFileFromUniquePath : Range.range * string list -> SyntaxTree.QualifiedNameOfFile - val QualFileNameOfSpecs: + val QualFileNameOfSpecs : filename:string -> specs:SyntaxTree.SynModuleOrNamespaceSig list -> SyntaxTree.QualifiedNameOfFile - val QualFileNameOfImpls: + val QualFileNameOfImpls : filename:string -> specs:SyntaxTree.SynModuleOrNamespace list -> SyntaxTree.QualifiedNameOfFile - val PrependPathToQualFileName: + val PrependPathToQualFileName : x:SyntaxTree.Ident list -> SyntaxTree.QualifiedNameOfFile -> SyntaxTree.QualifiedNameOfFile - val PrependPathToImpl: + val PrependPathToImpl : x:SyntaxTree.Ident list -> SyntaxTree.SynModuleOrNamespace -> SyntaxTree.SynModuleOrNamespace - val PrependPathToSpec: + val PrependPathToSpec : x:SyntaxTree.Ident list -> SyntaxTree.SynModuleOrNamespaceSig -> SyntaxTree.SynModuleOrNamespaceSig - val PrependPathToInput: + val PrependPathToInput : SyntaxTree.Ident list -> SyntaxTree.ParsedInput -> SyntaxTree.ParsedInput - val ComputeAnonModuleName: + val ComputeAnonModuleName : check:bool -> defaultNamespace:string option -> filename:string -> m:Range.range -> SyntaxTree.Ident list - val PostParseModuleImpl: + val PostParseModuleImpl : _i:'a * defaultNamespace:string option * isLastCompiland:(bool * bool) * filename:string * impl:SyntaxTree.ParsedImplFileFragment -> SyntaxTree.SynModuleOrNamespace - val PostParseModuleSpec: + val PostParseModuleSpec : _i:'a * defaultNamespace:string option * isLastCompiland:(bool * bool) * filename:string * intf:SyntaxTree.ParsedSigFileFragment -> SyntaxTree.SynModuleOrNamespaceSig - val GetScopedPragmasForInput: + val GetScopedPragmasForInput : input:SyntaxTree.ParsedInput -> SyntaxTree.ScopedPragma list - val GetScopedPragmasForHashDirective: + val GetScopedPragmasForHashDirective : hd:SyntaxTree.ParsedHashDirective -> SyntaxTree.ScopedPragma list - val PostParseModuleImpls: + val PostParseModuleImpls : defaultNamespace:string option * filename:string * isLastCompiland:(bool * bool) * SyntaxTree.ParsedImplFile -> SyntaxTree.ParsedInput - val PostParseModuleSpecs: + val PostParseModuleSpecs : defaultNamespace:string option * filename:string * isLastCompiland:(bool * bool) * SyntaxTree.ParsedSigFile -> SyntaxTree.ParsedInput type ModuleNamesDict = Map> - val DeduplicateModuleName: + val DeduplicateModuleName : moduleNamesDict:ModuleNamesDict -> fileName:string -> qualNameOfFile:SyntaxTree.QualifiedNameOfFile -> SyntaxTree.QualifiedNameOfFile * ModuleNamesDict - val DeduplicateParsedInputModuleName: + val DeduplicateParsedInputModuleName : ModuleNamesDict -> SyntaxTree.ParsedInput -> SyntaxTree.ParsedInput * ModuleNamesDict - val ParseInput: + val ParseInput : (Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token) * ErrorLogger.ErrorLogger * UnicodeLexing.Lexbuf * string option * string * isLastCompiland:(bool * bool) -> SyntaxTree.ParsedInput - val ShowAllTokensAndExit: + val ShowAllTokensAndExit : shortFilename:string * tokenizer:LexFilter.LexFilter * lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> unit - val TestInteractionParserAndExit: + val TestInteractionParserAndExit : tokenizer:LexFilter.LexFilter * lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> 'a - val ReportParsingStatistics: res:SyntaxTree.ParsedInput -> unit - val ParseOneInputLexbuf: + val ReportParsingStatistics : res:SyntaxTree.ParsedInput -> unit + val ParseOneInputLexbuf : tcConfig:CompilerConfig.TcConfig * lexResourceManager:Lexhelp.LexResourceManager * conditionalCompilationDefines:string list * lexbuf:UnicodeLexing.Lexbuf * filename:string * isLastCompiland:(bool * bool) * errorLogger:ErrorLogger.ErrorLogger -> SyntaxTree.ParsedInput option - val ValidSuffixes: string list - val ParseOneInputFile: + val ValidSuffixes : string list + val ParseOneInputFile : CompilerConfig.TcConfig * Lexhelp.LexResourceManager * string list * string * isLastCompiland:(bool * bool) * ErrorLogger.ErrorLogger * bool -> SyntaxTree.ParsedInput option - val ProcessMetaCommandsFromInput: + val ProcessMetaCommandsFromInput : (('T -> Range.range * string -> 'T) * ('T -> Range.range * string * CompilerConfig.Directive -> 'T) * ('T -> Range.range * string -> unit)) -> CompilerConfig.TcConfigBuilder * SyntaxTree.ParsedInput * string * 'T -> 'T - val ApplyNoWarnsToTcConfig: + val ApplyNoWarnsToTcConfig : CompilerConfig.TcConfig * SyntaxTree.ParsedInput * string -> CompilerConfig.TcConfig - val ApplyMetaCommandsFromInputToTcConfig: + val ApplyMetaCommandsFromInputToTcConfig : CompilerConfig.TcConfig * SyntaxTree.ParsedInput * string * Microsoft.DotNet.DependencyManager.DependencyProvider -> CompilerConfig.TcConfig - val GetInitialTcEnv: + val GetInitialTcEnv : assemblyName:string * Range.range * CompilerConfig.TcConfig * CompilerImports.TcImports * TcGlobals.TcGlobals -> CheckExpressions.TcEnv - val CheckSimulateException: tcConfig:CompilerConfig.TcConfig -> unit + val CheckSimulateException : tcConfig:CompilerConfig.TcConfig -> unit type RootSigs = AbstractIL.Internal.Zmap type RootImpls = AbstractIL.Internal.Zset - val qnameOrder: + val qnameOrder : System.Collections.Generic.IComparer - [] + [] type TcState = { tcsCcu: TypedTree.CcuThunk tcsCcuType: TypedTree.ModuleOrNamespace @@ -14244,20 +39311,20 @@ namespace FSharp.Compiler tcsCcuSig: TypedTree.ModuleOrNamespaceType } with member - NextStateAfterIncrementalFragment: CheckExpressions.TcEnv -> TcState - member Ccu: TypedTree.CcuThunk - member CcuSig: TypedTree.ModuleOrNamespaceType - member CcuType: TypedTree.ModuleOrNamespace - member CreatesGeneratedProvidedTypes: bool - member NiceNameGenerator: CompilerGlobalState.NiceNameGenerator - member TcEnvFromImpls: CheckExpressions.TcEnv - member TcEnvFromSignatures: CheckExpressions.TcEnv - - val GetInitialTcState: + NextStateAfterIncrementalFragment : CheckExpressions.TcEnv -> TcState + member Ccu : TypedTree.CcuThunk + member CcuSig : TypedTree.ModuleOrNamespaceType + member CcuType : TypedTree.ModuleOrNamespace + member CreatesGeneratedProvidedTypes : bool + member NiceNameGenerator : CompilerGlobalState.NiceNameGenerator + member TcEnvFromImpls : CheckExpressions.TcEnv + member TcEnvFromSignatures : CheckExpressions.TcEnv + end + val GetInitialTcState : Range.range * string * CompilerConfig.TcConfig * TcGlobals.TcGlobals * CompilerImports.TcImports * CompilerGlobalState.NiceNameGenerator * CheckExpressions.TcEnv -> TcState - val TypeCheckOneInputEventually: + val TypeCheckOneInputEventually : checkForErrors:(unit -> bool) * CompilerConfig.TcConfig * CompilerImports.TcImports * TcGlobals.TcGlobals * SyntaxTree.LongIdent option * NameResolution.TcResultsSink * TcState * @@ -14267,7 +39334,7 @@ namespace FSharp.Compiler TypedTree.TypedImplFile option * TypedTree.ModuleOrNamespaceType) * TcState> - val TypeCheckOneInput: + val TypeCheckOneInput : ctok:AbstractIL.Internal.Library.CompilationThreadToken * checkForErrors:(unit -> bool) * tcConfig:CompilerConfig.TcConfig * tcImports:CompilerImports.TcImports * tcGlobals:TcGlobals.TcGlobals * @@ -14277,12 +39344,12 @@ namespace FSharp.Compiler (CheckExpressions.TcEnv * CheckDeclarations.TopAttribs * TypedTree.TypedImplFile option * TypedTree.ModuleOrNamespaceType) * TcState - val TypeCheckMultipleInputsFinish: + val TypeCheckMultipleInputsFinish : (CheckExpressions.TcEnv * CheckDeclarations.TopAttribs * 'T option * 'U) list * TcState -> (CheckExpressions.TcEnv * CheckDeclarations.TopAttribs * 'T list * 'U list) * TcState - val TypeCheckOneInputAndFinishEventually: + val TypeCheckOneInputAndFinishEventually : checkForErrors:(unit -> bool) * CompilerConfig.TcConfig * CompilerImports.TcImports * TcGlobals.TcGlobals * SyntaxTree.LongIdent option * NameResolution.TcResultsSink * TcState * @@ -14292,27 +39359,27 @@ namespace FSharp.Compiler TypedTree.TypedImplFile list * TypedTree.ModuleOrNamespaceType list) * TcState> - val TypeCheckClosedInputSetFinish: + val TypeCheckClosedInputSetFinish : TypedTree.TypedImplFile list * TcState -> TcState * TypedTree.TypedImplFile list - val TypeCheckClosedInputSet: + val TypeCheckClosedInputSet : AbstractIL.Internal.Library.CompilationThreadToken * checkForErrors:(unit -> bool) * CompilerConfig.TcConfig * CompilerImports.TcImports * TcGlobals.TcGlobals * SyntaxTree.LongIdent option * TcState * SyntaxTree.ParsedInput list -> TcState * CheckDeclarations.TopAttribs * TypedTree.TypedImplFile list * CheckExpressions.TcEnv - + end namespace FSharp.Compiler - module internal ScriptClosure = - [] + module internal ScriptClosure = begin + [] type LoadClosureInput = { FileName: string SyntaxTree: SyntaxTree.ParsedInput option ParseDiagnostics: (ErrorLogger.PhasedDiagnostic * bool) list MetaCommandDiagnostics: (ErrorLogger.PhasedDiagnostic * bool) list } - [] + [] type LoadClosure = { SourceFiles: (string * Range.range list) list References: (string * CompilerImports.AssemblyResolution list) list @@ -14327,7 +39394,7 @@ namespace FSharp.Compiler (ErrorLogger.PhasedDiagnostic * bool) list } with static member - ComputeClosureOfScriptFiles: AbstractIL.Internal.Library.CompilationThreadToken * + ComputeClosureOfScriptFiles : AbstractIL.Internal.Library.CompilationThreadToken * tcConfig:CompilerConfig.TcConfig * (string * Range.range) list * implicitDefines:CodeContext * @@ -14335,7 +39402,7 @@ namespace FSharp.Compiler dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> LoadClosure static member - ComputeClosureOfScriptText: AbstractIL.Internal.Library.CompilationThreadToken * + ComputeClosureOfScriptText : AbstractIL.Internal.Library.CompilationThreadToken * legacyReferenceResolver:ReferenceResolver.Resolver * defaultFSharpBinariesDir:string * filename:string * @@ -14351,13 +39418,13 @@ namespace FSharp.Compiler reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> LoadClosure - - [] + end + [] type CodeContext = | CompilationAndEvaluation | Compilation | Editing - module ScriptPreprocessClosure = + module ScriptPreprocessClosure = begin type ClosureSource = | ClosureSource of filename: string * referenceRange: Range.range * @@ -14369,17 +39436,17 @@ namespace FSharp.Compiler (ErrorLogger.PhasedDiagnostic * bool) list * (string * Range.range) list type Observed = - - new: unit -> Observed - member HaveSeen: check:string -> bool - member SetSeen: check:string -> unit - - val ParseScriptText: + class + new : unit -> Observed + member HaveSeen : check:string -> bool + member SetSeen : check:string -> unit + end + val ParseScriptText : filename:string * sourceText:Text.ISourceText * tcConfig:CompilerConfig.TcConfig * codeContext:CodeContext * lexResourceManager:Lexhelp.LexResourceManager * errorLogger:ErrorLogger.ErrorLogger -> SyntaxTree.ParsedInput option - val CreateScriptTextTcConfig: + val CreateScriptTextTcConfig : legacyReferenceResolver:ReferenceResolver.Resolver * defaultFSharpBinariesDir:string * filename:string * codeContext:CodeContext * useSimpleResolution:bool * useFsiAuxLib:bool * @@ -14389,27 +39456,27 @@ namespace FSharp.Compiler tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag -> CompilerConfig.TcConfig - val ClosureSourceOfFilename: + val ClosureSourceOfFilename : filename:string * m:Range.range * inputCodePage:int option * parseRequired:bool -> ClosureSource list - val ApplyMetaCommandsFromInputToTcConfigAndGatherNoWarn: + val ApplyMetaCommandsFromInputToTcConfigAndGatherNoWarn : tcConfig:CompilerConfig.TcConfig * inp:SyntaxTree.ParsedInput * pathOfMetaCommandSource:string * dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> CompilerConfig.TcConfig * (string * Range.range) list - val FindClosureFiles: + val FindClosureFiles : mainFile:string * _m:'a * closureSources:ClosureSource list * origTcConfig:CompilerConfig.TcConfig * codeContext:CodeContext * lexResourceManager:Lexhelp.LexResourceManager * dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> ClosureFile list * CompilerConfig.TcConfig * (Range.range * string list) [] - val GetLoadClosure: + val GetLoadClosure : ctok:AbstractIL.Internal.Library.CompilationThreadToken * rootFilename:string * closureFiles:ClosureFile list * tcConfig:CompilerConfig.TcConfig * codeContext:CodeContext * packageReferences:(Range.range * string list) [] -> LoadClosure - val GetFullClosureOfScriptText: + val GetFullClosureOfScriptText : ctok:AbstractIL.Internal.Library.CompilationThreadToken * legacyReferenceResolver:ReferenceResolver.Resolver * defaultFSharpBinariesDir:string * filename:string * @@ -14422,20 +39489,20 @@ namespace FSharp.Compiler reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> LoadClosure - val GetFullClosureOfScriptFiles: + val GetFullClosureOfScriptFiles : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfig:CompilerConfig.TcConfig * files:(string * Range.range) list * codeContext:CodeContext * lexResourceManager:Lexhelp.LexResourceManager * dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> LoadClosure - - + end + end namespace FSharp.Compiler - module internal CompilerOptions = - module Attributes = - - [] + module internal CompilerOptions = begin + module Attributes = begin + end + [] type OptionSwitch = | On | Off @@ -14460,319 +39527,319 @@ namespace FSharp.Compiler and CompilerOptionBlock = | PublicOptions of string * CompilerOption list | PrivateOptions of CompilerOption list - val GetOptionsOfBlock: block:CompilerOptionBlock -> CompilerOption list - val FilterCompilerOptionBlock: + val GetOptionsOfBlock : block:CompilerOptionBlock -> CompilerOption list + val FilterCompilerOptionBlock : (CompilerOption -> bool) -> CompilerOptionBlock -> CompilerOptionBlock - val compilerOptionUsage: CompilerOption -> string - val PrintCompilerOption: CompilerOption -> unit - val PrintPublicOptions: heading:string * opts:CompilerOption list -> unit - val PrintCompilerOptionBlocks: CompilerOptionBlock list -> unit - val dumpCompilerOption: prefix:string -> CompilerOption -> unit - val dumpCompilerOptionBlock: _arg1:CompilerOptionBlock -> unit - val DumpCompilerOptionBlocks: CompilerOptionBlock list -> unit - val isSlashOpt: opt:string -> bool - module ResponseFile = + val compilerOptionUsage : CompilerOption -> string + val PrintCompilerOption : CompilerOption -> unit + val PrintPublicOptions : heading:string * opts:CompilerOption list -> unit + val PrintCompilerOptionBlocks : CompilerOptionBlock list -> unit + val dumpCompilerOption : prefix:string -> CompilerOption -> unit + val dumpCompilerOptionBlock : _arg1:CompilerOptionBlock -> unit + val DumpCompilerOptionBlocks : CompilerOptionBlock list -> unit + val isSlashOpt : opt:string -> bool + module ResponseFile = begin type ResponseFileData = ResponseFileLine list and ResponseFileLine = | CompilerOptionSpec of string | Comment of string - val parseFile: path:string -> Choice - - val ParseCompilerOptions: + val parseFile : path:string -> Choice + end + val ParseCompilerOptions : (string -> unit) * CompilerOptionBlock list * string list -> unit - val lexFilterVerbose: bool - val mutable enableConsoleColoring: bool - val setFlag: r:(bool -> 'a) -> n:int -> 'a - val SetOptimizeOff: tcConfigB:CompilerConfig.TcConfigBuilder -> unit - val SetOptimizeOn: tcConfigB:CompilerConfig.TcConfigBuilder -> unit - val SetOptimizeSwitch: + val lexFilterVerbose : bool + val mutable enableConsoleColoring : bool + val setFlag : r:(bool -> 'a) -> n:int -> 'a + val SetOptimizeOff : tcConfigB:CompilerConfig.TcConfigBuilder -> unit + val SetOptimizeOn : tcConfigB:CompilerConfig.TcConfigBuilder -> unit + val SetOptimizeSwitch : CompilerConfig.TcConfigBuilder -> OptionSwitch -> unit - val SetTailcallSwitch: + val SetTailcallSwitch : CompilerConfig.TcConfigBuilder -> OptionSwitch -> unit - val SetDeterministicSwitch: + val SetDeterministicSwitch : tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val AddPathMapping: + val AddPathMapping : tcConfigB:CompilerConfig.TcConfigBuilder -> pathPair:string -> unit - val jitoptimizeSwitch: + val jitoptimizeSwitch : tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val localoptimizeSwitch: + val localoptimizeSwitch : tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val crossOptimizeSwitch: + val crossOptimizeSwitch : tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val splittingSwitch: + val splittingSwitch : tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val callVirtSwitch: + val callVirtSwitch : tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val useHighEntropyVASwitch: + val useHighEntropyVASwitch : tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val subSystemVersionSwitch: + val subSystemVersionSwitch : tcConfigB:CompilerConfig.TcConfigBuilder -> text:string -> unit - val SetUseSdkSwitch: + val SetUseSdkSwitch : tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val ( ++ ): x:'a list -> s:'a -> 'a list - val SetTarget: tcConfigB:CompilerConfig.TcConfigBuilder -> s:string -> unit - val SetDebugSwitch: + val ( ++ ) : x:'a list -> s:'a -> 'a list + val SetTarget : tcConfigB:CompilerConfig.TcConfigBuilder -> s:string -> unit + val SetDebugSwitch : CompilerConfig.TcConfigBuilder -> string option -> OptionSwitch -> unit - val SetEmbedAllSourceSwitch: + val SetEmbedAllSourceSwitch : tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val setOutFileName: + val setOutFileName : tcConfigB:CompilerConfig.TcConfigBuilder -> path:string -> unit - val setSignatureFile: + val setSignatureFile : tcConfigB:CompilerConfig.TcConfigBuilder -> s:string -> unit - val tagString: string - val tagExe: string - val tagWinExe: string - val tagLibrary: string - val tagModule: string - val tagFile: string - val tagFileList: string - val tagDirList: string - val tagPathList: string - val tagResInfo: string - val tagFullPDBOnlyPortable: string - val tagWarnList: string - val tagSymbolList: string - val tagAddress: string - val tagAlgorithm: string - val tagInt: string - val tagPathMap: string - val tagNone: string - val tagLangVersionValues: string - val PrintOptionInfo: CompilerConfig.TcConfigBuilder -> unit - val inputFileFlagsBoth: + val tagString : string + val tagExe : string + val tagWinExe : string + val tagLibrary : string + val tagModule : string + val tagFile : string + val tagFileList : string + val tagDirList : string + val tagPathList : string + val tagResInfo : string + val tagFullPDBOnlyPortable : string + val tagWarnList : string + val tagSymbolList : string + val tagAddress : string + val tagAlgorithm : string + val tagInt : string + val tagPathMap : string + val tagNone : string + val tagLangVersionValues : string + val PrintOptionInfo : CompilerConfig.TcConfigBuilder -> unit + val inputFileFlagsBoth : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val referenceFlagAbbrev: + val referenceFlagAbbrev : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val compilerToolFlagAbbrev: + val compilerToolFlagAbbrev : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val inputFileFlagsFsc: + val inputFileFlagsFsc : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val inputFileFlagsFsiBase: + val inputFileFlagsFsiBase : _tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val inputFileFlagsFsi: + val inputFileFlagsFsi : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val errorsAndWarningsFlags: + val errorsAndWarningsFlags : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val outputFileFlagsFsi: + val outputFileFlagsFsi : _tcConfigB:CompilerConfig.TcConfigBuilder -> 'a list - val outputFileFlagsFsc: + val outputFileFlagsFsc : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val resourcesFlagsFsi: _tcConfigB:CompilerConfig.TcConfigBuilder -> 'a list - val resourcesFlagsFsc: + val resourcesFlagsFsi : _tcConfigB:CompilerConfig.TcConfigBuilder -> 'a list + val resourcesFlagsFsc : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val codeGenerationFlags: + val codeGenerationFlags : isFsi:bool -> tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val defineSymbol: + val defineSymbol : tcConfigB:CompilerConfig.TcConfigBuilder -> s:string -> unit - val mlCompatibilityFlag: + val mlCompatibilityFlag : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val setLanguageVersion: specifiedVersion:string -> Features.LanguageVersion - val languageFlags: + val setLanguageVersion : specifiedVersion:string -> Features.LanguageVersion + val languageFlags : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val libFlag: tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val codePageFlag: + val libFlag : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val codePageFlag : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val preferredUiLang: + val preferredUiLang : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val utf8OutputFlag: + val utf8OutputFlag : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val fullPathsFlag: + val fullPathsFlag : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val cliRootFlag: + val cliRootFlag : _tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val SetTargetProfile: CompilerConfig.TcConfigBuilder -> string -> unit - val advancedFlagsBoth: + val SetTargetProfile : CompilerConfig.TcConfigBuilder -> string -> unit + val advancedFlagsBoth : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val noFrameworkFlag: + val noFrameworkFlag : isFsc:bool -> tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val advancedFlagsFsi: + val advancedFlagsFsi : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val advancedFlagsFsc: + val advancedFlagsFsc : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val testFlag: tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val editorSpecificFlags: + val testFlag : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption + val editorSpecificFlags : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val internalFlags: + val internalFlags : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val compilingFsLibFlag: + val compilingFsLibFlag : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val compilingFsLib20Flag: CompilerOption - val compilingFsLib40Flag: CompilerOption - val compilingFsLibNoBigIntFlag: CompilerOption - val mlKeywordsFlag: CompilerOption - val gnuStyleErrorsFlag: + val compilingFsLib20Flag : CompilerOption + val compilingFsLib40Flag : CompilerOption + val compilingFsLibNoBigIntFlag : CompilerOption + val mlKeywordsFlag : CompilerOption + val gnuStyleErrorsFlag : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val deprecatedFlagsBoth: + val deprecatedFlagsBoth : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val deprecatedFlagsFsi: + val deprecatedFlagsFsi : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val deprecatedFlagsFsc: + val deprecatedFlagsFsc : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val DisplayBannerText: CompilerConfig.TcConfigBuilder -> unit - val displayHelpFsc: + val DisplayBannerText : CompilerConfig.TcConfigBuilder -> unit + val displayHelpFsc : tcConfigB:CompilerConfig.TcConfigBuilder -> blocks:CompilerOptionBlock list -> 'a - val displayVersion: tcConfigB:CompilerConfig.TcConfigBuilder -> 'a - val miscFlagsBoth: + val displayVersion : tcConfigB:CompilerConfig.TcConfigBuilder -> 'a + val miscFlagsBoth : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val miscFlagsFsc: + val miscFlagsFsc : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val miscFlagsFsi: + val miscFlagsFsi : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val abbreviatedFlagsBoth: + val abbreviatedFlagsBoth : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val abbreviatedFlagsFsi: + val abbreviatedFlagsFsi : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val abbreviatedFlagsFsc: + val abbreviatedFlagsFsc : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val GetAbbrevFlagSet: CompilerConfig.TcConfigBuilder -> bool -> Set - val PostProcessCompilerArgs: Set -> string [] -> string list - val testingAndQAFlags: _tcConfigB:'a -> CompilerOption list - val GetCoreFscCompilerOptions: + val GetAbbrevFlagSet : CompilerConfig.TcConfigBuilder -> bool -> Set + val PostProcessCompilerArgs : Set -> string [] -> string list + val testingAndQAFlags : _tcConfigB:'a -> CompilerOption list + val GetCoreFscCompilerOptions : CompilerConfig.TcConfigBuilder -> CompilerOptionBlock list - val GetCoreServiceCompilerOptions: + val GetCoreServiceCompilerOptions : CompilerConfig.TcConfigBuilder -> CompilerOptionBlock list - val GetCoreFsiCompilerOptions: + val GetCoreFsiCompilerOptions : CompilerConfig.TcConfigBuilder -> CompilerOptionBlock list - val ApplyCommandLineArgs: + val ApplyCommandLineArgs : tcConfigB:CompilerConfig.TcConfigBuilder * sourceFiles:string list * argv:string list -> string list - val mutable showTermFileCount: int - val PrintWholeAssemblyImplementation: + val mutable showTermFileCount : int + val PrintWholeAssemblyImplementation : g:TcGlobals.TcGlobals -> tcConfig:CompilerConfig.TcConfig -> outfile:string -> header:string -> expr:TypedTree.TypedImplFile list -> unit - val mutable tPrev: (float * int []) option - val mutable nPrev: string option - val ReportTime: CompilerConfig.TcConfig -> string -> unit - val ignoreFailureOnMono1_1_16: (unit -> unit) -> unit - val foreBackColor: + val mutable tPrev : (float * int []) option + val mutable nPrev : string option + val ReportTime : CompilerConfig.TcConfig -> string -> unit + val ignoreFailureOnMono1_1_16 : (unit -> unit) -> unit + val foreBackColor : unit -> (System.ConsoleColor * System.ConsoleColor) option - val DoWithColor: System.ConsoleColor -> (unit -> 'a) -> 'a - val DoWithErrorColor: bool -> (unit -> 'a) -> 'a - + val DoWithColor : System.ConsoleColor -> (unit -> 'a) -> 'a + val DoWithErrorColor : bool -> (unit -> 'a) -> 'a + end namespace FSharp.Compiler - module internal OptimizeInputs = - val mutable showTermFileCount: int - val PrintWholeAssemblyImplementation: + module internal OptimizeInputs = begin + val mutable showTermFileCount : int + val PrintWholeAssemblyImplementation : g:TcGlobals.TcGlobals -> tcConfig:CompilerConfig.TcConfig -> outfile:string -> header:string -> expr:TypedTree.TypedImplFile list -> unit - val AddExternalCcuToOptimizationEnv: + val AddExternalCcuToOptimizationEnv : TcGlobals.TcGlobals -> Optimizer.IncrementalOptimizationEnv -> CompilerImports.ImportedAssembly -> Optimizer.IncrementalOptimizationEnv - val GetInitialOptimizationEnv: + val GetInitialOptimizationEnv : CompilerImports.TcImports * TcGlobals.TcGlobals -> Optimizer.IncrementalOptimizationEnv - val ApplyAllOptimizations: + val ApplyAllOptimizations : CompilerConfig.TcConfig * TcGlobals.TcGlobals * ConstraintSolver.TcValF * string * Import.ImportMap * bool * Optimizer.IncrementalOptimizationEnv * TypedTree.CcuThunk * TypedTree.TypedImplFile list -> TypedTree.TypedAssemblyAfterOptimization * Optimizer.CcuOptimizationInfo * Optimizer.IncrementalOptimizationEnv - val CreateIlxAssemblyGenerator: + val CreateIlxAssemblyGenerator : CompilerConfig.TcConfig * CompilerImports.TcImports * TcGlobals.TcGlobals * ConstraintSolver.TcValF * TypedTree.CcuThunk -> IlxGen.IlxAssemblyGenerator - val GenerateIlxCode: + val GenerateIlxCode : IlxGen.IlxGenBackend * isInteractiveItExpr:bool * isInteractiveOnMono:bool * CompilerConfig.TcConfig * CheckDeclarations.TopAttribs * TypedTree.TypedAssemblyAfterOptimization * fragName:string * IlxGen.IlxAssemblyGenerator -> IlxGen.IlxGenResults - val NormalizeAssemblyRefs: + val NormalizeAssemblyRefs : AbstractIL.Internal.Library.CompilationThreadToken * AbstractIL.IL.ILGlobals * CompilerImports.TcImports -> (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILScopeRef) - val GetGeneratedILModuleName: + val GetGeneratedILModuleName : CompilerConfig.CompilerTarget -> string -> string - + end namespace FSharp.Compiler - module internal XmlDocFileWriter = - module XmlDocWriter = - val hasDoc: doc:XmlDoc.XmlDoc -> bool - val ComputeXmlDocSigs: + module internal XmlDocFileWriter = begin + module XmlDocWriter = begin + val hasDoc : doc:XmlDoc.XmlDoc -> bool + val ComputeXmlDocSigs : tcGlobals:TcGlobals.TcGlobals * generatedCcu:TypedTree.CcuThunk -> unit - val WriteXmlDocFile: + val WriteXmlDocFile : assemblyName:string * generatedCcu:TypedTree.CcuThunk * xmlfile:string -> unit - - + end + end namespace FSharp.Compiler - module internal BinaryResourceFormats = - module BinaryGenerationUtilities = - val b0: n:int -> byte - val b1: n:int -> byte - val b2: n:int -> byte - val b3: n:int -> byte - val i16: i:int32 -> byte [] - val i32: i:int32 -> byte [] - val Padded: initialAlignment:int -> v:byte [] -> byte [] - - module ResFileFormat = - val ResFileNode: + module internal BinaryResourceFormats = begin + module BinaryGenerationUtilities = begin + val b0 : n:int -> byte + val b1 : n:int -> byte + val b2 : n:int -> byte + val b3 : n:int -> byte + val i16 : i:int32 -> byte [] + val i32 : i:int32 -> byte [] + val Padded : initialAlignment:int -> v:byte [] -> byte [] + end + module ResFileFormat = begin + val ResFileNode : dwTypeID:int32 * dwNameID:int32 * wMemFlags:int32 * wLangID:int32 * data:byte [] -> byte [] - val ResFileHeader: unit -> byte [] - - module VersionResourceFormat = - val VersionInfoNode: data:byte [] -> byte [] - val VersionInfoElement: + val ResFileHeader : unit -> byte [] + end + module VersionResourceFormat = begin + val VersionInfoNode : data:byte [] -> byte [] + val VersionInfoElement : wType:int32 * szKey:byte [] * valueOpt:byte [] option * children:byte [] [] * isString:bool -> byte [] - val Version: version:AbstractIL.IL.ILVersionInfo -> byte [] - val String: string:string * value:string -> byte [] - val StringTable: + val Version : version:AbstractIL.IL.ILVersionInfo -> byte [] + val String : string:string * value:string -> byte [] + val StringTable : language:string * strings:seq -> byte [] - val StringFileInfo: + val StringFileInfo : stringTables:#seq -> byte [] - when 'b:> seq - val VarFileInfo: vars:#seq -> byte [] - val VS_FIXEDFILEINFO: + when 'b :> seq + val VarFileInfo : vars:#seq -> byte [] + val VS_FIXEDFILEINFO : fileVersion:AbstractIL.IL.ILVersionInfo * productVersion:AbstractIL.IL.ILVersionInfo * dwFileFlagsMask:int32 * dwFileFlags:int32 * dwFileOS:int32 * dwFileType:int32 * dwFileSubtype:int32 * lwFileDate:int64 -> byte [] - val VS_VERSION_INFO: + val VS_VERSION_INFO : fixedFileInfo:(AbstractIL.IL.ILVersionInfo * AbstractIL.IL.ILVersionInfo * int32 * int32 * int32 * int32 * int32 * int64) * stringFileInfo:seq> * varFileInfo:seq -> byte [] - val VS_VERSION_INFO_RESOURCE: + val VS_VERSION_INFO_RESOURCE : (AbstractIL.IL.ILVersionInfo * AbstractIL.IL.ILVersionInfo * int32 * int32 * int32 * int32 * int32 * int64) * seq> * seq -> byte [] - - module ManifestResourceFormat = - val VS_MANIFEST_RESOURCE: data:byte [] * isLibrary:bool -> byte [] - - + end + module ManifestResourceFormat = begin + val VS_MANIFEST_RESOURCE : data:byte [] * isLibrary:bool -> byte [] + end + end namespace FSharp.Compiler - module internal StaticLinking = + module internal StaticLinking = begin type TypeForwarding = - - new: tcImports:CompilerImports.TcImports -> TypeForwarding + class + new : tcImports:CompilerImports.TcImports -> TypeForwarding member - TypeForwardILTypeRef: tref:AbstractIL.IL.ILTypeRef -> + TypeForwardILTypeRef : tref:AbstractIL.IL.ILTypeRef -> AbstractIL.IL.ILTypeRef - - val debugStaticLinking: bool - val StaticLinkILModules: + end + val debugStaticLinking : bool + val StaticLinkILModules : tcConfig:CompilerConfig.TcConfig * ilGlobals:AbstractIL.IL.ILGlobals * tcImports:CompilerImports.TcImports * ilxMainModule:AbstractIL.IL.ILModuleDef * dependentILModules:(TypedTree.CcuThunk option * AbstractIL.IL.ILModuleDef) list -> AbstractIL.IL.ILModuleDef * (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILScopeRef) - [] + [] type Node = { name: string data: AbstractIL.IL.ILModuleDef @@ -14780,70 +39847,70 @@ namespace FSharp.Compiler refs: AbstractIL.IL.ILReferences mutable edges: Node list mutable visited: bool } - val FindDependentILModulesForStaticLinking: + val FindDependentILModulesForStaticLinking : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfig:CompilerConfig.TcConfig * tcImports:CompilerImports.TcImports * ilGlobals:AbstractIL.IL.ILGlobals * ilxMainModule:AbstractIL.IL.ILModuleDef -> (TypedTree.CcuThunk option * AbstractIL.IL.ILModuleDef) list - val FindProviderGeneratedILModules: + val FindProviderGeneratedILModules : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcImports:CompilerImports.TcImports * providerGeneratedAssemblies:(CompilerImports.ImportedBinary * 'a) list -> ((TypedTree.CcuThunk option * AbstractIL.IL.ILScopeRef * AbstractIL.IL.ILModuleDef) * (string * 'a)) list - val StaticLink: + val StaticLink : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfig:CompilerConfig.TcConfig * tcImports:CompilerImports.TcImports * ilGlobals:AbstractIL.IL.ILGlobals -> (AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILModuleDef) - + end namespace FSharp.Compiler - module internal CreateILModule = - module AttributeHelpers = - val TryFindStringAttribute: + module internal CreateILModule = begin + module AttributeHelpers = begin + val TryFindStringAttribute : g:TcGlobals.TcGlobals -> attrib:string -> attribs:TypedTree.Attribs -> string option - val TryFindIntAttribute: + val TryFindIntAttribute : g:TcGlobals.TcGlobals -> attrib:string -> attribs:TypedTree.Attribs -> int32 option - val TryFindBoolAttribute: + val TryFindBoolAttribute : g:TcGlobals.TcGlobals -> attrib:string -> attribs:TypedTree.Attribs -> bool option - val ( |ILVersion|_| ): + val ( |ILVersion|_| ) : versionString:string -> AbstractIL.IL.ILVersionInfo option - + end type StrongNameSigningInfo = | StrongNameSigningInfo of delaysign: bool * publicsign: bool * signer: string option * container: string option - val ValidateKeySigningAttributes: + val ValidateKeySigningAttributes : tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * CheckDeclarations.TopAttribs -> StrongNameSigningInfo - val GetStrongNameSigner: + val GetStrongNameSigner : signingInfo:StrongNameSigningInfo -> AbstractIL.Internal.StrongNameSign.ILStrongNameSigner option - module MainModuleBuilder = - val injectedCompatTypes: Set - val typesForwardedToMscorlib: Set - val typesForwardedToSystemNumerics: Set - val createMscorlibExportList: + module MainModuleBuilder = begin + val injectedCompatTypes : Set + val typesForwardedToMscorlib : Set + val typesForwardedToSystemNumerics : Set + val createMscorlibExportList : tcGlobals:TcGlobals.TcGlobals -> AbstractIL.IL.ILExportedTypeOrForwarder list - val createSystemNumericsExportList: + val createSystemNumericsExportList : tcConfig:CompilerConfig.TcConfig -> tcImports:CompilerImports.TcImports -> AbstractIL.IL.ILExportedTypeOrForwarder list - val fileVersion: + val fileVersion : findStringAttr:(string -> string option) -> assemblyVersion:AbstractIL.IL.ILVersionInfo -> AbstractIL.IL.ILVersionInfo - val productVersion: + val productVersion : findStringAttr:(string -> string option) -> fileVersion:AbstractIL.IL.ILVersionInfo -> string - val productVersionToILVersionInfo: string -> AbstractIL.IL.ILVersionInfo - val CreateMainModule: + val productVersionToILVersionInfo : string -> AbstractIL.IL.ILVersionInfo + val CreateMainModule : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * tcImports:CompilerImports.TcImports * pdbfile:'t option * @@ -14856,72 +39923,72 @@ namespace FSharp.Compiler assemVerFromAttrib:AbstractIL.IL.ILVersionInfo option * metadataVersion:string * secDecls:AbstractIL.IL.ILSecurityDecls -> AbstractIL.IL.ILModuleDef - - + end + end namespace FSharp.Compiler - module internal Driver = - [] + module internal Driver = begin + [] type ErrorLoggerUpToMaxErrors = - + class inherit ErrorLogger.ErrorLogger - new: tcConfigB:CompilerConfig.TcConfigBuilder * + new : tcConfigB:CompilerConfig.TcConfigBuilder * exiter:ErrorLogger.Exiter * nameForDebugging:string -> ErrorLoggerUpToMaxErrors override - DiagnosticSink: err:ErrorLogger.PhasedDiagnostic * isError:bool -> + DiagnosticSink : err:ErrorLogger.PhasedDiagnostic * isError:bool -> unit abstract member - HandleIssue: tcConfigB:CompilerConfig.TcConfigBuilder * + HandleIssue : tcConfigB:CompilerConfig.TcConfigBuilder * error:ErrorLogger.PhasedDiagnostic * isError:bool -> unit - abstract member HandleTooManyErrors: text:string -> unit - override ErrorCount: int - - val ConsoleErrorLoggerUpToMaxErrors: + abstract member HandleTooManyErrors : text:string -> unit + override ErrorCount : int + end + val ConsoleErrorLoggerUpToMaxErrors : tcConfigB:CompilerConfig.TcConfigBuilder * exiter:ErrorLogger.Exiter -> ErrorLogger.ErrorLogger type DelayAndForwardErrorLogger = - + class inherit ErrorLogger.CapturingErrorLogger - new: exiter:ErrorLogger.Exiter * + new : exiter:ErrorLogger.Exiter * errorLoggerProvider:ErrorLoggerProvider -> DelayAndForwardErrorLogger member - ForwardDelayedDiagnostics: tcConfigB:CompilerConfig.TcConfigBuilder -> + ForwardDelayedDiagnostics : tcConfigB:CompilerConfig.TcConfigBuilder -> unit - - [] + end + [] and ErrorLoggerProvider = - - new: unit -> ErrorLoggerProvider + class + new : unit -> ErrorLoggerProvider member - CreateDelayAndForwardLogger: exiter:ErrorLogger.Exiter -> + CreateDelayAndForwardLogger : exiter:ErrorLogger.Exiter -> DelayAndForwardErrorLogger abstract member - CreateErrorLoggerUpToMaxErrors: tcConfigBuilder:CompilerConfig.TcConfigBuilder * + CreateErrorLoggerUpToMaxErrors : tcConfigBuilder:CompilerConfig.TcConfigBuilder * exiter:ErrorLogger.Exiter -> ErrorLogger.ErrorLogger - + end type InProcErrorLoggerProvider = - - new: unit -> InProcErrorLoggerProvider - member CapturedErrors: CompilerDiagnostics.Diagnostic [] - member CapturedWarnings: CompilerDiagnostics.Diagnostic [] - member Provider: ErrorLoggerProvider - + class + new : unit -> InProcErrorLoggerProvider + member CapturedErrors : CompilerDiagnostics.Diagnostic [] + member CapturedWarnings : CompilerDiagnostics.Diagnostic [] + member Provider : ErrorLoggerProvider + end type ConsoleLoggerProvider = - + class inherit ErrorLoggerProvider - new: unit -> ConsoleLoggerProvider + new : unit -> ConsoleLoggerProvider override - CreateErrorLoggerUpToMaxErrors: tcConfigBuilder:CompilerConfig.TcConfigBuilder * + CreateErrorLoggerUpToMaxErrors : tcConfigBuilder:CompilerConfig.TcConfigBuilder * exiter:ErrorLogger.Exiter -> ErrorLogger.ErrorLogger - - val AbortOnError: + end + val AbortOnError : errorLogger:ErrorLogger.ErrorLogger * exiter:ErrorLogger.Exiter -> unit - val TypeCheck: + val TypeCheck : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfig:CompilerConfig.TcConfig * tcImports:CompilerImports.TcImports * tcGlobals:TcGlobals.TcGlobals * errorLogger:ErrorLogger.ErrorLogger * @@ -14930,48 +39997,48 @@ namespace FSharp.Compiler exiter:ErrorLogger.Exiter -> ParseAndCheckInputs.TcState * CheckDeclarations.TopAttribs * TypedTree.TypedImplFile list * CheckExpressions.TcEnv - val AdjustForScriptCompile: + val AdjustForScriptCompile : ctok:AbstractIL.Internal.Library.CompilationThreadToken * tcConfigB:CompilerConfig.TcConfigBuilder * commandLineSourceFiles:string list * lexResourceManager:Lexhelp.LexResourceManager * dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> string list - val SetProcessThreadLocals: + val SetProcessThreadLocals : tcConfigB:CompilerConfig.TcConfigBuilder -> unit - val ProcessCommandLineFlags: + val ProcessCommandLineFlags : tcConfigB:CompilerConfig.TcConfigBuilder * lcidFromCodePage:int option * argv:string [] -> string list - val EncodeSignatureData: + val EncodeSignatureData : tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * exportRemapping:TypedTreeOps.Remap * generatedCcu:TypedTree.CcuThunk * outfile:string * isIncrementalBuild:bool -> AbstractIL.IL.ILAttribute list * AbstractIL.IL.ILResource list - val EncodeOptimizationData: + val EncodeOptimizationData : tcGlobals:TcGlobals.TcGlobals * tcConfig:CompilerConfig.TcConfig * outfile:string * exportRemapping:TypedTreeOps.Remap * data:(TypedTree.CcuThunk * #Optimizer.CcuOptimizationInfo) * isIncrementalBuild:bool -> AbstractIL.IL.ILResource list - module InterfaceFileWriter = - val BuildInitialDisplayEnvForSigFileGeneration: + module InterfaceFileWriter = begin + val BuildInitialDisplayEnvForSigFileGeneration : tcGlobals:TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv - val WriteInterfaceFile: + val WriteInterfaceFile : tcGlobals:TcGlobals.TcGlobals * tcConfig:CompilerConfig.TcConfig * infoReader:InfoReader.InfoReader * declaredImpls:seq -> unit - - val CopyFSharpCore: + end + val CopyFSharpCore : outFile:string * referencedDlls:CompilerConfig.AssemblyReference list -> unit - val TryFindVersionAttribute: + val TryFindVersionAttribute : g:TcGlobals.TcGlobals -> attrib:string -> attribName:System.String -> attribs:TypedTree.Attribs -> deterministic:bool -> AbstractIL.IL.ILVersionInfo option - [] + [] type Args<'T> = | Args of 'T - val main1: + val main1 : ctok:'a * argv:string [] * legacyReferenceResolver:ReferenceResolver.Resolver * bannerAlreadyPrinted:bool * @@ -14984,8 +40051,8 @@ namespace FSharp.Compiler TypedTree.TypedImplFile list * CheckDeclarations.TopAttribs * CompilerConfig.TcConfig * string * string option * string * ErrorLogger.ErrorLogger * ErrorLogger.Exiter> - when 'a:> AbstractIL.Internal.Library.CompilationThreadToken - val main1OfAst: + when 'a :> AbstractIL.Internal.Library.CompilationThreadToken + val main1OfAst : ctok:'a * legacyReferenceResolver:ReferenceResolver.Resolver * reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * assemblyName:string * target:CompilerConfig.CompilerTarget * outfile:'b * @@ -14997,8 +40064,8 @@ namespace FSharp.Compiler TypedTree.TypedImplFile list * CheckDeclarations.TopAttribs * CompilerConfig.TcConfig * 'b * 'c option * string * ErrorLogger.ErrorLogger * ErrorLogger.Exiter> - when 'a:> AbstractIL.Internal.Library.CompilationThreadToken - val main2: + when 'a :> AbstractIL.Internal.Library.CompilationThreadToken + val main2 : Args<'a * 'b * CompilerImports.TcImports * 'c * TypedTree.CcuThunk * 'd * CheckDeclarations.TopAttribs * CompilerConfig.TcConfig * 'e * 'f * string * #ErrorLogger.ErrorLogger * ErrorLogger.Exiter> -> @@ -15007,8 +40074,8 @@ namespace FSharp.Compiler CheckDeclarations.TopAttribs * 'f * string * AbstractIL.IL.ILVersionInfo option * CreateILModule.StrongNameSigningInfo * ErrorLogger.Exiter> - when 'b:> TcGlobals.TcGlobals and 'd:> seq - val main3: + when 'b :> TcGlobals.TcGlobals and 'd :> seq + val main3 : Args<'a * CompilerConfig.TcConfig * CompilerImports.TcImports * CompilerImports.TcImports * 'b * ErrorLogger.ErrorLogger * TypedTree.CcuThunk * string * TypedTree.TypedImplFile list * 'c * 'd * @@ -15018,8 +40085,8 @@ namespace FSharp.Compiler TypedTree.TypedAssemblyAfterOptimization * 'c * 'd * 'e * AbstractIL.IL.ILAttribute list * AbstractIL.IL.ILResource list * AbstractIL.IL.ILResource list * 'f * 'g * string * - ErrorLogger.Exiter> when 'b:> TcGlobals.TcGlobals - val main4: + ErrorLogger.Exiter> when 'b :> TcGlobals.TcGlobals + val main4 : tcImportsCapture:(CompilerImports.TcImports -> unit) option * dynamicAssemblyCreator:'a option -> Args<'b * CompilerConfig.TcConfig * CompilerImports.TcImports * @@ -15033,14 +40100,14 @@ namespace FSharp.Compiler TcGlobals.TcGlobals * 'c * (AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILModuleDef) * string * 'd option * AbstractIL.IL.ILModuleDef * 'e * ErrorLogger.Exiter> - when 'b:> AbstractIL.Internal.Library.CompilationThreadToken and - 'c:> ErrorLogger.ErrorLogger - val main5: + when 'b :> AbstractIL.Internal.Library.CompilationThreadToken and + 'c :> ErrorLogger.ErrorLogger + val main5 : Args<'a * 'b * 'c * 'd * ErrorLogger.ErrorLogger * ('e -> 'f) * 'g * 'h * 'e * 'i * ErrorLogger.Exiter> -> Args<'a * 'b * 'c * 'd * ErrorLogger.ErrorLogger * 'f * 'g * 'h * 'i * ErrorLogger.Exiter> - val main6: + val main6 : dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * AbstractIL.IL.ILModuleDef -> unit) option -> Args<#AbstractIL.Internal.Library.CompilationThreadToken * @@ -15048,7 +40115,7 @@ namespace FSharp.Compiler TcGlobals.TcGlobals * ErrorLogger.ErrorLogger * AbstractIL.IL.ILModuleDef * string * string option * CreateILModule.StrongNameSigningInfo * ErrorLogger.Exiter> -> unit - val mainCompile: + val mainCompile : ctok:AbstractIL.Internal.Library.CompilationThreadToken * argv:string [] * legacyReferenceResolver:ReferenceResolver.Resolver * bannerAlreadyPrinted:bool * @@ -15058,7 +40125,7 @@ namespace FSharp.Compiler tcImportsCapture:(CompilerImports.TcImports -> unit) option * dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * AbstractIL.IL.ILModuleDef -> unit) option -> unit - val compileOfAst: + val compileOfAst : ctok:AbstractIL.Internal.Library.CompilationThreadToken * legacyReferenceResolver:ReferenceResolver.Resolver * reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * @@ -15069,120 +40136,120 @@ namespace FSharp.Compiler tcImportsCapture:(CompilerImports.TcImports -> unit) option * dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * AbstractIL.IL.ILModuleDef -> unit) option -> unit - + end namespace FSharp.Compiler.SourceCodeServices - module EnvMisc2 = - val maxMembers: int - - [] + module EnvMisc2 = begin + val maxMembers : int + end + [] type FSharpErrorSeverity = | Warning | Error - module FSharpErrorInfo = - [] - val ObsoleteMessage: string + module FSharpErrorInfo = begin + [] + val ObsoleteMessage : string = "Use FSharpErrorInfo.Range. This API will be removed in a future update." - - [] + end + [] type FSharpErrorInfo = - - new: m:Range.range * severity:FSharpErrorSeverity * message:string * + class + new : m:Range.range * severity:FSharpErrorSeverity * message:string * subcategory:string * errorNum:int -> FSharpErrorInfo static member - CreateFromException: ErrorLogger.PhasedDiagnostic * isError:bool * + CreateFromException : ErrorLogger.PhasedDiagnostic * isError:bool * Range.range * suggestNames:bool -> FSharpErrorInfo static member - CreateFromExceptionAndAdjustEof: ErrorLogger.PhasedDiagnostic * + CreateFromExceptionAndAdjustEof : ErrorLogger.PhasedDiagnostic * isError:bool * Range.range * lastPosInFile:(int * int) * suggestNames:bool -> FSharpErrorInfo - override ToString: unit -> string - member WithEnd: newEnd:Range.pos -> FSharpErrorInfo - member WithStart: newStart:Range.pos -> FSharpErrorInfo + override ToString : unit -> string + member WithEnd : newEnd:Range.pos -> FSharpErrorInfo + member WithStart : newStart:Range.pos -> FSharpErrorInfo [] - member End: Range.pos + member End : Range.pos [] - member EndColumn: int + member EndColumn : int [] - member EndLine: Range.Line0 + member EndLine : Range.Line0 [] - member EndLineAlternate: int - member ErrorNumber: int + member EndLineAlternate : int + member ErrorNumber : int [] - member FileName: string - member Message: string - member Range: Range.range - member Severity: FSharpErrorSeverity + member FileName : string + member Message : string + member Range : Range.range + member Severity : FSharpErrorSeverity [] - member Start: Range.pos + member Start : Range.pos [] - member StartColumn: int + member StartColumn : int [] - member StartLine: Range.Line0 + member StartLine : Range.Line0 [] - member StartLineAlternate: int - member Subcategory: string - - [] + member StartLineAlternate : int + member Subcategory : string + end + [] type ErrorScope = - + class interface System.IDisposable - new: unit -> ErrorScope - static member - Protect: Range.range -> (unit -> 'a) -> (string -> 'a) -> 'a - member TryGetFirstErrorText: unit -> string option - member Diagnostics: FSharpErrorInfo list - member Errors: FSharpErrorInfo list - member FirstError: string option - member Warnings: FSharpErrorInfo list - + new : unit -> ErrorScope + static member + Protect : Range.range -> (unit -> 'a) -> (string -> 'a) -> 'a + member TryGetFirstErrorText : unit -> string option + member Diagnostics : FSharpErrorInfo list + member Errors : FSharpErrorInfo list + member FirstError : string option + member Warnings : FSharpErrorInfo list + end type internal CompilationErrorLogger = - + class inherit ErrorLogger.ErrorLogger - new: debugName:string * options:ErrorLogger.FSharpErrorSeverityOptions -> + new : debugName:string * options:ErrorLogger.FSharpErrorSeverityOptions -> CompilationErrorLogger override - DiagnosticSink: exn:ErrorLogger.PhasedDiagnostic * isError:bool -> unit + DiagnosticSink : exn:ErrorLogger.PhasedDiagnostic * isError:bool -> unit member - GetErrors: unit -> + GetErrors : unit -> (ErrorLogger.PhasedDiagnostic * FSharpErrorSeverity) [] - override ErrorCount: int - + override ErrorCount : int + end type CompilationGlobalsScope = - + class interface System.IDisposable - new: ErrorLogger.ErrorLogger * ErrorLogger.BuildPhase -> + new : ErrorLogger.ErrorLogger * ErrorLogger.BuildPhase -> CompilationGlobalsScope - - module ErrorHelpers = - val ReportError: + end + module ErrorHelpers = begin + val ReportError : ErrorLogger.FSharpErrorSeverityOptions * allErrors:bool * mainInputFileName:string * fileInfo:(int * int) * (ErrorLogger.PhasedDiagnostic * FSharpErrorSeverity) * suggestNames:bool -> FSharpErrorInfo list - val CreateErrorInfos: + val CreateErrorInfos : ErrorLogger.FSharpErrorSeverityOptions * allErrors:bool * mainInputFileName:string * seq * suggestNames:bool -> FSharpErrorInfo [] - + end type Layout = Internal.Utilities.StructuredFormat.Layout - [] + [] type FSharpXmlDoc = | None | Text of unprocessedLines: string [] * elaboratedXmlLines: string [] | XmlDocFileSignature of string * string - [] + [] type FSharpToolTipElementData<'T> = { MainDescription: 'T XmlDoc: FSharpXmlDoc @@ -15191,32 +40258,32 @@ namespace FSharp.Compiler.SourceCodeServices ParamName: string option } with static member - Create: layout:'T * xml:FSharpXmlDoc * ?typeMapping:'T list * + Create : layout:'T * xml:FSharpXmlDoc * ?typeMapping:'T list * ?paramName:string * ?remarks:'T -> FSharpToolTipElementData<'T> - - [] + end + [] type FSharpToolTipElement<'T> = | None | Group of FSharpToolTipElementData<'T> list | CompositionError of string with static member - Single: 'T * FSharpXmlDoc * ?typeMapping:'T list * ?paramName:string * + Single : 'T * FSharpXmlDoc * ?typeMapping:'T list * ?paramName:string * ?remarks:'T -> FSharpToolTipElement<'T> - + end type FSharpToolTipElement = FSharpToolTipElement type FSharpStructuredToolTipElement = FSharpToolTipElement type FSharpToolTipText<'T> = | FSharpToolTipText of FSharpToolTipElement<'T> list type FSharpToolTipText = FSharpToolTipText type FSharpStructuredToolTipText = FSharpToolTipText - module Tooltips = - val ToFSharpToolTipElement: + module Tooltips = begin + val ToFSharpToolTipElement : FSharpToolTipElement -> FSharpToolTipElement - val ToFSharpToolTipText: + val ToFSharpToolTipText : FSharpToolTipText -> FSharpToolTipText - - [] + end + [] type CompletionItemKind = | Field | Property @@ -15237,334 +40304,334 @@ namespace FSharp.Compiler.SourceCodeServices Type: TypedTree.TyconRef option Unresolved: UnresolvedSymbol option } with - member Item: NameResolution.Item - - module internal SymbolHelpers = - val OutputFullName: + member Item : NameResolution.Item + end + module internal SymbolHelpers = begin + val OutputFullName : isListItem:bool -> ppF:('a -> 'b option) -> fnF:('a -> Internal.Utilities.StructuredFormat.Layout) -> r:'a -> Internal.Utilities.StructuredFormat.Layout - val rangeOfValRef: + val rangeOfValRef : preferFlag:bool option -> vref:TypedTree.ValRef -> Range.range - val rangeOfEntityRef: + val rangeOfEntityRef : preferFlag:bool option -> eref:TypedTree.EntityRef -> Range.range - val rangeOfPropInfo: + val rangeOfPropInfo : preferFlag:bool option -> pinfo:Infos.PropInfo -> Range.range option - val rangeOfMethInfo: + val rangeOfMethInfo : g:TcGlobals.TcGlobals -> preferFlag:bool option -> minfo:Infos.MethInfo -> Range.range option - val rangeOfEventInfo: + val rangeOfEventInfo : preferFlag:bool option -> einfo:Infos.EventInfo -> Range.range option - val rangeOfUnionCaseInfo: + val rangeOfUnionCaseInfo : preferFlag:bool option -> ucinfo:Infos.UnionCaseInfo -> Range.range - val rangeOfRecdField: + val rangeOfRecdField : preferFlag:bool option -> rField:TypedTree.RecdField -> Range.range - val rangeOfRecdFieldInfo: + val rangeOfRecdFieldInfo : preferFlag:bool option -> rfinfo:Infos.RecdFieldInfo -> Range.range - val rangeOfItem: + val rangeOfItem : TcGlobals.TcGlobals -> bool option -> NameResolution.Item -> Range.range option - val computeCcuOfTyconRef: + val computeCcuOfTyconRef : tcref:TypedTree.TyconRef -> TypedTree.CcuThunk option - val ccuOfMethInfo: + val ccuOfMethInfo : g:TcGlobals.TcGlobals -> minfo:Infos.MethInfo -> TypedTree.CcuThunk option - val ccuOfItem: + val ccuOfItem : TcGlobals.TcGlobals -> NameResolution.Item -> TypedTree.CcuThunk option - val fileNameOfItem: + val fileNameOfItem : TcGlobals.TcGlobals -> string option -> Range.range -> NameResolution.Item -> string - val cutFileName: s:string -> string - val libFileOfEntityRef: x:TypedTree.EntityRef -> string option - val ParamNameAndTypesOfUnaryCustomOperation: + val cutFileName : s:string -> string + val libFileOfEntityRef : x:TypedTree.EntityRef -> string option + val ParamNameAndTypesOfUnaryCustomOperation : TcGlobals.TcGlobals -> Infos.MethInfo -> Infos.ParamNameAndType list - val metaInfoOfEntityRef: + val metaInfoOfEntityRef : infoReader:InfoReader.InfoReader -> m:Range.range -> tcref:TypedTree.EntityRef -> (string option * TypedTree.Typars * Infos.ILTypeInfo) option - val mkXmlComment: thing:(string option * string) option -> FSharpXmlDoc - val GetXmlDocSigOfEntityRef: + val mkXmlComment : thing:(string option * string) option -> FSharpXmlDoc + val GetXmlDocSigOfEntityRef : InfoReader.InfoReader -> Range.range -> TypedTree.EntityRef -> (string option * string) option - val GetXmlDocSigOfScopedValRef: + val GetXmlDocSigOfScopedValRef : TcGlobals.TcGlobals -> TypedTree.TyconRef -> TypedTree.ValRef -> (string option * string) option - val GetXmlDocSigOfRecdFieldInfo: + val GetXmlDocSigOfRecdFieldInfo : Infos.RecdFieldInfo -> (string option * string) option - val GetXmlDocSigOfUnionCaseInfo: + val GetXmlDocSigOfUnionCaseInfo : Infos.UnionCaseInfo -> (string option * string) option - val GetXmlDocSigOfMethInfo: + val GetXmlDocSigOfMethInfo : InfoReader.InfoReader -> Range.range -> Infos.MethInfo -> (string option * string) option - val GetXmlDocSigOfValRef: + val GetXmlDocSigOfValRef : TcGlobals.TcGlobals -> TypedTree.ValRef -> (string option * string) option - val GetXmlDocSigOfProp: + val GetXmlDocSigOfProp : InfoReader.InfoReader -> Range.range -> Infos.PropInfo -> (string option * string) option - val GetXmlDocSigOfEvent: + val GetXmlDocSigOfEvent : InfoReader.InfoReader -> Range.range -> Infos.EventInfo -> (string option * string) option - val GetXmlDocSigOfILFieldInfo: + val GetXmlDocSigOfILFieldInfo : InfoReader.InfoReader -> Range.range -> Infos.ILFieldInfo -> (string option * string) option - val GetXmlDocHelpSigOfItemForLookup: + val GetXmlDocHelpSigOfItemForLookup : infoReader:InfoReader.InfoReader -> m:Range.range -> d:NameResolution.Item -> FSharpXmlDoc - val GetXmlCommentForItemAux: + val GetXmlCommentForItemAux : xmlDoc:XmlDoc.XmlDoc option -> infoReader:InfoReader.InfoReader -> m:Range.range -> d:NameResolution.Item -> FSharpXmlDoc - val mutable ToolTipFault: string option - val GetXmlCommentForMethInfoItem: + val mutable ToolTipFault : string option + val GetXmlCommentForMethInfoItem : infoReader:InfoReader.InfoReader -> m:Range.range -> d:NameResolution.Item -> minfo:Infos.MethInfo -> FSharpXmlDoc - val FormatTyparMapping: + val FormatTyparMapping : denv:TypedTreeOps.DisplayEnv -> prettyTyparInst:TypedTreeOps.TyparInst -> Internal.Utilities.StructuredFormat.Layout list - val FormatOverloadsToList: + val FormatOverloadsToList : infoReader:InfoReader.InfoReader -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> item:NameResolution.ItemWithInst -> minfos:seq -> FSharpStructuredToolTipElement - val pubpathOfValRef: v:TypedTree.ValRef -> TypedTree.ValPublicPath option - val pubpathOfTyconRef: x:TypedTree.TyconRef -> TypedTree.PublicPath option - val ( |ItemWhereTypIsPreferred|_| ): + val pubpathOfValRef : v:TypedTree.ValRef -> TypedTree.ValPublicPath option + val pubpathOfTyconRef : x:TypedTree.TyconRef -> TypedTree.PublicPath option + val ( |ItemWhereTypIsPreferred|_| ) : item:NameResolution.Item -> TypedTree.TType option - val ItemDisplayPartialEquality: + val ItemDisplayPartialEquality : g:TcGlobals.TcGlobals -> AbstractIL.Internal.Library.IPartialEqualityComparer - val CompletionItemDisplayPartialEquality: + val CompletionItemDisplayPartialEquality : g:TcGlobals.TcGlobals -> AbstractIL.Internal.Library.IPartialEqualityComparer - val ItemWithTypeDisplayPartialEquality: + val ItemWithTypeDisplayPartialEquality : g:TcGlobals.TcGlobals -> AbstractIL.Internal.Library.IPartialEqualityComparer - val RemoveDuplicateModuleRefs: + val RemoveDuplicateModuleRefs : modrefs:TypedTree.ModuleOrNamespaceRef list -> TypedTree.ModuleOrNamespaceRef list - val RemoveDuplicateItems: + val RemoveDuplicateItems : TcGlobals.TcGlobals -> NameResolution.ItemWithInst list -> NameResolution.ItemWithInst list - val RemoveDuplicateCompletionItems: + val RemoveDuplicateCompletionItems : TcGlobals.TcGlobals -> CompletionItem list -> CompletionItem list - val IsExplicitlySuppressed: + val IsExplicitlySuppressed : TcGlobals.TcGlobals -> NameResolution.Item -> bool - val RemoveExplicitlySuppressed: + val RemoveExplicitlySuppressed : TcGlobals.TcGlobals -> NameResolution.ItemWithInst list -> NameResolution.ItemWithInst list - val RemoveExplicitlySuppressedCompletionItems: + val RemoveExplicitlySuppressedCompletionItems : TcGlobals.TcGlobals -> CompletionItem list -> CompletionItem list - val SimplerDisplayEnv: TypedTreeOps.DisplayEnv -> TypedTreeOps.DisplayEnv - val FullNameOfItem: TcGlobals.TcGlobals -> NameResolution.Item -> string - val GetXmlCommentForItem: + val SimplerDisplayEnv : TypedTreeOps.DisplayEnv -> TypedTreeOps.DisplayEnv + val FullNameOfItem : TcGlobals.TcGlobals -> NameResolution.Item -> string + val GetXmlCommentForItem : InfoReader.InfoReader -> Range.range -> NameResolution.Item -> FSharpXmlDoc - val IsAttribute: InfoReader.InfoReader -> NameResolution.Item -> bool - val FormatItemDescriptionToToolTipElement: + val IsAttribute : InfoReader.InfoReader -> NameResolution.Item -> bool + val FormatItemDescriptionToToolTipElement : isListItem:bool -> infoReader:InfoReader.InfoReader -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> item:NameResolution.ItemWithInst -> FSharpToolTipElement - val ( |ItemIsProvidedType|_| ): + val ( |ItemIsProvidedType|_| ) : TcGlobals.TcGlobals -> NameResolution.Item -> TypedTree.TyconRef option - val ( |ItemIsProvidedTypeWithStaticArguments|_| ): + val ( |ItemIsProvidedTypeWithStaticArguments|_| ) : Range.range -> TcGlobals.TcGlobals -> NameResolution.Item -> Tainted [] option - val ( |ItemIsProvidedMethodWithStaticArguments|_| ): + val ( |ItemIsProvidedMethodWithStaticArguments|_| ) : item:NameResolution.Item -> Tainted [] option - val ( |ItemIsWithStaticArguments|_| ): + val ( |ItemIsWithStaticArguments|_| ) : Range.range -> TcGlobals.TcGlobals -> NameResolution.Item -> Tainted [] option - val GetF1Keyword: + val GetF1Keyword : TcGlobals.TcGlobals -> NameResolution.Item -> string option - val FormatStructuredDescriptionOfItem: + val FormatStructuredDescriptionOfItem : isDecl:bool -> InfoReader.InfoReader -> Range.range -> TypedTreeOps.DisplayEnv -> NameResolution.ItemWithInst -> FSharpToolTipElement - val FlattenItems: + val FlattenItems : TcGlobals.TcGlobals -> Range.range -> NameResolution.Item -> NameResolution.Item list - + end namespace FSharp.Compiler.SourceCodeServices type FSharpAccessibility = - - new: TypedTree.Accessibility * ?isProtected:bool -> FSharpAccessibility - override ToString: unit -> string - member internal Contents: TypedTree.Accessibility - member IsInternal: bool - member IsPrivate: bool - member IsProtected: bool - member IsPublic: bool - + class + new : TypedTree.Accessibility * ?isProtected:bool -> FSharpAccessibility + override ToString : unit -> string + member internal Contents : TypedTree.Accessibility + member IsInternal : bool + member IsPrivate : bool + member IsProtected : bool + member IsPublic : bool + end and SymbolEnv = - - new: TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + class + new : TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * thisCcuTyp:TypedTree.ModuleOrNamespaceType option * tcImports:CompilerImports.TcImports -> SymbolEnv - new: TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + new : TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * thisCcuTyp:TypedTree.ModuleOrNamespaceType option * tcImports:CompilerImports.TcImports * amap:Import.ImportMap * infoReader:InfoReader.InfoReader -> SymbolEnv - member amap: Import.ImportMap - member g: TcGlobals.TcGlobals - member infoReader: InfoReader.InfoReader - member tcImports: CompilerImports.TcImports + member amap : Import.ImportMap + member g : TcGlobals.TcGlobals + member infoReader : InfoReader.InfoReader + member tcImports : CompilerImports.TcImports member - tcValF: (TypedTree.ValRef -> TypedTree.ValUseFlag -> + tcValF : (TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TTypes -> Range.range -> TypedTree.Expr * TypedTree.TType) - member thisCcu: TypedTree.CcuThunk - member thisCcuTy: TypedTree.ModuleOrNamespaceType option - + member thisCcu : TypedTree.CcuThunk + member thisCcuTy : TypedTree.ModuleOrNamespaceType option + end and FSharpDisplayContext = - - new: denv:(TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv) -> + class + new : denv:(TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv) -> FSharpDisplayContext - member Contents: g:TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv - member WithShortTypeNames: bool -> FSharpDisplayContext - static member Empty: FSharpDisplayContext - - [] + member Contents : g:TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv + member WithShortTypeNames : bool -> FSharpDisplayContext + static member Empty : FSharpDisplayContext + end + [] and FSharpSymbol = - - new: cenv:SymbolEnv * item:(unit -> NameResolution.Item) * + class + new : cenv:SymbolEnv * item:(unit -> NameResolution.Item) * access:(FSharpSymbol -> TypedTree.CcuThunk -> AccessibilityLogic.AccessorDomain -> bool) -> FSharpSymbol static member - Create: cenv:SymbolEnv * item:NameResolution.Item -> FSharpSymbol + Create : cenv:SymbolEnv * item:NameResolution.Item -> FSharpSymbol static member - Create: g:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + Create : g:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * thisCcuTyp:TypedTree.ModuleOrNamespaceType * tcImports:CompilerImports.TcImports * item:NameResolution.Item -> FSharpSymbol static member - GetAccessibility: FSharpSymbol -> FSharpAccessibility option - override Equals: other:obj -> bool - member GetEffectivelySameAsHash: unit -> int - override GetHashCode: unit -> int - member IsAccessible: FSharpAccessibilityRights -> bool - member IsEffectivelySameAs: other:FSharpSymbol -> bool - override ToString: unit -> string - member Assembly: FSharpAssembly - member DeclarationLocation: Range.range option - member DisplayName: string - member FullName: string - member ImplementationLocation: Range.range option - member IsExplicitlySuppressed: bool - member internal Item: NameResolution.Item - member SignatureLocation: Range.range option - + GetAccessibility : FSharpSymbol -> FSharpAccessibility option + override Equals : other:obj -> bool + member GetEffectivelySameAsHash : unit -> int + override GetHashCode : unit -> int + member IsAccessible : FSharpAccessibilityRights -> bool + member IsEffectivelySameAs : other:FSharpSymbol -> bool + override ToString : unit -> string + member Assembly : FSharpAssembly + member DeclarationLocation : Range.range option + member DisplayName : string + member FullName : string + member ImplementationLocation : Range.range option + member IsExplicitlySuppressed : bool + member internal Item : NameResolution.Item + member SignatureLocation : Range.range option + end and FSharpEntity = - + class inherit FSharpSymbol - new: SymbolEnv * TypedTree.EntityRef -> FSharpEntity - override Equals: other:obj -> bool - override GetHashCode: unit -> int - override ToString: unit -> string - member AbbreviatedType: FSharpType - member AccessPath: string - member Accessibility: FSharpAccessibility - member ActivePatternCases: FSharpActivePatternCase list - member AllCompilationPaths: string list - member AllInterfaces: System.Collections.Generic.IList - member ArrayRank: int - member Attributes: System.Collections.Generic.IList - member BaseType: FSharpType option - member CompiledName: string - member DeclarationLocation: Range.range - member DeclaredInterfaces: System.Collections.Generic.IList - member DeclaringEntity: FSharpEntity option - member DisplayName: string - member ElaboratedXmlDoc: System.Collections.Generic.IList - member Entity: TypedTree.EntityRef - member FSharpDelegateSignature: FSharpDelegateSignature - member FSharpFields: System.Collections.Generic.IList - member FullName: string + new : SymbolEnv * TypedTree.EntityRef -> FSharpEntity + override Equals : other:obj -> bool + override GetHashCode : unit -> int + override ToString : unit -> string + member AbbreviatedType : FSharpType + member AccessPath : string + member Accessibility : FSharpAccessibility + member ActivePatternCases : FSharpActivePatternCase list + member AllCompilationPaths : string list + member AllInterfaces : System.Collections.Generic.IList + member ArrayRank : int + member Attributes : System.Collections.Generic.IList + member BaseType : FSharpType option + member CompiledName : string + member DeclarationLocation : Range.range + member DeclaredInterfaces : System.Collections.Generic.IList + member DeclaringEntity : FSharpEntity option + member DisplayName : string + member ElaboratedXmlDoc : System.Collections.Generic.IList + member Entity : TypedTree.EntityRef + member FSharpDelegateSignature : FSharpDelegateSignature + member FSharpFields : System.Collections.Generic.IList + member FullName : string member - GenericParameters: System.Collections.Generic.IList - member HasAssemblyCodeRepresentation: bool - member HasFSharpModuleSuffix: bool - member IsAbstractClass: bool - member IsArrayType: bool - member IsAttributeType: bool - member IsByRef: bool - member IsClass: bool - member IsDelegate: bool - member IsDisposableType: bool - member IsEnum: bool - member IsFSharp: bool - member IsFSharpAbbreviation: bool - member IsFSharpExceptionDeclaration: bool - member IsFSharpModule: bool - member IsFSharpRecord: bool - member IsFSharpUnion: bool - member IsInterface: bool - member IsMeasure: bool - member IsNamespace: bool - member IsOpaque: bool - member IsProvided: bool - member IsProvidedAndErased: bool - member IsProvidedAndGenerated: bool - member IsStaticInstantiation: bool - member IsUnresolved: bool - member IsValueType: bool - member LogicalName: string + GenericParameters : System.Collections.Generic.IList + member HasAssemblyCodeRepresentation : bool + member HasFSharpModuleSuffix : bool + member IsAbstractClass : bool + member IsArrayType : bool + member IsAttributeType : bool + member IsByRef : bool + member IsClass : bool + member IsDelegate : bool + member IsDisposableType : bool + member IsEnum : bool + member IsFSharp : bool + member IsFSharpAbbreviation : bool + member IsFSharpExceptionDeclaration : bool + member IsFSharpModule : bool + member IsFSharpRecord : bool + member IsFSharpUnion : bool + member IsInterface : bool + member IsMeasure : bool + member IsNamespace : bool + member IsOpaque : bool + member IsProvided : bool + member IsProvidedAndErased : bool + member IsProvidedAndGenerated : bool + member IsStaticInstantiation : bool + member IsUnresolved : bool + member IsValueType : bool + member LogicalName : string member - MembersFunctionsAndValues: System.Collections.Generic.IList + MembersFunctionsAndValues : System.Collections.Generic.IList [] member - MembersOrValues: System.Collections.Generic.IList - member Namespace: string option - member NestedEntities: System.Collections.Generic.IList - member QualifiedName: string + MembersOrValues : System.Collections.Generic.IList + member Namespace : string option + member NestedEntities : System.Collections.Generic.IList + member QualifiedName : string [] - member RecordFields: System.Collections.Generic.IList - member RepresentationAccessibility: FSharpAccessibility + member RecordFields : System.Collections.Generic.IList + member RepresentationAccessibility : FSharpAccessibility member - StaticParameters: System.Collections.Generic.IList - member TryFullName: string option - member UnionCases: System.Collections.Generic.IList - member UsesPrefixDisplay: bool - member XmlDoc: System.Collections.Generic.IList - member XmlDocSig: string - - [] + StaticParameters : System.Collections.Generic.IList + member TryFullName : string option + member UnionCases : System.Collections.Generic.IList + member UsesPrefixDisplay : bool + member XmlDoc : System.Collections.Generic.IList + member XmlDocSig : string + end + [] and FSharpUnionCase = - + class inherit FSharpSymbol - new: SymbolEnv * TypedTree.UnionCaseRef -> FSharpUnionCase - override Equals: other:obj -> bool - override GetHashCode: unit -> int - override ToString: unit -> string - member Accessibility: FSharpAccessibility - member Attributes: System.Collections.Generic.IList - member CompiledName: string - member DeclarationLocation: Range.range - member ElaboratedXmlDoc: System.Collections.Generic.IList - member HasFields: bool - member IsUnresolved: bool - member Name: string - member ReturnType: FSharpType - member UnionCaseFields: System.Collections.Generic.IList - member private V: TypedTree.UnionCaseRef - member XmlDoc: System.Collections.Generic.IList - member XmlDocSig: string - + new : SymbolEnv * TypedTree.UnionCaseRef -> FSharpUnionCase + override Equals : other:obj -> bool + override GetHashCode : unit -> int + override ToString : unit -> string + member Accessibility : FSharpAccessibility + member Attributes : System.Collections.Generic.IList + member CompiledName : string + member DeclarationLocation : Range.range + member ElaboratedXmlDoc : System.Collections.Generic.IList + member HasFields : bool + member IsUnresolved : bool + member Name : string + member ReturnType : FSharpType + member UnionCaseFields : System.Collections.Generic.IList + member private V : TypedTree.UnionCaseRef + member XmlDoc : System.Collections.Generic.IList + member XmlDocSig : string + end and FSharpFieldData = | AnonField of TypedTree.AnonRecdTypeInfo * TypedTree.TTypes * int * Range.range @@ -15572,210 +40639,210 @@ namespace FSharp.Compiler.SourceCodeServices | RecdOrClass of TypedTree.RecdFieldRef | Union of TypedTree.UnionCaseRef * int with - member TryDeclaringTyconRef: TypedTree.TyconRef option + member TryDeclaringTyconRef : TypedTree.TyconRef option member - TryRecdField: Choice - - [] + end + [] and FSharpAnonRecordTypeDetails = - - new: cenv:SymbolEnv * anonInfo:TypedTree.AnonRecdTypeInfo -> + class + new : cenv:SymbolEnv * anonInfo:TypedTree.AnonRecdTypeInfo -> FSharpAnonRecordTypeDetails - member Assembly: FSharpAssembly - member CompiledName: string - member EnclosingCompiledTypeNames: string list - member SortedFieldNames: string [] - - [] + member Assembly : FSharpAssembly + member CompiledName : string + member EnclosingCompiledTypeNames : string list + member SortedFieldNames : string [] + end + [] and FSharpField = - + class inherit FSharpSymbol - new: SymbolEnv * TypedTree.RecdFieldRef -> FSharpField - new: SymbolEnv * TypedTree.UnionCaseRef * int -> FSharpField - new: cenv:SymbolEnv * d:FSharpFieldData -> FSharpField - override Equals: other:obj -> bool - override GetHashCode: unit -> int - override ToString: unit -> string - member Accessibility: FSharpAccessibility + new : SymbolEnv * TypedTree.RecdFieldRef -> FSharpField + new : SymbolEnv * TypedTree.UnionCaseRef * int -> FSharpField + new : cenv:SymbolEnv * d:FSharpFieldData -> FSharpField + override Equals : other:obj -> bool + override GetHashCode : unit -> int + override ToString : unit -> string + member Accessibility : FSharpAccessibility member - AnonRecordFieldDetails: FSharpAnonRecordTypeDetails * FSharpType [] * + AnonRecordFieldDetails : FSharpAnonRecordTypeDetails * FSharpType [] * int - member DeclarationLocation: Range.range - member DeclaringEntity: FSharpEntity option - member DeclaringUnionCase: FSharpUnionCase option - member ElaboratedXmlDoc: System.Collections.Generic.IList - member FieldAttributes: System.Collections.Generic.IList - member FieldType: FSharpType - member IsAnonRecordField: bool - member IsCompilerGenerated: bool - member IsDefaultValue: bool - member IsLiteral: bool - member IsMutable: bool - member IsNameGenerated: bool - member IsStatic: bool - member IsUnionCaseField: bool - member IsUnresolved: bool - member IsVolatile: bool - member LiteralValue: obj option - member Name: string + member DeclarationLocation : Range.range + member DeclaringEntity : FSharpEntity option + member DeclaringUnionCase : FSharpUnionCase option + member ElaboratedXmlDoc : System.Collections.Generic.IList + member FieldAttributes : System.Collections.Generic.IList + member FieldType : FSharpType + member IsAnonRecordField : bool + member IsCompilerGenerated : bool + member IsDefaultValue : bool + member IsLiteral : bool + member IsMutable : bool + member IsNameGenerated : bool + member IsStatic : bool + member IsUnionCaseField : bool + member IsUnresolved : bool + member IsVolatile : bool + member LiteralValue : obj option + member Name : string member - PropertyAttributes: System.Collections.Generic.IList - member private V: FSharpFieldData - member XmlDoc: System.Collections.Generic.IList - member XmlDocSig: string - + PropertyAttributes : System.Collections.Generic.IList + member private V : FSharpFieldData + member XmlDoc : System.Collections.Generic.IList + member XmlDocSig : string + end [] and FSharpRecordField = FSharpField - [] + [] and FSharpAccessibilityRights = - - new: TypedTree.CcuThunk * AccessibilityLogic.AccessorDomain -> + class + new : TypedTree.CcuThunk * AccessibilityLogic.AccessorDomain -> FSharpAccessibilityRights - member internal Contents: AccessibilityLogic.AccessorDomain - member internal ThisCcu: TypedTree.CcuThunk - - [] + member internal Contents : AccessibilityLogic.AccessorDomain + member internal ThisCcu : TypedTree.CcuThunk + end + [] and FSharpActivePatternCase = - + class inherit FSharpSymbol - new: cenv:SymbolEnv * apinfo:PrettyNaming.ActivePatternInfo * + new : cenv:SymbolEnv * apinfo:PrettyNaming.ActivePatternInfo * ty:TypedTree.TType * n:int * valOpt:TypedTree.ValRef option * item:NameResolution.Item -> FSharpActivePatternCase - member DeclarationLocation: Range.range - member ElaboratedXmlDoc: System.Collections.Generic.IList - member Group: FSharpActivePatternGroup - member Index: int - member Name: string - member XmlDoc: System.Collections.Generic.IList - member XmlDocSig: string - - [] + member DeclarationLocation : Range.range + member ElaboratedXmlDoc : System.Collections.Generic.IList + member Group : FSharpActivePatternGroup + member Index : int + member Name : string + member XmlDoc : System.Collections.Generic.IList + member XmlDocSig : string + end + [] and FSharpActivePatternGroup = - - new: cenv:SymbolEnv * apinfo:PrettyNaming.ActivePatternInfo * + class + new : cenv:SymbolEnv * apinfo:PrettyNaming.ActivePatternInfo * ty:TypedTree.TType * valOpt:TypedTree.ValRef option -> FSharpActivePatternGroup - member DeclaringEntity: FSharpEntity option - member IsTotal: bool - member Name: string option - member Names: System.Collections.Generic.IList - member OverallType: FSharpType - - [] + member DeclaringEntity : FSharpEntity option + member IsTotal : bool + member Name : string option + member Names : System.Collections.Generic.IList + member OverallType : FSharpType + end + [] and FSharpGenericParameter = - + class inherit FSharpSymbol - new: SymbolEnv * TypedTree.Typar -> FSharpGenericParameter - override Equals: other:obj -> bool - override GetHashCode: unit -> int - override ToString: unit -> string - member Attributes: System.Collections.Generic.IList + new : SymbolEnv * TypedTree.Typar -> FSharpGenericParameter + override Equals : other:obj -> bool + override GetHashCode : unit -> int + override ToString : unit -> string + member Attributes : System.Collections.Generic.IList member - Constraints: System.Collections.Generic.IList - member DeclarationLocation: Range.range - member ElaboratedXmlDoc: System.Collections.Generic.IList - member IsCompilerGenerated: bool - member IsMeasure: bool - member IsSolveAtCompileTime: bool - member Name: string - member internal V: TypedTree.Typar - member XmlDoc: System.Collections.Generic.IList - - [] + Constraints : System.Collections.Generic.IList + member DeclarationLocation : Range.range + member ElaboratedXmlDoc : System.Collections.Generic.IList + member IsCompilerGenerated : bool + member IsMeasure : bool + member IsSolveAtCompileTime : bool + member Name : string + member internal V : TypedTree.Typar + member XmlDoc : System.Collections.Generic.IList + end + [] and FSharpDelegateSignature = - - new: cenv:SymbolEnv * info:TypedTree.SlotSig -> FSharpDelegateSignature - override ToString: unit -> string + class + new : cenv:SymbolEnv * info:TypedTree.SlotSig -> FSharpDelegateSignature + override ToString : unit -> string member - DelegateArguments: System.Collections.Generic.IList - member DelegateReturnType: FSharpType - - [] + member DelegateReturnType : FSharpType + end + [] and FSharpAbstractParameter = - - new: cenv:SymbolEnv * info:TypedTree.SlotParam -> FSharpAbstractParameter - member Attributes: System.Collections.Generic.IList - member IsInArg: bool - member IsOptionalArg: bool - member IsOutArg: bool - member Name: string option - member Type: FSharpType - - [] + class + new : cenv:SymbolEnv * info:TypedTree.SlotParam -> FSharpAbstractParameter + member Attributes : System.Collections.Generic.IList + member IsInArg : bool + member IsOptionalArg : bool + member IsOutArg : bool + member Name : string option + member Type : FSharpType + end + [] and FSharpAbstractSignature = - - new: SymbolEnv * TypedTree.SlotSig -> FSharpAbstractSignature + class + new : SymbolEnv * TypedTree.SlotSig -> FSharpAbstractSignature member - AbstractArguments: System.Collections.Generic.IList> - member AbstractReturnType: FSharpType - member DeclaringType: FSharpType + AbstractArguments : System.Collections.Generic.IList> + member AbstractReturnType : FSharpType + member DeclaringType : FSharpType member - DeclaringTypeGenericParameters: System.Collections.Generic.IList + DeclaringTypeGenericParameters : System.Collections.Generic.IList member - MethodGenericParameters: System.Collections.Generic.IList - member Name: string - - [] + MethodGenericParameters : System.Collections.Generic.IList + member Name : string + end + [] and FSharpGenericParameterMemberConstraint = - - new: cenv:SymbolEnv * info:TypedTree.TraitConstraintInfo -> + class + new : cenv:SymbolEnv * info:TypedTree.TraitConstraintInfo -> FSharpGenericParameterMemberConstraint - override ToString: unit -> string - member MemberArgumentTypes: System.Collections.Generic.IList - member MemberIsStatic: bool - member MemberName: string - member MemberReturnType: FSharpType - member MemberSources: System.Collections.Generic.IList - - [] + override ToString : unit -> string + member MemberArgumentTypes : System.Collections.Generic.IList + member MemberIsStatic : bool + member MemberName : string + member MemberReturnType : FSharpType + member MemberSources : System.Collections.Generic.IList + end + [] and FSharpGenericParameterDelegateConstraint = - - new: cenv:SymbolEnv * tupledArgTy:TypedTree.TType * rty:TypedTree.TType -> + class + new : cenv:SymbolEnv * tupledArgTy:TypedTree.TType * rty:TypedTree.TType -> FSharpGenericParameterDelegateConstraint - override ToString: unit -> string - member DelegateReturnType: FSharpType - member DelegateTupledArgumentType: FSharpType - - [] + override ToString : unit -> string + member DelegateReturnType : FSharpType + member DelegateTupledArgumentType : FSharpType + end + [] and FSharpGenericParameterDefaultsToConstraint = - - new: cenv:SymbolEnv * pri:int * ty:TypedTree.TType -> + class + new : cenv:SymbolEnv * pri:int * ty:TypedTree.TType -> FSharpGenericParameterDefaultsToConstraint - override ToString: unit -> string - member DefaultsToPriority: int - member DefaultsToTarget: FSharpType - - [] + override ToString : unit -> string + member DefaultsToPriority : int + member DefaultsToTarget : FSharpType + end + [] and FSharpGenericParameterConstraint = - - new: cenv:SymbolEnv * cx:TypedTree.TyparConstraint -> + class + new : cenv:SymbolEnv * cx:TypedTree.TyparConstraint -> FSharpGenericParameterConstraint - override ToString: unit -> string - member CoercesToTarget: FSharpType + override ToString : unit -> string + member CoercesToTarget : FSharpType member - DefaultsToConstraintData: FSharpGenericParameterDefaultsToConstraint - member DelegateConstraintData: FSharpGenericParameterDelegateConstraint - member EnumConstraintTarget: FSharpType - member IsCoercesToConstraint: bool - member IsComparisonConstraint: bool - member IsDefaultsToConstraint: bool - member IsDelegateConstraint: bool - member IsEnumConstraint: bool - member IsEqualityConstraint: bool - member IsMemberConstraint: bool - member IsNonNullableValueTypeConstraint: bool - member IsReferenceTypeConstraint: bool - member IsRequiresDefaultConstructorConstraint: bool - member IsSimpleChoiceConstraint: bool - member IsSupportsNullConstraint: bool - member IsUnmanagedConstraint: bool - member MemberConstraintData: FSharpGenericParameterMemberConstraint - member SimpleChoices: System.Collections.Generic.IList - - [] + DefaultsToConstraintData : FSharpGenericParameterDefaultsToConstraint + member DelegateConstraintData : FSharpGenericParameterDelegateConstraint + member EnumConstraintTarget : FSharpType + member IsCoercesToConstraint : bool + member IsComparisonConstraint : bool + member IsDefaultsToConstraint : bool + member IsDelegateConstraint : bool + member IsEnumConstraint : bool + member IsEqualityConstraint : bool + member IsMemberConstraint : bool + member IsNonNullableValueTypeConstraint : bool + member IsReferenceTypeConstraint : bool + member IsRequiresDefaultConstructorConstraint : bool + member IsSimpleChoiceConstraint : bool + member IsSupportsNullConstraint : bool + member IsUnmanagedConstraint : bool + member MemberConstraintData : FSharpGenericParameterMemberConstraint + member SimpleChoices : System.Collections.Generic.IList + end + [] and FSharpInlineAnnotation = | PseudoValue | AlwaysInline @@ -15790,316 +40857,316 @@ namespace FSharp.Compiler.SourceCodeServices | V of TypedTree.ValRef and FSharpMemberOrVal = FSharpMemberOrFunctionOrValue and FSharpMemberFunctionOrValue = FSharpMemberOrFunctionOrValue - [] + [] and FSharpMemberOrFunctionOrValue = - + class inherit FSharpSymbol - new: SymbolEnv * Infos.MethInfo -> FSharpMemberOrFunctionOrValue - new: SymbolEnv * TypedTree.ValRef -> FSharpMemberOrFunctionOrValue - new: cenv:SymbolEnv * d:FSharpMemberOrValData * item:NameResolution.Item -> + new : SymbolEnv * Infos.MethInfo -> FSharpMemberOrFunctionOrValue + new : SymbolEnv * TypedTree.ValRef -> FSharpMemberOrFunctionOrValue + new : cenv:SymbolEnv * d:FSharpMemberOrValData * item:NameResolution.Item -> FSharpMemberOrFunctionOrValue - override Equals: other:obj -> bool + override Equals : other:obj -> bool member - FormatLayout: context:FSharpDisplayContext -> + FormatLayout : context:FSharpDisplayContext -> Internal.Utilities.StructuredFormat.Layout - override GetHashCode: unit -> int + override GetHashCode : unit -> int member - GetWitnessPassingInfo: unit -> + GetWitnessPassingInfo : unit -> (string * System.Collections.Generic.IList) option member - Overloads: bool -> + Overloads : bool -> System.Collections.Generic.IList option - override ToString: unit -> string - member Accessibility: FSharpAccessibility - member ApparentEnclosingEntity: FSharpEntity - member Attributes: System.Collections.Generic.IList - member CompiledName: string + override ToString : unit -> string + member Accessibility : FSharpAccessibility + member ApparentEnclosingEntity : FSharpEntity + member Attributes : System.Collections.Generic.IList + member CompiledName : string member - CurriedParameterGroups: System.Collections.Generic.IList> - member Data: FSharpMemberOrValData - member DeclarationLocation: Range.range - member DeclarationLocationOpt: Range.range option - member DeclaringEntity: FSharpEntity option - member DisplayName: string - member ElaboratedXmlDoc: System.Collections.Generic.IList - member EventAddMethod: FSharpMemberOrFunctionOrValue - member EventDelegateType: FSharpType - member EventForFSharpProperty: FSharpMemberOrFunctionOrValue option - member EventIsStandard: bool - member EventRemoveMethod: FSharpMemberOrFunctionOrValue - member FullType: FSharpType + CurriedParameterGroups : System.Collections.Generic.IList> + member Data : FSharpMemberOrValData + member DeclarationLocation : Range.range + member DeclarationLocationOpt : Range.range option + member DeclaringEntity : FSharpEntity option + member DisplayName : string + member ElaboratedXmlDoc : System.Collections.Generic.IList + member EventAddMethod : FSharpMemberOrFunctionOrValue + member EventDelegateType : FSharpType + member EventForFSharpProperty : FSharpMemberOrFunctionOrValue option + member EventIsStandard : bool + member EventRemoveMethod : FSharpMemberOrFunctionOrValue + member FullType : FSharpType member - GenericParameters: System.Collections.Generic.IList - member GetterMethod: FSharpMemberOrFunctionOrValue - member HasGetterMethod: bool - member HasSetterMethod: bool + GenericParameters : System.Collections.Generic.IList + member GetterMethod : FSharpMemberOrFunctionOrValue + member HasGetterMethod : bool + member HasSetterMethod : bool member - ImplementedAbstractSignatures: System.Collections.Generic.IList - member InlineAnnotation: FSharpInlineAnnotation - member IsActivePattern: bool - member IsBaseValue: bool - member IsCompilerGenerated: bool - member IsConstructor: bool - member IsConstructorThisValue: bool - member IsDispatchSlot: bool - member IsEvent: bool - member IsEventAddMethod: bool - member IsEventRemoveMethod: bool - member IsExplicitInterfaceImplementation: bool - member IsExtensionMember: bool + ImplementedAbstractSignatures : System.Collections.Generic.IList + member InlineAnnotation : FSharpInlineAnnotation + member IsActivePattern : bool + member IsBaseValue : bool + member IsCompilerGenerated : bool + member IsConstructor : bool + member IsConstructorThisValue : bool + member IsDispatchSlot : bool + member IsEvent : bool + member IsEventAddMethod : bool + member IsEventRemoveMethod : bool + member IsExplicitInterfaceImplementation : bool + member IsExtensionMember : bool [] - member IsGetterMethod: bool - member IsImplicitConstructor: bool - member IsInstanceMember: bool - member IsInstanceMemberInCompiledCode: bool - member IsMember: bool - member IsMemberThisValue: bool - member IsModuleValueOrMember: bool - member IsMutable: bool - member IsOverrideOrExplicitInterfaceImplementation: bool + member IsGetterMethod : bool + member IsImplicitConstructor : bool + member IsInstanceMember : bool + member IsInstanceMemberInCompiledCode : bool + member IsMember : bool + member IsMemberThisValue : bool + member IsModuleValueOrMember : bool + member IsMutable : bool + member IsOverrideOrExplicitInterfaceImplementation : bool [] - member IsOverrideOrExplicitMember: bool - member IsProperty: bool - member IsPropertyGetterMethod: bool - member IsPropertySetterMethod: bool + member IsOverrideOrExplicitMember : bool + member IsProperty : bool + member IsPropertyGetterMethod : bool + member IsPropertySetterMethod : bool [] - member IsSetterMethod: bool - member IsTypeFunction: bool - member IsUnresolved: bool - member IsValCompiledAsMethod: bool - member IsValue: bool - member LiteralValue: obj option - member LogicalName: string - member ReturnParameter: FSharpParameter - member SetterMethod: FSharpMemberOrFunctionOrValue - member XmlDoc: System.Collections.Generic.IList - member XmlDocSig: string - - [] + member IsSetterMethod : bool + member IsTypeFunction : bool + member IsUnresolved : bool + member IsValCompiledAsMethod : bool + member IsValue : bool + member LiteralValue : obj option + member LogicalName : string + member ReturnParameter : FSharpParameter + member SetterMethod : FSharpMemberOrFunctionOrValue + member XmlDoc : System.Collections.Generic.IList + member XmlDocSig : string + end + [] and FSharpType = - - new: g:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + class + new : g:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * thisCcuTyp:TypedTree.ModuleOrNamespaceType * tcImports:CompilerImports.TcImports * ty:TypedTree.TType -> FSharpType - new: SymbolEnv * ty:TypedTree.TType -> FSharpType + new : SymbolEnv * ty:TypedTree.TType -> FSharpType static member - Prettify: parameters:System.Collections.Generic.IList> -> + Prettify : parameters:System.Collections.Generic.IList> -> System.Collections.Generic.IList> static member - Prettify: parameters:System.Collections.Generic.IList -> + Prettify : parameters:System.Collections.Generic.IList -> System.Collections.Generic.IList - static member Prettify: parameter:FSharpParameter -> FSharpParameter + static member Prettify : parameter:FSharpParameter -> FSharpParameter static member - Prettify: types:System.Collections.Generic.IList -> + Prettify : types:System.Collections.Generic.IList -> System.Collections.Generic.IList - static member Prettify: ty:FSharpType -> FSharpType + static member Prettify : ty:FSharpType -> FSharpType static member - Prettify: parameters:System.Collections.Generic.IList> * + Prettify : parameters:System.Collections.Generic.IList> * returnParameter:FSharpParameter -> System.Collections.Generic.IList> * FSharpParameter - member private AdjustType: t:TypedTree.TType -> FSharpType - override Equals: other:obj -> bool - member Format: context:FSharpDisplayContext -> string + member private AdjustType : t:TypedTree.TType -> FSharpType + override Equals : other:obj -> bool + member Format : context:FSharpDisplayContext -> string member - FormatLayout: context:FSharpDisplayContext -> + FormatLayout : context:FSharpDisplayContext -> Internal.Utilities.StructuredFormat.Layout - override GetHashCode: unit -> int + override GetHashCode : unit -> int member - Instantiate: (FSharpGenericParameter * FSharpType) list -> FSharpType - override ToString: unit -> string - member AbbreviatedType: FSharpType - member AllInterfaces: System.Collections.Generic.IList - member AnonRecordTypeDetails: FSharpAnonRecordTypeDetails - member BaseType: FSharpType option - member GenericArguments: System.Collections.Generic.IList - member GenericParameter: FSharpGenericParameter - member HasTypeDefinition: bool - member IsAbbreviation: bool - member IsAnonRecordType: bool - member IsFunctionType: bool - member IsGenericParameter: bool + Instantiate : (FSharpGenericParameter * FSharpType) list -> FSharpType + override ToString : unit -> string + member AbbreviatedType : FSharpType + member AllInterfaces : System.Collections.Generic.IList + member AnonRecordTypeDetails : FSharpAnonRecordTypeDetails + member BaseType : FSharpType option + member GenericArguments : System.Collections.Generic.IList + member GenericParameter : FSharpGenericParameter + member HasTypeDefinition : bool + member IsAbbreviation : bool + member IsAnonRecordType : bool + member IsFunctionType : bool + member IsGenericParameter : bool [] - member IsNamedType: bool - member IsStructTupleType: bool - member IsTupleType: bool - member IsUnresolved: bool + member IsNamedType : bool + member IsStructTupleType : bool + member IsTupleType : bool + member IsUnresolved : bool [] - member NamedEntity: FSharpEntity - member TypeDefinition: FSharpEntity - member private V: TypedTree.TType - member private cenv: SymbolEnv - - [] + member NamedEntity : FSharpEntity + member TypeDefinition : FSharpEntity + member private V : TypedTree.TType + member private cenv : SymbolEnv + end + [] and FSharpAttribute = - - new: cenv:SymbolEnv * attrib:AttributeChecking.AttribInfo -> + class + new : cenv:SymbolEnv * attrib:AttributeChecking.AttribInfo -> FSharpAttribute - member Format: context:FSharpDisplayContext -> string - override ToString: unit -> string - member AttributeType: FSharpEntity + member Format : context:FSharpDisplayContext -> string + override ToString : unit -> string + member AttributeType : FSharpEntity member - ConstructorArguments: System.Collections.Generic.IList - member IsUnresolved: bool + ConstructorArguments : System.Collections.Generic.IList + member IsUnresolved : bool member - NamedArguments: System.Collections.Generic.IList - member Range: Range.range - - [] + member Range : Range.range + end + [] and FSharpStaticParameter = - + class inherit FSharpSymbol - new: cenv:SymbolEnv * sp:Tainted * + new : cenv:SymbolEnv * sp:Tainted * m:Range.range -> FSharpStaticParameter - override Equals: other:obj -> bool - override GetHashCode: unit -> int - override ToString: unit -> string - member DeclarationLocation: Range.range - member DefaultValue: obj + override Equals : other:obj -> bool + override GetHashCode : unit -> int + override ToString : unit -> string + member DeclarationLocation : Range.range + member DefaultValue : obj [] - member HasDefaultValue: bool - member IsOptional: bool - member Kind: FSharpType - member Name: string - member Range: Range.range - - [] + member HasDefaultValue : bool + member IsOptional : bool + member Kind : FSharpType + member Name : string + member Range : Range.range + end + [] and FSharpParameter = - + class inherit FSharpSymbol - new: cenv:SymbolEnv * ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo * + new : cenv:SymbolEnv * ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo * ownerRangeOpt:Range.range option -> FSharpParameter - new: cenv:SymbolEnv * id:SyntaxTree.Ident * ty:TypedTree.TType * + new : cenv:SymbolEnv * id:SyntaxTree.Ident * ty:TypedTree.TType * container:NameResolution.ArgumentContainer option -> FSharpParameter - new: cenv:SymbolEnv * paramTy:TypedTree.TType * + new : cenv:SymbolEnv * paramTy:TypedTree.TType * topArgInfo:TypedTree.ArgReprInfo * ownerOpt:NameResolution.ArgumentContainer option * ownerRangeOpt:Range.range option * isParamArrayArg:bool * isInArg:bool * isOutArg:bool * isOptionalArg:bool * isWitnessArg:bool -> FSharpParameter - member AdjustType: ty:TypedTree.TType -> FSharpParameter - override Equals: other:obj -> bool - override GetHashCode: unit -> int - override ToString: unit -> string - member Attributes: System.Collections.Generic.IList - member DeclarationLocation: Range.range - member IsInArg: bool - member IsOptionalArg: bool - member IsOutArg: bool - member IsParamArrayArg: bool - member IsWitnessArg: bool - member Name: string option - member Owner: FSharpSymbol option - member Type: FSharpType - member V: TypedTree.TType - member private ValReprInfo: TypedTree.ArgReprInfo - member cenv: SymbolEnv - + member AdjustType : ty:TypedTree.TType -> FSharpParameter + override Equals : other:obj -> bool + override GetHashCode : unit -> int + override ToString : unit -> string + member Attributes : System.Collections.Generic.IList + member DeclarationLocation : Range.range + member IsInArg : bool + member IsOptionalArg : bool + member IsOutArg : bool + member IsParamArrayArg : bool + member IsWitnessArg : bool + member Name : string option + member Owner : FSharpSymbol option + member Type : FSharpType + member V : TypedTree.TType + member private ValReprInfo : TypedTree.ArgReprInfo + member cenv : SymbolEnv + end and FSharpAssemblySignature = - - new: tcGlobals:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + class + new : tcGlobals:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * thisCcuTyp:TypedTree.ModuleOrNamespaceType * tcImports:CompilerImports.TcImports * topAttribs:CheckDeclarations.TopAttribs option * contents:TypedTree.ModuleOrNamespaceType -> FSharpAssemblySignature - new: cenv:SymbolEnv * ccu:TypedTree.CcuThunk -> FSharpAssemblySignature - new: cenv:SymbolEnv * topAttribs:CheckDeclarations.TopAttribs option * + new : cenv:SymbolEnv * ccu:TypedTree.CcuThunk -> FSharpAssemblySignature + new : cenv:SymbolEnv * topAttribs:CheckDeclarations.TopAttribs option * optViewedCcu:TypedTree.CcuThunk option * mtyp:TypedTree.ModuleOrNamespaceType -> FSharpAssemblySignature - member FindEntityByPath: string list -> FSharpEntity option - override ToString: unit -> string - member Attributes: System.Collections.Generic.IList - member Entities: System.Collections.Generic.IList - + member FindEntityByPath : string list -> FSharpEntity option + override ToString : unit -> string + member Attributes : System.Collections.Generic.IList + member Entities : System.Collections.Generic.IList + end and FSharpAssembly = - - new: tcGlobals:TcGlobals.TcGlobals * tcImports:CompilerImports.TcImports * + class + new : tcGlobals:TcGlobals.TcGlobals * tcImports:CompilerImports.TcImports * ccu:TypedTree.CcuThunk -> FSharpAssembly - internal new: cenv:SymbolEnv * ccu:TypedTree.CcuThunk -> FSharpAssembly - override ToString: unit -> string + internal new : cenv:SymbolEnv * ccu:TypedTree.CcuThunk -> FSharpAssembly + override ToString : unit -> string [] - member CodeLocation: string - member Contents: FSharpAssemblySignature - member FileName: string option - member IsProviderGenerated: bool - member QualifiedName: string - member RawCcuThunk: TypedTree.CcuThunk - member SimpleName: string - - [] + member CodeLocation : string + member Contents : FSharpAssemblySignature + member FileName : string option + member IsProviderGenerated : bool + member QualifiedName : string + member RawCcuThunk : TypedTree.CcuThunk + member SimpleName : string + end + [] and FSharpOpenDeclaration = - - new: target:SyntaxTree.SynOpenDeclTarget * range:Range.range option * + class + new : target:SyntaxTree.SynOpenDeclTarget * range:Range.range option * modules:FSharpEntity list * types:FSharpType list * appliedScope:Range.range * isOwnNamespace:bool -> FSharpOpenDeclaration - member AppliedScope: Range.range - member IsOwnNamespace: bool - member LongId: SyntaxTree.LongIdent - member Modules: FSharpEntity list - member Range: Range.range option - member Target: SyntaxTree.SynOpenDeclTarget - member Types: FSharpType list - - [] + member AppliedScope : Range.range + member IsOwnNamespace : bool + member LongId : SyntaxTree.LongIdent + member Modules : FSharpEntity list + member Range : Range.range option + member Target : SyntaxTree.SynOpenDeclTarget + member Types : FSharpType list + end + [] and FSharpSymbolUse = - - new: g:TcGlobals.TcGlobals * denv:TypedTreeOps.DisplayEnv * + class + new : g:TcGlobals.TcGlobals * denv:TypedTreeOps.DisplayEnv * symbol:FSharpSymbol * itemOcc:NameResolution.ItemOccurence * range:Range.range -> FSharpSymbolUse - override ToString: unit -> string - member DisplayContext: FSharpDisplayContext - member FileName: string - member IsDefinition: bool - member IsFromAttribute: bool - member IsFromComputationExpression: bool - member IsFromDefinition: bool - member IsFromDispatchSlotImplementation: bool - member IsFromOpenStatement: bool - member IsFromPattern: bool - member IsFromType: bool - member IsPrivateToFile: bool - member Range: Range.Range01 - member RangeAlternate: Range.range - member Symbol: FSharpSymbol - - module Impl = - val protect: f:(unit -> 'a) -> 'a - val makeReadOnlyCollection: + override ToString : unit -> string + member DisplayContext : FSharpDisplayContext + member FileName : string + member IsDefinition : bool + member IsFromAttribute : bool + member IsFromComputationExpression : bool + member IsFromDefinition : bool + member IsFromDispatchSlotImplementation : bool + member IsFromOpenStatement : bool + member IsFromPattern : bool + member IsFromType : bool + member IsPrivateToFile : bool + member Range : Range.Range01 + member RangeAlternate : Range.range + member Symbol : FSharpSymbol + end + module Impl = begin + val protect : f:(unit -> 'a) -> 'a + val makeReadOnlyCollection : arr:seq<'T> -> System.Collections.Generic.IList<'T> - val makeXmlDoc: + val makeXmlDoc : doc:XmlDoc.XmlDoc -> System.Collections.Generic.IList - val makeElaboratedXmlDoc: + val makeElaboratedXmlDoc : doc:XmlDoc.XmlDoc -> System.Collections.Generic.IList - val rescopeEntity: + val rescopeEntity : optViewedCcu:TypedTree.CcuThunk option -> entity:TypedTree.Entity -> TypedTree.EntityRef - val entityIsUnresolved: entity:TypedTree.EntityRef -> bool - val checkEntityIsResolved: entity:TypedTree.EntityRef -> unit - val checkForCrossProjectAccessibility: + val entityIsUnresolved : entity:TypedTree.EntityRef -> bool + val checkEntityIsResolved : entity:TypedTree.EntityRef -> unit + val checkForCrossProjectAccessibility : ilg:AbstractIL.IL.ILGlobals -> thisCcu2:TypedTree.CcuThunk * ad2:AccessibilityLogic.AccessorDomain -> thisCcu1:TypedTree.CcuThunk * taccess1:TypedTree.Accessibility -> bool - val getApproxFSharpAccessibilityOfMember: + val getApproxFSharpAccessibilityOfMember : declaringEntity:TypedTree.EntityRef -> ilAccess:AbstractIL.IL.ILMemberAccess -> TypedTree.Accessibility - val getApproxFSharpAccessibilityOfEntity: + val getApproxFSharpAccessibilityOfEntity : entity:TypedTree.EntityRef -> TypedTree.Accessibility - val getLiteralValue: _arg6:TypedTree.Const option -> obj option - val getXmlDocSigForEntity: + val getLiteralValue : _arg6:TypedTree.Const option -> obj option + val getXmlDocSigForEntity : cenv:SymbolEnv -> ent:TypedTree.EntityRef -> string - + end namespace FSharp.Compiler.SourceCodeServices - module ExprTranslationImpl = - val nonNil: x:'a list -> bool + module ExprTranslationImpl = begin + val nonNil : x:'a list -> bool type ExprTranslationEnv = { vs: TypedTreeOps.ValMap tyvs: TypedTree.StampMap @@ -16108,28 +41175,28 @@ namespace FSharp.Compiler.SourceCodeServices suppressWitnesses: bool witnessesInScope: TypedTreeOps.TraitWitnessInfoHashMap } with - static member Empty: g:TcGlobals.TcGlobals -> ExprTranslationEnv + static member Empty : g:TcGlobals.TcGlobals -> ExprTranslationEnv member - BindCurriedVals: vsl:TypedTree.Val list list -> ExprTranslationEnv + BindCurriedVals : vsl:TypedTree.Val list list -> ExprTranslationEnv member - BindIsInstVal: v:TypedTree.Val -> + BindIsInstVal : v:TypedTree.Val -> ty:TypedTree.TType * e:TypedTree.Expr -> ExprTranslationEnv member - BindSubstVal: v:TypedTree.Val -> + BindSubstVal : v:TypedTree.Val -> e:TypedTree.Expr -> ExprTranslationEnv member - BindTypar: v:TypedTree.Typar * gp:FSharpGenericParameter -> + BindTypar : v:TypedTree.Typar * gp:FSharpGenericParameter -> ExprTranslationEnv member - BindTypars: vs:(TypedTree.Typar * #FSharpGenericParameter) list -> + BindTypars : vs:(TypedTree.Typar * #FSharpGenericParameter) list -> ExprTranslationEnv - member BindVal: v:TypedTree.Val -> ExprTranslationEnv - member BindVals: vs:TypedTree.Val list -> ExprTranslationEnv - + member BindVal : v:TypedTree.Val -> ExprTranslationEnv + member BindVals : vs:TypedTree.Val list -> ExprTranslationEnv + end exception IgnoringPartOfQuotedTermWarning of string * Range.range - val wfail: msg:string * m:Range.range -> 'a - + val wfail : msg:string * m:Range.range -> 'a + end type E = | Value of FSharpMemberOrFunctionOrValue | ThisValue of FSharpType @@ -16190,179 +41257,179 @@ namespace FSharp.Compiler.SourceCodeServices | ILFieldSet of FSharpExpr option * FSharpType * string * FSharpExpr | ILAsm of string * FSharpType list * FSharpExpr list | WitnessArg of int - [] + [] and FSharpObjectExprOverride = - - new: sgn:FSharpAbstractSignature * gps:FSharpGenericParameter list * + class + new : sgn:FSharpAbstractSignature * gps:FSharpGenericParameter list * args:FSharpMemberOrFunctionOrValue list list * body:FSharpExpr -> FSharpObjectExprOverride - member Body: FSharpExpr - member CurriedParameterGroups: FSharpMemberOrFunctionOrValue list list - member GenericParameters: FSharpGenericParameter list - member Signature: FSharpAbstractSignature - - [] + member Body : FSharpExpr + member CurriedParameterGroups : FSharpMemberOrFunctionOrValue list list + member GenericParameters : FSharpGenericParameter list + member Signature : FSharpAbstractSignature + end + [] and FSharpExpr = - - new: cenv:SymbolEnv * f:(unit -> FSharpExpr) option * e:E * m:Range.range * + class + new : cenv:SymbolEnv * f:(unit -> FSharpExpr) option * e:E * m:Range.range * ty:TypedTree.TType -> FSharpExpr - override ToString: unit -> string - member E: E - member ImmediateSubExpressions: FSharpExpr list - member Range: Range.range - member Type: FSharpType - member cenv: SymbolEnv - - module FSharpExprConvert = - val IsStaticInitializationField: rfref:TypedTree.RecdFieldRef -> bool - val ( |StaticInitializationCheck|_| ): e:TypedTree.Expr -> unit option - val ( |StaticInitializationCount|_| ): e:TypedTree.Expr -> unit option - val ( |ILUnaryOp|_| ): + override ToString : unit -> string + member E : E + member ImmediateSubExpressions : FSharpExpr list + member Range : Range.range + member Type : FSharpType + member cenv : SymbolEnv + end + module FSharpExprConvert = begin + val IsStaticInitializationField : rfref:TypedTree.RecdFieldRef -> bool + val ( |StaticInitializationCheck|_| ) : e:TypedTree.Expr -> unit option + val ( |StaticInitializationCount|_| ) : e:TypedTree.Expr -> unit option + val ( |ILUnaryOp|_| ) : e:AbstractIL.IL.ILInstr -> (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr) option - val ( |ILMulDivOp|_| ): + val ( |ILMulDivOp|_| ) : e:AbstractIL.IL.ILInstr -> ((#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.TType -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr) * bool) option - val ( |ILBinaryOp|_| ): + val ( |ILBinaryOp|_| ) : e:AbstractIL.IL.ILInstr -> (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr) option - val ( |ILConvertOp|_| ): + val ( |ILConvertOp|_| ) : e:AbstractIL.IL.ILInstr -> (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr) option - val ( |TTypeConvOp|_| ): + val ( |TTypeConvOp|_| ) : cenv:SymbolEnv -> ty:TypedTree.TType -> (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr) option - val ConvType: cenv:SymbolEnv -> ty:TypedTree.TType -> FSharpType - val ConvTypes: + val ConvType : cenv:SymbolEnv -> ty:TypedTree.TType -> FSharpType + val ConvTypes : cenv:SymbolEnv -> tys:TypedTree.TType list -> FSharpType list - val ConvILTypeRefApp: + val ConvILTypeRefApp : cenv:SymbolEnv -> m:Range.range -> tref:AbstractIL.IL.ILTypeRef -> tyargs:TypedTree.TypeInst -> FSharpType - val ConvUnionCaseRef: + val ConvUnionCaseRef : cenv:SymbolEnv -> ucref:TypedTree.UnionCaseRef -> FSharpUnionCase - val ConvRecdFieldRef: + val ConvRecdFieldRef : cenv:SymbolEnv -> rfref:TypedTree.RecdFieldRef -> FSharpField - val exprOfExprAddr: cenv:SymbolEnv -> expr:TypedTree.Expr -> TypedTree.Expr - val Mk: + val exprOfExprAddr : cenv:SymbolEnv -> expr:TypedTree.Expr -> TypedTree.Expr + val Mk : cenv:SymbolEnv -> m:Range.range -> ty:TypedTree.TType -> e:E -> FSharpExpr - val Mk2: cenv:SymbolEnv -> orig:TypedTree.Expr -> e:E -> FSharpExpr - val ConvLValueExpr: + val Mk2 : cenv:SymbolEnv -> orig:TypedTree.Expr -> e:E -> FSharpExpr + val ConvLValueExpr : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> expr:TypedTree.Expr -> FSharpExpr - val ConvExpr: + val ConvExpr : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> expr:TypedTree.Expr -> FSharpExpr - val ConvExprLinear: + val ConvExprLinear : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> expr:TypedTree.Expr -> contF:(FSharpExpr -> E) -> E - val ConvExprPrimLinear: + val ConvExprPrimLinear : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> expr:TypedTree.Expr -> contF:(E -> E) -> E - val ConvModuleValueOrMemberUseLinear: + val ConvModuleValueOrMemberUseLinear : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> expr:TypedTree.Expr * vref:TypedTree.ValRef * vFlags:TypedTree.ValUseFlag * tyargs:TypedTree.TypeInst * curriedArgs:TypedTree.Expr list -> contF:(E -> E) -> E - val GetWitnessArgs: + val GetWitnessArgs : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> vref:TypedTree.ValRef -> m:Range.range -> tps:TypedTree.Typars -> tyargs:TypedTree.TypeInst -> FSharpExpr list - val ConvExprPrim: + val ConvExprPrim : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> expr:TypedTree.Expr -> E - val ConvWitnessInfoPrim: + val ConvWitnessInfoPrim : _cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> traitInfo:TypedTree.TraitConstraintInfo -> E - val ConvWitnessInfo: + val ConvWitnessInfo : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> m:Range.range -> traitInfo:TypedTree.TraitConstraintInfo -> FSharpExpr - val ConvLetBind: + val ConvLetBind : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> bind:TypedTree.Binding -> (FSharpMemberOrFunctionOrValue * FSharpExpr) option * ExprTranslationImpl.ExprTranslationEnv - val ConvILCall: + val ConvILCall : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> isNewObj:bool * valUseFlags:TypedTree.ValUseFlag * ilMethRef:AbstractIL.IL.ILMethodRef * enclTypeArgs:TypedTree.TypeInst * methTypeArgs:TypedTree.TypeInst * callArgs:TypedTree.Exprs * m:Range.range -> E - val ConvObjectModelCallLinear: + val ConvObjectModelCallLinear : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> isNewObj:bool * v:FSharpMemberOrFunctionOrValue * enclTyArgs:TypedTree.TType list * methTyArgs:TypedTree.TType list * witnessArgsR:FSharpExpr list * callArgs:TypedTree.Expr list -> contF:(E -> E) -> E - val ConvExprs: + val ConvExprs : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> args:TypedTree.Exprs -> FSharpExpr list - val ConvExprsLinear: + val ConvExprsLinear : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> args:TypedTree.Expr list -> contF:(FSharpExpr list -> E) -> E - val ConvTargetsLinear: + val ConvTargetsLinear : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> tgs:TypedTree.DecisionTreeTarget list -> contF:((FSharpMemberOrFunctionOrValue list * FSharpExpr) list -> E) -> E - val ConvValRef: + val ConvValRef : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> m:Range.range -> vref:TypedTree.ValRef -> E - val ConvVal: + val ConvVal : cenv:SymbolEnv -> v:TypedTree.Val -> FSharpMemberOrFunctionOrValue - val ConvConst: + val ConvConst : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> m:Range.range -> c:TypedTree.Const -> ty:TypedTree.TType -> E - val ConvDecisionTree: + val ConvDecisionTree : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> dtreeRetTy:TypedTree.TType -> x:TypedTree.DecisionTree -> m:Range.range -> FSharpExpr - val ConvDecisionTreePrim: + val ConvDecisionTreePrim : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> dtreeRetTy:TypedTree.TType -> x:TypedTree.DecisionTree -> E - val ConvExprOnDemand: + val ConvExprOnDemand : cenv:SymbolEnv -> env:ExprTranslationImpl.ExprTranslationEnv -> expr:TypedTree.Expr -> FSharpExpr - + end type FSharpAssemblyContents = - - new: tcGlobals:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * + class + new : tcGlobals:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * thisCcuType:TypedTree.ModuleOrNamespaceType option * tcImports:CompilerImports.TcImports * mimpls:TypedTree.TypedImplFile list -> FSharpAssemblyContents - new: cenv:SymbolEnv * mimpls:TypedTree.TypedImplFile list -> + new : cenv:SymbolEnv * mimpls:TypedTree.TypedImplFile list -> FSharpAssemblyContents - member ImplementationFiles: FSharpImplementationFileContents list - + member ImplementationFiles : FSharpImplementationFileContents list + end and FSharpImplementationFileDeclaration = | Entity of FSharpEntity * FSharpImplementationFileDeclaration list | MemberOrFunctionOrValue of @@ -16370,183 +41437,183 @@ namespace FSharp.Compiler.SourceCodeServices FSharpExpr | InitAction of FSharpExpr and FSharpImplementationFileContents = - - new: cenv:SymbolEnv * mimpl:TypedTree.TypedImplFile -> + class + new : cenv:SymbolEnv * mimpl:TypedTree.TypedImplFile -> FSharpImplementationFileContents - member Declarations: FSharpImplementationFileDeclaration list - member FileName: string - member HasExplicitEntryPoint: bool - member IsScript: bool - member QualifiedName: string - - module BasicPatterns = - val ( |Value|_| ): FSharpExpr -> FSharpMemberOrFunctionOrValue option - val ( |Const|_| ): FSharpExpr -> (obj * FSharpType) option - val ( |TypeLambda|_| ): + member Declarations : FSharpImplementationFileDeclaration list + member FileName : string + member HasExplicitEntryPoint : bool + member IsScript : bool + member QualifiedName : string + end + module BasicPatterns = begin + val ( |Value|_| ) : FSharpExpr -> FSharpMemberOrFunctionOrValue option + val ( |Const|_| ) : FSharpExpr -> (obj * FSharpType) option + val ( |TypeLambda|_| ) : FSharpExpr -> (FSharpGenericParameter list * FSharpExpr) option - val ( |Lambda|_| ): + val ( |Lambda|_| ) : FSharpExpr -> (FSharpMemberOrFunctionOrValue * FSharpExpr) option - val ( |Application|_| ): + val ( |Application|_| ) : FSharpExpr -> (FSharpExpr * FSharpType list * FSharpExpr list) option - val ( |IfThenElse|_| ): + val ( |IfThenElse|_| ) : FSharpExpr -> (FSharpExpr * FSharpExpr * FSharpExpr) option - val ( |Let|_| ): + val ( |Let|_| ) : FSharpExpr -> ((FSharpMemberOrFunctionOrValue * FSharpExpr) * FSharpExpr) option - val ( |LetRec|_| ): + val ( |LetRec|_| ) : FSharpExpr -> ((FSharpMemberOrFunctionOrValue * FSharpExpr) list * FSharpExpr) option - val ( |NewRecord|_| ): FSharpExpr -> (FSharpType * FSharpExpr list) option - val ( |NewAnonRecord|_| ): + val ( |NewRecord|_| ) : FSharpExpr -> (FSharpType * FSharpExpr list) option + val ( |NewAnonRecord|_| ) : FSharpExpr -> (FSharpType * FSharpExpr list) option - val ( |NewUnionCase|_| ): + val ( |NewUnionCase|_| ) : FSharpExpr -> (FSharpType * FSharpUnionCase * FSharpExpr list) option - val ( |NewTuple|_| ): FSharpExpr -> (FSharpType * FSharpExpr list) option - val ( |TupleGet|_| ): FSharpExpr -> (FSharpType * int * FSharpExpr) option - val ( |Call|_| ): + val ( |NewTuple|_| ) : FSharpExpr -> (FSharpType * FSharpExpr list) option + val ( |TupleGet|_| ) : FSharpExpr -> (FSharpType * int * FSharpExpr) option + val ( |Call|_| ) : FSharpExpr -> (FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * FSharpType list * FSharpExpr list) option - val ( |CallWithWitnesses|_| ): + val ( |CallWithWitnesses|_| ) : FSharpExpr -> (FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * FSharpType list * FSharpExpr list * FSharpExpr list) option - val ( |NewObject|_| ): + val ( |NewObject|_| ) : FSharpExpr -> (FSharpMemberOrFunctionOrValue * FSharpType list * FSharpExpr list) option - val ( |FSharpFieldGet|_| ): + val ( |FSharpFieldGet|_| ) : FSharpExpr -> (FSharpExpr option * FSharpType * FSharpField) option - val ( |AnonRecordGet|_| ): + val ( |AnonRecordGet|_| ) : FSharpExpr -> (FSharpExpr * FSharpType * int) option - val ( |FSharpFieldSet|_| ): + val ( |FSharpFieldSet|_| ) : FSharpExpr -> (FSharpExpr option * FSharpType * FSharpField * FSharpExpr) option - val ( |UnionCaseGet|_| ): + val ( |UnionCaseGet|_| ) : FSharpExpr -> (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField) option - val ( |UnionCaseTag|_| ): FSharpExpr -> (FSharpExpr * FSharpType) option - val ( |UnionCaseTest|_| ): + val ( |UnionCaseTag|_| ) : FSharpExpr -> (FSharpExpr * FSharpType) option + val ( |UnionCaseTest|_| ) : FSharpExpr -> (FSharpExpr * FSharpType * FSharpUnionCase) option - val ( |NewArray|_| ): FSharpExpr -> (FSharpType * FSharpExpr list) option - val ( |Coerce|_| ): FSharpExpr -> (FSharpType * FSharpExpr) option - val ( |Quote|_| ): FSharpExpr -> FSharpExpr option - val ( |TypeTest|_| ): FSharpExpr -> (FSharpType * FSharpExpr) option - val ( |Sequential|_| ): FSharpExpr -> (FSharpExpr * FSharpExpr) option - val ( |FastIntegerForLoop|_| ): + val ( |NewArray|_| ) : FSharpExpr -> (FSharpType * FSharpExpr list) option + val ( |Coerce|_| ) : FSharpExpr -> (FSharpType * FSharpExpr) option + val ( |Quote|_| ) : FSharpExpr -> FSharpExpr option + val ( |TypeTest|_| ) : FSharpExpr -> (FSharpType * FSharpExpr) option + val ( |Sequential|_| ) : FSharpExpr -> (FSharpExpr * FSharpExpr) option + val ( |FastIntegerForLoop|_| ) : FSharpExpr -> (FSharpExpr * FSharpExpr * FSharpExpr * bool) option - val ( |WhileLoop|_| ): FSharpExpr -> (FSharpExpr * FSharpExpr) option - val ( |TryFinally|_| ): FSharpExpr -> (FSharpExpr * FSharpExpr) option - val ( |TryWith|_| ): + val ( |WhileLoop|_| ) : FSharpExpr -> (FSharpExpr * FSharpExpr) option + val ( |TryFinally|_| ) : FSharpExpr -> (FSharpExpr * FSharpExpr) option + val ( |TryWith|_| ) : FSharpExpr -> (FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr) option - val ( |NewDelegate|_| ): FSharpExpr -> (FSharpType * FSharpExpr) option - val ( |DefaultValue|_| ): FSharpExpr -> FSharpType option - val ( |AddressSet|_| ): FSharpExpr -> (FSharpExpr * FSharpExpr) option - val ( |ValueSet|_| ): + val ( |NewDelegate|_| ) : FSharpExpr -> (FSharpType * FSharpExpr) option + val ( |DefaultValue|_| ) : FSharpExpr -> FSharpType option + val ( |AddressSet|_| ) : FSharpExpr -> (FSharpExpr * FSharpExpr) option + val ( |ValueSet|_| ) : FSharpExpr -> (FSharpMemberOrFunctionOrValue * FSharpExpr) option - val ( |AddressOf|_| ): FSharpExpr -> FSharpExpr option - val ( |ThisValue|_| ): FSharpExpr -> FSharpType option - val ( |BaseValue|_| ): FSharpExpr -> FSharpType option - val ( |ILAsm|_| ): + val ( |AddressOf|_| ) : FSharpExpr -> FSharpExpr option + val ( |ThisValue|_| ) : FSharpExpr -> FSharpType option + val ( |BaseValue|_| ) : FSharpExpr -> FSharpType option + val ( |ILAsm|_| ) : FSharpExpr -> (string * FSharpType list * FSharpExpr list) option - val ( |ILFieldGet|_| ): + val ( |ILFieldGet|_| ) : FSharpExpr -> (FSharpExpr option * FSharpType * string) option - val ( |ILFieldSet|_| ): + val ( |ILFieldSet|_| ) : FSharpExpr -> (FSharpExpr option * FSharpType * string * FSharpExpr) option - val ( |ObjectExpr|_| ): + val ( |ObjectExpr|_| ) : FSharpExpr -> (FSharpType * FSharpExpr * FSharpObjectExprOverride list * (FSharpType * FSharpObjectExprOverride list) list) option - val ( |DecisionTree|_| ): + val ( |DecisionTree|_| ) : FSharpExpr -> (FSharpExpr * (FSharpMemberOrFunctionOrValue list * FSharpExpr) list) option - val ( |DecisionTreeSuccess|_| ): + val ( |DecisionTreeSuccess|_| ) : FSharpExpr -> (int * FSharpExpr list) option - val ( |UnionCaseSet|_| ): + val ( |UnionCaseSet|_| ) : FSharpExpr -> (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField * FSharpExpr) option - val ( |TraitCall|_| ): + val ( |TraitCall|_| ) : FSharpExpr -> (FSharpType list * string * SyntaxTree.MemberFlags * FSharpType list * FSharpType list * FSharpExpr list) option - val ( |WitnessArg|_| ): FSharpExpr -> int option - + val ( |WitnessArg|_| ) : FSharpExpr -> int option + end namespace FSharp.Compiler.SourceCodeServices - module Symbol = - val isAttribute<'T>: FSharpAttribute -> bool - val tryGetAttribute<'T>: seq -> FSharpAttribute option - module Option = - val attempt: f:(unit -> 'a) -> 'a option - - val hasModuleSuffixAttribute: FSharpEntity -> bool - val isOperator: name:string -> bool - val UnnamedUnionFieldRegex: System.Text.RegularExpressions.Regex - val isUnnamedUnionCaseField: FSharpField -> bool - val ( |AbbreviatedType|_| ): FSharpEntity -> FSharpType option - val ( |TypeWithDefinition|_| ): FSharpType -> FSharpEntity option - val getEntityAbbreviatedType: + module Symbol = begin + val isAttribute<'T> : FSharpAttribute -> bool + val tryGetAttribute<'T> : seq -> FSharpAttribute option + module Option = begin + val attempt : f:(unit -> 'a) -> 'a option + end + val hasModuleSuffixAttribute : FSharpEntity -> bool + val isOperator : name:string -> bool + val UnnamedUnionFieldRegex : System.Text.RegularExpressions.Regex + val isUnnamedUnionCaseField : FSharpField -> bool + val ( |AbbreviatedType|_| ) : FSharpEntity -> FSharpType option + val ( |TypeWithDefinition|_| ) : FSharpType -> FSharpEntity option + val getEntityAbbreviatedType : FSharpEntity -> FSharpEntity * FSharpType option - val getAbbreviatedType: FSharpType -> FSharpType - val ( |Attribute|_| ): FSharpEntity -> unit option - val hasAttribute<'T>: seq -> bool - val ( |ValueType|_| ): FSharpEntity -> unit option - val ( |Class|_| ): + val getAbbreviatedType : FSharpType -> FSharpType + val ( |Attribute|_| ) : FSharpEntity -> unit option + val hasAttribute<'T> : seq -> bool + val ( |ValueType|_| ) : FSharpEntity -> unit option + val ( |Class|_| ) : original:FSharpEntity * abbreviated:FSharpEntity * 'a -> unit option - val ( |Record|_| ): FSharpEntity -> unit option - val ( |UnionType|_| ): FSharpEntity -> unit option - val ( |Delegate|_| ): FSharpEntity -> unit option - val ( |FSharpException|_| ): FSharpEntity -> unit option - val ( |Interface|_| ): FSharpEntity -> unit option - val ( |AbstractClass|_| ): FSharpEntity -> unit option - val ( |FSharpType|_| ): FSharpEntity -> unit option - val ( |ProvidedType|_| ): FSharpEntity -> unit option - val ( |ByRef|_| ): FSharpEntity -> unit option - val ( |Array|_| ): FSharpEntity -> unit option - val ( |FSharpModule|_| ): FSharpEntity -> unit option - val ( |Namespace|_| ): FSharpEntity -> unit option - val ( |ProvidedAndErasedType|_| ): FSharpEntity -> unit option - val ( |Enum|_| ): FSharpEntity -> unit option - val ( |Tuple|_| ): FSharpType -> unit option - val ( |RefCell|_| ): FSharpType -> unit option - val ( |FunctionType|_| ): FSharpType -> unit option - val ( |Pattern|_| ): FSharpSymbol -> unit option - val ( |Field|_| ): FSharpSymbol -> (FSharpField * FSharpType) option - val ( |MutableVar|_| ): FSharpSymbol -> unit option - val ( |FSharpEntity|_| ): + val ( |Record|_| ) : FSharpEntity -> unit option + val ( |UnionType|_| ) : FSharpEntity -> unit option + val ( |Delegate|_| ) : FSharpEntity -> unit option + val ( |FSharpException|_| ) : FSharpEntity -> unit option + val ( |Interface|_| ) : FSharpEntity -> unit option + val ( |AbstractClass|_| ) : FSharpEntity -> unit option + val ( |FSharpType|_| ) : FSharpEntity -> unit option + val ( |ProvidedType|_| ) : FSharpEntity -> unit option + val ( |ByRef|_| ) : FSharpEntity -> unit option + val ( |Array|_| ) : FSharpEntity -> unit option + val ( |FSharpModule|_| ) : FSharpEntity -> unit option + val ( |Namespace|_| ) : FSharpEntity -> unit option + val ( |ProvidedAndErasedType|_| ) : FSharpEntity -> unit option + val ( |Enum|_| ) : FSharpEntity -> unit option + val ( |Tuple|_| ) : FSharpType -> unit option + val ( |RefCell|_| ) : FSharpType -> unit option + val ( |FunctionType|_| ) : FSharpType -> unit option + val ( |Pattern|_| ) : FSharpSymbol -> unit option + val ( |Field|_| ) : FSharpSymbol -> (FSharpField * FSharpType) option + val ( |MutableVar|_| ) : FSharpSymbol -> unit option + val ( |FSharpEntity|_| ) : FSharpSymbol -> (FSharpEntity * FSharpEntity * FSharpType option) option - val ( |Parameter|_| ): FSharpSymbol -> unit option - val ( |UnionCase|_| ): FSharpSymbol -> FSharpUnionCase option - val ( |RecordField|_| ): FSharpSymbol -> FSharpField option - val ( |ActivePatternCase|_| ): + val ( |Parameter|_| ) : FSharpSymbol -> unit option + val ( |UnionCase|_| ) : FSharpSymbol -> FSharpUnionCase option + val ( |RecordField|_| ) : FSharpSymbol -> FSharpField option + val ( |ActivePatternCase|_| ) : FSharpSymbol -> FSharpActivePatternCase option - val ( |MemberFunctionOrValue|_| ): + val ( |MemberFunctionOrValue|_| ) : FSharpSymbol -> FSharpMemberOrFunctionOrValue option - val ( |Constructor|_| ): + val ( |Constructor|_| ) : FSharpMemberOrFunctionOrValue -> FSharpEntity option - val ( |Function|_| ): + val ( |Function|_| ) : excluded:bool -> FSharpMemberOrFunctionOrValue -> unit option - val ( |ExtensionMember|_| ): FSharpMemberOrFunctionOrValue -> unit option - val ( |Event|_| ): FSharpMemberOrFunctionOrValue -> unit option - + val ( |ExtensionMember|_| ) : FSharpMemberOrFunctionOrValue -> unit option + val ( |Event|_| ) : FSharpMemberOrFunctionOrValue -> unit option + end namespace FSharp.Compiler.SourceCodeServices type internal IReactorOperations = interface abstract member - EnqueueAndAwaitOpAsync: userOpName:string * opName:string * + EnqueueAndAwaitOpAsync : userOpName:string * opName:string * opArg:string * action:(AbstractIL.Internal.Library.CompilationThreadToken -> AbstractIL.Internal.Library.Cancellable<'T>) -> Async<'T> abstract member - EnqueueOp: userOpName:string * opName:string * opArg:string * + EnqueueOp : userOpName:string * opName:string * opArg:string * action:(AbstractIL.Internal.Library.CompilationThreadToken -> unit) -> unit - - [] + end + [] type internal ReactorCommands = | SetBackgroundOp of (string * string * string * @@ -16559,41 +41626,41 @@ namespace FSharp.Compiler.SourceCodeServices (unit -> unit) | WaitForBackgroundOpCompletion of AsyncReplyChannel | CompleteAllQueuedOps of AsyncReplyChannel - [] + [] type Reactor = - - new: unit -> Reactor - member CancelBackgroundOp: unit -> unit - member CompleteAllQueuedOps: unit -> unit + class + new : unit -> Reactor + member CancelBackgroundOp : unit -> unit + member CompleteAllQueuedOps : unit -> unit member - EnqueueAndAwaitOpAsync: userOpName:string * opName:string * + EnqueueAndAwaitOpAsync : userOpName:string * opName:string * opArg:string * (AbstractIL.Internal.Library.CompilationThreadToken -> AbstractIL.Internal.Library.Cancellable<'T>) -> Async<'T> member - EnqueueOp: userOpName:string * opName:string * opArg:string * + EnqueueOp : userOpName:string * opName:string * opArg:string * op:(AbstractIL.Internal.Library.CompilationThreadToken -> unit) -> unit member - EnqueueOpPrim: userOpName:string * opName:string * opArg:string * + EnqueueOpPrim : userOpName:string * opName:string * opArg:string * ct:System.Threading.CancellationToken * op:(AbstractIL.Internal.Library.CompilationThreadToken -> unit) * ccont:(unit -> unit) -> unit member - SetBackgroundOp: (string * string * string * + SetBackgroundOp : (string * string * string * (AbstractIL.Internal.Library.CompilationThreadToken -> System.Threading.CancellationToken -> bool)) option -> unit - member SetPreferredUILang: string option -> unit - member WaitForBackgroundOpCompletion: unit -> unit - member CurrentQueueLength: int - member PauseBeforeBackgroundWork: int - static member Singleton: Reactor - + member SetPreferredUILang : string option -> unit + member WaitForBackgroundOpCompletion : unit -> unit + member CurrentQueueLength : int + member PauseBeforeBackgroundWork : int + static member Singleton : Reactor + end namespace FSharp.Compiler.SourceCodeServices - [] + [] type SemanticClassificationType = | ReferenceType | ValueType @@ -16632,134 +41699,134 @@ namespace FSharp.Compiler.SourceCodeServices | Type | TypeDef | Plaintext - module TcResolutionsExtensions = - val ( |CNR| ): + module TcResolutionsExtensions = begin + val ( |CNR| ) : cnr:NameResolution.CapturedNameResolution -> NameResolution.Item * NameResolution.ItemOccurence * TypedTreeOps.DisplayEnv * NameResolution.NameResolutionEnv * AccessibilityLogic.AccessorDomain * Range.range type internal TcResolutions with member - GetSemanticClassification: g:TcGlobals.TcGlobals * + GetSemanticClassification : g:TcGlobals.TcGlobals * amap:Import.ImportMap * formatSpecifierLocations:(Range.range * int) [] * range:Range.range option -> - + struct (Range.range * SemanticClassificationType) [] - + end namespace FSharp.Compiler.SourceCodeServices - module ItemKeyTags = - [] - val entityRef: string = "#E#" - [] - val typeTuple: string = "#T#" - [] - val typeAnonymousRecord: string = "#N#" - [] - val typeFunction: string = "#F#" - [] - val typeMeasure: string = "#M#" - [] - val typeUnionCase: string = "#U#" - [] - val typeMeasureVar: string = "#p#" - [] - val typeMeasureCon: string = "#c#" - [] - val itemValueMember: string = "m$" - [] - val itemValue: string = "v$" - [] - val itemUnionCase: string = "u$" - [] - val itemActivePattern: string = "r$" - [] - val itemExnCase: string = "e$" - [] - val itemRecordField: string = "d$" - [] - val itemAnonymousRecordField: string = "a$" - [] - val itemNewDef: string = "n$" - [] - val itemILField: string = "l$" - [] - val itemEvent: string = "t$" - [] - val itemProperty: string = "p$" - [] - val itemTypeVar: string = "y$" - [] - val itemModuleOrNamespace: string = "o$" - [] - val itemDelegateCtor: string = "g$" - [] - val parameters: string = "p$p$" - - [] + module ItemKeyTags = begin + [] + val entityRef : string = "#E#" + [] + val typeTuple : string = "#T#" + [] + val typeAnonymousRecord : string = "#N#" + [] + val typeFunction : string = "#F#" + [] + val typeMeasure : string = "#M#" + [] + val typeUnionCase : string = "#U#" + [] + val typeMeasureVar : string = "#p#" + [] + val typeMeasureCon : string = "#c#" + [] + val itemValueMember : string = "m$" + [] + val itemValue : string = "v$" + [] + val itemUnionCase : string = "u$" + [] + val itemActivePattern : string = "r$" + [] + val itemExnCase : string = "e$" + [] + val itemRecordField : string = "d$" + [] + val itemAnonymousRecordField : string = "a$" + [] + val itemNewDef : string = "n$" + [] + val itemILField : string = "l$" + [] + val itemEvent : string = "t$" + [] + val itemProperty : string = "p$" + [] + val itemTypeVar : string = "y$" + [] + val itemModuleOrNamespace : string = "o$" + [] + val itemDelegateCtor : string = "g$" + [] + val parameters : string = "p$p$" + end + [] type ItemKeyStore = - + class interface System.IDisposable - new: mmf:System.IO.MemoryMappedFiles.MemoryMappedFile * length:int64 -> + new : mmf:System.IO.MemoryMappedFiles.MemoryMappedFile * length:int64 -> ItemKeyStore - member FindAll: NameResolution.Item -> seq - member ReadFirstKeyString: unit -> System.ReadOnlySpan + member FindAll : NameResolution.Item -> seq + member ReadFirstKeyString : unit -> System.ReadOnlySpan member - ReadKeyString: reader:byref -> + ReadKeyString : reader:byref -> System.ReadOnlySpan member - ReadRange: reader:byref -> + ReadRange : reader:byref -> Range.range - - [] + end + [] and ItemKeyStoreBuilder = - - new: unit -> ItemKeyStoreBuilder - member TryBuildAndReset: unit -> ItemKeyStore option - member Write: Range.range * NameResolution.Item -> unit - + class + new : unit -> ItemKeyStoreBuilder + member TryBuildAndReset : unit -> ItemKeyStore option + member Write : Range.range * NameResolution.Item -> unit + end namespace FSharp.Compiler - module internal IncrementalBuild = - val mutable injectCancellationFault: bool - val LocallyInjectCancellationFault: unit -> System.IDisposable - - module IncrementalBuilderEventTesting = + module internal IncrementalBuild = begin + val mutable injectCancellationFault : bool + val LocallyInjectCancellationFault : unit -> System.IDisposable + end + module IncrementalBuilderEventTesting = begin type internal FixedLengthMRU<'T> = - - new: unit -> FixedLengthMRU<'T> - member Add: filename:'T -> unit - member MostRecentList: n:int -> 'T list - member CurrentEventNum: int - + class + new : unit -> FixedLengthMRU<'T> + member Add : filename:'T -> unit + member MostRecentList : n:int -> 'T list + member CurrentEventNum : int + end type IBEvent = | IBEParsed of string | IBETypechecked of string | IBECreated - val MRU: FixedLengthMRU - val GetMostRecentIncrementalBuildEvents: int -> IBEvent list - val GetCurrentIncrementalBuildEventNum: unit -> int - - module IncrementalBuildSyntaxTree = - [] + val MRU : FixedLengthMRU + val GetMostRecentIncrementalBuildEvents : int -> IBEvent list + val GetCurrentIncrementalBuildEventNum : unit -> int + end + module IncrementalBuildSyntaxTree = begin + [] type SyntaxTree = - - new: tcConfig:CompilerConfig.TcConfig * fileParsed:Event * + class + new : tcConfig:CompilerConfig.TcConfig * fileParsed:Event * lexResourceManager:Lexhelp.LexResourceManager * sourceRange:Range.range * filename:string * isLastCompiland:(bool * bool) -> SyntaxTree - member Invalidate: unit -> unit + member Invalidate : unit -> unit member - Parse: sigNameOpt:SyntaxTree.QualifiedNameOfFile option -> + Parse : sigNameOpt:SyntaxTree.QualifiedNameOfFile option -> SyntaxTree.ParsedInput option * Range.range * string * (ErrorLogger.PhasedDiagnostic * SourceCodeServices.FSharpErrorSeverity) [] - member FileName: string - - - [] + member FileName : string + end + end + [] type TcInfo = { tcState: ParseAndCheckInputs.TcState tcEnvAtEndOfFile: CheckExpressions.TcEnv @@ -16772,10 +41839,10 @@ namespace FSharp.Compiler sigNameOpt: (string * SyntaxTree.QualifiedNameOfFile) option } with member - TcErrors: (ErrorLogger.PhasedDiagnostic * + TcErrors : (ErrorLogger.PhasedDiagnostic * SourceCodeServices.FSharpErrorSeverity) [] - - [] + end + [] type TcInfoOptional = { tcResolutionsRev: NameResolution.TcResolutions list tcSymbolUsesRev: NameResolution.TcSymbolUses list @@ -16783,21 +41850,21 @@ namespace FSharp.Compiler latestImplFile: TypedTree.TypedImplFile option itemKeyStore: SourceCodeServices.ItemKeyStore option semanticClassification: - (Range.range * SourceCodeServices.SemanticClassificationType) [] } + struct (Range.range * SourceCodeServices.SemanticClassificationType) [] } with - member TcSymbolUses: NameResolution.TcSymbolUses list - - [] + member TcSymbolUses : NameResolution.TcSymbolUses list + end + [] type TcInfoState = | PartialState of TcInfo | FullState of TcInfo * TcInfoOptional with - member Partial: TcInfo - - [] + member Partial : TcInfo + end + [] type SemanticModel = - - private new: tcConfig:CompilerConfig.TcConfig * + class + private new : tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * tcImports:CompilerImports.TcImports * keepAssemblyContents:bool * @@ -16812,7 +41879,7 @@ namespace FSharp.Compiler syntaxTreeOpt:IncrementalBuildSyntaxTree.SyntaxTree option * lazyTcInfoState:TcInfoState option ref -> SemanticModel static member - Create: tcConfig:CompilerConfig.TcConfig * + Create : tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * tcImports:CompilerImports.TcImports * keepAssemblyContents:bool * keepAllBackgroundResolutions:bool * @@ -16826,90 +41893,90 @@ namespace FSharp.Compiler syntaxTreeOpt:IncrementalBuildSyntaxTree.SyntaxTree option -> SemanticModel member - Finish: finalTcErrorsRev:(ErrorLogger.PhasedDiagnostic * + Finish : finalTcErrorsRev:(ErrorLogger.PhasedDiagnostic * SourceCodeServices.FSharpErrorSeverity) [] list * finalTopAttribs:CheckDeclarations.TopAttribs option -> AbstractIL.Internal.Library.Eventually member - GetState: partialCheck:bool -> + GetState : partialCheck:bool -> AbstractIL.Internal.Library.Eventually - member Invalidate: unit -> unit + member Invalidate : unit -> unit member - Next: syntaxTree:IncrementalBuildSyntaxTree.SyntaxTree -> + Next : syntaxTree:IncrementalBuildSyntaxTree.SyntaxTree -> AbstractIL.Internal.Library.Eventually member - private TypeCheck: partialCheck:bool -> + private TypeCheck : partialCheck:bool -> AbstractIL.Internal.Library.Eventually - member BackingSignature: SyntaxTree.QualifiedNameOfFile option - member TcConfig: CompilerConfig.TcConfig - member TcGlobals: TcGlobals.TcGlobals - member TcImports: CompilerImports.TcImports - member TcInfo: AbstractIL.Internal.Library.Eventually + member BackingSignature : SyntaxTree.QualifiedNameOfFile option + member TcConfig : CompilerConfig.TcConfig + member TcGlobals : TcGlobals.TcGlobals + member TcImports : CompilerImports.TcImports + member TcInfo : AbstractIL.Internal.Library.Eventually member - TcInfoWithOptional: AbstractIL.Internal.Library.Eventually - + end type FrameworkImportsCacheKey = string list * string * string list * string * decimal type FrameworkImportsCache = - - new: size:int -> FrameworkImportsCache - member Clear: AbstractIL.Internal.Library.CompilationThreadToken -> unit + class + new : size:int -> FrameworkImportsCache + member Clear : AbstractIL.Internal.Library.CompilationThreadToken -> unit member - Downsize: AbstractIL.Internal.Library.CompilationThreadToken -> unit + Downsize : AbstractIL.Internal.Library.CompilationThreadToken -> unit member - Get: AbstractIL.Internal.Library.CompilationThreadToken * + Get : AbstractIL.Internal.Library.CompilationThreadToken * CompilerConfig.TcConfig -> AbstractIL.Internal.Library.Cancellable - - [] + end + [] type PartialCheckResults = - - private new: semanticModel:SemanticModel * timeStamp:System.DateTime -> + class + private new : semanticModel:SemanticModel * timeStamp:System.DateTime -> PartialCheckResults static member - Create: semanticModel:SemanticModel * timestamp:System.DateTime -> + Create : semanticModel:SemanticModel * timestamp:System.DateTime -> PartialCheckResults member - GetSemanticClassification: AbstractIL.Internal.Library.CompilationThreadToken -> - + GetSemanticClassification : AbstractIL.Internal.Library.CompilationThreadToken -> + struct (Range.range * SourceCodeServices.SemanticClassificationType) [] member - TcInfo: AbstractIL.Internal.Library.CompilationThreadToken -> TcInfo + TcInfo : AbstractIL.Internal.Library.CompilationThreadToken -> TcInfo member - TcInfoWithOptional: AbstractIL.Internal.Library.CompilationThreadToken -> + TcInfoWithOptional : AbstractIL.Internal.Library.CompilationThreadToken -> TcInfo * TcInfoOptional member - TryGetItemKeyStore: AbstractIL.Internal.Library.CompilationThreadToken -> + TryGetItemKeyStore : AbstractIL.Internal.Library.CompilationThreadToken -> SourceCodeServices.ItemKeyStore option - member TcConfig: CompilerConfig.TcConfig - member TcGlobals: TcGlobals.TcGlobals - member TcImports: CompilerImports.TcImports - member TimeStamp: System.DateTime - - module Utilities = - val TryFindFSharpStringAttribute: + member TcConfig : CompilerConfig.TcConfig + member TcGlobals : TcGlobals.TcGlobals + member TcImports : CompilerImports.TcImports + member TimeStamp : System.DateTime + end + module Utilities = begin + val TryFindFSharpStringAttribute : tcGlobals:TcGlobals.TcGlobals -> attribSpec:TcGlobals.BuiltinAttribInfo -> attribs:TypedTree.Attribs -> string option - + end type RawFSharpAssemblyDataBackedByLanguageService = - + class interface CompilerConfig.IRawFSharpAssemblyData - new: tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * + new : tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * tcState:ParseAndCheckInputs.TcState * outfile:string * topAttrs:CheckDeclarations.TopAttribs * assemblyName:string * ilAssemRef:AbstractIL.IL.ILAssemblyRef -> RawFSharpAssemblyDataBackedByLanguageService - - [] + end + [] type IncrementalBuilder = - - new: tcGlobals:TcGlobals.TcGlobals * + class + new : tcGlobals:TcGlobals.TcGlobals * frameworkTcImports:CompilerImports.TcImports * nonFrameworkAssemblyInputs:(Choice * @@ -16931,7 +41998,7 @@ namespace FSharp.Compiler dependencyProviderOpt:Microsoft.DotNet.DependencyManager.DependencyProvider option -> IncrementalBuilder static member - TryCreateIncrementalBuilderForProjectOptions: AbstractIL.Internal.Library.CompilationThreadToken * + TryCreateIncrementalBuilderForProjectOptions : AbstractIL.Internal.Library.CompilationThreadToken * ReferenceResolver.Resolver * defaultFSharpBinariesDir:string * FrameworkImportsCache * @@ -16952,73 +42019,81 @@ namespace FSharp.Compiler dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider option -> AbstractIL.Internal.Library.Cancellable - member AreCheckResultsBeforeFileInProjectReady: filename:string -> bool - member ContainsFile: filename:string -> bool + member AreCheckResultsBeforeFileInProjectReady : filename:string -> bool + member ContainsFile : filename:string -> bool member - GetCheckResultsAfterFileInProject: AbstractIL.Internal.Library.CompilationThreadToken * + GetCheckResultsAfterFileInProject : AbstractIL.Internal.Library.CompilationThreadToken * filename:string -> AbstractIL.Internal.Library.Cancellable member - GetCheckResultsAfterLastFileInProject: AbstractIL.Internal.Library.CompilationThreadToken -> + GetCheckResultsAfterLastFileInProject : AbstractIL.Internal.Library.CompilationThreadToken -> AbstractIL.Internal.Library.Cancellable member - GetCheckResultsAndImplementationsForProject: AbstractIL.Internal.Library.CompilationThreadToken -> + GetCheckResultsAndImplementationsForProject : AbstractIL.Internal.Library.CompilationThreadToken -> AbstractIL.Internal.Library.Cancellable member - GetCheckResultsBeforeFileInProject: AbstractIL.Internal.Library.CompilationThreadToken * + GetCheckResultsBeforeFileInProject : AbstractIL.Internal.Library.CompilationThreadToken * filename:string -> AbstractIL.Internal.Library.Cancellable member - GetCheckResultsBeforeFileInProjectEvenIfStale: filename:string -> + GetCheckResultsBeforeFileInProjectEvenIfStale : filename:string -> PartialCheckResults option member - GetCheckResultsBeforeSlotInProject: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + GetCheckResultsBeforeSlotInProject : ctok:AbstractIL.Internal.Library.CompilationThreadToken * slotOfFile:int -> AbstractIL.Internal.Library.Cancellable member - GetFullCheckResultsAfterFileInProject: AbstractIL.Internal.Library.CompilationThreadToken * + GetFullCheckResultsAfterFileInProject : AbstractIL.Internal.Library.CompilationThreadToken * filename:string -> AbstractIL.Internal.Library.Cancellable member - GetFullCheckResultsAndImplementationsForProject: AbstractIL.Internal.Library.CompilationThreadToken -> + GetFullCheckResultsAndImplementationsForProject : AbstractIL.Internal.Library.CompilationThreadToken -> AbstractIL.Internal.Library.Cancellable member - GetLogicalTimeStampForProject: CompilerConfig.TimeStampCache * + GetLogicalTimeStampForProject : CompilerConfig.TimeStampCache * AbstractIL.Internal.Library.CompilationThreadToken -> System.DateTime member - GetParseResultsForFile: AbstractIL.Internal.Library.CompilationThreadToken * + GetParseResultsForFile : AbstractIL.Internal.Library.CompilationThreadToken * filename:string -> AbstractIL.Internal.Library.Cancellable - member GetSlotOfFileName: filename:string -> int - member GetSlotsCount: unit -> int + member GetSlotOfFileName : filename:string -> int + member GetSlotsCount : unit -> int member - Step: AbstractIL.Internal.Library.CompilationThreadToken -> + Step : AbstractIL.Internal.Library.CompilationThreadToken -> AbstractIL.Internal.Library.Cancellable - member TryGetCurrentTcImports: unit -> CompilerImports.TcImports option - member TryGetSlotOfFileName: filename:string -> int option - member AllDependenciesDeprecated: string [] - member BeforeFileChecked: IEvent - member FileChecked: IEvent - member FileParsed: IEvent - member ImportsInvalidatedByTypeProvider: IEvent - member ProjectChecked: IEvent - member SourceFiles: string list - member TcConfig: CompilerConfig.TcConfig - + member TryGetCurrentTcImports : unit -> CompilerImports.TcImports option + member TryGetSlotOfFileName : filename:string -> int option + member AllDependenciesDeprecated : string [] + member BeforeFileChecked : IEvent + member FileChecked : IEvent + member FileParsed : IEvent + member ImportsInvalidatedByTypeProvider : IEvent + member ProjectChecked : IEvent + member SourceFiles : string list + member TcConfig : CompilerConfig.TcConfig + end + +namespace FSharp.Compiler.SourceCodeServices + type DiagnosticKind = + | AddIndexerDot + | ReplaceWithSuggestion of suggestion: string + module CompilerDiagnostics = begin + val getErrorMessage : diagnosticKind:DiagnosticKind -> string + end namespace FSharp.Compiler.SourceCodeServices - [] + [] type FSharpGlyph = | Class | Constant @@ -17043,37 +42118,37 @@ namespace FSharp.Compiler.SourceCodeServices | Error namespace FSharp.Compiler.SourceCodeServices - [] + [] type FSharpMethodGroupItemParameter = - - new: name:string * canonicalTypeTextForSorting:string * + class + new : name:string * canonicalTypeTextForSorting:string * display:Layout.layout * isOptional:bool -> FSharpMethodGroupItemParameter - member CanonicalTypeTextForSorting: string - member Display: string - member IsOptional: bool - member ParameterName: string - member StructuredDisplay: Layout.layout - - module internal DescriptionListsImpl = - val isFunction: g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val printCanonicalizedTypeName: + member CanonicalTypeTextForSorting : string + member Display : string + member IsOptional : bool + member ParameterName : string + member StructuredDisplay : Layout.layout + end + module internal DescriptionListsImpl = begin + val isFunction : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool + val printCanonicalizedTypeName : g:TcGlobals.TcGlobals -> denv:TypedTreeOps.DisplayEnv -> tau:TypedTree.TType -> string - val PrettyParamOfRecdField: + val PrettyParamOfRecdField : g:TcGlobals.TcGlobals -> denv:TypedTreeOps.DisplayEnv -> f:TypedTree.RecdField -> FSharpMethodGroupItemParameter - val PrettyParamOfUnionCaseField: + val PrettyParamOfUnionCaseField : g:TcGlobals.TcGlobals -> denv:TypedTreeOps.DisplayEnv -> isGenerated:(int -> TypedTree.RecdField -> bool) -> i:int -> f:TypedTree.RecdField -> FSharpMethodGroupItemParameter - val ParamOfParamData: + val ParamOfParamData : g:TcGlobals.TcGlobals -> denv:TypedTreeOps.DisplayEnv -> Infos.ParamData -> FSharpMethodGroupItemParameter - val PrettyParamsOfParamDatas: + val PrettyParamsOfParamDatas : g:TcGlobals.TcGlobals -> denv:TypedTreeOps.DisplayEnv -> typarInst:TypedTreeOps.TyparInst -> @@ -17082,7 +42157,7 @@ namespace FSharp.Compiler.SourceCodeServices TypedTreeOps.TyparInst * FSharpMethodGroupItemParameter list * Internal.Utilities.StructuredFormat.Layout * Internal.Utilities.StructuredFormat.Layout - val PrettyParamsOfTypes: + val PrettyParamsOfTypes : g:TcGlobals.TcGlobals -> denv:TypedTreeOps.DisplayEnv -> typarInst:TypedTreeOps.TyparInst -> @@ -17091,28 +42166,28 @@ namespace FSharp.Compiler.SourceCodeServices TypedTreeOps.TyparInst * FSharpMethodGroupItemParameter list * Internal.Utilities.StructuredFormat.Layout * Internal.Utilities.StructuredFormat.Layout - val StaticParamsOfItem: + val StaticParamsOfItem : infoReader:InfoReader.InfoReader -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> item:NameResolution.Item -> FSharpMethodGroupItemParameter [] - val PrettyParamsAndReturnTypeOfItem: + val PrettyParamsAndReturnTypeOfItem : infoReader:InfoReader.InfoReader -> m:Range.range -> denv:TypedTreeOps.DisplayEnv -> item:NameResolution.ItemWithInst -> FSharpMethodGroupItemParameter list * Internal.Utilities.StructuredFormat.Layout - val GlyphOfItem: + val GlyphOfItem : denv:TypedTreeOps.DisplayEnv * item:NameResolution.Item -> FSharpGlyph - val AnotherFlattenItems: + val AnotherFlattenItems : g:TcGlobals.TcGlobals -> m:Range.range -> item:NameResolution.Item -> NameResolution.Item list - - [] + end + [] type FSharpDeclarationListItem = - - new: name:string * nameInCode:string * fullName:string * + class + new : name:string * nameInCode:string * fullName:string * glyph:FSharpGlyph * info:Choice<(CompletionItem list * InfoReader.InfoReader * Range.range * TypedTreeOps.DisplayEnv), @@ -17120,142 +42195,142 @@ namespace FSharp.Compiler.SourceCodeServices accessibility:FSharpAccessibility option * kind:CompletionItemKind * isOwnMember:bool * priority:int * isResolved:bool * namespaceToOpen:string option -> FSharpDeclarationListItem - member Accessibility: FSharpAccessibility option - member DescriptionText: FSharpToolTipText + member Accessibility : FSharpAccessibility option + member DescriptionText : FSharpToolTipText [] - member DescriptionTextAsync: Async - member FullName: string - member Glyph: FSharpGlyph - member IsOwnMember: bool - member IsResolved: bool - member Kind: CompletionItemKind - member MinorPriority: int - member Name: string - member NameInCode: string - member NamespaceToOpen: string option - member StructuredDescriptionText: FSharpToolTipText + member DescriptionTextAsync : Async + member FullName : string + member Glyph : FSharpGlyph + member IsOwnMember : bool + member IsResolved : bool + member Kind : CompletionItemKind + member MinorPriority : int + member Name : string + member NameInCode : string + member NamespaceToOpen : string option + member StructuredDescriptionText : FSharpToolTipText [] - member StructuredDescriptionTextAsync: Async> - - [] + member StructuredDescriptionTextAsync : Async> + end + [] type FSharpDeclarationListInfo = - - new: declarations:FSharpDeclarationListItem [] * isForType:bool * + class + new : declarations:FSharpDeclarationListItem [] * isForType:bool * isError:bool -> FSharpDeclarationListInfo static member - Create: infoReader:InfoReader.InfoReader * m:Range.range * + Create : infoReader:InfoReader.InfoReader * m:Range.range * denv:TypedTreeOps.DisplayEnv * getAccessibility:(NameResolution.Item -> FSharpAccessibility option) * items:CompletionItem list * currentNamespace:string [] option * isAttributeApplicationContext:bool -> FSharpDeclarationListInfo - static member Error: message:string -> FSharpDeclarationListInfo - member IsError: bool - member IsForType: bool - member Items: FSharpDeclarationListItem [] - static member Empty: FSharpDeclarationListInfo - - [] + static member Error : message:string -> FSharpDeclarationListInfo + member IsError : bool + member IsForType : bool + member Items : FSharpDeclarationListItem [] + static member Empty : FSharpDeclarationListInfo + end + [] type FSharpMethodGroupItem = - - new: description:FSharpToolTipText * xmlDoc:FSharpXmlDoc * + class + new : description:FSharpToolTipText * xmlDoc:FSharpXmlDoc * returnType:Layout.layout * parameters:FSharpMethodGroupItemParameter [] * hasParameters:bool * hasParamArrayArg:bool * staticParameters:FSharpMethodGroupItemParameter [] -> FSharpMethodGroupItem - member Description: FSharpToolTipText - member HasParamArrayArg: bool - member HasParameters: bool - member Parameters: FSharpMethodGroupItemParameter [] - member ReturnTypeText: string - member StaticParameters: FSharpMethodGroupItemParameter [] - member StructuredDescription: FSharpToolTipText - member StructuredReturnTypeText: Layout.layout - member XmlDoc: FSharpXmlDoc - - [] + member Description : FSharpToolTipText + member HasParamArrayArg : bool + member HasParameters : bool + member Parameters : FSharpMethodGroupItemParameter [] + member ReturnTypeText : string + member StaticParameters : FSharpMethodGroupItemParameter [] + member StructuredDescription : FSharpToolTipText + member StructuredReturnTypeText : Layout.layout + member XmlDoc : FSharpXmlDoc + end + [] type FSharpMethodGroup = - - new: string * FSharpMethodGroupItem [] -> FSharpMethodGroup + class + new : string * FSharpMethodGroupItem [] -> FSharpMethodGroup static member - Create: InfoReader.InfoReader * Range.range * TypedTreeOps.DisplayEnv * + Create : InfoReader.InfoReader * Range.range * TypedTreeOps.DisplayEnv * NameResolution.ItemWithInst list -> FSharpMethodGroup - member MethodName: string - member Methods: FSharpMethodGroupItem [] - + member MethodName : string + member Methods : FSharpMethodGroupItem [] + end namespace FSharp.Compiler.SourceCodeServices type Position = int * int type Range = Position * Position - module FSharpTokenTag = - val Identifier: int - val String: int - val IDENT: int - val STRING: int - val INTERP_STRING_BEGIN_END: int - val INTERP_STRING_BEGIN_PART: int - val INTERP_STRING_PART: int - val INTERP_STRING_END: int - val LPAREN: int - val RPAREN: int - val LBRACK: int - val RBRACK: int - val LBRACE: int - val RBRACE: int - val LBRACK_LESS: int - val GREATER_RBRACK: int - val LESS: int - val GREATER: int - val LBRACK_BAR: int - val BAR_RBRACK: int - val PLUS_MINUS_OP: int - val MINUS: int - val STAR: int - val INFIX_STAR_DIV_MOD_OP: int - val PERCENT_OP: int - val INFIX_AT_HAT_OP: int - val QMARK: int - val COLON: int - val EQUALS: int - val SEMICOLON: int - val COMMA: int - val DOT: int - val DOT_DOT: int - val DOT_DOT_HAT: int - val INT32_DOT_DOT: int - val UNDERSCORE: int - val BAR: int - val COLON_GREATER: int - val COLON_QMARK_GREATER: int - val COLON_QMARK: int - val INFIX_BAR_OP: int - val INFIX_COMPARE_OP: int - val COLON_COLON: int - val AMP_AMP: int - val PREFIX_OP: int - val COLON_EQUALS: int - val BAR_BAR: int - val RARROW: int - val LARROW: int - val QUOTE: int - val WHITESPACE: int - val COMMENT: int - val LINE_COMMENT: int - val BEGIN: int - val DO: int - val FUNCTION: int - val THEN: int - val ELSE: int - val STRUCT: int - val CLASS: int - val TRY: int - val NEW: int - val WITH: int - val OWITH: int - + module FSharpTokenTag = begin + val Identifier : int + val String : int + val IDENT : int + val STRING : int + val INTERP_STRING_BEGIN_END : int + val INTERP_STRING_BEGIN_PART : int + val INTERP_STRING_PART : int + val INTERP_STRING_END : int + val LPAREN : int + val RPAREN : int + val LBRACK : int + val RBRACK : int + val LBRACE : int + val RBRACE : int + val LBRACK_LESS : int + val GREATER_RBRACK : int + val LESS : int + val GREATER : int + val LBRACK_BAR : int + val BAR_RBRACK : int + val PLUS_MINUS_OP : int + val MINUS : int + val STAR : int + val INFIX_STAR_DIV_MOD_OP : int + val PERCENT_OP : int + val INFIX_AT_HAT_OP : int + val QMARK : int + val COLON : int + val EQUALS : int + val SEMICOLON : int + val COMMA : int + val DOT : int + val DOT_DOT : int + val DOT_DOT_HAT : int + val INT32_DOT_DOT : int + val UNDERSCORE : int + val BAR : int + val COLON_GREATER : int + val COLON_QMARK_GREATER : int + val COLON_QMARK : int + val INFIX_BAR_OP : int + val INFIX_COMPARE_OP : int + val COLON_COLON : int + val AMP_AMP : int + val PREFIX_OP : int + val COLON_EQUALS : int + val BAR_BAR : int + val RARROW : int + val LARROW : int + val QUOTE : int + val WHITESPACE : int + val COMMENT : int + val LINE_COMMENT : int + val BEGIN : int + val DO : int + val FUNCTION : int + val THEN : int + val ELSE : int + val STRUCT : int + val CLASS : int + val TRY : int + val NEW : int + val WITH : int + val OWITH : int + end type FSharpTokenColorKind = | Default = 0 | Text = 0 @@ -17299,26 +42374,26 @@ namespace FSharp.Compiler.SourceCodeServices Tag: int TokenName: string FullMatchedLength: int } - module internal TokenClassifications = - val tokenInfo: + module internal TokenClassifications = begin + val tokenInfo : token:Parser.token -> FSharpTokenColorKind * FSharpTokenCharKind * FSharpTokenTriggerClass - - module internal TestExpose = - val TokenInfo: + end + module internal TestExpose = begin + val TokenInfo : Parser.token -> FSharpTokenColorKind * FSharpTokenCharKind * FSharpTokenTriggerClass - - [] + end + [] type FSharpTokenizerLexState = { PosBits: int64 OtherBits: int64 } with - override Equals: obj:obj -> bool - member Equals: FSharpTokenizerLexState -> bool - override GetHashCode: unit -> int - static member Initial: FSharpTokenizerLexState - + override Equals : obj:obj -> bool + member Equals : FSharpTokenizerLexState -> bool + override GetHashCode : unit -> int + static member Initial : FSharpTokenizerLexState + end type FSharpTokenizerColorState = | Token = 1 | IfDefSkip = 3 @@ -17334,94 +42409,94 @@ namespace FSharp.Compiler.SourceCodeServices | TripleQuoteString = 13 | TripleQuoteStringInComment = 14 | InitialState = 0 - module internal LexerStateEncoding = - val computeNextLexState: + module internal LexerStateEncoding = begin + val computeNextLexState : token:Parser.token -> prevLexcont:ParseHelpers.LexerContinuation -> ParseHelpers.LexerContinuation - val revertToDefaultLexCont: ParseHelpers.LexerContinuation - val lexstateNumBits: int - val ncommentsNumBits: int - val hardwhiteNumBits: int - val ifdefstackCountNumBits: int - val ifdefstackNumBits: int - val stringKindBits: int - val nestingBits: int - val lexstateStart: int - val ncommentsStart: int - val hardwhitePosStart: int - val ifdefstackCountStart: int - val ifdefstackStart: int - val stringKindStart: int - val nestingStart: int - val lexstateMask: int64 - val ncommentsMask: int64 - val hardwhitePosMask: int64 - val ifdefstackCountMask: int64 - val ifdefstackMask: int64 - val stringKindMask: int64 - val nestingMask: int64 - val bitOfBool: b:bool -> int - val boolOfBit: n:int64 -> bool - val colorStateOfLexState: + val revertToDefaultLexCont : ParseHelpers.LexerContinuation + val lexstateNumBits : int + val ncommentsNumBits : int + val hardwhiteNumBits : int + val ifdefstackCountNumBits : int + val ifdefstackNumBits : int + val stringKindBits : int + val nestingBits : int + val lexstateStart : int + val ncommentsStart : int + val hardwhitePosStart : int + val ifdefstackCountStart : int + val ifdefstackStart : int + val stringKindStart : int + val nestingStart : int + val lexstateMask : int64 + val ncommentsMask : int64 + val hardwhitePosMask : int64 + val ifdefstackCountMask : int64 + val ifdefstackMask : int64 + val stringKindMask : int64 + val nestingMask : int64 + val bitOfBool : b:bool -> int + val boolOfBit : n:int64 -> bool + val colorStateOfLexState : state:FSharpTokenizerLexState -> FSharpTokenizerColorState - val lexStateOfColorState: state:FSharpTokenizerColorState -> int64 - val encodeStringStyle: kind:ParseHelpers.LexerStringStyle -> int - val decodeStringStyle: kind:int -> ParseHelpers.LexerStringStyle - val encodeLexCont: + val lexStateOfColorState : state:FSharpTokenizerColorState -> int64 + val encodeStringStyle : kind:ParseHelpers.LexerStringStyle -> int + val decodeStringStyle : kind:int -> ParseHelpers.LexerStringStyle + val encodeLexCont : colorState:FSharpTokenizerColorState * numComments:int64 * b:Range.pos * ifdefStack:seq * light:bool * stringKind:ParseHelpers.LexerStringKind * stringNest:(int * ParseHelpers.LexerStringStyle * 'b) list -> FSharpTokenizerLexState - val decodeLexCont: + val decodeLexCont : state:FSharpTokenizerLexState -> FSharpTokenizerColorState * int32 * Range.pos * (ParseHelpers.LexerIfdefStackEntry * Range.range) list * bool * ParseHelpers.LexerStringKind * ParseHelpers.LexerInterpolatedStringNesting - val encodeLexInt: + val encodeLexInt : lightStatus:bool -> lexcont:ParseHelpers.LexerContinuation -> FSharpTokenizerLexState - val decodeLexInt: + val decodeLexInt : state:FSharpTokenizerLexState -> bool * ParseHelpers.LexerContinuation - + end type SingleLineTokenState = | BeforeHash = 0 | NoFurtherMatchPossible = 1 - [] + [] type FSharpLineTokenizer = - - new: lexbuf:UnicodeLexing.Lexbuf * maxLength:int option * + class + new : lexbuf:UnicodeLexing.Lexbuf * maxLength:int option * filename:string option * lexargs:Lexhelp.LexArgs -> FSharpLineTokenizer static member - ColorStateOfLexState: FSharpTokenizerLexState -> + ColorStateOfLexState : FSharpTokenizerLexState -> FSharpTokenizerColorState static member - LexStateOfColorState: FSharpTokenizerColorState -> + LexStateOfColorState : FSharpTokenizerColorState -> FSharpTokenizerLexState member - ScanToken: lexState:FSharpTokenizerLexState -> + ScanToken : lexState:FSharpTokenizerLexState -> FSharpTokenInfo option * FSharpTokenizerLexState - - [] + end + [] type FSharpSourceTokenizer = - - new: conditionalDefines:string list * filename:string option -> + class + new : conditionalDefines:string list * filename:string option -> FSharpSourceTokenizer member - CreateBufferTokenizer: bufferFiller:(char [] * int * int -> int) -> + CreateBufferTokenizer : bufferFiller:(char [] * int * int -> int) -> FSharpLineTokenizer - member CreateLineTokenizer: lineText:string -> FSharpLineTokenizer - - module Keywords = - val DoesIdentifierNeedQuotation: string -> bool - val QuoteIdentifierIfNeeded: string -> string - val NormalizeIdentifierBackticks: string -> string - val KeywordsWithDescription: (string * string) list - - module Lexer = + member CreateLineTokenizer : lineText:string -> FSharpLineTokenizer + end + module Keywords = begin + val DoesIdentifierNeedQuotation : string -> bool + val QuoteIdentifierIfNeeded : string -> string + val NormalizeIdentifierBackticks : string -> string + val KeywordsWithDescription : (string * string) list + end + module Lexer = begin [] @@ -17626,23 +42701,23 @@ namespace FSharp.Compiler.SourceCodeServices | InfixLsr | InfixLxor | InfixMod - [] type FSharpSyntaxToken = - - new: tok:Parser.token * tokRange:Range.range -> FSharpSyntaxToken + struct + new : tok:Parser.token * tokRange:Range.range -> FSharpSyntaxToken val private tok: Parser.token val private tokRange: Range.range - member IsCommentTrivia: bool - member IsIdentifier: bool - member IsKeyword: bool - member IsNumericLiteral: bool - member IsStringLiteral: bool - member Kind: FSharpSyntaxTokenKind - member Range: Range.range - - val lexWithErrorLogger: + member IsCommentTrivia : bool + member IsIdentifier : bool + member IsKeyword : bool + member IsNumericLiteral : bool + member IsStringLiteral : bool + member Kind : FSharpSyntaxTokenKind + member Range : Range.range + end + val lexWithErrorLogger : text:Text.ISourceText -> conditionalCompilationDefines:string list -> flags:FSharpLexerFlags -> @@ -17651,7 +42726,7 @@ namespace FSharp.Compiler.SourceCodeServices onToken:(Parser.token -> Range.range -> unit) -> pathMap:Internal.Utilities.PathMap -> ct:System.Threading.CancellationToken -> unit - val lex: + val lex : text:Text.ISourceText -> conditionalCompilationDefines:string list -> flags:FSharpLexerFlags -> @@ -17663,26 +42738,26 @@ namespace FSharp.Compiler.SourceCodeServices ExperimentalAttribute ("This FCS API is experimental and subject to change.")>] type FSharpLexer = - + class [] static member - Lex: text:Text.ISourceText * + Lex : text:Text.ISourceText * tokenCallback:(FSharpSyntaxToken -> unit) * ?langVersion:string * ?filePath:string * ?conditionalCompilationDefines:string list * ?flags:FSharpLexerFlags * ?pathMap:Map * ?ct:System.Threading.CancellationToken -> unit - - + end + end namespace FSharp.Compiler.SourceCodeServices - module AstTraversal = - val rangeContainsPosLeftEdgeInclusive: + module AstTraversal = begin + val rangeContainsPosLeftEdgeInclusive : m1:Range.range -> p:Range.pos -> bool - val rangeContainsPosEdgesExclusive: m1:Range.range -> p:Range.pos -> bool - val rangeContainsPosLeftEdgeExclusiveAndRightEdgeInclusive: + val rangeContainsPosEdgesExclusive : m1:Range.range -> p:Range.pos -> bool + val rangeContainsPosLeftEdgeExclusiveAndRightEdgeInclusive : m1:Range.range -> p:Range.pos -> bool - [] + [] type TraverseStep = | Expr of SyntaxTree.SynExpr | Module of SyntaxTree.SynModuleDecl @@ -17692,114 +42767,114 @@ namespace FSharp.Compiler.SourceCodeServices | MatchClause of SyntaxTree.SynMatchClause | Binding of SyntaxTree.SynBinding type TraversePath = TraverseStep list - [] + [] type AstVisitorBase<'T> = - - new: unit -> AstVisitorBase<'T> + class + new : unit -> AstVisitorBase<'T> override - VisitBinding: defaultTraverse:(SyntaxTree.SynBinding -> 'T option) * + VisitBinding : defaultTraverse:(SyntaxTree.SynBinding -> 'T option) * binding:SyntaxTree.SynBinding -> 'T option abstract member - VisitBinding: (SyntaxTree.SynBinding -> 'T option) * + VisitBinding : (SyntaxTree.SynBinding -> 'T option) * SyntaxTree.SynBinding -> 'T option - override VisitComponentInfo: SyntaxTree.SynComponentInfo -> 'T option + override VisitComponentInfo : SyntaxTree.SynComponentInfo -> 'T option abstract member - VisitComponentInfo: SyntaxTree.SynComponentInfo -> 'T option + VisitComponentInfo : SyntaxTree.SynComponentInfo -> 'T option abstract member - VisitExpr: TraversePath * (SyntaxTree.SynExpr -> 'T option) * + VisitExpr : TraversePath * (SyntaxTree.SynExpr -> 'T option) * (SyntaxTree.SynExpr -> 'T option) * SyntaxTree.SynExpr -> 'T option - override VisitHashDirective: Range.range -> 'T option - abstract member VisitHashDirective: Range.range -> 'T option + override VisitHashDirective : Range.range -> 'T option + abstract member VisitHashDirective : Range.range -> 'T option override - VisitImplicitInherit: defaultTraverse:(SyntaxTree.SynExpr -> + VisitImplicitInherit : defaultTraverse:(SyntaxTree.SynExpr -> 'T option) * _ty:SyntaxTree.SynType * expr:SyntaxTree.SynExpr * _m:Range.range -> 'T option abstract member - VisitImplicitInherit: (SyntaxTree.SynExpr -> 'T option) * + VisitImplicitInherit : (SyntaxTree.SynExpr -> 'T option) * SyntaxTree.SynType * SyntaxTree.SynExpr * Range.range -> 'T option override - VisitInheritSynMemberDefn: _componentInfo:SyntaxTree.SynComponentInfo * + VisitInheritSynMemberDefn : _componentInfo:SyntaxTree.SynComponentInfo * _typeDefnKind:SyntaxTree.SynTypeDefnKind * _synType:SyntaxTree.SynType * _members:SyntaxTree.SynMemberDefns * _range:Range.range -> 'T option abstract member - VisitInheritSynMemberDefn: SyntaxTree.SynComponentInfo * + VisitInheritSynMemberDefn : SyntaxTree.SynComponentInfo * SyntaxTree.SynTypeDefnKind * SyntaxTree.SynType * SyntaxTree.SynMemberDefns * Range.range -> 'T option override - VisitInterfaceSynMemberDefnType: _synType:SyntaxTree.SynType -> + VisitInterfaceSynMemberDefnType : _synType:SyntaxTree.SynType -> 'T option abstract member - VisitInterfaceSynMemberDefnType: SyntaxTree.SynType -> 'T option + VisitInterfaceSynMemberDefnType : SyntaxTree.SynType -> 'T option override - VisitLetOrUse: TraversePath * (SyntaxTree.SynBinding -> 'T option) * + VisitLetOrUse : TraversePath * (SyntaxTree.SynBinding -> 'T option) * SyntaxTree.SynBinding list * Range.range -> 'T option abstract member - VisitLetOrUse: TraversePath * (SyntaxTree.SynBinding -> 'T option) * + VisitLetOrUse : TraversePath * (SyntaxTree.SynBinding -> 'T option) * SyntaxTree.SynBinding list * Range.range -> 'T option override - VisitMatchClause: defaultTraverse:(SyntaxTree.SynMatchClause -> + VisitMatchClause : defaultTraverse:(SyntaxTree.SynMatchClause -> 'T option) * mc:SyntaxTree.SynMatchClause -> 'T option abstract member - VisitMatchClause: (SyntaxTree.SynMatchClause -> 'T option) * + VisitMatchClause : (SyntaxTree.SynMatchClause -> 'T option) * SyntaxTree.SynMatchClause -> 'T option override - VisitModuleDecl: defaultTraverse:(SyntaxTree.SynModuleDecl -> + VisitModuleDecl : defaultTraverse:(SyntaxTree.SynModuleDecl -> 'T option) * decl:SyntaxTree.SynModuleDecl -> 'T option abstract member - VisitModuleDecl: (SyntaxTree.SynModuleDecl -> 'T option) * + VisitModuleDecl : (SyntaxTree.SynModuleDecl -> 'T option) * SyntaxTree.SynModuleDecl -> 'T option override - VisitModuleOrNamespace: SyntaxTree.SynModuleOrNamespace -> 'T option + VisitModuleOrNamespace : SyntaxTree.SynModuleOrNamespace -> 'T option abstract member - VisitModuleOrNamespace: SyntaxTree.SynModuleOrNamespace -> 'T option + VisitModuleOrNamespace : SyntaxTree.SynModuleOrNamespace -> 'T option override - VisitPat: defaultTraverse:(SyntaxTree.SynPat -> 'T option) * + VisitPat : defaultTraverse:(SyntaxTree.SynPat -> 'T option) * pat:SyntaxTree.SynPat -> 'T option abstract member - VisitPat: (SyntaxTree.SynPat -> 'T option) * SyntaxTree.SynPat -> + VisitPat : (SyntaxTree.SynPat -> 'T option) * SyntaxTree.SynPat -> 'T option override - VisitRecordField: _path:TraversePath * + VisitRecordField : _path:TraversePath * _copyOpt:SyntaxTree.SynExpr option * _recordField:SyntaxTree.LongIdentWithDots option -> 'T option abstract member - VisitRecordField: TraversePath * SyntaxTree.SynExpr option * + VisitRecordField : TraversePath * SyntaxTree.SynExpr option * SyntaxTree.LongIdentWithDots option -> 'T option - override VisitSimplePats: SyntaxTree.SynSimplePat list -> 'T option + override VisitSimplePats : SyntaxTree.SynSimplePat list -> 'T option abstract member - VisitSimplePats: SyntaxTree.SynSimplePat list -> 'T option + VisitSimplePats : SyntaxTree.SynSimplePat list -> 'T option override - VisitType: defaultTraverse:(SyntaxTree.SynType -> 'T option) * + VisitType : defaultTraverse:(SyntaxTree.SynType -> 'T option) * ty:SyntaxTree.SynType -> 'T option abstract member - VisitType: (SyntaxTree.SynType -> 'T option) * SyntaxTree.SynType -> + VisitType : (SyntaxTree.SynType -> 'T option) * SyntaxTree.SynType -> 'T option override - VisitTypeAbbrev: _ty:SyntaxTree.SynType * _m:Range.range -> 'T option + VisitTypeAbbrev : _ty:SyntaxTree.SynType * _m:Range.range -> 'T option abstract member - VisitTypeAbbrev: SyntaxTree.SynType * Range.range -> 'T option - - val dive: node:'a -> range:'b -> project:('a -> 'c) -> 'b * (unit -> 'c) - val pick: + VisitTypeAbbrev : SyntaxTree.SynType * Range.range -> 'T option + end + val dive : node:'a -> range:'b -> project:('a -> 'c) -> 'b * (unit -> 'c) + val pick : pos:Range.pos -> outerRange:Range.range -> _debugObj:obj -> diveResults:(Range.range * (unit -> 'a option)) list -> 'a option - val Traverse: + val Traverse : pos:Range.pos * parseTree:SyntaxTree.ParsedInput * visitor:AstVisitorBase<'T> -> 'T option - + end namespace FSharp.Compiler.SourceCodeServices type FSharpNavigationDeclarationItemKind = @@ -17812,7 +42887,7 @@ namespace FSharp.Compiler.SourceCodeServices | PropertyDecl | FieldDecl | OtherDecl - [] + [] type FSharpEnclosingEntityKind = | Namespace | Module @@ -17822,71 +42897,71 @@ namespace FSharp.Compiler.SourceCodeServices | Record | Enum | DU - [] + [] type FSharpNavigationDeclarationItem = - - new: uniqueName:string * name:string * + class + new : uniqueName:string * name:string * kind:FSharpNavigationDeclarationItemKind * glyph:FSharpGlyph * range:Range.range * bodyRange:Range.range * singleTopLevel:bool * enclosingEntityKind:FSharpEnclosingEntityKind * isAbstract:bool * access:SyntaxTree.SynAccess option -> FSharpNavigationDeclarationItem static member - Create: name:string * kind:FSharpNavigationDeclarationItemKind * + Create : name:string * kind:FSharpNavigationDeclarationItemKind * glyph:FSharpGlyph * range:Range.range * bodyRange:Range.range * singleTopLevel:bool * enclosingEntityKind:FSharpEnclosingEntityKind * isAbstract:bool * access:SyntaxTree.SynAccess option -> FSharpNavigationDeclarationItem member - WithUniqueName: uniqueName:string -> FSharpNavigationDeclarationItem - member Access: SyntaxTree.SynAccess option - member BodyRange: Range.range - member EnclosingEntityKind: FSharpEnclosingEntityKind - member Glyph: FSharpGlyph - member IsAbstract: bool - member IsSingleTopLevel: bool - member Kind: FSharpNavigationDeclarationItemKind - member Name: string - member Range: Range.range - member UniqueName: string - member bodyRange: Range.range - - [] + WithUniqueName : uniqueName:string -> FSharpNavigationDeclarationItem + member Access : SyntaxTree.SynAccess option + member BodyRange : Range.range + member EnclosingEntityKind : FSharpEnclosingEntityKind + member Glyph : FSharpGlyph + member IsAbstract : bool + member IsSingleTopLevel : bool + member Kind : FSharpNavigationDeclarationItemKind + member Name : string + member Range : Range.range + member UniqueName : string + member bodyRange : Range.range + end + [] type FSharpNavigationTopLevelDeclaration = { Declaration: FSharpNavigationDeclarationItem Nested: FSharpNavigationDeclarationItem [] } - [] + [] type FSharpNavigationItems = - - new: declarations:FSharpNavigationTopLevelDeclaration [] -> + class + new : declarations:FSharpNavigationTopLevelDeclaration [] -> FSharpNavigationItems - member Declarations: FSharpNavigationTopLevelDeclaration [] - - module NavigationImpl = - val unionRangesChecked: r1:Range.range -> r2:Range.range -> Range.range - val rangeOfDecls2: + member Declarations : FSharpNavigationTopLevelDeclaration [] + end + module NavigationImpl = begin + val unionRangesChecked : r1:Range.range -> r2:Range.range -> Range.range + val rangeOfDecls2 : f:('a -> FSharpNavigationDeclarationItem) -> decls:'a list -> Range.range - val rangeOfDecls: + val rangeOfDecls : ((FSharpNavigationDeclarationItem * int) list -> Range.range) - val moduleRange: + val moduleRange : idm:Range.range -> others:(FSharpNavigationDeclarationItem * 'a * 'b) list -> Range.range - val fldspecRange: fldspec:SyntaxTree.SynUnionCaseType -> Range.range - val bodyRange: + val fldspecRange : fldspec:SyntaxTree.SynUnionCaseType -> Range.range + val bodyRange : mb:Range.range -> decls:(FSharpNavigationDeclarationItem * int) list -> Range.range - val getNavigationFromImplFile: + val getNavigationFromImplFile : modules:SyntaxTree.SynModuleOrNamespace list -> FSharpNavigationItems - val getNavigationFromSigFile: + val getNavigationFromSigFile : modules:SyntaxTree.SynModuleOrNamespaceSig list -> FSharpNavigationItems - - module FSharpNavigation = - val getNavigation: SyntaxTree.ParsedInput -> FSharpNavigationItems - val empty: FSharpNavigationItems - - module NavigateTo = - [] + end + module FSharpNavigation = begin + val getNavigation : SyntaxTree.ParsedInput -> FSharpNavigationItems + val empty : FSharpNavigationItems + end + module NavigateTo = begin + [] type NavigableItemKind = | Module | ModuleAbbreviation @@ -17900,9 +42975,9 @@ namespace FSharp.Compiler.SourceCodeServices | EnumCase | UnionCase with - override ToString: unit -> string - - [] + override ToString : unit -> string + end + [] type ContainerType = | File | Namespace @@ -17918,31 +42993,31 @@ namespace FSharp.Compiler.SourceCodeServices IsSignature: bool Kind: NavigableItemKind Container: Container } - val getNavigableItems: SyntaxTree.ParsedInput -> NavigableItem [] - + val getNavigableItems : SyntaxTree.ParsedInput -> NavigableItem [] + end namespace FSharp.Compiler.SourceCodeServices - [] + [] type FSharpNoteworthyParamInfoLocations = - - new: longId:string list * longIdRange:Range.range * + class + new : longId:string list * longIdRange:Range.range * openParenLocation:Range.pos * tupleEndLocations:Range.pos list * isThereACloseParen:bool * namedParamNames:string option list -> FSharpNoteworthyParamInfoLocations static member - Find: Range.pos * SyntaxTree.ParsedInput -> + Find : Range.pos * SyntaxTree.ParsedInput -> FSharpNoteworthyParamInfoLocations option - member IsThereACloseParen: bool - member LongId: string list - member LongIdEndLocation: Range.pos - member LongIdStartLocation: Range.pos - member NamedParamNames: string option [] - member OpenParenLocation: Range.pos - member TupleEndLocations: Range.pos [] - - module internal NoteworthyParamInfoLocationsImpl = - val isStaticArg: SyntaxTree.SynType -> bool - val digOutIdentFromFuncExpr: + member IsThereACloseParen : bool + member LongId : string list + member LongIdEndLocation : Range.pos + member LongIdStartLocation : Range.pos + member NamedParamNames : string option [] + member OpenParenLocation : Range.pos + member TupleEndLocations : Range.pos [] + end + module internal NoteworthyParamInfoLocationsImpl = begin + val isStaticArg : SyntaxTree.SynType -> bool + val digOutIdentFromFuncExpr : synExpr:SyntaxTree.SynExpr -> (string list * Range.range) option type FindResult = | Found of @@ -17950,62 +43025,62 @@ namespace FSharp.Compiler.SourceCodeServices commasAndCloseParen: (Range.pos * string option) list * hasClosedParen: bool | NotFound - val digOutIdentFromStaticArg: SyntaxTree.SynType -> string option - val getNamedParamName: e:SyntaxTree.SynExpr -> string option - val getTypeName: synType:SyntaxTree.SynType -> string list - val handleSingleArg: + val digOutIdentFromStaticArg : SyntaxTree.SynType -> string option + val getNamedParamName : e:SyntaxTree.SynExpr -> string option + val getTypeName : synType:SyntaxTree.SynType -> string list + val handleSingleArg : traverseSynExpr:(SyntaxTree.SynExpr -> 'a option) -> pos:Range.pos * synExpr:SyntaxTree.SynExpr * parenRange:Range.range * rpRangeOpt:'b option -> FindResult * 'c option - val searchSynArgExpr: + val searchSynArgExpr : traverseSynExpr:(SyntaxTree.SynExpr -> 'a option) -> pos:Range.pos -> expr:SyntaxTree.SynExpr -> FindResult * 'a option option - val ( |StaticParameters|_| ): + val ( |StaticParameters|_| ) : pos:Range.pos -> SyntaxTree.SynType -> FSharpNoteworthyParamInfoLocations option - val traverseInput: + val traverseInput : pos:Range.pos * parseTree:SyntaxTree.ParsedInput -> FSharpNoteworthyParamInfoLocations option - - module internal SynExprAppLocationsImpl = - val private searchSynArgExpr: + end + module internal SynExprAppLocationsImpl = begin + val private searchSynArgExpr : traverseSynExpr:(SyntaxTree.SynExpr -> 'a option) -> expr:SyntaxTree.SynExpr -> ranges:Range.range list -> Range.range list option * 'a option option - val getAllCurriedArgsAtPosition: + val getAllCurriedArgsAtPosition : pos:Range.pos -> parseTree:SyntaxTree.ParsedInput -> Range.range list option - + end namespace FSharp.Compiler.SourceCodeServices - module SourceFile = - val private compilableExtensions: string list - val private singleFileProjectExtensions: string list - val IsCompilable: string -> bool - val MustBeSingleFileProject: string -> bool - - module SourceFileImpl = - val IsInterfaceFile: string -> bool - val AdditionalDefinesForUseInEditor: isInteractive:bool -> string list - + module SourceFile = begin + val private compilableExtensions : string list + val private singleFileProjectExtensions : string list + val IsCompilable : string -> bool + val MustBeSingleFileProject : string -> bool + end + module SourceFileImpl = begin + val IsInterfaceFile : string -> bool + val AdditionalDefinesForUseInEditor : isInteractive:bool -> string list + end type CompletionPath = string list * string option - [] + [] type InheritanceOrigin = | Class | Interface | Unknown - [] + [] type InheritanceContext = | Class | Interface | Unknown - [] + [] type RecordContext = | CopyOnUpdate of Range.range * CompletionPath | Constructor of string | New of CompletionPath - [] + [] type CompletionContext = | Invalid | Inherit of InheritanceContext * CompletionPath @@ -18015,80 +43090,80 @@ namespace FSharp.Compiler.SourceCodeServices | AttributeApplication | OpenDeclaration of isOpenType: bool | PatternType - [] + [] type FSharpParseFileResults = - - new: errors:FSharpErrorInfo [] * input:SyntaxTree.ParsedInput option * + class + new : errors:FSharpErrorInfo [] * input:SyntaxTree.ParsedInput option * parseHadErrors:bool * dependencyFiles:string [] -> FSharpParseFileResults member - FindNoteworthyParamInfoLocations: pos:Range.pos -> + FindNoteworthyParamInfoLocations : pos:Range.pos -> FSharpNoteworthyParamInfoLocations option member - GetAllArgumentsForFunctionApplicationAtPostion: pos:Range.pos -> + GetAllArgumentsForFunctionApplicationAtPostion : pos:Range.pos -> Range.range list option - member GetNavigationItems: unit -> FSharpNavigationItems - member private GetNavigationItemsImpl: unit -> FSharpNavigationItems - member IsPosContainedInApplication: pos:Range.pos -> bool - member IsPositionContainedInACurriedParameter: pos:Range.pos -> bool + member GetNavigationItems : unit -> FSharpNavigationItems + member private GetNavigationItemsImpl : unit -> FSharpNavigationItems + member IsPosContainedInApplication : pos:Range.pos -> bool + member IsPositionContainedInACurriedParameter : pos:Range.pos -> bool member - TryIdentOfPipelineContainingPosAndNumArgsApplied: pos:Range.pos -> + TryIdentOfPipelineContainingPosAndNumArgsApplied : pos:Range.pos -> (SyntaxTree.Ident * int) option - member TryRangeOfExprInYieldOrReturn: pos:Range.pos -> Range.range option + member TryRangeOfExprInYieldOrReturn : pos:Range.pos -> Range.range option member - TryRangeOfFunctionOrMethodBeingApplied: pos:Range.pos -> + TryRangeOfFunctionOrMethodBeingApplied : pos:Range.pos -> Range.range option member - TryRangeOfParenEnclosingOpEqualsGreaterUsage: opGreaterEqualPos:Range.pos -> + TryRangeOfParenEnclosingOpEqualsGreaterUsage : opGreaterEqualPos:Range.pos -> (Range.range * Range.range * Range.range) option member - TryRangeOfRecordExpressionContainingPos: pos:Range.pos -> + TryRangeOfRecordExpressionContainingPos : pos:Range.pos -> Range.range option member - TryRangeOfRefCellDereferenceContainingPos: expressionPos:Range.pos -> + TryRangeOfRefCellDereferenceContainingPos : expressionPos:Range.pos -> Range.range option - member ValidateBreakpointLocation: pos:Range.pos -> Range.range option + member ValidateBreakpointLocation : pos:Range.pos -> Range.range option member - private ValidateBreakpointLocationImpl: pos:Range.pos -> + private ValidateBreakpointLocationImpl : pos:Range.pos -> Range.range option - member DependencyFiles: string [] - member Errors: FSharpErrorInfo [] - member FileName: string - member ParseHadErrors: bool - member ParseTree: SyntaxTree.ParsedInput option - + member DependencyFiles : string [] + member Errors : FSharpErrorInfo [] + member FileName : string + member ParseHadErrors : bool + member ParseTree : SyntaxTree.ParsedInput option + end type ModuleKind = { IsAutoOpen: bool HasModuleSuffix: bool } - [] + [] type EntityKind = | Attribute | Type | FunctionOrValue of isActivePattern: bool | Module of ModuleKind with - override ToString: unit -> string - - module UntypedParseImpl = - val emptyStringSet: System.Collections.Generic.HashSet - val GetRangeOfExprLeftOfDot: + override ToString : unit -> string + end + module UntypedParseImpl = begin + val emptyStringSet : System.Collections.Generic.HashSet + val GetRangeOfExprLeftOfDot : Range.pos * SyntaxTree.ParsedInput option -> Range.range option - val TryFindExpressionIslandInPosition: + val TryFindExpressionIslandInPosition : Range.pos * SyntaxTree.ParsedInput option -> string option - val TryFindExpressionASTLeftOfDotLeftOfCursor: + val TryFindExpressionASTLeftOfDotLeftOfCursor : Range.pos * SyntaxTree.ParsedInput option -> (Range.pos * bool) option - val GetEntityKind: Range.pos * SyntaxTree.ParsedInput -> EntityKind option + val GetEntityKind : Range.pos * SyntaxTree.ParsedInput -> EntityKind option type internal TS = AstTraversal.TraverseStep - val insideAttributeApplicationRegex: System.Text.RegularExpressions.Regex - val TryGetCompletionContext: + val insideAttributeApplicationRegex : System.Text.RegularExpressions.Regex + val TryGetCompletionContext : Range.pos * SyntaxTree.ParsedInput * lineStr:string -> CompletionContext option - val GetFullNameOfSmallestModuleOrNamespaceAtPoint: + val GetFullNameOfSmallestModuleOrNamespaceAtPoint : SyntaxTree.ParsedInput * Range.pos -> string [] - + end namespace FSharp.Compiler.SourceCodeServices type ShortIdent = string @@ -18098,32 +43173,32 @@ namespace FSharp.Compiler.SourceCodeServices Resolved: bool } type MaybeUnresolvedIdents = MaybeUnresolvedIdent [] type IsAutoOpen = bool - module Extensions = + module Extensions = begin type FSharpEntity with - member TryGetFullName: unit -> string option + member TryGetFullName : unit -> string option type FSharpEntity with - member TryGetFullDisplayName: unit -> string option + member TryGetFullDisplayName : unit -> string option type FSharpEntity with - member TryGetFullCompiledName: unit -> string option + member TryGetFullCompiledName : unit -> string option type FSharpEntity with - member PublicNestedEntities: seq + member PublicNestedEntities : seq type FSharpEntity with member - TryGetMembersFunctionsAndValues: System.Collections.Generic.IList + TryGetMembersFunctionsAndValues : System.Collections.Generic.IList type FSharpMemberOrFunctionOrValue with - member FullTypeSafe: FSharpType option + member FullTypeSafe : FSharpType option type FSharpMemberOrFunctionOrValue with - member TryGetFullDisplayName: unit -> string option + member TryGetFullDisplayName : unit -> string option type FSharpMemberOrFunctionOrValue with - member TryGetFullCompiledOperatorNameIdents: unit -> Idents option + member TryGetFullCompiledOperatorNameIdents : unit -> Idents option type FSharpAssemblySignature with - member TryGetEntities: unit -> seq - - [] + member TryGetEntities : unit -> seq + end + [] type LookupType = | Fuzzy | Precise - [] + [] type AssemblySymbol = { FullName: string CleanedIdents: Idents @@ -18135,8 +43210,8 @@ namespace FSharp.Compiler.SourceCodeServices Kind: LookupType -> EntityKind UnresolvedSymbol: UnresolvedSymbol } with - override ToString: unit -> string - + override ToString : unit -> string + end type AssemblyPath = string type AssemblyContentType = | Public @@ -18150,58 +43225,58 @@ namespace FSharp.Compiler.SourceCodeServices IsModule: bool } with static member - RewriteParentIdents: parentIdents:Idents option -> + RewriteParentIdents : parentIdents:Idents option -> idents:Idents -> Idents - member FixParentModuleSuffix: idents:Idents -> Idents + member FixParentModuleSuffix : idents:Idents -> Idents member - FormatEntityFullName: entity:FSharpEntity -> + FormatEntityFullName : entity:FSharpEntity -> (string * ShortIdent []) option - static member Empty: Parent - + static member Empty : Parent + end type AssemblyContentCacheEntry = { FileWriteTime: System.DateTime ContentType: AssemblyContentType Symbols: AssemblySymbol list } - [] + [] type IAssemblyContentCache = interface - abstract member Set: AssemblyPath -> AssemblyContentCacheEntry -> unit - abstract member TryGet: AssemblyPath -> AssemblyContentCacheEntry option - - module AssemblyContentProvider = - val unresolvedSymbol: + abstract member Set : AssemblyPath -> AssemblyContentCacheEntry -> unit + abstract member TryGet : AssemblyPath -> AssemblyContentCacheEntry option + end + module AssemblyContentProvider = begin + val unresolvedSymbol : topRequireQualifiedAccessParent:Idents option -> cleanedIdents:Idents -> fullName:string -> UnresolvedSymbol - val createEntity: + val createEntity : ns:Idents option -> parent:Parent -> entity:FSharpEntity -> AssemblySymbol option - val traverseMemberFunctionAndValues: + val traverseMemberFunctionAndValues : ns:Idents option -> parent:Parent -> membersFunctionsAndValues:seq -> seq - val traverseEntity: + val traverseEntity : contentType:AssemblyContentType -> parent:Parent -> entity:FSharpEntity -> seq - val getAssemblySignatureContent: + val getAssemblySignatureContent : AssemblyContentType -> FSharpAssemblySignature -> AssemblySymbol list - val getAssemblySignaturesContent: + val getAssemblySignaturesContent : contentType:AssemblyContentType -> assemblies:FSharpAssembly list -> AssemblySymbol list - val getAssemblyContent: + val getAssemblyContent : withCache:((IAssemblyContentCache -> AssemblySymbol list) -> AssemblySymbol list) -> contentType:AssemblyContentType -> fileName:string option -> assemblies:FSharpAssembly list -> AssemblySymbol list - + end type EntityCache = - + class interface IAssemblyContentCache - new: unit -> EntityCache - member Clear: unit -> unit - member Locking: (IAssemblyContentCache -> 'T) -> 'T - + new : unit -> EntityCache + member Clear : unit -> unit + member Locking : (IAssemblyContentCache -> 'T) -> 'T + end type StringLongIdent = string type Entity = { FullRelativeName: StringLongIdent @@ -18210,18 +43285,18 @@ namespace FSharp.Compiler.SourceCodeServices Name: StringLongIdent LastIdent: string } with - override ToString: unit -> string - - module Entity = - val getRelativeNamespace: targetNs:Idents -> sourceNs:Idents -> Idents - val cutAutoOpenModules: + override ToString : unit -> string + end + module Entity = begin + val getRelativeNamespace : targetNs:Idents -> sourceNs:Idents -> Idents + val cutAutoOpenModules : autoOpenParent:Idents option -> candidateNs:Idents -> ShortIdent [] - val tryCreate: + val tryCreate : targetNamespace:Idents option * targetScope:Idents * partiallyQualifiedName:MaybeUnresolvedIdents * requiresQualifiedAccessParent:Idents option * autoOpenParent:Idents option * candidateNamespace:Idents option * candidate:Idents -> Entity [] - + end type ScopeKind = | Namespace | TopModule @@ -18229,8 +43304,8 @@ namespace FSharp.Compiler.SourceCodeServices | OpenDeclaration | HashDirective with - override ToString: unit -> string - + override ToString : unit -> string + end type InsertContext = { ScopeKind: ScopeKind Pos: Range.pos } @@ -18240,98 +43315,98 @@ namespace FSharp.Compiler.SourceCodeServices type OpenStatementInsertionPoint = | TopLevel | Nearest - module ParsedInput = - val ( |Sequentials|_| ): + module ParsedInput = begin + val ( |Sequentials|_| ) : _arg1:SyntaxTree.SynExpr -> SyntaxTree.SynExpr list option - val ( |ConstructorPats| ): + val ( |ConstructorPats| ) : _arg1:SyntaxTree.SynArgPats -> SyntaxTree.SynPat list - val getLongIdents: + val getLongIdents : input:SyntaxTree.ParsedInput option -> System.Collections.Generic.IDictionary - val getLongIdentAt: + val getLongIdentAt : ast:SyntaxTree.ParsedInput -> pos:Range.pos -> SyntaxTree.LongIdent option type Scope = { Idents: Idents Kind: ScopeKind } - val tryFindNearestPointAndModules: + val tryFindNearestPointAndModules : currentLine:int -> ast:SyntaxTree.ParsedInput -> insertionPoint:OpenStatementInsertionPoint -> (Scope * string [] option * Range.pos) option * Module list - val findBestPositionToInsertOpenDeclaration: + val findBestPositionToInsertOpenDeclaration : modules:Module list -> scope:Scope -> pos:Range.pos -> entity:Idents -> InsertContext - val tryFindInsertionContext: + val tryFindInsertionContext : currentLine:int -> ast:SyntaxTree.ParsedInput -> MaybeUnresolvedIdents -> insertionPoint:OpenStatementInsertionPoint -> (Idents option * Idents option * Idents option * Idents -> (Entity * InsertContext) []) - val adjustInsertionPoint: + val adjustInsertionPoint : getLineStr:(int -> string) -> ctx:InsertContext -> Range.pos - val findNearestPointToInsertOpenDeclaration: + val findNearestPointToInsertOpenDeclaration : currentLine:int -> ast:SyntaxTree.ParsedInput -> entity:Idents -> insertionPoint:OpenStatementInsertionPoint -> InsertContext - + end namespace FSharp.Compiler.SourceCodeServices type XmlDocable = | XmlDocable of line: int * indent: int * paramNames: string list - module XmlDocParsing = - val ( |ConstructorPats| ): + module XmlDocParsing = begin + val ( |ConstructorPats| ) : _arg1:SyntaxTree.SynArgPats -> SyntaxTree.SynPat list - val digNamesFrom: pat:SyntaxTree.SynPat -> string list - val getXmlDocablesImpl: + val digNamesFrom : pat:SyntaxTree.SynPat -> string list + val getXmlDocablesImpl : sourceText:Text.ISourceText * input:SyntaxTree.ParsedInput option -> XmlDocable list - - module XmlDocComment = - val private ws: s:string * pos:int -> (string * int) option - val private str: + end + module XmlDocComment = begin + val private ws : s:string * pos:int -> (string * int) option + val private str : prefix:string -> s:string * pos:int -> (string * int) option - val private eol: s:string * pos:'a -> (string * 'a) option - val inline private ( >=> ): + val private eol : s:string * pos:'a -> (string * 'a) option + val inline private ( >=> ) : f:('a -> 'b option) -> g:('b -> 'c option) -> ('a -> 'c option) - val isBlank: string -> int option - - module XmlDocParser = - val getXmlDocables: + val isBlank : string -> int option + end + module XmlDocParser = begin + val getXmlDocables : Text.ISourceText * input:SyntaxTree.ParsedInput option -> XmlDocable list - + end namespace FSharp.Compiler.SourceCodeServices - module private Option = - val ofOptionList: xs:'a option list -> 'a list option - - [] + module private Option = begin + val ofOptionList : xs:'a option list -> 'a list option + end + [] type ExternalType = | Type of fullName: string * genericArgs: ExternalType list | Array of inner: ExternalType | Pointer of inner: ExternalType | TypeVar of typeName: string with - override ToString: unit -> string - - module ExternalType = - val internal tryOfILType: + override ToString : unit -> string + end + module ExternalType = begin + val internal tryOfILType : string array -> AbstractIL.IL.ILType -> ExternalType option - - [] + end + [] type ParamTypeSymbol = | Param of ExternalType | Byref of ExternalType with - override ToString: unit -> string - - module ParamTypeSymbol = - val internal tryOfILType: + override ToString : unit -> string + end + module ParamTypeSymbol = begin + val internal tryOfILType : string array -> AbstractIL.IL.ILType -> ParamTypeSymbol option - val internal tryOfILTypes: + val internal tryOfILTypes : string array -> AbstractIL.IL.ILType list -> ParamTypeSymbol list option - + end [] type ExternalSymbol = @@ -18344,9 +43419,9 @@ namespace FSharp.Compiler.SourceCodeServices | Event of typeName: string * name: string | Property of typeName: string * name: string with - member internal ToDebuggerDisplay: unit -> string - override ToString: unit -> string - + member internal ToDebuggerDisplay : unit -> string + override ToString : unit -> string + end namespace FSharp.Compiler type PartialLongName = @@ -18355,62 +43430,62 @@ namespace FSharp.Compiler EndColumn: int LastDotPos: int option } with - static member Empty: endColumn:int -> PartialLongName - - module QuickParse = - val MagicalAdjustmentConstant: int - val CorrectIdentifierToken: tokenText:string -> tokenTag:int -> int - val isValidStrippedName: name:System.ReadOnlySpan -> idx:int -> bool - val private isValidActivePatternName: name:string -> bool - val GetCompleteIdentifierIslandImpl: + static member Empty : endColumn:int -> PartialLongName + end + module QuickParse = begin + val MagicalAdjustmentConstant : int + val CorrectIdentifierToken : tokenText:string -> tokenTag:int -> int + val isValidStrippedName : name:System.ReadOnlySpan -> idx:int -> bool + val private isValidActivePatternName : name:string -> bool + val GetCompleteIdentifierIslandImpl : lineStr:string -> index:int -> (string * int * bool) option - val GetCompleteIdentifierIsland: + val GetCompleteIdentifierIsland : tolerateJustAfter:bool -> tokenText:string -> index:int -> (string * int * bool) option - val private defaultName: 'a list * string - val GetPartialLongName: lineStr:string * index:int -> string list * string + val private defaultName : 'a list * string + val GetPartialLongName : lineStr:string * index:int -> string list * string type private EatCommentCallContext = | SkipWhiteSpaces of ident: string * current: string list * throwAwayNext: bool | StartIdentifier of current: string list * throwAway: bool - val GetPartialLongNameEx: lineStr:string * index:int -> PartialLongName - val TokenNameEquals: + val GetPartialLongNameEx : lineStr:string * index:int -> PartialLongName + val TokenNameEquals : tokenInfo:SourceCodeServices.FSharpTokenInfo -> token2:string -> bool - val private expected: string [] list - val TestMemberOrOverrideDeclaration: + val private expected : string [] list + val TestMemberOrOverrideDeclaration : tokens:SourceCodeServices.FSharpTokenInfo [] -> bool - + end namespace FSharp.Compiler.SourceCodeServices - module internal FSharpCheckerResultsSettings = - val getToolTipTextSize: int - val maxTypeCheckErrorsOutOfProjectContext: int - val maxTimeShareMilliseconds: int64 - val defaultFSharpBinariesDir: string - - [] + module internal FSharpCheckerResultsSettings = begin + val getToolTipTextSize : int + val maxTypeCheckErrorsOutOfProjectContext : int + val maxTimeShareMilliseconds : int64 + val defaultFSharpBinariesDir : string + end + [] type FSharpFindDeclFailureReason = | Unknown of message: string | NoSourceCode | ProvidedType of string | ProvidedMember of string - [] + [] type FSharpFindDeclResult = | DeclNotFound of FSharpFindDeclFailureReason | DeclFound of Range.range | ExternalDecl of assembly: string * externalSym: ExternalSymbol - [] + [] type internal NameResResult = | Members of (NameResolution.ItemWithInst list * TypedTreeOps.DisplayEnv * Range.range) | Cancel of TypedTreeOps.DisplayEnv * Range.range | Empty - [] + [] type ResolveOverloads = | Yes | No - [] + [] type GetPreciseCompletionListFromExprTypingsResult = | NoneBecauseTypecheckIsStaleAndTextChanged | NoneBecauseThereWereTypeErrors @@ -18419,10 +43494,10 @@ namespace FSharp.Compiler.SourceCodeServices (NameResolution.ItemWithInst list * TypedTreeOps.DisplayEnv * Range.range) * TypedTree.TType type Names = string list - [] + [] type internal TypeCheckInfo = - - new: _sTcConfig:CompilerConfig.TcConfig * g:TcGlobals.TcGlobals * + class + new : _sTcConfig:CompilerConfig.TcConfig * g:TcGlobals.TcGlobals * ccuSigForFile:TypedTree.ModuleOrNamespaceType * thisCcu:TypedTree.CcuThunk * tcImports:CompilerImports.TcImports * tcAccessRights:AccessibilityLogic.AccessorDomain * @@ -18434,80 +43509,80 @@ namespace FSharp.Compiler.SourceCodeServices implFileOpt:TypedTree.TypedImplFile option * openDeclarations:NameResolution.OpenDeclaration [] -> TypeCheckInfo member - GetBestDisplayEnvForPos: cursorPos:Range.pos -> + GetBestDisplayEnvForPos : cursorPos:Range.pos -> (NameResolution.NameResolutionEnv * AccessibilityLogic.AccessorDomain) * Range.range member - GetDeclarationListSymbols: parseResultsOpt:FSharpParseFileResults option * + GetDeclarationListSymbols : parseResultsOpt:FSharpParseFileResults option * line:int * lineStr:string * partialName:PartialLongName * getAllEntities:(unit -> AssemblySymbol list) -> FSharpSymbolUse list list member - GetDeclarationLocation: line:int * lineStr:string * colAtEndOfNames:int * + GetDeclarationLocation : line:int * lineStr:string * colAtEndOfNames:int * names:string list * preferFlag:bool option -> FSharpFindDeclResult member - GetDeclarations: parseResultsOpt:FSharpParseFileResults option * + GetDeclarations : parseResultsOpt:FSharpParseFileResults option * line:int * lineStr:string * partialName:PartialLongName * getAllEntities:(unit -> AssemblySymbol list) -> FSharpDeclarationListInfo member - GetF1Keyword: line:int * lineStr:string * colAtEndOfNames:int * + GetF1Keyword : line:int * lineStr:string * colAtEndOfNames:int * names:string list -> string option member - GetFormatSpecifierLocationsAndArity: unit -> (Range.range * int) [] + GetFormatSpecifierLocationsAndArity : unit -> (Range.range * int) [] member - GetMethods: line:int * lineStr:string * colAtEndOfNames:int * + GetMethods : line:int * lineStr:string * colAtEndOfNames:int * namesOpt:string list option -> FSharpMethodGroup member - GetMethodsAsSymbols: line:int * lineStr:string * colAtEndOfNames:int * + GetMethodsAsSymbols : line:int * lineStr:string * colAtEndOfNames:int * names:string list -> (FSharpSymbol list * TypedTreeOps.DisplayEnv * Range.range) option member - GetReferenceResolutionStructuredToolTipText: line:int * col:int -> + GetReferenceResolutionStructuredToolTipText : line:int * col:int -> FSharpToolTipText - member GetReferencedAssemblies: unit -> FSharpAssembly list + member GetReferencedAssemblies : unit -> FSharpAssembly list member - GetSemanticClassification: range:Range.range option -> - + GetSemanticClassification : range:Range.range option -> + struct (Range.range * SemanticClassificationType) [] member - GetStructuredToolTipText: line:int * lineStr:string * + GetStructuredToolTipText : line:int * lineStr:string * colAtEndOfNames:int * names:string list -> FSharpToolTipText member - GetSymbolUseAtLocation: line:int * lineStr:string * colAtEndOfNames:int * + GetSymbolUseAtLocation : line:int * lineStr:string * colAtEndOfNames:int * names:string list -> (FSharpSymbol * TypedTreeOps.DisplayEnv * Range.range) option member - GetVisibleNamespacesAndModulesAtPosition: cursorPos:Range.pos -> + GetVisibleNamespacesAndModulesAtPosition : cursorPos:Range.pos -> TypedTree.ModuleOrNamespaceRef list member - IsRelativeNameResolvable: cursorPos:Range.pos * plid:string list * + IsRelativeNameResolvable : cursorPos:Range.pos * plid:string list * item:NameResolution.Item -> bool member - IsRelativeNameResolvableFromSymbol: cursorPos:Range.pos * + IsRelativeNameResolvableFromSymbol : cursorPos:Range.pos * plid:string list * symbol:FSharpSymbol -> bool - override ToString: unit -> string - member AccessRights: AccessibilityLogic.AccessorDomain - member CcuSigForFile: TypedTree.ModuleOrNamespaceType - member ImplementationFile: TypedTree.TypedImplFile option - member OpenDeclarations: NameResolution.OpenDeclaration [] - member PartialAssemblySignatureForFile: FSharpAssemblySignature - member ScopeResolutions: NameResolution.TcResolutions - member ScopeSymbolUses: NameResolution.TcSymbolUses - member SymbolEnv: SymbolEnv - member TcGlobals: TcGlobals.TcGlobals - member TcImports: CompilerImports.TcImports - member ThisCcu: TypedTree.CcuThunk - + override ToString : unit -> string + member AccessRights : AccessibilityLogic.AccessorDomain + member CcuSigForFile : TypedTree.ModuleOrNamespaceType + member ImplementationFile : TypedTree.TypedImplFile option + member OpenDeclarations : NameResolution.OpenDeclaration [] + member PartialAssemblySignatureForFile : FSharpAssemblySignature + member ScopeResolutions : NameResolution.TcResolutions + member ScopeSymbolUses : NameResolution.TcSymbolUses + member SymbolEnv : SymbolEnv + member TcGlobals : TcGlobals.TcGlobals + member TcImports : CompilerImports.TcImports + member ThisCcu : TypedTree.CcuThunk + end type FSharpParsingOptions = { SourceFiles: string [] ConditionalCompilationDefines: string list @@ -18518,55 +43593,55 @@ namespace FSharp.Compiler.SourceCodeServices IsExe: bool } with static member - FromTcConfig: tcConfig:CompilerConfig.TcConfig * sourceFiles:string [] * + FromTcConfig : tcConfig:CompilerConfig.TcConfig * sourceFiles:string [] * isInteractive:bool -> FSharpParsingOptions static member - FromTcConfigBuilder: tcConfigB:CompilerConfig.TcConfigBuilder * + FromTcConfigBuilder : tcConfigB:CompilerConfig.TcConfigBuilder * sourceFiles:string [] * isInteractive:bool -> FSharpParsingOptions - member LastFileName: string - static member Default: FSharpParsingOptions - - module internal ParseAndCheckFile = + member LastFileName : string + static member Default : FSharpParsingOptions + end + module internal ParseAndCheckFile = begin type ErrorHandler = - - new: reportErrors:bool * mainInputFileName:string * + class + new : reportErrors:bool * mainInputFileName:string * errorSeverityOptions:ErrorLogger.FSharpErrorSeverityOptions * sourceText:Text.ISourceText * suggestNamesForErrors:bool -> ErrorHandler - member AnyErrors: bool - member CollectedDiagnostics: FSharpErrorInfo [] - member ErrorCount: int - member ErrorLogger: ErrorLogger.ErrorLogger - member - ErrorSeverityOptions: ErrorLogger.FSharpErrorSeverityOptions with set - - val getLightSyntaxStatus: + member AnyErrors : bool + member CollectedDiagnostics : FSharpErrorInfo [] + member ErrorCount : int + member ErrorLogger : ErrorLogger.ErrorLogger + member + ErrorSeverityOptions : ErrorLogger.FSharpErrorSeverityOptions with set + end + val getLightSyntaxStatus : fileName:string -> options:FSharpParsingOptions -> Lexhelp.LightSyntaxStatus - val createLexerFunction: + val createLexerFunction : fileName:string -> options:FSharpParsingOptions -> lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> errHandler:ErrorHandler -> ('a -> Parser.token) - val isFeatureSupported: _featureId:Features.LanguageFeature -> bool - val createLexbuf: sourceText:Text.ISourceText -> UnicodeLexing.Lexbuf - val matchBraces: + val isFeatureSupported : _featureId:Features.LanguageFeature -> bool + val createLexbuf : sourceText:Text.ISourceText -> UnicodeLexing.Lexbuf + val matchBraces : sourceText:Text.ISourceText * fileName:string * options:FSharpParsingOptions * userOpName:string * suggestNamesForErrors:bool -> (Range.range * Range.range) [] - val parseFile: + val parseFile : sourceText:Text.ISourceText * fileName:string * options:FSharpParsingOptions * userOpName:string * suggestNamesForErrors:bool -> FSharpErrorInfo [] * SyntaxTree.ParsedInput option * bool - val ApplyLoadClosure: + val ApplyLoadClosure : tcConfig:CompilerConfig.TcConfig * parsedMainInput:SyntaxTree.ParsedInput * mainInputFileName:string * loadClosure:ScriptClosure.LoadClosure option * tcImports:CompilerImports.TcImports * backgroundDiagnostics:(ErrorLogger.PhasedDiagnostic * FSharpErrorSeverity) [] -> unit - val CheckOneFile: + val CheckOneFile : parseResults:FSharpParseFileResults * sourceText:Text.ISourceText * mainInputFileName:string * projectFileName:string * tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * @@ -18577,24 +43652,24 @@ namespace FSharp.Compiler.SourceCodeServices reactorOps:IReactorOperations * userOpName:string * suggestNamesForErrors:bool -> Async> - - [] + end + [] type FSharpProjectContext = - - new: thisCcu:TypedTree.CcuThunk * assemblies:FSharpAssembly list * + class + new : thisCcu:TypedTree.CcuThunk * assemblies:FSharpAssembly list * ad:AccessibilityLogic.AccessorDomain -> FSharpProjectContext - member GetReferencedAssemblies: unit -> FSharpAssembly list - member AccessibilityRights: FSharpAccessibilityRights - - [] + member GetReferencedAssemblies : unit -> FSharpAssembly list + member AccessibilityRights : FSharpAccessibilityRights + end + [] type FSharpCheckFileResults = - - new: filename:string * errors:FSharpErrorInfo [] * + class + new : filename:string * errors:FSharpErrorInfo [] * scopeOptX:TypeCheckInfo option * dependencyFiles:string [] * builderX:IncrementalBuilder option * keepAssemblyContents:bool -> FSharpCheckFileResults static member - CheckOneFile: parseResults:FSharpParseFileResults * + CheckOneFile : parseResults:FSharpParseFileResults * sourceText:Text.ISourceText * mainInputFileName:string * projectFileName:string * tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * @@ -18612,12 +43687,12 @@ namespace FSharp.Compiler.SourceCodeServices keepAssemblyContents:bool * suggestNamesForErrors:bool -> Async static member - JoinErrors: isIncompleteTypeCheckEnvironment:bool * + JoinErrors : isIncompleteTypeCheckEnvironment:bool * creationErrors:FSharpErrorInfo [] * parseErrors:FSharpErrorInfo [] * tcErrors:FSharpErrorInfo [] -> FSharpErrorInfo [] static member - Make: mainInputFileName:string * projectFileName:string * + Make : mainInputFileName:string * projectFileName:string * tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * isIncompleteTypeCheckEnvironment:bool * builder:IncrementalBuilder * dependencyFiles:string [] * @@ -18635,95 +43710,95 @@ namespace FSharp.Compiler.SourceCodeServices openDeclarations:NameResolution.OpenDeclaration [] -> FSharpCheckFileResults static member - MakeEmpty: filename:string * creationErrors:FSharpErrorInfo [] * + MakeEmpty : filename:string * creationErrors:FSharpErrorInfo [] * keepAssemblyContents:bool -> FSharpCheckFileResults member - GetAllUsesOfAllSymbolsInFile: ?cancellationToken:System.Threading.CancellationToken -> + GetAllUsesOfAllSymbolsInFile : ?cancellationToken:System.Threading.CancellationToken -> seq member - GetDeclarationListInfo: parsedFileResults:FSharpParseFileResults option * + GetDeclarationListInfo : parsedFileResults:FSharpParseFileResults option * line:int * lineText:string * partialName:PartialLongName * ?getAllEntities:(unit -> AssemblySymbol list) -> FSharpDeclarationListInfo member - GetDeclarationListSymbols: parsedFileResults:FSharpParseFileResults option * + GetDeclarationListSymbols : parsedFileResults:FSharpParseFileResults option * line:int * lineText:string * partialName:PartialLongName * ?getAllEntities:(unit -> AssemblySymbol list) -> FSharpSymbolUse list list member - GetDeclarationLocation: line:int * colAtEndOfNames:int * + GetDeclarationLocation : line:int * colAtEndOfNames:int * lineText:string * names:string list * ?preferFlag:bool -> FSharpFindDeclResult member - GetDisplayContextForPos: cursorPos:Range.pos -> + GetDisplayContextForPos : cursorPos:Range.pos -> FSharpDisplayContext option member - GetF1Keyword: line:int * colAtEndOfNames:int * lineText:string * + GetF1Keyword : line:int * colAtEndOfNames:int * lineText:string * names:string list -> string option [] - member GetFormatSpecifierLocations: unit -> Range.range [] + member GetFormatSpecifierLocations : unit -> Range.range [] member - GetFormatSpecifierLocationsAndArity: unit -> (Range.range * int) [] + GetFormatSpecifierLocationsAndArity : unit -> (Range.range * int) [] member - GetMethods: line:int * colAtEndOfNames:int * lineText:string * + GetMethods : line:int * colAtEndOfNames:int * lineText:string * names:string list option -> FSharpMethodGroup member - GetMethodsAsSymbols: line:int * colAtEndOfNames:int * lineText:string * + GetMethodsAsSymbols : line:int * colAtEndOfNames:int * lineText:string * names:string list -> FSharpSymbolUse list option member - GetSemanticClassification: Range.range option -> - + GetSemanticClassification : Range.range option -> + struct (Range.range * SemanticClassificationType) [] member - GetStructuredToolTipText: line:int * colAtEndOfNames:int * + GetStructuredToolTipText : line:int * colAtEndOfNames:int * lineText:string * names:string list * tokenTag:int -> FSharpToolTipText member - GetSymbolAtLocation: line:int * colAtEndOfNames:int * lineStr:string * + GetSymbolAtLocation : line:int * colAtEndOfNames:int * lineStr:string * names:string list -> FSharpSymbol option member - GetSymbolUseAtLocation: line:int * colAtEndOfNames:int * + GetSymbolUseAtLocation : line:int * colAtEndOfNames:int * lineText:string * names:string list -> FSharpSymbolUse option member - GetToolTipText: line:int * colAtEndOfNames:int * lineText:string * + GetToolTipText : line:int * colAtEndOfNames:int * lineText:string * names:string list * tokenTag:int -> FSharpToolTipText member - GetUsesOfSymbolInFile: symbol:FSharpSymbol * + GetUsesOfSymbolInFile : symbol:FSharpSymbol * ?cancellationToken:System.Threading.CancellationToken -> FSharpSymbolUse [] member - GetVisibleNamespacesAndModulesAtPoint: Range.pos -> + GetVisibleNamespacesAndModulesAtPoint : Range.pos -> TypedTree.ModuleOrNamespaceRef [] member - IsRelativeNameResolvable: cursorPos:Range.pos * plid:string list * + IsRelativeNameResolvable : cursorPos:Range.pos * plid:string list * item:NameResolution.Item -> bool member - IsRelativeNameResolvableFromSymbol: cursorPos:Range.pos * + IsRelativeNameResolvableFromSymbol : cursorPos:Range.pos * plid:string list * symbol:FSharpSymbol -> bool - override ToString: unit -> string - member TryGetCurrentTcImports: unit -> CompilerImports.TcImports option - member DependencyFiles: string [] - member Errors: FSharpErrorInfo [] - member HasFullTypeCheckInfo: bool - member ImplementationFile: FSharpImplementationFileContents option - member OpenDeclarations: FSharpOpenDeclaration [] - member PartialAssemblySignature: FSharpAssemblySignature - member ProjectContext: FSharpProjectContext - - [] + override ToString : unit -> string + member TryGetCurrentTcImports : unit -> CompilerImports.TcImports option + member DependencyFiles : string [] + member Errors : FSharpErrorInfo [] + member HasFullTypeCheckInfo : bool + member ImplementationFile : FSharpImplementationFileContents option + member OpenDeclarations : FSharpOpenDeclaration [] + member PartialAssemblySignature : FSharpAssemblySignature + member ProjectContext : FSharpProjectContext + end + [] and FSharpCheckFileAnswer = | Aborted | Succeeded of FSharpCheckFileResults - [] + [] type FSharpCheckProjectResults = - - new: projectFileName:string * + class + new : projectFileName:string * tcConfigOption:CompilerConfig.TcConfig option * keepAssemblyContents:bool * errors:FSharpErrorInfo [] * details:(TcGlobals.TcGlobals * CompilerImports.TcImports * @@ -18736,53 +43811,53 @@ namespace FSharp.Compiler.SourceCodeServices TypedTree.TypedImplFile list option * string []) option -> FSharpCheckProjectResults member - GetAllUsesOfAllSymbols: ?cancellationToken:System.Threading.CancellationToken -> + GetAllUsesOfAllSymbols : ?cancellationToken:System.Threading.CancellationToken -> FSharpSymbolUse [] - member GetOptimizedAssemblyContents: unit -> FSharpAssemblyContents + member GetOptimizedAssemblyContents : unit -> FSharpAssemblyContents member - GetUsesOfSymbol: symbol:FSharpSymbol * + GetUsesOfSymbol : symbol:FSharpSymbol * ?cancellationToken:System.Threading.CancellationToken -> FSharpSymbolUse [] - override ToString: unit -> string - member AssemblyContents: FSharpAssemblyContents - member AssemblyFullName: string - member AssemblySignature: FSharpAssemblySignature - member DependencyFiles: string [] - member Errors: FSharpErrorInfo [] - member HasCriticalErrors: bool - member ProjectContext: FSharpProjectContext + override ToString : unit -> string + member AssemblyContents : FSharpAssemblyContents + member AssemblyFullName : string + member AssemblySignature : FSharpAssemblySignature + member DependencyFiles : string [] + member Errors : FSharpErrorInfo [] + member HasCriticalErrors : bool + member ProjectContext : FSharpProjectContext member - RawFSharpAssemblyData: CompilerConfig.IRawFSharpAssemblyData option + RawFSharpAssemblyData : CompilerConfig.IRawFSharpAssemblyData option member - TypedImplementationFiles: TcGlobals.TcGlobals * TypedTree.CcuThunk * + TypedImplementationFiles : TcGlobals.TcGlobals * TypedTree.CcuThunk * CompilerImports.TcImports * TypedTree.TypedImplFile list - + end type FsiInteractiveChecker = - - new: ReferenceResolver.Resolver * ops:IReactorOperations * + class + new : ReferenceResolver.Resolver * ops:IReactorOperations * tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * tcImports:CompilerImports.TcImports * tcState:ParseAndCheckInputs.TcState -> FsiInteractiveChecker member - ParseAndCheckInteraction: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + ParseAndCheckInteraction : ctok:AbstractIL.Internal.Library.CompilationThreadToken * sourceText:Text.ISourceText * ?userOpName:string -> Async - + end namespace FSharp.Compiler.SourceCodeServices type internal Layout = Internal.Utilities.StructuredFormat.Layout - module EnvMisc = - val braceMatchCacheSize: int - val parseFileCacheSize: int - val checkFileInProjectCacheSize: int - val projectCacheSizeDefault: int - val frameworkTcImportsCacheStrongSize: int - val maxMBDefault: int - + module EnvMisc = begin + val braceMatchCacheSize : int + val parseFileCacheSize : int + val checkFileInProjectCacheSize : int + val projectCacheSizeDefault : int + val frameworkTcImportsCacheStrongSize : int + val maxMBDefault : int + end type UnresolvedReferencesSet = | UnresolvedReferencesSet of CompilerConfig.UnresolvedAssemblyReference list type FSharpProjectOptions = @@ -18800,49 +43875,49 @@ namespace FSharp.Compiler.SourceCodeServices Stamp: int64 option } with static member - AreSameForChecking: options1:FSharpProjectOptions * + AreSameForChecking : options1:FSharpProjectOptions * options2:FSharpProjectOptions -> bool static member - UseSameProject: options1:FSharpProjectOptions * + UseSameProject : options1:FSharpProjectOptions * options2:FSharpProjectOptions -> bool - override ToString: unit -> string - member ProjectDirectory: string - member ProjectOptions: string [] - - [] + override ToString : unit -> string + member ProjectDirectory : string + member ProjectOptions : string [] + end + [] type IsResultObsolete = | IsResultObsolete of (unit -> bool) - module Helpers = - val AreSameForChecking2: + module Helpers = begin + val AreSameForChecking2 : (string * FSharpProjectOptions) * (string * FSharpProjectOptions) -> bool - val AreSubsumable2: + val AreSubsumable2 : (string * FSharpProjectOptions) * (string * FSharpProjectOptions) -> bool - val AreSameForParsing: - (string * int * 'a) * (string * int * 'a) -> bool when 'a: equality - val AreSimilarForParsing: - ('a * 'b * 'c) * ('a * 'd * 'e) -> bool when 'a: equality - val AreSameForChecking3: + val AreSameForParsing : + (string * int * 'a) * (string * int * 'a) -> bool when 'a : equality + val AreSimilarForParsing : + ('a * 'b * 'c) * ('a * 'd * 'e) -> bool when 'a : equality + val AreSameForChecking3 : (string * int * FSharpProjectOptions) * (string * int * FSharpProjectOptions) -> bool - val AreSubsumable3: + val AreSubsumable3 : (string * 'a * FSharpProjectOptions) * (string * 'b * FSharpProjectOptions) -> bool - - module CompileHelpers = - val mkCompilationErrorHandlers: + end + module CompileHelpers = begin + val mkCompilationErrorHandlers : unit -> ResizeArray * ErrorLogger.ErrorLogger * Driver.ErrorLoggerProvider - val tryCompile: + val tryCompile : errorLogger:ErrorLogger.ErrorLogger -> f:(ErrorLogger.Exiter -> unit) -> int - val compileFromArgs: + val compileFromArgs : ctok:AbstractIL.Internal.Library.CompilationThreadToken * argv:string [] * legacyReferenceResolver:ReferenceResolver.Resolver * tcImportsCapture:(CompilerImports.TcImports -> unit) option * dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * AbstractIL.IL.ILModuleDef -> unit) option -> FSharpErrorInfo [] * int - val compileFromAsts: + val compileFromAsts : ctok:AbstractIL.Internal.Library.CompilationThreadToken * legacyReferenceResolver:ReferenceResolver.Resolver * asts:SyntaxTree.ParsedInput list * assemblyName:string * outFile:string * @@ -18852,33 +43927,33 @@ namespace FSharp.Compiler.SourceCodeServices dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * AbstractIL.IL.ILModuleDef -> unit) option -> FSharpErrorInfo [] * int - val createDynamicAssembly: + val createDynamicAssembly : ctok:AbstractIL.Internal.Library.CompilationThreadToken * debugInfo:bool * tcImportsRef:CompilerImports.TcImports option ref * execute:bool * assemblyBuilderRef:System.Reflection.Emit.AssemblyBuilder option ref -> tcGlobals:TcGlobals.TcGlobals * outfile:string * ilxMainModule:AbstractIL.IL.ILModuleDef -> unit - val setOutputStreams: + val setOutputStreams : execute:(#System.IO.TextWriter * #System.IO.TextWriter) option -> unit - + end type SourceTextHash = int type FileName = string type FilePath = string type ProjectPath = string type FileVersion = int type ParseCacheLockToken = - + class interface AbstractIL.Internal.Library.LockToken - new: unit -> ParseCacheLockToken - + new : unit -> ParseCacheLockToken + end type ScriptClosureCacheToken = - + class interface AbstractIL.Internal.Library.LockToken - new: unit -> ScriptClosureCacheToken - + new : unit -> ScriptClosureCacheToken + end type BackgroundCompiler = - - new: legacyReferenceResolver:ReferenceResolver.Resolver * + class + new : legacyReferenceResolver:ReferenceResolver.Resolver * projectCacheSize:int * keepAssemblyContents:bool * keepAllBackgroundResolutions:bool * tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * @@ -18886,13 +43961,13 @@ namespace FSharp.Compiler.SourceCodeServices enableBackgroundItemKeyStoreAndSemanticClassification:bool * enablePartialTypeChecking:bool -> BackgroundCompiler member - CheckFileInProject: parseResults:FSharpParseFileResults * + CheckFileInProject : parseResults:FSharpParseFileResults * filename:string * fileVersion:int * sourceText:Text.ISourceText * options:FSharpProjectOptions * userOpName:string -> Async member - CheckFileInProjectAllowingStaleCachedResults: parseResults:FSharpParseFileResults * + CheckFileInProjectAllowingStaleCachedResults : parseResults:FSharpParseFileResults * filename:string * fileVersion:int * sourceText:Text.ISourceText * @@ -18900,7 +43975,7 @@ namespace FSharp.Compiler.SourceCodeServices userOpName:string -> Async member - private CheckOneFileImpl: parseResults:FSharpParseFileResults * + private CheckOneFileImpl : parseResults:FSharpParseFileResults * sourceText:Text.ISourceText * fileName:string * options:FSharpProjectOptions * fileVersion:int * builder:IncrementalBuilder * @@ -18917,43 +43992,43 @@ namespace FSharp.Compiler.SourceCodeServices userOpName:string -> Async member - CheckProjectInBackground: options:FSharpProjectOptions * + CheckProjectInBackground : options:FSharpProjectOptions * userOpName:string -> unit member - ClearCache: options:seq * userOpName:string -> + ClearCache : options:seq * userOpName:string -> unit - member ClearCachesAsync: userOpName:string -> Async - member CompleteAllQueuedOps: unit -> unit - member DownsizeCaches: userOpName:string -> Async + member ClearCachesAsync : userOpName:string -> Async + member CompleteAllQueuedOps : unit -> unit + member DownsizeCaches : userOpName:string -> Async member - FindReferencesInFile: filename:string * options:FSharpProjectOptions * + FindReferencesInFile : filename:string * options:FSharpProjectOptions * symbol:FSharpSymbol * canInvalidateProject:bool * userOpName:string -> Async> member - GetAssemblyData: options:FSharpProjectOptions * + GetAssemblyData : options:FSharpProjectOptions * ctok:AbstractIL.Internal.Library.CompilationThreadToken * userOpName:string -> AbstractIL.Internal.Library.Cancellable member - GetBackgroundCheckResultsForFileInProject: filename:string * + GetBackgroundCheckResultsForFileInProject : filename:string * options:FSharpProjectOptions * userOpName:string -> Async member - GetBackgroundParseResultsForFileInProject: filename:string * + GetBackgroundParseResultsForFileInProject : filename:string * options:FSharpProjectOptions * userOpName:string -> Async member - GetCachedCheckFileResult: builder:IncrementalBuilder * + GetCachedCheckFileResult : builder:IncrementalBuilder * filename:FileName * sourceText:Text.ISourceText * options:FSharpProjectOptions -> (FSharpParseFileResults * FSharpCheckFileResults) option member - GetProjectOptionsFromScript: filename:string * + GetProjectOptionsFromScript : filename:string * sourceText:Text.ISourceText * previewEnabled:bool option * loadedTimeStamp:System.DateTime option * @@ -18967,47 +44042,47 @@ namespace FSharp.Compiler.SourceCodeServices Async member - GetSemanticClassificationForFile: filename:string * + GetSemanticClassificationForFile : filename:string * options:FSharpProjectOptions * userOpName:string -> Async member - ImplicitlyStartCheckProjectInBackground: options:FSharpProjectOptions * + ImplicitlyStartCheckProjectInBackground : options:FSharpProjectOptions * userOpName:string -> unit member - InvalidateConfiguration: options:FSharpProjectOptions * + InvalidateConfiguration : options:FSharpProjectOptions * startBackgroundCompileIfAlreadySeen:bool option * userOpName:string -> unit member - NotifyProjectCleaned: options:FSharpProjectOptions * userOpName:string -> + NotifyProjectCleaned : options:FSharpProjectOptions * userOpName:string -> Async member - ParseAndCheckFileInProject: filename:string * fileVersion:int * + ParseAndCheckFileInProject : filename:string * fileVersion:int * sourceText:Text.ISourceText * options:FSharpProjectOptions * userOpName:string -> Async member - ParseAndCheckProject: options:FSharpProjectOptions * userOpName:string -> + ParseAndCheckProject : options:FSharpProjectOptions * userOpName:string -> Async member - private ParseAndCheckProjectImpl: options:FSharpProjectOptions * + private ParseAndCheckProjectImpl : options:FSharpProjectOptions * ctok:AbstractIL.Internal.Library.CompilationThreadToken * userOpName:string -> AbstractIL.Internal.Library.Cancellable member - ParseFile: filename:string * sourceText:Text.ISourceText * + ParseFile : filename:string * sourceText:Text.ISourceText * options:FSharpParsingOptions * userOpName:string -> Async member - ParseFileNoCache: filename:string * sourceText:Text.ISourceText * + ParseFileNoCache : filename:string * sourceText:Text.ISourceText * options:FSharpParsingOptions * userOpName:string -> Async member - RecordTypeCheckFileInProjectResults: filename:string * + RecordTypeCheckFileInProjectResults : filename:string * options:FSharpProjectOptions * parsingOptions:FSharpParsingOptions * parseResults:FSharpParseFileResults * @@ -19015,38 +44090,38 @@ namespace FSharp.Compiler.SourceCodeServices priorTimeStamp:System.DateTime * checkAnswer:FSharpCheckFileAnswer option * sourceText:SourceTextHash -> unit - member StopBackgroundCompile: unit -> unit + member StopBackgroundCompile : unit -> unit member - private TryGetLogicalTimeStampForProject: cache:CompilerConfig.TimeStampCache * + private TryGetLogicalTimeStampForProject : cache:CompilerConfig.TimeStampCache * ctok:AbstractIL.Internal.Library.CompilationThreadToken * options:FSharpProjectOptions * userOpName:string -> System.DateTime option member - TryGetRecentCheckResultsForFile: filename:string * + TryGetRecentCheckResultsForFile : filename:string * options:FSharpProjectOptions * sourceText:Text.ISourceText option * _userOpName:string -> (FSharpParseFileResults * FSharpCheckFileResults * FileVersion) option - member WaitForBackgroundCompile: unit -> unit - member BeforeBackgroundFileCheck: IEvent - member CurrentQueueLength: int - member FileChecked: IEvent - member FileParsed: IEvent - member FrameworkImportsCache: FrameworkImportsCache - member ImplicitlyStartBackgroundWork: bool - member ProjectChecked: IEvent - member Reactor: Reactor - member ReactorOps: IReactorOperations - static member GlobalForegroundParseCountStatistic: int - static member GlobalForegroundTypeCheckCountStatistic: int - - [] + member WaitForBackgroundCompile : unit -> unit + member BeforeBackgroundFileCheck : IEvent + member CurrentQueueLength : int + member FileChecked : IEvent + member FileParsed : IEvent + member FrameworkImportsCache : FrameworkImportsCache + member ImplicitlyStartBackgroundWork : bool + member ProjectChecked : IEvent + member Reactor : Reactor + member ReactorOps : IReactorOperations + static member GlobalForegroundParseCountStatistic : int + static member GlobalForegroundTypeCheckCountStatistic : int + end + [] type FSharpChecker = - - new: legacyReferenceResolver:ReferenceResolver.Resolver * + class + new : legacyReferenceResolver:ReferenceResolver.Resolver * projectCacheSize:int * keepAssemblyContents:bool * keepAllBackgroundResolutions:bool * tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * @@ -19054,7 +44129,7 @@ namespace FSharp.Compiler.SourceCodeServices enableBackgroundItemKeyStoreAndSemanticClassification:bool * enablePartialTypeChecking:bool -> FSharpChecker static member - Create: ?projectCacheSize:int * ?keepAssemblyContents:bool * + Create : ?projectCacheSize:int * ?keepAssemblyContents:bool * ?keepAllBackgroundResolutions:bool * ?legacyReferenceResolver:ReferenceResolver.Resolver * ?tryGetMetadataSnapshot:(string * System.DateTime -> @@ -19063,7 +44138,7 @@ namespace FSharp.Compiler.SourceCodeServices ?enableBackgroundItemKeyStoreAndSemanticClassification:bool * ?enablePartialTypeChecking:bool -> FSharpChecker member - CheckFileInProject: parseResults:FSharpParseFileResults * + CheckFileInProject : parseResults:FSharpParseFileResults * filename:string * fileVersion:int * sourceText:Text.ISourceText * options:FSharpProjectOptions * ?userOpName:string -> @@ -19071,42 +44146,42 @@ namespace FSharp.Compiler.SourceCodeServices [] member - CheckFileInProjectAllowingStaleCachedResults: parseResults:FSharpParseFileResults * + CheckFileInProjectAllowingStaleCachedResults : parseResults:FSharpParseFileResults * filename:string * fileVersion:int * source:string * options:FSharpProjectOptions * ?userOpName:string -> Async - member CheckMaxMemoryReached: unit -> unit + member CheckMaxMemoryReached : unit -> unit member - CheckProjectInBackground: options:FSharpProjectOptions * + CheckProjectInBackground : options:FSharpProjectOptions * ?userOpName:string -> unit member - ClearCache: options:seq * ?userOpName:string -> + ClearCache : options:seq * ?userOpName:string -> unit - member ClearCaches: ?userOpName:string -> unit - member ClearCachesAsync: ?userOpName:string -> Async + member ClearCaches : ?userOpName:string -> unit + member ClearCachesAsync : ?userOpName:string -> Async member - ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients: unit -> + ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients : unit -> unit member - Compile: argv:string [] * ?userOpName:string -> + Compile : argv:string [] * ?userOpName:string -> Async member - Compile: ast:SyntaxTree.ParsedInput list * assemblyName:string * + Compile : ast:SyntaxTree.ParsedInput list * assemblyName:string * outFile:string * dependencies:string list * ?pdbFile:string * ?executable:bool * ?noframework:bool * ?userOpName:string -> Async member - CompileToDynamicAssembly: otherFlags:string [] * + CompileToDynamicAssembly : otherFlags:string [] * execute:(System.IO.TextWriter * System.IO.TextWriter) option * ?userOpName:string -> Async member - CompileToDynamicAssembly: ast:SyntaxTree.ParsedInput list * + CompileToDynamicAssembly : ast:SyntaxTree.ParsedInput list * assemblyName:string * dependencies:string list * execute:(System.IO.TextWriter * @@ -19116,53 +44191,53 @@ namespace FSharp.Compiler.SourceCodeServices Async member - FindBackgroundReferencesInFile: filename:string * + FindBackgroundReferencesInFile : filename:string * options:FSharpProjectOptions * symbol:FSharpSymbol * ?canInvalidateProject:bool * ?userOpName:string -> Async> member - GetBackgroundCheckResultsForFileInProject: filename:string * + GetBackgroundCheckResultsForFileInProject : filename:string * options:FSharpProjectOptions * ?userOpName:string -> Async member - GetBackgroundParseResultsForFileInProject: filename:string * + GetBackgroundParseResultsForFileInProject : filename:string * options:FSharpProjectOptions * ?userOpName:string -> Async member - GetBackgroundSemanticClassificationForFile: filename:string * + GetBackgroundSemanticClassificationForFile : filename:string * options:FSharpProjectOptions * ?userOpName:string -> Async member - GetParsingOptionsFromCommandLineArgs: argv:string list * + GetParsingOptionsFromCommandLineArgs : argv:string list * ?isInteractive:bool -> FSharpParsingOptions * FSharpErrorInfo list member - GetParsingOptionsFromCommandLineArgs: sourceFiles:string list * + GetParsingOptionsFromCommandLineArgs : sourceFiles:string list * argv:string list * ?isInteractive:bool -> FSharpParsingOptions * FSharpErrorInfo list member - GetParsingOptionsFromProjectOptions: options:FSharpProjectOptions -> + GetParsingOptionsFromProjectOptions : options:FSharpProjectOptions -> FSharpParsingOptions * FSharpErrorInfo list member - GetProjectOptionsFromCommandLineArgs: projectFileName:string * + GetProjectOptionsFromCommandLineArgs : projectFileName:string * argv:string [] * ?loadedTimeStamp:System.DateTime * ?extraProjectInfo:obj -> FSharpProjectOptions member - GetProjectOptionsFromScript: filename:string * source:Text.ISourceText * + GetProjectOptionsFromScript : filename:string * source:Text.ISourceText * ?previewEnabled:bool * ?loadedTimeStamp:System.DateTime * ?otherFlags:string [] * ?useFsiAuxLib:bool * @@ -19172,135 +44247,142 @@ namespace FSharp.Compiler.SourceCodeServices ?optionsStamp:int64 * ?userOpName:string -> Async - member InvalidateAll: unit -> unit + member InvalidateAll : unit -> unit member - InvalidateConfiguration: options:FSharpProjectOptions * + InvalidateConfiguration : options:FSharpProjectOptions * ?startBackgroundCompile:bool * ?userOpName:string -> unit [] member - MatchBraces: filename:string * source:string * + MatchBraces : filename:string * source:string * options:FSharpProjectOptions * ?userOpName:string -> Async<(Range.range * Range.range) []> member - MatchBraces: filename:string * sourceText:Text.ISourceText * + MatchBraces : filename:string * sourceText:Text.ISourceText * options:FSharpParsingOptions * ?userOpName:string -> Async<(Range.range * Range.range) []> member - NotifyProjectCleaned: options:FSharpProjectOptions * ?userOpName:string -> + NotifyProjectCleaned : options:FSharpProjectOptions * ?userOpName:string -> Async member - ParseAndCheckFileInProject: filename:string * fileVersion:int * + ParseAndCheckFileInProject : filename:string * fileVersion:int * sourceText:Text.ISourceText * options:FSharpProjectOptions * ?userOpName:string -> Async member - ParseAndCheckProject: options:FSharpProjectOptions * ?userOpName:string -> + ParseAndCheckProject : options:FSharpProjectOptions * ?userOpName:string -> Async member - ParseFile: filename:string * sourceText:Text.ISourceText * + ParseFile : filename:string * sourceText:Text.ISourceText * options:FSharpParsingOptions * ?userOpName:string -> Async [] member - ParseFileInProject: filename:string * source:string * + ParseFileInProject : filename:string * source:string * options:FSharpProjectOptions * ?userOpName:string -> Async member - ParseFileNoCache: filename:string * sourceText:Text.ISourceText * + ParseFileNoCache : filename:string * sourceText:Text.ISourceText * options:FSharpParsingOptions * ?userOpName:string -> Async member - StartBackgroundCompile: options:FSharpProjectOptions * + StartBackgroundCompile : options:FSharpProjectOptions * ?userOpName:string -> unit - member StopBackgroundCompile: unit -> unit - member TokenizeFile: source:string -> FSharpTokenInfo [] [] + member StopBackgroundCompile : unit -> unit + member TokenizeFile : source:string -> FSharpTokenInfo [] [] member - TokenizeLine: line:string * state:FSharpTokenizerLexState -> + TokenizeLine : line:string * state:FSharpTokenizerLexState -> FSharpTokenInfo [] * FSharpTokenizerLexState member - TryGetRecentCheckResultsForFile: filename:string * + TryGetRecentCheckResultsForFile : filename:string * options:FSharpProjectOptions * ?sourceText:Text.ISourceText * ?userOpName:string -> (FSharpParseFileResults * FSharpCheckFileResults * FileVersion) option - member WaitForBackgroundCompile: unit -> unit - member BeforeBackgroundFileCheck: IEvent - member CurrentQueueLength: int - member FileChecked: IEvent - member FileParsed: IEvent - member internal FrameworkImportsCache: FrameworkImportsCache - member ImplicitlyStartBackgroundWork: bool - member MaxMemory: int - member MaxMemoryReached: IEvent - member PauseBeforeBackgroundWork: int - member ProjectChecked: IEvent - member ReactorOps: IReactorOperations - member ReferenceResolver: ReferenceResolver.Resolver - static member GlobalForegroundParseCountStatistic: int - static member GlobalForegroundTypeCheckCountStatistic: int + member WaitForBackgroundCompile : unit -> unit + member BeforeBackgroundFileCheck : IEvent + member CurrentQueueLength : int + member FileChecked : IEvent + member FileParsed : IEvent + member internal FrameworkImportsCache : FrameworkImportsCache + member ImplicitlyStartBackgroundWork : bool + member MaxMemory : int + member MaxMemoryReached : IEvent + member PauseBeforeBackgroundWork : int + member ProjectChecked : IEvent + member ReactorOps : IReactorOperations + member ReferenceResolver : ReferenceResolver.Resolver + static member GlobalForegroundParseCountStatistic : int + static member GlobalForegroundTypeCheckCountStatistic : int [] - static member Instance: FSharpChecker - - [] + static member Instance : FSharpChecker + end + [] type CompilerEnvironment = - + class static member - BinFolderOfDefaultFSharpCompiler: ?probePoint:string -> string option - - module CompilerEnvironment = - val DefaultReferencesForOrphanSources: + BinFolderOfDefaultFSharpCompiler : ?probePoint:string -> string option + end + module CompilerEnvironment = begin + val DefaultReferencesForOrphanSources : assumeDotNetFramework:bool -> string list - val GetCompilationDefinesForEditing: + val GetCompilationDefinesForEditing : parsingOptions:FSharpParsingOptions -> string list - val IsCheckerSupportedSubcategory: string -> bool - - module DebuggerEnvironment = - val GetLanguageID: unit -> System.Guid - - module PrettyNaming = - val IsIdentifierPartCharacter: char -> bool - val IsLongIdentifierPartCharacter: char -> bool - val IsOperatorName: string -> bool - val GetLongNameFromString: string -> string list - val FormatAndOtherOverloadsString: System.Int32 -> string - val QuoteIdentifierIfNeeded: string -> string - val KeywordNames: string list - - module FSharpFileUtilities = - val isScriptFile: string -> bool + val IsCheckerSupportedSubcategory : string -> bool + end + module DebuggerEnvironment = begin + val GetLanguageID : unit -> System.Guid + end + module PrettyNaming = begin + val IsIdentifierPartCharacter : char -> bool + val IsLongIdentifierPartCharacter : char -> bool + val IsOperatorName : string -> bool + val GetLongNameFromString : string -> string list + val FormatAndOtherOverloadsString : System.Int32 -> string + val QuoteIdentifierIfNeeded : string -> string + val KeywordNames : string list + end + module FSharpFileUtilities = begin + val isScriptFile : string -> bool + end +namespace FSharp.Compiler.SourceCodeServices + module ErrorResolutionHints = begin + val getSuggestedNames : + suggestionsF:ErrorLogger.Suggestions -> + unresolvedIdentifier:string -> seq + end namespace FSharp.Compiler.SourceCodeServices - module Structure = - module Range = - val endToEnd: r1:Range.range -> r2:Range.range -> Range.range - val endToStart: r1:Range.range -> r2:Range.range -> Range.range - val startToEnd: r1:Range.range -> r2:Range.range -> Range.range - val startToStart: r1:Range.range -> r2:Range.range -> Range.range - val modStart: m:int -> r:Range.range -> Range.range - val modEnd: m:int -> r:Range.range -> Range.range - val modBoth: modStart:int -> modEnd:int -> r:Range.range -> Range.range - - val longIdentRange: longId:SyntaxTree.LongIdent -> Range.range - val rangeOfTypeArgsElse: + module Structure = begin + module Range = begin + val endToEnd : r1:Range.range -> r2:Range.range -> Range.range + val endToStart : r1:Range.range -> r2:Range.range -> Range.range + val startToEnd : r1:Range.range -> r2:Range.range -> Range.range + val startToStart : r1:Range.range -> r2:Range.range -> Range.range + val modStart : m:int -> r:Range.range -> Range.range + val modEnd : m:int -> r:Range.range -> Range.range + val modBoth : modStart:int -> modEnd:int -> r:Range.range -> Range.range + end + val longIdentRange : longId:SyntaxTree.LongIdent -> Range.range + val rangeOfTypeArgsElse : other:Range.range -> typeArgs:SyntaxTree.SynTyparDecl list -> Range.range - val rangeOfSynPatsElse: + val rangeOfSynPatsElse : other:Range.range -> synPats:SyntaxTree.SynSimplePat list -> Range.range - [] + [] type Collapse = | Below | Same - [] + [] type Scope = | Open | Namespace @@ -19350,9 +44432,9 @@ namespace FSharp.Compiler.SourceCodeServices | Comment | XmlDocComment with - override ToString: unit -> string - - [] + override ToString : unit -> string + end + [] type ScopeRange = { Scope: Scope Collapse: Collapse @@ -19363,53 +44445,53 @@ namespace FSharp.Compiler.SourceCodeServices type CommentType = | SingleLine | XmlDoc - [] + [] type CommentList = { Lines: ResizeArray Type: CommentType } with static member - New: ty:CommentType -> lineStr:(LineNumber * LineStr) -> CommentList - - val getOutliningRanges: + New : ty:CommentType -> lineStr:(LineNumber * LineStr) -> CommentList + end + val getOutliningRanges : sourceLines:string [] -> parsedInput:SyntaxTree.ParsedInput -> seq - + end namespace FSharp.Compiler.SourceCodeServices - module UnusedOpens = - val symbolHash: System.Collections.Generic.IEqualityComparer + module UnusedOpens = begin + val symbolHash : System.Collections.Generic.IEqualityComparer type OpenedModule = - - new: entity:FSharpEntity * isNestedAutoOpen:bool -> OpenedModule - member RevealedSymbolsContains: symbol:FSharpSymbol -> bool - member Entity: FSharpEntity - member IsNestedAutoOpen: bool - + class + new : entity:FSharpEntity * isNestedAutoOpen:bool -> OpenedModule + member RevealedSymbolsContains : symbol:FSharpSymbol -> bool + member Entity : FSharpEntity + member IsNestedAutoOpen : bool + end type OpenedModuleGroup = { OpenedModules: OpenedModule [] } with - static member Create: modul:FSharpEntity -> OpenedModuleGroup - + static member Create : modul:FSharpEntity -> OpenedModuleGroup + end type OpenStatement = { OpenedGroups: OpenedModuleGroup list Range: Range.range AppliedScope: Range.range } - val getOpenStatements: + val getOpenStatements : openDeclarations:FSharpOpenDeclaration [] -> OpenStatement [] - val filterSymbolUses: + val filterSymbolUses : getSourceLineStr:(int -> string) -> symbolUses:seq -> FSharpSymbolUse [] - val splitSymbolUses: + val splitSymbolUses : symbolUses:FSharpSymbolUse [] -> FSharpSymbolUse [] * FSharpSymbolUse [] - val isOpenStatementUsed: + val isOpenStatementUsed : symbolUses2:FSharpSymbolUse [] -> symbolUsesRangesByDeclaringEntity:System.Collections.Generic.Dictionary -> usedModules:System.Collections.Generic.Dictionary -> openStatement:OpenStatement -> bool - val filterOpenStatementsIncremental: + val filterOpenStatementsIncremental : symbolUses2:FSharpSymbolUse [] -> symbolUsesRangesByDeclaringEntity:System.Collections.Generic.Dictionary -> @@ -19417,280 +44499,280 @@ namespace FSharp.Compiler.SourceCodeServices usedModules:System.Collections.Generic.Dictionary -> acc:OpenStatement list -> Async - val entityHash: System.Collections.Generic.IEqualityComparer - val filterOpenStatements: + val entityHash : System.Collections.Generic.IEqualityComparer + val filterOpenStatements : symbolUses1:FSharpSymbolUse [] * symbolUses2:FSharpSymbolUse [] -> openStatements:OpenStatement [] -> Async - val getUnusedOpens: + val getUnusedOpens : checkFileResults:FSharpCheckFileResults * getSourceLineStr:(int -> string) -> Async - - module SimplifyNames = + end + module SimplifyNames = begin type SimplifiableRange = { Range: Range.range RelativeName: string } - val getPlidLength: plid:string list -> int - val getSimplifiableNames: + val getPlidLength : plid:string list -> int + val getSimplifiableNames : checkFileResults:FSharpCheckFileResults * getSourceLineStr:(int -> string) -> Async> - - module UnusedDeclarations = - val isPotentiallyUnusedDeclaration: symbol:FSharpSymbol -> bool - val getUnusedDeclarationRanges: + end + module UnusedDeclarations = begin + val isPotentiallyUnusedDeclaration : symbol:FSharpSymbol -> bool + val getUnusedDeclarationRanges : symbolsUses:seq -> isScript:bool -> seq - val getUnusedDeclarations: + val getUnusedDeclarations : checkFileResults:FSharpCheckFileResults * isScriptFile:bool -> Async> - + end namespace FSharp.Compiler.Interactive - module Shell = - [] + module Shell = begin + [] type FsiValue = - - new: reflectionValue:obj * reflectionType:System.Type * + class + new : reflectionValue:obj * reflectionType:System.Type * fsharpType:SourceCodeServices.FSharpType -> FsiValue - member FSharpType: SourceCodeServices.FSharpType - member ReflectionType: System.Type - member ReflectionValue: obj - - [] + member FSharpType : SourceCodeServices.FSharpType + member ReflectionType : System.Type + member ReflectionValue : obj + end + [] type FsiBoundValue = - - new: name:string * value:FsiValue -> FsiBoundValue - member Name: string - member Value: FsiValue - - module internal Utilities = + class + new : name:string * value:FsiValue -> FsiBoundValue + member Name : string + member Value : FsiValue + end + module internal Utilities = begin type IAnyToLayoutCall = interface abstract member - AnyToLayout: Internal.Utilities.StructuredFormat.FormatOptions * + AnyToLayout : Internal.Utilities.StructuredFormat.FormatOptions * obj * System.Type -> Internal.Utilities.StructuredFormat.Layout abstract member - FsiAnyToLayout: Internal.Utilities.StructuredFormat.FormatOptions * + FsiAnyToLayout : Internal.Utilities.StructuredFormat.FormatOptions * obj * System.Type -> Internal.Utilities.StructuredFormat.Layout - + end type private AnyToLayoutSpecialization<'T> = - + class interface IAnyToLayoutCall - new: unit -> AnyToLayoutSpecialization<'T> - - val getAnyToLayoutCall: ty:System.Type -> IAnyToLayoutCall - val callStaticMethod: + new : unit -> AnyToLayoutSpecialization<'T> + end + val getAnyToLayoutCall : ty:System.Type -> IAnyToLayoutCall + val callStaticMethod : ty:System.Type -> name:string -> args:obj list -> obj - val ignoreAllErrors: f:(unit -> unit) -> unit - val getMember: + val ignoreAllErrors : f:(unit -> unit) -> unit + val getMember : name:string -> memberType:System.Reflection.MemberTypes -> attr:System.Reflection.BindingFlags -> declaringType:System.Type -> System.Reflection.MemberInfo [] - val tryFindMember: + val tryFindMember : name:string -> memberType:System.Reflection.MemberTypes -> declaringType:System.Type -> System.Reflection.MemberInfo option - val getInstanceProperty: obj:obj -> nm:string -> 'a - val setInstanceProperty: obj:obj -> nm:string -> v:obj -> 'a - val callInstanceMethod0: + val getInstanceProperty : obj:obj -> nm:string -> 'a + val setInstanceProperty : obj:obj -> nm:string -> v:obj -> 'a + val callInstanceMethod0 : obj:obj -> typeArgs:System.Type [] -> nm:string -> 'a - val callInstanceMethod1: + val callInstanceMethod1 : obj:obj -> typeArgs:System.Type [] -> nm:string -> v:obj -> 'a - val callInstanceMethod3: + val callInstanceMethod3 : obj:obj -> typeArgs:System.Type [] -> nm:string -> v1:obj -> v2:obj -> v3:obj -> 'a - val colorPrintL: + val colorPrintL : outWriter:System.IO.TextWriter -> opts:Internal.Utilities.StructuredFormat.FormatOptions -> layout:Internal.Utilities.StructuredFormat.Layout -> unit - val reportError: + val reportError : m:Range.range -> Microsoft.DotNet.DependencyManager.ResolvingErrorReport - val getOutputDir: tcConfigB:CompilerConfig.TcConfigBuilder -> string - + val getOutputDir : tcConfigB:CompilerConfig.TcConfigBuilder -> string + end type internal FsiTimeReporter = - - new: outWriter:System.IO.TextWriter -> FsiTimeReporter - member TimeOp: f:(unit -> 'b) -> 'b - member TimeOpIf: flag:bool -> f:(unit -> 'a) -> 'a - + class + new : outWriter:System.IO.TextWriter -> FsiTimeReporter + member TimeOp : f:(unit -> 'b) -> 'b + member TimeOpIf : flag:bool -> f:(unit -> 'a) -> 'a + end type internal FsiValuePrinterMode = | PrintExpr | PrintDecl - [] + [] type EvaluationEventArgs = - + class inherit System.EventArgs - new: fsivalue:FsiValue option * + new : fsivalue:FsiValue option * symbolUse:SourceCodeServices.FSharpSymbolUse * decl:SourceCodeServices.FSharpImplementationFileDeclaration -> EvaluationEventArgs - member FsiValue: FsiValue option - member - ImplementationDeclaration: SourceCodeServices.FSharpImplementationFileDeclaration - member Name: string - member Symbol: SourceCodeServices.FSharpSymbol - member SymbolUse: SourceCodeServices.FSharpSymbolUse - - [] + member FsiValue : FsiValue option + member + ImplementationDeclaration : SourceCodeServices.FSharpImplementationFileDeclaration + member Name : string + member Symbol : SourceCodeServices.FSharpSymbol + member SymbolUse : SourceCodeServices.FSharpSymbolUse + end + [] type FsiEvaluationSessionHostConfig = - - new: unit -> FsiEvaluationSessionHostConfig - abstract member EventLoopInvoke: codeToRun:(unit -> 'T) -> 'T - abstract member EventLoopRun: unit -> bool - abstract member EventLoopScheduleRestart: unit -> unit + class + new : unit -> FsiEvaluationSessionHostConfig + abstract member EventLoopInvoke : codeToRun:(unit -> 'T) -> 'T + abstract member EventLoopRun : unit -> bool + abstract member EventLoopScheduleRestart : unit -> unit abstract member - GetOptionalConsoleReadLine: probeToSeeIfConsoleWorks:bool -> + GetOptionalConsoleReadLine : probeToSeeIfConsoleWorks:bool -> (unit -> string) option - abstract member ReportUserCommandLineArgs: string [] -> unit - abstract member StartServer: fsiServerName:string -> unit + abstract member ReportUserCommandLineArgs : string [] -> unit + abstract member StartServer : fsiServerName:string -> unit member - internal TriggerEvaluation: value:FsiValue option * + internal TriggerEvaluation : value:FsiValue option * symbolUse:SourceCodeServices.FSharpSymbolUse * decl:SourceCodeServices.FSharpImplementationFileDeclaration -> unit abstract member - AddedPrinters: Choice<(System.Type * (obj -> string)), + AddedPrinters : Choice<(System.Type * (obj -> string)), (System.Type * (obj -> obj))> list - abstract member FloatingPointFormat: string - abstract member FormatProvider: System.IFormatProvider - member OnEvaluation: IEvent - abstract member PrintDepth: int - abstract member PrintLength: int - abstract member PrintSize: int - abstract member PrintWidth: int - abstract member ShowDeclarationValues: bool - abstract member ShowIEnumerable: bool - abstract member ShowProperties: bool - abstract member UseFsiAuxLib: bool - + abstract member FloatingPointFormat : string + abstract member FormatProvider : System.IFormatProvider + member OnEvaluation : IEvent + abstract member PrintDepth : int + abstract member PrintLength : int + abstract member PrintSize : int + abstract member PrintWidth : int + abstract member ShowDeclarationValues : bool + abstract member ShowIEnumerable : bool + abstract member ShowProperties : bool + abstract member UseFsiAuxLib : bool + end type internal FsiValuePrinter = - - new: fsi:FsiEvaluationSessionHostConfig * g:TcGlobals.TcGlobals * + class + new : fsi:FsiEvaluationSessionHostConfig * g:TcGlobals.TcGlobals * generateDebugInfo:bool * resolveAssemblyRef:(AbstractIL.IL.ILAssemblyRef -> Choice option) * outWriter:System.IO.TextWriter -> FsiValuePrinter - member FormatValue: obj:obj * objTy:System.Type -> string + member FormatValue : obj:obj * objTy:System.Type -> string member - GetEvaluationContext: emEnv:AbstractIL.ILRuntimeWriter.emEnv -> + GetEvaluationContext : emEnv:AbstractIL.ILRuntimeWriter.emEnv -> IlxGen.ExecutionContext member - GetFsiPrintOptions: unit -> + GetFsiPrintOptions : unit -> Internal.Utilities.StructuredFormat.FormatOptions member - InvokeDeclLayout: emEnv:AbstractIL.ILRuntimeWriter.emEnv * + InvokeDeclLayout : emEnv:AbstractIL.ILRuntimeWriter.emEnv * ilxGenerator:IlxGen.IlxAssemblyGenerator * v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout option member - InvokeExprPrinter: denv:TypedTreeOps.DisplayEnv * + InvokeExprPrinter : denv:TypedTreeOps.DisplayEnv * emEnv:AbstractIL.ILRuntimeWriter.emEnv * ilxGenerator:IlxGen.IlxAssemblyGenerator * vref:TypedTree.Val -> unit member - PrintValue: printMode:FsiValuePrinterMode * + PrintValue : printMode:FsiValuePrinterMode * opts:Internal.Utilities.StructuredFormat.FormatOptions * x:obj * ty:System.Type -> Internal.Utilities.StructuredFormat.Layout - + end type internal FsiStdinSyphon = - - new: errorWriter:System.IO.TextWriter -> FsiStdinSyphon - member Add: str:string -> unit - member GetLine: filename:string -> i:int -> string + class + new : errorWriter:System.IO.TextWriter -> FsiStdinSyphon + member Add : str:string -> unit + member GetLine : filename:string -> i:int -> string member - PrintError: tcConfig:CompilerConfig.TcConfigBuilder * + PrintError : tcConfig:CompilerConfig.TcConfigBuilder * err:ErrorLogger.PhasedDiagnostic -> unit - member Reset: unit -> unit - + member Reset : unit -> unit + end type internal FsiConsoleOutput = - - new: tcConfigB:CompilerConfig.TcConfigBuilder * + class + new : tcConfigB:CompilerConfig.TcConfigBuilder * outWriter:System.IO.TextWriter * errorWriter:System.IO.TextWriter -> FsiConsoleOutput - member uprintf: fmt:Printf.TextWriterFormat<'f> -> 'f - member uprintfn: fmt:Printf.TextWriterFormat<'e> -> 'e - member uprintfnn: fmt:Printf.TextWriterFormat<'d,unit> -> 'd - member uprintnf: fmt:Printf.TextWriterFormat<'c> -> 'c - member uprintnfn: fmt:Printf.TextWriterFormat<'b> -> 'b - member uprintnfnn: fmt:Printf.TextWriterFormat<'a,unit> -> 'a - member Error: System.IO.TextWriter - member Out: System.IO.TextWriter - + member uprintf : fmt:Printf.TextWriterFormat<'f> -> 'f + member uprintfn : fmt:Printf.TextWriterFormat<'e> -> 'e + member uprintfnn : fmt:Printf.TextWriterFormat<'d,unit> -> 'd + member uprintnf : fmt:Printf.TextWriterFormat<'c> -> 'c + member uprintnfn : fmt:Printf.TextWriterFormat<'b> -> 'b + member uprintnfnn : fmt:Printf.TextWriterFormat<'a,unit> -> 'a + member Error : System.IO.TextWriter + member Out : System.IO.TextWriter + end type internal ErrorLoggerThatStopsOnFirstError = - + class inherit ErrorLogger.ErrorLogger - new: tcConfigB:CompilerConfig.TcConfigBuilder * + new : tcConfigB:CompilerConfig.TcConfigBuilder * fsiStdinSyphon:FsiStdinSyphon * fsiConsoleOutput:FsiConsoleOutput -> ErrorLoggerThatStopsOnFirstError override - DiagnosticSink: err:ErrorLogger.PhasedDiagnostic * isError:bool -> + DiagnosticSink : err:ErrorLogger.PhasedDiagnostic * isError:bool -> unit - member ResetErrorCount: unit -> unit - member SetError: unit -> unit - override ErrorCount: int - + member ResetErrorCount : unit -> unit + member SetError : unit -> unit + override ErrorCount : int + end type ErrorLogger with - member CheckForErrors: unit -> bool + member CheckForErrors : unit -> bool type ErrorLogger with - member AbortOnError: fsiConsoleOutput:FsiConsoleOutput -> unit - val internal directoryName: s:string -> string + member AbortOnError : fsiConsoleOutput:FsiConsoleOutput -> unit + val internal directoryName : s:string -> string type internal FsiCommandLineOptions = - - new: fsi:FsiEvaluationSessionHostConfig * argv:string [] * + class + new : fsi:FsiEvaluationSessionHostConfig * argv:string [] * tcConfigB:CompilerConfig.TcConfigBuilder * fsiConsoleOutput:FsiConsoleOutput -> FsiCommandLineOptions - member ShowBanner: unit -> unit - member ShowHelp: m:Range.range -> unit - member - DependencyProvider: Microsoft.DotNet.DependencyManager.DependencyProvider - member EnableConsoleKeyProcessing: bool - member FsiLCID: int option - member FsiServerInputCodePage: int option - member FsiServerName: string - member FsiServerOutputCodePage: int option - member Gui: bool - member Interact: bool - member IsInteractiveServer: bool - member PeekAheadOnConsoleToPermitTyping: bool - member ProbeToSeeIfConsoleWorks: bool - member ShowILCode: bool - member ShowTypes: bool - member SourceFiles: (string * bool) list - - val internal SetCurrentUICultureForThread: + member ShowBanner : unit -> unit + member ShowHelp : m:Range.range -> unit + member + DependencyProvider : Microsoft.DotNet.DependencyManager.DependencyProvider + member EnableConsoleKeyProcessing : bool + member FsiLCID : int option + member FsiServerInputCodePage : int option + member FsiServerName : string + member FsiServerOutputCodePage : int option + member Gui : bool + member Interact : bool + member IsInteractiveServer : bool + member PeekAheadOnConsoleToPermitTyping : bool + member ProbeToSeeIfConsoleWorks : bool + member ShowILCode : bool + member ShowTypes : bool + member SourceFiles : (string * bool) list + end + val internal SetCurrentUICultureForThread : lcid:int option -> System.IDisposable - val internal InstallErrorLoggingOnThisThread: + val internal InstallErrorLoggingOnThisThread : errorLogger:ErrorLogger.ErrorLogger -> unit - val internal SetServerCodePages: fsiOptions:FsiCommandLineOptions -> unit + val internal SetServerCodePages : fsiOptions:FsiCommandLineOptions -> unit type internal FsiConsolePrompt = - - new: fsiOptions:FsiCommandLineOptions * + class + new : fsiOptions:FsiCommandLineOptions * fsiConsoleOutput:FsiConsoleOutput -> FsiConsolePrompt - member Print: unit -> unit - member PrintAhead: unit -> unit - member SkipNext: unit -> unit - member FsiOptions: FsiCommandLineOptions - + member Print : unit -> unit + member PrintAhead : unit -> unit + member SkipNext : unit -> unit + member FsiOptions : FsiCommandLineOptions + end type internal FsiConsoleInput = - - new: fsi:FsiEvaluationSessionHostConfig * + class + new : fsi:FsiEvaluationSessionHostConfig * fsiOptions:FsiCommandLineOptions * inReader:System.IO.TextReader * outWriter:System.IO.TextWriter -> FsiConsoleInput - member TryGetConsole: unit -> (unit -> string) option - member TryGetFirstLine: unit -> string option - member WaitForInitialConsoleInput: unit -> unit - member In: System.IO.TextReader - + member TryGetConsole : unit -> (unit -> string) option + member TryGetFirstLine : unit -> string option + member WaitForInitialConsoleInput : unit -> unit + member In : System.IO.TextReader + end type internal FsiInteractionStepStatus = | CtrlC | EndOfFile | Completed of FsiValue option | CompletedWithAlreadyReportedError | CompletedWithReportedError of exn - [] + [] type internal FsiDynamicCompilerState = { optEnv: Optimizer.IncrementalOptimizationEnv emEnv: AbstractIL.ILRuntimeWriter.emEnv @@ -19701,14 +44783,14 @@ namespace FSharp.Compiler.Interactive boundValues: AbstractIL.Internal.Library.NameMap timing: bool debugBreak: bool } - val internal WithImplicitHome: + val internal WithImplicitHome : tcConfigB:CompilerConfig.TcConfigBuilder * dir:string -> f:(unit -> 'a) -> 'a - val internal convertReflectionTypeToILTypeRef: + val internal convertReflectionTypeToILTypeRef : reflectionTy:System.Type -> AbstractIL.IL.ILTypeRef - val internal convertReflectionTypeToILType: + val internal convertReflectionTypeToILType : reflectionTy:System.Type -> AbstractIL.IL.ILType - val internal mkBoundValueTypedImpl: + val internal mkBoundValueTypedImpl : tcGlobals:TcGlobals.TcGlobals -> m:Range.range -> moduleName:string -> @@ -19717,8 +44799,8 @@ namespace FSharp.Compiler.Interactive TypedTree.ModuleOrNamespace * TypedTree.Val * TypedTree.TypedImplFile type internal FsiDynamicCompiler = - - new: fsi:FsiEvaluationSessionHostConfig * timeReporter:FsiTimeReporter * + class + new : fsi:FsiEvaluationSessionHostConfig * timeReporter:FsiTimeReporter * tcConfigB:CompilerConfig.TcConfigBuilder * tcLockObject:obj * outWriter:System.IO.TextWriter * tcImports:CompilerImports.TcImports * @@ -19729,31 +44811,31 @@ namespace FSharp.Compiler.Interactive Choice option) -> FsiDynamicCompiler member - AddBoundValue: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + AddBoundValue : ctok:AbstractIL.Internal.Library.CompilationThreadToken * errorLogger:ErrorLogger.ErrorLogger * istate:FsiDynamicCompilerState * name:string * value:obj -> FsiDynamicCompilerState * FsiInteractionStepStatus member - BuildItBinding: expr:SyntaxTree.SynExpr -> + BuildItBinding : expr:SyntaxTree.SynExpr -> SyntaxTree.SynModuleDecl list member - CommitDependencyManagerText: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + CommitDependencyManagerText : ctok:AbstractIL.Internal.Library.CompilationThreadToken * istate:FsiDynamicCompilerState * lexResourceManager:Lexhelp.LexResourceManager * errorLogger:ErrorLogger.ErrorLogger -> FsiDynamicCompilerState - member CreateDebuggerBreak: m:Range.range -> SyntaxTree.SynModuleDecl + member CreateDebuggerBreak : m:Range.range -> SyntaxTree.SynModuleDecl member - CurrentPartialAssemblySignature: istate:FsiDynamicCompilerState -> + CurrentPartialAssemblySignature : istate:FsiDynamicCompilerState -> SourceCodeServices.FSharpAssemblySignature member - EvalDependencyManagerTextFragment: packageManager:Microsoft.DotNet.DependencyManager.IDependencyManagerProvider * + EvalDependencyManagerTextFragment : packageManager:Microsoft.DotNet.DependencyManager.IDependencyManagerProvider * lt:CompilerConfig.Directive * m:Range.range * path:string -> unit member - EvalParsedDefinitions: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + EvalParsedDefinitions : ctok:AbstractIL.Internal.Library.CompilationThreadToken * errorLogger:ErrorLogger.ErrorLogger * istate:FsiDynamicCompilerState * showTypes:bool * isInteractiveItExpr:bool * @@ -19761,48 +44843,48 @@ namespace FSharp.Compiler.Interactive FsiDynamicCompilerState * FsiInteractionStepStatus member - EvalParsedExpression: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + EvalParsedExpression : ctok:AbstractIL.Internal.Library.CompilationThreadToken * errorLogger:ErrorLogger.ErrorLogger * istate:FsiDynamicCompilerState * expr:SyntaxTree.SynExpr -> FsiDynamicCompilerState * FsiInteractionStepStatus member - EvalParsedSourceFiles: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + EvalParsedSourceFiles : ctok:AbstractIL.Internal.Library.CompilationThreadToken * errorLogger:ErrorLogger.ErrorLogger * istate:FsiDynamicCompilerState * inputs:SyntaxTree.ParsedInput list -> FsiDynamicCompilerState member - EvalRequireReference: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + EvalRequireReference : ctok:AbstractIL.Internal.Library.CompilationThreadToken * istate:FsiDynamicCompilerState * m:Range.range * path:string -> CompilerImports.AssemblyResolution list * FsiDynamicCompilerState member - EvalSourceFiles: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + EvalSourceFiles : ctok:AbstractIL.Internal.Library.CompilationThreadToken * istate:FsiDynamicCompilerState * m:Range.range * sourceFiles:string list * lexResourceManager:Lexhelp.LexResourceManager * errorLogger:ErrorLogger.ErrorLogger -> FsiDynamicCompilerState - member FormatValue: obj:obj * objTy:System.Type -> string + member FormatValue : obj:obj * objTy:System.Type -> string member - GetBoundValues: istate:FsiDynamicCompilerState -> FsiBoundValue list - member GetInitialInteractiveState: unit -> FsiDynamicCompilerState + GetBoundValues : istate:FsiDynamicCompilerState -> FsiBoundValue list + member GetInitialInteractiveState : unit -> FsiDynamicCompilerState member - ProcessMetaCommandsFromInputAsInteractiveCommands: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + ProcessMetaCommandsFromInputAsInteractiveCommands : ctok:AbstractIL.Internal.Library.CompilationThreadToken * istate:FsiDynamicCompilerState * sourceFile:string * inp:SyntaxTree.ParsedInput -> FsiDynamicCompilerState member - TryFindBoundValue: istate:FsiDynamicCompilerState * nm:string -> + TryFindBoundValue : istate:FsiDynamicCompilerState * nm:string -> FsiBoundValue option - member DynamicAssembly: System.Reflection.Assembly - member DynamicAssemblyName: string - member ValueBound: IEvent - + member DynamicAssembly : System.Reflection.Assembly + member DynamicAssemblyName : string + member ValueBound : IEvent + end type ControlEventHandler = delegate of int -> bool type internal FsiInterruptStdinState = @@ -19817,58 +44899,58 @@ namespace FSharp.Compiler.Interactive | ExitRequest | PrintInterruptRequest type internal FsiInterruptController = - - new: fsiOptions:FsiCommandLineOptions * + class + new : fsiOptions:FsiCommandLineOptions * fsiConsoleOutput:FsiConsoleOutput -> FsiInterruptController - member ClearInterruptRequest: unit -> unit - member Exit: unit -> 'a + member ClearInterruptRequest : unit -> unit + member Exit : unit -> 'a member - InstallKillThread: threadToKill:System.Threading.Thread * + InstallKillThread : threadToKill:System.Threading.Thread * pauseMilliseconds:int -> unit - member Interrupt: unit -> unit - member PosixInvoke: n:int -> unit - member EventHandlers: ControlEventHandler list - member FsiInterruptStdinState: FsiInterruptStdinState - member InterruptAllowed: FsiInterruptControllerState with set - - module internal MagicAssemblyResolution = - val private assemblyLoadFrom: path:string -> System.Reflection.Assembly - val Install: + member Interrupt : unit -> unit + member PosixInvoke : n:int -> unit + member EventHandlers : ControlEventHandler list + member FsiInterruptStdinState : FsiInterruptStdinState + member InterruptAllowed : FsiInterruptControllerState with set + end + module internal MagicAssemblyResolution = begin + val private assemblyLoadFrom : path:string -> System.Reflection.Assembly + val Install : tcConfigB:CompilerConfig.TcConfigBuilder * tcImports:CompilerImports.TcImports * fsiDynamicCompiler:FsiDynamicCompiler * fsiConsoleOutput:FsiConsoleOutput -> System.IDisposable - + end type internal FsiStdinLexerProvider = - - new: tcConfigB:CompilerConfig.TcConfigBuilder * + class + new : tcConfigB:CompilerConfig.TcConfigBuilder * fsiStdinSyphon:FsiStdinSyphon * fsiConsoleInput:FsiConsoleInput * fsiConsoleOutput:FsiConsoleOutput * fsiOptions:FsiCommandLineOptions * lexResourceManager:Lexhelp.LexResourceManager -> FsiStdinLexerProvider member - CreateBufferLexer: sourceFileName:string * + CreateBufferLexer : sourceFileName:string * lexbuf:UnicodeLexing.Lexbuf * errorLogger:ErrorLogger.ErrorLogger -> LexFilter.LexFilter member - CreateIncludedScriptLexer: sourceFileName:string * + CreateIncludedScriptLexer : sourceFileName:string * reader:System.IO.StreamReader * errorLogger:ErrorLogger.ErrorLogger -> LexFilter.LexFilter member - CreateStdinLexer: errorLogger:ErrorLogger.ErrorLogger -> + CreateStdinLexer : errorLogger:ErrorLogger.ErrorLogger -> LexFilter.LexFilter member - CreateStringLexer: sourceFileName:string * source:string * + CreateStringLexer : sourceFileName:string * source:string * errorLogger:ErrorLogger.ErrorLogger -> LexFilter.LexFilter - member ConsoleInput: FsiConsoleInput - + member ConsoleInput : FsiConsoleInput + end type internal FsiInteractionProcessor = - - new: fsi:FsiEvaluationSessionHostConfig * + class + new : fsi:FsiEvaluationSessionHostConfig * tcConfigB:CompilerConfig.TcConfigBuilder * fsiOptions:FsiCommandLineOptions * fsiDynamicCompiler:FsiDynamicCompiler * @@ -19880,48 +44962,48 @@ namespace FSharp.Compiler.Interactive initialInteractiveState:FsiDynamicCompilerState -> FsiInteractionProcessor member - AddBoundValue: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + AddBoundValue : ctok:AbstractIL.Internal.Library.CompilationThreadToken * errorLogger:ErrorLogger.ErrorLogger * name:string * value:obj -> Choice member - CompletionsForPartialLID: istate:FsiDynamicCompilerState * + CompletionsForPartialLID : istate:FsiDynamicCompilerState * prefix:string -> string list member - EvalExpression: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + EvalExpression : ctok:AbstractIL.Internal.Library.CompilationThreadToken * sourceText:string * scriptFileName:string * errorLogger:ErrorLogger.ErrorLogger -> Choice member - EvalIncludedScript: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + EvalIncludedScript : ctok:AbstractIL.Internal.Library.CompilationThreadToken * istate:FsiDynamicCompilerState * sourceFile:string * m:Range.range * errorLogger:ErrorLogger.ErrorLogger -> FsiDynamicCompilerState * FsiInteractionStepStatus member - EvalIncludedScripts: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + EvalIncludedScripts : ctok:AbstractIL.Internal.Library.CompilationThreadToken * istate:FsiDynamicCompilerState * sourceFiles:string list * errorLogger:ErrorLogger.ErrorLogger -> FsiDynamicCompilerState member - EvalInteraction: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + EvalInteraction : ctok:AbstractIL.Internal.Library.CompilationThreadToken * sourceText:string * scriptFileName:string * errorLogger:ErrorLogger.ErrorLogger * ?cancellationToken:System.Threading.CancellationToken -> Choice member - EvalScript: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + EvalScript : ctok:AbstractIL.Internal.Library.CompilationThreadToken * scriptPath:string * errorLogger:ErrorLogger.ErrorLogger -> Choice member - LoadDummyInteraction: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + LoadDummyInteraction : ctok:AbstractIL.Internal.Library.CompilationThreadToken * errorLogger:ErrorLogger.ErrorLogger -> unit member - LoadInitialFiles: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + LoadInitialFiles : ctok:AbstractIL.Internal.Library.CompilationThreadToken * errorLogger:ErrorLogger.ErrorLogger -> unit member - ParseAndCheckInteraction: ctok:AbstractIL.Internal.Library.CompilationThreadToken * + ParseAndCheckInteraction : ctok:AbstractIL.Internal.Library.CompilationThreadToken * legacyReferenceResolver:ReferenceResolver.Resolver * checker:SourceCodeServices.IReactorOperations * istate:FsiDynamicCompilerState * @@ -19930,7 +45012,7 @@ namespace FSharp.Compiler.Interactive SourceCodeServices.FSharpCheckFileResults * SourceCodeServices.FSharpCheckProjectResults> member - ParseAndExecOneSetOfInteractionsFromLexbuf: runCodeOnMainThread:((#AbstractIL.Internal.Library.CompilationThreadToken -> + ParseAndExecOneSetOfInteractionsFromLexbuf : runCodeOnMainThread:((#AbstractIL.Internal.Library.CompilationThreadToken -> FsiDynamicCompilerState -> FsiDynamicCompilerState * FsiInteractionStepStatus) -> @@ -19944,162 +45026,162 @@ namespace FSharp.Compiler.Interactive FsiDynamicCompilerState * FsiInteractionStepStatus member - StartStdinReadAndProcessThread: errorLogger:ErrorLogger.ErrorLogger -> + StartStdinReadAndProcessThread : errorLogger:ErrorLogger.ErrorLogger -> unit - member CurrentState: FsiDynamicCompilerState - member PartialAssemblySignatureUpdated: IEvent - - val internal SpawnThread: name:string -> f:(unit -> unit) -> unit - val internal SpawnInteractiveServer: + member CurrentState : FsiDynamicCompilerState + member PartialAssemblySignatureUpdated : IEvent + end + val internal SpawnThread : name:string -> f:(unit -> unit) -> unit + val internal SpawnInteractiveServer : fsi:FsiEvaluationSessionHostConfig * fsiOptions:FsiCommandLineOptions * fsiConsoleOutput:FsiConsoleOutput -> unit - val internal DriveFsiEventLoop: + val internal DriveFsiEventLoop : fsi:FsiEvaluationSessionHostConfig * fsiConsoleOutput:FsiConsoleOutput -> unit - [] + [] type FsiCompilationException = - + class inherit System.Exception - new: string * SourceCodeServices.FSharpErrorInfo [] option -> + new : string * SourceCodeServices.FSharpErrorInfo [] option -> FsiCompilationException - member ErrorInfos: SourceCodeServices.FSharpErrorInfo [] option - - [] + member ErrorInfos : SourceCodeServices.FSharpErrorInfo [] option + end + [] type FsiEvaluationSession = - + class interface System.IDisposable - new: fsi:FsiEvaluationSessionHostConfig * argv:string [] * + new : fsi:FsiEvaluationSessionHostConfig * argv:string [] * inReader:System.IO.TextReader * outWriter:System.IO.TextWriter * errorWriter:System.IO.TextWriter * fsiCollectible:bool * legacyReferenceResolver:ReferenceResolver.Resolver option -> FsiEvaluationSession static member - Create: fsiConfig:FsiEvaluationSessionHostConfig * argv:string [] * + Create : fsiConfig:FsiEvaluationSessionHostConfig * argv:string [] * inReader:System.IO.TextReader * outWriter:System.IO.TextWriter * errorWriter:System.IO.TextWriter * ?collectible:bool * ?legacyReferenceResolver:ReferenceResolver.Resolver -> FsiEvaluationSession static member - GetDefaultConfiguration: unit -> FsiEvaluationSessionHostConfig + GetDefaultConfiguration : unit -> FsiEvaluationSessionHostConfig static member - GetDefaultConfiguration: fsiObj:obj -> FsiEvaluationSessionHostConfig + GetDefaultConfiguration : fsiObj:obj -> FsiEvaluationSessionHostConfig static member - GetDefaultConfiguration: fsiObj:obj * useFsiAuxLib:bool -> + GetDefaultConfiguration : fsiObj:obj * useFsiAuxLib:bool -> FsiEvaluationSessionHostConfig - member AddBoundValue: name:string * value:obj -> unit - member EvalExpression: code:string -> FsiValue option + member AddBoundValue : name:string * value:obj -> unit + member EvalExpression : code:string -> FsiValue option member - EvalExpressionNonThrowing: code:string -> + EvalExpressionNonThrowing : code:string -> Choice * SourceCodeServices.FSharpErrorInfo [] member - EvalInteraction: code:string * + EvalInteraction : code:string * ?cancellationToken:System.Threading.CancellationToken -> unit member - EvalInteractionNonThrowing: code:string * + EvalInteractionNonThrowing : code:string * ?cancellationToken:System.Threading.CancellationToken -> Choice * SourceCodeServices.FSharpErrorInfo [] - member EvalScript: filePath:string -> unit + member EvalScript : filePath:string -> unit member - EvalScriptNonThrowing: filePath:string -> + EvalScriptNonThrowing : filePath:string -> Choice * SourceCodeServices.FSharpErrorInfo [] member - FormatValue: reflectionValue:obj * reflectionType:System.Type -> + FormatValue : reflectionValue:obj * reflectionType:System.Type -> string - member GetBoundValues: unit -> FsiBoundValue list - member GetCompletions: longIdent:string -> seq - member Interrupt: unit -> unit + member GetBoundValues : unit -> FsiBoundValue list + member GetCompletions : longIdent:string -> seq + member Interrupt : unit -> unit member - ParseAndCheckInteraction: code:string -> + ParseAndCheckInteraction : code:string -> Async - member ReportUnhandledException: exn:exn -> unit - member Run: unit -> unit - member TryFindBoundValue: name:string -> FsiBoundValue option - member - CurrentPartialAssemblySignature: SourceCodeServices.FSharpAssemblySignature - member DynamicAssembly: System.Reflection.Assembly - member InteractiveChecker: SourceCodeServices.FSharpChecker - member IsGui: bool - member LCID: int option - member PartialAssemblySignatureUpdated: IEvent - member ValueBound: IEvent - - module Settings = + member ReportUnhandledException : exn:exn -> unit + member Run : unit -> unit + member TryFindBoundValue : name:string -> FsiBoundValue option + member + CurrentPartialAssemblySignature : SourceCodeServices.FSharpAssemblySignature + member DynamicAssembly : System.Reflection.Assembly + member InteractiveChecker : SourceCodeServices.FSharpChecker + member IsGui : bool + member LCID : int option + member PartialAssemblySignatureUpdated : IEvent + member ValueBound : IEvent + end + module Settings = begin type IEventLoop = interface - abstract member Invoke: (unit -> 'T) -> 'T - abstract member Run: unit -> bool - abstract member ScheduleRestart: unit -> unit - + abstract member Invoke : (unit -> 'T) -> 'T + abstract member Run : unit -> bool + abstract member ScheduleRestart : unit -> unit + end type internal SimpleEventLoop = - + class interface System.IDisposable interface IEventLoop - new: unit -> SimpleEventLoop - - [] + new : unit -> SimpleEventLoop + end + [] type InteractiveSettings = - - new: unit -> InteractiveSettings - member AddPrintTransformer: ('T -> obj) -> unit - member AddPrinter: ('T -> string) -> unit + class + new : unit -> InteractiveSettings + member AddPrintTransformer : ('T -> obj) -> unit + member AddPrinter : ('T -> string) -> unit member - AddedPrinters: Choice<(System.Type * (obj -> string)), + AddedPrinters : Choice<(System.Type * (obj -> string)), (System.Type * (obj -> obj))> list - member CommandLineArgs: string [] - member EventLoop: IEventLoop - member FloatingPointFormat: string - member FormatProvider: System.IFormatProvider - member PrintDepth: int - member PrintLength: int - member PrintSize: int - member PrintWidth: int - member ShowDeclarationValues: bool - member ShowIDictionary: bool - member ShowIEnumerable: bool - member ShowProperties: bool - - val fsi: InteractiveSettings - - [] + member CommandLineArgs : string [] + member EventLoop : IEventLoop + member FloatingPointFormat : string + member FormatProvider : System.IFormatProvider + member PrintDepth : int + member PrintLength : int + member PrintSize : int + member PrintWidth : int + member ShowDeclarationValues : bool + member ShowIDictionary : bool + member ShowIEnumerable : bool + member ShowProperties : bool + end + val fsi : InteractiveSettings + end + [] type CompilerInputStream = - + class inherit System.IO.Stream - new: unit -> CompilerInputStream - member Add: str:string -> unit - override Flush: unit -> unit - override Read: buffer:byte [] * offset:int * count:int -> int - override Seek: _offset:int64 * _origin:System.IO.SeekOrigin -> int64 - override SetLength: _value:int64 -> unit - override Write: _buffer:byte [] * _offset:int * _count:int -> unit - override CanRead: bool - override CanSeek: bool - override CanWrite: bool - override Length: int64 - override Position: int64 - - [] + new : unit -> CompilerInputStream + member Add : str:string -> unit + override Flush : unit -> unit + override Read : buffer:byte [] * offset:int * count:int -> int + override Seek : _offset:int64 * _origin:System.IO.SeekOrigin -> int64 + override SetLength : _value:int64 -> unit + override Write : _buffer:byte [] * _offset:int * _count:int -> unit + override CanRead : bool + override CanSeek : bool + override CanWrite : bool + override Length : int64 + override Position : int64 + end + [] type CompilerOutputStream = - + class inherit System.IO.Stream - new: unit -> CompilerOutputStream - override Flush: unit -> unit - member Read: unit -> string - override Read: _buffer:byte [] * _offset:int * _count:int -> int - override Seek: _offset:int64 * _origin:System.IO.SeekOrigin -> int64 - override SetLength: _value:int64 -> unit - override Write: buffer:byte [] * offset:int * count:int -> unit - override CanRead: bool - override CanSeek: bool - override CanWrite: bool - override Length: int64 - override Position: int64 - - + new : unit -> CompilerOutputStream + override Flush : unit -> unit + member Read : unit -> string + override Read : _buffer:byte [] * _offset:int * _count:int -> int + override Seek : _offset:int64 * _origin:System.IO.SeekOrigin -> int64 + override SetLength : _value:int64 -> unit + override Write : buffer:byte [] * offset:int * count:int -> unit + override CanRead : bool + override CanSeek : bool + override CanWrite : bool + override Length : int64 + override Position : int64 + end + end diff --git a/src/fsharp/MethodCalls.fs b/src/fsharp/MethodCalls.fs index 2c643411d90..52ea6aaff39 100644 --- a/src/fsharp/MethodCalls.fs +++ b/src/fsharp/MethodCalls.fs @@ -484,34 +484,34 @@ type CalledMeth<'T> member x.amap = infoReader.amap - /// the method we're attempting to call + /// The method we're attempting to call member x.Method = minfo - /// the instantiation of the method we're attempting to call + /// The instantiation of the method we're attempting to call member x.CalledTyArgs = calledTyArgs member x.AllCalledArgs = fullCurriedCalledArgs - /// the instantiation of the method we're attempting to call + /// The instantiation of the method we're attempting to call member x.CalledTyparInst = let tps = minfo.FormalMethodTypars if tps.Length = calledTyArgs.Length then mkTyparInst tps calledTyArgs else [] - /// the formal instantiation of the method we're attempting to call + /// The formal instantiation of the method we're attempting to call member x.CallerTyArgs = callerTyArgs - /// The types of the actual object arguments, if any + /// The types of the actual object arguments, if any member x.CallerObjArgTys = callerObjArgTys - /// The argument analysis for each set of curried arguments + /// The argument analysis for each set of curried arguments member x.ArgSets = argSets - /// return type after implicit deference of byref returns is taken into account + /// The return type after implicit deference of byref returns is taken into account member x.CalledReturnTypeAfterByrefDeref = let retTy = methodRetTy if isByrefTy g retTy then destByrefTy g retTy else retTy - /// return type after tupling of out args is taken into account + /// Return type after tupling of out args is taken into account member x.CalledReturnTypeAfterOutArgTupling = let retTy = x.CalledReturnTypeAfterByrefDeref if isNil unnamedCalledOutArgs then @@ -521,22 +521,22 @@ type CalledMeth<'T> if isUnitTy g retTy then mkRefTupledTy g outArgTys else mkRefTupledTy g (retTy :: outArgTys) - /// named setters + /// Named setters member x.AssignedItemSetters = assignedNamedProps - /// the property related to the method we're attempting to call, if any + /// The property related to the method we're attempting to call, if any member x.AssociatedPropertyInfo = pinfoOpt - /// unassigned args + /// Unassigned args member x.UnassignedNamedArgs = unassignedNamedItems - /// args assigned to specify values for attribute fields and properties (these are not necessarily "property sets") + /// Args assigned to specify values for attribute fields and properties (these are not necessarily "property sets") member x.AttributeAssignedNamedArgs = attributeAssignedNamedItems - /// unnamed called optional args: pass defaults for these + /// Unnamed called optional args: pass defaults for these member x.UnnamedCalledOptArgs = unnamedCalledOptArgs - /// unnamed called out args: return these as part of the return tuple + /// Unnamed called out args: return these as part of the return tuple member x.UnnamedCalledOutArgs = unnamedCalledOutArgs static member GetMethod (x: CalledMeth<'T>) = x.Method @@ -753,10 +753,6 @@ let TakeObjAddrForMethodCall g amap (minfo: MethInfo) isMutable m objArgs f = let e, ety = f ccallInfo objArgs wrap e, ety -//------------------------------------------------------------------------- -// Build method calls. -//------------------------------------------------------------------------- - /// Build an expression node that is a call to a .NET method. let BuildILMethInfoCall g amap m isProp (minfo: ILMethInfo) valUseFlags minst direct args = let valu = isStructTy g minfo.ApparentEnclosingType diff --git a/src/fsharp/MethodCalls.fsi b/src/fsharp/MethodCalls.fsi index 2c643411d90..c9bc2381894 100644 --- a/src/fsharp/MethodCalls.fsi +++ b/src/fsharp/MethodCalls.fsi @@ -12,6 +12,7 @@ open FSharp.Compiler.AccessibilityLogic open FSharp.Compiler.AttributeChecking open FSharp.Compiler.ErrorLogger open FSharp.Compiler.Features +open FSharp.Compiler.Import open FSharp.Compiler.InfoReader open FSharp.Compiler.Infos open FSharp.Compiler.Lib @@ -31,11 +32,6 @@ open FSharp.Compiler.TypeRelations open FSharp.Compiler.ExtensionTyping #endif -//------------------------------------------------------------------------- -// Sets of methods involved in overload resolution and trait constraint -// satisfaction. -//------------------------------------------------------------------------- - /// In the following, 'T gets instantiated to: /// 1. the expression being supplied for an argument /// 2. "unit", when simply checking for the existence of an overload that satisfies @@ -47,45 +43,33 @@ open FSharp.Compiler.ExtensionTyping /// an adhoc conversion. /// /// The bool indicates if named using a '?', making the caller argument explicit-optional -type CallerArg<'T> = - /// CallerArg(ty, range, isOpt, exprInfo) - | CallerArg of ty: TType * range: range * isOpt: bool * exprInfo: 'T +type CallerArg<'T> = + | CallerArg of ty: TType * range: range * isOpt: bool * exprInfo: 'T - member x.CallerArgumentType = (let (CallerArg(ty, _, _, _)) = x in ty) + member CallerArgumentType: TType - member x.Range = (let (CallerArg(_, m, _, _)) = x in m) + member Expr: 'T - member x.IsExplicitOptional = (let (CallerArg(_, _, isOpt, _)) = x in isOpt) + member IsExplicitOptional: bool - member x.Expr = (let (CallerArg(_, _, _, expr)) = x in expr) - -/// Represents the information about an argument in the method being called -type CalledArg = + member Range: range + +type CalledArg = { Position: struct (int * int) - IsParamArray : bool - OptArgInfo : OptionalArgInfo - CallerInfo : CallerInfo + IsParamArray: bool + OptArgInfo: OptionalArgInfo + CallerInfo: CallerInfo IsInArg: bool IsOutArg: bool ReflArgInfo: ReflectedArgInfo NameOpt: Ident option - CalledArgumentType : TType } + CalledArgumentType: TType } -let CalledArg (pos, isParamArray, optArgInfo, callerInfo, isInArg, isOutArg, nameOpt, reflArgInfo, calledArgTy) = - { Position=pos - IsParamArray=isParamArray - OptArgInfo=optArgInfo - CallerInfo=callerInfo - IsInArg=isInArg - IsOutArg=isOutArg - ReflArgInfo=reflArgInfo - NameOpt=nameOpt - CalledArgumentType=calledArgTy } +val CalledArg: pos:struct (int * int) * isParamArray:bool * optArgInfo:OptionalArgInfo * callerInfo:CallerInfo * isInArg:bool * isOutArg:bool * nameOpt:Ident option * reflArgInfo:ReflectedArgInfo * calledArgTy:TType -> CalledArg /// Represents a match between a caller argument and a called argument, arising from either /// a named argument or an unnamed argument. -type AssignedCalledArg<'T> = - +type AssignedCalledArg<'T> = { /// The identifier for a named argument, if any NamedArgIdOpt : Ident option @@ -94,198 +78,41 @@ type AssignedCalledArg<'T> = /// The argument on the caller side CallerArg: CallerArg<'T> } - - member x.Position = x.CalledArg.Position - + member Position: struct (int * int) + /// Represents the possibilities for a named-setter argument (a property, field, or a record field setter) -type AssignedItemSetterTarget = - | AssignedPropSetter of PropInfo * MethInfo * TypeInst (* the MethInfo is a non-indexer setter property *) - | AssignedILFieldSetter of ILFieldInfo - | AssignedRecdFieldSetter of RecdFieldInfo +type AssignedItemSetterTarget = + | AssignedPropSetter of PropInfo * MethInfo * TypeInst + | AssignedILFieldSetter of ILFieldInfo + | AssignedRecdFieldSetter of RecdFieldInfo /// Represents the resolution of a caller argument as a named-setter argument -type AssignedItemSetter<'T> = AssignedItemSetter of Ident * AssignedItemSetterTarget * CallerArg<'T> - -type CallerNamedArg<'T> = - | CallerNamedArg of Ident * CallerArg<'T> - - member x.Ident = (let (CallerNamedArg(id, _)) = x in id) - - member x.Name = x.Ident.idText - - member x.CallerArg = (let (CallerNamedArg(_, a)) = x in a) - +type AssignedItemSetter<'T> = + | AssignedItemSetter of + Ident * AssignedItemSetterTarget * CallerArg<'T> + +type CallerNamedArg<'T> = + | CallerNamedArg of Ident * CallerArg<'T> + member CallerArg: CallerArg<'T> + member Ident: Ident + member Name: string + /// Represents the list of unnamed / named arguments at method call site /// remark: The usage of list list is due to tupling and currying of arguments, /// stemming from SynValInfo in the AST. -[] -type CallerArgs<'T> = - { - Unnamed: CallerArg<'T> list list - Named: CallerNamedArg<'T> list list - } - static member Empty : CallerArgs<'T> = { Unnamed = []; Named = [] } - member x.CallerArgCounts = List.length x.Unnamed, List.length x.Named - member x.CurriedCallerArgs = List.zip x.Unnamed x.Named - member x.ArgumentNamesAndTypes = - let unnamed = x.Unnamed |> List.collect (List.map (fun i -> None, i.CallerArgumentType)) - let named = x.Named |> List.collect (List.map (fun i -> Some i.Name, i.CallerArg.CallerArgumentType)) - unnamed @ named - -//------------------------------------------------------------------------- -// Callsite conversions -//------------------------------------------------------------------------- - -// If the called method argument is a delegate type, and the caller is known to be a function type, then the caller may provide a function -// If the called method argument is an Expression type, and the caller is known to be a function type, then the caller may provide a T -// If the called method argument is an [] Quotations.Expr, and the caller is not known to be a quoted expression type, then the caller may provide a T -let AdjustCalledArgTypeForLinqExpressionsAndAutoQuote (infoReader: InfoReader) callerArgTy (calledArg: CalledArg) m = - let g = infoReader.g - let calledArgTy = calledArg.CalledArgumentType - - let adjustDelegateTy calledTy = - let (SigOfFunctionForDelegate(_, delArgTys, _, fty)) = GetSigOfFunctionForDelegate infoReader calledTy m AccessibleFromSomewhere - let delArgTys = if isNil delArgTys then [g.unit_ty] else delArgTys - if (fst (stripFunTy g callerArgTy)).Length = delArgTys.Length then - fty - else - calledArgTy - - if isDelegateTy g calledArgTy && isFunTy g callerArgTy then - adjustDelegateTy calledArgTy - - elif isLinqExpressionTy g calledArgTy && isFunTy g callerArgTy then - let calledArgTyNoExpr = destLinqExpressionTy g calledArgTy - if isDelegateTy g calledArgTyNoExpr then - adjustDelegateTy calledArgTyNoExpr - else - calledArgTy - - elif calledArg.ReflArgInfo.AutoQuote && isQuotedExprTy g calledArgTy && not (isQuotedExprTy g callerArgTy) then - destQuotedExprTy g calledArgTy - - else calledArgTy - -/// Adjust the called argument type to take into account whether the caller's argument is CSharpMethod(?arg=Some(3)) or CSharpMethod(arg=1) -let AdjustCalledArgTypeForOptionals (g: TcGlobals) enforceNullableOptionalsKnownTypes (calledArg: CalledArg) calledArgTy (callerArg: CallerArg<_>) = - - if callerArg.IsExplicitOptional then - match calledArg.OptArgInfo with - // CSharpMethod(?x = arg), optional C#-style argument, may have nullable type - | CallerSide _ -> - if g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop then - if isNullableTy g calledArgTy then - mkOptionTy g (destNullableTy g calledArgTy) - else - mkOptionTy g calledArgTy - else - calledArgTy - - // FSharpMethod(?x = arg), optional F#-style argument - | CalleeSide -> - // In this case, the called argument will already have option type - calledArgTy - - | NotOptional -> - // This condition represents an error but the error is raised in later processing - calledArgTy - else - match calledArg.OptArgInfo with - // CSharpMethod(x = arg), non-optional C#-style argument, may have type Nullable. - | NotOptional when not (g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop) -> - calledArgTy - - // The arg should have type ty. However for backwards compat, we also allow arg to have type Nullable - | NotOptional - // CSharpMethod(x = arg), optional C#-style argument, may have type Nullable. - | CallerSide _ -> - if isNullableTy g calledArgTy && g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop then - // If inference has worked out it's a nullable then use this - if isNullableTy g callerArg.CallerArgumentType then - calledArgTy - // If inference has worked out it's a struct (e.g. an int) then use this - elif isStructTy g callerArg.CallerArgumentType then - destNullableTy g calledArgTy - // If neither and we are at the end of overload resolution then use the Nullable - elif enforceNullableOptionalsKnownTypes then - calledArgTy - // If at the beginning of inference then use a type variable. - else - let destTy = destNullableTy g calledArgTy - match calledArg.OptArgInfo with - // Use the type variable from the Nullable if called arg is not optional. - | NotOptional when isTyparTy g destTy -> - destTy - | _ -> - let compgenId = mkSynId range0 unassignedTyparName - mkTyparTy (Construct.NewTypar (TyparKind.Type, TyparRigidity.Flexible, Typar(compgenId, NoStaticReq, true), false, TyparDynamicReq.No, [], false, false)) - else - calledArgTy - - // FSharpMethod(x = arg), optional F#-style argument, should have option type - | CalleeSide -> - if isOptionTy g calledArgTy then - destOptionTy g calledArgTy - else - calledArgTy - -// F# supports three adhoc conversions at method callsites (note C# supports more, though ones -// such as implicit conversions interact badly with type inference). -// -// 1. The use of "(fun x y -> ...)" when a delegate it expected. This is not part of -// the ":>" coercion relationship or inference constraint problem as -// such, but is a special rule applied only to method arguments. -// -// The function AdjustCalledArgType detects this case based on types and needs to know that the type being applied -// is a function type. -// -// 2. The use of "(fun x y -> ...)" when Expression it expected. This is similar to above. -// -// 3. Two ways to pass a value where a byref is expected. The first (default) -// is to use a reference cell, and the interior address is taken automatically -// The second is an explicit use of the "address-of" operator "&e". Here we detect the second case, -// and record the presence of the syntax "&e" in the pre-inferred actual type for the method argument. -// The function AdjustCalledArgType detects this and refuses to apply the default byref-to-ref transformation. -// -// The function AdjustCalledArgType also adjusts for optional arguments. -let AdjustCalledArgType (infoReader: InfoReader) isConstraint enforceNullableOptionalsKnownTypes (calledArg: CalledArg) (callerArg: CallerArg<_>) = - let g = infoReader.g - let m = callerArg.Range - // #424218 - when overload resolution is part of constraint solving - do not perform type-directed conversions - let calledArgTy = calledArg.CalledArgumentType - let callerArgTy = callerArg.CallerArgumentType - if isConstraint then - calledArgTy - else - - // If the called method argument is an inref type, then the caller may provide a byref or value - if isInByrefTy g calledArgTy then -#if IMPLICIT_ADDRESS_OF - if isByrefTy g callerArgTy then - calledArgTy - else - destByrefTy g calledArgTy -#else - calledArgTy -#endif - - // If the called method argument is a (non inref) byref type, then the caller may provide a byref or ref. - elif isByrefTy g calledArgTy then - if isByrefTy g callerArgTy then - calledArgTy - else - mkRefCellTy g (destByrefTy g calledArgTy) - - else - let calledArgTy2 = AdjustCalledArgTypeForLinqExpressionsAndAutoQuote infoReader callerArgTy calledArg m - let calledArgTy3 = AdjustCalledArgTypeForOptionals g enforceNullableOptionalsKnownTypes calledArg calledArgTy2 callerArg - calledArgTy3 - -//------------------------------------------------------------------------- -// CalledMeth -//------------------------------------------------------------------------- - -type CalledMethArgSet<'T> = +[] +type CallerArgs<'T> = + { Unnamed: CallerArg<'T> list list + Named: CallerNamedArg<'T> list list } + member ArgumentNamesAndTypes: (string option * TType) list + member CallerArgCounts: int * int + member CurriedCallerArgs: (CallerArg<'T> list * CallerNamedArg<'T> list) list + static member Empty: CallerArgs<'T> + +/// F# supports some adhoc conversions at method callsites +val AdjustCalledArgType: infoReader:InfoReader -> isConstraint:bool -> enforceNullableOptionalsKnownTypes:bool -> calledArg:CalledArg -> callerArg:CallerArg<'a> -> TType + +type CalledMethArgSet<'T> = { /// The called arguments corresponding to "unnamed" arguments UnnamedCalledArgs : CalledArg list @@ -301,579 +128,121 @@ type CalledMethArgSet<'T> = /// Named args AssignedNamedArgs: AssignedCalledArg<'T> list } - member x.NumUnnamedCallerArgs = x.UnnamedCallerArgs.Length - - member x.NumAssignedNamedArgs = x.AssignedNamedArgs.Length + member NumAssignedNamedArgs: int - member x.NumUnnamedCalledArgs = x.UnnamedCalledArgs.Length - -let MakeCalledArgs amap m (minfo: MethInfo) minst = - // Mark up the arguments with their position, so we can sort them back into order later - let paramDatas = minfo.GetParamDatas(amap, m, minst) - paramDatas |> List.mapiSquared (fun i j (ParamData(isParamArrayArg, isInArg, isOutArg, optArgInfo, callerInfoFlags, nmOpt, reflArgInfo, typeOfCalledArg)) -> - { Position=struct(i,j) - IsParamArray=isParamArrayArg - OptArgInfo=optArgInfo - CallerInfo = callerInfoFlags - IsInArg=isInArg - IsOutArg=isOutArg - ReflArgInfo=reflArgInfo - NameOpt=nmOpt - CalledArgumentType=typeOfCalledArg }) + member NumUnnamedCalledArgs: int + member NumUnnamedCallerArgs: int + /// Represents the syntactic matching between a caller of a method and the called method. /// /// The constructor takes all the information about the caller and called side of a method, match up named arguments, property setters etc., /// and returns a CalledMeth object for further analysis. -type CalledMeth<'T> - (infoReader: InfoReader, - nameEnv: NameResolutionEnv option, - isCheckingAttributeCall, - /// a function to help generate fresh type variables the property setters methods in generic classes - freshenMethInfo, - /// range - m, - /// the access domain of the place where the call is taking place - ad, - /// the method we're attempting to call - minfo: MethInfo, - /// the 'called type arguments', i.e. the fresh generic instantiation of the method we're attempting to call - calledTyArgs, - /// the 'caller type arguments', i.e. user-given generic instantiation of the method we're attempting to call - // todo: consider CallerTypeArgs record - callerTyArgs: TType list, - /// the property related to the method we're attempting to call, if any - pinfoOpt: PropInfo option, - /// the types of the actual object argument, if any - callerObjArgTys: TType list, - /// the 'caller method arguments', i.e. a list of user-given parameter expressions, split between unnamed and named arguments - callerArgs: CallerArgs<'T>, - /// do we allow the use of a param args method in its "expanded" form? - allowParamArgs: bool, - /// do we allow the use of the transformation that converts out arguments as tuple returns? - allowOutAndOptArgs: bool, - /// method parameters - tyargsOpt : TType option) - = - let g = infoReader.g - let methodRetTy = minfo.GetFSharpReturnTy(infoReader.amap, m, calledTyArgs) - - let fullCurriedCalledArgs = MakeCalledArgs infoReader.amap m minfo calledTyArgs - do assert (fullCurriedCalledArgs.Length = fullCurriedCalledArgs.Length) - - let argSetInfos = - (callerArgs.CurriedCallerArgs, fullCurriedCalledArgs) ||> List.map2 (fun (unnamedCallerArgs, namedCallerArgs) fullCalledArgs -> - // Find the arguments not given by name - let unnamedCalledArgs = - fullCalledArgs |> List.filter (fun calledArg -> - match calledArg.NameOpt with - | Some nm -> namedCallerArgs |> List.forall (fun (CallerNamedArg(nm2, _e)) -> nm.idText <> nm2.idText) - | None -> true) - - // See if any of them are 'out' arguments being returned as part of a return tuple - let minArgs, unnamedCalledArgs, unnamedCalledOptArgs, unnamedCalledOutArgs = - let nUnnamedCallerArgs = unnamedCallerArgs.Length - let nUnnamedCalledArgs = unnamedCalledArgs.Length - if allowOutAndOptArgs && nUnnamedCallerArgs < nUnnamedCalledArgs then - let unnamedCalledArgsTrimmed, unnamedCalledOptOrOutArgs = List.splitAt nUnnamedCallerArgs unnamedCalledArgs - - // Check if all optional/out arguments are byref-out args - if unnamedCalledOptOrOutArgs |> List.forall (fun x -> x.IsOutArg && isByrefTy g x.CalledArgumentType) then - nUnnamedCallerArgs - 1, unnamedCalledArgsTrimmed, [], unnamedCalledOptOrOutArgs - // Check if all optional/out arguments are optional args - elif unnamedCalledOptOrOutArgs |> List.forall (fun x -> x.OptArgInfo.IsOptional) then - nUnnamedCallerArgs - 1, unnamedCalledArgsTrimmed, unnamedCalledOptOrOutArgs, [] - // Otherwise drop them on the floor - else - nUnnamedCalledArgs - 1, unnamedCalledArgs, [], [] - else - nUnnamedCalledArgs - 1, unnamedCalledArgs, [], [] - - let (unnamedCallerArgs, paramArrayCallerArgs), unnamedCalledArgs, paramArrayCalledArgOpt = - let supportsParamArgs = - allowParamArgs && - minArgs >= 0 && - unnamedCalledArgs |> List.last |> (fun calledArg -> calledArg.IsParamArray && isArray1DTy g calledArg.CalledArgumentType) - - if supportsParamArgs && unnamedCallerArgs.Length >= minArgs then - let a, b = List.frontAndBack unnamedCalledArgs - List.splitAt minArgs unnamedCallerArgs, a, Some(b) - else - (unnamedCallerArgs, []), unnamedCalledArgs, None - - let assignedNamedArgs = - fullCalledArgs |> List.choose (fun calledArg -> - match calledArg.NameOpt with - | Some nm -> - namedCallerArgs |> List.tryPick (fun (CallerNamedArg(nm2, callerArg)) -> - if nm.idText = nm2.idText then Some { NamedArgIdOpt = Some nm2; CallerArg=callerArg; CalledArg=calledArg } - else None) - | _ -> None) - - let unassignedNamedItems = - namedCallerArgs |> List.filter (fun (CallerNamedArg(nm, _e)) -> - fullCalledArgs |> List.forall (fun calledArg -> - match calledArg.NameOpt with - | Some nm2 -> nm.idText <> nm2.idText - | None -> true)) - - let attributeAssignedNamedItems = - if isCheckingAttributeCall then - // The process for assigning names-->properties is substantially different for attribute specifications - // because it permits the bindings of names to immutable fields. So we use the old - // code for this. - unassignedNamedItems - else - [] - - let assignedNamedProps, unassignedNamedItems = - let returnedObjTy = if minfo.IsConstructor then minfo.ApparentEnclosingType else methodRetTy - unassignedNamedItems |> List.splitChoose (fun (CallerNamedArg(id, e) as arg) -> - let nm = id.idText - let pinfos = GetIntrinsicPropInfoSetsOfType infoReader (Some nm) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides id.idRange returnedObjTy - let pinfos = pinfos |> ExcludeHiddenOfPropInfos g infoReader.amap m - match pinfos with - | [pinfo] when pinfo.HasSetter && not pinfo.IsIndexer -> - let pminfo = pinfo.SetterMethod - let pminst = freshenMethInfo m pminfo - Choice1Of2(AssignedItemSetter(id, AssignedPropSetter(pinfo, pminfo, pminst), e)) - | _ -> - let epinfos = - match nameEnv with - | Some ne -> ExtensionPropInfosOfTypeInScope ResultCollectionSettings.AllResults infoReader ne (Some nm) ad m returnedObjTy - | _ -> [] - match epinfos with - | [pinfo] when pinfo.HasSetter && not pinfo.IsIndexer -> - let pminfo = pinfo.SetterMethod - let pminst = match minfo with - | MethInfo.FSMeth(_, TType.TType_app(_, types), _, _) -> types - | _ -> freshenMethInfo m pminfo - - let pminst = match tyargsOpt with - | Some(TType.TType_app(_, types)) -> types - | _ -> pminst - Choice1Of2(AssignedItemSetter(id, AssignedPropSetter(pinfo, pminfo, pminst), e)) - | _ -> - match infoReader.GetILFieldInfosOfType(Some(nm), ad, m, returnedObjTy) with - | finfo :: _ -> - Choice1Of2(AssignedItemSetter(id, AssignedILFieldSetter(finfo), e)) - | _ -> - match infoReader.TryFindRecdOrClassFieldInfoOfType(nm, m, returnedObjTy) with - | ValueSome rfinfo -> - Choice1Of2(AssignedItemSetter(id, AssignedRecdFieldSetter(rfinfo), e)) - | _ -> - Choice2Of2(arg)) - - let names = System.Collections.Generic.HashSet<_>() - for CallerNamedArg(nm, _) in namedCallerArgs do - if not (names.Add nm.idText) then - errorR(Error(FSComp.SR.typrelNamedArgumentHasBeenAssignedMoreThenOnce nm.idText, m)) - - let argSet = { UnnamedCalledArgs=unnamedCalledArgs; UnnamedCallerArgs=unnamedCallerArgs; ParamArrayCalledArgOpt=paramArrayCalledArgOpt; ParamArrayCallerArgs=paramArrayCallerArgs; AssignedNamedArgs=assignedNamedArgs } - - (argSet, assignedNamedProps, unassignedNamedItems, attributeAssignedNamedItems, unnamedCalledOptArgs, unnamedCalledOutArgs)) - - let argSets = argSetInfos |> List.map (fun (x, _, _, _, _, _) -> x) - let assignedNamedProps = argSetInfos |> List.collect (fun (_, x, _, _, _, _) -> x) - let unassignedNamedItems = argSetInfos |> List.collect (fun (_, _, x, _, _, _) -> x) - let attributeAssignedNamedItems = argSetInfos |> List.collect (fun (_, _, _, x, _, _) -> x) - let unnamedCalledOptArgs = argSetInfos |> List.collect (fun (_, _, _, _, x, _) -> x) - let unnamedCalledOutArgs = argSetInfos |> List.collect (fun (_, _, _, _, _, x) -> x) - - member x.infoReader = infoReader - - member x.amap = infoReader.amap - - /// the method we're attempting to call - member x.Method = minfo - - /// the instantiation of the method we're attempting to call - member x.CalledTyArgs = calledTyArgs - - member x.AllCalledArgs = fullCurriedCalledArgs - - /// the instantiation of the method we're attempting to call - member x.CalledTyparInst = - let tps = minfo.FormalMethodTypars - if tps.Length = calledTyArgs.Length then mkTyparInst tps calledTyArgs else [] - - /// the formal instantiation of the method we're attempting to call - member x.CallerTyArgs = callerTyArgs - - /// The types of the actual object arguments, if any - member x.CallerObjArgTys = callerObjArgTys - - /// The argument analysis for each set of curried arguments - member x.ArgSets = argSets - - /// return type after implicit deference of byref returns is taken into account - member x.CalledReturnTypeAfterByrefDeref = - let retTy = methodRetTy - if isByrefTy g retTy then destByrefTy g retTy else retTy - - /// return type after tupling of out args is taken into account - member x.CalledReturnTypeAfterOutArgTupling = - let retTy = x.CalledReturnTypeAfterByrefDeref - if isNil unnamedCalledOutArgs then - retTy - else - let outArgTys = unnamedCalledOutArgs |> List.map (fun calledArg -> destByrefTy g calledArg.CalledArgumentType) - if isUnitTy g retTy then mkRefTupledTy g outArgTys - else mkRefTupledTy g (retTy :: outArgTys) - - /// named setters - member x.AssignedItemSetters = assignedNamedProps - - /// the property related to the method we're attempting to call, if any - member x.AssociatedPropertyInfo = pinfoOpt - - /// unassigned args - member x.UnassignedNamedArgs = unassignedNamedItems - - /// args assigned to specify values for attribute fields and properties (these are not necessarily "property sets") - member x.AttributeAssignedNamedArgs = attributeAssignedNamedItems - - /// unnamed called optional args: pass defaults for these - member x.UnnamedCalledOptArgs = unnamedCalledOptArgs - - /// unnamed called out args: return these as part of the return tuple - member x.UnnamedCalledOutArgs = unnamedCalledOutArgs - - static member GetMethod (x: CalledMeth<'T>) = x.Method - - member x.NumArgSets = x.ArgSets.Length - - member x.HasOptArgs = not (isNil x.UnnamedCalledOptArgs) - - member x.HasOutArgs = not (isNil x.UnnamedCalledOutArgs) - - member x.UsesParamArrayConversion = x.ArgSets |> List.exists (fun argSet -> argSet.ParamArrayCalledArgOpt.IsSome) - - member x.ParamArrayCalledArgOpt = x.ArgSets |> List.tryPick (fun argSet -> argSet.ParamArrayCalledArgOpt) - - member x.ParamArrayCallerArgs = x.ArgSets |> List.tryPick (fun argSet -> if Option.isSome argSet.ParamArrayCalledArgOpt then Some argSet.ParamArrayCallerArgs else None ) - - member x.GetParamArrayElementType() = - // turned as a method to avoid assert in variable inspector - assert (x.UsesParamArrayConversion) - x.ParamArrayCalledArgOpt.Value.CalledArgumentType |> destArrayTy x.amap.g - - member x.NumAssignedProps = x.AssignedItemSetters.Length - - member x.CalledObjArgTys(m) = - match x.Method.GetObjArgTypes(x.amap, m, x.CalledTyArgs) with - | [ thisArgTy ] when isByrefTy g thisArgTy -> [ destByrefTy g thisArgTy ] - | res -> res - - member x.NumCalledTyArgs = x.CalledTyArgs.Length - - member x.NumCallerTyArgs = x.CallerTyArgs.Length - - member x.AssignsAllNamedArgs = isNil x.UnassignedNamedArgs - - member x.HasCorrectArity = - (x.NumCalledTyArgs = x.NumCallerTyArgs) && - x.ArgSets |> List.forall (fun argSet -> argSet.NumUnnamedCalledArgs = argSet.NumUnnamedCallerArgs) - - member x.HasCorrectGenericArity = - (x.NumCalledTyArgs = x.NumCallerTyArgs) - - member x.IsAccessible(m, ad) = - IsMethInfoAccessible x.amap m ad x.Method - - member x.HasCorrectObjArgs(m) = - x.CalledObjArgTys(m).Length = x.CallerObjArgTys.Length - - member x.IsCandidate(m, ad) = - x.IsAccessible(m, ad) && - x.HasCorrectArity && - x.HasCorrectObjArgs(m) && - x.AssignsAllNamedArgs - - member x.AssignedUnnamedArgs = - // We use Seq.map2 to tolerate there being mismatched caller/called args - x.ArgSets |> List.map (fun argSet -> - (argSet.UnnamedCalledArgs, argSet.UnnamedCallerArgs) ||> Seq.map2 (fun calledArg callerArg -> - { NamedArgIdOpt=None; CalledArg=calledArg; CallerArg=callerArg }) |> Seq.toList) - - member x.AssignedNamedArgs = - x.ArgSets |> List.map (fun argSet -> argSet.AssignedNamedArgs) - - member x.AllUnnamedCalledArgs = x.ArgSets |> List.collect (fun x -> x.UnnamedCalledArgs) - - member x.TotalNumUnnamedCalledArgs = x.ArgSets |> List.sumBy (fun x -> x.NumUnnamedCalledArgs) - - member x.TotalNumUnnamedCallerArgs = x.ArgSets |> List.sumBy (fun x -> x.NumUnnamedCallerArgs) - - member x.TotalNumAssignedNamedArgs = x.ArgSets |> List.sumBy (fun x -> x.NumAssignedNamedArgs) - - override x.ToString() = "call to " + minfo.ToString() - -let NamesOfCalledArgs (calledArgs: CalledArg list) = - calledArgs |> List.choose (fun x -> x.NameOpt) - -//------------------------------------------------------------------------- -// Helpers dealing with propagating type information in method overload resolution -//------------------------------------------------------------------------- - -type ArgumentAnalysis = +type CalledMeth<'T> = + + new: infoReader:InfoReader * + nameEnv:NameResolutionEnv option * + isCheckingAttributeCall:bool * + freshenMethInfo:(range -> MethInfo -> TypeInst) * + m:range * + ad:AccessorDomain * + minfo:MethInfo * + calledTyArgs:TType list * + callerTyArgs:TType list * + pinfoOpt:PropInfo option * + callerObjArgTys:TType list * + callerArgs:CallerArgs<'T> * + allowParamArgs:bool * + allowOutAndOptArgs:bool * + tyargsOpt:TType option -> CalledMeth<'T> + static member GetMethod: x:CalledMeth<'T> -> MethInfo + member CalledObjArgTys: m:range -> TType list + member GetParamArrayElementType: unit -> TType + member HasCorrectObjArgs: m:range -> bool + member IsAccessible: m:range * ad:AccessorDomain -> bool + member IsCandidate: m:range * ad:AccessorDomain -> bool + member AllCalledArgs: CalledArg list list + member AllUnnamedCalledArgs: CalledArg list + + /// The argument analysis for each set of curried arguments + member ArgSets: CalledMethArgSet<'T> list + + /// Named setters + member AssignedItemSetters: AssignedItemSetter<'T> list + member AssignedNamedArgs: AssignedCalledArg<'T> list list + member AssignedUnnamedArgs: AssignedCalledArg<'T> list list + member AssignsAllNamedArgs: bool + + /// The property related to the method we're attempting to call, if any + member AssociatedPropertyInfo: PropInfo option + + /// Args assigned to specify values for attribute fields and properties (these are not necessarily "property sets") + member AttributeAssignedNamedArgs: CallerNamedArg<'T> list + + /// The return type after implicit deference of byref returns is taken into account + member CalledReturnTypeAfterByrefDeref: TType + + /// Return type after tupling of out args is taken into account + member CalledReturnTypeAfterOutArgTupling: TType + + /// The instantiation of the method we're attempting to call + member CalledTyArgs: TType list + + /// The instantiation of the method we're attempting to call + member CalledTyparInst: TypedTreeOps.TyparInst + + /// The types of the actual object arguments, if any + member CallerObjArgTys: TType list + + /// The formal instantiation of the method we're attempting to call + member CallerTyArgs: TType list + member HasCorrectArity: bool + member HasCorrectGenericArity: bool + member HasOptArgs: bool + member HasOutArgs: bool + + /// The method we're attempting to call + member Method: MethInfo + member NumArgSets: int + member NumAssignedProps: int + member NumCalledTyArgs: int + member NumCallerTyArgs: int + member ParamArrayCalledArgOpt: CalledArg option + member ParamArrayCallerArgs: CallerArg<'T> list option + member TotalNumAssignedNamedArgs: int + member TotalNumUnnamedCalledArgs: int + member TotalNumUnnamedCallerArgs: int + + /// Unassigned args + member UnassignedNamedArgs: CallerNamedArg<'T> list + + /// Unnamed called optional args: pass defaults for these + member UnnamedCalledOptArgs: CalledArg list + + /// Unnamed called out args: return these as part of the return tuple + member UnnamedCalledOutArgs: CalledArg list + member UsesParamArrayConversion: bool + member amap: ImportMap + member infoReader: InfoReader + +val NamesOfCalledArgs: calledArgs:CalledArg list -> Ident list + +type ArgumentAnalysis = | NoInfo - | ArgDoesNotMatch + | ArgDoesNotMatch | CallerLambdaHasArgTypes of TType list | CalledArgMatchesType of TType -let InferLambdaArgsForLambdaPropagation origRhsExpr = - let rec loop e = - match e with - | SynExpr.Lambda (_, _, _, rest, _, _) -> 1 + loop rest - | SynExpr.MatchLambda _ -> 1 - | _ -> 0 - loop origRhsExpr +val ExamineMethodForLambdaPropagation: x:CalledMeth -> (ArgumentAnalysis list list * (Ident * ArgumentAnalysis) list list) option -let ExamineArgumentForLambdaPropagation (infoReader: InfoReader) (arg: AssignedCalledArg) = - let g = infoReader.g +/// Is this a 'base' call +val IsBaseCall: objArgs:Expr list -> bool - // Find the explicit lambda arguments of the caller. Ignore parentheses. - let argExpr = match arg.CallerArg.Expr with SynExpr.Paren (x, _, _, _) -> x | x -> x - let countOfCallerLambdaArg = InferLambdaArgsForLambdaPropagation argExpr - - // Adjust for Expression<_>, Func<_, _>, ... - let adjustedCalledArgTy = AdjustCalledArgType infoReader false false arg.CalledArg arg.CallerArg - if countOfCallerLambdaArg > 0 then - // Decompose the explicit function type of the target - let calledLambdaArgTys, _calledLambdaRetTy = stripFunTy g adjustedCalledArgTy - if calledLambdaArgTys.Length >= countOfCallerLambdaArg then - // success - CallerLambdaHasArgTypes calledLambdaArgTys - elif isDelegateTy g (if isLinqExpressionTy g adjustedCalledArgTy then destLinqExpressionTy g adjustedCalledArgTy else adjustedCalledArgTy) then - // delegate arity mismatch - ArgDoesNotMatch - else - // not a function type on the called side - no information - NoInfo - else - // not a lambda on the caller side - push information from caller to called - CalledArgMatchesType(adjustedCalledArgTy) - - -let ExamineMethodForLambdaPropagation (x: CalledMeth) = - let unnamedInfo = x.AssignedUnnamedArgs |> List.mapSquared (ExamineArgumentForLambdaPropagation x.infoReader) - let namedInfo = x.AssignedNamedArgs |> List.mapSquared (fun arg -> (arg.NamedArgIdOpt.Value, ExamineArgumentForLambdaPropagation x.infoReader arg)) - if unnamedInfo |> List.existsSquared (function CallerLambdaHasArgTypes _ -> true | _ -> false) || - namedInfo |> List.existsSquared (function (_, CallerLambdaHasArgTypes _) -> true | _ -> false) then - Some (unnamedInfo, namedInfo) - else - None - -//------------------------------------------------------------------------- -// Additional helpers for building method calls and doing TAST generation -//------------------------------------------------------------------------- - -/// Is this a 'base' call (in the sense of C#) -let IsBaseCall objArgs = - match objArgs with - | [Expr.Val (v, _, _)] when v.BaseOrThisInfo = BaseVal -> true - | _ -> false - -/// Compute whether we insert a 'coerce' on the 'this' pointer for an object model call -/// For example, when calling an interface method on a struct, or a method on a constrained -/// variable type. -let ComputeConstrainedCallInfo g amap m (objArgs, minfo: MethInfo) = - match objArgs with - | [objArgExpr] when not minfo.IsExtensionMember -> - let methObjTy = minfo.ApparentEnclosingType - let objArgTy = tyOfExpr g objArgExpr - if TypeDefinitelySubsumesTypeNoCoercion 0 g amap m methObjTy objArgTy - // Constrained calls to class types can only ever be needed for the three class types that - // are base types of value types - || (isClassTy g methObjTy && - (not (typeEquiv g methObjTy g.system_Object_ty || - typeEquiv g methObjTy g.system_Value_ty || - typeEquiv g methObjTy g.system_Enum_ty))) then - None - else - // The object argument is a value type or variable type and the target method is an interface or System.Object - // type. A .NET 2.0 generic constrained call is required - Some objArgTy - | _ -> - None - -/// Adjust the 'this' pointer before making a call -/// Take the address of a struct, and coerce to an interface/base/constraint type if necessary -let TakeObjAddrForMethodCall g amap (minfo: MethInfo) isMutable m objArgs f = - let ccallInfo = ComputeConstrainedCallInfo g amap m (objArgs, minfo) - - let wrap, objArgs = - - match objArgs with - | [objArgExpr] -> - - let hasCallInfo = ccallInfo.IsSome - let mustTakeAddress = hasCallInfo || minfo.ObjArgNeedsAddress(amap, m) - let objArgTy = tyOfExpr g objArgExpr - - let isMutable = - match isMutable with - | DefinitelyMutates - | NeverMutates - | AddressOfOp -> isMutable - | PossiblyMutates -> - // Check to see if the method is read-only. Perf optimization. - // If there is an extension member whose first arg is an inref, we must return NeverMutates. - if mustTakeAddress && (minfo.IsReadOnly || minfo.IsReadOnlyExtensionMember (amap, m)) then - NeverMutates - else - isMutable - - let wrap, objArgExprAddr, isReadOnly, _isWriteOnly = - mkExprAddrOfExpr g mustTakeAddress hasCallInfo isMutable objArgExpr None m - - // Extension members and calls to class constraints may need a coercion for their object argument - let objArgExprCoerced = - if not hasCallInfo && - not (TypeDefinitelySubsumesTypeNoCoercion 0 g amap m minfo.ApparentEnclosingType objArgTy) then - mkCoerceExpr(objArgExprAddr, minfo.ApparentEnclosingType, m, objArgTy) - else - objArgExprAddr - - // Check to see if the extension member uses the extending type as a byref. - // If so, make sure we don't allow readonly/immutable values to be passed byref from an extension member. - // An inref will work though. - if isReadOnly && mustTakeAddress && minfo.IsExtensionMember then - minfo.TryObjArgByrefType(amap, m, minfo.FormalMethodInst) - |> Option.iter (fun ty -> - if not (isInByrefTy g ty) then - errorR(Error(FSComp.SR.tcCannotCallExtensionMethodInrefToByref(minfo.DisplayName), m))) - - - wrap, [objArgExprCoerced] - - | _ -> - id, objArgs - let e, ety = f ccallInfo objArgs - wrap e, ety - -//------------------------------------------------------------------------- -// Build method calls. -//------------------------------------------------------------------------- - -/// Build an expression node that is a call to a .NET method. -let BuildILMethInfoCall g amap m isProp (minfo: ILMethInfo) valUseFlags minst direct args = - let valu = isStructTy g minfo.ApparentEnclosingType - let ctor = minfo.IsConstructor - if minfo.IsClassConstructor then - error (InternalError (minfo.ILName+": cannot call a class constructor", m)) - let useCallvirt = - not valu && not direct && minfo.IsVirtual - let isProtected = minfo.IsProtectedAccessibility - let ilMethRef = minfo.ILMethodRef - let newobj = ctor && (match valUseFlags with NormalValUse -> true | _ -> false) - let exprTy = if ctor then minfo.ApparentEnclosingType else minfo.GetFSharpReturnTy(amap, m, minst) - let retTy = if not ctor && ilMethRef.ReturnType = ILType.Void then [] else [exprTy] - let isDllImport = minfo.IsDllImport g - Expr.Op (TOp.ILCall (useCallvirt, isProtected, valu, newobj, valUseFlags, isProp, isDllImport, ilMethRef, minfo.DeclaringTypeInst, minst, retTy), [], args, m), - exprTy - - -/// Build a call to an F# method. -/// -/// Consume the arguments in chunks and build applications. This copes with various F# calling signatures -/// all of which ultimately become 'methods'. -/// -/// QUERY: this looks overly complex considering that we are doing a fundamentally simple -/// thing here. -let BuildFSharpMethodApp g m (vref: ValRef) vexp vexprty (args: Exprs) = - let arities = (arityOfVal vref.Deref).AritiesOfArgs - - let args3, (leftover, retTy) = - let exprL expr = exprL g expr - ((args, vexprty), arities) ||> List.mapFold (fun (args, fty) arity -> - match arity, args with - | (0|1), [] when typeEquiv g (domainOfFunTy g fty) g.unit_ty -> mkUnit g m, (args, rangeOfFunTy g fty) - | 0, (arg :: argst) -> - let msg = Layout.showL (Layout.sepListL (Layout.rightL (Layout.TaggedTextOps.tagText ";")) (List.map exprL args)) - warning(InternalError(sprintf "Unexpected zero arity, args = %s" msg, m)) - arg, (argst, rangeOfFunTy g fty) - | 1, (arg :: argst) -> arg, (argst, rangeOfFunTy g fty) - | 1, [] -> error(InternalError("expected additional arguments here", m)) - | _ -> - if args.Length < arity then - error(InternalError("internal error in getting arguments, n = "+string arity+", #args = "+string args.Length, m)) - let tupargs, argst = List.splitAt arity args - let tuptys = tupargs |> List.map (tyOfExpr g) - (mkRefTupled g m tupargs tuptys), - (argst, rangeOfFunTy g fty) ) - if not leftover.IsEmpty then error(InternalError("Unexpected "+string(leftover.Length)+" remaining arguments in method application", m)) - mkApps g ((vexp, vexprty), [], args3, m), - retTy - -/// Build a call to an F# method. -let BuildFSharpMethodCall g m (ty, vref: ValRef) valUseFlags minst args = - let vexp = Expr.Val (vref, valUseFlags, m) - let vexpty = vref.Type - let tpsorig, tau = vref.TypeScheme - let vtinst = argsOfAppTy g ty @ minst - if tpsorig.Length <> vtinst.Length then error(InternalError("BuildFSharpMethodCall: unexpected List.length mismatch", m)) - let expr = mkTyAppExpr m (vexp, vexpty) vtinst - let exprty = instType (mkTyparInst tpsorig vtinst) tau - BuildFSharpMethodApp g m vref expr exprty args - +val BuildILMethInfoCall: g:TcGlobals -> amap:ImportMap -> m:range -> isProp:bool -> minfo:ILMethInfo -> valUseFlags:ValUseFlag -> minst:TType list -> direct:bool -> args:Exprs -> Expr * TType /// Make a call to a method info. Used by the optimizer and code generator to build /// calls to the type-directed solutions to member constraints. -let MakeMethInfoCall amap m minfo minst args = - let valUseFlags = NormalValUse // correct unless if we allow wild trait constraints like "T has a ctor and can be used as a parent class" - - match minfo with - - | ILMeth(g, ilminfo, _) -> - let direct = not minfo.IsVirtual - let isProp = false // not necessarily correct, but this is only used post-creflect where this flag is irrelevant - BuildILMethInfoCall g amap m isProp ilminfo valUseFlags minst direct args |> fst - - | FSMeth(g, ty, vref, _) -> - BuildFSharpMethodCall g m (ty, vref) valUseFlags minst args |> fst - - | DefaultStructCtor(_, ty) -> - mkDefault (m, ty) - -#if !NO_EXTENSIONTYPING - | ProvidedMeth(amap, mi, _, m) -> - let isProp = false // not necessarily correct, but this is only used post-creflect where this flag is irrelevant - let ilMethodRef = Import.ImportProvidedMethodBaseAsILMethodRef amap m mi - let isConstructor = mi.PUntaint((fun c -> c.IsConstructor), m) - let valu = mi.PUntaint((fun c -> c.DeclaringType.IsValueType), m) - let actualTypeInst = [] // GENERIC TYPE PROVIDERS: for generics, we would have something here - let actualMethInst = [] // GENERIC TYPE PROVIDERS: for generics, we would have something here - let ilReturnTys = Option.toList (minfo.GetCompiledReturnTy(amap, m, [])) // GENERIC TYPE PROVIDERS: for generics, we would have more here - // REVIEW: Should we allow protected calls? - Expr.Op (TOp.ILCall (false, false, valu, isConstructor, valUseFlags, isProp, false, ilMethodRef, actualTypeInst, actualMethInst, ilReturnTys), [], args, m) - -#endif - -#if !NO_EXTENSIONTYPING -// This imports a provided method, and checks if it is a known compiler intrinsic like "1 + 2" -let TryImportProvidedMethodBaseAsLibraryIntrinsic (amap: Import.ImportMap, m: range, mbase: Tainted) = - let methodName = mbase.PUntaint((fun x -> x.Name), m) - let declaringType = Import.ImportProvidedType amap m (mbase.PApply((fun x -> x.DeclaringType), m)) - match tryTcrefOfAppTy amap.g declaringType with - | ValueSome declaringEntity -> - if not declaringEntity.IsLocalRef && ccuEq declaringEntity.nlr.Ccu amap.g.fslibCcu then - let n = mbase.PUntaint((fun x -> x.GetParameters().Length), m) - match amap.g.knownIntrinsics.TryGetValue ((declaringEntity.LogicalName, None, methodName, n)) with - | true, vref -> Some vref - | _ -> - match amap.g.knownFSharpCoreModules.TryGetValue declaringEntity.LogicalName with - | true, modRef -> - modRef.ModuleOrNamespaceType.AllValsByLogicalName - |> Seq.tryPick (fun (KeyValue(_, v)) -> if (v.CompiledName amap.g.CompilerGlobalState) = methodName then Some (mkNestedValRef modRef v) else None) - | _ -> None - else - None - | _ -> - None -#endif - +val MakeMethInfoCall: amap:ImportMap -> m:range -> minfo:MethInfo -> minst:TType list -> args:Exprs -> Expr /// Build an expression that calls a given method info. /// This is called after overload resolution, and also to call other @@ -883,930 +252,60 @@ let TryImportProvidedMethodBaseAsLibraryIntrinsic (amap: Import.ImportMap, m: ra // minst: the instantiation to apply for a generic method // objArgs: the 'this' argument, if any // args: the arguments, if any -let BuildMethodCall tcVal g amap isMutable m isProp minfo valUseFlags minst objArgs args = - let direct = IsBaseCall objArgs - - TakeObjAddrForMethodCall g amap minfo isMutable m objArgs (fun ccallInfo objArgs -> - let allArgs = objArgs @ args - let valUseFlags = - if direct && (match valUseFlags with NormalValUse -> true | _ -> false) then - VSlotDirectCall - else - match ccallInfo with - | Some ty -> - // printfn "possible constrained call to '%s' at %A" minfo.LogicalName m - PossibleConstrainedCall ty - | None -> - valUseFlags - - match minfo with -#if !NO_EXTENSIONTYPING - // By this time this is an erased method info, e.g. one returned from an expression - // REVIEW: copied from tastops, which doesn't allow protected methods - | ProvidedMeth (amap, providedMeth, _, _) -> - // TODO: there is a fair bit of duplication here with mk_il_minfo_call. We should be able to merge these - - /// Build an expression node that is a call to a extension method in a generated assembly - let enclTy = minfo.ApparentEnclosingType - // prohibit calls to methods that are declared in specific array types (Get, Set, Address) - // these calls are provided by the runtime and should not be called from the user code - if isArrayTy g enclTy then - let tpe = TypeProviderError(FSComp.SR.tcRuntimeSuppliedMethodCannotBeUsedInUserCode(minfo.DisplayName), providedMeth.TypeProviderDesignation, m) - error tpe - let valu = isStructTy g enclTy - let isCtor = minfo.IsConstructor - if minfo.IsClassConstructor then - error (InternalError (minfo.LogicalName + ": cannot call a class constructor", m)) - let useCallvirt = not valu && not direct && minfo.IsVirtual - let isProtected = minfo.IsProtectedAccessibility - let exprTy = if isCtor then enclTy else minfo.GetFSharpReturnTy(amap, m, minst) - match TryImportProvidedMethodBaseAsLibraryIntrinsic (amap, m, providedMeth) with - | Some fsValRef -> - //reraise() calls are converted to TOp.Reraise in the type checker. So if a provided expression includes a reraise call - // we must put it in that form here. - if valRefEq amap.g fsValRef amap.g.reraise_vref then - mkReraise m exprTy, exprTy - else - let vexp, vexpty = tcVal fsValRef valUseFlags (minfo.DeclaringTypeInst @ minst) m - BuildFSharpMethodApp g m fsValRef vexp vexpty allArgs - | None -> - let ilMethRef = Import.ImportProvidedMethodBaseAsILMethodRef amap m providedMeth - let isNewObj = isCtor && (match valUseFlags with NormalValUse -> true | _ -> false) - let actualTypeInst = - if isRefTupleTy g enclTy then argsOfAppTy g (mkCompiledTupleTy g false (destRefTupleTy g enclTy)) // provided expressions can include method calls that get properties of tuple types - elif isFunTy g enclTy then [ domainOfFunTy g enclTy; rangeOfFunTy g enclTy ] // provided expressions can call Invoke - else minfo.DeclaringTypeInst - let actualMethInst = minst - let retTy = if not isCtor && (ilMethRef.ReturnType = ILType.Void) then [] else [exprTy] - let noTailCall = false - let expr = Expr.Op (TOp.ILCall (useCallvirt, isProtected, valu, isNewObj, valUseFlags, isProp, noTailCall, ilMethRef, actualTypeInst, actualMethInst, retTy), [], allArgs, m) - expr, exprTy - -#endif - - // Build a call to a .NET method - | ILMeth(_, ilMethInfo, _) -> - BuildILMethInfoCall g amap m isProp ilMethInfo valUseFlags minst direct allArgs - - // Build a call to an F# method - | FSMeth(_, _, vref, _) -> - - // Go see if this is a use of a recursive definition... Note we know the value instantiation - // we want to use so we pass that in order not to create a new one. - let vexp, vexpty = tcVal vref valUseFlags (minfo.DeclaringTypeInst @ minst) m - BuildFSharpMethodApp g m vref vexp vexpty allArgs - - // Build a 'call' to a struct default constructor - | DefaultStructCtor (g, ty) -> - if not (TypeHasDefaultValue g m ty) then - errorR(Error(FSComp.SR.tcDefaultStructConstructorCall(), m)) - mkDefault (m, ty), ty) - -//------------------------------------------------------------------------- -// Adjust caller arguments as part of building a method call -//------------------------------------------------------------------------- +val BuildMethodCall: + tcVal:(ValRef -> ValUseFlag -> TType list -> range -> Expr * TType) -> + g:TcGlobals -> + amap:ImportMap -> + isMutable:TypedTreeOps.Mutates -> + m:range -> + isProp:bool -> + minfo:MethInfo -> + valUseFlags:ValUseFlag -> + minst:TType list -> + objArgs:Expr list -> + args:Expr list + -> Expr * TType /// Build a call to the System.Object constructor taking no arguments, -let BuildObjCtorCall (g: TcGlobals) m = - let ilMethRef = (mkILCtorMethSpecForTy(g.ilg.typ_Object, [])).MethodRef - Expr.Op (TOp.ILCall (false, false, false, false, CtorValUsedAsSuperInit, false, true, ilMethRef, [], [], [g.obj_ty]), [], [], m) +val BuildObjCtorCall: g:TcGlobals -> m:range -> Expr /// Implements the elaborated form of adhoc conversions from functions to delegates at member callsites -let BuildNewDelegateExpr (eventInfoOpt: EventInfo option, g, amap, delegateTy, invokeMethInfo: MethInfo, delArgTys, f, fty, m) = - let slotsig = invokeMethInfo.GetSlotSig(amap, m) - let delArgVals, expr = - let topValInfo = ValReprInfo([], List.replicate (max 1 (List.length delArgTys)) ValReprInfo.unnamedTopArg, ValReprInfo.unnamedRetVal) - - // Try to pull apart an explicit lambda and use it directly - // Don't do this in the case where we're adjusting the arguments of a function used to build a .NET-compatible event handler - let lambdaContents = - if Option.isSome eventInfoOpt then - None - else - tryDestTopLambda g amap topValInfo (f, fty) - - match lambdaContents with - | None -> - - if List.exists (isByrefTy g) delArgTys then - error(Error(FSComp.SR.tcFunctionRequiresExplicitLambda(List.length delArgTys), m)) - - let delArgVals = delArgTys |> List.mapi (fun i argty -> fst (mkCompGenLocal m ("delegateArg" + string i) argty)) - let expr = - let args = - match eventInfoOpt with - | Some einfo -> - match delArgVals with - | [] -> error(nonStandardEventError einfo.EventName m) - | h :: _ when not (isObjTy g h.Type) -> error(nonStandardEventError einfo.EventName m) - | h :: t -> [exprForVal m h; mkRefTupledVars g m t] - | None -> - if isNil delArgTys then [mkUnit g m] else List.map (exprForVal m) delArgVals - mkApps g ((f, fty), [], args, m) - delArgVals, expr - - | Some _ -> - let _, _, _, vsl, body, _ = IteratedAdjustArityOfLambda g amap topValInfo f - List.concat vsl, body - - let meth = TObjExprMethod(slotsig, [], [], [delArgVals], expr, m) - mkObjExpr(delegateTy, None, BuildObjCtorCall g m, [meth], [], m) - -let CoerceFromFSharpFuncToDelegate g amap infoReader ad callerArgTy m callerArgExpr delegateTy = - let (SigOfFunctionForDelegate(invokeMethInfo, delArgTys, _, _)) = GetSigOfFunctionForDelegate infoReader delegateTy m ad - BuildNewDelegateExpr (None, g, amap, delegateTy, invokeMethInfo, delArgTys, callerArgExpr, callerArgTy, m) - -// Handle adhoc argument conversions -let AdjustCallerArgExprForCoercions (g: TcGlobals) amap infoReader ad isOutArg calledArgTy (reflArgInfo: ReflectedArgInfo) callerArgTy m callerArgExpr = - if isByrefTy g calledArgTy && isRefCellTy g callerArgTy then - None, Expr.Op (TOp.RefAddrGet false, [destRefCellTy g callerArgTy], [callerArgExpr], m) - -#if IMPLICIT_ADDRESS_OF - elif isInByrefTy g calledArgTy && not (isByrefTy g callerArgTy) then - let wrap, callerArgExprAddress, _readonly, _writeonly = mkExprAddrOfExpr g true false NeverMutates callerArgExpr None m - Some wrap, callerArgExprAddress -#endif - - elif isDelegateTy g calledArgTy && isFunTy g callerArgTy then - None, CoerceFromFSharpFuncToDelegate g amap infoReader ad callerArgTy m callerArgExpr calledArgTy - - elif isLinqExpressionTy g calledArgTy && isDelegateTy g (destLinqExpressionTy g calledArgTy) && isFunTy g callerArgTy then - let delegateTy = destLinqExpressionTy g calledArgTy - let expr = CoerceFromFSharpFuncToDelegate g amap infoReader ad callerArgTy m callerArgExpr delegateTy - None, mkCallQuoteToLinqLambdaExpression g m delegateTy (Expr.Quote (expr, ref None, false, m, mkQuotedExprTy g delegateTy)) - - // auto conversions to quotations (to match auto conversions to LINQ expressions) - elif reflArgInfo.AutoQuote && isQuotedExprTy g calledArgTy && not (isQuotedExprTy g callerArgTy) then - match reflArgInfo with - | ReflectedArgInfo.Quote true -> - None, mkCallLiftValueWithDefn g m calledArgTy callerArgExpr - | ReflectedArgInfo.Quote false -> - None, Expr.Quote (callerArgExpr, ref None, false, m, calledArgTy) - | ReflectedArgInfo.None -> failwith "unreachable" // unreachable due to reflArgInfo.AutoQuote condition - - // Note: out args do not need to be coerced - elif isOutArg then - None, callerArgExpr - - // Note: not all these casts are reported in quotations - else - None, mkCoerceIfNeeded g calledArgTy callerArgTy callerArgExpr - -/// Some of the code below must allocate temporary variables or bind other variables to particular values. -/// As usual we represent variable allocators by expr -> expr functions -/// which we then use to wrap the whole expression. These will either do nothing or pre-bind a variable. It doesn't -/// matter what order they are applied in as long as they are all composed together. -let emptyPreBinder (e: Expr) = e - -/// Get the expression that must be inserted on the caller side for a CallerSide optional arg, -/// i.e. one where there is no corresponding caller arg. -let rec GetDefaultExpressionForCallerSideOptionalArg tcFieldInit g (calledArg: CalledArg) currCalledArgTy currDfltVal eCallerMemberName mMethExpr = - match currDfltVal with - | MissingValue -> - // Add an I_nop if this is an initonly field to make sure we never recognize it as an lvalue. See mkExprAddrOfExpr. - emptyPreBinder, mkAsmExpr ([ mkNormalLdsfld (fspec_Missing_Value g); AI_nop ], [], [], [currCalledArgTy], mMethExpr) - - | DefaultValue -> - emptyPreBinder, mkDefault(mMethExpr, currCalledArgTy) - - | Constant fieldInit -> - match currCalledArgTy with - | NullableTy g inst when fieldInit <> ILFieldInit.Null -> - let nullableTy = mkILNonGenericBoxedTy(g.FindSysILTypeRef "System.Nullable`1") - let ctor = mkILCtorMethSpecForTy(nullableTy, [ILType.TypeVar 0us]).MethodRef - let ctorArgs = [Expr.Const (tcFieldInit mMethExpr fieldInit, mMethExpr, inst)] - emptyPreBinder, Expr.Op (TOp.ILCall (false, false, true, true, NormalValUse, false, false, ctor, [inst], [], [currCalledArgTy]), [], ctorArgs, mMethExpr) - | ByrefTy g inst -> - GetDefaultExpressionForCallerSideOptionalArg tcFieldInit g calledArg inst (PassByRef(inst, currDfltVal)) eCallerMemberName mMethExpr - | _ -> - match calledArg.CallerInfo, eCallerMemberName with - | CallerLineNumber, _ when typeEquiv g currCalledArgTy g.int_ty -> - emptyPreBinder, Expr.Const (Const.Int32(mMethExpr.StartLine), mMethExpr, currCalledArgTy) - | CallerFilePath, _ when typeEquiv g currCalledArgTy g.string_ty -> - let fileName = mMethExpr.FileName |> FileSystem.GetFullPathShim |> PathMap.apply g.pathMap - emptyPreBinder, Expr.Const (Const.String fileName, mMethExpr, currCalledArgTy) - | CallerMemberName, Some callerName when (typeEquiv g currCalledArgTy g.string_ty) -> - emptyPreBinder, Expr.Const (Const.String callerName, mMethExpr, currCalledArgTy) - | _ -> - emptyPreBinder, Expr.Const (tcFieldInit mMethExpr fieldInit, mMethExpr, currCalledArgTy) - - | WrapperForIDispatch -> - match g.TryFindSysILTypeRef "System.Runtime.InteropServices.DispatchWrapper" with - | None -> error(Error(FSComp.SR.fscSystemRuntimeInteropServicesIsRequired(), mMethExpr)) - | Some tref -> - let ty = mkILNonGenericBoxedTy tref - let mref = mkILCtorMethSpecForTy(ty, [g.ilg.typ_Object]).MethodRef - let expr = Expr.Op (TOp.ILCall (false, false, false, true, NormalValUse, false, false, mref, [], [], [g.obj_ty]), [], [mkDefault(mMethExpr, currCalledArgTy)], mMethExpr) - emptyPreBinder, expr - - | WrapperForIUnknown -> - match g.TryFindSysILTypeRef "System.Runtime.InteropServices.UnknownWrapper" with - | None -> error(Error(FSComp.SR.fscSystemRuntimeInteropServicesIsRequired(), mMethExpr)) - | Some tref -> - let ty = mkILNonGenericBoxedTy tref - let mref = mkILCtorMethSpecForTy(ty, [g.ilg.typ_Object]).MethodRef - let expr = Expr.Op (TOp.ILCall (false, false, false, true, NormalValUse, false, false, mref, [], [], [g.obj_ty]), [], [mkDefault(mMethExpr, currCalledArgTy)], mMethExpr) - emptyPreBinder, expr - - | PassByRef (ty, dfltVal2) -> - let v, _ = mkCompGenLocal mMethExpr "defaultByrefArg" ty - let wrapper2, rhs = GetDefaultExpressionForCallerSideOptionalArg tcFieldInit g calledArg currCalledArgTy dfltVal2 eCallerMemberName mMethExpr - (wrapper2 >> mkCompGenLet mMethExpr v rhs), mkValAddr mMethExpr false (mkLocalValRef v) - -/// Get the expression that must be inserted on the caller side for a CalleeSide optional arg where -/// no caller argument has been provided. Normally this is 'None', however CallerMemberName and friends -/// can be used with 'CalleeSide' optional arguments -let GetDefaultExpressionForCalleeSideOptionalArg g (calledArg: CalledArg) eCallerMemberName (mMethExpr: range) = - let calledArgTy = calledArg.CalledArgumentType - let calledNonOptTy = - if isOptionTy g calledArgTy then - destOptionTy g calledArgTy - else - calledArgTy // should be unreachable - - match calledArg.CallerInfo, eCallerMemberName with - | CallerLineNumber, _ when typeEquiv g calledNonOptTy g.int_ty -> - let lineExpr = Expr.Const(Const.Int32 mMethExpr.StartLine, mMethExpr, calledNonOptTy) - mkSome g calledNonOptTy lineExpr mMethExpr - | CallerFilePath, _ when typeEquiv g calledNonOptTy g.string_ty -> - let fileName = mMethExpr.FileName |> FileSystem.GetFullPathShim |> PathMap.apply g.pathMap - let filePathExpr = Expr.Const (Const.String(fileName), mMethExpr, calledNonOptTy) - mkSome g calledNonOptTy filePathExpr mMethExpr - | CallerMemberName, Some(callerName) when typeEquiv g calledNonOptTy g.string_ty -> - let memberNameExpr = Expr.Const (Const.String callerName, mMethExpr, calledNonOptTy) - mkSome g calledNonOptTy memberNameExpr mMethExpr - | _ -> - mkNone g calledNonOptTy mMethExpr +val BuildNewDelegateExpr: eventInfoOpt:EventInfo option * g:TcGlobals * amap:ImportMap * delegateTy:TType * invokeMethInfo:MethInfo * delArgTys:TType list * f:Expr * fty:TType * m:range -> Expr -/// Get the expression that must be inserted on the caller side for an optional arg where -/// no caller argument has been provided. -let GetDefaultExpressionForOptionalArg tcFieldInit g (calledArg: CalledArg) eCallerMemberName mItem (mMethExpr: range) = - let calledArgTy = calledArg.CalledArgumentType - let preBinder, expr = - match calledArg.OptArgInfo with - | NotOptional -> - error(InternalError("Unexpected NotOptional", mItem)) +val CoerceFromFSharpFuncToDelegate: g:TcGlobals -> amap:ImportMap -> infoReader:InfoReader -> ad:AccessorDomain -> callerArgTy:TType -> m:range -> callerArgExpr:Expr -> delegateTy:TType -> Expr - | CallerSide dfltVal -> - GetDefaultExpressionForCallerSideOptionalArg tcFieldInit g calledArg calledArgTy dfltVal eCallerMemberName mMethExpr - - | CalleeSide -> - emptyPreBinder, GetDefaultExpressionForCalleeSideOptionalArg g calledArg eCallerMemberName mMethExpr - - // Combine the variable allocators (if any) - let callerArg = CallerArg(calledArgTy, mMethExpr, false, expr) - preBinder, { NamedArgIdOpt = None; CalledArg = calledArg; CallerArg = callerArg } - -let MakeNullableExprIfNeeded (infoReader: InfoReader) calledArgTy callerArgTy callerArgExpr m = - let g = infoReader.g - let amap = infoReader.amap - if isNullableTy g callerArgTy then - callerArgExpr - else - let calledNonOptTy = destNullableTy g calledArgTy - let minfo = GetIntrinsicConstructorInfosOfType infoReader m calledArgTy |> List.head - let callerArgExprCoerced = mkCoerceIfNeeded g calledNonOptTy callerArgTy callerArgExpr - MakeMethInfoCall amap m minfo [] [callerArgExprCoerced] - -// Adjust all the optional arguments, filling in values for defaults, -let AdjustCallerArgForOptional tcFieldInit eCallerMemberName (infoReader: InfoReader) (assignedArg: AssignedCalledArg<_>) = - let g = infoReader.g - let callerArg = assignedArg.CallerArg - let (CallerArg(callerArgTy, m, isOptCallerArg, callerArgExpr)) = callerArg - let calledArg = assignedArg.CalledArg - let calledArgTy = calledArg.CalledArgumentType - match calledArg.OptArgInfo with - | NotOptional when not (g.langVersion.SupportsFeature LanguageFeature.NullableOptionalInterop) -> - if isOptCallerArg then errorR(Error(FSComp.SR.tcFormalArgumentIsNotOptional(), m)) - assignedArg - - // For non-nullable, non-optional arguments no conversion is needed. - // We return precisely the assignedArg. This also covers the case where there - // can be a lingering permitted type mismatch between caller argument and called argument, - // specifically caller can by `byref` and called `outref`. No coercion is inserted in the - // expression tree in this case. - | NotOptional when not (isNullableTy g calledArgTy) -> - if isOptCallerArg then errorR(Error(FSComp.SR.tcFormalArgumentIsNotOptional(), m)) - assignedArg - - | _ -> - - let callerArgExpr2 = - match calledArg.OptArgInfo with - | NotOptional -> - // T --> Nullable widening at callsites - if isOptCallerArg then errorR(Error(FSComp.SR.tcFormalArgumentIsNotOptional(), m)) - if isNullableTy g calledArgTy then - MakeNullableExprIfNeeded infoReader calledArgTy callerArgTy callerArgExpr m - else - failwith "unreachable" // see case above - - | CallerSide dfltVal -> - let calledArgTy = calledArg.CalledArgumentType - - if isOptCallerArg then - // CSharpMethod(?x=b) - if isOptionTy g callerArgTy then - if isNullableTy g calledArgTy then - // CSharpMethod(?x=b) when 'b' has optional type and 'x' has nullable type --> CSharpMethod(x=Option.toNullable b) - mkOptionToNullable g m (destOptionTy g callerArgTy) callerArgExpr - else - // CSharpMethod(?x=b) when 'b' has optional type and 'x' has non-nullable type --> CSharpMethod(x=Option.defaultValue DEFAULT v) - let _wrapper, defaultExpr = GetDefaultExpressionForCallerSideOptionalArg tcFieldInit g calledArg calledArgTy dfltVal eCallerMemberName m - let ty = destOptionTy g callerArgTy - mkOptionDefaultValue g m ty defaultExpr callerArgExpr - else - // This should be unreachable but the error will be reported elsewhere - callerArgExpr - else - if isNullableTy g calledArgTy then - // CSharpMethod(x=b) when 'x' has nullable type - // CSharpMethod(x=b) when both 'x' and 'b' have nullable type --> CSharpMethod(x=b) - // CSharpMethod(x=b) when 'x' has nullable type and 'b' does not --> CSharpMethod(x=Nullable(b)) - MakeNullableExprIfNeeded infoReader calledArgTy callerArgTy callerArgExpr m - else - // CSharpMethod(x=b) --> CSharpMethod(?x=b) - callerArgExpr - - | CalleeSide -> - if isOptCallerArg then - // CSharpMethod(?x=b) --> CSharpMethod(?x=b) - callerArgExpr - else - // CSharpMethod(x=b) when CSharpMethod(A) --> CSharpMethod(?x=Some(b :> A)) - if isOptionTy g calledArgTy then - let calledNonOptTy = destOptionTy g calledArgTy - let callerArgExprCoerced = mkCoerceIfNeeded g calledNonOptTy callerArgTy callerArgExpr - mkSome g calledNonOptTy callerArgExprCoerced m - else - assert false - callerArgExpr // defensive code - this case is unreachable - - let callerArg2 = CallerArg(tyOfExpr g callerArgExpr2, m, isOptCallerArg, callerArgExpr2) - { assignedArg with CallerArg=callerArg2 } - -// Handle CallerSide optional arguments. -// -// CallerSide optional arguments are largely for COM interop, e.g. to PIA assemblies for Word etc. -// As a result we follow the VB and C# behavior here. -// -// "1. If the parameter is statically typed as System.Object and does not have a value, then there are four cases: -// a. The parameter is marked with MarshalAs(IUnknown), MarshalAs(Interface), or MarshalAs(IDispatch). In this case we pass null. -// b. Else if the parameter is marked with IUnknownConstantAttribute. In this case we pass new System.Runtime.InteropServices.UnknownWrapper(null) -// c. Else if the parameter is marked with IDispatchConstantAttribute. In this case we pass new System.Runtime.InteropServices.DispatchWrapper(null) -// d. Else, we will pass Missing.Value. -// 2. Otherwise, if there is a value attribute, then emit the default value. -// 3. Otherwise, we emit default(T). -// 4. Finally, we apply conversions from the value to the parameter type. This is where the nullable conversions take place for VB. -// - VB allows you to mark ref parameters as optional. The semantics of this is that we create a temporary -// with type = type of parameter, load the optional value to it, and call the method. -// - VB also allows you to mark arrays with Nothing as the optional value. -// - VB also allows you to pass intrinsic values as optional values to parameters -// typed as Object. What we do in this case is we box the intrinsic value." -// -let AdjustCallerArgsForOptionals tcFieldInit eCallerMemberName (infoReader: InfoReader) (calledMeth: CalledMeth<_>) mItem mMethExpr = - let g = infoReader.g - - let assignedNamedArgs = calledMeth.ArgSets |> List.collect (fun argSet -> argSet.AssignedNamedArgs) - let unnamedCalledArgs = calledMeth.ArgSets |> List.collect (fun argSet -> argSet.UnnamedCalledArgs) - let unnamedCallerArgs = calledMeth.ArgSets |> List.collect (fun argSet -> argSet.UnnamedCallerArgs) - let unnamedArgs = - (unnamedCalledArgs, unnamedCallerArgs) ||> List.map2 (fun called caller -> - { NamedArgIdOpt = None; CalledArg=called; CallerArg=caller }) - - // Adjust all the optional arguments that require a default value to be inserted into the call, - // i.e. there is no corresponding caller arg. - let optArgs, optArgPreBinder = - (emptyPreBinder, calledMeth.UnnamedCalledOptArgs) ||> List.mapFold (fun preBinder calledArg -> - let preBinder2, arg = GetDefaultExpressionForOptionalArg tcFieldInit g calledArg eCallerMemberName mItem mMethExpr - arg, (preBinder >> preBinder2)) - - let adjustedNormalUnnamedArgs = List.map (AdjustCallerArgForOptional tcFieldInit eCallerMemberName infoReader) unnamedArgs - let adjustedAssignedNamedArgs = List.map (AdjustCallerArgForOptional tcFieldInit eCallerMemberName infoReader) assignedNamedArgs - - optArgs, optArgPreBinder, adjustedNormalUnnamedArgs, adjustedAssignedNamedArgs - -/// Adjust any 'out' arguments, passing in the address of a mutable local -let AdjustOutCallerArgs g (calledMeth: CalledMeth<_>) mMethExpr = - calledMeth.UnnamedCalledOutArgs |> List.map (fun calledArg -> - let calledArgTy = calledArg.CalledArgumentType - let outArgTy = destByrefTy g calledArgTy - let outv, outArgExpr = mkMutableCompGenLocal mMethExpr PrettyNaming.outArgCompilerGeneratedName outArgTy // mutable! - let expr = mkDefault (mMethExpr, outArgTy) - let callerArg = CallerArg (calledArgTy, mMethExpr, false, mkValAddr mMethExpr false (mkLocalValRef outv)) - let outArg = { NamedArgIdOpt=None;CalledArg=calledArg;CallerArg=callerArg } - outArg, outArgExpr, mkCompGenBind outv expr) - |> List.unzip3 - -/// Adjust any '[]' arguments, converting to an array -let AdjustParamArrayCallerArgs g amap infoReader ad (calledMeth: CalledMeth<_>) mMethExpr = - let argSets = calledMeth.ArgSets - - let paramArrayCallerArgs = argSets |> List.collect (fun argSet -> argSet.ParamArrayCallerArgs) - - match calledMeth.ParamArrayCalledArgOpt with - | None -> - [], [] - - | Some paramArrayCalledArg -> - let paramArrayCalledArgElementType = destArrayTy g paramArrayCalledArg.CalledArgumentType - - let paramArrayPreBinders, paramArrayExprs = - paramArrayCallerArgs - |> List.map (fun callerArg -> - let (CallerArg(callerArgTy, m, isOutArg, callerArgExpr)) = callerArg - AdjustCallerArgExprForCoercions g amap infoReader ad isOutArg paramArrayCalledArgElementType paramArrayCalledArg.ReflArgInfo callerArgTy m callerArgExpr) - |> List.unzip - - let paramArrayExpr = Expr.Op (TOp.Array, [paramArrayCalledArgElementType], paramArrayExprs, mMethExpr) - - let paramArrayCallerArg = - [ { NamedArgIdOpt = None - CalledArg=paramArrayCalledArg - CallerArg=CallerArg(paramArrayCalledArg.CalledArgumentType, mMethExpr, false, paramArrayExpr) } ] - - paramArrayPreBinders, paramArrayCallerArg +val AdjustCallerArgExprForCoercions: g:TcGlobals -> amap:ImportMap -> infoReader:InfoReader -> ad:AccessorDomain -> isOutArg:bool -> calledArgTy:TType -> reflArgInfo:ReflectedArgInfo -> callerArgTy:TType -> m:range -> callerArgExpr:Expr -> 'a option * Expr /// Build the argument list for a method call. Adjust for param array, optional arguments, byref arguments and coercions. /// For example, if you pass an F# reference cell to a byref then we must get the address of the /// contents of the ref. Likewise lots of adjustments are made for optional arguments etc. -let AdjustCallerArgs tcFieldInit eCallerMemberName (infoReader: InfoReader) ad (calledMeth: CalledMeth<_>) objArgs lambdaVars mItem mMethExpr = - let g = infoReader.g - let amap = infoReader.amap - let calledMethInfo = calledMeth.Method - - // For unapplied 'e.M' we first evaluate 'e' outside the lambda, i.e. 'let v = e in (fun arg -> v.CSharpMethod(arg))' - let objArgPreBinder, objArgs = - match objArgs, lambdaVars with - | [objArg], Some _ -> - if calledMethInfo.IsExtensionMember && calledMethInfo.ObjArgNeedsAddress(amap, mMethExpr) then - error(Error(FSComp.SR.tcCannotPartiallyApplyExtensionMethodForByref(calledMethInfo.DisplayName), mMethExpr)) - let objArgTy = tyOfExpr g objArg - let v, ve = mkCompGenLocal mMethExpr "objectArg" objArgTy - (fun body -> mkCompGenLet mMethExpr v objArg body), [ve] - | _ -> - emptyPreBinder, objArgs - - // Handle param array and optional arguments - let paramArrayPreBinders, paramArrayArgs = - AdjustParamArrayCallerArgs g amap infoReader ad calledMeth mMethExpr - - let optArgs, optArgPreBinder, adjustedNormalUnnamedArgs, adjustedFinalAssignedNamedArgs = - AdjustCallerArgsForOptionals tcFieldInit eCallerMemberName infoReader calledMeth mItem mMethExpr - - let outArgs, outArgExprs, outArgTmpBinds = - AdjustOutCallerArgs g calledMeth mMethExpr - - let allArgs = - adjustedNormalUnnamedArgs @ - adjustedFinalAssignedNamedArgs @ - paramArrayArgs @ - optArgs @ - outArgs - - let allArgs = - allArgs |> List.sortBy (fun x -> x.Position) - - let allArgsPreBinders, allArgsCoerced = - allArgs - |> List.map (fun assignedArg -> - let isOutArg = assignedArg.CalledArg.IsOutArg - let reflArgInfo = assignedArg.CalledArg.ReflArgInfo - let calledArgTy = assignedArg.CalledArg.CalledArgumentType - let (CallerArg(callerArgTy, m, _, e)) = assignedArg.CallerArg - - AdjustCallerArgExprForCoercions g amap infoReader ad isOutArg calledArgTy reflArgInfo callerArgTy m e) - |> List.unzip - - objArgPreBinder, objArgs, allArgsPreBinders, allArgs, allArgsCoerced, optArgPreBinder, paramArrayPreBinders, outArgExprs, outArgTmpBinds +val AdjustCallerArgs: + tcFieldInit:(range -> AbstractIL.IL.ILFieldInit -> Const) -> + eCallerMemberName:string option -> + infoReader:InfoReader -> + ad:AccessorDomain -> + calledMeth:CalledMeth -> + objArgs:Expr list -> + lambdaVars:'a option -> + mItem:range -> + mMethExpr:range -> + (Expr -> Expr) * Expr list * + 'b option list * AssignedCalledArg list * + Expr list * (Expr -> Expr) * + 'c option list * Expr list * + Binding list +val RecdFieldInstanceChecks: g:TcGlobals -> amap:ImportMap -> ad:AccessorDomain -> m:range -> rfinfo:RecdFieldInfo -> unit -//------------------------------------------------------------------------- -// Import provided expressions -//------------------------------------------------------------------------- +val ILFieldStaticChecks: g:TcGlobals -> amap:ImportMap -> infoReader:InfoReader -> ad:AccessorDomain -> m:range -> finfo:ILFieldInfo -> unit +val ILFieldInstanceChecks: g:TcGlobals -> amap:ImportMap -> ad:AccessorDomain -> m:range -> finfo:ILFieldInfo -> unit -#if !NO_EXTENSIONTYPING -// This file is not a great place for this functionality to sit, it's here because of BuildMethodCall -module ProvidedMethodCalls = - - let private convertConstExpr g amap m (constant : Tainted) = - let (obj, objTy) = constant.PApply2(id, m) - let ty = Import.ImportProvidedType amap m objTy - let normTy = normalizeEnumTy g ty - obj.PUntaint((fun v -> - let fail() = raise (TypeProviderError(FSComp.SR.etUnsupportedConstantType(v.GetType().ToString()), constant.TypeProviderDesignation, m)) - try - if isNull v then mkNull m ty else - let c = - match v with - | _ when typeEquiv g normTy g.bool_ty -> Const.Bool(v :?> bool) - | _ when typeEquiv g normTy g.sbyte_ty -> Const.SByte(v :?> sbyte) - | _ when typeEquiv g normTy g.byte_ty -> Const.Byte(v :?> byte) - | _ when typeEquiv g normTy g.int16_ty -> Const.Int16(v :?> int16) - | _ when typeEquiv g normTy g.uint16_ty -> Const.UInt16(v :?> uint16) - | _ when typeEquiv g normTy g.int32_ty -> Const.Int32(v :?> int32) - | _ when typeEquiv g normTy g.uint32_ty -> Const.UInt32(v :?> uint32) - | _ when typeEquiv g normTy g.int64_ty -> Const.Int64(v :?> int64) - | _ when typeEquiv g normTy g.uint64_ty -> Const.UInt64(v :?> uint64) - | _ when typeEquiv g normTy g.nativeint_ty -> Const.IntPtr(v :?> int64) - | _ when typeEquiv g normTy g.unativeint_ty -> Const.UIntPtr(v :?> uint64) - | _ when typeEquiv g normTy g.float32_ty -> Const.Single(v :?> float32) - | _ when typeEquiv g normTy g.float_ty -> Const.Double(v :?> float) - | _ when typeEquiv g normTy g.char_ty -> Const.Char(v :?> char) - | _ when typeEquiv g normTy g.string_ty -> Const.String(v :?> string) - | _ when typeEquiv g normTy g.decimal_ty -> Const.Decimal(v :?> decimal) - | _ when typeEquiv g normTy g.unit_ty -> Const.Unit - | _ -> fail() - Expr.Const (c, m, ty) - with _ -> fail() - ), range=m) - - /// Erasure over System.Type. - /// - /// This is a reimplementation of the logic of provided-type erasure, working entirely over (tainted, provided) System.Type - /// values. This is used when preparing ParameterInfo objects to give to the provider in GetInvokerExpression. - /// These ParameterInfo have erased ParameterType - giving the provider an erased type makes it considerably easier - /// to implement a correct GetInvokerExpression. - /// - /// Ideally we would implement this operation by converting to an F# TType using ImportSystemType, and then erasing, and then converting - /// back to System.Type. However, there is currently no way to get from an arbitrary F# TType (even the TType for - /// System.Object) to a System.Type to give to the type provider. - let eraseSystemType (amap, m, inputType) = - let rec loop (st: Tainted) = - if st.PUntaint((fun st -> st.IsGenericParameter), m) then st - elif st.PUntaint((fun st -> st.IsArray), m) then - let et = st.PApply((fun st -> st.GetElementType()), m) - let rank = st.PUntaint((fun st -> st.GetArrayRank()), m) - (loop et).PApply((fun st -> if rank = 1 then st.MakeArrayType() else st.MakeArrayType(rank)), m) - elif st.PUntaint((fun st -> st.IsByRef), m) then - let et = st.PApply((fun st -> st.GetElementType()), m) - (loop et).PApply((fun st -> st.MakeByRefType()), m) - elif st.PUntaint((fun st -> st.IsPointer), m) then - let et = st.PApply((fun st -> st.GetElementType()), m) - (loop et).PApply((fun st -> st.MakePointerType()), m) - else - let isGeneric = st.PUntaint((fun st -> st.IsGenericType), m) - let headType = if isGeneric then st.PApply((fun st -> st.GetGenericTypeDefinition()), m) else st - // We import in order to use IsProvidedErasedTycon, to make sure we at least don't reinvent that - let headTypeAsFSharpType = Import.ImportProvidedNamedType amap m headType - if headTypeAsFSharpType.IsProvidedErasedTycon then - let baseType = - st.PApply((fun st -> - match st.BaseType with - | null -> ProvidedType.CreateNoContext(typeof) // it might be an interface - | st -> st), m) - loop baseType - else - if isGeneric then - let genericArgs = st.PApplyArray((fun st -> st.GetGenericArguments()), "GetGenericArguments", m) - let typars = headTypeAsFSharpType.Typars(m) - // Drop the generic arguments that don't correspond to type arguments, i.e. are units-of-measure - let genericArgs = - [| for (genericArg, tp) in Seq.zip genericArgs typars do - if tp.Kind = TyparKind.Type then - yield genericArg |] - - if genericArgs.Length = 0 then - headType - else - let erasedArgTys = genericArgs |> Array.map loop - headType.PApply((fun st -> - let erasedArgTys = erasedArgTys |> Array.map (fun a -> a.PUntaintNoFailure(id)) - st.MakeGenericType erasedArgTys), m) - else - st - loop inputType - - let convertProvidedExpressionToExprAndWitness - tcVal - (thisArg: Expr option, - allArgs: Exprs, - paramVars: Tainted[], - g, amap, mut, isProp, isSuperInit, m, - expr: Tainted) = - - let varConv = - // note: using paramVars.Length as assumed initial size, but this might not - // be the optimal value; this wasn't checked before obsoleting Dictionary.ofList - let dict = Dictionary.newWithSize paramVars.Length - for v, e in Seq.zip (paramVars |> Seq.map (fun x -> x.PUntaint(id, m))) (Option.toList thisArg @ allArgs) do - dict.Add(v, (None, e)) - dict - let rec exprToExprAndWitness top (ea: Tainted) = - let fail() = error(Error(FSComp.SR.etUnsupportedProvidedExpression(ea.PUntaint((fun etree -> etree.UnderlyingExpressionString), m)), m)) - match ea with - | Tainted.Null -> error(Error(FSComp.SR.etNullProvidedExpression(ea.TypeProviderDesignation), m)) - | _ -> - let exprType = ea.PApplyOption((fun x -> x.GetExprType()), m) - let exprType = match exprType with | Some exprType -> exprType | None -> fail() - match exprType.PUntaint(id, m) with - | ProvidedTypeAsExpr (expr, targetTy) -> - let (expr, targetTy) = exprType.PApply2((fun _ -> (expr, targetTy)), m) - let srcExpr = exprToExpr expr - let targetTy = Import.ImportProvidedType amap m (targetTy.PApply(id, m)) - let sourceTy = Import.ImportProvidedType amap m (expr.PApply ((fun e -> e.Type), m)) - let te = mkCoerceIfNeeded g targetTy sourceTy srcExpr - None, (te, tyOfExpr g te) - | ProvidedTypeTestExpr (expr, targetTy) -> - let (expr, targetTy) = exprType.PApply2((fun _ -> (expr, targetTy)), m) - let srcExpr = exprToExpr expr - let targetTy = Import.ImportProvidedType amap m (targetTy.PApply(id, m)) - let te = mkCallTypeTest g m targetTy srcExpr - None, (te, tyOfExpr g te) - | ProvidedIfThenElseExpr (test, thenBranch, elseBranch) -> - let test, thenBranch, elseBranch = exprType.PApply3((fun _ -> (test, thenBranch, elseBranch)), m) - let testExpr = exprToExpr test - let ifTrueExpr = exprToExpr thenBranch - let ifFalseExpr = exprToExpr elseBranch - let te = mkCond NoDebugPointAtStickyBinding DebugPointForTarget.No m (tyOfExpr g ifTrueExpr) testExpr ifTrueExpr ifFalseExpr - None, (te, tyOfExpr g te) - | ProvidedVarExpr providedVar -> - let _, vTe = varToExpr (exprType.PApply((fun _ -> providedVar), m)) - None, (vTe, tyOfExpr g vTe) - | ProvidedConstantExpr (obj, prType) -> - let ce = convertConstExpr g amap m (exprType.PApply((fun _ -> (obj, prType)), m)) - None, (ce, tyOfExpr g ce) - | ProvidedNewTupleExpr info -> - let elems = exprType.PApplyArray((fun _ -> info), "GetInvokerExpression", m) - let elemsT = elems |> Array.map exprToExpr |> Array.toList - let exprT = mkRefTupledNoTypes g m elemsT - None, (exprT, tyOfExpr g exprT) - | ProvidedNewArrayExpr (ty, elems) -> - let ty, elems = exprType.PApply2((fun _ -> (ty, elems)), m) - let tyT = Import.ImportProvidedType amap m ty - let elems = elems.PApplyArray(id, "GetInvokerExpression", m) - let elemsT = elems |> Array.map exprToExpr |> Array.toList - let exprT = Expr.Op (TOp.Array, [tyT], elemsT, m) - None, (exprT, tyOfExpr g exprT) - | ProvidedTupleGetExpr (inp, n) -> - let inp, n = exprType.PApply2((fun _ -> (inp, n)), m) - let inpT = inp |> exprToExpr - // if type of expression is erased type then we need convert it to the underlying base type - let typeOfExpr = - let t = tyOfExpr g inpT - stripTyEqnsWrtErasure EraseMeasures g t - let tupInfo, tysT = tryDestAnyTupleTy g typeOfExpr - let exprT = mkTupleFieldGet g (tupInfo, inpT, tysT, n.PUntaint(id, m), m) - None, (exprT, tyOfExpr g exprT) - | ProvidedLambdaExpr (v, b) -> - let v, b = exprType.PApply2((fun _ -> (v, b)), m) - let vT = addVar v - let bT = exprToExpr b - removeVar v - let exprT = mkLambda m vT (bT, tyOfExpr g bT) - None, (exprT, tyOfExpr g exprT) - | ProvidedLetExpr (v, e, b) -> - let v, e, b = exprType.PApply3((fun _ -> (v, e, b)), m) - let eT = exprToExpr e - let vT = addVar v - let bT = exprToExpr b - removeVar v - let exprT = mkCompGenLet m vT eT bT - None, (exprT, tyOfExpr g exprT) - | ProvidedVarSetExpr (v, e) -> - let v, e = exprType.PApply2((fun _ -> (v, e)), m) - let eT = exprToExpr e - let vTopt, _ = varToExpr v - match vTopt with - | None -> - fail() - | Some vT -> - let exprT = mkValSet m (mkLocalValRef vT) eT - None, (exprT, tyOfExpr g exprT) - | ProvidedWhileLoopExpr (guardExpr, bodyExpr) -> - let guardExpr, bodyExpr = (exprType.PApply2((fun _ -> (guardExpr, bodyExpr)), m)) - let guardExprT = exprToExpr guardExpr - let bodyExprT = exprToExpr bodyExpr - let exprT = mkWhile g (DebugPointAtWhile.No, SpecialWhileLoopMarker.NoSpecialWhileLoopMarker, guardExprT, bodyExprT, m) - None, (exprT, tyOfExpr g exprT) - | ProvidedForIntegerRangeLoopExpr (v, e1, e2, e3) -> - let v, e1, e2, e3 = exprType.PApply4((fun _ -> (v, e1, e2, e3)), m) - let e1T = exprToExpr e1 - let e2T = exprToExpr e2 - let vT = addVar v - let e3T = exprToExpr e3 - removeVar v - let exprT = mkFastForLoop g (DebugPointAtFor.No, m, vT, e1T, true, e2T, e3T) - None, (exprT, tyOfExpr g exprT) - | ProvidedNewDelegateExpr (delegateTy, boundVars, delegateBodyExpr) -> - let delegateTy, boundVars, delegateBodyExpr = exprType.PApply3((fun _ -> (delegateTy, boundVars, delegateBodyExpr)), m) - let delegateTyT = Import.ImportProvidedType amap m delegateTy - let vs = boundVars.PApplyArray(id, "GetInvokerExpression", m) |> Array.toList - let vsT = List.map addVar vs - let delegateBodyExprT = exprToExpr delegateBodyExpr - List.iter removeVar vs - let lambdaExpr = mkLambdas m [] vsT (delegateBodyExprT, tyOfExpr g delegateBodyExprT) - let lambdaExprTy = tyOfExpr g lambdaExpr - let infoReader = InfoReader(g, amap) - let exprT = CoerceFromFSharpFuncToDelegate g amap infoReader AccessorDomain.AccessibleFromSomewhere lambdaExprTy m lambdaExpr delegateTyT - None, (exprT, tyOfExpr g exprT) -#if PROVIDED_ADDRESS_OF - | ProvidedAddressOfExpr e -> - let eT = exprToExpr (exprType.PApply((fun _ -> e), m)) - let wrap,ce, _readonly, _writeonly = mkExprAddrOfExpr g true false DefinitelyMutates eT None m - let ce = wrap ce - None, (ce, tyOfExpr g ce) -#endif - | ProvidedDefaultExpr pty -> - let ty = Import.ImportProvidedType amap m (exprType.PApply((fun _ -> pty), m)) - let ce = mkDefault (m, ty) - None, (ce, tyOfExpr g ce) - | ProvidedCallExpr (e1, e2, e3) -> - methodCallToExpr top ea (exprType.PApply((fun _ -> (e1, e2, e3)), m)) - | ProvidedSequentialExpr (e1, e2) -> - let e1, e2 = exprType.PApply2((fun _ -> (e1, e2)), m) - let e1T = exprToExpr e1 - let e2T = exprToExpr e2 - let ce = mkCompGenSequential m e1T e2T - None, (ce, tyOfExpr g ce) - | ProvidedTryFinallyExpr (e1, e2) -> - let e1, e2 = exprType.PApply2((fun _ -> (e1, e2)), m) - let e1T = exprToExpr e1 - let e2T = exprToExpr e2 - let ce = mkTryFinally g (e1T, e2T, m, tyOfExpr g e1T, DebugPointAtTry.No, DebugPointAtFinally.No) - None, (ce, tyOfExpr g ce) - | ProvidedTryWithExpr (e1, e2, e3, e4, e5) -> - let info = exprType.PApply((fun _ -> (e1, e2, e3, e4, e5)), m) - let bT = exprToExpr (info.PApply((fun (x, _, _, _, _) -> x), m)) - let v1 = info.PApply((fun (_, x, _, _, _) -> x), m) - let v1T = addVar v1 - let e1T = exprToExpr (info.PApply((fun (_, _, x, _, _) -> x), m)) - removeVar v1 - let v2 = info.PApply((fun (_, _, _, x, _) -> x), m) - let v2T = addVar v2 - let e2T = exprToExpr (info.PApply((fun (_, _, _, _, x) -> x), m)) - removeVar v2 - let ce = mkTryWith g (bT, v1T, e1T, v2T, e2T, m, tyOfExpr g bT, DebugPointAtTry.No, DebugPointAtWith.No) - None, (ce, tyOfExpr g ce) - | ProvidedNewObjectExpr (e1, e2) -> - None, ctorCallToExpr (exprType.PApply((fun _ -> (e1, e2)), m)) - - - and ctorCallToExpr (ne: Tainted<_>) = - let (ctor, args) = ne.PApply2(id, m) - let targetMethInfo = ProvidedMeth(amap, ctor.PApply((fun ne -> upcast ne), m), None, m) - let objArgs = [] - let arguments = [ for ea in args.PApplyArray(id, "GetInvokerExpression", m) -> exprToExpr ea ] - let callExpr = BuildMethodCall tcVal g amap Mutates.PossiblyMutates m false targetMethInfo isSuperInit [] objArgs arguments - callExpr - - and addVar (v: Tainted) = - let nm = v.PUntaint ((fun v -> v.Name), m) - let mut = v.PUntaint ((fun v -> v.IsMutable), m) - let vRaw = v.PUntaint (id, m) - let tyT = Import.ImportProvidedType amap m (v.PApply ((fun v -> v.Type), m)) - let vT, vTe = if mut then mkMutableCompGenLocal m nm tyT else mkCompGenLocal m nm tyT - varConv.[vRaw] <- (Some vT, vTe) - vT - - and removeVar (v: Tainted) = - let vRaw = v.PUntaint (id, m) - varConv.Remove vRaw |> ignore - - and methodCallToExpr top _origExpr (mce: Tainted<_>) = - let (objOpt, meth, args) = mce.PApply3(id, m) - let targetMethInfo = ProvidedMeth(amap, meth.PApply((fun mce -> upcast mce), m), None, m) - let objArgs = - match objOpt.PApplyOption(id, m) with - | None -> [] - | Some objExpr -> [exprToExpr objExpr] - - let arguments = [ for ea in args.PApplyArray(id, "GetInvokerExpression", m) -> exprToExpr ea ] - let genericArguments = - if meth.PUntaint((fun m -> m.IsGenericMethod), m) then - meth.PApplyArray((fun m -> m.GetGenericArguments()), "GetGenericArguments", m) - else - [| |] - let replacementGenericArguments = genericArguments |> Array.map (fun t->Import.ImportProvidedType amap m t) |> List.ofArray - - let mut = if top then mut else PossiblyMutates - let isSuperInit = if top then isSuperInit else ValUseFlag.NormalValUse - let isProp = if top then isProp else false - let callExpr = BuildMethodCall tcVal g amap mut m isProp targetMethInfo isSuperInit replacementGenericArguments objArgs arguments - Some meth, callExpr - - and varToExpr (pe: Tainted) = - // sub in the appropriate argument - // REVIEW: "thisArg" pointer should be first, if present - let vRaw = pe.PUntaint(id, m) - match varConv.TryGetValue vRaw with - | true, v -> v - | _ -> - let typeProviderDesignation = ExtensionTyping.DisplayNameOfTypeProvider (pe.TypeProvider, m) - error(NumberedError(FSComp.SR.etIncorrectParameterExpression(typeProviderDesignation, vRaw.Name), m)) - - and exprToExpr expr = - let _, (resExpr, _) = exprToExprAndWitness false expr - resExpr - - exprToExprAndWitness true expr - - - // fill in parameter holes in the expression - let TranslateInvokerExpressionForProvidedMethodCall tcVal (g, amap, mut, isProp, isSuperInit, mi: Tainted, objArgs, allArgs, m) = - let parameters = - mi.PApplyArray((fun mi -> mi.GetParameters()), "GetParameters", m) - let paramTys = - parameters - |> Array.map (fun p -> p.PApply((fun st -> st.ParameterType), m)) - let erasedParamTys = - paramTys - |> Array.map (fun pty -> eraseSystemType (amap, m, pty)) - let paramVars = - erasedParamTys - |> Array.mapi (fun i erasedParamTy -> erasedParamTy.PApply((fun ty -> ty.AsProvidedVar("arg" + i.ToString())), m)) - - - // encode "this" as the first ParameterExpression, if applicable - let thisArg, paramVars = - match objArgs with - | [objArg] -> - let erasedThisTy = eraseSystemType (amap, m, mi.PApply((fun mi -> mi.DeclaringType), m)) - let thisVar = erasedThisTy.PApply((fun ty -> ty.AsProvidedVar("this")), m) - Some objArg, Array.append [| thisVar |] paramVars - | [] -> None, paramVars - | _ -> failwith "multiple objArgs?" - - let ea = mi.PApplyWithProvider((fun (methodInfo, provider) -> ExtensionTyping.GetInvokerExpression(provider, methodInfo, [| for p in paramVars -> p.PUntaintNoFailure id |])), m) - - convertProvidedExpressionToExprAndWitness tcVal (thisArg, allArgs, paramVars, g, amap, mut, isProp, isSuperInit, m, ea) - - - let BuildInvokerExpressionForProvidedMethodCall tcVal (g, amap, mi: Tainted, objArgs, mut, isProp, isSuperInit, allArgs, m) = - try - let methInfoOpt, (expr, retTy) = TranslateInvokerExpressionForProvidedMethodCall tcVal (g, amap, mut, isProp, isSuperInit, mi, objArgs, allArgs, m) - - let exprty = GetCompiledReturnTyOfProvidedMethodInfo amap m mi |> GetFSharpViewOfReturnType g - let expr = mkCoerceIfNeeded g exprty retTy expr - methInfoOpt, expr, exprty - with - | :? TypeProviderError as tpe -> - let typeName = mi.PUntaint((fun mb -> mb.DeclaringType.FullName), m) - let methName = mi.PUntaint((fun mb -> mb.Name), m) - raise( tpe.WithContext(typeName, methName) ) // loses original stack trace -#endif - -let RecdFieldInstanceChecks g amap ad m (rfinfo: RecdFieldInfo) = - if rfinfo.IsStatic then error (Error (FSComp.SR.tcStaticFieldUsedWhenInstanceFieldExpected(), m)) - CheckRecdFieldInfoAttributes g rfinfo m |> CommitOperationResult - CheckRecdFieldInfoAccessible amap m ad rfinfo - -let ILFieldStaticChecks g amap infoReader ad m (finfo : ILFieldInfo) = - CheckILFieldInfoAccessible g amap m ad finfo - if not finfo.IsStatic then error (Error (FSComp.SR.tcFieldIsNotStatic(finfo.FieldName), m)) - - // Static IL interfaces fields are not supported in lower F# versions. - if isInterfaceTy g finfo.ApparentEnclosingType then - checkLanguageFeatureRuntimeErrorRecover infoReader LanguageFeature.DefaultInterfaceMemberConsumption m - checkLanguageFeatureErrorRecover g.langVersion LanguageFeature.DefaultInterfaceMemberConsumption m - - CheckILFieldAttributes g finfo m - -let ILFieldInstanceChecks g amap ad m (finfo : ILFieldInfo) = - if finfo.IsStatic then error (Error (FSComp.SR.tcStaticFieldUsedWhenInstanceFieldExpected(), m)) - CheckILFieldInfoAccessible g amap m ad finfo - CheckILFieldAttributes g finfo m +val MethInfoChecks: g:TcGlobals -> amap:ImportMap -> isInstance:bool -> tyargsOpt:'a option -> objArgs:Expr list -> ad:AccessorDomain -> m:range -> minfo:MethInfo -> unit -let MethInfoChecks g amap isInstance tyargsOpt objArgs ad m (minfo: MethInfo) = - if minfo.IsInstance <> isInstance then - if isInstance then - error (Error (FSComp.SR.csMethodIsNotAnInstanceMethod(minfo.LogicalName), m)) - else - error (Error (FSComp.SR.csMethodIsNotAStaticMethod(minfo.LogicalName), m)) +exception FieldNotMutable of TypedTreeOps.DisplayEnv * RecdFieldRef * range - // keep the original accessibility domain to determine type accessibility - let adOriginal = ad - // Eliminate the 'protected' portion of the accessibility domain for instance accesses - let ad = - match objArgs, ad with - | [objArg], AccessibleFrom(paths, Some tcref) -> - let objArgTy = tyOfExpr g objArg - let ty = generalizedTyconRef tcref - // We get to keep our rights if the type we're in subsumes the object argument type - if TypeFeasiblySubsumesType 0 g amap m ty CanCoerce objArgTy then - ad - // We get to keep our rights if this is a base call - elif IsBaseCall objArgs then - ad - else - AccessibleFrom(paths, None) - | _ -> ad - - if not (IsTypeAndMethInfoAccessible amap m adOriginal ad minfo) then - error (Error (FSComp.SR.tcMethodNotAccessible(minfo.LogicalName), m)) - - if isAnyTupleTy g minfo.ApparentEnclosingType && not minfo.IsExtensionMember && - (minfo.LogicalName.StartsWithOrdinal("get_Item") || minfo.LogicalName.StartsWithOrdinal("get_Rest")) then - warning (Error (FSComp.SR.tcTupleMemberNotNormallyUsed(), m)) - - CheckMethInfoAttributes g m tyargsOpt minfo |> CommitOperationResult - -exception FieldNotMutable of DisplayEnv * RecdFieldRef * range - -let CheckRecdFieldMutation m denv (rfinfo: RecdFieldInfo) = - if not rfinfo.RecdField.IsMutable then - errorR (FieldNotMutable (denv, rfinfo.RecdFieldRef, m)) +val CheckRecdFieldMutation: m:range -> denv:TypedTreeOps.DisplayEnv -> rfinfo:RecdFieldInfo -> unit /// Generate a witness for the given (solved) constraint. Five possiblilities are taken /// into account. @@ -1821,152 +320,26 @@ let CheckRecdFieldMutation m denv (rfinfo: RecdFieldInfo) = /// /// None is returned in the cases where the trait has not been solved (e.g. is part of generic code) /// or there is an unexpected mismatch of some kind. -let GenWitnessExpr amap g m (traitInfo: TraitConstraintInfo) argExprs = - - let sln = - match traitInfo.Solution with - | None -> Choice5Of5() - | Some sln -> - - // Given the solution information, reconstruct the MethInfo for the solution - match sln with - | ILMethSln(origTy, extOpt, mref, minst) -> - let metadataTy = convertToTypeWithMetadataIfPossible g origTy - let tcref = tcrefOfAppTy g metadataTy - let mdef = resolveILMethodRef tcref.ILTyconRawMetadata mref - let ilMethInfo = - match extOpt with - | None -> MethInfo.CreateILMeth(amap, m, origTy, mdef) - | Some ilActualTypeRef -> - let actualTyconRef = Import.ImportILTypeRef amap m ilActualTypeRef - MethInfo.CreateILExtensionMeth(amap, m, origTy, actualTyconRef, None, mdef) - Choice1Of5 (ilMethInfo, minst) - - | FSMethSln(ty, vref, minst) -> - Choice1Of5 (FSMeth(g, ty, vref, None), minst) - - | FSRecdFieldSln(tinst, rfref, isSetProp) -> - Choice2Of5 (tinst, rfref, isSetProp) - - | FSAnonRecdFieldSln(anonInfo, tinst, i) -> - Choice3Of5 (anonInfo, tinst, i) - - | ClosedExprSln expr -> - Choice4Of5 expr - - | BuiltInSln -> - Choice5Of5 () - - match sln with - | Choice1Of5(minfo, methArgTys) -> - let argExprs = - // FIX for #421894 - typechecker assumes that coercion can be applied for the trait - // calls arguments but codegen doesn't emit coercion operations - // result - generation of non-verifiable code - // fix - apply coercion for the arguments (excluding 'receiver' argument in instance calls) - - // flatten list of argument types (looks like trait calls with curried arguments are not supported so - // we can just convert argument list in straight-forward way) - let argTypes = - minfo.GetParamTypes(amap, m, methArgTys) - |> List.concat - - // do not apply coercion to the 'receiver' argument - let receiverArgOpt, argExprs = - if minfo.IsInstance then - match argExprs with - | h :: t -> Some h, t - | argExprs -> None, argExprs - else None, argExprs +val GenWitnessExpr: amap:ImportMap -> g:TcGlobals -> m:range -> traitInfo:TraitConstraintInfo -> argExprs:Expr list -> Expr option - // For methods taking no arguments, 'argExprs' will be a single unit expression here - let argExprs = - match argTypes, argExprs with - | [], [_] -> [] - | _ -> argExprs - - let convertedArgs = (argExprs, argTypes) ||> List.map2 (fun expr expectedTy -> mkCoerceIfNeeded g expectedTy (tyOfExpr g expr) expr) - match receiverArgOpt with - | Some r -> r :: convertedArgs - | None -> convertedArgs - - // Fix bug 1281: If we resolve to an instance method on a struct and we haven't yet taken - // the address of the object then go do that - if minfo.IsStruct && minfo.IsInstance then - match argExprs with - | h :: t when not (isByrefTy g (tyOfExpr g h)) -> - let wrap, h', _readonly, _writeonly = mkExprAddrOfExpr g true false PossiblyMutates h None m - Some (wrap (Expr.Op (TOp.TraitCall traitInfo, [], (h' :: t), m))) - | _ -> - Some (MakeMethInfoCall amap m minfo methArgTys argExprs) - else - Some (MakeMethInfoCall amap m minfo methArgTys argExprs) - - | Choice2Of5 (tinst, rfref, isSet) -> - match isSet, rfref.RecdField.IsStatic, argExprs.Length with - // static setter - | true, true, 1 -> - Some (mkStaticRecdFieldSet (rfref, tinst, argExprs.[0], m)) - - // instance setter - | true, false, 2 -> - // If we resolve to an instance field on a struct and we haven't yet taken - // the address of the object then go do that - if rfref.Tycon.IsStructOrEnumTycon && not (isByrefTy g (tyOfExpr g argExprs.[0])) then - let h = List.head argExprs - let wrap, h', _readonly, _writeonly = mkExprAddrOfExpr g true false DefinitelyMutates h None m - Some (wrap (mkRecdFieldSetViaExprAddr (h', rfref, tinst, argExprs.[1], m))) - else - Some (mkRecdFieldSetViaExprAddr (argExprs.[0], rfref, tinst, argExprs.[1], m)) - - // static getter - | false, true, 0 -> - Some (mkStaticRecdFieldGet (rfref, tinst, m)) - - // instance getter - | false, false, 1 -> - if rfref.Tycon.IsStructOrEnumTycon && isByrefTy g (tyOfExpr g argExprs.[0]) then - Some (mkRecdFieldGetViaExprAddr (argExprs.[0], rfref, tinst, m)) - else - Some (mkRecdFieldGet g (argExprs.[0], rfref, tinst, m)) - - | _ -> None - - | Choice3Of5 (anonInfo, tinst, i) -> - let tupInfo = anonInfo.TupInfo - if evalTupInfoIsStruct tupInfo && isByrefTy g (tyOfExpr g argExprs.[0]) then - Some (mkAnonRecdFieldGetViaExprAddr (anonInfo, argExprs.[0], tinst, i, m)) - else - Some (mkAnonRecdFieldGet g (anonInfo, argExprs.[0], tinst, i, m)) - - | Choice4Of5 expr -> - Some (MakeApplicationAndBetaReduce g (expr, tyOfExpr g expr, [], argExprs, m)) - - | Choice5Of5 () -> - match traitInfo.Solution with - | None -> None // the trait has been generalized - | Some _-> - // For these operators, the witness is just a call to the coresponding FSharp.Core operator - match g.TryMakeOperatorAsBuiltInWitnessInfo isStringTy isArrayTy traitInfo argExprs with - | Some (info, tyargs, actualArgExprs) -> - tryMkCallCoreFunctionAsBuiltInWitness g info tyargs actualArgExprs m - | None -> - // For all other built-in operators, the witness is a call to the coresponding BuiltInWitnesses operator - // These are called as F# methods not F# functions - tryMkCallBuiltInWitness g traitInfo argExprs m - /// Generate a lambda expression for the given solved trait. -let GenWitnessExprLambda amap g m (traitInfo: TraitConstraintInfo) = - let witnessInfo = traitInfo.TraitKey - let argtysl = GenWitnessArgTys g witnessInfo - let vse = argtysl |> List.mapiSquared (fun i j ty -> mkCompGenLocal m ("arg" + string i + "_" + string j) ty) - let vsl = List.mapSquared fst vse - match GenWitnessExpr amap g m traitInfo (List.concat (List.mapSquared snd vse)) with - | Some expr -> - Choice2Of2 (mkMemberLambdas m [] None None vsl (expr, tyOfExpr g expr)) - | None -> - Choice1Of2 traitInfo +val GenWitnessExprLambda: amap:ImportMap -> g:TcGlobals -> m:range -> traitInfo:TraitConstraintInfo -> Choice /// Generate the arguments passed for a set of (solved) traits in non-generic code -let GenWitnessArgs amap g m (traitInfos: TraitConstraintInfo list) = - [ for traitInfo in traitInfos -> GenWitnessExprLambda amap g m traitInfo ] +val GenWitnessArgs: amap:ImportMap -> g:TcGlobals -> m:range -> traitInfos:TraitConstraintInfo list -> Choice list + +#if !NO_EXTENSIONTYPING +module ProvidedMethodCalls = + val BuildInvokerExpressionForProvidedMethodCall: + tcVal:(ValRef -> ValUseFlag -> TType list -> range -> Expr * TType) -> + g:TcGlobals * + amap:ImportMap * + mi:Tainted * + objArgs:Expr list * + mut:TypedTreeOps.Mutates * + isProp:bool * + isSuperInit:ValUseFlag * + allArgs:Exprs * + m:range -> + Tainted option * Expr * TType +#endif diff --git a/src/fsharp/MethodOverrides.fsi b/src/fsharp/MethodOverrides.fsi index d5105e649dc..cc1d057cc28 100644 --- a/src/fsharp/MethodOverrides.fsi +++ b/src/fsharp/MethodOverrides.fsi @@ -3,909 +3,97 @@ /// Primary logic related to method overrides. module internal FSharp.Compiler.MethodOverrides -open FSharp.Compiler open FSharp.Compiler.AbstractIL.Internal.Library open FSharp.Compiler.AccessibilityLogic -open FSharp.Compiler.ErrorLogger open FSharp.Compiler.InfoReader -open FSharp.Compiler.Lib +open FSharp.Compiler.Import open FSharp.Compiler.Infos -open FSharp.Compiler.Features open FSharp.Compiler.NameResolution open FSharp.Compiler.Range open FSharp.Compiler.SyntaxTree -open FSharp.Compiler.SyntaxTreeOps open FSharp.Compiler.TcGlobals open FSharp.Compiler.TypedTree -open FSharp.Compiler.TypedTreeBasics open FSharp.Compiler.TypedTreeOps -open FSharp.Compiler.TypeRelations -//------------------------------------------------------------------------- -// Completeness of classes -//------------------------------------------------------------------------- - -type OverrideCanImplement = +type OverrideCanImplement = | CanImplementAnyInterfaceSlot | CanImplementAnyClassHierarchySlot | CanImplementAnySlot | CanImplementNoSlots - + /// The overall information about a method implementation in a class or object expression -type OverrideInfo = +type OverrideInfo = | Override of OverrideCanImplement * TyconRef * Ident * (Typars * TyparInst) * TType list list * TType option * bool * bool - member x.CanImplement = let (Override(a, _, _, _, _, _, _, _)) = x in a - member x.BoundingTyconRef = let (Override(_, ty, _, _, _, _, _, _)) = x in ty - member x.LogicalName = let (Override(_, _, id, _, _, _, _, _)) = x in id.idText - member x.Range = let (Override(_, _, id, _, _, _, _, _)) = x in id.idRange - member x.IsFakeEventProperty = let (Override(_, _, _, _, _, _, b, _)) = x in b - member x.ArgTypes = let (Override(_, _, _, _, b, _, _, _)) = x in b - member x.ReturnType = let (Override(_, _, _, _, _, b, _, _)) = x in b - member x.IsCompilerGenerated = let (Override(_, _, _, _, _, _, _, b)) = x in b - -type RequiredSlot = + + member ArgTypes: TType list list + + member BoundingTyconRef: TyconRef + + member CanImplement: OverrideCanImplement + + member IsCompilerGenerated: bool + + member IsFakeEventProperty: bool + + member LogicalName: string + + member Range: range + + member ReturnType: TType option + +type RequiredSlot = | RequiredSlot of MethInfo * isOptional: bool | DefaultInterfaceImplementationSlot of MethInfo * isOptional: bool * possiblyNoMostSpecific: bool - /// A slot which does not have to be implemented, because an inherited implementation is available. - member this.IsOptional = - match this with - | RequiredSlot(_, isOptional) - | DefaultInterfaceImplementationSlot(_, isOptional, _) -> isOptional - - /// A slot which has a default interface implementation. + /// Indicates a slot which has a default interface implementation. /// A combination of this flag and the lack of IsOptional means the slot may have been reabstracted. - member this.HasDefaultInterfaceImplementation = - match this with - | DefaultInterfaceImplementationSlot _ -> true - | _ -> false - - /// A slot that *might* have ambiguity due to multiple inheritance; happens with default interface implementations. - member this.PossiblyNoMostSpecificImplementation = - match this with - | DefaultInterfaceImplementationSlot(_, _, possiblyNoMostSpecific) -> possiblyNoMostSpecific - | _ -> false + member HasDefaultInterfaceImplementation: bool + + /// Indicates a slot which does not have to be implemented, because an inherited implementation is available. + member IsOptional: bool /// Gets the method info. - member this.MethodInfo = - match this with - | RequiredSlot(methInfo, _) - | DefaultInterfaceImplementationSlot(methInfo, _, _) -> methInfo + member MethodInfo: MethInfo + /// A slot that *might* have ambiguity due to multiple inheritance; happens with default interface implementations. + member PossiblyNoMostSpecificImplementation: bool + type SlotImplSet = SlotImplSet of RequiredSlot list * NameMultiMap * OverrideInfo list * PropInfo list exception TypeIsImplicitlyAbstract of range -exception OverrideDoesntOverride of DisplayEnv * OverrideInfo * MethInfo option * TcGlobals * Import.ImportMap * range - -module DispatchSlotChecking = - - /// Print the signature of an override to a buffer as part of an error message - let PrintOverrideToBuffer denv os (Override(_, _, id, (mtps, memberToParentInst), argTys, retTy, _, _)) = - let denv = { denv with showTyparBinding = true } - let retTy = (retTy |> GetFSharpViewOfReturnType denv.g) - let argInfos = - match argTys with - | [] -> [[(denv.g.unit_ty, ValReprInfo.unnamedTopArg1)]] - | _ -> argTys |> List.mapSquared (fun ty -> (ty, ValReprInfo.unnamedTopArg1)) - Layout.bufferL os (NicePrint.prettyLayoutOfMemberSig denv (memberToParentInst, id.idText, mtps, argInfos, retTy)) - /// Print the signature of a MethInfo to a buffer as part of an error message - let PrintMethInfoSigToBuffer g amap m denv os minfo = - let denv = { denv with showTyparBinding = true } - let (CompiledSig(argTys, retTy, fmtps, ttpinst)) = CompiledSigOfMeth g amap m minfo - let retTy = (retTy |> GetFSharpViewOfReturnType g) - let argInfos = argTys |> List.mapSquared (fun ty -> (ty, ValReprInfo.unnamedTopArg1)) - let nm = minfo.LogicalName - Layout.bufferL os (NicePrint.prettyLayoutOfMemberSig denv (ttpinst, nm, fmtps, argInfos, retTy)) +exception OverrideDoesntOverride of DisplayEnv * OverrideInfo * MethInfo option * TcGlobals * ImportMap * range +module DispatchSlotChecking = /// Format the signature of an override as a string as part of an error message - let FormatOverride denv d = bufs (fun buf -> PrintOverrideToBuffer denv buf d) + val FormatOverride: denv:DisplayEnv -> d:OverrideInfo -> string /// Format the signature of a MethInfo as a string as part of an error message - let FormatMethInfoSig g amap m denv d = bufs (fun buf -> PrintMethInfoSigToBuffer g amap m denv buf d) - - /// Get the override info for an existing (inherited) method being used to implement a dispatch slot. - let GetInheritedMemberOverrideInfo g amap m parentType (minfo: MethInfo) = - let nm = minfo.LogicalName - let (CompiledSig (argTys, retTy, fmtps, ttpinst)) = CompiledSigOfMeth g amap m minfo - - let isFakeEventProperty = minfo.IsFSharpEventPropertyMethod - Override(parentType, minfo.ApparentEnclosingTyconRef, mkSynId m nm, (fmtps, ttpinst), argTys, retTy, isFakeEventProperty, false) - - /// Get the override info for a value being used to implement a dispatch slot. - let GetTypeMemberOverrideInfo g reqdTy (overrideBy: ValRef) = - let _, _, argInfos, retTy, _ = GetTypeOfMemberInMemberForm g overrideBy - let nm = overrideBy.LogicalName - - let argTys = argInfos |> List.mapSquared fst - - let memberMethodTypars, memberToParentInst, argTys, retTy = - match PartitionValRefTypars g overrideBy with - | Some(_, _, memberMethodTypars, memberToParentInst, _tinst) -> - let argTys = argTys |> List.mapSquared (instType memberToParentInst) - let retTy = retTy |> Option.map (instType memberToParentInst) - memberMethodTypars, memberToParentInst, argTys, retTy - | None -> - error(Error(FSComp.SR.typrelMethodIsOverconstrained(), overrideBy.Range)) - let implKind = - if ValRefIsExplicitImpl g overrideBy then - - let belongsToReqdTy = - match overrideBy.MemberInfo.Value.ImplementedSlotSigs with - | [] -> false - | ss :: _ -> isInterfaceTy g ss.ImplementedType && typeEquiv g reqdTy ss.ImplementedType - if belongsToReqdTy then - CanImplementAnyInterfaceSlot - else - CanImplementNoSlots - else if overrideBy.IsDispatchSlotMember then - CanImplementNoSlots - // abstract slots can only implement interface slots - //CanImplementAnyInterfaceSlot <<----- Change to this to enable implicit interface implementation - - else - CanImplementAnyClassHierarchySlot - //CanImplementAnySlot <<----- Change to this to enable implicit interface implementation - - let isFakeEventProperty = overrideBy.IsFSharpEventProperty(g) - Override(implKind, overrideBy.MemberApparentEntity, mkSynId overrideBy.Range nm, (memberMethodTypars, memberToParentInst), argTys, retTy, isFakeEventProperty, overrideBy.IsCompilerGenerated) + val FormatMethInfoSig: g:TcGlobals -> amap:ImportMap -> m:range -> denv:DisplayEnv -> d:MethInfo -> string /// Get the override information for an object expression method being used to implement dispatch slots - let GetObjectExprOverrideInfo g amap (implty, id: Ident, memberFlags, ty, arityInfo, bindingAttribs, rhsExpr) = - // Dissect the type. The '0' indicates there are no enclosing generic class type parameters relevant here. - let tps, _, argInfos, retTy, _ = GetMemberTypeInMemberForm g memberFlags arityInfo 0 ty id.idRange - let argTys = argInfos |> List.mapSquared fst - // Dissect the implementation - let _, ctorThisValOpt, baseValOpt, vsl, rhsExpr, _ = destTopLambda g amap arityInfo (rhsExpr, ty) - assert ctorThisValOpt.IsNone - - // Drop 'this' - match vsl with - | [thisv] :: vs -> - // Check for empty variable list from a () arg - let vs = if vs.Length = 1 && argInfos.IsEmpty then [] else vs - let implKind = - if isInterfaceTy g implty then - CanImplementAnyInterfaceSlot - else - CanImplementAnyClassHierarchySlot - //CanImplementAnySlot <<----- Change to this to enable implicit interface implementation - let isFakeEventProperty = CompileAsEvent g bindingAttribs - let overrideByInfo = Override(implKind, tcrefOfAppTy g implty, id, (tps, []), argTys, retTy, isFakeEventProperty, false) - overrideByInfo, (baseValOpt, thisv, vs, bindingAttribs, rhsExpr) - | _ -> - error(InternalError("Unexpected shape for object expression override", id.idRange)) - - /// Check if an override matches a dispatch slot by name - let IsNameMatch (dispatchSlot: MethInfo) (overrideBy: OverrideInfo) = - (overrideBy.LogicalName = dispatchSlot.LogicalName) - - /// Check if an override matches a dispatch slot by name - let IsImplMatch g (dispatchSlot: MethInfo) (overrideBy: OverrideInfo) = - // If the override is listed as only relevant to one type, and we're matching it against an abstract slot of an interface type, - // then check that interface type is the right type. - match overrideBy.CanImplement with - | CanImplementNoSlots -> false - | CanImplementAnySlot -> true - | CanImplementAnyClassHierarchySlot -> not (isInterfaceTy g dispatchSlot.ApparentEnclosingType) - | CanImplementAnyInterfaceSlot -> isInterfaceTy g dispatchSlot.ApparentEnclosingType - - /// Check if the kinds of type parameters match between a dispatch slot and an override. - let IsTyparKindMatch (CompiledSig(_, _, fvmtps, _)) (Override(_, _, _, (mtps, _), _, _, _, _)) = - List.lengthsEqAndForall2 (fun (tp1: Typar) (tp2: Typar) -> tp1.Kind = tp2.Kind) mtps fvmtps - - /// Check if an override is a partial match for the requirements for a dispatch slot except for the name. - let IsSigPartialMatch g (dispatchSlot: MethInfo) compiledSig (Override(_, _, _, (mtps, _), argTys, _retTy, _, _) as overrideBy) = - let (CompiledSig (vargtys, _, fvmtps, _)) = compiledSig - mtps.Length = fvmtps.Length && - IsTyparKindMatch compiledSig overrideBy && - argTys.Length = vargtys.Length && - IsImplMatch g dispatchSlot overrideBy - - /// Check if an override is a partial match for the requirements for a dispatch slot. - let IsPartialMatch g dispatchSlot compiledSig overrideBy = - IsNameMatch dispatchSlot overrideBy && - IsSigPartialMatch g dispatchSlot compiledSig overrideBy - - /// Compute the reverse of a type parameter renaming. - let ReverseTyparRenaming g tinst = - tinst |> List.map (fun (tp, ty) -> (destTyparTy g ty, mkTyparTy tp)) - - /// Compose two instantiations of type parameters. - let ComposeTyparInsts inst1 inst2 = - inst1 |> List.map (map2Of2 (instType inst2)) - - /// Check if an override exactly matches the requirements for a dispatch slot except for the name. - let IsSigExactMatch g amap m dispatchSlot (Override(_, _, _, (mtps, mtpinst), argTys, retTy, _, _) as overrideBy) = - let compiledSig = CompiledSigOfMeth g amap m dispatchSlot - IsSigPartialMatch g dispatchSlot compiledSig overrideBy && - let (CompiledSig (vargtys, vrty, fvmtps, ttpinst)) = compiledSig - - // Compare the types. CompiledSigOfMeth, GetObjectExprOverrideInfo and GetTypeMemberOverrideInfo have already - // applied all relevant substitutions except the renamings from fvtmps <-> mtps - - let aenv = TypeEquivEnv.FromEquivTypars fvmtps mtps - - List.forall2 (List.lengthsEqAndForall2 (typeAEquiv g aenv)) vargtys argTys && - returnTypesAEquiv g aenv vrty retTy && - - // Comparing the method typars and their constraints is much trickier since the substitutions have not been applied - // to the constraints of these babies. This is partly because constraints are directly attached to typars so it's - // difficult to apply substitutions to them unless we separate them off at some point, which we don't as yet. - // - // Given C - // D - // dispatchSlot : C.M(...) - // overrideBy: parent: D value: ! (...) - // - // where X[dtps] indicates that X may involve free type variables dtps - // - // we have - // ttpinst maps ctps --> ctys[dtps] - // mtpinst maps ttps --> dtps - // - // compare fvtmps[ctps] and mtps[ttps] by - // fvtmps[ctps] @ ttpinst -- gives fvtmps[dtps] - // fvtmps[dtps] @ rev(mtpinst) -- gives fvtmps[ttps] - // - // Now fvtmps[ttps] and mtpinst[ttps] are comparable, i.e. have constraints w.r.t. the same set of type variables - // - // i.e. Compose the substitutions ttpinst and rev(mtpinst) - - let ttpinst = - // check we can reverse - in some error recovery situations we can't - if mtpinst |> List.exists (snd >> isTyparTy g >> not) then ttpinst - else ComposeTyparInsts ttpinst (ReverseTyparRenaming g mtpinst) - - // Compare under the composed substitutions - let aenv = TypeEquivEnv.FromTyparInst ttpinst - - typarsAEquiv g aenv fvmtps mtps + val GetObjectExprOverrideInfo: g:TcGlobals -> amap:ImportMap -> implty:TType * id:Ident * memberFlags:MemberFlags * ty:TType * arityInfo:ValReprInfo * bindingAttribs:Attribs * rhsExpr:Expr -> OverrideInfo * (Val option * Val * Val list list * Attribs * Expr) /// Check if an override exactly matches the requirements for a dispatch slot. - let IsExactMatch g amap m dispatchSlot overrideBy = - IsNameMatch dispatchSlot overrideBy && - IsSigExactMatch g amap m dispatchSlot overrideBy - - /// Check if an override implements a dispatch slot - let OverrideImplementsDispatchSlot g amap m dispatchSlot availPriorOverride = - IsExactMatch g amap m dispatchSlot availPriorOverride && - // The override has to actually be in some subtype of the dispatch slot - ExistsHeadTypeInEntireHierarchy g amap m (generalizedTyconRef availPriorOverride.BoundingTyconRef) dispatchSlot.DeclaringTyconRef - - /// Check if a dispatch slot is already implemented - let DispatchSlotIsAlreadyImplemented g amap m availPriorOverridesKeyed (dispatchSlot: MethInfo) = - availPriorOverridesKeyed - |> NameMultiMap.find dispatchSlot.LogicalName - |> List.exists (OverrideImplementsDispatchSlot g amap m dispatchSlot) + val IsExactMatch: g:TcGlobals -> amap:ImportMap -> m:range -> dispatchSlot:MethInfo -> overrideBy:OverrideInfo -> bool /// Check all dispatch slots are implemented by some override. - let CheckDispatchSlotsAreImplemented (denv, infoReader: InfoReader, m, - nenv, sink: TcResultsSink, - isOverallTyAbstract, - reqdTy, - dispatchSlots: RequiredSlot list, - availPriorOverrides: OverrideInfo list, - overrides: OverrideInfo list) = - let g = infoReader.g - let amap = infoReader.amap - - let isReqdTyInterface = isInterfaceTy g reqdTy - let showMissingMethodsAndRaiseErrors = (isReqdTyInterface || not isOverallTyAbstract) - - let mutable res = true - let fail exn = - res <- false - if showMissingMethodsAndRaiseErrors then - errorR exn - - // Index the availPriorOverrides and overrides by name - let availPriorOverridesKeyed = availPriorOverrides |> NameMultiMap.initBy (fun ov -> ov.LogicalName) - let overridesKeyed = overrides |> NameMultiMap.initBy (fun ov -> ov.LogicalName) - - // we accumulate those to compose a more complete error message, see noimpl() bellow. - let missingOverloadImplementation = ResizeArray() - - for reqdSlot in dispatchSlots do - let dispatchSlot = reqdSlot.MethodInfo - - // Always try to raise a target runtime error if we have a DIM. - if reqdSlot.HasDefaultInterfaceImplementation then - checkLanguageFeatureRuntimeErrorRecover infoReader LanguageFeature.DefaultInterfaceMemberConsumption m - - let maybeResolvedSlot = - NameMultiMap.find dispatchSlot.LogicalName overridesKeyed - |> List.filter (OverrideImplementsDispatchSlot g amap m dispatchSlot) - - match maybeResolvedSlot with - | [ovd] -> - if not ovd.IsCompilerGenerated then - let item = Item.MethodGroup(ovd.LogicalName, [dispatchSlot],None) - CallNameResolutionSink sink (ovd.Range, nenv, item, dispatchSlot.FormalMethodTyparInst, ItemOccurence.Implemented, AccessorDomain.AccessibleFromSomewhere) - | [] -> - if not reqdSlot.IsOptional && - // Check that no available prior override implements this dispatch slot - not (DispatchSlotIsAlreadyImplemented g amap m availPriorOverridesKeyed dispatchSlot) - then - // Always try to raise a language version error if we have a DIM that is not explicitly implemented. - if reqdSlot.HasDefaultInterfaceImplementation then - checkLanguageFeatureErrorRecover g.langVersion LanguageFeature.DefaultInterfaceMemberConsumption m - - if reqdSlot.PossiblyNoMostSpecificImplementation then - errorR(Error(FSComp.SR.typrelInterfaceMemberNoMostSpecificImplementation(NicePrint.stringOfMethInfo amap m denv dispatchSlot), m)) - - // error reporting path - let compiledSig = CompiledSigOfMeth g amap m dispatchSlot - - let noimpl() = - missingOverloadImplementation.Add((isReqdTyInterface, lazy NicePrint.stringOfMethInfo amap m denv dispatchSlot)) - - match overrides |> List.filter (IsPartialMatch g dispatchSlot compiledSig) with - | [] -> - let possibleOverrides = - overrides - |> List.filter (fun overrideBy -> IsNameMatch dispatchSlot overrideBy && IsImplMatch g dispatchSlot overrideBy) - - match possibleOverrides with - | [] -> - noimpl() - | [ Override(_, _, _, (mtps, _), argTys, _, _, _) as overrideBy ] -> - let moreThanOnePossibleDispatchSlot = - dispatchSlots - |> List.filter (fun reqdSlot-> IsNameMatch reqdSlot.MethodInfo overrideBy && IsImplMatch g reqdSlot.MethodInfo overrideBy) - |> isNilOrSingleton - |> not - - let (CompiledSig (vargtys, _, fvmtps, _)) = compiledSig - - if moreThanOnePossibleDispatchSlot then - noimpl() - - elif argTys.Length <> vargtys.Length then - fail(Error(FSComp.SR.typrelMemberDoesNotHaveCorrectNumberOfArguments(FormatOverride denv overrideBy, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range)) - elif mtps.Length <> fvmtps.Length then - fail(Error(FSComp.SR.typrelMemberDoesNotHaveCorrectNumberOfTypeParameters(FormatOverride denv overrideBy, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range)) - elif not (IsTyparKindMatch compiledSig overrideBy) then - fail(Error(FSComp.SR.typrelMemberDoesNotHaveCorrectKindsOfGenericParameters(FormatOverride denv overrideBy, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range)) - else - fail(Error(FSComp.SR.typrelMemberCannotImplement(FormatOverride denv overrideBy, NicePrint.stringOfMethInfo amap m denv dispatchSlot, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range)) - | overrideBy :: _ -> - errorR(Error(FSComp.SR.typrelOverloadNotFound(FormatMethInfoSig g amap m denv dispatchSlot, FormatMethInfoSig g amap m denv dispatchSlot), overrideBy.Range)) - - | [ overrideBy ] -> - if dispatchSlots |> List.exists (fun reqdSlot -> OverrideImplementsDispatchSlot g amap m reqdSlot.MethodInfo overrideBy) then - noimpl() - else - // Error will be reported below in CheckOverridesAreAllUsedOnce - () - | _ -> - fail(Error(FSComp.SR.typrelOverrideWasAmbiguous(FormatMethInfoSig g amap m denv dispatchSlot), m)) - | _ -> fail(Error(FSComp.SR.typrelMoreThenOneOverride(FormatMethInfoSig g amap m denv dispatchSlot), m)) - - if missingOverloadImplementation.Count > 0 then - // compose message listing missing override implementation - let maxDisplayedOverrides = 10 - let shouldTruncate = missingOverloadImplementation.Count > maxDisplayedOverrides - let messageWithInterfaceSuggestion = - // check any of the missing overrides has isReqdTyInterface flag set - // in which case we use the message "with suggestion" - missingOverloadImplementation - |> Seq.map fst - |> Seq.filter id - |> Seq.isEmpty - |> not - - if missingOverloadImplementation.Count = 1 then - // only one missing override, we have specific message for that - let signature = (snd missingOverloadImplementation.[0]).Value - if messageWithInterfaceSuggestion then - fail(Error(FSComp.SR.typrelNoImplementationGivenWithSuggestion(signature), m)) - else - fail(Error(FSComp.SR.typrelNoImplementationGiven(signature), m)) - else - let signatures = - (missingOverloadImplementation - |> Seq.truncate maxDisplayedOverrides - |> Seq.map snd - |> Seq.map (fun signature -> System.Environment.NewLine + "\t'" + signature.Value + "'") - |> String.concat "") + System.Environment.NewLine - - // we have specific message if the list is truncated - let messageFunction = - match shouldTruncate, messageWithInterfaceSuggestion with - | false, true -> FSComp.SR.typrelNoImplementationGivenSeveralWithSuggestion - | false, false -> FSComp.SR.typrelNoImplementationGivenSeveral - | true , true -> FSComp.SR.typrelNoImplementationGivenSeveralTruncatedWithSuggestion - | true , false -> FSComp.SR.typrelNoImplementationGivenSeveralTruncated - fail(Error(messageFunction(signatures), m)) - - res - - /// This is to find override methods that are at the most specific in the hierarchy of interface types. - let GetMostSpecificOverrideInterfaceMethodSets (infoReader: InfoReader) allReqdTys = - let g = infoReader.g - let amap = infoReader.amap - - let multipleSets = - allReqdTys - // Widdle down to the most specific interfaces. - |> GetMostSpecificItemsByType g amap (fun (ty, m) -> - if isInterfaceTy g ty then - Some(ty, m) - else - None) - - // Get the most specific method overrides for each interface type. - |> List.choose (fun (ty, m) -> - let mostSpecificOverrides = GetIntrinisicMostSpecificOverrideMethInfoSetsOfType infoReader m ty - if mostSpecificOverrides.IsEmpty then None - else Some mostSpecificOverrides) - - match multipleSets with - | [] -> NameMultiMap.Empty - | [set] -> set - | _ -> - multipleSets - // Merge method sets together. - |> List.reduce (fun final minfoSets -> - Map.fold (fun acc key minfos -> - match acc.TryGetValue key with - | true, minfos2 -> Map.add key (minfos @ minfos2) acc - | _ -> Map.add key minfos acc) final minfoSets) - - // Filter for most specifics when the sets have merged together. - |> FilterMostSpecificMethInfoSets g amap range0 - - /// Finds the override interface methods from the most specific overrides by the given method. - let GetMostSpecificOverrideInterfaceMethodsByMethod g amap m (mostSpecificOverrides: NameMultiMap) (minfo: MethInfo) = - let overrideBy = GetInheritedMemberOverrideInfo g amap m OverrideCanImplement.CanImplementAnyInterfaceSlot minfo - let minfoTy = generalizedTyconRef minfo.ApparentEnclosingTyconRef - NameMultiMap.find minfo.LogicalName mostSpecificOverrides - |> List.filter (fun (overridenTy, minfo2) -> - typeEquiv g overridenTy minfoTy && - IsSigExactMatch g amap m minfo2 overrideBy) - - /// Get a collection of slots for the given interface type. - let GetInterfaceDispatchSlots (infoReader: InfoReader) ad m availImpliedInterfaces mostSpecificOverrides interfaceTy = - let g = infoReader.g - let amap = infoReader.amap - - if isInterfaceTy g interfaceTy then - // Check if the interface has an inherited implementation - // If so, you do not have to implement all the methods - each - // specific method is "optionally" implemented. - let isInterfaceOptional = ListSet.contains (typeEquiv g) interfaceTy availImpliedInterfaces - [ for minfo in GetImmediateIntrinsicMethInfosOfType (None, ad) g amap m interfaceTy do - if minfo.IsNewSlot then - // If the interface itself is considered optional, then we are finished and do not need anymore context. - // Even if the method is actually not abstract. - if isInterfaceOptional then - yield RequiredSlot (minfo, true) - - // F# defined interface methods have no notion of optional/abstract or DIMs. - elif not minfo.IsILMethod then - yield RequiredSlot (minfo, false) - - // IL methods might have default implementations. - else - let isMethodOptional (minfo: MethInfo) = - // A DIM is considered *not* 'optional' if it is not language supported. - g.langVersion.SupportsFeature LanguageFeature.DefaultInterfaceMemberConsumption && - not minfo.IsAbstract - - match GetMostSpecificOverrideInterfaceMethodsByMethod g amap m mostSpecificOverrides minfo with - // No override. - | [] -> - if minfo.IsAbstract then - // Regular interface methods are never optional. - yield RequiredSlot (minfo, false) - else - yield DefaultInterfaceImplementationSlot (minfo, isMethodOptional minfo, false) - - // One override, one default implementation. - | [ (_, minfo2) ] -> - yield DefaultInterfaceImplementationSlot (minfo, isMethodOptional minfo2, false) - - // We found multiple override methods, means we might have ambiguity. - | _ -> - // If DIMs are not language supported, then do not consider a slot to have a specific implementation. - let possiblyNoMostSpecific = - g.langVersion.SupportsFeature LanguageFeature.DefaultInterfaceMemberConsumption - - yield DefaultInterfaceImplementationSlot (minfo, false, possiblyNoMostSpecific) ] - else - [] - - /// Get a collection of slots for the given class type. - let GetClassDispatchSlots (infoReader: InfoReader) ad m reqdTy = - [ if not (isInterfaceTy infoReader.g reqdTy) then - // In the normal case, the requirements for a class are precisely all the abstract slots up the whole hierarchy. - // So here we get and yield all of those. - for minfo in reqdTy |> GetIntrinsicMethInfosOfType infoReader None ad AllowMultiIntfInstantiations.Yes IgnoreOverrides m do - if minfo.IsDispatchSlot then - yield RequiredSlot(minfo, not minfo.IsAbstract) ] - - /// Get a collection of slots for the given type and implied types. - let GetDispatchSlotSet (infoReader: InfoReader) ad m availImpliedInterfaces mostSpecificOverrides reqdTy impliedTys = - let g = infoReader.g - - if isInterfaceTy g reqdTy then - [ for impliedTy in impliedTys do - yield (impliedTy, GetInterfaceDispatchSlots infoReader ad m availImpliedInterfaces mostSpecificOverrides impliedTy) ] - else - [ (reqdTy, GetClassDispatchSlots infoReader ad m reqdTy) ] + val CheckDispatchSlotsAreImplemented: denv:DisplayEnv * infoReader:InfoReader * m:range * nenv:NameResolutionEnv * sink:TcResultsSink * isOverallTyAbstract:bool * reqdTy:TType * dispatchSlots:RequiredSlot list * availPriorOverrides:OverrideInfo list * overrides:OverrideInfo list -> bool /// Check all implementations implement some dispatch slot. - let CheckOverridesAreAllUsedOnce(denv, g, amap, isObjExpr, reqdTy, - dispatchSlotsKeyed: NameMultiMap, - availPriorOverrides: OverrideInfo list, - overrides: OverrideInfo list) = - let availPriorOverridesKeyed = availPriorOverrides |> NameMultiMap.initBy (fun ov -> ov.LogicalName) - for overrideBy in overrides do - if not overrideBy.IsFakeEventProperty then - let m = overrideBy.Range - let relevantVirts = NameMultiMap.find overrideBy.LogicalName dispatchSlotsKeyed - let relevantVirts = relevantVirts |> List.map (fun reqdSlot -> reqdSlot.MethodInfo) - - match relevantVirts |> List.filter (fun dispatchSlot -> OverrideImplementsDispatchSlot g amap m dispatchSlot overrideBy) with - | [] -> - // This is all error reporting - match relevantVirts |> List.filter (fun dispatchSlot -> IsPartialMatch g dispatchSlot (CompiledSigOfMeth g amap m dispatchSlot) overrideBy) with - | [dispatchSlot] -> - errorR(OverrideDoesntOverride(denv, overrideBy, Some dispatchSlot, g, amap, m)) - | _ -> - match relevantVirts |> List.filter (fun dispatchSlot -> IsNameMatch dispatchSlot overrideBy) with - | [] -> errorR(OverrideDoesntOverride(denv, overrideBy, None, g, amap, m)) - | [dispatchSlot] -> - errorR(OverrideDoesntOverride(denv, overrideBy, Some dispatchSlot, g, amap, m)) - | possibleDispatchSlots -> - let details = - possibleDispatchSlots - |> List.map (fun dispatchSlot -> FormatMethInfoSig g amap m denv dispatchSlot) - |> Seq.map (sprintf "%s %s" System.Environment.NewLine) - |> String.concat "" - - errorR(Error(FSComp.SR.typrelMemberHasMultiplePossibleDispatchSlots(FormatOverride denv overrideBy, details), overrideBy.Range)) - - - | [dispatchSlot] -> - if dispatchSlot.IsFinal && (isObjExpr || not (typeEquiv g reqdTy dispatchSlot.ApparentEnclosingType)) then - errorR(Error(FSComp.SR.typrelMethodIsSealed(NicePrint.stringOfMethInfo amap m denv dispatchSlot), m)) - | dispatchSlots -> - match dispatchSlots |> List.filter (fun dispatchSlot -> - isInterfaceTy g dispatchSlot.ApparentEnclosingType || - not (DispatchSlotIsAlreadyImplemented g amap m availPriorOverridesKeyed dispatchSlot)) with - | h1 :: h2 :: _ -> - errorR(Error(FSComp.SR.typrelOverrideImplementsMoreThenOneSlot((FormatOverride denv overrideBy), (NicePrint.stringOfMethInfo amap m denv h1), (NicePrint.stringOfMethInfo amap m denv h2)), m)) - | _ -> - // dispatch slots are ordered from the derived classes to base - // so we can check the topmost dispatch slot if it is final - match dispatchSlots with - | meth :: _ when meth.IsFinal -> errorR(Error(FSComp.SR.tcCannotOverrideSealedMethod((sprintf "%s::%s" (meth.ApparentEnclosingType.ToString()) (meth.LogicalName))), m)) - | _ -> () - - - - /// Get the slots of a type that can or must be implemented. This depends - /// partly on the full set of interface types that are being implemented - /// simultaneously, e.g. - /// { new C with interface I2 = ... interface I3 = ... } - /// allReqdTys = {C;I2;I3} - /// - /// allReqdTys can include one class/record/union type. - let GetSlotImplSets (infoReader: InfoReader) denv ad isObjExpr allReqdTys = - - let g = infoReader.g - let amap = infoReader.amap - - let availImpliedInterfaces : TType list = - [ for (reqdTy, m) in allReqdTys do - if not (isInterfaceTy g reqdTy) then - let baseTyOpt = if isObjExpr then Some reqdTy else GetSuperTypeOfType g amap m reqdTy - match baseTyOpt with - | None -> () - | Some baseTy -> yield! AllInterfacesOfType g amap m AllowMultiIntfInstantiations.Yes baseTy ] - - // For each implemented type, get a list containing the transitive closure of - // interface types implied by the type. This includes the implemented type itself if the implemented type - // is an interface type. - let intfSets = - allReqdTys |> List.mapi (fun i (reqdTy, m) -> - let interfaces = AllInterfacesOfType g amap m AllowMultiIntfInstantiations.Yes reqdTy - let impliedTys = (if isInterfaceTy g reqdTy then interfaces else reqdTy :: interfaces) - (i, reqdTy, impliedTys, m)) - - // For each implemented type, reduce its list of implied interfaces by subtracting out those implied - // by another implemented interface type. - // - // REVIEW: Note complexity O(N^2) - let reqdTyInfos = - intfSets |> List.map (fun (i, reqdTy, impliedTys, m) -> - let reduced = - (impliedTys, intfSets) ||> List.fold (fun acc (j, jty, impliedTys2, m) -> - if i <> j && TypeFeasiblySubsumesType 0 g amap m jty CanCoerce reqdTy - then ListSet.subtract (TypesFeasiblyEquiv 0 g amap m) acc impliedTys2 - else acc ) - (i, reqdTy, m, reduced)) - - // Find the full set of most derived interfaces, used roots to search for default interface implementations of interface methods. - let mostSpecificOverrides = GetMostSpecificOverrideInterfaceMethodSets infoReader allReqdTys - - // Get the SlotImplSet for each implemented type - // This contains the list of required members and the list of available members - [ for (i, reqdTy, reqdTyRange, impliedTys) in reqdTyInfos do - - // Check that, for each implemented type, at least one implemented type is implied. This is enough to capture - // duplicates. - if isInterfaceTy g reqdTy && isNil impliedTys then - errorR(Error(FSComp.SR.typrelDuplicateInterface(), reqdTyRange)) - - // Build a set of the implied interface types, for quicker lookup, by nominal type - let isImpliedInterfaceTable = - impliedTys - |> List.filter (isInterfaceTy g) - |> List.map (fun ty -> tcrefOfAppTy g ty, ()) - |> TyconRefMap.OfList - - // Is a member an abstract slot of one of the implied interface types? - let isImpliedInterfaceType ty = - isAppTy g ty && - isImpliedInterfaceTable.ContainsKey (tcrefOfAppTy g ty) && - impliedTys |> List.exists (TypesFeasiblyEquiv 0 g amap reqdTyRange ty) - - let dispatchSlotSet = GetDispatchSlotSet infoReader ad reqdTyRange availImpliedInterfaces mostSpecificOverrides reqdTy impliedTys - - // Compute the methods that are available to implement abstract slots from the base class - // - // This is used in CheckDispatchSlotsAreImplemented when we think a dispatch slot may not - // have been implemented. - let availPriorOverrides : OverrideInfo list = - if isInterfaceTy g reqdTy then - [] - else - let reqdTy = - let baseTyOpt = if isObjExpr then Some reqdTy else GetSuperTypeOfType g amap reqdTyRange reqdTy - match baseTyOpt with - | None -> reqdTy - | Some baseTy -> baseTy - [ // Get any class hierarchy methods or default interface methods on this type on this type - // - // NOTE: What we have below is an over-approximation that will get too many methods - // and not always correctly relate them to the slots they implement. For example, - // we may get an override from a base class and believe it implements a fresh, new abstract - // slot in a subclass. - for minfos in infoReader.GetRawIntrinsicMethodSetsOfType(None, ad, AllowMultiIntfInstantiations.Yes, reqdTyRange, reqdTy) do - for minfo in minfos do - if not minfo.IsAbstract then - yield GetInheritedMemberOverrideInfo g amap reqdTyRange CanImplementAnyClassHierarchySlot minfo ] - - /// Check that no interface type is implied twice - for (j, _, _, impliedTys2) in reqdTyInfos do - if i > j then - for (ty, dispatchSlots) in dispatchSlotSet do - if impliedTys2 |> List.exists (TypesFeasiblyEquiv 0 g amap reqdTyRange ty) then - if dispatchSlots - |> List.exists (fun reqdSlot -> - let minfo = reqdSlot.MethodInfo - // If the slot is optional, then we do not need an explicit implementation. - minfo.IsNewSlot && not reqdSlot.IsOptional) then - errorR(Error(FSComp.SR.typrelNeedExplicitImplementation(NicePrint.minimalStringOfType denv ty), reqdTyRange)) - - // We also collect up the properties. This is used for abstract slot inference when overriding properties - let isRelevantRequiredProperty (x: PropInfo) = - (x.IsVirtualProperty && not (isInterfaceTy g reqdTy)) || - isImpliedInterfaceType x.ApparentEnclosingType - - let reqdProperties = - GetIntrinsicPropInfosOfType infoReader None ad AllowMultiIntfInstantiations.Yes IgnoreOverrides reqdTyRange reqdTy - |> List.filter isRelevantRequiredProperty - - let dispatchSlots = dispatchSlotSet |> List.map snd |> List.concat - let dispatchSlotsKeyed = dispatchSlots |> NameMultiMap.initBy (fun reqdSlot -> reqdSlot.MethodInfo.LogicalName) - yield SlotImplSet(dispatchSlots, dispatchSlotsKeyed, availPriorOverrides, reqdProperties) ] - - - /// Check that a type definition implements all its required interfaces after processing all declarations - /// within a file. - let CheckImplementationRelationAtEndOfInferenceScope (infoReader : InfoReader, denv, nenv, sink, tycon: Tycon, isImplementation) = + val CheckOverridesAreAllUsedOnce: denv:DisplayEnv * g:TcGlobals * amap:ImportMap * isObjExpr:bool * reqdTy:TType * dispatchSlotsKeyed:NameMultiMap * availPriorOverrides:OverrideInfo list * overrides:OverrideInfo list -> unit - let g = infoReader.g - let amap = infoReader.amap - - let tcaug = tycon.TypeContents - let interfaces = tycon.ImmediateInterfacesOfFSharpTycon |> List.map (fun (ity, _compgen, m) -> (ity, m)) - - let overallTy = generalizedTyconRef (mkLocalTyconRef tycon) - - let allReqdTys = (overallTy, tycon.Range) :: interfaces - - // Get all the members that are immediately part of this type - // Include the auto-generated members - let allImmediateMembers = tycon.MembersOfFSharpTyconSorted @ tycon.AllGeneratedValues - - // Get all the members we have to implement, organized by each type we explicitly implement - let slotImplSets = GetSlotImplSets infoReader denv AccessibleFromSomewhere false allReqdTys - - let allImpls = List.zip allReqdTys slotImplSets - - // Find the methods relevant to implementing the abstract slots listed under the reqdType being checked. - let allImmediateMembersThatMightImplementDispatchSlots = - allImmediateMembers |> List.filter (fun overrideBy -> - overrideBy.IsInstanceMember && // exclude static - overrideBy.IsVirtualMember && // exclude non virtual (e.g. keep override/default). [4469] - not overrideBy.IsDispatchSlotMember) - - let mustOverrideSomething reqdTy (overrideBy: ValRef) = - let memberInfo = overrideBy.MemberInfo.Value - not (overrideBy.IsFSharpEventProperty(g)) && - memberInfo.MemberFlags.IsOverrideOrExplicitImpl && - - match memberInfo.ImplementedSlotSigs with - | [] -> - // Are we looking at the implementation of the class hierarchy? If so include all the override members - not (isInterfaceTy g reqdTy) - | ss -> - ss |> List.forall (fun ss -> - let ty = ss.ImplementedType - if isInterfaceTy g ty then - // Is this a method impl listed under the reqdTy? - typeEquiv g ty reqdTy - else - not (isInterfaceTy g reqdTy) ) - - - // We check all the abstracts related to the class hierarchy and then check each interface implementation - for ((reqdTy, m), slotImplSet) in allImpls do - let (SlotImplSet(dispatchSlots, dispatchSlotsKeyed, availPriorOverrides, _)) = slotImplSet - try - - // Now extract the information about each overriding method relevant to this SlotImplSet - let allImmediateMembersThatMightImplementDispatchSlots = - allImmediateMembersThatMightImplementDispatchSlots - |> List.map (fun overrideBy -> overrideBy, GetTypeMemberOverrideInfo g reqdTy overrideBy) - - // Now check the implementation - // We don't give missing method errors for abstract classes - - if isImplementation && not (isInterfaceTy g overallTy) then - let overrides = allImmediateMembersThatMightImplementDispatchSlots |> List.map snd - let allCorrect = CheckDispatchSlotsAreImplemented (denv, infoReader, m, nenv, sink, tcaug.tcaug_abstract, reqdTy, dispatchSlots, availPriorOverrides, overrides) - - // Tell the user to mark the thing abstract if it was missing implementations - if not allCorrect && not tcaug.tcaug_abstract && not (isInterfaceTy g reqdTy) then - errorR(TypeIsImplicitlyAbstract(m)) - - let overridesToCheck = - allImmediateMembersThatMightImplementDispatchSlots - |> List.filter (fst >> mustOverrideSomething reqdTy) - |> List.map snd - - CheckOverridesAreAllUsedOnce (denv, g, amap, false, reqdTy, dispatchSlotsKeyed, availPriorOverrides, overridesToCheck) - - with e -> errorRecovery e m - - // Now record the full slotsigs of the abstract members implemented by each override. - // This is used to generate IL MethodImpls in the code generator. - allImmediateMembersThatMightImplementDispatchSlots |> List.iter (fun overrideBy -> - - let isFakeEventProperty = overrideBy.IsFSharpEventProperty(g) - let overriden = - if isFakeEventProperty then - let slotsigs = overrideBy.MemberInfo.Value.ImplementedSlotSigs - slotsigs |> List.map (ReparentSlotSigToUseMethodTypars g overrideBy.Range overrideBy) - else - [ for ((reqdTy, m), (SlotImplSet(_dispatchSlots, dispatchSlotsKeyed, _, _))) in allImpls do - let overrideByInfo = GetTypeMemberOverrideInfo g reqdTy overrideBy - let overridenForThisSlotImplSet = - [ for reqdSlot in NameMultiMap.find overrideByInfo.LogicalName dispatchSlotsKeyed do - let dispatchSlot = reqdSlot.MethodInfo - if OverrideImplementsDispatchSlot g amap m dispatchSlot overrideByInfo then - if tyconRefEq g overrideByInfo.BoundingTyconRef dispatchSlot.DeclaringTyconRef then - match dispatchSlot.ArbitraryValRef with - | Some virtMember -> - if virtMember.MemberInfo.Value.IsImplemented then errorR(Error(FSComp.SR.tcDefaultImplementationAlreadyExists(), overrideByInfo.Range)) - virtMember.MemberInfo.Value.IsImplemented <- true - | None -> () // not an F# slot - - // Get the slotsig of the overridden method - let slotsig = dispatchSlot.GetSlotSig(amap, m) - - // The slotsig from the overridden method is in terms of the type parameters on the parent type of the overriding method, - // Modify map the slotsig so it is in terms of the type parameters for the overriding method - let slotsig = ReparentSlotSigToUseMethodTypars g m overrideBy slotsig - - // Record the slotsig via mutation - yield slotsig ] - //if mustOverrideSomething reqdTy overrideBy then - // assert nonNil overridenForThisSlotImplSet - yield! overridenForThisSlotImplSet ] - - overrideBy.MemberInfo.Value.ImplementedSlotSigs <- overriden) + /// Get the slots of a type that can or must be implemented. + val GetSlotImplSets: infoReader:InfoReader -> denv:DisplayEnv -> ad:AccessorDomain -> isObjExpr:bool -> allReqdTys:(TType * range) list -> SlotImplSet list /// "Type Completion" inference and a few other checks at the end of the inference scope -let FinalTypeDefinitionChecksAtEndOfInferenceScope (infoReader: InfoReader, nenv, sink, isImplementation, denv) (tycon: Tycon) = - - let g = infoReader.g - let amap = infoReader.amap - - let tcaug = tycon.TypeContents - tcaug.tcaug_closed <- true - - // Note you only have to explicitly implement 'System.IComparable' to customize structural comparison AND equality on F# types - if isImplementation && -#if !NO_EXTENSIONTYPING - not tycon.IsProvidedGeneratedTycon && -#endif - Option.isNone tycon.GeneratedCompareToValues && - tycon.HasInterface g g.mk_IComparable_ty && - not (tycon.HasOverride g "Equals" [g.obj_ty]) && - not tycon.IsFSharpInterfaceTycon - then - (* Warn when we're doing this for class types *) - if AugmentWithHashCompare.TyconIsCandidateForAugmentationWithEquals g tycon then - warning(Error(FSComp.SR.typrelTypeImplementsIComparableShouldOverrideObjectEquals(tycon.DisplayName), tycon.Range)) - else - warning(Error(FSComp.SR.typrelTypeImplementsIComparableDefaultObjectEqualsProvided(tycon.DisplayName), tycon.Range)) - - AugmentWithHashCompare.CheckAugmentationAttribs isImplementation g amap tycon - // Check some conditions about generic comparison and hashing. We can only check this condition after we've done the augmentation - if isImplementation -#if !NO_EXTENSIONTYPING - && not tycon.IsProvidedGeneratedTycon -#endif - then - let tcaug = tycon.TypeContents - let m = tycon.Range - let hasExplicitObjectGetHashCode = tycon.HasOverride g "GetHashCode" [] - let hasExplicitObjectEqualsOverride = tycon.HasOverride g "Equals" [g.obj_ty] +val FinalTypeDefinitionChecksAtEndOfInferenceScope: infoReader:InfoReader * nenv:NameResolutionEnv * sink:TcResultsSink * isImplementation:bool * denv:DisplayEnv -> tycon:Tycon -> unit - if (Option.isSome tycon.GeneratedHashAndEqualsWithComparerValues) && - (hasExplicitObjectGetHashCode || hasExplicitObjectEqualsOverride) then - errorR(Error(FSComp.SR.typrelExplicitImplementationOfGetHashCodeOrEquals(tycon.DisplayName), m)) - - if not hasExplicitObjectEqualsOverride && hasExplicitObjectGetHashCode then - warning(Error(FSComp.SR.typrelExplicitImplementationOfGetHashCode(tycon.DisplayName), m)) - - if hasExplicitObjectEqualsOverride && not hasExplicitObjectGetHashCode then - warning(Error(FSComp.SR.typrelExplicitImplementationOfEquals(tycon.DisplayName), m)) - - // remember these values to ensure we don't generate these methods during codegen - tcaug.SetHasObjectGetHashCode hasExplicitObjectGetHashCode - - if not tycon.IsHiddenReprTycon - && not tycon.IsTypeAbbrev - && not tycon.IsMeasureableReprTycon - && not tycon.IsAsmReprTycon - && not tycon.IsFSharpInterfaceTycon - && not tycon.IsFSharpDelegateTycon then - - DispatchSlotChecking.CheckImplementationRelationAtEndOfInferenceScope (infoReader, denv, nenv, sink, tycon, isImplementation) - /// Get the methods relevant to determining if a uniquely-identified-override exists based on the syntactic information /// at the member signature prior to type inference. This is used to pre-assign type information if it does -let GetAbstractMethInfosForSynMethodDecl(infoReader: InfoReader, ad, memberName: Ident, bindm, typToSearchForAbstractMembers, valSynData) = - let minfos = - match typToSearchForAbstractMembers with - | _, Some(SlotImplSet(_, dispatchSlotsKeyed, _, _)) -> - NameMultiMap.find memberName.idText dispatchSlotsKeyed |> List.map (fun reqdSlot -> reqdSlot.MethodInfo) - | ty, None -> - GetIntrinsicMethInfosOfType infoReader (Some memberName.idText) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides bindm ty - let dispatchSlots = minfos |> List.filter (fun minfo -> minfo.IsDispatchSlot) - let topValSynArities = SynInfo.AritiesOfArgs valSynData - let topValSynArities = if List.isEmpty topValSynArities then topValSynArities else topValSynArities.Tail - let dispatchSlotsArityMatch = dispatchSlots |> List.filter (fun minfo -> minfo.NumArgs = topValSynArities) - dispatchSlots, dispatchSlotsArityMatch +val GetAbstractMethInfosForSynMethodDecl: infoReader:InfoReader * ad:AccessorDomain * memberName:Ident * bindm:range * typToSearchForAbstractMembers:(TType * SlotImplSet option) * valSynData:SynValInfo -> MethInfo list * MethInfo list /// Get the properties relevant to determining if a uniquely-identified-override exists based on the syntactic information /// at the member signature prior to type inference. This is used to pre-assign type information if it does -let GetAbstractPropInfosForSynPropertyDecl(infoReader: InfoReader, ad, memberName: Ident, bindm, typToSearchForAbstractMembers, _k, _valSynData) = - let pinfos = - match typToSearchForAbstractMembers with - | _, Some(SlotImplSet(_, _, _, reqdProps)) -> - reqdProps |> List.filter (fun pinfo -> pinfo.PropertyName = memberName.idText) - | ty, None -> - GetIntrinsicPropInfosOfType infoReader (Some memberName.idText) ad AllowMultiIntfInstantiations.Yes IgnoreOverrides bindm ty - - let dispatchSlots = pinfos |> List.filter (fun pinfo -> pinfo.IsVirtualProperty) - dispatchSlots +val GetAbstractPropInfosForSynPropertyDecl: infoReader:InfoReader * ad:AccessorDomain * memberName:Ident * bindm:range * typToSearchForAbstractMembers:(TType * SlotImplSet option) * _k:'a * _valSynData:'b -> PropInfo list diff --git a/src/fsharp/Microsoft.DotNet.DependencyManager/DependencyProvider.fs b/src/fsharp/Microsoft.DotNet.DependencyManager/DependencyProvider.fs index f27681d4135..e801e4405c6 100644 --- a/src/fsharp/Microsoft.DotNet.DependencyManager/DependencyProvider.fs +++ b/src/fsharp/Microsoft.DotNet.DependencyManager/DependencyProvider.fs @@ -11,6 +11,13 @@ open Internal.Utilities.FSharpEnvironment open Microsoft.FSharp.Reflection open System.Collections.Concurrent +module Option = + + /// Convert string into Option string where null and String.Empty result in None + let ofString s = + if String.IsNullOrEmpty(s) then None + else Some(s) + [] module ReflectionHelper = let dependencyManagerPattern = "*DependencyManager*.dll" diff --git a/src/fsharp/NicePrint.fs b/src/fsharp/NicePrint.fs index 50b8f8c9f63..7062cf1a071 100755 --- a/src/fsharp/NicePrint.fs +++ b/src/fsharp/NicePrint.fs @@ -1390,7 +1390,6 @@ module private TastDefinitionPrinting = #endif | TNoRepr -> false -#if !NO_EXTENSIONTYPING let private layoutILFieldInfo denv amap m (e: ILFieldInfo) = let staticL = if e.IsStatic then WordL.keywordStatic else emptyL let nameL = wordL (tagField (adjustILName e.FieldName)) @@ -1585,6 +1584,7 @@ module private TastDefinitionPrinting = |> List.map snd let nestedTypeLs = +#if !NO_EXTENSIONTYPING match tryTcrefOfAppTy g ty with | ValueSome tcref -> match tcref.TypeReprInfo with @@ -1598,6 +1598,7 @@ module private TastDefinitionPrinting = | _ -> [] | ValueNone -> +#endif [] let inherits = @@ -1741,7 +1742,6 @@ module private TastDefinitionPrinting = (lhsL ^^ WordL.equals) --- (layoutType { denv with shortTypeNames = false } a) layoutAttribs denv false ty tycon.TypeOrMeasureKind tycon.Attribs reprL -#endif // Layout: exception definition let layoutExnDefn denv (exnc: Entity) = @@ -1959,20 +1959,14 @@ let stringOfParamData denv paramData = bufs (fun buf -> InfoMemberPrinting.forma let layoutOfParamData denv paramData = InfoMemberPrinting.layoutParamData denv paramData -let outputExnDef denv os x = x |> TastDefinitionPrinting.layoutExnDefn denv |> bufferL os - let layoutExnDef denv x = x |> TastDefinitionPrinting.layoutExnDefn denv let stringOfTyparConstraints denv x = x |> PrintTypes.layoutConstraintsWithInfo denv SimplifyTypes.typeSimplificationInfo0 |> showL -let outputTycon denv infoReader ad m (* width *) os x = TastDefinitionPrinting.layoutTycon denv infoReader ad m true WordL.keywordType x (* |> Display.squashTo width *) |> bufferL os - let layoutTycon denv infoReader ad m (* width *) x = TastDefinitionPrinting.layoutTycon denv infoReader ad m true WordL.keywordType x (* |> Display.squashTo width *) let layoutUnionCases denv x = x |> TastDefinitionPrinting.layoutUnionCaseFields denv true -let outputUnionCases denv os x = x |> TastDefinitionPrinting.layoutUnionCaseFields denv true |> bufferL os - /// Pass negative number as pos in case of single cased discriminated unions let isGeneratedUnionCaseField pos f = TastDefinitionPrinting.isGeneratedUnionCaseField pos f diff --git a/src/fsharp/NicePrint.fsi b/src/fsharp/NicePrint.fsi new file mode 100644 index 00000000000..8458fae4eed --- /dev/null +++ b/src/fsharp/NicePrint.fsi @@ -0,0 +1,117 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +/// Print Signatures/Types, for signatures, intellisense, quick info, FSI responses +module internal FSharp.Compiler.NicePrint + +open System.Text +open FSharp.Compiler +open FSharp.Compiler.AbstractIL +open FSharp.Compiler.AbstractIL.IL +open FSharp.Compiler.AccessibilityLogic +open FSharp.Compiler.Import +open FSharp.Compiler.Infos +open FSharp.Compiler.InfoReader +open FSharp.Compiler.Range +open FSharp.Compiler.TcGlobals +open FSharp.Compiler.TypedTree +open FSharp.Compiler.TypedTreeOps +open Internal.Utilities.StructuredFormat + +module PrintUtilities = + val layoutBuiltinAttribute: denv:DisplayEnv -> attrib:BuiltinAttribInfo -> Layout + +val layoutTyparConstraint: denv:DisplayEnv -> Typar * TyparConstraint -> Layout + +val outputType: denv:DisplayEnv -> os:StringBuilder -> x:TType -> unit + +val layoutType: denv:DisplayEnv -> x:TType -> Layout + +val outputTypars: denv:DisplayEnv -> nm:Layout.TaggedText -> os:StringBuilder -> x:Typars -> unit + +val outputTyconRef: denv:DisplayEnv -> os:StringBuilder -> x:TyconRef -> unit + +val layoutTyconRef: denv:DisplayEnv -> x:TyconRef -> Layout + +val layoutConst: g:TcGlobals -> ty:TType -> c:Const -> Layout + +val prettyLayoutOfMemberSig: denv:DisplayEnv -> (Typar * TType) list * string * Typars * (TType * ArgReprInfo) list list * TType -> Layout + +val prettyLayoutOfUncurriedSig: denv:DisplayEnv -> argInfos:TyparInst -> tau:UncurriedArgInfos -> (TType -> TyparInst * Layout) + +val prettyLayoutsOfUnresolvedOverloading: denv:DisplayEnv -> argInfos:(TType * ArgReprInfo) list -> retTy:TType -> genericParameters:seq -> Layout * Layout * Layout + +val dataExprL: denv:DisplayEnv -> expr:Expr -> Layout + +val outputValOrMember: denv:DisplayEnv -> os:StringBuilder -> x:Val -> unit + +val stringValOrMember: denv:DisplayEnv -> x:Val -> string + +val layoutQualifiedValOrMember: denv:DisplayEnv -> typarInst:TyparInst -> v:Val -> TyparInst * Layout + +val outputQualifiedValOrMember: denv:DisplayEnv -> os:StringBuilder -> v:Val -> unit + +val outputQualifiedValSpec: denv:DisplayEnv -> os:StringBuilder -> v:Val -> unit + +val stringOfQualifiedValOrMember: denv:DisplayEnv -> v:Val -> string + +val formatMethInfoToBufferFreeStyle: amap:ImportMap -> m:range -> denv:DisplayEnv -> buf:StringBuilder -> d:MethInfo -> unit + +val prettyLayoutOfMethInfoFreeStyle: amap:ImportMap -> m:range -> denv:DisplayEnv -> typarInst:TyparInst -> minfo:MethInfo -> TyparInst * Layout + +val prettyLayoutOfPropInfoFreeStyle: g:TcGlobals -> amap:ImportMap -> m:range -> denv:DisplayEnv -> d:PropInfo -> Layout + +val stringOfMethInfo: amap:ImportMap -> m:range -> denv:DisplayEnv -> d:MethInfo -> string + +val stringOfParamData: denv:DisplayEnv -> paramData:ParamData -> string + +val layoutOfParamData: denv:DisplayEnv -> paramData:ParamData -> Layout + +val layoutExnDef: denv:DisplayEnv -> x:Entity -> Layout + +val stringOfTyparConstraints: denv:DisplayEnv -> x:(Typar * TyparConstraint) list -> string + +val layoutTycon: denv:DisplayEnv -> infoReader:InfoReader -> ad:AccessorDomain -> m:range -> x:Tycon -> Layout + +val layoutUnionCases: denv:DisplayEnv -> x:RecdField list -> Layout + +val isGeneratedUnionCaseField: pos:int -> f:RecdField -> bool + +val isGeneratedExceptionField: pos:'a -> f:RecdField -> bool + +val stringOfTyparConstraint: denv:DisplayEnv -> Typar * TyparConstraint -> string + +val stringOfTy: denv:DisplayEnv -> x:TType -> string + +val prettyLayoutOfType: denv:DisplayEnv -> x:TType -> Layout + +val prettyLayoutOfTypeNoCx: denv:DisplayEnv -> x:TType -> Layout + +val prettyStringOfTy: denv:DisplayEnv -> x:TType -> string + +val prettyStringOfTyNoCx: denv:DisplayEnv -> x:TType -> string + +val stringOfRecdField: denv:DisplayEnv -> x:RecdField -> string + +val stringOfUnionCase: denv:DisplayEnv -> x:UnionCase -> string + +val stringOfExnDef: denv:DisplayEnv -> x:Entity -> string + +val stringOfFSAttrib: denv:DisplayEnv -> x:Attrib -> string + +val stringOfILAttrib: denv:DisplayEnv -> ILType * ILAttribElem list -> string + +val layoutInferredSigOfModuleExpr: showHeader:bool -> denv:DisplayEnv -> infoReader:InfoReader -> ad:AccessorDomain -> m:range -> expr:ModuleOrNamespaceExprWithSig -> Layout + +val prettyLayoutOfValOrMember: denv:DisplayEnv -> typarInst:TyparInst -> v:Val -> TyparInst * Layout + +val prettyLayoutOfValOrMemberNoInst: denv:DisplayEnv -> v:Val -> Layout + +val prettyLayoutOfMemberNoInstShort: denv:DisplayEnv -> v:Val -> Layout + +val prettyLayoutOfInstAndSig: denv:DisplayEnv -> TyparInst * TTypes * TType -> TyparInst * (TTypes * TType) * (Layout list * Layout) * Layout + +val minimalStringsOfTwoTypes: denv:DisplayEnv -> t1:TType -> t2:TType -> string * string * string + +val minimalStringsOfTwoValues: denv:DisplayEnv -> v1:Val -> v2:Val -> string * string + +val minimalStringOfType: denv:DisplayEnv -> ty:TType -> string diff --git a/src/fsharp/ReferenceResolver.fsi b/src/fsharp/ReferenceResolver.fsi index 33af4dfad7f..fd295cdf34f 100644 --- a/src/fsharp/ReferenceResolver.fsi +++ b/src/fsharp/ReferenceResolver.fsi @@ -1,56 +1,58 @@ // Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. -module FSharp.Compiler.ReferenceResolver +namespace FSharp.Compiler -exception internal ResolutionFailure +module public ReferenceResolver = -[] -type ResolutionEnvironment = - /// Indicates a script or source being edited or compiled. Uses reference assemblies (not implementation assemblies). - | EditingOrCompilation of isEditing: bool + exception internal ResolutionFailure - /// Indicates a script or source being dynamically compiled and executed. Uses implementation assemblies. - | CompilationAndEvaluation + [] + type ResolutionEnvironment = + /// Indicates a script or source being edited or compiled. Uses reference assemblies (not implementation assemblies). + | EditingOrCompilation of isEditing: bool -type ResolvedFile = - { - /// Item specification. - itemSpec:string + /// Indicates a script or source being dynamically compiled and executed. Uses implementation assemblies. + | CompilationAndEvaluation - /// Prepare textual information about where the assembly was resolved from, used for tooltip output - prepareToolTip: string * string -> string + type ResolvedFile = + { + /// Item specification. + itemSpec:string - /// Round-tripped baggage - baggage:string - } + /// Prepare textual information about where the assembly was resolved from, used for tooltip output + prepareToolTip: string * string -> string + + /// Round-tripped baggage + baggage:string + } -[] -type Resolver = - /// Get the "v4.5.1"-style moniker for the highest installed .NET Framework version. - /// This is the value passed back to Resolve if no explicit "mscorlib" has been given. - /// - /// Note: If an explicit "mscorlib" is given, then --noframework is being used, and the whole ReferenceResolver logic is essentially - /// unused. However in the future an option may be added to allow an explicit specification of - /// a .NET Framework version to use for scripts. - abstract member HighestInstalledNetFrameworkVersion: unit -> string - - /// Perform assembly resolution on the given references under the given conditions - abstract member Resolve: - resolutionEnvironment:ResolutionEnvironment * - references:(string * string) [] * - targetFrameworkVersion:string * - targetFrameworkDirectories:string list * - targetProcessorArchitecture:string * - fsharpCoreDir:string * - explicitIncludeDirs:string list * - implicitIncludeDir:string * - logMessage:(string -> unit) * - logDiagnostic:(bool -> string -> string -> unit) -> - ResolvedFile [] - - /// Get the Reference Assemblies directory for the .NET Framework (on Windows) - /// This is added to the default resolution path for - /// design-time compilations. - abstract member DotNetFrameworkReferenceAssembliesRootDirectory: string + [] + type Resolver = + /// Get the "v4.5.1"-style moniker for the highest installed .NET Framework version. + /// This is the value passed back to Resolve if no explicit "mscorlib" has been given. + /// + /// Note: If an explicit "mscorlib" is given, then --noframework is being used, and the whole ReferenceResolver logic is essentially + /// unused. However in the future an option may be added to allow an explicit specification of + /// a .NET Framework version to use for scripts. + abstract member HighestInstalledNetFrameworkVersion: unit -> string + + /// Perform assembly resolution on the given references under the given conditions + abstract member Resolve: + resolutionEnvironment:ResolutionEnvironment * + references:(string * string) [] * + targetFrameworkVersion:string * + targetFrameworkDirectories:string list * + targetProcessorArchitecture:string * + fsharpCoreDir:string * + explicitIncludeDirs:string list * + implicitIncludeDir:string * + logMessage:(string -> unit) * + logDiagnostic:(bool -> string -> string -> unit) -> + ResolvedFile [] + + /// Get the Reference Assemblies directory for the .NET Framework (on Windows) + /// This is added to the default resolution path for + /// design-time compilations. + abstract member DotNetFrameworkReferenceAssembliesRootDirectory: string diff --git a/src/fsharp/SignatureConformance.fsi b/src/fsharp/SignatureConformance.fsi index b1bd00345e9..e12dceae5fd 100644 --- a/src/fsharp/SignatureConformance.fsi +++ b/src/fsharp/SignatureConformance.fsi @@ -7,23 +7,10 @@ module internal FSharp.Compiler.SignatureConformance open System.Text open FSharp.Compiler -open FSharp.Compiler.AbstractIL.Internal -open FSharp.Compiler.AbstractIL.Internal.Library -open FSharp.Compiler.ErrorLogger -open FSharp.Compiler.Lib -open FSharp.Compiler.Infos open FSharp.Compiler.Range -open FSharp.Compiler.SyntaxTree -open FSharp.Compiler.SyntaxTreeOps open FSharp.Compiler.TypedTree -open FSharp.Compiler.TypedTreeBasics open FSharp.Compiler.TypedTreeOps -#if !NO_EXTENSIONTYPING -open FSharp.Compiler.ExtensionTyping -#endif - - exception RequiredButNotSpecified of DisplayEnv * ModuleOrNamespaceRef * string * (StringBuilder -> unit) * range exception ValueNotContained of DisplayEnv * ModuleOrNamespaceRef * Val * Val * (string * string * string -> string) @@ -36,640 +23,15 @@ exception FieldNotContained of DisplayEnv * RecdField * RecdField * (string * st exception InterfaceNotRevealed of DisplayEnv * TType * range -// Use a type to capture the constant, common parameters -type Checker(g, amap, denv, remapInfo: SignatureRepackageInfo, checkingSig) = - - // Build a remap that maps tcrefs in the signature to tcrefs in the implementation - // Used when checking attributes. - let sigToImplRemap = - let remap = Remap.Empty - let remap = (remapInfo.RepackagedEntities, remap) ||> List.foldBack (fun (implTcref, signTcref) acc -> addTyconRefRemap signTcref implTcref acc) - let remap = (remapInfo.RepackagedVals, remap) ||> List.foldBack (fun (implValRef, signValRef) acc -> addValRemap signValRef.Deref implValRef.Deref acc) - remap - - // For all attributable elements (types, modules, exceptions, record fields, unions, parameters, generic type parameters) - // - // (a) Start with lists AImpl and ASig containing the attributes in the implementation and signature, in declaration order - // (b) Each attribute in AImpl is checked against the available attributes in ASig. - // a. If an attribute is found in ASig which is an exact match (after evaluating attribute arguments), then the attribute in the implementation is ignored, the attribute is removed from ASig, and checking continues - // b. If an attribute is found in ASig that has the same attribute type, then a warning is given and the attribute in the implementation is ignored - // c. Otherwise, the attribute in the implementation is kept - // (c) The attributes appearing in the compiled element are the compiled forms of the attributes from the signature and the kept attributes from the implementation - let checkAttribs _aenv (implAttribs: Attribs) (sigAttribs: Attribs) fixup = - - // Remap the signature attributes to make them look as if they were declared in - // the implementation. This allows us to compare them and propagate them to the implementation - // if needed. - let sigAttribs = sigAttribs |> List.map (remapAttrib g sigToImplRemap) - - // Helper to check for equality of evaluated attribute expressions - let attribExprEq (AttribExpr(_, e1)) (AttribExpr(_, e2)) = EvaledAttribExprEquality g e1 e2 - - // Helper to check for equality of evaluated named attribute arguments - let attribNamedArgEq (AttribNamedArg(nm1, ty1, isProp1, e1)) (AttribNamedArg(nm2, ty2, isProp2, e2)) = - (nm1 = nm2) && - typeEquiv g ty1 ty2 && - (isProp1 = isProp2) && - attribExprEq e1 e2 - - let attribsEq attrib1 attrib2 = - let (Attrib(implTcref, _, implArgs, implNamedArgs, _, _, _implRange)) = attrib1 - let (Attrib(signTcref, _, signArgs, signNamedArgs, _, _, _signRange)) = attrib2 - tyconRefEq g signTcref implTcref && - (implArgs, signArgs) ||> List.lengthsEqAndForall2 attribExprEq && - (implNamedArgs, signNamedArgs) ||> List.lengthsEqAndForall2 attribNamedArgEq - - let attribsHaveSameTycon attrib1 attrib2 = - let (Attrib(implTcref, _, _, _, _, _, _)) = attrib1 - let (Attrib(signTcref, _, _, _, _, _, _)) = attrib2 - tyconRefEq g signTcref implTcref - - // For each implementation attribute, only keep if it is not mentioned in the signature. - // Emit a warning if it is mentioned in the signature and the arguments to the attributes are - // not identical. - let rec check keptImplAttribsRev implAttribs sigAttribs = - match implAttribs with - | [] -> keptImplAttribsRev |> List.rev - | implAttrib :: remainingImplAttribs -> - - // Look for an attribute in the signature that matches precisely. If so, remove it - let lookForMatchingAttrib = sigAttribs |> List.tryRemove (attribsEq implAttrib) - match lookForMatchingAttrib with - | Some (_, remainingSigAttribs) -> check keptImplAttribsRev remainingImplAttribs remainingSigAttribs - | None -> - - // Look for an attribute in the signature that has the same type. If so, give a warning - let existsSimilarAttrib = sigAttribs |> List.exists (attribsHaveSameTycon implAttrib) - - if existsSimilarAttrib then - let (Attrib(implTcref, _, _, _, _, _, implRange)) = implAttrib - warning(Error(FSComp.SR.tcAttribArgsDiffer(implTcref.DisplayName), implRange)) - check keptImplAttribsRev remainingImplAttribs sigAttribs - else - check (implAttrib :: keptImplAttribsRev) remainingImplAttribs sigAttribs - - let keptImplAttribs = check [] implAttribs sigAttribs - - fixup (sigAttribs @ keptImplAttribs) - true - - let rec checkTypars m (aenv: TypeEquivEnv) (implTypars: Typars) (sigTypars: Typars) = - if implTypars.Length <> sigTypars.Length then - errorR (Error(FSComp.SR.typrelSigImplNotCompatibleParamCountsDiffer(), m)) - false - else - let aenv = aenv.BindEquivTypars implTypars sigTypars - (implTypars, sigTypars) ||> List.forall2 (fun implTypar sigTypar -> - let m = sigTypar.Range - if implTypar.StaticReq <> sigTypar.StaticReq then - errorR (Error(FSComp.SR.typrelSigImplNotCompatibleCompileTimeRequirementsDiffer(), m)) - - // Adjust the actual type parameter name to look like the signature - implTypar.SetIdent (mkSynId implTypar.Range sigTypar.Id.idText) - - // Mark it as "not compiler generated", now that we've got a good name for it - implTypar.SetCompilerGenerated false - - // Check the constraints in the implementation are present in the signature - implTypar.Constraints |> List.forall (fun implTyparCx -> - match implTyparCx with - // defaults can be dropped in the signature - | TyparConstraint.DefaultsTo(_, _acty, _) -> true - | _ -> - if not (List.exists (typarConstraintsAEquiv g aenv implTyparCx) sigTypar.Constraints) - then (errorR(Error(FSComp.SR.typrelSigImplNotCompatibleConstraintsDiffer(sigTypar.Name, Layout.showL(NicePrint.layoutTyparConstraint denv (implTypar, implTyparCx))), m)); false) - else true) && - - // Check the constraints in the signature are present in the implementation - sigTypar.Constraints |> List.forall (fun sigTyparCx -> - match sigTyparCx with - // defaults can be present in the signature and not in the implementation because they are erased - | TyparConstraint.DefaultsTo(_, _acty, _) -> true - // 'comparison' and 'equality' constraints can be present in the signature and not in the implementation because they are erased - | TyparConstraint.SupportsComparison _ -> true - | TyparConstraint.SupportsEquality _ -> true - | _ -> - if not (List.exists (fun implTyparCx -> typarConstraintsAEquiv g aenv implTyparCx sigTyparCx) implTypar.Constraints) then - (errorR(Error(FSComp.SR.typrelSigImplNotCompatibleConstraintsDifferRemove(sigTypar.Name, Layout.showL(NicePrint.layoutTyparConstraint denv (sigTypar, sigTyparCx))), m)); false) - else - true) && - (not checkingSig || checkAttribs aenv implTypar.Attribs sigTypar.Attribs (fun attribs -> implTypar.SetAttribs attribs))) - - and checkTypeDef (aenv: TypeEquivEnv) (implTycon: Tycon) (sigTycon: Tycon) = - let m = implTycon.Range - - // Propagate defn location information from implementation to signature . - sigTycon.SetOtherRange (implTycon.Range, true) - implTycon.SetOtherRange (sigTycon.Range, false) - - if implTycon.LogicalName <> sigTycon.LogicalName then - errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleNamesDiffer(implTycon.TypeOrMeasureKind.ToString(), sigTycon.LogicalName, implTycon.LogicalName), m)) - false - else - - if implTycon.CompiledName <> sigTycon.CompiledName then - errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleNamesDiffer(implTycon.TypeOrMeasureKind.ToString(), sigTycon.CompiledName, implTycon.CompiledName), m)) - false - else - - checkExnInfo (fun f -> ExnconstrNotContained(denv, implTycon, sigTycon, f)) aenv implTycon.ExceptionInfo sigTycon.ExceptionInfo && - - let implTypars = implTycon.Typars m - let sigTypars = sigTycon.Typars m - - if implTypars.Length <> sigTypars.Length then - errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleParameterCountsDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) - false - elif isLessAccessible implTycon.Accessibility sigTycon.Accessibility then - errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleAccessibilityDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) - false - else - let aenv = aenv.BindEquivTypars implTypars sigTypars - - let aintfs = implTycon.ImmediateInterfaceTypesOfFSharpTycon - let fintfs = sigTycon.ImmediateInterfaceTypesOfFSharpTycon - let aintfsUser = implTycon.TypeContents.tcaug_interfaces |> List.filter (fun (_, compgen, _) -> not compgen) |> List.map p13 - let flatten tys = - tys - |> List.collect (AllSuperTypesOfType g amap m AllowMultiIntfInstantiations.Yes) - |> ListSet.setify (typeEquiv g) - |> List.filter (isInterfaceTy g) - let aintfs = flatten aintfs - let fintfs = flatten fintfs - - let unimpl = ListSet.subtract (fun fity aity -> typeAEquiv g aenv aity fity) fintfs aintfs - (unimpl - |> List.forall (fun ity -> - let errorMessage = FSComp.SR.DefinitionsInSigAndImplNotCompatibleMissingInterface(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, NicePrint.minimalStringOfType denv ity) - errorR (Error(errorMessage, m)); false)) && - - let aintfsUser = flatten aintfsUser - - let hidden = ListSet.subtract (typeAEquiv g aenv) aintfsUser fintfs - let continueChecks, warningOrError = if implTycon.IsFSharpInterfaceTycon then false, errorR else true, warning - (hidden |> List.forall (fun ity -> warningOrError (InterfaceNotRevealed(denv, ity, implTycon.Range)); continueChecks)) && - - let aNull = IsUnionTypeWithNullAsTrueValue g implTycon - let fNull = IsUnionTypeWithNullAsTrueValue g sigTycon - if aNull && not fNull then - errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplementationSaysNull(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) - false - elif fNull && not aNull then - errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleSignatureSaysNull(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) - false - else - - let aNull2 = TypeNullIsExtraValue g m (generalizedTyconRef (mkLocalTyconRef implTycon)) - let fNull2 = TypeNullIsExtraValue g m (generalizedTyconRef (mkLocalTyconRef implTycon)) - if aNull2 && not fNull2 then - errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplementationSaysNull2(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) - false - elif fNull2 && not aNull2 then - errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleSignatureSaysNull2(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) - false - else - - let aSealed = isSealedTy g (generalizedTyconRef (mkLocalTyconRef implTycon)) - let fSealed = isSealedTy g (generalizedTyconRef (mkLocalTyconRef sigTycon)) - if aSealed && not fSealed then - errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplementationSealed(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) - false - elif not aSealed && fSealed then - errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplementationIsNotSealed(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) - false - else - - let aPartial = isAbstractTycon implTycon - let fPartial = isAbstractTycon sigTycon - if aPartial && not fPartial then - errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplementationIsAbstract(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) - false - elif not aPartial && fPartial then - errorR(Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleSignatureIsAbstract(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) - false - elif not (typeAEquiv g aenv (superOfTycon g implTycon) (superOfTycon g sigTycon)) then - errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleTypesHaveDifferentBaseTypes(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)) - false - else - - checkTypars m aenv implTypars sigTypars && - checkTypeRepr m aenv implTycon sigTycon.TypeReprInfo && - checkTypeAbbrev m aenv implTycon sigTycon && - checkAttribs aenv implTycon.Attribs sigTycon.Attribs (fun attribs -> implTycon.entity_attribs <- attribs) && - checkModuleOrNamespaceContents implTycon.Range aenv (mkLocalEntityRef implTycon) sigTycon.ModuleOrNamespaceType - - and checkValInfo aenv err (implVal : Val) (sigVal : Val) = - let id = implVal.Id - match implVal.ValReprInfo, sigVal.ValReprInfo with - | _, None -> true - | None, Some _ -> err(FSComp.SR.ValueNotContainedMutabilityArityNotInferred) - | Some (ValReprInfo (implTyparNames, implArgInfos, implRetInfo) as implValInfo), Some (ValReprInfo (sigTyparNames, sigArgInfos, sigRetInfo) as sigValInfo) -> - let ntps = implTyparNames.Length - let mtps = sigTyparNames.Length - let nSigArgInfos = sigArgInfos.Length - if ntps <> mtps then - err(fun(x, y, z) -> FSComp.SR.ValueNotContainedMutabilityGenericParametersDiffer(x, y, z, string mtps, string ntps)) - elif implValInfo.KindsOfTypars <> sigValInfo.KindsOfTypars then - err(FSComp.SR.ValueNotContainedMutabilityGenericParametersAreDifferentKinds) - elif not (nSigArgInfos <= implArgInfos.Length && List.forall2 (fun x y -> List.length x <= List.length y) sigArgInfos (fst (List.splitAt nSigArgInfos implArgInfos))) then - err(fun(x, y, z) -> FSComp.SR.ValueNotContainedMutabilityAritiesDiffer(x, y, z, id.idText, string nSigArgInfos, id.idText, id.idText)) - else - let implArgInfos = implArgInfos |> List.truncate nSigArgInfos - let implArgInfos = (implArgInfos, sigArgInfos) ||> List.map2 (fun l1 l2 -> l1 |> List.take l2.Length) - // Propagate some information signature to implementation. - - // Check the attributes on each argument, and update the ValReprInfo for - // the value to reflect the information in the signature. - // This ensures that the compiled form of the value matches the signature rather than - // the implementation. This also propagates argument names from signature to implementation - let res = - (implArgInfos, sigArgInfos) ||> List.forall2 (List.forall2 (fun implArgInfo sigArgInfo -> - checkAttribs aenv implArgInfo.Attribs sigArgInfo.Attribs (fun attribs -> - match implArgInfo.Name, sigArgInfo.Name with - | Some iname, Some sname when sname.idText <> iname.idText -> - warning(Error (FSComp.SR.ArgumentsInSigAndImplMismatch(sname.idText, iname.idText), iname.idRange)) - | _ -> () - - implArgInfo.Name <- sigArgInfo.Name - implArgInfo.Attribs <- attribs))) && - - checkAttribs aenv implRetInfo.Attribs sigRetInfo.Attribs (fun attribs -> - implRetInfo.Name <- sigRetInfo.Name - implRetInfo.Attribs <- attribs) - - implVal.SetValReprInfo (Some (ValReprInfo (sigTyparNames, implArgInfos, implRetInfo))) - res - - and checkVal implModRef (aenv: TypeEquivEnv) (implVal: Val) (sigVal: Val) = - - // Propagate defn location information from implementation to signature . - sigVal.SetOtherRange (implVal.Range, true) - implVal.SetOtherRange (sigVal.Range, false) +type Checker = - let mk_err denv f = ValueNotContained(denv, implModRef, implVal, sigVal, f) - let err denv f = errorR(mk_err denv f); false - let m = implVal.Range - if implVal.IsMutable <> sigVal.IsMutable then (err denv FSComp.SR.ValueNotContainedMutabilityAttributesDiffer) - elif implVal.LogicalName <> sigVal.LogicalName then (err denv FSComp.SR.ValueNotContainedMutabilityNamesDiffer) - elif (implVal.CompiledName g.CompilerGlobalState) <> (sigVal.CompiledName g.CompilerGlobalState) then (err denv FSComp.SR.ValueNotContainedMutabilityCompiledNamesDiffer) - elif implVal.DisplayName <> sigVal.DisplayName then (err denv FSComp.SR.ValueNotContainedMutabilityDisplayNamesDiffer) - elif isLessAccessible implVal.Accessibility sigVal.Accessibility then (err denv FSComp.SR.ValueNotContainedMutabilityAccessibilityMore) - elif implVal.MustInline <> sigVal.MustInline then (err denv FSComp.SR.ValueNotContainedMutabilityInlineFlagsDiffer) - elif implVal.LiteralValue <> sigVal.LiteralValue then (err denv FSComp.SR.ValueNotContainedMutabilityLiteralConstantValuesDiffer) - elif implVal.IsTypeFunction <> sigVal.IsTypeFunction then (err denv FSComp.SR.ValueNotContainedMutabilityOneIsTypeFunction) - else - let implTypars, atau = implVal.TypeScheme - let sigTypars, ftau = sigVal.TypeScheme - if implTypars.Length <> sigTypars.Length then (err {denv with showTyparBinding=true} FSComp.SR.ValueNotContainedMutabilityParameterCountsDiffer) else - let aenv = aenv.BindEquivTypars implTypars sigTypars - checkTypars m aenv implTypars sigTypars && - if not (typeAEquiv g aenv atau ftau) then err denv (FSComp.SR.ValueNotContainedMutabilityTypesDiffer) - elif not (checkValInfo aenv (err denv) implVal sigVal) then false - elif not (implVal.IsExtensionMember = sigVal.IsExtensionMember) then err denv (FSComp.SR.ValueNotContainedMutabilityExtensionsDiffer) - elif not (checkMemberDatasConform (err denv) (implVal.Attribs, implVal, implVal.MemberInfo) (sigVal.Attribs, sigVal, sigVal.MemberInfo)) then false - else checkAttribs aenv implVal.Attribs sigVal.Attribs (fun attribs -> implVal.SetAttribs attribs) - - - and checkExnInfo err aenv implTypeRepr sigTypeRepr = - match implTypeRepr, sigTypeRepr with - | TExnAsmRepr _, TExnFresh _ -> - (errorR (err FSComp.SR.ExceptionDefsNotCompatibleHiddenBySignature); false) - | TExnAsmRepr tcr1, TExnAsmRepr tcr2 -> - if tcr1 <> tcr2 then (errorR (err FSComp.SR.ExceptionDefsNotCompatibleDotNetRepresentationsDiffer); false) else true - | TExnAbbrevRepr _, TExnFresh _ -> - (errorR (err FSComp.SR.ExceptionDefsNotCompatibleAbbreviationHiddenBySignature); false) - | TExnAbbrevRepr ecr1, TExnAbbrevRepr ecr2 -> - if not (tcrefAEquiv g aenv ecr1 ecr2) then - (errorR (err FSComp.SR.ExceptionDefsNotCompatibleSignaturesDiffer); false) - else true - | TExnFresh r1, TExnFresh r2-> checkRecordFieldsForExn g denv err aenv r1 r2 - | TExnNone, TExnNone -> true - | _ -> - (errorR (err FSComp.SR.ExceptionDefsNotCompatibleExceptionDeclarationsDiffer); false) - - and checkUnionCase aenv implUnionCase sigUnionCase = - let err f = errorR(ConstrNotContained(denv, implUnionCase, sigUnionCase, f));false - sigUnionCase.OtherRangeOpt <- Some (implUnionCase.Range, true) - implUnionCase.OtherRangeOpt <- Some (sigUnionCase.Range, false) - if implUnionCase.Id.idText <> sigUnionCase.Id.idText then err FSComp.SR.ModuleContainsConstructorButNamesDiffer - elif implUnionCase.RecdFieldsArray.Length <> sigUnionCase.RecdFieldsArray.Length then err FSComp.SR.ModuleContainsConstructorButDataFieldsDiffer - elif not (Array.forall2 (checkField aenv) implUnionCase.RecdFieldsArray sigUnionCase.RecdFieldsArray) then err FSComp.SR.ModuleContainsConstructorButTypesOfFieldsDiffer - elif isLessAccessible implUnionCase.Accessibility sigUnionCase.Accessibility then err FSComp.SR.ModuleContainsConstructorButAccessibilityDiffers - else checkAttribs aenv implUnionCase.Attribs sigUnionCase.Attribs (fun attribs -> implUnionCase.Attribs <- attribs) - - and checkField aenv implField sigField = - let err f = errorR(FieldNotContained(denv, implField, sigField, f)); false - sigField.rfield_other_range <- Some (implField.Range, true) - implField.rfield_other_range <- Some (sigField.Range, false) - if implField.rfield_id.idText <> sigField.rfield_id.idText then err FSComp.SR.FieldNotContainedNamesDiffer - elif isLessAccessible implField.Accessibility sigField.Accessibility then err FSComp.SR.FieldNotContainedAccessibilitiesDiffer - elif implField.IsStatic <> sigField.IsStatic then err FSComp.SR.FieldNotContainedStaticsDiffer - elif implField.IsMutable <> sigField.IsMutable then err FSComp.SR.FieldNotContainedMutablesDiffer - elif implField.LiteralValue <> sigField.LiteralValue then err FSComp.SR.FieldNotContainedLiteralsDiffer - elif not (typeAEquiv g aenv implField.FormalType sigField.FormalType) then err FSComp.SR.FieldNotContainedTypesDiffer - else - checkAttribs aenv implField.FieldAttribs sigField.FieldAttribs (fun attribs -> implField.rfield_fattribs <- attribs) && - checkAttribs aenv implField.PropertyAttribs sigField.PropertyAttribs (fun attribs -> implField.rfield_pattribs <- attribs) - - and checkMemberDatasConform err (_implAttrs, implVal, implMemberInfo) (_sigAttrs, sigVal, sigMemberInfo) = - match implMemberInfo, sigMemberInfo with - | None, None -> true - | Some implMembInfo, Some sigMembInfo -> - if not ((implVal.CompiledName g.CompilerGlobalState) = (sigVal.CompiledName g.CompilerGlobalState)) then - err(FSComp.SR.ValueNotContainedMutabilityDotNetNamesDiffer) - elif not (implMembInfo.MemberFlags.IsInstance = sigMembInfo.MemberFlags.IsInstance) then - err(FSComp.SR.ValueNotContainedMutabilityStaticsDiffer) - elif false then - err(FSComp.SR.ValueNotContainedMutabilityVirtualsDiffer) - elif not (implMembInfo.MemberFlags.IsDispatchSlot = sigMembInfo.MemberFlags.IsDispatchSlot) then - err(FSComp.SR.ValueNotContainedMutabilityAbstractsDiffer) - // The final check is an implication: - // classes have non-final CompareTo/Hash methods - // abstract have non-final CompareTo/Hash methods - // records have final CompareTo/Hash methods - // unions have final CompareTo/Hash methods - // This is an example where it is OK for the signature to say 'non-final' when the implementation says 'final' - elif not implMembInfo.MemberFlags.IsFinal && sigMembInfo.MemberFlags.IsFinal then - err(FSComp.SR.ValueNotContainedMutabilityFinalsDiffer) - elif not (implMembInfo.MemberFlags.IsOverrideOrExplicitImpl = sigMembInfo.MemberFlags.IsOverrideOrExplicitImpl) then - err(FSComp.SR.ValueNotContainedMutabilityOverridesDiffer) - elif not (implMembInfo.MemberFlags.MemberKind = sigMembInfo.MemberFlags.MemberKind) then - err(FSComp.SR.ValueNotContainedMutabilityOneIsConstructor) - else - let finstance = ValSpecIsCompiledAsInstance g sigVal - let ainstance = ValSpecIsCompiledAsInstance g implVal - if finstance && not ainstance then - err(FSComp.SR.ValueNotContainedMutabilityStaticButInstance) - elif not finstance && ainstance then - err(FSComp.SR.ValueNotContainedMutabilityInstanceButStatic) - else true - - | _ -> false - - and checkRecordFields m aenv (implTycon: Tycon) (implFields: TyconRecdFields) (sigFields: TyconRecdFields) = - let implFields = implFields.TrueFieldsAsList - let sigFields = sigFields.TrueFieldsAsList - let m1 = implFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) - let m2 = sigFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) - NameMap.suball2 - (fun fieldName _ -> errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleFieldRequiredButNotSpecified(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, fieldName), m)); false) - (checkField aenv) m1 m2 && - NameMap.suball2 - (fun fieldName _ -> errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleFieldWasPresent(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, fieldName), m)); false) - (fun x y -> checkField aenv y x) m2 m1 && - - // This check is required because constructors etc. are externally visible - // and thus compiled representations do pick up dependencies on the field order - (if List.forall2 (checkField aenv) implFields sigFields - then true - else (errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleFieldOrderDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false)) - - and checkRecordFieldsForExn _g _denv err aenv (implFields: TyconRecdFields) (sigFields: TyconRecdFields) = - let implFields = implFields.TrueFieldsAsList - let sigFields = sigFields.TrueFieldsAsList - let m1 = implFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) - let m2 = sigFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) - NameMap.suball2 (fun s _ -> errorR(err (fun (x, y) -> FSComp.SR.ExceptionDefsNotCompatibleFieldInSigButNotImpl(s, x, y))); false) (checkField aenv) m1 m2 && - NameMap.suball2 (fun s _ -> errorR(err (fun (x, y) -> FSComp.SR.ExceptionDefsNotCompatibleFieldInImplButNotSig(s, x, y))); false) (fun x y -> checkField aenv y x) m2 m1 && - // This check is required because constructors etc. are externally visible - // and thus compiled representations do pick up dependencies on the field order - (if List.forall2 (checkField aenv) implFields sigFields - then true - else (errorR(err (FSComp.SR.ExceptionDefsNotCompatibleFieldOrderDiffers)); false)) - - and checkVirtualSlots denv m (implTycon: Tycon) implAbstractSlots sigAbstractSlots = - let m1 = NameMap.ofKeyedList (fun (v: ValRef) -> v.DisplayName) implAbstractSlots - let m2 = NameMap.ofKeyedList (fun (v: ValRef) -> v.DisplayName) sigAbstractSlots - (m1, m2) ||> NameMap.suball2 (fun _s vref -> - let kindText = implTycon.TypeOrMeasureKind.ToString() - let valText = NicePrint.stringValOrMember denv vref.Deref - errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleAbstractMemberMissingInImpl(kindText, implTycon.DisplayName, valText), m)); false) (fun _x _y -> true) && - - (m2, m1) ||> NameMap.suball2 (fun _s vref -> - let kindText = implTycon.TypeOrMeasureKind.ToString() - let valText = NicePrint.stringValOrMember denv vref.Deref - errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleAbstractMemberMissingInSig(kindText, implTycon.DisplayName, valText), m)); false) (fun _x _y -> true) - - and checkClassFields isStruct m aenv (implTycon: Tycon) (implFields: TyconRecdFields) (sigFields: TyconRecdFields) = - let implFields = implFields.TrueFieldsAsList - let sigFields = sigFields.TrueFieldsAsList - let m1 = implFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) - let m2 = sigFields |> NameMap.ofKeyedList (fun rfld -> rfld.Name) - NameMap.suball2 - (fun fieldName _ -> errorR(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleFieldRequiredButNotSpecified(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, fieldName), m)); false) - (checkField aenv) m1 m2 && - (if isStruct then - NameMap.suball2 - (fun fieldName _ -> warning(Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleFieldIsInImplButNotSig(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, fieldName), m)); true) - (fun x y -> checkField aenv y x) m2 m1 - else - true) - - - and checkTypeRepr m aenv (implTycon: Tycon) sigTypeRepr = - let reportNiceError k s1 s2 = - let aset = NameSet.ofList s1 - let fset = NameSet.ofList s2 - match Zset.elements (Zset.diff aset fset) with - | [] -> - match Zset.elements (Zset.diff fset aset) with - | [] -> (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleNumbersDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, k), m)); false) - | l -> (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleSignatureDefinesButImplDoesNot(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, k, String.concat ";" l), m)); false) - | l -> (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplDefinesButSignatureDoesNot(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, k, String.concat ";" l), m)); false) - - match implTycon.TypeReprInfo, sigTypeRepr with - | (TRecdRepr _ - | TUnionRepr _ - | TILObjectRepr _ -#if !NO_EXTENSIONTYPING - | TProvidedTypeExtensionPoint _ - | TProvidedNamespaceExtensionPoint _ -#endif - ), TNoRepr -> true - | (TFSharpObjectRepr r), TNoRepr -> - match r.fsobjmodel_kind with - | TTyconStruct | TTyconEnum -> - (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleImplDefinesStruct(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) - | _ -> - true - | (TAsmRepr _), TNoRepr -> - (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleDotNetTypeRepresentationIsHidden(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) - | (TMeasureableRepr _), TNoRepr -> - (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleTypeIsHidden(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) - | (TUnionRepr r1), (TUnionRepr r2) -> - let ucases1 = r1.UnionCasesAsList - let ucases2 = r2.UnionCasesAsList - if ucases1.Length <> ucases2.Length then - let names (l: UnionCase list) = l |> List.map (fun c -> c.Id.idText) - reportNiceError "union case" (names ucases1) (names ucases2) - else List.forall2 (checkUnionCase aenv) ucases1 ucases2 - | (TRecdRepr implFields), (TRecdRepr sigFields) -> - checkRecordFields m aenv implTycon implFields sigFields - | (TFSharpObjectRepr r1), (TFSharpObjectRepr r2) -> - if not (match r1.fsobjmodel_kind, r2.fsobjmodel_kind with - | TTyconClass, TTyconClass -> true - | TTyconInterface, TTyconInterface -> true - | TTyconStruct, TTyconStruct -> true - | TTyconEnum, TTyconEnum -> true - | TTyconDelegate (TSlotSig(_, typ1, ctps1, mtps1, ps1, rty1)), - TTyconDelegate (TSlotSig(_, typ2, ctps2, mtps2, ps2, rty2)) -> - (typeAEquiv g aenv typ1 typ2) && - (ctps1.Length = ctps2.Length) && - (let aenv = aenv.BindEquivTypars ctps1 ctps2 - (typarsAEquiv g aenv ctps1 ctps2) && - (mtps1.Length = mtps2.Length) && - (let aenv = aenv.BindEquivTypars mtps1 mtps2 - (typarsAEquiv g aenv mtps1 mtps2) && - ((ps1, ps2) ||> List.lengthsEqAndForall2 (List.lengthsEqAndForall2 (fun p1 p2 -> typeAEquiv g aenv p1.Type p2.Type))) && - (returnTypesAEquiv g aenv rty1 rty2))) - | _, _ -> false) then - (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleTypeIsDifferentKind(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) - else - let isStruct = (match r1.fsobjmodel_kind with TTyconStruct -> true | _ -> false) - checkClassFields isStruct m aenv implTycon r1.fsobjmodel_rfields r2.fsobjmodel_rfields && - checkVirtualSlots denv m implTycon r1.fsobjmodel_vslots r2.fsobjmodel_vslots - | (TAsmRepr tcr1), (TAsmRepr tcr2) -> - if tcr1 <> tcr2 then (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleILDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) else true - | (TMeasureableRepr ty1), (TMeasureableRepr ty2) -> - if typeAEquiv g aenv ty1 ty2 then true else (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleRepresentationsDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) - | TNoRepr, TNoRepr -> true -#if !NO_EXTENSIONTYPING - | TProvidedTypeExtensionPoint info1, TProvidedTypeExtensionPoint info2 -> - Tainted.EqTainted info1.ProvidedType.TypeProvider info2.ProvidedType.TypeProvider && ProvidedType.TaintedEquals(info1.ProvidedType, info2.ProvidedType) - | TProvidedNamespaceExtensionPoint _, TProvidedNamespaceExtensionPoint _ -> - System.Diagnostics.Debug.Assert(false, "unreachable: TProvidedNamespaceExtensionPoint only on namespaces, not types" ) - true -#endif - | TNoRepr, _ -> (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleRepresentationsDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) - | _, _ -> (errorR (Error(FSComp.SR.DefinitionsInSigAndImplNotCompatibleRepresentationsDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) - - and checkTypeAbbrev m aenv (implTycon: Tycon) (sigTycon: Tycon) = - let kind1 = implTycon.TypeOrMeasureKind - let kind2 = sigTycon.TypeOrMeasureKind - if kind1 <> kind2 then (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleSignatureDeclaresDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, kind2.ToString(), kind1.ToString()), m)); false) - else - match implTycon.TypeAbbrev, sigTycon.TypeAbbrev with - | Some ty1, Some ty2 -> - if not (typeAEquiv g aenv ty1 ty2) then - let s1, s2, _ = NicePrint.minimalStringsOfTwoTypes denv ty1 ty2 - errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleAbbreviationsDiffer(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName, s1, s2), m)) - false - else - true - | None, None -> true - | Some _, None -> (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleAbbreviationHiddenBySig(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) - | None, Some _ -> (errorR (Error (FSComp.SR.DefinitionsInSigAndImplNotCompatibleSigHasAbbreviation(implTycon.TypeOrMeasureKind.ToString(), implTycon.DisplayName), m)); false) - - and checkModuleOrNamespaceContents m aenv (implModRef: ModuleOrNamespaceRef) (signModType: ModuleOrNamespaceType) = - let implModType = implModRef.ModuleOrNamespaceType - (if implModType.ModuleOrNamespaceKind <> signModType.ModuleOrNamespaceKind then errorR(Error(FSComp.SR.typrelModuleNamespaceAttributesDifferInSigAndImpl(), m))) - - - (implModType.TypesByMangledName, signModType.TypesByMangledName) - ||> NameMap.suball2 - (fun s _fx -> errorR(RequiredButNotSpecified(denv, implModRef, "type", (fun os -> Printf.bprintf os "%s" s), m)); false) - (checkTypeDef aenv) && - - - (implModType.ModulesAndNamespacesByDemangledName, signModType.ModulesAndNamespacesByDemangledName ) - ||> NameMap.suball2 - (fun s fx -> errorR(RequiredButNotSpecified(denv, implModRef, (if fx.IsModule then "module" else "namespace"), (fun os -> Printf.bprintf os "%s" s), m)); false) - (fun x1 x2 -> checkModuleOrNamespace aenv (mkLocalModRef x1) x2) && - - let sigValHadNoMatchingImplementation (fx: Val) (_closeActualVal: Val option) = - errorR(RequiredButNotSpecified(denv, implModRef, "value", (fun os -> - (* In the case of missing members show the full required enclosing type and signature *) - if fx.IsMember then - NicePrint.outputQualifiedValOrMember denv os fx - else - Printf.bprintf os "%s" fx.DisplayName), m)) - - let valuesPartiallyMatch (av: Val) (fv: Val) = - let akey = av.GetLinkagePartialKey() - let fkey = fv.GetLinkagePartialKey() - (akey.MemberParentMangledName = fkey.MemberParentMangledName) && - (akey.LogicalName = fkey.LogicalName) && - (akey.TotalArgCount = fkey.TotalArgCount) - - (implModType.AllValsAndMembersByLogicalNameUncached, signModType.AllValsAndMembersByLogicalNameUncached) - ||> NameMap.suball2 - (fun _s (fxs: Val list) -> sigValHadNoMatchingImplementation fxs.Head None; false) - (fun avs fvs -> - match avs, fvs with - | [], _ | _, [] -> failwith "unreachable" - | [av], [fv] -> - if valuesPartiallyMatch av fv then - checkVal implModRef aenv av fv - else - sigValHadNoMatchingImplementation fv None - false - | _ -> - // for each formal requirement, try to find a precisely matching actual requirement - let matchingPairs = - fvs |> List.choose (fun fv -> - match avs |> List.tryFind (fun av -> valLinkageAEquiv g aenv av fv) with - | None -> None - | Some av -> Some(fv, av)) - - // Check the ones with matching linkage - let allPairsOk = matchingPairs |> List.map (fun (fv, av) -> checkVal implModRef aenv av fv) |> List.forall id - let someNotOk = matchingPairs.Length < fvs.Length - // Report an error for those that don't. Try pairing up by enclosing-type/name - if someNotOk then - let noMatches, partialMatchingPairs = - fvs |> List.splitChoose (fun fv -> - match avs |> List.tryFind (fun av -> valuesPartiallyMatch av fv) with - | None -> Choice1Of2 fv - | Some av -> Choice2Of2(fv, av)) - for (fv, av) in partialMatchingPairs do - checkVal implModRef aenv av fv |> ignore - for fv in noMatches do - sigValHadNoMatchingImplementation fv None - allPairsOk && not someNotOk) - - - and checkModuleOrNamespace aenv implModRef sigModRef = - // Propagate defn location information from implementation to signature . - sigModRef.SetOtherRange (implModRef.Range, true) - implModRef.Deref.SetOtherRange (sigModRef.Range, false) - checkModuleOrNamespaceContents implModRef.Range aenv implModRef sigModRef.ModuleOrNamespaceType && - checkAttribs aenv implModRef.Attribs sigModRef.Attribs implModRef.Deref.SetAttribs - - member __.CheckSignature aenv (implModRef: ModuleOrNamespaceRef) (signModType: ModuleOrNamespaceType) = - checkModuleOrNamespaceContents implModRef.Range aenv implModRef signModType - - member __.CheckTypars m aenv (implTypars: Typars) (signTypars: Typars) = - checkTypars m aenv implTypars signTypars + new: g:TcGlobals.TcGlobals * amap:Import.ImportMap * denv:DisplayEnv * remapInfo:SignatureRepackageInfo * checkingSig:bool -> Checker + member CheckSignature: aenv:TypeEquivEnv -> implModRef:ModuleOrNamespaceRef -> signModType:ModuleOrNamespaceType -> bool + member CheckTypars: m:range -> aenv:TypeEquivEnv -> implTypars:Typars -> signTypars:Typars -> bool + /// Check the names add up between a signature and its implementation. We check this first. -let rec CheckNamesOfModuleOrNamespaceContents denv (implModRef: ModuleOrNamespaceRef) (signModType: ModuleOrNamespaceType) = - let m = implModRef.Range - let implModType = implModRef.ModuleOrNamespaceType - NameMap.suball2 - (fun s _fx -> errorR(RequiredButNotSpecified(denv, implModRef, "type", (fun os -> Printf.bprintf os "%s" s), m)); false) - (fun _ _ -> true) - implModType.TypesByMangledName - signModType.TypesByMangledName && - - (implModType.ModulesAndNamespacesByDemangledName, signModType.ModulesAndNamespacesByDemangledName ) - ||> NameMap.suball2 - (fun s fx -> errorR(RequiredButNotSpecified(denv, implModRef, (if fx.IsModule then "module" else "namespace"), (fun os -> Printf.bprintf os "%s" s), m)); false) - (fun x1 (x2: ModuleOrNamespace) -> CheckNamesOfModuleOrNamespace denv (mkLocalModRef x1) x2.ModuleOrNamespaceType) && - - (implModType.AllValsAndMembersByLogicalNameUncached, signModType.AllValsAndMembersByLogicalNameUncached) - ||> NameMap.suball2 - (fun _s (fxs: Val list) -> - let fx = fxs.Head - errorR(RequiredButNotSpecified(denv, implModRef, "value", (fun os -> - // In the case of missing members show the full required enclosing type and signature - if Option.isSome fx.MemberInfo then - NicePrint.outputQualifiedValOrMember denv os fx - else - Printf.bprintf os "%s" fx.DisplayName), m)); false) - (fun _ _ -> true) - - -and CheckNamesOfModuleOrNamespace denv (implModRef: ModuleOrNamespaceRef) signModType = - CheckNamesOfModuleOrNamespaceContents denv implModRef signModType +val CheckNamesOfModuleOrNamespaceContents: denv:DisplayEnv -> implModRef:ModuleOrNamespaceRef -> signModType:ModuleOrNamespaceType -> bool +val CheckNamesOfModuleOrNamespace: denv:DisplayEnv -> implModRef:ModuleOrNamespaceRef -> signModType:ModuleOrNamespaceType -> bool diff --git a/src/fsharp/TypeRelations.fs b/src/fsharp/TypeRelations.fs index 03943339f2a..487d8f96c32 100755 --- a/src/fsharp/TypeRelations.fs +++ b/src/fsharp/TypeRelations.fs @@ -279,7 +279,6 @@ let IteratedAdjustArityOfLambda g amap topValInfo e = let vsl, body = IteratedAdjustArityOfLambdaBody g arities vsl body tps, ctorThisValOpt, baseValOpt, vsl, body, bodyty - /// "Single Feasible Type" inference /// Look for the unique supertype of ty2 for which ty2 :> ty1 might feasibly hold let FindUniqueFeasibleSupertype g amap m ty1 ty2 = diff --git a/src/fsharp/TypedTreeOps.fs b/src/fsharp/TypedTreeOps.fs index bca626f99ca..54708141bc0 100644 --- a/src/fsharp/TypedTreeOps.fs +++ b/src/fsharp/TypedTreeOps.fs @@ -3072,7 +3072,7 @@ let TryFindILAttributeOpt attr attrs = /// provided attributes. // // This is used for AttributeUsageAttribute, DefaultMemberAttribute and ConditionalAttribute (on attribute types) -let TryBindTyconRefAttribute g (m: range) (AttribInfo (atref, _) as args) (tcref: TyconRef) f1 f2 f3 = +let TryBindTyconRefAttribute g (m: range) (AttribInfo (atref, _) as args) (tcref: TyconRef) f1 f2 (f3: (obj option list * (string * obj option) list -> 'a option)) : 'a option = ignore m; ignore f3 match metadataOfTycon tcref.Deref with #if !NO_EXTENSIONTYPING diff --git a/src/fsharp/TypedTreeOps.fsi b/src/fsharp/TypedTreeOps.fsi index e47cb63da60..ecb112426d0 100755 --- a/src/fsharp/TypedTreeOps.fsi +++ b/src/fsharp/TypedTreeOps.fsi @@ -2422,4 +2422,12 @@ val (|TryFinallyExpr|_|): Expr -> (DebugPointAtTry * DebugPointAtFinally * TType val mkLabelled: range -> ILCodeLabel -> Expr -> Expr /// Shared helper for binding attributes -val TryBindTyconRefAttribute: g:TcGlobals -> m:range -> BuiltinAttribInfo -> tcref:TyconRef -> f1:(ILAttribElem list * ILAttributeNamedArg list -> 'a option) -> f2:(Attrib -> 'a option) -> f3:(obj option list * (string * obj option) list -> 'a option) -> 'a option +val TryBindTyconRefAttribute: + g:TcGlobals -> + m:range -> + BuiltinAttribInfo -> + tcref:TyconRef -> + f1:(ILAttribElem list * ILAttributeNamedArg list -> 'a option) -> + f2:(Attrib -> 'a option) -> + f3:(obj option list * (string * obj option) list -> 'a option) + -> 'a option diff --git a/src/fsharp/XmlAdapters.fs b/src/fsharp/XmlAdapters.fs index 2e04733fc18..908f5f059ff 100644 --- a/src/fsharp/XmlAdapters.fs +++ b/src/fsharp/XmlAdapters.fs @@ -1,19 +1,18 @@ // Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. -namespace Microsoft.FSharp.Core +module internal FSharp.Compiler.XmlAdapters //Replacement for: System.Security.SecurityElement.Escape(line) All platforms -module internal XmlAdapters = - let s_escapeChars = [| '<'; '>'; '\"'; '\''; '&' |] +let s_escapeChars = [| '<'; '>'; '\"'; '\''; '&' |] - let getEscapeSequence c = - match c with - | '<' -> "<" - | '>' -> ">" - | '\"' -> """ - | '\'' -> "'" - | '&' -> "&" - | _ as ch -> ch.ToString() +let getEscapeSequence c = + match c with + | '<' -> "<" + | '>' -> ">" + | '\"' -> """ + | '\'' -> "'" + | '&' -> "&" + | _ as ch -> ch.ToString() - let escape str = String.collect getEscapeSequence str +let escape str = String.collect getEscapeSequence str diff --git a/src/fsharp/absil/il.fs b/src/fsharp/absil/il.fs index c7a021b75b4..f2f895611e8 100644 --- a/src/fsharp/absil/il.fs +++ b/src/fsharp/absil/il.fs @@ -1301,6 +1301,23 @@ type ILFieldInit = | Double of double | Null + member x.AsObject() = + match x with + | ILFieldInit.String s -> box s + | ILFieldInit.Bool bool -> box bool + | ILFieldInit.Char u16 -> box (char (int u16)) + | ILFieldInit.Int8 i8 -> box i8 + | ILFieldInit.Int16 i16 -> box i16 + | ILFieldInit.Int32 i32 -> box i32 + | ILFieldInit.Int64 i64 -> box i64 + | ILFieldInit.UInt8 u8 -> box u8 + | ILFieldInit.UInt16 u16 -> box u16 + | ILFieldInit.UInt32 u32 -> box u32 + | ILFieldInit.UInt64 u64 -> box u64 + | ILFieldInit.Single ieee32 -> box ieee32 + | ILFieldInit.Double ieee64 -> box ieee64 + | ILFieldInit.Null -> (null :> Object) + // -------------------------------------------------------------------- // Native Types, for marshalling to the native C interface. // These are taken directly from the ILASM syntax, and don't really diff --git a/src/fsharp/absil/il.fsi b/src/fsharp/absil/il.fsi index 723e8995024..bcfeb3eca36 100644 --- a/src/fsharp/absil/il.fsi +++ b/src/fsharp/absil/il.fsi @@ -629,6 +629,8 @@ type ILFieldInit = | Double of double | Null + member AsObject: unit -> obj + [] type ILNativeVariant = | Empty diff --git a/src/fsharp/absil/ilreflect.fs b/src/fsharp/absil/ilreflect.fs index b23273f909f..2e410f95772 100644 --- a/src/fsharp/absil/ilreflect.fs +++ b/src/fsharp/absil/ilreflect.fs @@ -620,27 +620,6 @@ let convReturnModifiers cenv emEnv (p: ILReturn) = let mods = convParamModifiersOfType cenv emEnv p.Type splitModifiers mods -//---------------------------------------------------------------------------- -// convFieldInit -//---------------------------------------------------------------------------- - -let convFieldInit x = - match x with - | ILFieldInit.String s -> box s - | ILFieldInit.Bool bool -> box bool - | ILFieldInit.Char u16 -> box (char (int u16)) - | ILFieldInit.Int8 i8 -> box i8 - | ILFieldInit.Int16 i16 -> box i16 - | ILFieldInit.Int32 i32 -> box i32 - | ILFieldInit.Int64 i64 -> box i64 - | ILFieldInit.UInt8 u8 -> box u8 - | ILFieldInit.UInt16 u16 -> box u16 - | ILFieldInit.UInt32 u32 -> box u32 - | ILFieldInit.UInt64 u64 -> box u64 - | ILFieldInit.Single ieee32 -> box ieee32 - | ILFieldInit.Double ieee64 -> box ieee64 - | ILFieldInit.Null -> (null :> Object) - //---------------------------------------------------------------------------- // Some types require hard work... //---------------------------------------------------------------------------- @@ -1652,14 +1631,14 @@ let buildFieldPass2 cenv tref (typB: TypeBuilder) emEnv (fdef: ILFieldDef) = // it is ok to init fields with type = enum that are defined in other assemblies || not fieldT.Assembly.IsDynamic then - fieldB.SetConstant(convFieldInit initial) + fieldB.SetConstant(initial.AsObject()) emEnv else // if field type (enum) is defined in FSI dynamic assembly it is created as nested type // => its underlying type cannot be explicitly specified and will be inferred at the very moment of first field definition // => here we cannot detect if underlying type is already set so as a conservative solution we delay initialization of fields // to the end of pass2 (types and members are already created but method bodies are yet not emitted) - { emEnv with delayedFieldInits = (fun() -> fieldB.SetConstant(convFieldInit initial)) :: emEnv.delayedFieldInits } + { emEnv with delayedFieldInits = (fun() -> fieldB.SetConstant(initial.AsObject())) :: emEnv.delayedFieldInits } fdef.Offset |> Option.iter (fun offset -> fieldB.SetOffset offset) // custom attributes: done on pass 3 as they may reference attribute constructors generated on // pass 2. @@ -1684,7 +1663,7 @@ let buildPropertyPass2 cenv tref (typB: TypeBuilder) emEnv (prop: ILPropertyDef) prop.SetMethod |> Option.iter (fun mref -> propB.SetSetMethod(envGetMethB emEnv mref)) prop.GetMethod |> Option.iter (fun mref -> propB.SetGetMethod(envGetMethB emEnv mref)) // set default value - prop.Init |> Option.iter (fun initial -> propB.SetConstant(convFieldInit initial)) + prop.Init |> Option.iter (fun initial -> propB.SetConstant(initial.AsObject())) // custom attributes let pref = ILPropertyRef.Create (tref, prop.Name) envBindPropRef emEnv pref propB diff --git a/src/fsharp/infos.fsi b/src/fsharp/infos.fsi index a2b6b5f88df..083fb373ff8 100644 --- a/src/fsharp/infos.fsi +++ b/src/fsharp/infos.fsi @@ -4,13 +4,16 @@ module internal FSharp.Compiler.Infos open FSharp.Compiler open FSharp.Compiler.AbstractIL.IL -open FSharp.Compiler.ExtensionTyping open FSharp.Compiler.Import open FSharp.Compiler.Range open FSharp.Compiler.TypedTree open FSharp.Compiler.TypedTreeOps open FSharp.Compiler.TcGlobals +#if !NO_EXTENSIONTYPING +open FSharp.Compiler.ExtensionTyping +#endif + /// Import an IL type as an F# type. importInst gives the context for interpreting type variables. val ImportILType: scoref:ILScopeRef -> amap:ImportMap -> m:range -> importInst:TType list -> ilty:ILType -> TType @@ -493,8 +496,12 @@ type MethInfo = /// For an extension member, drop the 'this' argument. member NumArgs: int list - /// Get the information about provided static parameters, if any +/// Get the information about provided static parameters, if any +#if NO_EXTENSIONTYPING + member ProvidedStaticParameterInfo: obj option +#else member ProvidedStaticParameterInfo: (Tainted * Tainted []) option +#endif /// Get the TcGlobals value that governs the method declaration member TcGlobals: TcGlobals diff --git a/src/fsharp/service/FSharpCheckerResults.fs b/src/fsharp/service/FSharpCheckerResults.fs index 803d0858bb1..e862f4abc0f 100644 --- a/src/fsharp/service/FSharpCheckerResults.fs +++ b/src/fsharp/service/FSharpCheckerResults.fs @@ -502,7 +502,10 @@ type internal TypeCheckInfo nameMatchesResidue n1 || meths |> List.exists (fun meth -> let tcref = meth.ApparentEnclosingTyconRef - tcref.IsProvided || nameMatchesResidue tcref.DisplayName) +#if !NO_EXTENSIONTYPING + tcref.IsProvided || +#endif + nameMatchesResidue tcref.DisplayName) | _ -> residue = n1) /// Post-filter items to make sure they have precisely the right name diff --git a/src/fsharp/symbols/Symbols.fs b/src/fsharp/symbols/Symbols.fs index b9959dcbb00..4021f93d3d0 100644 --- a/src/fsharp/symbols/Symbols.fs +++ b/src/fsharp/symbols/Symbols.fs @@ -955,7 +955,7 @@ type FSharpField(cenv: SymbolEnv, d: FSharpFieldData) = if isUnresolved() then None else match d.TryRecdField with | Choice1Of3 r -> getLiteralValue r.LiteralValue - | Choice2Of3 f -> f.LiteralValue |> Option.map AbstractIL.ILRuntimeWriter.convFieldInit + | Choice2Of3 f -> f.LiteralValue |> Option.map (fun v -> v.AsObject()) | Choice3Of3 _ -> None member _.IsVolatile = @@ -1171,6 +1171,8 @@ type FSharpGenericParameter(cenv, v:Typar) = (fun () -> Item.TypeVar(v.Name, v)), (fun _ _ _ad -> true)) + member _.Range = v.Range + member _.Name = v.DisplayName member _.DeclarationLocation = v.Range diff --git a/src/fsharp/utils/CompilerLocationUtils.fsi b/src/fsharp/utils/CompilerLocationUtils.fsi index 15cf7ab934b..3301f19f931 100644 --- a/src/fsharp/utils/CompilerLocationUtils.fsi +++ b/src/fsharp/utils/CompilerLocationUtils.fsi @@ -6,7 +6,6 @@ open Microsoft.FSharp.Core module internal FSharpEnvironment = - module internal FSharpEnvironment = val FSharpBannerVersion: string val FSharpProductName: string From 96148810b55fcfa46ec27d34213a1230293e2d53 Mon Sep 17 00:00:00 2001 From: Don Syme Date: Fri, 11 Dec 2020 23:12:41 +0000 Subject: [PATCH 4/8] fix build --- src/fsharp/ErrorLogger.fsi | 6 +++--- src/fsharp/TypedTree.fs | 2 +- src/fsharp/absil/ilreflect.fs | 2 +- src/fsharp/absil/ilreflect.fsi | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/fsharp/ErrorLogger.fsi b/src/fsharp/ErrorLogger.fsi index 144ec183461..4a0e187b974 100644 --- a/src/fsharp/ErrorLogger.fsi +++ b/src/fsharp/ErrorLogger.fsi @@ -164,11 +164,11 @@ type CapturingErrorLogger = [] type internal CompileThreadStatic = - static member BuildPhase: BuildPhase + static member BuildPhase: BuildPhase with get, set - static member BuildPhaseUnchecked: BuildPhase + static member BuildPhaseUnchecked: BuildPhase with get - static member ErrorLogger: ErrorLogger + static member ErrorLogger: ErrorLogger with get, set [] module ErrorLoggerExtensions = diff --git a/src/fsharp/TypedTree.fs b/src/fsharp/TypedTree.fs index 462943e7439..b5f3bffaf6b 100644 --- a/src/fsharp/TypedTree.fs +++ b/src/fsharp/TypedTree.fs @@ -5434,7 +5434,7 @@ type Construct() = #endif /// Create a new entity node for a module or namespace - static member NewModuleOrNamespace cpath access (id: Ident) xml attribs mtype = + static member NewModuleOrNamespace cpath access (id: Ident) (xml: XmlDoc) attribs mtype = let stamp = newStamp() // Put the module suffix on if needed Tycon.New "mspec" diff --git a/src/fsharp/absil/ilreflect.fs b/src/fsharp/absil/ilreflect.fs index 2e410f95772..e77f4ca6869 100644 --- a/src/fsharp/absil/ilreflect.fs +++ b/src/fsharp/absil/ilreflect.fs @@ -2080,7 +2080,7 @@ let defineDynamicAssemblyAndLog (asmName, flags, asmDir: string) = printfn "let assemblyBuilder%d = System.AppDomain.CurrentDomain.DefineDynamicAssembly(AssemblyName(Name=\"%s\"), enum %d, %A)" (abs <| hash asmB) asmName.Name (LanguagePrimitives.EnumToValue flags) asmDir asmB -let mkDynamicAssemblyAndModule (assemblyName, optimize, debugInfo, collectible) = +let mkDynamicAssemblyAndModule (assemblyName, optimize, debugInfo: bool, collectible) = let filename = assemblyName + ".dll" let asmDir = "." let asmName = new AssemblyName() diff --git a/src/fsharp/absil/ilreflect.fsi b/src/fsharp/absil/ilreflect.fsi index 88a2103904e..061a8a8521d 100644 --- a/src/fsharp/absil/ilreflect.fsi +++ b/src/fsharp/absil/ilreflect.fsi @@ -24,7 +24,7 @@ open FSharp.Compiler.ErrorLogger open FSharp.Compiler.Range open FSharp.Core.Printf -val mkDynamicAssemblyAndModule: assemblyName:string * optimize:bool * debugInfo:'a * collectible:bool -> AssemblyBuilder * ModuleBuilder +val mkDynamicAssemblyAndModule: assemblyName:string * optimize:bool * debugInfo:bool * collectible:bool -> AssemblyBuilder * ModuleBuilder type cenv = { ilg: ILGlobals From 361d73a2c215915dfd0347f7567b92b263fc3ddd Mon Sep 17 00:00:00 2001 From: Don Syme Date: Fri, 11 Dec 2020 23:17:08 +0000 Subject: [PATCH 5/8] fix build --- src/fsharp/symbols/SymbolHelpers.fs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/fsharp/symbols/SymbolHelpers.fs b/src/fsharp/symbols/SymbolHelpers.fs index 08d663393cf..0548770d56e 100644 --- a/src/fsharp/symbols/SymbolHelpers.fs +++ b/src/fsharp/symbols/SymbolHelpers.fs @@ -1514,6 +1514,7 @@ module internal SymbolHelpers = /// Get rid of groups of overloads an replace them with single items. let FlattenItems g (m: range) item = + ignore m match item with | Item.MethodGroup(nm, minfos, orig) -> minfos |> List.map (fun minfo -> Item.MethodGroup(nm, [minfo], orig)) | Item.CtorGroup(nm, cinfos) -> cinfos |> List.map (fun minfo -> Item.CtorGroup(nm, [minfo])) From 96005a4083edfa4d4c0eb99a629b39ef5c878866 Mon Sep 17 00:00:00 2001 From: Don Syme Date: Fri, 11 Dec 2020 23:17:37 +0000 Subject: [PATCH 6/8] fix build --- .../FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj b/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj index 836c31fb5be..6ce94b9ea98 100644 --- a/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj +++ b/src/fsharp/FSharp.Compiler.Service/FSharp.Compiler.Service.fsproj @@ -7,7 +7,7 @@ true $(DefineConstants);COMPILER_SERVICE_AS_DLL $(DefineConstants);COMPILER - $(DefineConstants);ENABLE_MONO_SUPPORT;NO_EXTENSIONTYPING + $(DefineConstants);ENABLE_MONO_SUPPORT $(OtherFlags) --sig:all.fsi /warnon:3218 /warnon:1182 /warnon:3390 --times true From d6b5c09f13d3539350dd28c3acffc534aa654692 Mon Sep 17 00:00:00 2001 From: Don Syme Date: Fri, 11 Dec 2020 23:18:25 +0000 Subject: [PATCH 7/8] fix build --- src/fsharp/FSharp.Compiler.Service/all.fsi | 45187 ------------------- 1 file changed, 45187 deletions(-) delete mode 100644 src/fsharp/FSharp.Compiler.Service/all.fsi diff --git a/src/fsharp/FSharp.Compiler.Service/all.fsi b/src/fsharp/FSharp.Compiler.Service/all.fsi deleted file mode 100644 index a9de56778fb..00000000000 --- a/src/fsharp/FSharp.Compiler.Service/all.fsi +++ /dev/null @@ -1,45187 +0,0 @@ -namespace FSComp - type internal SR = - class - private new : unit -> SR - static member - ArgumentsInSigAndImplMismatch : a0:System.String * a1:System.String -> - int * string - static member - CallerMemberNameIsOverriden : a0:System.String -> int * string - static member - DefaultParameterValueNotAppropriateForArgument : unit -> int * string - static member - DefinitionsInSigAndImplNotCompatibleAbbreviationHiddenBySig : a0:System.String * - a1:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleAbbreviationsDiffer : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleAbstractMemberMissingInImpl : a0:System.String * - a1:System.String * - a2:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleAbstractMemberMissingInSig : a0:System.String * - a1:System.String * - a2:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleAccessibilityDiffer : a0:System.String * - a1:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleDotNetTypeRepresentationIsHidden : a0:System.String * - a1:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleFieldIsInImplButNotSig : a0:System.String * - a1:System.String * - a2:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleFieldOrderDiffer : a0:System.String * - a1:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleFieldRequiredButNotSpecified : a0:System.String * - a1:System.String * - a2:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleFieldWasPresent : a0:System.String * - a1:System.String * - a2:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleILDiffer : a0:System.String * - a1:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleImplDefinesButSignatureDoesNot : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleImplDefinesStruct : a0:System.String * - a1:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleImplementationIsAbstract : a0:System.String * - a1:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleImplementationIsNotSealed : a0:System.String * - a1:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleImplementationSaysNull : a0:System.String * - a1:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleImplementationSaysNull2 : a0:System.String * - a1:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleImplementationSealed : a0:System.String * - a1:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleMissingInterface : a0:System.String * - a1:System.String * - a2:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleNamesDiffer : a0:System.String * - a1:System.String * - a2:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleNumbersDiffer : a0:System.String * - a1:System.String * - a2:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleParameterCountsDiffer : a0:System.String * - a1:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleRepresentationsDiffer : a0:System.String * - a1:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleSigHasAbbreviation : a0:System.String * - a1:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleSignatureDeclaresDiffer : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleSignatureDefinesButImplDoesNot : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String -> - int * - string - static member - DefinitionsInSigAndImplNotCompatibleSignatureIsAbstract : a0:System.String * - a1:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleSignatureSaysNull : a0:System.String * - a1:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleSignatureSaysNull2 : a0:System.String * - a1:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleTypeIsDifferentKind : a0:System.String * - a1:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleTypeIsHidden : a0:System.String * - a1:System.String -> - int * string - static member - DefinitionsInSigAndImplNotCompatibleTypesHaveDifferentBaseTypes : a0:System.String * - a1:System.String -> - int * - string - static member - ExceptionDefsNotCompatibleAbbreviationHiddenBySignature : a0:System.String * - a1:System.String -> - string - static member - ExceptionDefsNotCompatibleDotNetRepresentationsDiffer : a0:System.String * - a1:System.String -> - string - static member - ExceptionDefsNotCompatibleExceptionDeclarationsDiffer : a0:System.String * - a1:System.String -> - string - static member - ExceptionDefsNotCompatibleFieldInImplButNotSig : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ExceptionDefsNotCompatibleFieldInSigButNotImpl : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ExceptionDefsNotCompatibleFieldOrderDiffers : a0:System.String * - a1:System.String -> string - static member - ExceptionDefsNotCompatibleHiddenBySignature : a0:System.String * - a1:System.String -> string - static member - ExceptionDefsNotCompatibleSignaturesDiffer : a0:System.String * - a1:System.String -> string - static member - FieldNotContainedAccessibilitiesDiffer : a0:System.String * - a1:System.String -> string - static member - FieldNotContainedLiteralsDiffer : a0:System.String * a1:System.String -> - string - static member - FieldNotContainedMutablesDiffer : a0:System.String * a1:System.String -> - string - static member - FieldNotContainedNamesDiffer : a0:System.String * a1:System.String -> - string - static member - FieldNotContainedStaticsDiffer : a0:System.String * a1:System.String -> - string - static member - FieldNotContainedTypesDiffer : a0:System.String * a1:System.String -> - string - static member - InvalidRecursiveReferenceToAbstractSlot : unit -> int * string - static member - ModuleContainsConstructorButAccessibilityDiffers : a0:System.String * - a1:System.String -> - string - static member - ModuleContainsConstructorButDataFieldsDiffer : a0:System.String * - a1:System.String -> - string - static member - ModuleContainsConstructorButNamesDiffer : a0:System.String * - a1:System.String -> string - static member - ModuleContainsConstructorButTypesOfFieldsDiffer : a0:System.String * - a1:System.String -> - string - static member RunStartupValidation : unit -> unit - static member - ValueNotContainedMutabilityAbstractsDiffer : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - ValueNotContainedMutabilityAccessibilityMore : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ValueNotContainedMutabilityAritiesDiffer : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String * - a4:System.String * - a5:System.String * - a6:System.String -> string - static member - ValueNotContainedMutabilityArityNotInferred : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - ValueNotContainedMutabilityAttributesDiffer : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - ValueNotContainedMutabilityCompiledNamesDiffer : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ValueNotContainedMutabilityDisplayNamesDiffer : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ValueNotContainedMutabilityDotNetNamesDiffer : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ValueNotContainedMutabilityExtensionsDiffer : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - ValueNotContainedMutabilityFinalsDiffer : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - ValueNotContainedMutabilityGenericParametersAreDifferentKinds : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ValueNotContainedMutabilityGenericParametersDiffer : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String * - a4:System.String -> - string - static member - ValueNotContainedMutabilityInlineFlagsDiffer : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ValueNotContainedMutabilityInstanceButStatic : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ValueNotContainedMutabilityLiteralConstantValuesDiffer : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ValueNotContainedMutabilityNamesDiffer : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - ValueNotContainedMutabilityOneIsConstructor : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - ValueNotContainedMutabilityOneIsTypeFunction : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ValueNotContainedMutabilityOverridesDiffer : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - ValueNotContainedMutabilityParameterCountsDiffer : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ValueNotContainedMutabilityStaticButInstance : a0:System.String * - a1:System.String * - a2:System.String -> - string - static member - ValueNotContainedMutabilityStaticsDiffer : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - ValueNotContainedMutabilityTypesDiffer : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - ValueNotContainedMutabilityVirtualsDiffer : a0:System.String * - a1:System.String * - a2:System.String -> string - static member abImplicitHeapAllocation : a0:System.String -> int * string - static member - activePatternChoiceHasFreeTypars : a0:System.String -> int * string - static member - activePatternIdentIsNotFunctionTyped : a0:System.String -> int * string - static member addIndexerDot : unit -> string - static member - arrayElementHasWrongType : a0:System.String * a1:System.String -> string - static member - assemblyResolutionFoundByAssemblyFoldersExKey : unit -> string - static member assemblyResolutionFoundByAssemblyFoldersKey : unit -> string - static member assemblyResolutionGAC : unit -> string - static member assemblyResolutionNetFramework : unit -> string - static member astDeprecatedIndexerNotation : unit -> string - static member astInvalidExprLeftHandOfAssignment : unit -> int * string - static member astParseEmbeddedILError : unit -> int * string - static member astParseEmbeddedILTypeError : unit -> int * string - static member augCustomCompareNeedsIComp : unit -> int * string - static member augCustomEqNeedsNoCompOrCustomComp : unit -> int * string - static member augCustomEqNeedsObjEquals : unit -> int * string - static member augInvalidAttrs : unit -> int * string - static member augNoCompCantImpIComp : unit -> int * string - static member augNoEqNeedsNoObjEquals : unit -> int * string - static member augNoEqualityNeedsNoComparison : unit -> int * string - static member augNoRefEqualsOnStruct : unit -> int * string - static member augOnlyCertainTypesCanHaveAttrs : unit -> int * string - static member augRefEqCantHaveObjEquals : unit -> int * string - static member augStructCompNeedsStructEquality : unit -> int * string - static member augStructEqNeedsNoCompOrStructComp : unit -> int * string - static member augTypeCantHaveRefEqAndStructAttrs : unit -> int * string - static member buildArgInvalidFloat : a0:System.String -> int * string - static member buildArgInvalidInt : a0:System.String -> int * string - static member buildAssemblyResolutionFailed : unit -> int * string - static member buildCannotReadAssembly : a0:System.String -> int * string - static member buildCompilingExtensionIsForML : unit -> string - static member - buildCouldNotFindSourceFile : a0:System.String -> int * string - static member - buildCouldNotResolveAssembly : a0:System.String -> int * string - static member - buildCouldNotResolveAssemblyRequiredByFile : a0:System.String * - a1:System.String -> - int * string - static member - buildDifferentVersionMustRecompile : a0:System.String -> int * string - static member buildDirectivesInModulesAreIgnored : unit -> int * string - static member - buildErrorOpeningBinaryFile : a0:System.String * a1:System.String -> - int * string - static member - buildExpectedFileAlongSideFSharpCore : a0:System.String * - a1:System.String -> int * string - static member buildExpectedSigdataFile : a0:System.String -> int * string - static member - buildImplementationAlreadyGiven : a0:System.String -> int * string - static member - buildImplementationAlreadyGivenDetail : a0:System.String -> int * string - static member - buildImplicitModuleIsNotLegalIdentifier : a0:System.String * - a1:System.String -> - int * string - static member buildInvalidAssemblyName : a0:System.String -> int * string - static member buildInvalidFilename : a0:System.String -> int * string - static member buildInvalidHashIDirective : unit -> int * string - static member buildInvalidHashloadDirective : unit -> int * string - static member buildInvalidHashrDirective : unit -> int * string - static member buildInvalidHashtimeDirective : unit -> int * string - static member buildInvalidModuleOrNamespaceName : unit -> int * string - static member buildInvalidPrivacy : a0:System.String -> int * string - static member - buildInvalidSearchDirectory : a0:System.String -> int * string - static member - buildInvalidSourceFileExtension : a0:System.String -> int * string - static member buildInvalidVersionFile : a0:System.String -> int * string - static member buildInvalidVersionString : a0:System.String -> int * string - static member buildInvalidWarningNumber : a0:System.String -> int * string - static member - buildMultiFileRequiresNamespaceOrModule : unit -> int * string - static member buildMultipleToplevelModules : unit -> int * string - static member buildNoInputsSpecified : unit -> int * string - static member - buildOptionRequiresParameter : a0:System.String -> int * string - static member buildPdbRequiresDebug : unit -> int * string - static member - buildProblemReadingAssembly : a0:System.String * a1:System.String -> - int * string - static member - buildProblemWithFilename : a0:System.String * a1:System.String -> - int * string - static member - buildSearchDirectoryNotFound : a0:System.String -> int * string - static member - buildSignatureAlreadySpecified : a0:System.String -> int * string - static member - buildSignatureWithoutImplementation : a0:System.String -> int * string - static member - buildUnexpectedFileNameCharacter : a0:System.String * a1:System.String -> - int * string - static member - buildUnexpectedTypeArgs : a0:System.String * a1:System.Int32 -> string - static member buildUnrecognizedOption : a0:System.String -> int * string - static member - cannotResolveNullableOperators : a0:System.String -> int * string - static member - checkLowercaseLiteralBindingInPattern : a0:System.String -> int * string - static member - checkNotSufficientlyGenericBecauseOfScope : a0:System.String -> - int * string - static member - checkNotSufficientlyGenericBecauseOfScopeAnon : unit -> int * string - static member - checkRaiseFamilyFunctionArgumentCount : a0:System.String * - a1:System.Int32 * - a2:System.Int32 -> int * string - static member chkAttrHasAllowMultiFalse : a0:System.String -> int * string - static member chkBaseUsedInInvalidWay : unit -> int * string - static member chkByrefUsedInInvalidWay : a0:System.String -> int * string - static member chkCantStoreByrefValue : unit -> int * string - static member chkCurriedMethodsCantHaveOutParams : unit -> int * string - static member - chkDuplicateMethod : a0:System.String * a1:System.String -> int * string - static member - chkDuplicateMethodCurried : a0:System.String * a1:System.String -> - int * string - static member - chkDuplicateMethodInheritedType : a0:System.String -> int * string - static member - chkDuplicateMethodInheritedTypeWithSuffix : a0:System.String -> - int * string - static member - chkDuplicateMethodWithSuffix : a0:System.String * a1:System.String -> - int * string - static member - chkDuplicateProperty : a0:System.String * a1:System.String -> - int * string - static member - chkDuplicatePropertyWithSuffix : a0:System.String * a1:System.String -> - int * string - static member chkEntryPointUsage : unit -> int * string - static member chkErrorContainsCallToRethrow : unit -> int * string - static member chkErrorUseOfByref : unit -> int * string - static member - chkFeatureNotLanguageSupported : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member - chkFeatureNotRuntimeSupported : a0:System.String -> int * string - static member - chkFeatureNotSupportedInLibrary : a0:System.String * a1:System.String -> - int * string - static member chkFirstClassFuncNoByref : unit -> int * string - static member - chkGetterAndSetterHaveSamePropertyType : a0:System.String * - a1:System.String * - a2:System.String -> - int * string - static member - chkGetterSetterDoNotMatchAbstract : a0:System.String * a1:System.String -> - int * string - static member chkInvalidCustAttrVal : unit -> int * string - static member - chkInvalidFunctionParameterType : a0:System.String * a1:System.String -> - int * string - static member - chkInvalidFunctionReturnType : a0:System.String -> int * string - static member chkLimitationsOfBaseKeyword : unit -> int * string - static member - chkMemberUsedInInvalidWay : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member - chkMultipleGenericInterfaceInstantiations : a0:System.String * - a1:System.String -> - int * string - static member - chkNoAddressFieldAtThisPoint : a0:System.String -> int * string - static member chkNoAddressOfArrayElementAtThisPoint : unit -> int * string - static member chkNoAddressOfAtThisPoint : a0:System.String -> int * string - static member - chkNoAddressStaticFieldAtThisPoint : a0:System.String -> int * string - static member chkNoByrefAddressOfLocal : a0:System.String -> int * string - static member - chkNoByrefAddressOfValueFromExpression : unit -> int * string - static member chkNoByrefAsTopValue : unit -> int * string - static member chkNoByrefAtThisPoint : a0:System.String -> int * string - static member chkNoByrefInTypeAbbrev : unit -> int * string - static member chkNoByrefLikeFunctionCall : unit -> int * string - static member chkNoByrefsOfByrefs : a0:System.String -> int * string - static member chkNoFirstClassAddressOf : unit -> int * string - static member chkNoFirstClassNameOf : unit -> int * string - static member chkNoFirstClassRethrow : unit -> int * string - static member chkNoFirstClassSplicing : unit -> int * string - static member - chkNoReflectedDefinitionOnStructMember : unit -> int * string - static member chkNoSpanLikeValueFromExpression : unit -> int * string - static member chkNoSpanLikeVariable : a0:System.String -> int * string - static member chkNoWriteToLimitedSpan : a0:System.String -> int * string - static member chkObjCtorsCantUseExceptionHandling : unit -> int * string - static member - chkPropertySameNameIndexer : a0:System.String * a1:System.String -> - int * string - static member - chkPropertySameNameMethod : a0:System.String * a1:System.String -> - int * string - static member chkProtectedOrBaseCalled : unit -> int * string - static member chkReflectedDefCantSplice : unit -> int * string - static member chkReturnTypeNoByref : unit -> int * string - static member chkSplicingOnlyInQuotations : unit -> int * string - static member - chkStructsMayNotReturnAddressesOfContents : unit -> int * string - static member chkSystemVoidOnlyInTypeof : unit -> int * string - static member chkTyparMultipleClassConstraints : unit -> int * string - static member - chkTypeLessAccessibleThanType : a0:System.String * a1:System.String -> - int * string - static member chkUnionCaseCompiledForm : unit -> string - static member chkUnionCaseDefaultAugmentation : unit -> string - static member chkUnusedThisVariable : a0:System.String -> int * string - static member chkUnusedValue : a0:System.String -> int * string - static member - chkValueWithDefaultValueMustHaveDefaultValue : unit -> int * string - static member chkVariableUsedInInvalidWay : a0:System.String -> string - static member commaInsteadOfSemicolonInRecord : unit -> string - static member - considerUpcast : a0:System.String * a1:System.String -> int * string - static member - considerUpcastOperator : a0:System.String * a1:System.String -> - int * string - static member - couldNotLoadDependencyManagerExtension : a0:System.String * - a1:System.String -> - int * string - static member crefBoundVarUsedInSplice : a0:System.String -> int * string - static member crefNoInnerGenericsInQuotations : unit -> int * string - static member crefNoSetOfHole : unit -> int * string - static member crefQuotationsCantCallTraitMembers : unit -> int * string - static member crefQuotationsCantContainAddressOf : unit -> int * string - static member - crefQuotationsCantContainArrayPatternMatching : unit -> int * string - static member - crefQuotationsCantContainDescendingForLoops : unit -> int * string - static member crefQuotationsCantContainGenericExprs : unit -> int * string - static member - crefQuotationsCantContainGenericFunctions : unit -> int * string - static member crefQuotationsCantContainInlineIL : unit -> int * string - static member crefQuotationsCantContainObjExprs : unit -> int * string - static member - crefQuotationsCantContainStaticFieldRef : unit -> int * string - static member crefQuotationsCantContainThisConstant : unit -> int * string - static member - crefQuotationsCantContainThisPatternMatch : unit -> int * string - static member crefQuotationsCantContainThisType : unit -> int * string - static member crefQuotationsCantFetchUnionIndexes : unit -> int * string - static member crefQuotationsCantRequireByref : unit -> int * string - static member crefQuotationsCantSetExceptionFields : unit -> int * string - static member crefQuotationsCantSetUnionFields : unit -> int * string - static member csArgumentLengthMismatch : unit -> int * string - static member csArgumentTypesDoNotMatch : unit -> int * string - static member csAvailableOverloads : a0:System.String -> string - static member csCandidates : a0:System.String -> string - static member csCodeLessGeneric : unit -> int * string - static member - csCtorHasNoArgumentOrReturnProperty : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - csCtorSignatureMismatchArity : a0:System.String * a1:System.Int32 * - a2:System.Int32 * a3:System.String -> - int * string - static member - csCtorSignatureMismatchArityProp : a0:System.String * a1:System.Int32 * - a2:System.Int32 * a3:System.String -> - int * string - static member - csExpectTypeWithOperatorButGivenFunction : a0:System.String -> string - static member - csExpectTypeWithOperatorButGivenTuple : a0:System.String -> string - static member csExpectedArguments : unit -> string - static member - csGenericConstructRequiresNonAbstract : a0:System.String -> string - static member - csGenericConstructRequiresPublicDefaultConstructor : a0:System.String -> - string - static member - csGenericConstructRequiresReferenceSemantics : a0:System.String -> - string - static member - csGenericConstructRequiresStructOrReferenceConstraint : unit -> string - static member - csGenericConstructRequiresStructType : a0:System.String -> string - static member - csGenericConstructRequiresUnmanagedType : a0:System.String -> string - static member - csIncorrectGenericInstantiation : a0:System.String * a1:System.String * - a2:System.Int32 -> int * string - static member - csIndexArgumentMismatch : a0:System.Int32 * a1:System.Int32 -> string - static member - csMemberHasNoArgumentOrReturnProperty : a0:System.String * - a1:System.String * - a2:System.String -> string - static member - csMemberIsNotAccessible : a0:System.String * a1:System.String -> - int * string - static member - csMemberIsNotAccessible2 : a0:System.String * a1:System.String -> - int * string - static member csMemberIsNotInstance : a0:System.String -> int * string - static member csMemberIsNotStatic : a0:System.String -> int * string - static member - csMemberNotAccessible : a0:System.String * a1:System.Int32 * - a2:System.String * a3:System.Int32 -> - int * string - static member - csMemberOverloadArityMismatch : a0:System.String * a1:System.Int32 * - a2:System.Int32 -> int * string - static member - csMemberSignatureMismatch : a0:System.String * a1:System.Int32 * - a2:System.String -> int * string - static member - csMemberSignatureMismatch2 : a0:System.String * a1:System.Int32 * - a2:System.String -> int * string - static member - csMemberSignatureMismatch3 : a0:System.String * a1:System.Int32 * - a2:System.String * a3:System.String -> - int * string - static member - csMemberSignatureMismatch4 : a0:System.String * a1:System.Int32 * - a2:System.String * a3:System.String -> - int * string - static member - csMemberSignatureMismatchArity : a0:System.String * a1:System.Int32 * - a2:System.Int32 * a3:System.String -> - int * string - static member - csMemberSignatureMismatchArityNamed : a0:System.String * a1:System.Int32 * - a2:System.Int32 * a3:System.Int32 * - a4:System.String -> int * string - static member - csMemberSignatureMismatchArityType : a0:System.String * a1:System.Int32 * - a2:System.Int32 * a3:System.String -> - int * string - static member csMethodExpectsParams : unit -> int * string - static member - csMethodFoundButIsNotStatic : a0:System.String * a1:System.String * - a2:System.String -> string - static member - csMethodFoundButIsStatic : a0:System.String * a1:System.String * - a2:System.String -> string - static member - csMethodIsNotAStaticMethod : a0:System.String -> int * string - static member - csMethodIsNotAnInstanceMethod : a0:System.String -> int * string - static member csMethodIsOverloaded : a0:System.String -> string - static member csMethodNotFound : a0:System.String -> int * string - static member - csNoMemberTakesTheseArguments : a0:System.String * a1:System.String * - a2:System.Int32 -> int * string - static member - csNoMemberTakesTheseArguments2 : a0:System.String * a1:System.String * - a2:System.Int32 * a3:System.Int32 -> - int * string - static member - csNoMemberTakesTheseArguments3 : a0:System.String * a1:System.String * - a2:System.Int32 * a3:System.String -> - int * string - static member csNoOverloadsFound : a0:System.String -> string - static member - csNoOverloadsFoundArgumentsPrefixPlural : a0:System.String -> string - static member - csNoOverloadsFoundArgumentsPrefixSingular : a0:System.String -> string - static member csNoOverloadsFoundReturnType : a0:System.String -> string - static member - csNoOverloadsFoundTypeParametersPrefixPlural : a0:System.String -> - string - static member - csNoOverloadsFoundTypeParametersPrefixSingular : a0:System.String -> - string - static member csNullableTypeDoesNotHaveNull : a0:System.String -> string - static member csOptionalArgumentNotPermittedHere : unit -> int * string - static member - csOverloadCandidateIndexedArgumentTypeMismatch : a0:System.Int32 -> - string - static member - csOverloadCandidateNamedArgumentTypeMismatch : a0:System.String -> - string - static member csRequiredSignatureIs : a0:System.String -> int * string - static member csStructConstraintInconsistent : unit -> int * string - static member - csTypeCannotBeResolvedAtCompileTime : a0:System.String -> string - static member csTypeDoesNotHaveNull : a0:System.String -> string - static member csTypeDoesNotSupportComparison1 : a0:System.String -> string - static member csTypeDoesNotSupportComparison2 : a0:System.String -> string - static member csTypeDoesNotSupportComparison3 : a0:System.String -> string - static member - csTypeDoesNotSupportConversion : a0:System.String * a1:System.String -> - string - static member csTypeDoesNotSupportEquality1 : a0:System.String -> string - static member csTypeDoesNotSupportEquality2 : a0:System.String -> string - static member csTypeDoesNotSupportEquality3 : a0:System.String -> string - static member - csTypeDoesNotSupportOperator : a0:System.String * a1:System.String -> - string - static member - csTypeDoesNotSupportOperatorNullable : a0:System.String * - a1:System.String -> string - static member - csTypeHasNonStandardDelegateType : a0:System.String -> string - static member csTypeInferenceMaxDepth : unit -> int * string - static member csTypeInstantiationLengthMismatch : unit -> int * string - static member csTypeIsNotDelegateType : a0:System.String -> string - static member csTypeIsNotEnumType : a0:System.String -> string - static member - csTypeNotCompatibleBecauseOfPrintf : a0:System.String * a1:System.String -> - string - static member csTypeParameterCannotBeNullable : unit -> string - static member - csTypesDoNotSupportOperator : a0:System.String * a1:System.String -> - string - static member - csTypesDoNotSupportOperatorNullable : a0:System.String * - a1:System.String -> string - static member - customOperationTextLikeGroupJoin : a0:System.String * a1:System.String * - a2:System.String -> string - static member - customOperationTextLikeJoin : a0:System.String * a1:System.String * - a2:System.String -> string - static member customOperationTextLikeZip : a0:System.String -> string - static member - delegatesNotAllowedToHaveCurriedSignatures : unit -> int * string - static member derefInsteadOfNot : unit -> string - static member descriptionUnavailable : unit -> string - static member descriptionWordIs : unit -> string - static member docfileNoXmlSuffix : unit -> int * string - static member elDeprecatedOperator : unit -> string - static member elSysEnvExitDidntExit : unit -> string - static member - elseBranchHasWrongType : a0:System.String * a1:System.String -> string - static member erasedTo : unit -> string - static member - estApplyStaticArgumentsForMethodNotImplemented : unit -> string - static member etBadUnnamedStaticArgs : unit -> int * string - static member - etDirectReferenceToGeneratedTypeNotAllowed : a0:System.String -> - int * string - static member - etEmptyNamespaceNotAllowed : a0:System.String -> int * string - static member - etEmptyNamespaceOfTypeNotAllowed : a0:System.String * a1:System.String -> - int * string - static member - etErasedTypeUsedInGeneration : a0:System.String * a1:System.String -> - int * string - static member - etErrorApplyingStaticArgumentsToMethod : unit -> int * string - static member etErrorApplyingStaticArgumentsToType : unit -> int * string - static member - etEventNoAdd : a0:System.String * a1:System.String -> int * string - static member - etEventNoRemove : a0:System.String * a1:System.String -> int * string - static member - etHostingAssemblyFoundWithoutHosts : a0:System.String * a1:System.String -> - int * string - static member - etIllegalCharactersInNamespaceName : a0:System.String * a1:System.String -> - int * string - static member - etIllegalCharactersInTypeName : a0:System.String * a1:System.String -> - int * string - static member - etIncorrectParameterExpression : a0:System.String * a1:System.String -> - int * string - static member - etIncorrectProvidedConstructor : a0:System.String * a1:System.String -> - int * string - static member - etIncorrectProvidedMethod : a0:System.String * a1:System.String * - a2:System.Int32 * a3:System.String -> - int * string - static member etInvalidStaticArgument : a0:System.String -> int * string - static member - etInvalidTypeProviderAssemblyName : a0:System.String * a1:System.String -> - int * string - static member - etMethodHasRequirements : a0:System.String * a1:System.String -> - int * string - static member etMissingStaticArgumentsToMethod : unit -> int * string - static member - etMultipleStaticParameterWithName : a0:System.String -> int * string - static member etMustNotBeAnArray : a0:System.String -> int * string - static member etMustNotBeGeneric : a0:System.String -> int * string - static member - etNestedProvidedTypesDoNotTakeStaticArgumentsOrGenericParameters : unit -> - int * - string - static member - etNoStaticParameterWithName : a0:System.String -> int * string - static member etNullMember : a0:System.String -> int * string - static member - etNullMemberDeclaringType : a0:System.String * a1:System.String -> - int * string - static member - etNullMemberDeclaringTypeDifferentFromProvidedType : a0:System.String * - a1:System.String * - a2:System.String -> - int * string - static member etNullOrEmptyMemberName : a0:System.String -> int * string - static member etNullProvidedExpression : a0:System.String -> int * string - static member - etOneOrMoreErrorsSeenDuringExtensionTypeSetting : unit -> int * string - static member - etPropertyCanReadButHasNoGetter : a0:System.String * a1:System.String -> - int * string - static member - etPropertyCanWriteButHasNoSetter : a0:System.String * a1:System.String -> - int * string - static member - etPropertyHasGetterButNoCanRead : a0:System.String * a1:System.String -> - int * string - static member - etPropertyHasSetterButNoCanWrite : a0:System.String * a1:System.String -> - int * string - static member - etPropertyNeedsCanWriteOrCanRead : a0:System.String * a1:System.String -> - int * string - static member - etProvidedAppliedMethodHadWrongName : a0:System.String * - a1:System.String * - a2:System.String -> int * string - static member - etProvidedAppliedTypeHadWrongName : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member - etProvidedTypeHasUnexpectedName : a0:System.String * a1:System.String -> - int * string - static member - etProvidedTypeHasUnexpectedPath : a0:System.String * a1:System.String -> - int * string - static member - etProvidedTypeReferenceInvalidText : a0:System.String -> int * string - static member - etProvidedTypeReferenceMissingArgument : a0:System.String -> - int * string - static member - etProvidedTypeWithNameException : a0:System.String * a1:System.String -> - int * string - static member - etProvidedTypeWithNullOrEmptyName : a0:System.String -> int * string - static member etProviderDoesNotHaveValidConstructor : unit -> int * string - static member - etProviderError : a0:System.String * a1:System.String -> int * string - static member - etProviderErrorWithContext : a0:System.String * a1:System.String * - a2:System.String * a3:System.String -> - int * string - static member - etProviderHasDesignerAssemblyDependency : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String -> - int * string - static member - etProviderHasDesignerAssemblyException : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String -> - int * string - static member - etProviderHasWrongDesignerAssembly : a0:System.String * a1:System.String * - a2:System.String * a3:System.String * - a4:System.String -> int * string - static member - etProviderHasWrongDesignerAssemblyNoPath : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String -> - int * string - static member etProviderReturnedNull : a0:System.String -> int * string - static member - etStaticParameterAlreadyHasValue : a0:System.String -> int * string - static member - etStaticParameterRequiresAValue : a0:System.String * a1:System.String * - a2:System.String * a3:System.String -> - int * string - static member - etTooManyStaticParameters : a0:System.Int32 * a1:System.Int32 * - a2:System.Int32 -> int * string - static member - etTypeProviderConstructorException : a0:System.String -> int * string - static member - etUnexpectedExceptionFromProvidedMemberMember : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String -> - int * string - static member - etUnexpectedExceptionFromProvidedTypeMember : a0:System.String * - a1:System.String * - a2:System.String -> - int * string - static member - etUnexpectedNullFromProvidedTypeMember : a0:System.String * - a1:System.String -> - int * string - static member - etUnknownStaticArgumentKind : a0:System.String * a1:System.String -> - int * string - static member etUnsupportedConstantType : a0:System.String -> int * string - static member - etUnsupportedMemberKind : a0:System.String * a1:System.String -> - int * string - static member - etUnsupportedProvidedExpression : a0:System.String -> int * string - static member - eventHasNonStandardType : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member experimentalConstruct : unit -> string - static member expressionHasNoName : unit -> int * string - static member featureAndBang : unit -> string - static member featureDefaultInterfaceMemberConsumption : unit -> string - static member featureDotlessFloat32Literal : unit -> string - static member featureExpandedMeasurables : unit -> string - static member featureFixedIndexSlice3d4d : unit -> string - static member featureFromEndSlicing : unit -> string - static member featureImplicitYield : unit -> string - static member - featureInterfacesWithMultipleGenericInstantiation : unit -> string - static member featureNameOf : unit -> string - static member featureNullableOptionalInterop : unit -> string - static member featureOpenTypeDeclaration : unit -> string - static member featureOverloadsForCustomOperations : unit -> string - static member featurePackageManagement : unit -> string - static member featureRelaxWhitespace : unit -> string - static member featureSingleUnderscorePattern : unit -> string - static member featureStringInterpolation : unit -> string - static member featureWildCardInForLoop : unit -> string - static member featureWitnessPassing : unit -> string - static member fieldIsNotAccessible : a0:System.String -> int * string - static member - followingPatternMatchClauseHasWrongType : a0:System.String * - a1:System.String -> string - static member forBadFormatSpecifier : unit -> string - static member forBadFormatSpecifierGeneral : a0:System.String -> string - static member forBadPrecision : unit -> string - static member forBadWidth : unit -> string - static member - forDoesNotSupportPrefixFlag : a0:System.String * a1:System.String -> - string - static member forDoesNotSupportZeroFlag : a0:System.String -> string - static member forFlagSetTwice : a0:System.String -> string - static member forFormatDoesntSupportPrecision : a0:System.String -> string - static member forFormatInvalidForInterpolated : unit -> string - static member forFormatInvalidForInterpolated2 : unit -> string - static member forFormatInvalidForInterpolated3 : unit -> string - static member forFormatInvalidForInterpolated4 : unit -> string - static member forHIsUnnecessary : unit -> string - static member forHashSpecifierIsInvalid : unit -> string - static member forLIsUnnecessary : unit -> string - static member forMissingFormatSpecifier : unit -> string - static member forPositionalSpecifiersNotPermitted : unit -> string - static member forPrecisionMissingAfterDot : unit -> string - static member forPrefixFlagSpacePlusSetTwice : unit -> string - static member formatDashItem : a0:System.String -> string - static member fromEndSlicingRequiresVFive : unit -> int * string - static member fscAssemblyCultureAttributeError : unit -> int * string - static member - fscAssemblyNotFoundInDependencySet : a0:System.String -> int * string - static member fscAssemblyVersionAttributeIgnored : unit -> int * string - static member - fscAssemblyWildcardAndDeterminism : a0:System.String * a1:System.String -> - int * string - static member - fscAssumeStaticLinkContainsNoDependencies : a0:System.String -> - int * string - static member - fscBadAssemblyVersion : a0:System.String * a1:System.String -> - int * string - static member fscDelaySignWarning : unit -> int * string - static member - fscDeterministicDebugRequiresPortablePdb : unit -> int * string - static member - fscIgnoringMixedWhenLinking : a0:System.String -> int * string - static member - fscKeyFileCouldNotBeOpened : a0:System.String -> int * string - static member fscKeyFileWarning : unit -> int * string - static member fscKeyNameWarning : unit -> int * string - static member fscNoImplementationFiles : unit -> int * string - static member fscPathMapDebugRequiresPortablePdb : unit -> int * string - static member - fscProblemWritingBinary : a0:System.String * a1:System.String -> - int * string - static member - fscQuotationLiteralsStaticLinking : a0:System.String -> int * string - static member fscQuotationLiteralsStaticLinking0 : unit -> int * string - static member fscReferenceOnCommandLine : a0:System.String -> int * string - static member fscRemotingError : unit -> int * string - static member - fscResxSourceFileDeprecated : a0:System.String -> int * string - static member fscStaticLinkingNoEXE : unit -> int * string - static member fscStaticLinkingNoMixedDLL : unit -> int * string - static member fscStaticLinkingNoProfileMismatches : unit -> int * string - static member - fscSystemRuntimeInteropServicesIsRequired : unit -> int * string - static member fscTooManyErrors : unit -> string - static member fscTwoResourceManifests : unit -> int * string - static member fsharpCoreNotFoundToBeCopied : unit -> int * string - static member - fsiInvalidDirective : a0:System.String * a1:System.String -> - int * string - static member ifExpression : a0:System.String * a1:System.String -> string - static member ilAddressOfLiteralFieldIsInvalid : unit -> int * string - static member - ilAddressOfValueHereIsInvalid : a0:System.String -> int * string - static member - ilCustomMarshallersCannotBeUsedInFSharp : unit -> int * string - static member - ilDefaultAugmentationAttributeCouldNotBeDecoded : unit -> int * string - static member ilDllImportAttributeCouldNotBeDecoded : unit -> int * string - static member ilDynamicInvocationNotSupported : a0:System.String -> string - static member - ilFieldDoesNotHaveValidOffsetForStructureLayout : a0:System.String * - a1:System.String -> - int * string - static member ilFieldHasOffsetForSequentialLayout : unit -> int * string - static member - ilFieldOffsetAttributeCouldNotBeDecoded : unit -> int * string - static member ilIncorrectNumberOfTypeArguments : unit -> int * string - static member ilLabelNotFound : a0:System.String -> int * string - static member ilLiteralFieldsCannotBeSet : unit -> int * string - static member ilMainModuleEmpty : unit -> int * string - static member ilMarshalAsAttributeCannotBeDecoded : unit -> int * string - static member ilMutableVariablesCannotEscapeMethod : unit -> int * string - static member - ilReflectedDefinitionsCannotUseSliceOperator : unit -> int * string - static member ilSignBadImageFormat : unit -> int * string - static member ilSignInvalidAlgId : unit -> int * string - static member ilSignInvalidBitLen : unit -> int * string - static member ilSignInvalidMagicValue : unit -> int * string - static member ilSignInvalidPKBlob : unit -> int * string - static member ilSignInvalidRSAParams : unit -> int * string - static member ilSignInvalidSignatureSize : unit -> int * string - static member ilSignNoSignatureDirectory : unit -> int * string - static member ilSignPrivateKeyExpected : unit -> int * string - static member ilSignRsaKeyExpected : unit -> int * string - static member - ilSignatureForExternalFunctionContainsTypeParameters : unit -> - int * string - static member ilStaticMethodIsNotLambda : a0:System.String -> int * string - static member - ilStructLayoutAttributeCouldNotBeDecoded : unit -> int * string - static member ilTypeCannotBeUsedForLiteralField : unit -> int * string - static member ilUndefinedValue : a0:System.String -> int * string - static member ilUnexpectedGetSetAnnotation : unit -> int * string - static member ilUnexpectedUnrealizedValue : unit -> int * string - static member ilreadFileChanged : a0:System.String -> int * string - static member ilwriteErrorCreatingMdb : unit -> int * string - static member ilwriteErrorCreatingPdb : a0:System.String -> int * string - static member - ilwriteMDBFileNameCannotBeChangedWarning : unit -> int * string - static member ilwriteMDBMemberMissing : a0:System.String -> int * string - static member - ilxgenUnexpectedArgumentToMethodHandleOfDuringCodegen : unit -> - int * string - static member - impImportedAssemblyUsesNotPublicType : a0:System.String -> int * string - static member - impInvalidMeasureArgument1 : a0:System.String * a1:System.String -> - int * string - static member - impInvalidMeasureArgument2 : a0:System.String -> int * string - static member - impInvalidNumberOfGenericArguments : a0:System.String * a1:System.Int32 * - a2:System.Int32 -> int * string - static member - impNotEnoughTypeParamsInScopeWhileImporting : unit -> int * string - static member - impReferenceToDllRequiredByAssembly : a0:System.String * - a1:System.String * - a2:System.String -> int * string - static member - impReferencedTypeCouldNotBeFoundInAssembly : a0:System.String * - a1:System.String -> - int * string - static member - impTypeRequiredUnavailable : a0:System.String * a1:System.String -> - int * string - static member - implicitlyDiscardedInSequenceExpression : a0:System.String -> - int * string - static member - implicitlyDiscardedSequenceInSequenceExpression : a0:System.String -> - int * string - static member - infosInvalidProvidedLiteralValue : a0:System.String -> int * string - static member invalidFullNameForProvidedType : unit -> string - static member invalidNamespaceForProvidedType : unit -> string - static member invalidPlatformTarget : unit -> int * string - static member - itemNotFoundDuringDynamicCodeGen : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member - itemNotFoundInTypeDuringDynamicCodeGen : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String -> - int * string - static member keywordDescriptionAbstract : unit -> string - static member keywordDescriptionAs : unit -> string - static member keywordDescriptionAssert : unit -> string - static member keywordDescriptionBase : unit -> string - static member keywordDescriptionBegin : unit -> string - static member keywordDescriptionCast : unit -> string - static member keywordDescriptionClass : unit -> string - static member keywordDescriptionConst : unit -> string - static member keywordDescriptionDefault : unit -> string - static member keywordDescriptionDelegate : unit -> string - static member keywordDescriptionDo : unit -> string - static member keywordDescriptionDone : unit -> string - static member keywordDescriptionDowncast : unit -> string - static member keywordDescriptionDownto : unit -> string - static member keywordDescriptionDynamicCast : unit -> string - static member keywordDescriptionElif : unit -> string - static member keywordDescriptionElse : unit -> string - static member keywordDescriptionEnd : unit -> string - static member keywordDescriptionException : unit -> string - static member keywordDescriptionExtern : unit -> string - static member keywordDescriptionFinally : unit -> string - static member keywordDescriptionFor : unit -> string - static member keywordDescriptionFun : unit -> string - static member keywordDescriptionFunction : unit -> string - static member keywordDescriptionGlobal : unit -> string - static member keywordDescriptionIf : unit -> string - static member keywordDescriptionIn : unit -> string - static member keywordDescriptionInherit : unit -> string - static member keywordDescriptionInline : unit -> string - static member keywordDescriptionInterface : unit -> string - static member keywordDescriptionInternal : unit -> string - static member keywordDescriptionLazy : unit -> string - static member keywordDescriptionLeftArrow : unit -> string - static member keywordDescriptionLet : unit -> string - static member keywordDescriptionLetBang : unit -> string - static member keywordDescriptionMatch : unit -> string - static member keywordDescriptionMatchBang : unit -> string - static member keywordDescriptionMember : unit -> string - static member keywordDescriptionModule : unit -> string - static member keywordDescriptionMutable : unit -> string - static member keywordDescriptionNamespace : unit -> string - static member keywordDescriptionNew : unit -> string - static member keywordDescriptionNot : unit -> string - static member keywordDescriptionNull : unit -> string - static member keywordDescriptionOf : unit -> string - static member keywordDescriptionOpen : unit -> string - static member keywordDescriptionOr : unit -> string - static member keywordDescriptionOverride : unit -> string - static member keywordDescriptionPrivate : unit -> string - static member keywordDescriptionPublic : unit -> string - static member keywordDescriptionRec : unit -> string - static member keywordDescriptionReturn : unit -> string - static member keywordDescriptionReturnBang : unit -> string - static member keywordDescriptionRightArrow : unit -> string - static member keywordDescriptionSelect : unit -> string - static member keywordDescriptionStatic : unit -> string - static member keywordDescriptionStruct : unit -> string - static member keywordDescriptionThen : unit -> string - static member keywordDescriptionTo : unit -> string - static member keywordDescriptionTrueFalse : unit -> string - static member keywordDescriptionTry : unit -> string - static member keywordDescriptionType : unit -> string - static member keywordDescriptionTypedQuotation : unit -> string - static member keywordDescriptionUntypedQuotation : unit -> string - static member keywordDescriptionUpcast : unit -> string - static member keywordDescriptionUse : unit -> string - static member keywordDescriptionUseBang : unit -> string - static member keywordDescriptionVal : unit -> string - static member keywordDescriptionVoid : unit -> string - static member keywordDescriptionWhen : unit -> string - static member keywordDescriptionWhile : unit -> string - static member keywordDescriptionWith : unit -> string - static member keywordDescriptionYield : unit -> string - static member keywordDescriptionYieldBang : unit -> string - static member keyworkDescriptionAnd : unit -> string - static member lexByteArrayCannotEncode : unit -> int * string - static member lexByteStringMayNotBeInterpolated : unit -> int * string - static member - lexCharNotAllowedInOperatorNames : a0:System.String -> string - static member lexHashBangMustBeFirstInFile : unit -> string - static member lexHashElseMustBeFirst : unit -> int * string - static member lexHashElseNoMatchingIf : unit -> string - static member lexHashEndifMustBeFirst : unit -> int * string - static member lexHashEndifRequiredForElse : unit -> string - static member lexHashEndingNoMatchingIf : unit -> string - static member lexHashIfMustBeFirst : unit -> int * string - static member lexHashIfMustHaveIdent : unit -> int * string - static member lexIdentEndInMarkReserved : a0:System.String -> int * string - static member lexIndentOffForML : unit -> string - static member lexInvalidByteLiteral : unit -> int * string - static member lexInvalidCharLiteral : unit -> int * string - static member lexInvalidFloat : unit -> int * string - static member lexInvalidLineNumber : a0:System.String -> int * string - static member lexInvalidNumericLiteral : unit -> int * string - static member lexInvalidUnicodeLiteral : a0:System.String -> int * string - static member lexOusideDecimal : unit -> int * string - static member lexOusideThirtyTwoBitFloat : unit -> int * string - static member lexOutsideEightBitSigned : unit -> int * string - static member lexOutsideEightBitSignedHex : unit -> int * string - static member lexOutsideEightBitUnsigned : unit -> int * string - static member lexOutsideIntegerRange : unit -> int * string - static member lexOutsideNativeSigned : unit -> int * string - static member lexOutsideNativeUnsigned : unit -> int * string - static member lexOutsideSixteenBitSigned : unit -> int * string - static member lexOutsideSixteenBitUnsigned : unit -> int * string - static member lexOutsideSixtyFourBitSigned : unit -> int * string - static member lexOutsideSixtyFourBitUnsigned : unit -> int * string - static member lexOutsideThirtyTwoBitSigned : unit -> int * string - static member lexOutsideThirtyTwoBitUnsigned : unit -> int * string - static member lexRBraceInInterpolatedString : unit -> int * string - static member lexSingleQuoteInSingleQuote : unit -> int * string - static member lexTabsNotAllowed : unit -> int * string - static member lexThisUnicodeOnlyInStringLiterals : unit -> int * string - static member lexTokenReserved : unit -> int * string - static member lexTripleQuoteInTripleQuote : unit -> int * string - static member lexUnexpectedChar : a0:System.String -> string - static member lexWrongNestedHashEndif : unit -> int * string - static member lexfltIncorrentIndentationOfIn : unit -> string - static member - lexfltSeparatorTokensOfPatternMatchMisaligned : unit -> string - static member - lexfltTokenIsOffsideOfContextStartedEarlier : a0:System.String -> string - static member lexhlpIdentifierReserved : a0:System.String -> string - static member - lexhlpIdentifiersContainingAtSymbolReserved : unit -> int * string - static member - listElementHasWrongType : a0:System.String * a1:System.String -> string - static member loadingDescription : unit -> string - static member - memberOperatorDefinitionWithCurriedArguments : a0:System.String -> - int * string - static member - memberOperatorDefinitionWithNoArguments : a0:System.String -> - int * string - static member - memberOperatorDefinitionWithNonPairArgument : a0:System.String * - a1:System.Int32 -> - int * string - static member - memberOperatorDefinitionWithNonTripleArgument : a0:System.String * - a1:System.Int32 -> - int * string - static member methodIsNotStatic : a0:System.String -> int * string - static member missingElseBranch : a0:System.String -> string - static member mlCompatMessage : a0:System.String -> string - static member moreThanOneInvokeMethodFound : unit -> string - static member nativeResourceFormatError : unit -> string - static member nativeResourceHeaderMalformed : a0:System.String -> string - static member nicePrintOtherOverloads1 : unit -> string - static member nicePrintOtherOverloadsN : a0:System.Int32 -> string - static member noEqualSignAfterModule : unit -> int * string - static member noInvokeMethodsFound : unit -> int * string - static member notAFunction : unit -> string - static member notAFunctionButMaybeDeclaration : unit -> string - static member notAFunctionButMaybeIndexer : unit -> string - static member notAFunctionButMaybeIndexerErrorCode : unit -> int * string - static member - notAFunctionButMaybeIndexerWithName : a0:System.String -> string - static member nrGlobalUsedOnlyAsFirstName : unit -> int * string - static member nrInvalidExpression : a0:System.String -> int * string - static member nrInvalidFieldLabel : unit -> int * string - static member nrInvalidModuleExprType : unit -> int * string - static member nrIsNotConstructorOrLiteral : unit -> int * string - static member - nrNoConstructorsAvailableForType : a0:System.String -> int * string - static member - nrRecordDoesNotContainSuchLabel : a0:System.String * a1:System.String -> - int * string - static member - nrRecordTypeNeedsQualifiedAccess : a0:System.String * a1:System.String -> - int * string - static member - nrTypeInstantiationIsMissingAndCouldNotBeInferred : a0:System.String * - a1:System.String -> - int * string - static member - nrTypeInstantiationNeededToDisambiguateTypesWithSameName : a0:System.String * - a1:System.String -> - int * - string - static member nrUnexpectedEmptyLongId : unit -> int * string - static member - nrUnionTypeNeedsQualifiedAccess : a0:System.String * a1:System.String -> - int * string - static member optFailedToInlineValue : a0:System.String -> int * string - static member - optLocalValueNotFoundDuringOptimization : a0:System.String -> - int * string - static member optRecursiveValValue : a0:System.String -> int * string - static member - optValueMarkedInlineButIncomplete : a0:System.String -> int * string - static member - optValueMarkedInlineButWasNotBoundInTheOptEnv : a0:System.String -> - int * string - static member optValueMarkedInlineCouldNotBeInlined : unit -> int * string - static member - optValueMarkedInlineHasUnexpectedValue : unit -> int * string - static member optsBaseaddress : unit -> string - static member optsBuildConsole : unit -> string - static member optsBuildLibrary : unit -> string - static member optsBuildModule : unit -> string - static member optsBuildWindows : unit -> string - static member optsChecked : unit -> string - static member optsChecksumAlgorithm : unit -> string - static member optsClirootDeprecatedMsg : unit -> string - static member optsClirootDescription : unit -> string - static member optsCodepage : unit -> string - static member optsCompilerTool : unit -> string - static member optsConsoleColors : unit -> string - static member optsCopyright : unit -> string - static member optsCopyrightCommunity : unit -> string - static member optsCrossoptimize : unit -> string - static member - optsDCLODeprecatedSuggestAlternative : a0:System.String * - a1:System.String -> string - static member optsDCLOHtmlDoc : a0:System.String -> string - static member optsDCLONoDescription : a0:System.String -> string - static member optsDebug : a0:System.String -> string - static member optsDebugPM : unit -> string - static member optsDefine : unit -> string - static member optsDelaySign : unit -> string - static member optsDeterministic : unit -> string - static member optsEmbedAllSource : unit -> string - static member optsEmbedSource : unit -> string - static member optsEmbeddedSourceRequirePortablePDBs : unit -> int * string - static member optsEmitDebugInfoInQuotations : unit -> string - static member optsFullpaths : unit -> string - static member optsHelp : unit -> string - static member optsHelpBannerAdvanced : unit -> string - static member optsHelpBannerCodeGen : unit -> string - static member optsHelpBannerErrsAndWarns : unit -> string - static member optsHelpBannerInputFiles : unit -> string - static member optsHelpBannerLanguage : unit -> string - static member optsHelpBannerMisc : unit -> string - static member optsHelpBannerOutputFiles : unit -> string - static member optsHelpBannerResources : unit -> string - static member optsInternalNoDescription : a0:System.String -> string - static member optsInvalidPathMapFormat : unit -> int * string - static member - optsInvalidResponseFile : a0:System.String * a1:System.String -> - int * string - static member - optsInvalidSubSystemVersion : a0:System.String -> int * string - static member optsInvalidTargetProfile : a0:System.String -> int * string - static member optsInvalidWarningLevel : a0:System.Int32 -> int * string - static member optsLangVersion : unit -> string - static member optsLib : unit -> string - static member optsLinkresource : unit -> string - static member optsMlcompatibility : unit -> string - static member optsNameOfOutputFile : unit -> string - static member optsNoCopyFsharpCore : unit -> string - static member optsNoInterface : unit -> string - static member optsNoOpt : unit -> string - static member optsNoframework : unit -> string - static member optsNologo : unit -> string - static member optsNowarn : unit -> string - static member optsNowin32manifest : unit -> string - static member optsOptimize : unit -> string - static member optsPathMap : unit -> string - static member optsPdb : unit -> string - static member optsPlatform : unit -> string - static member optsPreferredUiLang : unit -> string - static member - optsProblemWithCodepage : a0:System.Int32 * a1:System.String -> - int * string - static member optsPublicSign : unit -> string - static member optsReference : unit -> string - static member optsResident : unit -> string - static member optsResource : unit -> string - static member optsResponseFile : unit -> string - static member - optsResponseFileNameInvalid : a0:System.String -> int * string - static member - optsResponseFileNotFound : a0:System.String * a1:System.String -> - int * string - static member optsShortFormOf : a0:System.String -> string - static member optsSig : unit -> string - static member optsSimpleresolution : unit -> string - static member optsSourceLink : unit -> string - static member optsSourceLinkRequirePortablePDBs : unit -> int * string - static member optsStandalone : unit -> string - static member optsStaticlink : unit -> string - static member optsStrongKeyContainer : unit -> string - static member optsStrongKeyFile : unit -> string - static member optsSubSystemVersion : unit -> string - static member optsSupportedLangVersions : unit -> string - static member optsTailcalls : unit -> string - static member optsTargetProfile : unit -> string - static member - optsUnknownArgumentToTheTestSwitch : a0:System.String -> int * string - static member - optsUnknownChecksumAlgorithm : a0:System.String -> int * string - static member optsUnknownPlatform : a0:System.String -> int * string - static member optsUnrecognizedDebugType : a0:System.String -> int * string - static member - optsUnrecognizedLanguageVersion : a0:System.String -> int * string - static member optsUnrecognizedTarget : a0:System.String -> int * string - static member optsUseHighEntropyVA : unit -> string - static member optsUtf8output : unit -> string - static member optsVersion : unit -> string - static member optsWarn : unit -> string - static member optsWarnOn : unit -> string - static member optsWarnaserror : unit -> string - static member optsWarnaserrorPM : unit -> string - static member optsWin32manifest : unit -> string - static member optsWin32res : unit -> string - static member optsWriteXml : unit -> string - static member packageManagementRequiresVFive : unit -> int * string - static member packageManagerError : a0:System.String -> int * string - static member - packageManagerUnknown : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member - parsAccessibilityModsIllegalForAbstract : unit -> int * string - static member parsActivePatternCaseContainsPipe : unit -> int * string - static member - parsActivePatternCaseMustBeginWithUpperCase : unit -> int * string - static member parsAllEnumFieldsRequireValues : unit -> int * string - static member parsArrowUseIsLimited : unit -> int * string - static member parsAssertIsNotFirstClassValue : unit -> int * string - static member parsAttributeOnIncompleteCode : unit -> int * string - static member - parsAttributesAreNotPermittedOnInterfaceImplementations : unit -> - int * string - static member parsAttributesIgnored : unit -> int * string - static member parsAttributesIllegalHere : unit -> int * string - static member parsAttributesIllegalOnInherit : unit -> int * string - static member parsAttributesMustComeBeforeVal : unit -> string - static member - parsAugmentationsIllegalOnDelegateType : unit -> int * string - static member parsConsiderUsingSeparateRecordType : unit -> string - static member - parsDoCannotHaveVisibilityDeclarations : a0:System.String -> - int * string - static member parsEmptyFillInInterpolatedString : unit -> int * string - static member parsEmptyTypeDefinition : unit -> int * string - static member - parsEnumFieldsCannotHaveVisibilityDeclarations : unit -> int * string - static member - parsEnumTypesCannotHaveVisibilityDeclarations : unit -> int * string - static member parsEofInComment : unit -> int * string - static member parsEofInDirective : unit -> int * string - static member parsEofInHashIf : unit -> int * string - static member parsEofInIfOcaml : unit -> int * string - static member parsEofInInterpolatedString : unit -> int * string - static member parsEofInInterpolatedStringFill : unit -> int * string - static member - parsEofInInterpolatedTripleQuoteString : unit -> int * string - static member parsEofInInterpolatedVerbatimString : unit -> int * string - static member parsEofInString : unit -> int * string - static member parsEofInStringInComment : unit -> int * string - static member parsEofInTripleQuoteString : unit -> int * string - static member parsEofInTripleQuoteStringInComment : unit -> int * string - static member parsEofInVerbatimString : unit -> int * string - static member parsEofInVerbatimStringInComment : unit -> int * string - static member - parsEqualsMissingInTypeDefinition : a0:System.String -> int * string - static member - parsErrorInReturnForLetIncorrectIndentation : unit -> int * string - static member parsErrorParsingAsOperatorName : unit -> int * string - static member - parsExpectedExpressionAfterLet : a0:System.String * a1:System.String -> - int * string - static member parsExpectedExpressionAfterToken : unit -> int * string - static member parsExpectedNameAfterToken : unit -> int * string - static member parsExpectedTypeAfterToken : unit -> int * string - static member parsFieldBinding : unit -> int * string - static member parsForDoExpected : unit -> int * string - static member parsGetAndOrSetRequired : unit -> int * string - static member parsGetOrSetRequired : unit -> int * string - static member parsGetterAtMostOneArgument : unit -> int * string - static member parsGetterMustHaveAtLeastOneArgument : unit -> int * string - static member parsIdentifierExpected : unit -> int * string - static member - parsIgnoreAttributesOnModuleAbbreviation : unit -> int * string - static member - parsIgnoreAttributesOnModuleAbbreviationAlwaysPrivate : a0:System.String -> - int * string - static member - parsIgnoreVisibilityOnModuleAbbreviationAlwaysPrivate : a0:System.String -> - int * string - static member - parsIllegalDenominatorForMeasureExponent : unit -> int * string - static member - parsIllegalMemberVarInObjectImplementation : unit -> int * string - static member parsInOrEqualExpected : unit -> int * string - static member parsIncompleteIf : unit -> int * string - static member - parsIndexerPropertyRequiresAtLeastOneArgument : unit -> int * string - static member - parsInheritDeclarationsCannotHaveAsBindings : unit -> int * string - static member - parsInlineAssemblyCannotHaveVisibilityDeclarations : unit -> - int * string - static member - parsIntegerForLoopRequiresSimpleIdentifier : unit -> int * string - static member - parsInterfacesHaveSameVisibilityAsEnclosingType : unit -> int * string - static member parsInvalidAnonRecdExpr : unit -> int * string - static member parsInvalidAnonRecdType : unit -> int * string - static member parsInvalidDeclarationSyntax : unit -> int * string - static member parsInvalidLiteralInType : unit -> int * string - static member parsInvalidPrefixOperator : unit -> int * string - static member parsInvalidPrefixOperatorDefinition : unit -> int * string - static member parsInvalidProperty : unit -> int * string - static member parsInvalidUseOfRec : unit -> int * string - static member parsLetAndForNonRecBindings : unit -> int * string - static member - parsMemberIllegalInObjectImplementation : unit -> int * string - static member - parsMismatchedQuotationName : a0:System.String -> int * string - static member parsMismatchedQuote : a0:System.String -> int * string - static member parsMissingFunctionBody : unit -> int * string - static member parsMissingGreaterThan : unit -> int * string - static member parsMissingQualificationAfterDot : unit -> int * string - static member parsMissingTypeArgs : unit -> int * string - static member - parsModuleAbbreviationMustBeSimpleName : unit -> int * string - static member parsModuleDefnMustBeSimpleName : unit -> int * string - static member parsMultiArgumentGenericTypeFormDeprecated : unit -> string - static member parsMultipleAccessibilitiesForGetSet : unit -> int * string - static member - parsMutableOnAutoPropertyShouldBeGetSet : unit -> int * string - static member - parsMutableOnAutoPropertyShouldBeGetSetNotJustSet : unit -> int * string - static member parsNamespaceOrModuleNotBoth : unit -> int * string - static member parsNoEqualShouldFollowNamespace : unit -> string - static member parsNoHashEndIfFound : unit -> int * string - static member parsNoMatchingInForLet : unit -> int * string - static member parsNonAdjacentTyargs : unit -> int * string - static member parsNonAdjacentTypars : unit -> int * string - static member parsNonAtomicType : unit -> string - static member parsOnlyClassCanTakeValueArguments : unit -> int * string - static member parsOnlyHashDirectivesAllowed : unit -> int * string - static member parsOnlyOneWithAugmentationAllowed : unit -> int * string - static member parsParenFormIsForML : unit -> string - static member - parsRecordFieldsCannotHaveVisibilityDeclarations : unit -> int * string - static member parsSetSyntax : unit -> int * string - static member parsSetterAtMostTwoArguments : unit -> int * string - static member - parsSuccessiveArgsShouldBeSpacedOrTupled : unit -> int * string - static member - parsSuccessivePatternsShouldBeSpacedOrTupled : unit -> int * string - static member parsSyntaxError : unit -> int * string - static member parsSyntaxErrorInLabeledType : unit -> int * string - static member parsSyntaxModuleSigEndDeprecated : unit -> string - static member parsSyntaxModuleStructEndDeprecated : unit -> string - static member - parsTypeAbbreviationsCannotHaveVisibilityDeclarations : unit -> - int * string - static member parsTypeAnnotationsOnGetSet : unit -> int * string - static member parsTypeNameCannotBeEmpty : unit -> int * string - static member parsUnClosedBlockInHashLight : unit -> int * string - static member parsUnderscoreInvalidFieldName : unit -> int * string - static member parsUnexpectedEmptyModuleDefn : unit -> int * string - static member parsUnexpectedEndOfFile : unit -> int * string - static member parsUnexpectedEndOfFileDefinition : unit -> int * string - static member parsUnexpectedEndOfFileElse : unit -> int * string - static member parsUnexpectedEndOfFileExpression : unit -> int * string - static member parsUnexpectedEndOfFileFor : unit -> int * string - static member parsUnexpectedEndOfFileFunBody : unit -> int * string - static member parsUnexpectedEndOfFileMatch : unit -> int * string - static member parsUnexpectedEndOfFileObjectMembers : unit -> int * string - static member parsUnexpectedEndOfFileThen : unit -> int * string - static member parsUnexpectedEndOfFileTry : unit -> int * string - static member parsUnexpectedEndOfFileTypeArgs : unit -> int * string - static member parsUnexpectedEndOfFileTypeDefinition : unit -> int * string - static member parsUnexpectedEndOfFileTypeSignature : unit -> int * string - static member parsUnexpectedEndOfFileWhile : unit -> int * string - static member parsUnexpectedEndOfFileWith : unit -> int * string - static member parsUnexpectedIdentifier : a0:System.String -> int * string - static member parsUnexpectedInfixOperator : unit -> int * string - static member - parsUnexpectedIntegerLiteralForUnitOfMeasure : unit -> int * string - static member - parsUnexpectedOperatorForUnitOfMeasure : unit -> int * string - static member - parsUnexpectedQuotationOperatorInTypeAliasDidYouMeanVerbatimString : unit -> - int * - string - static member parsUnexpectedSemicolon : unit -> int * string - static member parsUnexpectedSymbolDot : unit -> int * string - static member parsUnexpectedSymbolEqualsInsteadOfIn : unit -> int * string - static member parsUnexpectedTypeParameter : unit -> int * string - static member - parsUnexpectedVisibilityDeclaration : a0:System.String -> int * string - static member parsUnfinishedExpression : a0:System.String -> int * string - static member - parsUnionCasesCannotHaveVisibilityDeclarations : unit -> int * string - static member parsUnmatched : a0:System.String -> int * string - static member parsUnmatchedBegin : unit -> int * string - static member parsUnmatchedBeginOrStruct : unit -> int * string - static member parsUnmatchedBrace : unit -> int * string - static member parsUnmatchedBraceBar : unit -> int * string - static member parsUnmatchedBracket : unit -> int * string - static member parsUnmatchedBracketBar : unit -> int * string - static member parsUnmatchedClassInterfaceOrStruct : unit -> int * string - static member parsUnmatchedLBrackLess : unit -> int * string - static member parsUnmatchedLet : unit -> int * string - static member parsUnmatchedLetBang : unit -> int * string - static member parsUnmatchedParen : unit -> int * string - static member parsUnmatchedUse : unit -> int * string - static member parsUnmatchedUseBang : unit -> int * string - static member parsUnmatchedWith : unit -> int * string - static member - parsUseBindingsIllegalInImplicitClassConstructors : unit -> int * string - static member parsUseBindingsIllegalInModules : unit -> int * string - static member - parsVisibilityDeclarationsShouldComePriorToIdentifier : unit -> - int * string - static member parsVisibilityIllegalOnInherit : unit -> int * string - static member parsWhileDoExpected : unit -> int * string - static member patcMissingVariable : a0:System.String -> int * string - static member - patcPartialActivePatternsGenerateOneResult : unit -> int * string - static member pathIsInvalid : a0:System.String -> int * string - static member patternMatchGuardIsNotBool : a0:System.String -> string - static member - pickleErrorReadingWritingMetadata : a0:System.String * a1:System.String -> - string - static member - pickleMissingDefinition : a0:System.Int32 * a1:System.String * - a2:System.String -> int * string - static member pickleUnexpectedNonZero : a0:System.String -> int * string - static member - poundiNotSupportedByRegisteredDependencyManagers : unit -> int * string - static member pplexExpectedSingleLineComment : unit -> int * string - static member pplexUnexpectedChar : a0:System.String -> int * string - static member ppparsIncompleteExpression : unit -> int * string - static member ppparsMissingToken : a0:System.String -> int * string - static member ppparsUnexpectedToken : a0:System.String -> int * string - static member - readOnlyAttributeOnStructWithMutableField : unit -> int * string - static member recursiveClassHierarchy : a0:System.String -> int * string - static member replaceWithSuggestion : a0:System.String -> string - static member returnUsedInsteadOfReturnBang : unit -> string - static member srcFileTooLarge : unit -> string - static member - structOrClassFieldIsNotAccessible : a0:System.String -> int * string - static member tastActivePatternsLimitedToSeven : unit -> int * string - static member tastCantTakeAddressOfExpression : unit -> int * string - static member - tastConflictingModuleAndTypeDefinitionInAssembly : a0:System.String * - a1:System.String -> - int * string - static member tastConstantExpressionOverflow : unit -> int * string - static member - tastDuplicateTypeDefinitionInAssembly : a0:System.String * - a1:System.String -> int * string - static member - tastInvalidAddressOfMutableAcrossAssemblyBoundary : unit -> int * string - static member tastInvalidFormForPropertyGetter : unit -> int * string - static member tastInvalidFormForPropertySetter : unit -> int * string - static member tastInvalidMemberSignature : unit -> int * string - static member tastInvalidMutationOfConstant : unit -> int * string - static member - tastNamespaceAndModuleWithSameNameInAssembly : a0:System.String -> - int * string - static member tastNotAConstantExpression : unit -> int * string - static member - tastRecursiveValuesMayNotAppearInConstructionOfType : a0:System.String -> - int * string - static member - tastRecursiveValuesMayNotBeAssignedToNonMutableField : a0:System.String * - a1:System.String -> - int * string - static member - tastRecursiveValuesMayNotBeInConstructionOfTuple : unit -> int * string - static member - tastTwoModulesWithSameNameInAssembly : a0:System.String -> int * string - static member - tastTypeHasAssemblyCodeRepresentation : a0:System.String -> string - static member - tastTypeOrModuleNotConcrete : a0:System.String -> int * string - static member - tastUndefinedItemRefModuleNamespace : a0:System.String * - a1:System.String * - a2:System.String -> int * string - static member - tastUndefinedItemRefModuleNamespaceType : a0:System.String * - a1:System.String * - a2:System.String -> - int * string - static member - tastUndefinedItemRefVal : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member tastUnexpectedByRef : unit -> int * string - static member tastUnexpectedDecodeOfAutoOpenAttribute : unit -> string - static member - tastUnexpectedDecodeOfInterfaceDataVersionAttribute : unit -> string - static member - tastUnexpectedDecodeOfInternalsVisibleToAttribute : unit -> string - static member tastValueDoesNotHaveSetterType : unit -> int * string - static member tastValueHasBeenCopied : unit -> string - static member tastValueMustBeLocal : unit -> int * string - static member tastValueMustBeMutable : unit -> int * string - static member tastopsMaxArrayThirtyTwo : a0:System.Int32 -> int * string - static member tcAbbreviatedTypesCannotBeSealed : unit -> int * string - static member - tcAbbreviationsFordotNetExceptionsCannotTakeArguments : unit -> - int * string - static member - tcAbbreviationsFordotNetExceptionsMustHaveMatchingObjectConstructor : unit -> - int * - string - static member - tcAbstractMembersIllegalInAugmentation : unit -> int * string - static member - tcAbstractPropertyMissingGetOrSet : a0:System.String -> int * string - static member tcAbstractTypeCannotBeInstantiated : unit -> int * string - static member tcActivePatternsDoNotHaveFields : unit -> int * string - static member - tcAllImplementedInterfacesShouldBeDeclared : unit -> int * string - static member - tcAllowNullTypesMayOnlyInheritFromAllowNullTypes : unit -> int * string - static member tcAndBangNotSupported : unit -> int * string - static member - tcAnonRecdCcuMismatch : a0:System.String * a1:System.String -> string - static member tcAnonRecdFieldNameDifferent : a0:System.String -> string - static member - tcAnonRecdFieldNameMismatch : a0:System.String * a1:System.String -> - string - static member tcAnonRecdFieldNameSubset : a0:System.String -> string - static member tcAnonRecdFieldNameSuperset : a0:System.String -> string - static member tcAnonRecdInvalid : unit -> string - static member tcAnonymousTypeInvalidInDeclaration : unit -> int * string - static member - tcAnonymousUnitsOfMeasureCannotBeNested : unit -> int * string - static member - tcArgumentArityMismatch : a0:System.String * a1:System.Int32 * - a2:System.Int32 * a3:System.String * - a4:System.String -> int * string - static member - tcArgumentArityMismatchOneOverload : a0:System.String * a1:System.Int32 * - a2:System.Int32 * a3:System.String * - a4:System.String -> int * string - static member tcAtLeastOneOverrideIsInvalid : unit -> int * string - static member tcAttribArgsDiffer : a0:System.String -> int * string - static member - tcAttributeAutoOpenWasIgnored : a0:System.String * a1:System.String -> - int * string - static member - tcAttributeExpressionsMustBeConstructorCalls : unit -> int * string - static member - tcAttributeIsNotValidForLanguageElement : unit -> int * string - static member - tcAttributeIsNotValidForLanguageElementUseDo : unit -> int * string - static member - tcAttributesAreNotPermittedOnLetBindings : unit -> int * string - static member tcAttributesInvalidInPatterns : unit -> int * string - static member - tcAttributesOfTypeSpecifyMultipleKindsForType : unit -> int * string - static member tcAugmentationsCannotHaveAttributes : unit -> int * string - static member - tcAutoPropertyRequiresImplicitConstructionSequence : unit -> - int * string - static member - tcBinaryOperatorRequiresBody : a0:System.String * a1:System.String -> - int * string - static member - tcBinaryOperatorRequiresVariable : a0:System.String * a1:System.String -> - int * string - static member tcBindMayNotBeUsedInQueries : unit -> int * string - static member tcBindingCannotBeUseAndRec : unit -> int * string - static member tcByRefLikeNotStruct : unit -> int * string - static member tcByrefReturnImplicitlyDereferenced : unit -> int * string - static member tcByrefsMayNotHaveTypeExtensions : unit -> int * string - static member tcCallerInfoNotOptional : a0:System.String -> int * string - static member - tcCallerInfoWrongType : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member - tcCannotCallAbstractBaseMember : a0:System.String -> int * string - static member - tcCannotCallExtensionMethodInrefToByref : a0:System.String -> - int * string - static member tcCannotCreateExtensionOfSealedType : unit -> int * string - static member tcCannotInheritFromErasedType : unit -> int * string - static member tcCannotInheritFromInterfaceType : unit -> int * string - static member tcCannotInheritFromSealedType : unit -> int * string - static member tcCannotInheritFromVariableType : unit -> int * string - static member - tcCannotOverrideSealedMethod : a0:System.String -> int * string - static member - tcCannotPartiallyApplyExtensionMethodForByref : a0:System.String -> - int * string - static member tcCompiledNameAttributeMisused : unit -> int * string - static member tcConcreteMembersIllegalInInterface : unit -> int * string - static member tcConditionalAttributeRequiresMembers : unit -> int * string - static member tcConditionalAttributeUsage : unit -> int * string - static member - tcConstrainedTypeVariableCannotBeGeneralized : unit -> int * string - static member - tcConstructIsAmbiguousInComputationExpression : unit -> int * string - static member - tcConstructIsAmbiguousInSequenceExpression : unit -> int * string - static member - tcConstructRequiresComputationExpression : unit -> int * string - static member - tcConstructRequiresComputationExpressions : unit -> int * string - static member - tcConstructRequiresListArrayOrSequence : unit -> int * string - static member - tcConstructRequiresSequenceOrComputations : unit -> int * string - static member tcConstructorCannotHaveTypeParameters : unit -> int * string - static member - tcConstructorDoesNotHaveFieldWithGivenName : a0:System.String -> - int * string - static member - tcConstructorForInterfacesDoNotTakeArguments : unit -> int * string - static member tcConstructorRequiresArguments : unit -> int * string - static member tcConstructorRequiresCall : a0:System.String -> int * string - static member - tcConstructorsCannotBeFirstClassValues : unit -> int * string - static member - tcConstructorsDisallowedInExceptionAugmentation : unit -> int * string - static member tcConstructorsIllegalForThisType : unit -> int * string - static member tcConstructorsIllegalInAugmentation : unit -> int * string - static member tcCopyAndUpdateNeedsRecordType : unit -> int * string - static member tcCouldNotFindIDisposable : unit -> string - static member tcCouldNotFindOffsetToStringData : unit -> int * string - static member tcCustomAttributeArgumentMismatch : unit -> int * string - static member tcCustomAttributeMustBeReferenceType : unit -> int * string - static member - tcCustomAttributeMustInvokeConstructor : unit -> int * string - static member - tcCustomOperationHasIncorrectArgCount : a0:System.String * - a1:System.Int32 * - a2:System.Int32 -> int * string - static member tcCustomOperationInvalid : a0:System.String -> int * string - static member - tcCustomOperationMayNotBeOverloaded : a0:System.String -> int * string - static member tcCustomOperationMayNotBeUsedHere : unit -> int * string - static member - tcCustomOperationMayNotBeUsedInConjunctionWithNonSimpleLetBindings : unit -> - int * - string - static member - tcCustomOperationNotUsedCorrectly : a0:System.String -> int * string - static member - tcCustomOperationNotUsedCorrectly2 : a0:System.String * a1:System.String -> - int * string - static member - tcDeclarationElementNotPermittedInAugmentation : unit -> int * string - static member - tcDeclaredTypeParametersForExtensionDoNotMatchOriginal : a0:System.String -> - int * string - static member tcDefaultAmbiguous : unit -> int * string - static member tcDefaultImplementationAlreadyExists : unit -> int * string - static member - tcDefaultImplementationForInterfaceHasAlreadyBeenAdded : unit -> - int * string - static member tcDefaultStructConstructorCall : unit -> int * string - static member tcDefaultValueAttributeRequiresVal : unit -> int * string - static member tcDelegateConstructorMustBePassed : unit -> int * string - static member tcDelegatesCannotBeCurried : unit -> int * string - static member tcDllImportNotAllowed : unit -> int * string - static member tcDllImportStubsCannotBeInlined : unit -> int * string - static member tcDoBangIllegalInSequenceExpression : unit -> int * string - static member - tcDoesNotAllowExplicitTypeArguments : a0:System.String -> int * string - static member tcDuplicateSpecOfInterface : unit -> int * string - static member tcEmptyCopyAndUpdateRecordInvalid : unit -> int * string - static member tcEmptyRecordInvalid : unit -> int * string - static member - tcEntryPointAttributeRequiresFunctionInModule : unit -> int * string - static member - tcEnumTypeCannotBeEnumerated : a0:System.String -> int * string - static member - tcEnumerationsCannotHaveInterfaceDeclaration : unit -> int * string - static member tcEnumerationsMayNotHaveMembers : unit -> int * string - static member tcEventIsNotStatic : a0:System.String -> int * string - static member tcEventIsStatic : a0:System.String -> int * string - static member - tcExceptionAbbreviationsMustReferToValidExceptions : unit -> - int * string - static member - tcExceptionAbbreviationsShouldNotHaveArgumentList : unit -> int * string - static member - tcExceptionConstructorDoesNotHaveFieldWithGivenName : a0:System.String * - a1:System.String -> - int * string - static member tcExpectModuleOrNamespaceParent : a0:System.String -> string - static member tcExpectedInterfaceType : unit -> int * string - static member tcExpectedTypeNotUnitOfMeasure : unit -> int * string - static member tcExpectedTypeParameter : unit -> int * string - static member - tcExpectedUnitOfMeasureMarkWithAttribute : unit -> int * string - static member tcExpectedUnitOfMeasureNotType : unit -> int * string - static member tcExplicitObjectConstructorSyntax : unit -> int * string - static member tcExplicitStaticInitializerSyntax : unit -> int * string - static member tcExplicitTypeParameterInvalid : unit -> int * string - static member - tcExplicitTypeSpecificationCannotBeUsedForExceptionConstructors : unit -> - int * - string - static member tcExprUndelayed : unit -> int * string - static member - tcExpressionCountMisMatch : a0:System.Int32 * a1:System.Int32 -> - int * string - static member - tcExpressionFormRequiresObjectConstructor : unit -> int * string - static member tcExpressionFormRequiresRecordTypes : unit -> int * string - static member tcExpressionRequiresSequence : unit -> int * string - static member tcExpressionWithIfRequiresParenthesis : unit -> string - static member tcExtraneousFieldsGivenValues : unit -> int * string - static member tcFSharpCoreRequiresExplicit : unit -> int * string - static member - tcFieldAppearsTwiceInRecord : a0:System.String -> int * string - static member tcFieldIsNotMutable : unit -> int * string - static member tcFieldIsNotStatic : a0:System.String -> int * string - static member tcFieldIsReadonly : unit -> int * string - static member - tcFieldNameConflictsWithGeneratedNameForAnonymousField : a0:System.String -> - int * string - static member - tcFieldNameIsUsedModeThanOnce : a0:System.String -> int * string - static member - tcFieldNotLiteralCannotBeUsedInPattern : unit -> int * string - static member - tcFieldRequiresAssignment : a0:System.String * a1:System.String -> - int * string - static member tcFieldRequiresName : unit -> int * string - static member tcFieldValIllegalHere : unit -> int * string - static member - tcFieldsDoNotDetermineUniqueRecordType : unit -> int * string - static member tcFixedNotAllowed : unit -> int * string - static member tcFormalArgumentIsNotOptional : unit -> int * string - static member - tcFunctionRequiresExplicitLambda : a0:System.Int32 -> int * string - static member - tcFunctionRequiresExplicitTypeArguments : a0:System.String -> - int * string - static member - tcGeneratedTypesShouldBeInternalOrPrivate : unit -> int * string - static member - tcGenericParameterHasBeenConstrained : a0:System.String -> int * string - static member tcGenericTypesCannotHaveStructLayout : unit -> int * string - static member tcGlobalsSystemTypeNotFound : a0:System.String -> string - static member tcIDisposableTypeShouldUseNew : unit -> int * string - static member tcIfThenElseMayNotBeUsedWithinQueries : unit -> int * string - static member tcIllegalAttributesForLiteral : unit -> int * string - static member tcIllegalByrefsInOpenTypeDeclaration : unit -> int * string - static member - tcIllegalFormForExplicitTypeDeclaration : unit -> int * string - static member tcIllegalPattern : unit -> int * string - static member - tcIllegalStructTypeForConstantExpression : unit -> int * string - static member tcIllegalSyntaxInTypeExpression : unit -> int * string - static member - tcImplementsGenericIComparableExplicitly : a0:System.String -> - int * string - static member - tcImplementsIComparableExplicitly : a0:System.String -> int * string - static member - tcImplementsIEquatableExplicitly : a0:System.String -> int * string - static member - tcImplementsIStructuralComparableExplicitly : a0:System.String -> - int * string - static member - tcImplementsIStructuralEquatableExplicitly : a0:System.String -> - int * string - static member tcImplicitMeasureFollowingSlash : unit -> int * string - static member - tcInferredGenericTypeGivesRiseToInconsistency : a0:System.String * - a1:System.String -> - int * string - static member tcInheritCannotBeUsedOnInterfaceType : unit -> int * string - static member - tcInheritConstructionCallNotPartOfImplicitSequence : unit -> - int * string - static member tcInheritDeclarationMissingArguments : unit -> int * string - static member tcInheritIllegalHere : unit -> int * string - static member tcInheritedTypeIsNotObjectModelType : unit -> int * string - static member tcInstanceMemberRequiresTarget : unit -> int * string - static member - tcInterfaceTypesAndDelegatesCannotContainFields : unit -> int * string - static member tcInterfaceTypesCannotBeSealed : unit -> int * string - static member - tcInterfacesShouldUseInheritNotInterface : unit -> int * string - static member tcInterpolationMixedWithPercent : unit -> int * string - static member tcIntoNeedsRestOfQuery : unit -> int * string - static member tcInvalidActivePatternName : unit -> int * string - static member - tcInvalidAlignmentInInterpolatedString : unit -> int * string - static member tcInvalidArgForParameterizedPattern : unit -> int * string - static member tcInvalidAssignment : unit -> int * string - static member tcInvalidConstantExpression : unit -> int * string - static member tcInvalidConstraint : unit -> int * string - static member tcInvalidConstraintTypeSealed : unit -> int * string - static member tcInvalidDeclaration : unit -> int * string - static member tcInvalidDelegateSpecification : unit -> int * string - static member tcInvalidEnumConstraint : unit -> int * string - static member tcInvalidEnumerationLiteral : unit -> int * string - static member tcInvalidIndexIntoActivePatternArray : unit -> int * string - static member - tcInvalidIndexOperatorDefinition : a0:System.String -> string - static member tcInvalidIndexerExpression : unit -> int * string - static member tcInvalidInlineSpecification : unit -> int * string - static member - tcInvalidMemberName : a0:System.String * a1:System.String -> string - static member tcInvalidMemberNameCtor : unit -> int * string - static member tcInvalidMemberNameFixedTypes : a0:System.String -> string - static member - tcInvalidMethodNameForEquality : a0:System.String * a1:System.String -> - string - static member - tcInvalidMethodNameForRelationalOperator : a0:System.String * - a1:System.String -> string - static member tcInvalidMixtureOfRecursiveForms : unit -> int * string - static member tcInvalidModuleName : unit -> int * string - static member tcInvalidNamespaceModuleTypeUnionName : unit -> int * string - static member tcInvalidNewConstraint : unit -> int * string - static member - tcInvalidNonPrimitiveLiteralInPatternMatch : unit -> int * string - static member tcInvalidObjectConstructionExpression : unit -> int * string - static member tcInvalidObjectExpressionSyntaxForm : unit -> int * string - static member - tcInvalidObjectSequenceOrRecordExpression : unit -> int * string - static member tcInvalidOperatorDefinition : a0:System.String -> string - static member - tcInvalidOperatorDefinitionEquality : a0:System.String -> string - static member - tcInvalidOperatorDefinitionRelational : a0:System.String -> string - static member - tcInvalidOptionalAssignmentToPropertyOrField : unit -> int * string - static member tcInvalidPattern : unit -> int * string - static member tcInvalidPropertyType : unit -> int * string - static member tcInvalidRecordConstruction : unit -> int * string - static member tcInvalidRelationInJoin : a0:System.String -> int * string - static member tcInvalidSequenceExpressionSyntaxForm : unit -> int * string - static member tcInvalidSignatureForSet : unit -> int * string - static member - tcInvalidTypeArgumentCount : a0:System.Int32 * a1:System.Int32 -> - int * string - static member tcInvalidTypeArgumentUsage : unit -> int * string - static member tcInvalidTypeExtension : unit -> int * string - static member tcInvalidTypeForLiteralEnumeration : unit -> int * string - static member tcInvalidTypeForUnitsOfMeasure : unit -> int * string - static member tcInvalidUnitsOfMeasurePrefix : unit -> int * string - static member tcInvalidUseBangBinding : unit -> int * string - static member tcInvalidUseBangBindingNoAndBangs : unit -> int * string - static member tcInvalidUseBinding : unit -> int * string - static member tcInvalidUseNullAsTrueValue : unit -> int * string - static member tcInvalidUseOfDelegate : unit -> int * string - static member tcInvalidUseOfInterfaceType : unit -> int * string - static member tcInvalidUseOfTypeName : unit -> int * string - static member tcIsReadOnlyNotStruct : unit -> int * string - static member - tcJoinMustUseSimplePattern : a0:System.String -> int * string - static member - tcKindOfTypeSpecifiedDoesNotMatchDefinition : unit -> int * string - static member - tcLessGenericBecauseOfAnnotation : a0:System.String * a1:System.String -> - int * string - static member - tcLetAndDoRequiresImplicitConstructionSequence : unit -> int * string - static member tcListLiteralMaxSize : unit -> int * string - static member - tcLiteralAttributeRequiresConstantValue : unit -> int * string - static member tcLiteralCannotBeInline : unit -> int * string - static member tcLiteralCannotBeMutable : unit -> int * string - static member tcLiteralCannotHaveGenericParameters : unit -> int * string - static member tcLiteralDoesNotTakeArguments : unit -> int * string - static member tcLiteralFieldAssignmentNoArg : unit -> int * string - static member - tcLiteralFieldAssignmentWithArg : a0:System.String -> int * string - static member tcLocalClassBindingsCannotBeInline : unit -> int * string - static member tcLookupMayNotBeUsedHere : unit -> int * string - static member tcMatchMayNotBeUsedWithQuery : unit -> int * string - static member - tcMeasureDeclarationsRequireStaticMembers : unit -> int * string - static member - tcMeasureDeclarationsRequireStaticMembersNotConstructors : unit -> - int * - string - static member - tcMeasureDefinitionsCannotHaveTypeParameters : unit -> int * string - static member - tcMemberAndLocalClassBindingHaveSameName : a0:System.String -> - int * string - static member - tcMemberFoundIsNotAbstractOrVirtual : a0:System.String * - a1:System.String -> int * string - static member tcMemberIsNotSufficientlyGeneric : unit -> int * string - static member tcMemberKindPropertyGetSetNotExpected : unit -> string - static member - tcMemberNotPermittedInInterfaceImplementation : unit -> int * string - static member tcMemberOperatorDefinitionInExtrinsic : unit -> int * string - static member tcMemberOverridesIllegalInInterface : unit -> int * string - static member - tcMemberUsedInInvalidWay : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member - tcMembersThatExtendInterfaceMustBePlacedInSeparateModule : unit -> - int * - string - static member tcMethodNotAccessible : a0:System.String -> int * string - static member tcMethodOverridesIllegalHere : unit -> int * string - static member tcMissingCustomOperation : a0:System.String -> int * string - static member tcModuleAbbrevFirstInMutRec : unit -> int * string - static member - tcModuleAbbreviationForNamespace : a0:System.String -> int * string - static member - tcModuleRequiresQualifiedAccess : a0:System.String -> int * string - static member tcMultipleVisibilityAttributes : unit -> int * string - static member tcMultipleVisibilityAttributesWithLet : unit -> int * string - static member tcMutableValuesCannotBeInline : unit -> int * string - static member - tcMutableValuesMayNotHaveGenericParameters : unit -> int * string - static member tcMutableValuesSyntax : unit -> int * string - static member tcNameArgumentsMustAppearLast : unit -> int * string - static member tcNameNotBoundInPattern : a0:System.String -> int * string - static member tcNamedActivePattern : a0:System.String -> int * string - static member - tcNamedArgumentDidNotMatch : a0:System.String -> int * string - static member - tcNamedArgumentsCannotBeUsedInMemberTraits : unit -> int * string - static member tcNamedTypeRequired : a0:System.String -> int * string - static member - tcNamespaceCannotContainExtensionMembers : unit -> int * string - static member tcNamespaceCannotContainValues : unit -> int * string - static member tcNewCannotBeUsedOnInterfaceType : unit -> int * string - static member - tcNewMemberHidesAbstractMember : a0:System.String -> int * string - static member - tcNewMemberHidesAbstractMemberWithSuffix : a0:System.String -> - int * string - static member tcNewMustBeUsedWithNamedType : unit -> int * string - static member tcNewRequiresObjectConstructor : unit -> int * string - static member - tcNoAbstractOrVirtualMemberFound : a0:System.String -> int * string - static member tcNoArgumentsForRecordValue : unit -> int * string - static member - tcNoComparisonNeeded1 : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member - tcNoComparisonNeeded2 : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member - tcNoEqualityNeeded1 : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member - tcNoEqualityNeeded2 : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member tcNoIntegerForLoopInQuery : unit -> int * string - static member - tcNoInterfaceImplementationForConstructionExpression : unit -> - int * string - static member tcNoMemberFoundForOverride : unit -> int * string - static member tcNoPropertyFoundForOverride : unit -> int * string - static member tcNoTryFinallyInQuery : unit -> int * string - static member tcNoWhileInQuery : unit -> int * string - static member tcNonLiteralCannotBeUsedInPattern : unit -> int * string - static member tcNonSimpleLetBindingInQuery : unit -> int * string - static member tcNonUniformMemberUse : a0:System.String -> int * string - static member - tcNonZeroConstantCannotHaveGenericUnit : unit -> int * string - static member tcNotAnException : unit -> int * string - static member - tcNotSufficientlyGenericBecauseOfScope : a0:System.String -> - int * string - static member tcNotValidEnumCaseName : unit -> int * string - static member - tcNumericLiteralRequiresModule : a0:System.String -> int * string - static member - tcObjectConstructionCanOnlyBeUsedInClassTypes : unit -> int * string - static member - tcObjectConstructionExpressionCanOnlyImplementConstructorsInObjectModelTypes : unit -> - int * - string - static member tcObjectConstructorRequiresArgument : unit -> int * string - static member - tcObjectConstructorsIllegalInInterface : unit -> int * string - static member - tcObjectConstructorsOnTypeParametersCannotTakeArguments : unit -> - int * string - static member tcObjectExpressionFormDeprecated : unit -> string - static member - tcObjectExpressionsCanOnlyOverrideAbstractOrVirtual : unit -> - int * string - static member - tcObjectOfIndeterminateTypeUsedRequireTypeConstraint : unit -> - int * string - static member - tcObjectsMustBeInitializedWithObjectExpression : unit -> int * string - static member tcOnlyClassesCanHaveAbstract : unit -> int * string - static member tcOnlyFunctionsCanBeInline : unit -> int * string - static member - tcOnlyRecordFieldsAndSimpleLetCanBeMutable : unit -> int * string - static member - tcOnlySimpleBindingsCanBeUsedInConstructionExpressions : unit -> - int * string - static member tcOnlySimplePatternsInLetRec : unit -> int * string - static member tcOnlyStructsCanHaveStructLayout : unit -> int * string - static member - tcOnlyTypesRepresentingUnitsOfMeasureCanHaveMeasure : unit -> - int * string - static member tcOpenFirstInMutRec : unit -> int * string - static member - tcOpenUsedWithPartiallyQualifiedPath : a0:System.String -> int * string - static member - tcOperatorDoesntAcceptInto : a0:System.String -> int * string - static member - tcOperatorIncorrectSyntax : a0:System.String * a1:System.String -> - int * string - static member - tcOperatorRequiresIn : a0:System.String * a1:System.String -> - int * string - static member - tcOptionalArgsMustComeAfterNonOptionalArgs : unit -> int * string - static member tcOptionalArgsOnlyOnMembers : unit -> int * string - static member - tcOptionalArgumentsCannotBeUsedInCustomAttribute : unit -> int * string - static member tcOverloadsCannotHaveCurriedArguments : unit -> int * string - static member tcOverrideArityMismatch : a0:System.String -> int * string - static member - tcOverridesCannotHaveVisibilityDeclarations : unit -> int * string - static member - tcOverridingMethodRequiresAllOrNoTypeParameters : unit -> int * string - static member tcParameterInferredByref : a0:System.String -> int * string - static member tcParameterRequiresName : unit -> int * string - static member - tcPredefinedTypeCannotBeUsedAsSuperType : unit -> int * string - static member tcPropertyCannotBeSet0 : unit -> int * string - static member tcPropertyCannotBeSet1 : a0:System.String -> int * string - static member tcPropertyIsNotReadable : a0:System.String -> int * string - static member tcPropertyIsNotStatic : a0:System.String -> int * string - static member tcPropertyIsStatic : a0:System.String -> int * string - static member tcPropertyOrFieldNotFoundInAttribute : unit -> int * string - static member - tcPropertyRequiresExplicitTypeParameters : unit -> int * string - static member tcRecImplied : unit -> int * string - static member tcRecordFieldInconsistentTypes : unit -> int * string - static member - tcRecordsUnionsAbbreviationsStructsMayNotHaveAllowNullLiteralAttribute : unit -> - int * - string - static member - tcRecursiveBindingsWithMembersMustBeDirectAugmentation : unit -> - int * string - static member - tcRepresentationOfTypeHiddenBySignature : unit -> int * string - static member tcRequireActivePatternWithOneResult : unit -> int * string - static member tcRequireBuilderMethod : a0:System.String -> int * string - static member - tcRequireMergeSourcesOrBindN : a0:System.String -> int * string - static member tcRequireVarConstRecogOrLiteral : unit -> int * string - static member tcReservedSyntaxForAugmentation : unit -> string - static member tcReturnMayNotBeUsedInQueries : unit -> int * string - static member tcReturnTypesForUnionMustBeSameAsType : unit -> int * string - static member tcReturnValuesCannotHaveNames : unit -> int * string - static member - tcRuntimeSuppliedMethodCannotBeUsedInUserCode : a0:System.String -> - int * string - static member tcSeqResultsUseYield : unit -> int * string - static member tcSimpleMethodNameRequired : unit -> int * string - static member - tcStaticFieldUsedWhenInstanceFieldExpected : unit -> int * string - static member tcStaticInitializerRequiresArgument : unit -> int * string - static member - tcStaticInitializersIllegalInInterface : unit -> int * string - static member - tcStaticLetBindingsRequireClassesWithImplicitConstructors : unit -> - int * - string - static member tcStaticMemberShouldNotHaveThis : unit -> int * string - static member - tcStaticOptimizationConditionalsOnlyForFSharpLibrary : unit -> - int * string - static member - tcStaticValFieldsMustBeMutableAndPrivate : unit -> int * string - static member - tcStructTypesCannotContainAbstractMembers : unit -> int * string - static member tcStructUnionMultiCaseDistinctFields : unit -> int * string - static member - tcStructsCanOnlyBindThisAtMemberDeclaration : unit -> int * string - static member - tcStructsCannotHaveConstructorWithNoArguments : unit -> int * string - static member - tcStructsInterfacesEnumsDelegatesMayNotInheritFromOtherTypes : unit -> - int * - string - static member tcStructsMayNotContainDoBindings : unit -> string - static member tcStructsMayNotContainLetBindings : unit -> int * string - static member - tcStructsMustDeclareTypesOfImplicitCtorArgsExplicitly : unit -> - int * string - static member - tcStructuralComparisonNotSatisfied1 : a0:System.String * - a1:System.String -> int * string - static member - tcStructuralComparisonNotSatisfied2 : a0:System.String * - a1:System.String -> int * string - static member - tcStructuralEqualityNotSatisfied1 : a0:System.String * a1:System.String -> - int * string - static member - tcStructuralEqualityNotSatisfied2 : a0:System.String * a1:System.String -> - int * string - static member - tcSyntaxCanOnlyBeUsedToCreateObjectTypes : a0:System.String -> - int * string - static member tcSyntaxErrorUnexpectedQMark : unit -> int * string - static member - tcSyntaxFormUsedOnlyWithRecordLabelsPropertiesAndFields : unit -> - int * string - static member tcTPFieldMustBeLiteral : unit -> int * string - static member - tcThisTypeMayNotHaveACLIMutableAttribute : unit -> int * string - static member tcThisValueMayNotBeInlined : unit -> int * string - static member - tcThreadStaticAndContextStaticMustBeStatic : unit -> int * string - static member tcTryIllegalInSequenceExpression : unit -> int * string - static member tcTryWithMayNotBeUsedInQueries : unit -> int * string - static member tcTupleMemberNotNormallyUsed : unit -> int * string - static member tcTupleStructMismatch : unit -> string - static member - tcTypeAbbreviationHasTypeParametersMissingOnType : unit -> string - static member - tcTypeAbbreviationsCannotHaveAugmentations : unit -> int * string - static member - tcTypeAbbreviationsCannotHaveInterfaceDeclaration : unit -> int * string - static member tcTypeAbbreviationsCheckedAtCompileTime : unit -> string - static member tcTypeAbbreviationsMayNotHaveMembers : unit -> int * string - static member tcTypeCannotBeEnumerated : a0:System.String -> int * string - static member - tcTypeCastErased : a0:System.String * a1:System.String -> int * string - static member tcTypeDefinitionIsCyclic : unit -> int * string - static member - tcTypeDefinitionIsCyclicThroughInheritance : unit -> int * string - static member - tcTypeDefinitionsWithImplicitConstructionMustHaveLocalBindingsBeforeMembers : unit -> - int * - string - static member - tcTypeDefinitionsWithImplicitConstructionMustHaveOneInherit : unit -> - int * - string - static member tcTypeDoesNotInheritAttribute : unit -> int * string - static member tcTypeExceptionOrModule : unit -> string - static member tcTypeHasNoAccessibleConstructor : unit -> int * string - static member tcTypeHasNoNestedTypes : unit -> int * string - static member tcTypeIsInaccessible : unit -> int * string - static member tcTypeIsNotARecordType : unit -> int * string - static member tcTypeIsNotARecordTypeNeedConstructor : unit -> int * string - static member tcTypeIsNotInterfaceType0 : unit -> int * string - static member tcTypeIsNotInterfaceType1 : a0:System.String -> int * string - static member tcTypeOrModule : unit -> string - static member - tcTypeParameterArityMismatch : a0:System.Int32 * a1:System.Int32 -> - int * string - static member - tcTypeParameterHasBeenConstrained : a0:System.String -> int * string - static member - tcTypeParameterInvalidAsTypeConstructor : unit -> int * string - static member tcTypeParametersInferredAreNotStable : unit -> int * string - static member tcTypeRequiresDefinition : unit -> int * string - static member - tcTypeTestErased : a0:System.String * a1:System.String -> int * string - static member tcTypeTestLosesMeasures : a0:System.String -> int * string - static member - tcTypeTestLossy : a0:System.String * a1:System.String -> int * string - static member - tcTypeUsedInInvalidWay : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member tcTypesAreAlwaysSealedAssemblyCode : unit -> int * string - static member tcTypesAreAlwaysSealedDU : unit -> int * string - static member tcTypesAreAlwaysSealedDelegate : unit -> int * string - static member tcTypesAreAlwaysSealedEnum : unit -> int * string - static member tcTypesAreAlwaysSealedRecord : unit -> int * string - static member tcTypesAreAlwaysSealedStruct : unit -> int * string - static member tcTypesCannotContainNestedTypes : unit -> int * string - static member - tcTypesCannotInheritFromMultipleConcreteTypes : unit -> int * string - static member - tcUnableToParseFormatString : a0:System.String -> int * string - static member - tcUnableToParseInterpolatedString : a0:System.String -> int * string - static member - tcUndefinedField : a0:System.String * a1:System.String -> int * string - static member tcUnexpectedBigRationalConstant : unit -> string - static member - tcUnexpectedConditionInImportedAssembly : unit -> int * string - static member tcUnexpectedConstByteArray : unit -> string - static member tcUnexpectedConstUint16Array : unit -> string - static member tcUnexpectedExprAtRecInfPoint : unit -> int * string - static member tcUnexpectedMeasureAnon : unit -> int * string - static member tcUnexpectedPropertyInSyntaxTree : unit -> int * string - static member tcUnexpectedPropertySpec : unit -> int * string - static member tcUnexpectedSlashInType : unit -> int * string - static member - tcUnexpectedSymbolInTypeExpression : a0:System.String -> int * string - static member tcUnexpectedTypeArguments : unit -> int * string - static member tcUninitializedValFieldsMustBeMutable : unit -> int * string - static member - tcUnionCaseConstructorDoesNotHaveFieldWithGivenName : a0:System.String * - a1:System.String -> - int * string - static member tcUnionCaseDoesNotTakeArguments : unit -> int * string - static member - tcUnionCaseExpectsTupledArguments : a0:System.Int32 -> int * string - static member - tcUnionCaseFieldCannotBeUsedMoreThanOnce : a0:System.String -> - int * string - static member - tcUnionCaseNameConflictsWithGeneratedType : a0:System.String * - a1:System.String -> - int * string - static member tcUnionCaseRequiresOneArgument : unit -> int * string - static member - tcUnitsOfMeasureInvalidInTypeConstructor : unit -> int * string - static member tcUnknownUnion : unit -> int * string - static member tcUnnamedArgumentsDoNotFormPrefix : unit -> string - static member tcUnrecognizedAttributeTarget : unit -> int * string - static member tcUnrecognizedQueryBinaryOperator : unit -> int * string - static member tcUnrecognizedQueryOperator : unit -> int * string - static member tcUnsupportedAttribute : unit -> int * string - static member tcUnsupportedMutRecDecl : unit -> int * string - static member tcUseForInSequenceExpression : unit -> int * string - static member tcUseMayNotBeUsedInQueries : unit -> int * string - static member tcUseWhenPatternGuard : unit -> string - static member tcUseYieldBangForMultipleResults : unit -> int * string - static member - tcValueInSignatureRequiresLiteralAttribute : unit -> int * string - static member tcVolatileFieldsMustBeMutable : unit -> int * string - static member tcVolatileOnlyOnClassLetBindings : unit -> int * string - static member - tlrLambdaLiftingOptimizationsNotApplied : unit -> int * string - static member tlrUnexpectedTExpr : unit -> int * string - static member - toolLocationHelperUnsupportedFrameworkVersion : a0:System.String -> - int * string - static member tupleRequiredInAbstractMethod : unit -> string - static member typeInfoActivePatternResult : unit -> string - static member typeInfoActiveRecognizer : unit -> string - static member typeInfoAnonRecdField : unit -> string - static member typeInfoArgument : unit -> string - static member typeInfoCallsWord : unit -> string - static member typeInfoCustomOperation : unit -> string - static member typeInfoEvent : unit -> string - static member typeInfoExtension : unit -> string - static member typeInfoField : unit -> string - static member typeInfoFromFirst : a0:System.String -> string - static member typeInfoFromNext : a0:System.String -> string - static member typeInfoFullName : unit -> string - static member typeInfoGeneratedProperty : unit -> string - static member typeInfoGeneratedType : unit -> string - static member typeInfoModule : unit -> string - static member typeInfoNamespace : unit -> string - static member typeInfoNamespaceOrModule : unit -> string - static member typeInfoOtherOverloads : a0:System.Int32 -> string - static member typeInfoPatternVariable : unit -> string - static member typeInfoProperty : unit -> string - static member typeInfoUnionCase : unit -> string - static member typeIsNotAccessible : a0:System.String -> int * string - static member - typrelCannotResolveAmbiguityInDelegate : unit -> int * string - static member typrelCannotResolveAmbiguityInEnum : unit -> int * string - static member typrelCannotResolveAmbiguityInPrintf : unit -> int * string - static member - typrelCannotResolveAmbiguityInUnmanaged : unit -> int * string - static member - typrelCannotResolveImplicitGenericInstantiation : a0:System.String * - a1:System.String -> - int * string - static member typrelDuplicateInterface : unit -> int * string - static member - typrelExplicitImplementationOfEquals : a0:System.String -> int * string - static member - typrelExplicitImplementationOfGetHashCode : a0:System.String -> - int * string - static member - typrelExplicitImplementationOfGetHashCodeOrEquals : a0:System.String -> - int * string - static member - typrelInterfaceMemberNoMostSpecificImplementation : a0:System.String -> - int * string - static member - typrelInterfaceWithConcreteAndVariable : a0:System.String * - a1:System.String * - a2:System.String * - a3:System.String -> - int * string - static member - typrelInterfaceWithConcreteAndVariableObjectExpression : a0:System.String * - a1:System.String * - a2:System.String -> - int * string - static member typrelInvalidValue : unit -> int * string - static member - typrelMemberCannotImplement : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member - typrelMemberDoesNotHaveCorrectKindsOfGenericParameters : a0:System.String * - a1:System.String -> - int * string - static member - typrelMemberDoesNotHaveCorrectNumberOfArguments : a0:System.String * - a1:System.String -> - int * string - static member - typrelMemberDoesNotHaveCorrectNumberOfTypeParameters : a0:System.String * - a1:System.String -> - int * string - static member - typrelMemberHasMultiplePossibleDispatchSlots : a0:System.String * - a1:System.String -> - int * string - static member typrelMethodIsOverconstrained : unit -> int * string - static member typrelMethodIsSealed : a0:System.String -> int * string - static member - typrelModuleNamespaceAttributesDifferInSigAndImpl : unit -> int * string - static member typrelMoreThenOneOverride : a0:System.String -> int * string - static member - typrelNamedArgumentHasBeenAssignedMoreThenOnce : a0:System.String -> - int * string - static member - typrelNeedExplicitImplementation : a0:System.String -> int * string - static member - typrelNoImplementationGiven : a0:System.String -> int * string - static member - typrelNoImplementationGivenSeveral : a0:System.String -> int * string - static member - typrelNoImplementationGivenSeveralTruncated : a0:System.String -> - int * string - static member - typrelNoImplementationGivenSeveralTruncatedWithSuggestion : a0:System.String -> - int * - string - static member - typrelNoImplementationGivenSeveralWithSuggestion : a0:System.String -> - int * string - static member - typrelNoImplementationGivenWithSuggestion : a0:System.String -> - int * string - static member - typrelOverloadNotFound : a0:System.String * a1:System.String -> - int * string - static member - typrelOverrideImplementsMoreThenOneSlot : a0:System.String * - a1:System.String * - a2:System.String -> - int * string - static member - typrelOverrideWasAmbiguous : a0:System.String -> int * string - static member - typrelSigImplNotCompatibleCompileTimeRequirementsDiffer : unit -> - int * string - static member - typrelSigImplNotCompatibleConstraintsDiffer : a0:System.String * - a1:System.String -> - int * string - static member - typrelSigImplNotCompatibleConstraintsDifferRemove : a0:System.String * - a1:System.String -> - int * string - static member - typrelSigImplNotCompatibleParamCountsDiffer : unit -> int * string - static member - typrelTypeImplementsIComparableDefaultObjectEqualsProvided : a0:System.String -> - int * - string - static member - typrelTypeImplementsIComparableShouldOverrideObjectEquals : a0:System.String -> - int * - string - static member - undefinedNameConstructorModuleOrNamespace : a0:System.String -> string - static member - undefinedNameFieldConstructorOrMember : a0:System.String -> string - static member - undefinedNameFieldConstructorOrMemberWhenTypeIsKnown : a0:System.String * - a1:System.String -> - string - static member undefinedNameNamespace : a0:System.String -> string - static member undefinedNameNamespaceOrModule : a0:System.String -> string - static member - undefinedNamePatternDiscriminator : a0:System.String -> string - static member undefinedNameRecordLabel : a0:System.String -> string - static member - undefinedNameRecordLabelOrNamespace : a0:System.String -> string - static member undefinedNameSuggestionsIntro : unit -> string - static member undefinedNameType : a0:System.String -> string - static member - undefinedNameTypeIn : a0:System.String * a1:System.String -> string - static member undefinedNameTypeParameter : a0:System.String -> string - static member - undefinedNameValueConstructorNamespaceOrType : a0:System.String -> - string - static member - undefinedNameValueNamespaceTypeOrModule : a0:System.String -> string - static member undefinedNameValueOfConstructor : a0:System.String -> string - static member unionCaseIsNotAccessible : a0:System.String -> int * string - static member - unionCasesAreNotAccessible : a0:System.String -> int * string - static member useSdkRefs : unit -> string - static member valueIsNotAccessible : a0:System.String -> int * string - static member writeToReadOnlyByref : unit -> int * string - static member xmlDocBadlyFormed : a0:System.String -> int * string - static member xmlDocDuplicateParameter : a0:System.String -> int * string - static member - xmlDocInvalidParameterName : a0:System.String -> int * string - static member xmlDocMissingCrossReference : unit -> int * string - static member xmlDocMissingParameter : a0:System.String -> int * string - static member xmlDocMissingParameterName : unit -> int * string - static member - xmlDocUnresolvedCrossReference : a0:System.String -> int * string - static member yieldUsedInsteadOfYieldBang : unit -> string - static member SwallowResourceText : bool - end - -namespace DependencyManager - type internal SR = - class - private new : unit -> SR - static member RunStartupValidation : unit -> unit - static member - couldNotLoadDependencyManagerExtension : a0:System.String * - a1:System.String -> - int * string - static member packageManagerError : a0:System.String -> int * string - static member - packageManagerUnknown : a0:System.String * a1:System.String * - a2:System.String -> int * string - static member SwallowResourceText : bool - end - -namespace FSIstrings - type internal SR = - class - private new : unit -> SR - static member RunStartupValidation : unit -> unit - static member fsiAbortingMainThread : unit -> string - static member fsiAdvanced : unit -> string - static member fsiBanner3 : unit -> string - static member fsiBindingSessionTo : a0:System.String -> string - static member fsiCodeGeneration : unit -> string - static member fsiConsoleProblem : unit -> string - static member fsiCouldNotInstallCtrlCHandler : a0:System.String -> string - static member fsiDidAHashI : a0:System.String -> string - static member fsiDidAHashr : a0:System.String -> string - static member fsiDidAHashrWithLockWarning : a0:System.String -> string - static member fsiDidAHashrWithStaleWarning : a0:System.String -> string - static member fsiDirectoryDoesNotExist : a0:System.String -> int * string - static member fsiEmitDebugInfoInQuotations : unit -> string - static member fsiErrorsAndWarnings : unit -> string - static member - fsiExceptionDuringPrettyPrinting : a0:System.String -> string - static member - fsiExceptionRaisedStartingServer : a0:System.String -> string - static member fsiExec : unit -> string - static member fsiExit : unit -> string - static member fsiFailedToResolveAssembly : a0:System.String -> string - static member fsiGui : unit -> string - static member fsiHelp : unit -> string - static member fsiInputFiles : unit -> string - static member fsiInterrupt : unit -> string - static member fsiIntroPackageSourceUriInfo : unit -> string - static member fsiIntroTextHashIInfo : unit -> string - static member fsiIntroTextHashhelpInfo : unit -> string - static member fsiIntroTextHashloadInfo : unit -> string - static member fsiIntroTextHashquitInfo : unit -> string - static member fsiIntroTextHashrInfo : unit -> string - static member fsiIntroTextHashtimeInfo : unit -> string - static member fsiIntroTextHeader1directives : unit -> string - static member fsiIntroTextHeader2commandLine : unit -> string - static member fsiIntroTextHeader3 : a0:System.String -> string - static member fsiInvalidAssembly : a0:System.String -> int * string - static member fsiLanguage : unit -> string - static member fsiLineTooLong : unit -> string - static member fsiLoad : unit -> string - static member fsiLoadingFilesPrefixText : unit -> string - static member fsiMiscellaneous : unit -> string - static member fsiOperationCouldNotBeCompleted : unit -> string - static member fsiOperationFailed : unit -> string - static member fsiProductName : a0:System.String -> string - static member fsiProductNameCommunity : a0:System.String -> string - static member fsiQuiet : unit -> string - static member fsiReadline : unit -> string - static member fsiRemaining : unit -> string - static member - fsiTimeInfoGCGenerationLabelSomeShorthandForTheWordGeneration : unit -> - string - static member - fsiTimeInfoMainString : a0:System.String * a1:System.String * - a2:System.String -> string - static member fsiTurnedTimingOff : unit -> string - static member fsiTurnedTimingOn : unit -> string - static member fsiUnexpectedThreadAbortException : unit -> string - static member fsiUsage : a0:System.String -> string - static member fsiUse : unit -> string - static member shadowCopyReferences : unit -> string - static member stoppedDueToError : unit -> string - static member SwallowResourceText : bool - end - -namespace UtilsStrings - type internal SR = - class - private new : unit -> SR - static member RunStartupValidation : unit -> unit - static member buildProductName : a0:System.String -> string - static member - fSharpBannerVersion : a0:System.String * a1:System.String -> string - static member SwallowResourceText : bool - end - -namespace FSharp - module internal BuildProperties = begin - val fsProductVersion : string - val fsLanguageVersion : string - end - - - - - - - -namespace Internal.Utilities.StructuredFormat - [] - type LayoutTag = - | ActivePatternCase - | ActivePatternResult - | Alias - | Class - | Union - | UnionCase - | Delegate - | Enum - | Event - | Field - | Interface - | Keyword - | LineBreak - | Local - | Record - | RecordField - | Method - | Member - | ModuleBinding - | Function - | Module - | Namespace - | NumericLiteral - | Operator - | Parameter - | Property - | Space - | StringLiteral - | Struct - | TypeParameter - | Text - | Punctuation - | UnknownType - | UnknownEntity - type TaggedText = - interface - abstract member Tag : LayoutTag - abstract member Text : string - end - type TaggedTextWriter = - interface - abstract member Write : t:TaggedText -> unit - abstract member WriteLine : unit -> unit - end - [] - type Joint = - | Unbreakable - | Breakable of indentation: int - | Broken of indentation: int - [] - type Layout = - | ObjLeaf of juxtLeft: bool * object: obj * juxtRight: bool - | Leaf of juxtLeft: bool * text: TaggedText * justRight: bool - | Node of leftLayout: Layout * rightLayout: Layout * joint: Joint - | Attr of text: string * attributes: (string * string) list * layout: Layout - with - static member JuxtapositionMiddle : left:Layout * right:Layout -> bool - member JuxtapositionLeft : bool - member JuxtapositionRight : bool - end - [] - type IEnvironment = - interface - abstract member GetLayout : obj -> Layout - abstract member MaxColumns : int - abstract member MaxRows : int - end - module TaggedTextOps = begin - val mkTag : LayoutTag -> string -> TaggedText - val length : tt:TaggedText -> int - val toText : tt:TaggedText -> string - val tagAlias : string -> TaggedText - val keywordFunctions : Set - val tagClass : string -> TaggedText - val tagUnionCase : string -> TaggedText - val tagDelegate : string -> TaggedText - val tagEnum : string -> TaggedText - val tagEvent : string -> TaggedText - val tagField : string -> TaggedText - val tagInterface : string -> TaggedText - val tagKeyword : string -> TaggedText - val tagLineBreak : string -> TaggedText - val tagLocal : string -> TaggedText - val tagRecord : string -> TaggedText - val tagRecordField : string -> TaggedText - val tagMethod : string -> TaggedText - val tagModule : string -> TaggedText - val tagModuleBinding : string -> TaggedText - val tagFunction : string -> TaggedText - val tagNamespace : string -> TaggedText - val tagNumericLiteral : string -> TaggedText - val tagOperator : string -> TaggedText - val tagParameter : string -> TaggedText - val tagProperty : string -> TaggedText - val tagSpace : string -> TaggedText - val tagStringLiteral : string -> TaggedText - val tagStruct : string -> TaggedText - val tagTypeParameter : string -> TaggedText - val tagText : string -> TaggedText - val tagPunctuation : string -> TaggedText - module Literals = begin - val lineBreak : TaggedText - val space : TaggedText - val comma : TaggedText - val semicolon : TaggedText - val leftParen : TaggedText - val rightParen : TaggedText - val leftBracket : TaggedText - val rightBracket : TaggedText - val leftBrace : TaggedText - val rightBrace : TaggedText - val leftBraceBar : TaggedText - val rightBraceBar : TaggedText - val equals : TaggedText - val arrow : TaggedText - val questionMark : TaggedText - end - end - module LayoutOps = begin - val mkNode : l:Layout -> r:Layout -> joint:Joint -> Layout - val objL : value:obj -> Layout - val sLeaf : l:bool * t:TaggedText * r:bool -> Layout - val wordL : text:TaggedText -> Layout - val sepL : text:TaggedText -> Layout - val rightL : text:TaggedText -> Layout - val leftL : text:TaggedText -> Layout - val emptyL : Layout - val isEmptyL : layout:Layout -> bool - val aboveL : layout1:Layout -> layout2:Layout -> Layout - val tagAttrL : - text:string -> maps:(string * string) list -> layout:Layout -> Layout - val apply2 : - f:(Layout -> Layout -> Layout) -> l:Layout -> r:Layout -> Layout - val ( ^^ ) : layout1:Layout -> layout2:Layout -> Layout - val ( ++ ) : layout1:Layout -> layout2:Layout -> Layout - val ( -- ) : layout1:Layout -> layout2:Layout -> Layout - val ( --- ) : layout1:Layout -> layout2:Layout -> Layout - val ( @@ ) : layout1:Layout -> layout2:Layout -> Layout - val ( @@- ) : layout1:Layout -> layout2:Layout -> Layout - val ( @@-- ) : layout1:Layout -> layout2:Layout -> Layout - val tagListL : tagger:(Layout -> Layout) -> els:Layout list -> Layout - val commaListL : layouts:Layout list -> Layout - val semiListL : layouts:Layout list -> Layout - val spaceListL : layouts:Layout list -> Layout - val sepListL : layout1:Layout -> layouts:Layout list -> Layout - val bracketL : layout:Layout -> Layout - val tupleL : layouts:Layout list -> Layout - val aboveListL : layouts:Layout list -> Layout - val optionL : selector:('T -> Layout) -> value:'T option -> Layout - val listL : selector:('T -> Layout) -> value:'T list -> Layout - val squareBracketL : layout:Layout -> Layout - val braceL : layout:Layout -> Layout - val boundedUnfoldL : - itemL:('a -> Layout) -> - project:('z -> ('a * 'z) option) -> - stopShort:('z -> bool) -> z:'z -> maxLength:int -> Layout list - val unfoldL : - selector:('T -> Layout) -> - folder:('State -> ('T * 'State) option) -> - state:'State -> count:int -> Layout list - end - [] - type FormatOptions = - { FloatingPointFormat: string - AttributeProcessor: string -> (string * string) list -> bool -> unit - PrintIntercepts: (IEnvironment -> obj -> Layout option) list - StringLimit: int - FormatProvider: System.IFormatProvider - BindingFlags: System.Reflection.BindingFlags - PrintWidth: int - PrintDepth: int - PrintLength: int - PrintSize: int - ShowProperties: bool - ShowIEnumerable: bool } - with - static member Default : FormatOptions - end - module ReflectUtils = begin - [] - type TypeInfo = - | TupleType of System.Type list - | FunctionType of System.Type * System.Type - | RecordType of (string * System.Type) list - | SumType of (string * (string * System.Type) list) list - | UnitType - | ObjectType of System.Type - val isNamedType : ty:System.Type -> bool - val equivHeadTypes : ty1:System.Type -> ty2:System.Type -> bool - val option : System.Type - val func : System.Type - val isOptionTy : ty:System.Type -> bool - val isUnitType : ty:System.Type -> bool - val isListType : ty:System.Type -> bool - [] - type TupleType = - | Value - | Reference - [] - type ValueInfo = - | TupleValue of TupleType * (obj * System.Type) [] - | FunctionClosureValue of System.Type - | RecordValue of (string * obj * System.Type) [] - | UnionCaseValue of string * (string * (obj * System.Type)) [] - | ExceptionValue of System.Type * (string * (obj * System.Type)) [] - | NullValue - | UnitValue - | ObjectValue of obj - module Value = begin - val GetValueInfoOfObject : - bindingFlags:System.Reflection.BindingFlags -> obj:obj -> ValueInfo - val GetValueInfo : - bindingFlags:System.Reflection.BindingFlags -> - x:'a * ty:System.Type -> ValueInfo - end - end - module Display = begin - val string_of_int : i:int -> string - val typeUsesSystemObjectToString : ty:System.Type -> bool - val catchExn : f:(unit -> 'a) -> Choice<'a,exn> - [] - type Breaks = - | Breaks of nextFreeSlot: int * nextOuterBreak: int * savingsStack: int [] - val chunkN : int - val breaks0 : unit -> Breaks - val pushBreak : saving:int -> Breaks -> Breaks - val popBreak : Breaks -> Breaks * bool - val forceBreak : Breaks -> (Breaks * int) option - val squashToAux : - maxWidth:int * leafFormatter:(obj -> TaggedText) -> - layout:Layout -> Layout - val combine : strs:string list -> string - val showL : - opts:FormatOptions -> - leafFormatter:(obj -> string) -> layout:Layout -> string - val outL : - outAttribute:(string -> (string * string) list -> bool -> 'a) -> - leafFormatter:(obj -> #TaggedText) -> - chan:TaggedTextWriter -> layout:Layout -> unit - val unpackCons : recd:('a * 'b) [] -> 'b * 'b - val getListValueInfo : - bindingFlags:System.Reflection.BindingFlags -> - x:obj * ty:System.Type -> - ((obj * System.Type) * (obj * System.Type)) option - val structL : Layout - val nullL : Layout - val unitL : Layout - val makeRecordL : nameXs:(#TaggedText * Layout) list -> Layout - val makePropertiesL : nameXs:(#TaggedText * Layout option) list -> Layout - val makeListL : itemLs:Layout list -> Layout - val makeArrayL : xs:Layout list -> Layout - val makeArray2L : xs:Layout list -> Layout - val getProperty : ty:System.Type -> obj:obj -> name:string -> obj - val getField : obj:'a -> fieldInfo:System.Reflection.FieldInfo -> obj - val formatChar : isChar:bool -> c:char -> string - val formatString : s:string -> string - val formatStringInWidth : width:int -> str:string -> string - type Precedence = - | BracketIfTupleOrNotAtomic = 2 - | BracketIfTuple = 3 - | NeverBracket = 4 - [] - type ShowMode = - | ShowAll - | ShowTopLevelBinding - val isSetOrMapType : ty:System.Type -> bool - type ObjectGraphFormatter = - class - new : opts:FormatOptions * bindingFlags:System.Reflection.BindingFlags -> - ObjectGraphFormatter - member Format : showMode:ShowMode * x:'a * xty:System.Type -> Layout - end - val leafFormatter : opts:FormatOptions -> obj:obj -> TaggedText - val any_to_layout : - options:FormatOptions -> value:'T * typValue:System.Type -> Layout - val squashTo : width:int -> layout:Layout -> Layout - val squash_layout : options:FormatOptions -> layout:Layout -> Layout - val asTaggedTextWriter : writer:System.IO.TextWriter -> TaggedTextWriter - val output_layout_tagged : - options:FormatOptions -> writer:TaggedTextWriter -> layout:Layout -> unit - val output_layout : - options:FormatOptions -> - writer:System.IO.TextWriter -> layout:Layout -> unit - val layout_to_string : options:FormatOptions -> layout:Layout -> string - val output_any_ex : - opts:FormatOptions -> oc:System.IO.TextWriter -> 'a * System.Type -> unit - val output_any : writer:System.IO.TextWriter -> 'a * System.Type -> unit - val layout_as_string : - options:FormatOptions -> value:'T * typValue:System.Type -> string - val any_to_string : 'a * System.Type -> string - val fsi_any_to_layout : - options:FormatOptions -> value:'T * typValue:System.Type -> Layout - end - -namespace FSharp.Compiler - module internal SR = begin - val private resources : Lazy - val GetString : string -> string - end - module internal DiagnosticMessage = begin - val mkFunctionValue : tys:System.Type [] -> impl:(obj -> obj) -> obj - val funTyC : System.Type - val mkFunTy : a:System.Type -> b:System.Type -> System.Type - val isNamedType : ty:System.Type -> bool - val isFunctionType : ty1:System.Type -> bool - val destFunTy : ty:System.Type -> System.Type * System.Type [] - val buildFunctionForOneArgPat : - ty:System.Type -> impl:(System.Type -> obj -> obj) -> obj - val capture1 : - fmt:string -> - i:int -> - args:obj list -> - ty:System.Type -> go:(obj list -> System.Type -> int -> obj) -> obj - val postProcessString : s:string -> string - val createMessageString : - messageString:string -> fmt:Printf.StringFormat<'T> -> 'T - type ResourceString<'T> = - class - new : string * Printf.StringFormat<'T> -> ResourceString<'T> - member Format : 'T - end - val DeclareResourceString : - string * Printf.StringFormat<'T> -> ResourceString<'T> - end - -namespace FSharp.Compiler - type LogCompilerFunctionId = - | Service_ParseAndCheckFileInProject = 1 - | Service_CheckOneFile = 2 - | Service_IncrementalBuildersCache_BuildingNewCache = 3 - | Service_IncrementalBuildersCache_GettingCache = 4 - | CompileOps_TypeCheckOneInputAndFinishEventually = 5 - | IncrementalBuild_CreateItemKeyStoreAndSemanticClassification = 6 - | IncrementalBuild_TypeCheck = 7 - [] - type FSharpCompilerEventSource = - class - inherit System.Diagnostics.Tracing.EventSource - new : unit -> FSharpCompilerEventSource - [] - member - BlockMessageStart : message:string * functionId:LogCompilerFunctionId -> - unit - [] - member - BlockMessageStop : message:string * functionId:LogCompilerFunctionId -> - unit - [] - member BlockStart : functionId:LogCompilerFunctionId -> unit - [] - member BlockStop : functionId:LogCompilerFunctionId -> unit - [] - member Log : functionId:LogCompilerFunctionId -> unit - [] - member - LogMessage : message:string * functionId:LogCompilerFunctionId -> unit - static member Instance : FSharpCompilerEventSource - end - module Logger = begin - val Log : LogCompilerFunctionId -> unit - val LogMessage : message:string -> LogCompilerFunctionId -> unit - val LogBlockStart : LogCompilerFunctionId -> unit - val LogBlockStop : LogCompilerFunctionId -> unit - val LogBlockMessageStart : message:string -> LogCompilerFunctionId -> unit - val LogBlockMessageStop : message:string -> LogCompilerFunctionId -> unit - val LogBlock : LogCompilerFunctionId -> System.IDisposable - val LogBlockMessage : - message:string -> LogCompilerFunctionId -> System.IDisposable - end - -namespace FSharp.Compiler - module internal Features = begin - [] - type LanguageFeature = - | SingleUnderscorePattern - | WildCardInForLoop - | RelaxWhitespace - | NameOf - | ImplicitYield - | OpenTypeDeclaration - | DotlessFloat32Literal - | PackageManagement - | FromEndSlicing - | FixedIndexSlice3d4d - | AndBang - | NullableOptionalInterop - | DefaultInterfaceMemberConsumption - | WitnessPassing - | InterfacesWithMultipleGenericInstantiation - | StringInterpolation - | OverloadsForCustomOperations - | ExpandedMeasurables - type LanguageVersion = - class - new : string -> LanguageVersion - member ContainsVersion : string -> bool - member GetFeatureString : feature:LanguageFeature -> string - member GetFeatureVersionString : feature:LanguageFeature -> string - member SupportsFeature : LanguageFeature -> bool - member IsPreviewEnabled : bool - member SpecifiedVersion : decimal - member SpecifiedVersionString : string - member ValidOptions : string [] - member ValidVersions : string [] - end - end - -namespace FSharp.Compiler.Text - type ISourceText = - interface - abstract member ContentEquals : sourceText:ISourceText -> bool - abstract member - CopyTo : sourceIndex:int * destination:char [] * destinationIndex:int * - count:int -> unit - abstract member GetLastCharacterPosition : unit -> int * int - abstract member GetLineCount : unit -> int - abstract member GetLineString : lineIndex:int -> string - abstract member GetSubTextString : start:int * length:int -> string - abstract member SubTextEquals : target:string * startIndex:int -> bool - abstract member Item : int -> char with get - abstract member Length : int - end - [] - type StringText = - class - interface ISourceText - new : str:string -> StringText - override Equals : obj:obj -> bool - override GetHashCode : unit -> int - override ToString : unit -> string - member String : string - end - module SourceText = begin - val ofString : string -> ISourceText - end -namespace Internal.Utilities.Text.Lexing - [] - type internal Position = - struct - new : fileIndex:int * line:int * originalLine:int * - startOfLineAbsoluteOffset:int * absoluteOffset:int -> Position - val FileIndex: int - val Line: int - val OriginalLine: int - val AbsoluteOffset: int - val StartOfLineAbsoluteOffset: int - static member FirstLine : fileIdx:int -> Position - member ApplyLineDirective : fileIdx:int * line:int -> Position - member EndOfToken : n:int -> Position - member ShiftColumnBy : by:int -> Position - member Column : int - member ColumnMinusOne : Position - member NextLine : Position - static member Empty : Position - end - type internal LexBufferFiller<'Char> = LexBuffer<'Char> -> unit - [] - and internal LexBuffer<'Char> = - class - new : filler:LexBufferFiller<'Char> * - supportsFeature:(FSharp.Compiler.Features.LanguageFeature -> bool) -> - LexBuffer<'Char> - static member - FromArray : supportsFeature:(FSharp.Compiler.Features.LanguageFeature -> - bool) * s:'Char [] -> LexBuffer<'Char> - static member - FromArrayNoCopy : supportsFeature:(FSharp.Compiler.Features.LanguageFeature -> - bool) * buffer:'Char [] -> - LexBuffer<'Char> - static member - FromChars : (FSharp.Compiler.Features.LanguageFeature -> bool) * char [] -> - LexBuffer - static member - FromFunction : (FSharp.Compiler.Features.LanguageFeature -> bool) * - ('Char [] * int * int -> int) -> LexBuffer<'Char> - static member - FromSourceText : (FSharp.Compiler.Features.LanguageFeature -> bool) * - FSharp.Compiler.Text.ISourceText -> LexBuffer - static member LexemeString : LexBuffer -> System.String - member DiscardInput : unit -> unit - member EndOfScan : unit -> int - member EnsureBufferSize : n:int -> unit - member LexemeChar : int -> 'Char - member LexemeContains : 'Char -> bool - member RefillBuffer : unit -> unit - member SupportsFeature : FSharp.Compiler.Features.LanguageFeature -> bool - member Buffer : 'Char [] - member BufferAcceptAction : int - member - BufferLocalStore : System.Collections.Generic.IDictionary - member BufferMaxScanLength : int - member BufferScanLength : int - member BufferScanPos : int - member BufferScanStart : int - member EndPos : Position - member IsPastEndOfStream : bool - member LexemeLength : int - member LexemeView : System.ReadOnlySpan<'Char> - member StartPos : Position - end - module GenericImplFragments = begin - val startInterpret : lexBuffer:LexBuffer -> unit - val afterRefill : - trans:uint16 [] [] * sentinel:int * lexBuffer:LexBuffer * - scanUntilSentinel:(LexBuffer -> int -> 'a) * endOfScan:(unit -> 'a) * - state:int * eofPos:int -> 'a - val onAccept : lexBuffer:LexBuffer * a:int -> unit - end - [] - type internal UnicodeTables = - class - new : trans:uint16 [] array * accept:uint16 [] -> UnicodeTables - static member Create : uint16 [] array * uint16 [] -> UnicodeTables - member Interpret : initialState:int * LexBuffer -> int - end - -namespace Internal.Utilities.Text.Parsing - exception RecoverableParseError - exception Accept of obj - [] - type internal IParseState = - class - new : ruleStartPoss:Lexing.Position [] * ruleEndPoss:Lexing.Position [] * - lhsPos:Lexing.Position [] * ruleValues:obj [] * - lexbuf:Lexing.LexBuffer -> IParseState - member GetInput : index:int -> obj - member InputEndPosition : index:int -> Lexing.Position - member InputRange : index:int -> Lexing.Position * Lexing.Position - member InputStartPosition : index:int -> Lexing.Position - member RaiseError : unit -> 'b - member LexBuffer : Lexing.LexBuffer - member ResultEndPosition : Lexing.Position - member ResultRange : Lexing.Position * Lexing.Position - member ResultStartPosition : Lexing.Position - end - [] - type internal ParseErrorContext<'tok> = - class - new : stateStack:int list * parseState:IParseState * reduceTokens:int list * - currentToken:'tok option * reducibleProductions:int list list * - shiftableTokens:int list * message:string -> ParseErrorContext<'tok> - member CurrentToken : 'tok option - member Message : string - member ParseState : IParseState - member ReduceTokens : int list - member ReducibleProductions : int list list - member ShiftTokens : int list - member StateStack : int list - end - type internal Tables<'tok> = - { reductions: (IParseState -> obj) [] - endOfInputTag: int - tagOfToken: 'tok -> int - dataOfToken: 'tok -> obj - actionTableElements: uint16 [] - actionTableRowOffsets: uint16 [] - reductionSymbolCounts: uint16 [] - immediateActions: uint16 [] - gotos: uint16 [] - sparseGotoTableRowOffsets: uint16 [] - stateToProdIdxsTableElements: uint16 [] - stateToProdIdxsTableRowOffsets: uint16 [] - productionToNonTerminalTable: uint16 [] - parseError: ParseErrorContext<'tok> -> unit - numTerminals: int - tagOfErrorTerminal: int } - with - member - Interpret : lexer:(Lexing.LexBuffer -> 'tok) * - lexbuf:Lexing.LexBuffer * initialState:int -> obj - end - type Stack<'a> = - class - new : n:int -> Stack<'a> - member Ensure : newSize:int -> unit - member Peep : unit -> 'a - member Pop : unit -> unit - member PrintStack : unit -> unit - member Push : x:'a -> unit - member Top : n:int -> 'a list - member Count : int - member IsEmpty : bool - end - module Flags = begin - val mutable debug : bool - end - module internal Implementation = begin - val anyMarker : int - val shiftFlag : int - val reduceFlag : int - val errorFlag : int - val acceptFlag : int - val actionMask : int - val actionValue : action:int -> int - val actionKind : action:int -> int - type AssocTable = - class - new : elemTab:uint16 [] * offsetTab:uint16 [] * cache:int [] * - cacheSize:int -> AssocTable - member Read : rowNumber:int * keyToFind:int -> int - member ReadAll : n:int -> (int * int) list * int - member - ReadAssoc : minElemNum:int * maxElemNum:int * defaultValueOfAssoc:int * - keyToFind:int -> int - end - type IdxToIdxListTable = - class - new : elemTab:uint16 [] * offsetTab:uint16 [] -> IdxToIdxListTable - member ReadAll : n:int -> int list - end - [] - type ValueInfo = - struct - new : value:obj * startPos:Lexing.Position * endPos:Lexing.Position -> - ValueInfo - val value: obj - val startPos: Lexing.Position - val endPos: Lexing.Position - end - val interpret : - tables:Tables<'tok> -> - lexer:(Lexing.LexBuffer -> 'tok) -> - lexbuf:Lexing.LexBuffer -> initialState:int -> obj - end - module internal ParseHelpers = begin - val parse_error : string -> unit - val parse_error_rich : (ParseErrorContext<'tok> -> unit) option - end - -namespace Internal.Utilities - module internal ResizeArray = begin - val length : ResizeArray<'T> -> int - val get : ResizeArray<'T> -> int -> 'T - val set : ResizeArray<'T> -> int -> 'T -> unit - val create : int -> 'T -> ResizeArray<'T> - val init : int -> (int -> 'T) -> ResizeArray<'T> - val blit : ResizeArray<'T> -> int -> ResizeArray<'T> -> int -> int -> unit - val concat : ResizeArray<'T> list -> ResizeArray<'T> - val append : ResizeArray<'T> -> ResizeArray<'T> -> ResizeArray<'T> - val sub : ResizeArray<'T> -> int -> int -> ResizeArray<'T> - val fill : ResizeArray<'T> -> int -> int -> 'T -> unit - val copy : ResizeArray<'T> -> ResizeArray<'T> - val toList : ResizeArray<'T> -> 'T list - val ofList : 'T list -> ResizeArray<'T> - val iter : ('T -> unit) -> ResizeArray<'T> -> unit - val map : ('T -> 'U) -> ResizeArray<'T> -> ResizeArray<'U> - val mapi : (int -> 'T -> 'U) -> ResizeArray<'T> -> ResizeArray<'U> - val iteri : (int -> 'T -> unit) -> ResizeArray<'T> -> unit - val exists : ('T -> bool) -> ResizeArray<'T> -> bool - val forall : ('T -> bool) -> ResizeArray<'T> -> bool - val indexNotFound : unit -> 'a - val find : ('T -> bool) -> ResizeArray<'T> -> 'T - val tryPick : ('T -> 'U option) -> ResizeArray<'T> -> 'U option - val tryFind : ('T -> bool) -> ResizeArray<'T> -> 'T option - val iter2 : ('T -> 'U -> unit) -> ResizeArray<'T> -> ResizeArray<'U> -> unit - val map2 : - ('T -> 'U -> 'c) -> ResizeArray<'T> -> ResizeArray<'U> -> ResizeArray<'c> - val choose : ('T -> 'U option) -> ResizeArray<'T> -> ResizeArray<'U> - val filter : ('T -> bool) -> ResizeArray<'T> -> ResizeArray<'T> - val partition : - ('T -> bool) -> ResizeArray<'T> -> ResizeArray<'T> * ResizeArray<'T> - val rev : ResizeArray<'T> -> ResizeArray<'T> - val foldBack : ('T -> 'U -> 'U) -> ResizeArray<'T> -> 'U -> 'U - val fold : ('T -> 'U -> 'T) -> 'T -> ResizeArray<'U> -> 'T - val toArray : ResizeArray<'T> -> 'T [] - val ofArray : 'T [] -> ResizeArray<'T> - val toSeq : ResizeArray<'T> -> seq<'T> - val sort : ('T -> 'T -> int) -> ResizeArray<'T> -> unit - val sortBy : ('T -> 'Key) -> ResizeArray<'T> -> unit when 'Key : comparison - val exists2 : - ('T -> 'U -> bool) -> ResizeArray<'T> -> ResizeArray<'U> -> bool - val findIndex : ('T -> bool) -> ResizeArray<'T> -> int - val findIndexi : (int -> 'T -> bool) -> ResizeArray<'T> -> int - val foldSub : - f:('a -> 'b -> 'a) -> - acc:'a -> arr:ResizeArray<'b> -> start:int -> fin:int -> 'a - val foldBackSub : - f:('a -> 'b -> 'b) -> - arr:ResizeArray<'a> -> start:int -> fin:int -> acc:'b -> 'b - val reduce : ('T -> 'T -> 'T) -> ResizeArray<'T> -> 'T - val reduceBack : ('T -> 'T -> 'T) -> ResizeArray<'T> -> 'T - val fold2 : - ('state -> 'b1 -> 'b2 -> 'state) -> - 'state -> ResizeArray<'b1> -> ResizeArray<'b2> -> 'state - val foldBack2 : - ('a1 -> 'a2 -> 'U -> 'U) -> - ResizeArray<'a1> -> ResizeArray<'a2> -> 'U -> 'U - val forall2 : - ('T -> 'U -> bool) -> ResizeArray<'T> -> ResizeArray<'U> -> bool - val isEmpty : ResizeArray<'T> -> bool - val iteri2 : - (int -> 'T -> 'U -> unit) -> ResizeArray<'T> -> ResizeArray<'U> -> unit - val mapi2 : - (int -> 'T -> 'U -> 'c) -> - ResizeArray<'T> -> ResizeArray<'U> -> ResizeArray<'c> - val scanBackSub : - f:('T -> 'a -> 'a) -> - arr:ResizeArray<'T> -> start:int -> fin:int -> acc:'a -> ResizeArray<'a> - val scanSub : - f:('a -> 'T -> 'a) -> - acc:'a -> arr:ResizeArray<'T> -> start:int -> fin:int -> ResizeArray<'a> - val scan : ('U -> 'T -> 'U) -> 'U -> ResizeArray<'T> -> ResizeArray<'U> - val scanBack : ('T -> 'c -> 'c) -> ResizeArray<'T> -> 'c -> ResizeArray<'c> - val singleton : 'T -> ResizeArray<'T> - val tryFindIndex : ('T -> bool) -> ResizeArray<'T> -> int option - val tryFindIndexi : (int -> 'T -> bool) -> ResizeArray<'T> -> int option - val zip : ResizeArray<'T> -> ResizeArray<'U> -> ResizeArray<'T * 'U> - val unzip : ResizeArray<'T * 'U> -> ResizeArray<'T> * ResizeArray<'U> - end - -namespace Internal.Utilities.Collections - [] - type internal HashMultiMap<'Key,'Value> = - class - interface - System.Collections.Generic.ICollection> - interface System.Collections.Generic.IDictionary<'Key,'Value> - interface System.Collections.IEnumerable - interface - System.Collections.Generic.IEnumerable> - new : entries:seq<'Key * 'Value> * - comparer:System.Collections.Generic.IEqualityComparer<'Key> -> - HashMultiMap<'Key,'Value> - new : comparer:System.Collections.Generic.IEqualityComparer<'Key> -> - HashMultiMap<'Key,'Value> - new : size:int * - comparer:System.Collections.Generic.IEqualityComparer<'Key> -> - HashMultiMap<'Key,'Value> - member Add : 'Key * 'Value -> unit - member Clear : unit -> unit - member Contains : y:'Key -> bool - member ContainsKey : 'Key -> bool - member Copy : unit -> HashMultiMap<'Key,'Value> - member FindAll : 'Key -> 'Value list - member Fold : ('Key -> 'Value -> 'State -> 'State) -> 'State -> 'State - member GetRest : k:'Key -> 'Value list - member Iterate : ('Key -> 'Value -> unit) -> unit - member Remove : 'Key -> unit - member Replace : 'Key * 'Value -> unit - member TryFind : 'Key -> 'Value option - member Count : int - member FirstEntries : System.Collections.Generic.Dictionary<'Key,'Value> - member Item : 'Key -> 'Value with get - member Rest : System.Collections.Generic.Dictionary<'Key,'Value list> - end - -namespace Internal.Utilities - module internal EditDistance = begin - val inline existsInWin : - mChar:char -> str:string -> offset:int -> rad:int -> bool - val jaro : s1:string -> s2:string -> float - val JaroWinklerDistance : s1:string -> s2:string -> float - val private calcDamerauLevenshtein : a:string * b:string -> int - val CalcEditDistance : a:string * b:string -> int - end - -namespace Internal.Utilities.Collections.Tagged - [] - type internal SetTree<'T> = - class - new : k:'T -> SetTree<'T> - member Key : 'T - end - [] - type internal SetTreeNode<'T> = - class - inherit SetTree<'T> - new : v:'T * left:SetTree<'T> * right:SetTree<'T> * h:int -> - SetTreeNode<'T> - member Height : int - member Left : SetTree<'T> - member Right : SetTree<'T> - end - module SetTree = begin - val empty : 'a when 'a : null - val inline isEmpty : t:SetTree<'T> -> bool - val countAux : t:SetTree<'T> -> acc:int -> int - val count : s:SetTree<'a> -> int - val inline height : t:SetTree<'T> -> int - [] - val tolerance : int = 2 - val mk : l:SetTree<'T> -> k:'T -> r:SetTree<'T> -> SetTree<'T> - val inline private asNode : value:SetTree<'T> -> SetTreeNode<'T> - val rebalance : t1:SetTree<'a> -> v:'a -> t2:SetTree<'a> -> SetTree<'a> - val add : - comparer:System.Collections.Generic.IComparer<'T> -> - k:'T -> t:SetTree<'T> -> SetTree<'T> - val balance : - comparer:System.Collections.Generic.IComparer<'T> -> - t1:SetTree<'T> -> k:'T -> t2:SetTree<'T> -> SetTree<'T> - val split : - comparer:System.Collections.Generic.IComparer<'T> -> - pivot:'T -> t:SetTree<'T> -> SetTree<'T> * bool * SetTree<'T> - val spliceOutSuccessor : t:SetTree<'T> -> 'T * SetTree<'T> - val remove : - comparer:System.Collections.Generic.IComparer<'T> -> - k:'T -> t:SetTree<'T> -> SetTree<'T> - val contains : - comparer:System.Collections.Generic.IComparer<'T> -> - k:'T -> t:SetTree<'T> -> bool - val iter : f:('T -> unit) -> t:SetTree<'T> -> unit - val fold : f:('T -> 'a -> 'a) -> t:SetTree<'T> -> x:'a -> 'a - val forall : f:('T -> bool) -> t:SetTree<'T> -> bool - val exists : f:('T -> bool) -> t:SetTree<'T> -> bool - val subset : - comparer:System.Collections.Generic.IComparer<'a> -> - a:SetTree<'a> -> b:SetTree<'a> -> bool - val filterAux : - comparer:System.Collections.Generic.IComparer<'T> -> - f:('T -> bool) -> t:SetTree<'T> -> acc:SetTree<'T> -> SetTree<'T> - val filter : - comparer:System.Collections.Generic.IComparer<'a> -> - f:('a -> bool) -> s:SetTree<'a> -> SetTree<'a> - val diffAux : - comparer:System.Collections.Generic.IComparer<'T> -> - t:SetTree<'T> -> acc:SetTree<'T> -> SetTree<'T> - val diff : - comparer:System.Collections.Generic.IComparer<'a> -> - a:SetTree<'a> -> b:SetTree<'a> -> SetTree<'a> - val union : - comparer:System.Collections.Generic.IComparer<'T> -> - t1:SetTree<'T> -> t2:SetTree<'T> -> SetTree<'T> - val intersectionAux : - comparer:System.Collections.Generic.IComparer<'T> -> - b:SetTree<'T> -> t:SetTree<'T> -> acc:SetTree<'T> -> SetTree<'T> - val intersection : - comparer:System.Collections.Generic.IComparer<'a> -> - a:SetTree<'a> -> b:SetTree<'a> -> SetTree<'a> - val partition1 : - comparer:System.Collections.Generic.IComparer<'a> -> - f:('a -> bool) -> - k:'a -> - acc1:SetTree<'a> * acc2:SetTree<'a> -> SetTree<'a> * SetTree<'a> - val partitionAux : - comparer:System.Collections.Generic.IComparer<'T> -> - f:('T -> bool) -> - t:SetTree<'T> -> - SetTree<'T> * SetTree<'T> -> SetTree<'T> * SetTree<'T> - val partition : - comparer:System.Collections.Generic.IComparer<'a> -> - f:('a -> bool) -> s:SetTree<'a> -> SetTree<'a> * SetTree<'a> - val minimumElementAux : t:SetTree<'T> -> n:'T -> 'T - val minimumElementOpt : t:SetTree<'T> -> 'T option - val maximumElementAux : t:SetTree<'T> -> n:'T -> 'T - val maximumElementOpt : t:SetTree<'T> -> 'T option - val minimumElement : s:SetTree<'a> -> 'a - val maximumElement : s:SetTree<'a> -> 'a - type SetIterator<'T> = - class - new : s:SetTree<'T> -> SetTree.SetIterator<'T> - member MoveNext : unit -> bool - member Current : 'T - end - val toSeq : s:SetTree<'a> -> System.Collections.Generic.IEnumerator<'a> - val compareStacks : - comparer:System.Collections.Generic.IComparer<'T> -> - l1:SetTree<'T> list -> l2:SetTree<'T> list -> int - val compare : - comparer:System.Collections.Generic.IComparer<'T> -> - t1:SetTree<'T> -> t2:SetTree<'T> -> int - val choose : s:SetTree<'a> -> 'a - val toList : t:SetTree<'T> -> 'T list - val copyToArray : s:SetTree<'a> -> arr:'a [] -> i:int -> unit - val toArray : s:SetTree<'a> -> 'a [] - val mkFromEnumerator : - comparer:System.Collections.Generic.IComparer<'a> -> - acc:SetTree<'a> -> - e:System.Collections.Generic.IEnumerator<'a> -> SetTree<'a> - val ofSeq : - comparer:System.Collections.Generic.IComparer<'a> -> - c:System.Collections.Generic.IEnumerable<'a> -> SetTree<'a> - val ofArray : - comparer:System.Collections.Generic.IComparer<'a> -> - l:'a [] -> SetTree<'a> - end - [] - type internal Set<'T,'ComparerTag - when 'ComparerTag :> - System.Collections.Generic.IComparer<'T>> = - class - interface System.Collections.IEnumerable - interface System.Collections.Generic.IEnumerable<'T> - interface System.Collections.Generic.ICollection<'T> - interface System.IComparable - new : comparer:System.Collections.Generic.IComparer<'T> * tree:SetTree<'T> -> - Set<'T,'ComparerTag> - static member - ( + ) : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> - Set<'T,'ComparerTag> - static member - ( - ) : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> - Set<'T,'ComparerTag> - static member - Compare : a:Set<'T,'ComparerTag> * b:Set<'T,'ComparerTag> -> int - static member Create : 'ComparerTag * seq<'T> -> Set<'T,'ComparerTag> - static member - Difference : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> - Set<'T,'ComparerTag> - static member Empty : 'ComparerTag -> Set<'T,'ComparerTag> - static member - Equality : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> bool - static member - Intersection : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> - Set<'T,'ComparerTag> - static member Singleton : 'ComparerTag * 'T -> Set<'T,'ComparerTag> - static member - Union : Set<'T,'ComparerTag> * Set<'T,'ComparerTag> -> - Set<'T,'ComparerTag> - member Add : 'T -> Set<'T,'ComparerTag> - member ComputeHashCode : unit -> int - member Contains : 'T -> bool - override Equals : obj -> bool - member Exists : predicate:('T -> bool) -> bool - member Filter : predicate:('T -> bool) -> Set<'T,'ComparerTag> - member Fold : ('T -> 'State -> 'State) -> 'State -> 'State - member ForAll : predicate:('T -> bool) -> bool - override GetHashCode : unit -> int - member IsSubsetOf : Set<'T,'ComparerTag> -> bool - member IsSupersetOf : Set<'T,'ComparerTag> -> bool - member Iterate : ('T -> unit) -> unit - member - Partition : predicate:('T -> bool) -> - Set<'T,'ComparerTag> * Set<'T,'ComparerTag> - member Remove : 'T -> Set<'T,'ComparerTag> - member ToArray : unit -> 'T [] - member ToList : unit -> 'T list - member Choose : 'T - member Comparer : System.Collections.Generic.IComparer<'T> - member Count : int - member IsEmpty : bool - member MaximumElement : 'T - member MinimumElement : 'T - member Tree : SetTree<'T> - end - [] - type internal MapTree<'Key,'Value> = - class - new : k:'Key * v:'Value -> MapTree<'Key,'Value> - member Key : 'Key - member Value : 'Value - end - [] - type internal MapTreeNode<'Key,'Value> = - class - inherit MapTree<'Key,'Value> - new : k:'Key * v:'Value * left:MapTree<'Key,'Value> * - right:MapTree<'Key,'Value> * h:int -> MapTreeNode<'Key,'Value> - member Height : int - member Left : MapTree<'Key,'Value> - member Right : MapTree<'Key,'Value> - end - module MapTree = begin - val empty : 'a when 'a : null - val inline isEmpty : m:MapTree<'Key,'Value> -> bool - val sizeAux : acc:int -> m:MapTree<'Key,'Value> -> int - val size : x:MapTree<'a,'b> -> int - val inline height : m:MapTree<'Key,'Value> -> int - val mk : - l:MapTree<'Key,'Value> -> - k:'Key -> v:'Value -> r:MapTree<'Key,'Value> -> MapTree<'Key,'Value> - val inline private asNode : - value:MapTree<'Key,'Value> -> MapTreeNode<'Key,'Value> - val rebalance : - t1:MapTree<'Key,'Value> -> - k:'Key -> v:'Value -> t2:MapTree<'Key,'Value> -> MapTree<'Key,'Value> - val add : - comparer:System.Collections.Generic.IComparer<'Key> -> - k:'Key -> v:'Value -> m:MapTree<'Key,'Value> -> MapTree<'Key,'Value> - val indexNotFound : unit -> 'a - val tryGetValue : - comparer:System.Collections.Generic.IComparer<'Key> -> - k:'Key -> v:byref<'Value> -> m:MapTree<'Key,'Value> -> bool - val find : - comparer:System.Collections.Generic.IComparer<'Key> -> - k:'Key -> m:MapTree<'Key,'Value> -> 'Value - val tryFind : - comparer:System.Collections.Generic.IComparer<'Key> -> - k:'Key -> m:MapTree<'Key,'Value> -> 'Value option - val partition1 : - comparer:System.Collections.Generic.IComparer<'Key> -> - f:OptimizedClosures.FSharpFunc<'Key,'a,bool> -> - k:'Key -> - v:'a -> - acc1:MapTree<'Key,'a> * acc2:MapTree<'Key,'a> -> - MapTree<'Key,'a> * MapTree<'Key,'a> - val partitionAux : - comparer:System.Collections.Generic.IComparer<'Key> -> - f:OptimizedClosures.FSharpFunc<'Key,'Value,bool> -> - m:MapTree<'Key,'Value> -> - MapTree<'Key,'Value> * MapTree<'Key,'Value> -> - MapTree<'Key,'Value> * MapTree<'Key,'Value> - val partition : - comparer:System.Collections.Generic.IComparer<'Key> -> - f:('Key -> 'a -> bool) -> - m:MapTree<'Key,'a> -> MapTree<'Key,'a> * MapTree<'Key,'a> - val filter1 : - comparer:System.Collections.Generic.IComparer<'Key> -> - f:OptimizedClosures.FSharpFunc<'Key,'a,bool> -> - k:'Key -> v:'a -> acc:MapTree<'Key,'a> -> MapTree<'Key,'a> - val filterAux : - comparer:System.Collections.Generic.IComparer<'Key> -> - f:OptimizedClosures.FSharpFunc<'Key,'Value,bool> -> - m:MapTree<'Key,'Value> -> - acc:MapTree<'Key,'Value> -> MapTree<'Key,'Value> - val filter : - comparer:System.Collections.Generic.IComparer<'Key> -> - f:('Key -> 'a -> bool) -> m:MapTree<'Key,'a> -> MapTree<'Key,'a> - val spliceOutSuccessor : - m:MapTree<'Key,'Value> -> 'Key * 'Value * MapTree<'Key,'Value> - val remove : - comparer:System.Collections.Generic.IComparer<'Key> -> - k:'Key -> m:MapTree<'Key,'Value> -> MapTree<'Key,'Value> - val mem : - comparer:System.Collections.Generic.IComparer<'Key> -> - k:'Key -> m:MapTree<'Key,'Value> -> bool - val iterOpt : - f:OptimizedClosures.FSharpFunc<'Key,'Value,unit> -> - m:MapTree<'Key,'Value> -> unit - val iter : f:('a -> 'b -> unit) -> m:MapTree<'a,'b> -> unit - val tryPickOpt : - f:OptimizedClosures.FSharpFunc<'Key,'Value,'a option> -> - m:MapTree<'Key,'Value> -> 'a option - val tryPick : f:('a -> 'b -> 'c option) -> m:MapTree<'a,'b> -> 'c option - val existsOpt : - f:OptimizedClosures.FSharpFunc<'Key,'Value,bool> -> - m:MapTree<'Key,'Value> -> bool - val exists : f:('a -> 'b -> bool) -> m:MapTree<'a,'b> -> bool - val forallOpt : - f:OptimizedClosures.FSharpFunc<'Key,'Value,bool> -> - m:MapTree<'Key,'Value> -> bool - val forall : f:('a -> 'b -> bool) -> m:MapTree<'a,'b> -> bool - val map : - f:('Value -> 'Result) -> m:MapTree<'Key,'Value> -> MapTree<'Key,'Result> - val mapiOpt : - f:OptimizedClosures.FSharpFunc<'Key,'Value,'Result> -> - m:MapTree<'Key,'Value> -> MapTree<'Key,'Result> - val mapi : f:('a -> 'b -> 'c) -> m:MapTree<'a,'b> -> MapTree<'a,'c> - val foldBackOpt : - f:OptimizedClosures.FSharpFunc<'Key,'Value,'a,'a> -> - m:MapTree<'Key,'Value> -> x:'a -> 'a - val foldBack : f:('a -> 'b -> 'c -> 'c) -> m:MapTree<'a,'b> -> x:'c -> 'c - val foldSectionOpt : - comparer:System.Collections.Generic.IComparer<'Key> -> - lo:'Key -> - hi:'Key -> - f:OptimizedClosures.FSharpFunc<'Key,'Value,'a,'a> -> - m:MapTree<'Key,'Value> -> x:'a -> 'a - val foldSection : - comparer:System.Collections.Generic.IComparer<'Key> -> - lo:'Key -> - hi:'Key -> - f:('Key -> 'a -> 'b -> 'b) -> m:MapTree<'Key,'a> -> x:'b -> 'b - val foldMapOpt : - comparer:System.Collections.Generic.IComparer<'Key> -> - f:OptimizedClosures.FSharpFunc<'Key,'Value,'a,('b * 'a)> -> - m:MapTree<'Key,'Value> -> - z:'a -> acc:MapTree<'Key,'b> -> MapTree<'Key,'b> * 'a - val foldMap : - comparer:System.Collections.Generic.IComparer<'Key> -> - f:('Key -> 'Value -> 'a -> 'b * 'a) -> - m:MapTree<'Key,'Value> -> - z:'a -> acc:MapTree<'Key,'b> -> MapTree<'Key,'b> * 'a - val toList : m:MapTree<'a,'b> -> ('a * 'b) list - val toArray : m:MapTree<'a,'b> -> ('a * 'b) [] - val ofList : - comparer:System.Collections.Generic.IComparer<'a> -> - l:('a * 'b) list -> MapTree<'a,'b> - val mkFromEnumerator : - comparer:System.Collections.Generic.IComparer<'a> -> - acc:MapTree<'a,'b> -> - e:System.Collections.Generic.IEnumerator<'a * 'b> -> MapTree<'a,'b> - val ofSeq : - comparer:System.Collections.Generic.IComparer<'a> -> - c:seq<'a * 'b> -> MapTree<'a,'b> - val copyToArray : - s:MapTree<'a,'b> -> - arr:System.Collections.Generic.KeyValuePair<'a,'b> [] -> i:int -> unit - type MapIterator<'Key,'Value> = - class - new : s:MapTree<'Key,'Value> -> MapTree.MapIterator<'Key,'Value> - member MoveNext : unit -> bool - member Current : System.Collections.Generic.KeyValuePair<'Key,'Value> - end - val toSeq : - s:MapTree<'a,'b> -> - System.Collections.Generic.IEnumerator> - end - [] - type internal Map<'Key,'Value,'ComparerTag - when 'ComparerTag :> - System.Collections.Generic.IComparer<'Key>> = - class - interface System.IComparable - interface System.Collections.IEnumerable - interface - System.Collections.Generic.IEnumerable> - new : comparer:System.Collections.Generic.IComparer<'Key> * - tree:MapTree<'Key,'Value> -> Map<'Key,'Value,'ComparerTag> - static member - Create : 'ComparerTag * seq<'Key * 'Value> -> - Map<'Key,'Value,'ComparerTag> - static member Empty : 'ComparerTag -> Map<'Key,'Value,'ComparerTag> - static member - FromList : 'ComparerTag * ('Key * 'Value) list -> - Map<'Key,'Value,'ComparerTag> - member Add : 'Key * 'Value -> Map<'Key,'Value,'ComparerTag> - member ComputeHashCode : unit -> int - member ContainsKey : 'Key -> bool - override Equals : obj -> bool - member Exists : ('Key -> 'Value -> bool) -> bool - member Filter : ('Key -> 'Value -> bool) -> Map<'Key,'Value,'ComparerTag> - member First : ('Key -> 'Value -> 'T option) -> 'T option - member - Fold : folder:('Key -> 'Value -> 'State -> 'State) -> 'State -> 'State - member - FoldAndMap : ('Key -> 'Value -> 'State -> 'T * 'State) -> - 'State -> Map<'Key,'T,'ComparerTag> * 'State - member - FoldSection : 'Key -> - 'Key -> - ('Key -> 'Value -> 'State -> 'State) -> - 'State -> 'State - member ForAll : ('Key -> 'Value -> bool) -> bool - override GetHashCode : unit -> int - member Iterate : action:('Key -> 'Value -> unit) -> unit - member Map : mapping:('Key -> 'Value -> 'T) -> Map<'Key,'T,'ComparerTag> - member MapRange : mapping:('Value -> 'T) -> Map<'Key,'T,'ComparerTag> - member - Partition : ('Key -> 'Value -> bool) -> - Map<'Key,'Value,'ComparerTag> * - Map<'Key,'Value,'ComparerTag> - member Remove : 'Key -> Map<'Key,'Value,'ComparerTag> - member ToArray : unit -> ('Key * 'Value) [] - member ToList : unit -> ('Key * 'Value) list - member TryFind : 'Key -> 'Value option - member Comparer : System.Collections.Generic.IComparer<'Key> - member Count : int - member IsEmpty : bool - member Item : 'Key -> 'Value with get - member Tree : MapTree<'Key,'Value> - end - type internal Map<'Key,'Value> = - Map<'Key,'Value,System.Collections.Generic.IComparer<'Key>> - type internal Set<'T> = Set<'T,System.Collections.Generic.IComparer<'T>> - -namespace FSharp.Compiler.AbstractIL - module internal Diagnostics = begin - val mutable diagnosticsLog : System.IO.TextWriter option - val setDiagnosticsChannel : System.IO.TextWriter option -> unit - val dflushn : unit -> unit - val dflush : unit -> unit - val dprintn : string -> unit - val dprintf : Format<'a,System.IO.TextWriter,unit,unit> -> 'a - val dprintfn : Format<'a,System.IO.TextWriter,unit,unit> -> 'a - end - -namespace FSharp.Compiler.AbstractIL.Internal - module Library = begin - val ( >>>& ) : x:int32 -> n:int32 -> int32 - val notlazy : v:'a -> System.Lazy<'a> - val inline isNil : l:'a list -> bool - val inline isNilOrSingleton : l:'a list -> bool - val inline isSingleton : l:'a list -> bool - val inline isNonNull : x:'a -> bool when 'a : null - val inline nonNull : msg:string -> x:'a -> 'a when 'a : null - val inline ( === ) : x:'a -> y:'a -> bool when 'a : not struct - val LOH_SIZE_THRESHOLD_BYTES : int - val reportTime : (bool -> string -> unit) - [] - type InlineDelayInit<'T when 'T : not struct> = - struct - new : f:(unit -> 'T) -> InlineDelayInit<'T> - val mutable store: 'T - val mutable func: System.Func<'T> - member Value : 'T - end - val foldOn : p:('a -> 'b) -> f:('c -> 'b -> 'd) -> z:'c -> x:'a -> 'd - val notFound : unit -> 'a - module Order = begin - val orderBy : - p:('T -> 'U) -> System.Collections.Generic.IComparer<'T> - when 'U : comparison - val orderOn : - p:('T -> 'U) -> - pxOrder:System.Collections.Generic.IComparer<'U> -> - System.Collections.Generic.IComparer<'T> - val toFunction : - pxOrder:System.Collections.Generic.IComparer<'U> -> x:'U -> y:'U -> int - end - module Array = begin - val mapq : f:('a -> 'a) -> inp:'a [] -> 'a [] when 'a : not struct - val lengthsEqAndForall2 : - p:('a -> 'b -> bool) -> l1:'a [] -> l2:'b [] -> bool - val order : - eltOrder:System.Collections.Generic.IComparer<'T> -> - System.Collections.Generic.IComparer<'T array> - val existsOne : p:('a -> bool) -> l:'a [] -> bool - val existsTrue : arr:bool [] -> bool - val findFirstIndexWhereTrue : arr:'a [] -> p:('a -> bool) -> int - val revInPlace : array:'T [] -> unit - val mapAsync : mapping:('T -> Async<'U>) -> array:'T [] -> Async<'U []> - val replace : index:int -> value:'a -> array:'a [] -> 'a [] - val inline areEqual : xs:'T [] -> ys:'T [] -> bool when 'T : equality - val heads : array:'T [] -> 'T [] [] - val inline isSubArray : - subArray:'T [] -> wholeArray:'T [] -> index:int -> bool - when 'T : equality - val startsWith : prefix:'a [] -> whole:'a [] -> bool when 'a : equality - val endsWith : suffix:'a [] -> whole:'a [] -> bool when 'a : equality - end - module Option = begin - val mapFold : - f:('a -> 'b -> 'c * 'a) -> s:'a -> opt:'b option -> 'c option * 'a - val attempt : f:(unit -> 'T) -> 'T option - end - module List = begin - val sortWithOrder : - c:System.Collections.Generic.IComparer<'T> -> - elements:'T list -> 'T list - val splitAfter : n:int -> l:'a list -> 'a list * 'a list - val existsi : f:(int -> 'a -> bool) -> xs:'a list -> bool - val lengthsEqAndForall2 : - p:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool - val findi : n:int -> f:('a -> bool) -> l:'a list -> ('a * int) option - val splitChoose : - select:('a -> Choice<'b,'c>) -> l:'a list -> 'b list * 'c list - val checkq : l1:'a list -> l2:'a list -> bool when 'a : not struct - val mapq : f:('T -> 'T) -> inp:'T list -> 'T list when 'T : not struct - val frontAndBack : l:'a list -> 'a list * 'a - val tryRemove : f:('a -> bool) -> inp:'a list -> ('a * 'a list) option - val zip4 : - l1:'a list -> - l2:'b list -> l3:'c list -> l4:'d list -> ('a * 'b * 'c * 'd) list - val unzip4 : - l:('a * 'b * 'c * 'd) list -> 'a list * 'b list * 'c list * 'd list - val iter3 : - f:('a -> 'b -> 'c -> unit) -> - l1:'a list -> l2:'b list -> l3:'c list -> unit - val takeUntil : p:('a -> bool) -> l:'a list -> 'a list * 'a list - val order : - eltOrder:System.Collections.Generic.IComparer<'T> -> - System.Collections.Generic.IComparer<'T list> - val indexNotFound : unit -> 'a - val assoc : x:'a -> l:('a * 'b) list -> 'b when 'a : equality - val memAssoc : x:'a -> l:('a * 'b) list -> bool when 'a : equality - val memq : x:'a -> l:'a list -> bool when 'a : not struct - val mapNth : n:int -> f:('a -> 'a) -> xs:'a list -> 'a list - val count : pred:('a -> bool) -> xs:'a list -> int - val headAndTail : l:'a list -> 'a * 'a list - val mapHeadTail : - fhead:('a -> 'b) -> ftail:('a -> 'b) -> _arg1:'a list -> 'b list - val collectFold : - f:('a -> 'b -> 'c list * 'a) -> s:'a -> l:'b list -> 'c list * 'a - val collect2 : - f:('a -> 'b -> 'c list) -> xs:'a list -> ys:'b list -> 'c list - val toArraySquared : xss:'a list list -> 'a [] [] - val iterSquared : f:('a -> unit) -> xss:'a list list -> unit - val collectSquared : f:('a -> 'b list) -> xss:'a list list -> 'b list - val mapSquared : f:('a -> 'b) -> xss:'a list list -> 'b list list - val mapFoldSquared : - f:('a -> 'b -> 'c * 'a) -> z:'a -> xss:'b list list -> 'c list list * 'a - val forallSquared : f:('a -> bool) -> xss:'a list list -> bool - val mapiSquared : - f:(int -> int -> 'a -> 'b) -> xss:'a list list -> 'b list list - val existsSquared : f:('a -> bool) -> xss:'a list list -> bool - val mapiFoldSquared : - f:('a -> int * int * 'b -> 'c * 'a) -> - z:'a -> xss:'b list list -> 'c list list * 'a - val duplicates : xs:'T list -> 'T list when 'T : equality - val internal allEqual : xs:'T list -> bool when 'T : equality - end - module ResizeArray = begin - val chunkBySize : - chunkSize:int -> f:('t -> 'a) -> items:ResizeArray<'t> -> 'a [] [] - val mapToSmallArrayChunks : - f:('t -> 'a) -> inp:ResizeArray<'t> -> 'a [] [] - end - module ValueOptionInternal = begin - val inline ofOption : x:'a option -> 'a voption - val inline bind : f:('a -> 'b voption) -> x:'a voption -> 'b voption - end - type String with - member StartsWithOrdinal : value:string -> bool - type String with - member EndsWithOrdinal : value:string -> bool - module String = begin - val make : n:int -> c:char -> string - val get : str:string -> i:int -> char - val sub : s:string -> start:int -> len:int -> string - val contains : s:string -> c:char -> bool - val order : System.Collections.Generic.IComparer - val lowercase : s:string -> string - val uppercase : s:string -> string - val isLeadingIdentifierCharacterUpperCase : s:string -> bool - val capitalize : s:string -> string - val uncapitalize : s:string -> string - val dropPrefix : s:string -> t:string -> string - val dropSuffix : s:string -> t:string -> string - val inline toCharArray : str:string -> char [] - val lowerCaseFirstChar : str:string -> string - val extractTrailingIndex : str:string -> string * int option - val trim : value:string -> string - val split : - options:System.StringSplitOptions -> - separator:string [] -> value:string -> string [] - val ( |StartsWith|_| ) : pattern:string -> value:string -> unit option - val ( |Contains|_| ) : pattern:string -> value:string -> unit option - val getLines : str:string -> string [] - end - module Dictionary = begin - val inline newWithSize : - size:int -> System.Collections.Generic.Dictionary<'a,'b> - when 'a : equality - end - [] - type DictionaryExtensions = - class - new : unit -> DictionaryExtensions - [] - static member - BagAdd : dic:System.Collections.Generic.Dictionary<'key,'value list> * - key:'key * value:'value -> unit - [] - static member - BagExistsValueForKey : dic:System.Collections.Generic.Dictionary<'key, - 'value list> * - key:'key * f:('value -> bool) -> bool - end - module Lazy = begin - val force : x:System.Lazy<'T> -> 'T - end - type ExecutionToken - type CompilationThreadToken = - class - interface ExecutionToken - new : unit -> CompilationThreadToken - end - val RequireCompilationThread : _ctok:CompilationThreadToken -> unit - val DoesNotRequireCompilerThreadTokenAndCouldPossiblyBeMadeConcurrent : - _ctok:CompilationThreadToken -> unit - val AssumeCompilationThreadWithoutEvidence : unit -> CompilationThreadToken - type AnyCallerThreadToken = - class - interface ExecutionToken - new : unit -> AnyCallerThreadToken - end - val AnyCallerThread : AnyCallerThreadToken - type LockToken = - interface - inherit ExecutionToken - end - val AssumeLockWithoutEvidence : unit -> #LockToken - type Lock<'LockTokenType when 'LockTokenType :> LockToken> = - class - new : unit -> Lock<'LockTokenType> - member AcquireLock : f:('LockTokenType -> 'a) -> 'a - end - val getHole : r:'a option ref -> 'a - module Map = begin - val tryFindMulti : - k:'a -> map:Map<'a,'b list> -> 'b list when 'a : comparison - end - type ResultOrException<'TResult> = - | Result of 'TResult - | Exception of System.Exception - module ResultOrException = begin - val success : a:'a -> ResultOrException<'a> - val raze : b:exn -> ResultOrException<'a> - val ( |?> ) : - res:ResultOrException<'a> -> f:('a -> 'b) -> ResultOrException<'b> - val ForceRaise : res:ResultOrException<'a> -> 'a - val otherwise : - f:(unit -> ResultOrException<'a>) -> - x:ResultOrException<'a> -> ResultOrException<'a> - end - [] - type ValueOrCancelled<'TResult> = - | Value of 'TResult - | Cancelled of System.OperationCanceledException - [] - type Cancellable<'TResult> = - | Cancellable of - (System.Threading.CancellationToken -> ValueOrCancelled<'TResult>) - module Cancellable = begin - val run : - ct:System.Threading.CancellationToken -> - Cancellable<'a> -> ValueOrCancelled<'a> - val bind : - f:('a -> Cancellable<'b>) -> comp1:Cancellable<'a> -> Cancellable<'b> - val map : f:('a -> 'b) -> oper:Cancellable<'a> -> Cancellable<'b> - val ret : x:'a -> Cancellable<'a> - val fold : - f:('a -> 'b -> Cancellable<'a>) -> - acc:'a -> seq:seq<'b> -> Cancellable<'a> - val each : - f:('a -> Cancellable<'b>) -> seq:seq<'a> -> Cancellable<'b list> - val delay : f:(unit -> Cancellable<'T>) -> Cancellable<'T> - val runWithoutCancellation : comp:Cancellable<'a> -> 'a - val token : unit -> Cancellable - val canceled : unit -> Cancellable<'a> - val private catch : Cancellable<'a> -> Cancellable> - val tryFinally : - e:Cancellable<'a> -> compensation:(unit -> unit) -> Cancellable<'a> - val tryWith : - e:Cancellable<'a> -> handler:(exn -> Cancellable<'a>) -> Cancellable<'a> - end - type CancellableBuilder = - class - new : unit -> CancellableBuilder - member - Bind : e:Cancellable<'k> * k:('k -> Cancellable<'l>) -> - Cancellable<'l> - member - Combine : e1:Cancellable * e2:Cancellable<'h> -> Cancellable<'h> - member Delay : f:(unit -> Cancellable<'a>) -> Cancellable<'a> - member - For : es:seq<'f> * f:('f -> Cancellable<'g>) -> Cancellable<'g list> - member Return : v:'j -> Cancellable<'j> - member ReturnFrom : v:'i -> 'i - member - TryFinally : e:Cancellable<'b> * compensation:(unit -> unit) -> - Cancellable<'b> - member - TryWith : e:Cancellable<'e> * handler:(exn -> Cancellable<'e>) -> - Cancellable<'e> - member - Using : resource:'c * e:('c -> Cancellable<'d>) -> Cancellable<'d> - when 'c :> System.IDisposable - member Zero : unit -> Cancellable - end - val cancellable : CancellableBuilder - type Eventually<'T> = - | Done of 'T - | NotYetDone of (CompilationThreadToken -> Eventually<'T>) - module Eventually = begin - val box : e:Eventually<'a> -> Eventually - val forceWhile : - ctok:CompilationThreadToken -> - check:(unit -> bool) -> e:Eventually<'a> -> 'a option - val force : ctok:CompilationThreadToken -> e:Eventually<'a> -> 'a - val repeatedlyProgressUntilDoneOrTimeShareOverOrCanceled : - timeShareInMilliseconds:int64 -> - ct:System.Threading.CancellationToken -> - runner:(CompilationThreadToken -> - (#CompilationThreadToken -> Eventually<'b>) -> - Eventually<'b>) -> e:Eventually<'b> -> Eventually<'b> - val forceAsync : - runner:((CompilationThreadToken -> Eventually<'T>) -> - Async>) -> e:Eventually<'T> -> Async<'T option> - val bind : k:('a -> Eventually<'b>) -> e:Eventually<'a> -> Eventually<'b> - val fold : - f:('a -> 'b -> Eventually<'a>) -> - acc:'a -> seq:seq<'b> -> Eventually<'a> - val catch : e:Eventually<'a> -> Eventually> - val delay : f:(unit -> Eventually<'T>) -> Eventually<'T> - val tryFinally : - e:Eventually<'a> -> compensation:(unit -> unit) -> Eventually<'a> - val tryWith : - e:Eventually<'a> -> - handler:(System.Exception -> Eventually<'a>) -> Eventually<'a> - val token : Eventually - end - [] - type EventuallyBuilder = - class - new : unit -> EventuallyBuilder - member - Bind : e:Eventually<'g> * k:('g -> Eventually<'h>) -> Eventually<'h> - member - Combine : e1:Eventually * e2:Eventually<'d> -> Eventually<'d> - member Delay : f:(unit -> Eventually<'a>) -> Eventually<'a> - member Return : v:'f -> Eventually<'f> - member ReturnFrom : v:'e -> 'e - member - TryFinally : e:Eventually<'b> * compensation:(unit -> unit) -> - Eventually<'b> - member - TryWith : e:Eventually<'c> * - handler:(System.Exception -> Eventually<'c>) -> - Eventually<'c> - member Zero : unit -> Eventually - end - val eventually : EventuallyBuilder - type UniqueStampGenerator<'T when 'T : equality> = - class - new : unit -> UniqueStampGenerator<'T> - member Encode : str:'T -> int - member Table : System.Collections.Generic.ICollection<'T> - end - type MemoizationTable<'T,'U> = - class - new : compute:('T -> 'U) * - keyComparer:System.Collections.Generic.IEqualityComparer<'T> * - ?canMemoize:('T -> bool) -> MemoizationTable<'T,'U> - member Apply : x:'T -> 'U - end - exception UndefinedException - type LazyWithContextFailure = - class - new : exn:exn -> LazyWithContextFailure - member Exception : exn - static member Undefined : LazyWithContextFailure - end - [] - type LazyWithContext<'T,'ctxt> = - { mutable value: 'T - mutable funcOrException: obj - findOriginalException: exn -> exn } - with - static member - Create : f:('ctxt -> 'T) * findOriginalException:(exn -> exn) -> - LazyWithContext<'T,'ctxt> - static member NotLazy : x:'T -> LazyWithContext<'T,'ctxt> - member Force : ctxt:'ctxt -> 'T - member UnsynchronizedForce : ctxt:'ctxt -> 'T - member IsDelayed : bool - member IsForced : bool - end - module Tables = begin - val memoize : f:('a -> 'b) -> ('a -> 'b) when 'a : equality - end - type IPartialEqualityComparer<'T> = - interface - inherit System.Collections.Generic.IEqualityComparer<'T> - abstract member InEqualityRelation : 'T -> bool - end - module IPartialEqualityComparer = begin - val On : - f:('a -> 'b) -> - c:IPartialEqualityComparer<'b> -> IPartialEqualityComparer<'a> - [] - type private WrapType<'T> = | Wrap of 'T - val partialDistinctBy : - per:IPartialEqualityComparer<'T> -> seq:'T list -> 'T list - end - type NameMap<'T> = Map - type NameMultiMap<'T> = NameMap<'T list> - type MultiMap<'T,'U when 'T : comparison> = Map<'T,'U list> - module NameMap = begin - val empty : Map<'a,'b> when 'a : comparison - val range : m:Map<'a,'b> -> 'b list when 'a : comparison - val foldBack : f:(string -> 'T -> 'a -> 'a) -> m:NameMap<'T> -> z:'a -> 'a - val forall : - f:('a -> 'b -> bool) -> m:Map<'a,'b> -> bool when 'a : comparison - val exists : - f:('a -> 'b -> bool) -> m:Map<'a,'b> -> bool when 'a : comparison - val ofKeyedList : - f:('a -> 'b) -> l:'a list -> Map<'b,'a> when 'b : comparison - val ofList : l:(string * 'T) list -> NameMap<'T> - val ofSeq : l:seq -> NameMap<'T> - val toList : l:NameMap<'T> -> (string * 'T) list - val layer : m1:NameMap<'T> -> m2:Map -> Map - val layerAdditive : - addf:('a list -> 'b -> 'a list) -> - m1:Map<'c,'b> -> m2:Map<'c,'a list> -> Map<'c,'a list> - when 'c : comparison - val union : - unionf:(seq<'a> -> 'b) -> ms:seq> -> Map - val subfold2 : - errf:('a -> 'b -> 'c) -> - f:('a -> 'd -> 'b -> 'c -> 'c) -> - m1:Map<'a,'d> -> m2:Map<'a,'b> -> acc:'c -> 'c when 'a : comparison - val suball2 : - errf:('a -> 'b -> bool) -> - p:('c -> 'b -> bool) -> m1:Map<'a,'c> -> m2:Map<'a,'b> -> bool - when 'a : comparison - val mapFold : - f:('a -> string -> 'T -> 'b * 'a) -> - s:'a -> l:NameMap<'T> -> Map * 'a - val foldBackRange : f:('T -> 'a -> 'a) -> l:NameMap<'T> -> acc:'a -> 'a - val filterRange : f:('T -> bool) -> l:NameMap<'T> -> Map - val mapFilter : f:('T -> 'a option) -> l:NameMap<'T> -> Map - val map : f:('T -> 'a) -> l:NameMap<'T> -> Map - val iter : f:('T -> unit) -> l:NameMap<'T> -> unit - val partition : - f:('T -> bool) -> l:NameMap<'T> -> Map * Map - val mem : v:string -> m:NameMap<'T> -> bool - val find : v:string -> m:NameMap<'T> -> 'T - val tryFind : v:string -> m:NameMap<'T> -> 'T option - val add : v:string -> x:'T -> m:NameMap<'T> -> Map - val isEmpty : m:NameMap<'T> -> bool - val existsInRange : - p:('a -> bool) -> m:Map<'b,'a> -> bool when 'b : comparison - val tryFindInRange : - p:('a -> bool) -> m:Map<'b,'a> -> 'a option when 'b : comparison - end - module NameMultiMap = begin - val existsInRange : f:('T -> bool) -> m:NameMultiMap<'T> -> bool - val find : v:string -> m:NameMultiMap<'T> -> 'T list - val add : v:string -> x:'T -> m:NameMultiMap<'T> -> Map - val range : m:NameMultiMap<'T> -> 'T list - val rangeReversingEachBucket : m:NameMultiMap<'T> -> 'T list - val chooseRange : f:('T -> 'a option) -> m:NameMultiMap<'T> -> 'a list - val map : f:('T -> 'a) -> m:NameMultiMap<'T> -> Map - val empty : NameMultiMap<'T> - val initBy : f:('T -> string) -> xs:seq<'T> -> NameMultiMap<'T> - val ofList : xs:(string * 'T) list -> NameMultiMap<'T> - end - module MultiMap = begin - val existsInRange : - f:('a -> bool) -> m:MultiMap<'b,'a> -> bool when 'b : comparison - val find : v:'a -> m:MultiMap<'a,'b> -> 'b list when 'a : comparison - val add : - v:'a -> x:'b -> m:MultiMap<'a,'b> -> Map<'a,'b list> - when 'a : comparison - val range : m:MultiMap<'a,'b> -> 'b list when 'a : comparison - val empty : MultiMap<'a,'b> when 'a : comparison - val initBy : - f:('a -> 'b) -> xs:seq<'a> -> MultiMap<'b,'a> when 'b : comparison - end - type LayeredMap<'Key,'Value when 'Key : comparison> = Map<'Key,'Value> - type Map<'Key,'Value when 'Key : comparison> with - static member Empty : Map<'Key,'Value> when 'Key : comparison - type Map<'Key,'Value when 'Key : comparison> with - member Values : 'Value list - type Map<'Key,'Value when 'Key : comparison> with - member - AddAndMarkAsCollapsible : kvs:System.Collections.Generic.KeyValuePair<'Key, - 'Value> [] -> - Map<'Key,'Value> when 'Key : comparison - type Map<'Key,'Value when 'Key : comparison> with - member - LinearTryModifyThenLaterFlatten : key:'Key * f:('Value option -> 'Value) -> - Map<'Key,'Value> - when 'Key : comparison - type Map<'Key,'Value when 'Key : comparison> with - member MarkAsCollapsible : unit -> Map<'Key,'Value> when 'Key : comparison - [] - type LayeredMultiMap<'Key,'Value when 'Key : comparison> = - class - new : contents:LayeredMap<'Key,'Value list> -> - LayeredMultiMap<'Key,'Value> - member Add : k:'Key * v:'Value -> LayeredMultiMap<'Key,'Value> - member - AddAndMarkAsCollapsible : kvs:System.Collections.Generic.KeyValuePair<'Key, - 'Value> [] -> - LayeredMultiMap<'Key,'Value> - member MarkAsCollapsible : unit -> LayeredMultiMap<'Key,'Value> - member TryFind : k:'Key -> 'Value list option - member TryGetValue : k:'Key -> bool * 'Value list - member Item : k:'Key -> 'Value list with get - member Values : 'Value list - static member Empty : LayeredMultiMap<'Key,'Value> - end - module Shim = begin - type IFileSystem = - interface - abstract member - AssemblyLoad : assemblyName:System.Reflection.AssemblyName -> - System.Reflection.Assembly - abstract member - AssemblyLoadFrom : fileName:string -> System.Reflection.Assembly - abstract member FileDelete : fileName:string -> unit - abstract member - FileStreamCreateShim : fileName:string -> System.IO.Stream - abstract member - FileStreamReadShim : fileName:string -> System.IO.Stream - abstract member - FileStreamWriteExistingShim : fileName:string -> System.IO.Stream - abstract member GetFullPathShim : fileName:string -> string - abstract member - GetLastWriteTimeShim : fileName:string -> System.DateTime - abstract member GetTempPathShim : unit -> string - abstract member IsInvalidPathShim : filename:string -> bool - abstract member IsPathRootedShim : path:string -> bool - abstract member IsStableFileHeuristic : fileName:string -> bool - abstract member ReadAllBytesShim : fileName:string -> byte [] - abstract member SafeExists : fileName:string -> bool - end - type DefaultFileSystem = - class - interface IFileSystem - new : unit -> DefaultFileSystem - end - val mutable FileSystem : IFileSystem - val private retryDelayMilliseconds : int - val private numRetries : int - val private getReader : - filename:string * codePage:int option * retryLocked:bool -> - System.IO.StreamReader - type File with - static member - ReadBinaryChunk : fileName:string * start:int * len:int -> byte [] - type File with - static member - OpenReaderAndRetry : filename:string * codepage:int option * - retryLocked:bool -> System.IO.StreamReader - end - end - -namespace Internal.Utilities - module internal Filename = begin - exception IllegalFileNameChar of string * char - val checkPathForIllegalChars : (string -> unit) - val checkSuffix : string -> string -> bool - val hasExtensionWithValidate : validate:bool -> s:string -> bool - val hasExtension : string -> bool - val chopExtension : string -> string - val directoryName : string -> string - val fileNameOfPath : string -> string - val fileNameWithoutExtensionWithValidate : bool -> string -> string - val fileNameWithoutExtension : string -> string - val trimQuotes : string -> string - end - -namespace FSharp.Compiler.AbstractIL.Internal - type internal Zmap<'Key,'T> = - Internal.Utilities.Collections.Tagged.Map<'Key,'T> - module internal Zmap = begin - val empty : - System.Collections.Generic.IComparer<'Key> -> - Internal.Utilities.Collections.Tagged.Map<'Key,'T, - System.Collections.Generic.IComparer<'Key>> - val add : - 'Key -> - 'T -> - Zmap<'Key,'T> -> - Internal.Utilities.Collections.Tagged.Map<'Key,'T, - System.Collections.Generic.IComparer<'Key>> - val find : 'Key -> Zmap<'Key,'T> -> 'T - val tryFind : 'Key -> Zmap<'Key,'T> -> 'T option - val remove : - 'Key -> - Zmap<'Key,'T> -> - Internal.Utilities.Collections.Tagged.Map<'Key,'T, - System.Collections.Generic.IComparer<'Key>> - val mem : 'Key -> Zmap<'Key,'T> -> bool - val iter : action:('T -> 'U -> unit) -> Zmap<'T,'U> -> unit - val first : ('Key -> 'T -> bool) -> Zmap<'Key,'T> -> ('Key * 'T) option - val exists : ('Key -> 'T -> bool) -> Zmap<'Key,'T> -> bool - val forall : ('Key -> 'T -> bool) -> Zmap<'Key,'T> -> bool - val map : - mapping:('T -> 'U) -> - Zmap<'Key,'T> -> - Internal.Utilities.Collections.Tagged.Map<'Key,'U, - System.Collections.Generic.IComparer<'Key>> - val mapi : - mapping:('Key -> 'T -> 'U) -> - Zmap<'Key,'T> -> - Internal.Utilities.Collections.Tagged.Map<'Key,'U, - System.Collections.Generic.IComparer<'Key>> - val fold : ('Key -> 'T -> 'U -> 'U) -> Zmap<'Key,'T> -> 'U -> 'U - val toList : Zmap<'Key,'T> -> ('Key * 'T) list - val foldSection : - 'Key -> 'Key -> ('Key -> 'T -> 'U -> 'U) -> Zmap<'Key,'T> -> 'U -> 'U - val isEmpty : Zmap<'Key,'T> -> bool - val foldMap : - ('State -> 'Key -> 'T -> 'State * 'U) -> - 'State -> - Zmap<'Key,'T> -> - 'State * - Internal.Utilities.Collections.Tagged.Map<'Key,'U, - System.Collections.Generic.IComparer<'Key>> - val choose : ('Key -> 'T -> 'U option) -> Zmap<'Key,'T> -> 'U option - val chooseL : ('Key -> 'T -> 'U option) -> Zmap<'Key,'T> -> 'U list - val ofList : - System.Collections.Generic.IComparer<'Key> -> - ('Key * 'T) list -> - Internal.Utilities.Collections.Tagged.Map<'Key,'T, - System.Collections.Generic.IComparer<'Key>> - val keys : Zmap<'Key,'T> -> 'Key list - val values : Zmap<'Key,'T> -> 'T list - val memberOf : Zmap<'Key,'T> -> 'Key -> bool - end - -namespace FSharp.Compiler.AbstractIL.Internal - type internal Zset<'T> = Internal.Utilities.Collections.Tagged.Set<'T> - module internal Zset = begin - val empty : - System.Collections.Generic.IComparer<'T> -> - Internal.Utilities.Collections.Tagged.Set<'T, - System.Collections.Generic.IComparer<'T>> - val isEmpty : Zset<'T> -> bool - val contains : 'T -> Zset<'T> -> bool - val add : - 'T -> - Zset<'T> -> - Internal.Utilities.Collections.Tagged.Set<'T, - System.Collections.Generic.IComparer<'T>> - val addList : - 'T list -> - Internal.Utilities.Collections.Tagged.Set<'T, - System.Collections.Generic.IComparer<'T>> -> - Internal.Utilities.Collections.Tagged.Set<'T, - System.Collections.Generic.IComparer<'T>> - val singleton : - System.Collections.Generic.IComparer<'T> -> - 'T -> - Internal.Utilities.Collections.Tagged.Set<'T, - System.Collections.Generic.IComparer<'T>> - val remove : - 'T -> - Zset<'T> -> - Internal.Utilities.Collections.Tagged.Set<'T, - System.Collections.Generic.IComparer<'T>> - val fold : ('T -> 'State -> 'State) -> Zset<'T> -> 'State -> 'State - val iter : ('T -> unit) -> Zset<'T> -> unit - val forall : predicate:('T -> bool) -> Zset<'T> -> bool - val count : Zset<'T> -> int - val exists : predicate:('T -> bool) -> Zset<'T> -> bool - val subset : Zset<'T> -> Zset<'T> -> bool - val equal : Zset<'T> -> Zset<'T> -> bool - val elements : Zset<'T> -> 'T list - val filter : - predicate:('T -> bool) -> - Zset<'T> -> - Internal.Utilities.Collections.Tagged.Set<'T, - System.Collections.Generic.IComparer<'T>> - val union : - Zset<'T> -> - Zset<'T> -> - Internal.Utilities.Collections.Tagged.Set<'T, - System.Collections.Generic.IComparer<'T>> - val inter : - Zset<'T> -> - Zset<'T> -> - Internal.Utilities.Collections.Tagged.Set<'T, - System.Collections.Generic.IComparer<'T>> - val diff : - Zset<'T> -> - Zset<'T> -> - Internal.Utilities.Collections.Tagged.Set<'T, - System.Collections.Generic.IComparer<'T>> - val memberOf : Zset<'T> -> 'T -> bool - end - -namespace FSharp.Compiler.AbstractIL.Internal - module Utils = begin - val runningOnMono : bool - end - module internal Bytes = begin - val b0 : n:int -> int - val b1 : n:int -> int - val b2 : n:int -> int - val b3 : n:int -> int - val dWw1 : n:int64 -> int32 - val dWw0 : n:int64 -> int32 - val get : byte [] -> int -> int32 - val zeroCreate : int -> byte [] - val sub : b:byte [] -> s:int -> l:int -> byte [] - val blit : byte [] -> int -> byte [] -> int -> int -> unit - val ofInt32Array : int [] -> byte [] - val stringAsUtf8NullTerminated : string -> byte [] - val stringAsUnicodeNullTerminated : string -> byte [] - end - [] - type ByteMemory = - class - new : unit -> ByteMemory - static member FromArray : bytes:byte [] -> ByteMemory - static member - FromArray : bytes:byte [] * offset:int * length:int -> ByteMemory - static member - FromFile : path:string * System.IO.FileAccess * ?canShadowCopy:bool -> - ByteMemory - static member - FromMemoryMappedFile : System.IO.MemoryMappedFiles.MemoryMappedFile -> - ByteMemory - static member - FromUnsafePointer : addr:nativeint * length:int * holder:obj -> - ByteMemory - member AsReadOnly : unit -> ReadOnlyByteMemory - abstract member AsReadOnlyStream : unit -> System.IO.Stream - abstract member AsStream : unit -> System.IO.Stream - abstract member - Copy : srcOffset:int * dest:byte [] * destOffset:int * count:int -> unit - abstract member CopyTo : System.IO.Stream -> unit - abstract member ReadBytes : pos:int * count:int -> byte [] - abstract member ReadInt32 : pos:int -> int - abstract member ReadUInt16 : pos:int -> uint16 - abstract member ReadUtf8String : pos:int * count:int -> string - abstract member Slice : pos:int * count:int -> ByteMemory - abstract member ToArray : unit -> byte [] - abstract member Item : int -> byte with get - abstract member Length : int - static member Empty : ByteMemory - end - [] - type ByteArrayMemory = - class - inherit ByteMemory - new : bytes:byte [] * offset:int * length:int -> ByteArrayMemory - override AsReadOnlyStream : unit -> System.IO.Stream - override AsStream : unit -> System.IO.Stream - override - Copy : srcOffset:int * dest:byte [] * destOffset:int * count:int -> unit - override CopyTo : stream:System.IO.Stream -> unit - override ReadBytes : pos:int * count:int -> byte [] - override ReadInt32 : pos:int -> int - override ReadUInt16 : pos:int -> uint16 - override ReadUtf8String : pos:int * count:int -> string - override Slice : pos:int * count:int -> ByteMemory - override ToArray : unit -> byte [] - override Item : i:int -> byte with get - override Length : int - end - [] - type SafeUnmanagedMemoryStream = - class - inherit System.IO.UnmanagedMemoryStream - new : addr:nativeptr * length:int64 * capacity:int64 * - access:System.IO.FileAccess * holder:obj -> - SafeUnmanagedMemoryStream - new : addr:nativeptr * length:int64 * holder:obj -> - SafeUnmanagedMemoryStream - val mutable private holder: obj - val mutable private isDisposed: bool - override Dispose : disposing:bool -> unit - end - type RawByteMemory = - class - inherit ByteMemory - new : addr:nativeptr * length:int * holder:obj -> RawByteMemory - override AsReadOnlyStream : unit -> System.IO.Stream - override AsStream : unit -> System.IO.Stream - override - Copy : srcOffset:int * dest:byte [] * destOffset:int * count:int -> unit - override CopyTo : stream:System.IO.Stream -> unit - override ReadBytes : pos:int * count:int -> byte [] - override ReadInt32 : pos:int -> int - override ReadUInt16 : pos:int -> uint16 - override ReadUtf8String : pos:int * count:int -> string - override Slice : pos:int * count:int -> ByteMemory - override ToArray : unit -> byte [] - override Item : i:int -> byte with get - override Length : int - end - [] - type ReadOnlyByteMemory = - struct - new : ByteMemory -> ReadOnlyByteMemory - member AsStream : unit -> System.IO.Stream - member - Copy : srcOffset:int * dest:byte [] * destOffset:int * count:int -> unit - member CopyTo : System.IO.Stream -> unit - member ReadBytes : pos:int * count:int -> byte [] - member ReadInt32 : pos:int -> int - member ReadUInt16 : pos:int -> uint16 - member ReadUtf8String : pos:int * count:int -> string - member Slice : pos:int * count:int -> ReadOnlyByteMemory - member ToArray : unit -> byte [] - member Item : int -> byte with get - member Length : int - member Underlying : ByteMemory - end - module MemoryMappedFileExtensions = begin - type MemoryMappedFile with - static member - TryFromByteMemory : bytes:ReadOnlyByteMemory -> - System.IO.MemoryMappedFiles.MemoryMappedFile option - end - [] - type internal ByteStream = - { bytes: ReadOnlyByteMemory - mutable pos: int - max: int } - with - static member - FromBytes : ReadOnlyByteMemory * start:int * length:int -> ByteStream - member ReadByte : unit -> byte - member ReadBytes : int -> ReadOnlyByteMemory - member ReadUtf8String : int -> string - member Position : int - end - [] - type internal ByteBuffer = - { mutable bbArray: byte [] - mutable bbCurrent: int } - with - static member Create : int -> ByteBuffer - member Close : unit -> byte [] - member EmitBoolAsByte : bool -> unit - member EmitByte : byte -> unit - member EmitByteMemory : ReadOnlyByteMemory -> unit - member EmitBytes : byte [] -> unit - member EmitInt32 : int -> unit - member EmitInt32AsUInt16 : int -> unit - member EmitInt64 : int64 -> unit - member EmitIntAsByte : int -> unit - member EmitIntsAsBytes : int [] -> unit - member EmitUInt16 : uint16 -> unit - member Ensure : newSize:int -> unit - member FixupInt32 : pos:int -> value:int -> unit - member Position : int - end - [] - type ByteStorage = - class - new : getByteMemory:(unit -> ReadOnlyByteMemory) -> ByteStorage - static member FromByteArray : byte [] -> ByteStorage - static member - FromByteArrayAndCopy : byte [] * useBackingMemoryMappedFile:bool -> - ByteStorage - static member FromByteMemory : ReadOnlyByteMemory -> ByteStorage - static member - FromByteMemoryAndCopy : ReadOnlyByteMemory * - useBackingMemoryMappedFile:bool -> ByteStorage - member GetByteMemory : unit -> ReadOnlyByteMemory - end - -namespace FSharp.Compiler - module internal XmlAdapters = begin - val s_escapeChars : char [] - val getEscapeSequence : c:char -> string - val escape : str:string -> string - end - -namespace Internal.Utilities.Collections - [] - type internal ValueStrength<'T when 'T : not struct> = - | Strong of 'T - | Weak of System.WeakReference<'T> - type internal AgedLookup<'Token,'Key,'Value when 'Value : not struct> = - class - new : keepStrongly:int * areSimilar:('Key * 'Key -> bool) * - ?requiredToKeep:('Value -> bool) * ?keepMax:int -> - AgedLookup<'Token,'Key,'Value> - member Clear : 'Token -> unit - member Put : 'Token * 'Key * 'Value -> unit - member Remove : 'Token * key:'Key -> unit - member Resize : 'Token * newKeepStrongly:int * ?newKeepMax:int -> unit - member TryGet : 'Token * key:'Key -> 'Value option - member TryGetKeyValue : 'Token * key:'Key -> ('Key * 'Value) option - member TryPeekKeyValue : 'Token * key:'Key -> ('Key * 'Value) option - end - type internal MruCache<'Token,'Key,'Value when 'Value : not struct> = - class - new : keepStrongly:int * areSame:('Key * 'Key -> bool) * - ?isStillValid:('Key * 'Value -> bool) * - ?areSimilar:('Key * 'Key -> bool) * ?requiredToKeep:('Value -> bool) * - ?keepMax:int -> MruCache<'Token,'Key,'Value> - member Clear : 'Token -> unit - member ContainsSimilarKey : 'Token * key:'Key -> bool - member RemoveAnySimilar : 'Token * key:'Key -> unit - member Resize : 'Token * newKeepStrongly:int * ?newKeepMax:int -> unit - member Set : 'Token * key:'Key * value:'Value -> unit - member TryGet : 'Token * key:'Key -> 'Value option - member TryGetAny : 'Token * key:'Key -> 'Value option - member TryGetSimilar : 'Token * key:'Key -> 'Value option - member TryGetSimilarAny : 'Token * key:'Key -> 'Value option - end - -namespace Internal.Utilities - type internal QueueList<'T> = - class - interface System.Collections.IEnumerable - interface System.Collections.Generic.IEnumerable<'T> - new : xs:'T list -> QueueList<'T> - new : firstElementsIn:'T list * lastElementsRevIn:'T list * - numLastElementsIn:int -> QueueList<'T> - member Append : ys:seq<'T> -> QueueList<'T> - member AppendOne : y:'T -> QueueList<'T> - member ToList : unit -> 'T list - member FirstElements : 'T list - member LastElements : 'T list - static member Empty : QueueList<'T> - end - module internal QueueList = begin - val empty<'T> : QueueList<'T> - val ofSeq : x:seq<'a> -> QueueList<'a> - val iter : f:('a -> unit) -> x:QueueList<'a> -> unit - val map : f:('a -> 'b) -> x:QueueList<'a> -> QueueList<'b> - val exists : f:('a -> bool) -> x:QueueList<'a> -> bool - val filter : f:('a -> bool) -> x:QueueList<'a> -> QueueList<'a> - val foldBack : f:('a -> 'b -> 'b) -> x:QueueList<'a> -> acc:'b -> 'b - val forall : f:('a -> bool) -> x:QueueList<'a> -> bool - val ofList : x:'a list -> QueueList<'a> - val toList : x:QueueList<'a> -> 'a list - val tryFind : f:('a -> bool) -> x:QueueList<'a> -> 'a option - val one : x:'a -> QueueList<'a> - val appendOne : x:QueueList<'a> -> y:'a -> QueueList<'a> - val append : x:QueueList<'a> -> ys:QueueList<'a> -> QueueList<'a> - end - -namespace FSharp.Compiler - module internal Lib = begin - val debug : bool - val verbose : bool - val mutable progress : bool - val mutable tracking : bool - val condition : s:string -> bool - val GetEnvInteger : e:string -> dflt:int -> int - val dispose : x:System.IDisposable -> unit - module Bits = begin - val b0 : n:int -> int - val b1 : n:int -> int - val b2 : n:int -> int - val b3 : n:int -> int - val pown32 : n:int -> int - val pown64 : n:int -> int64 - val mask32 : m:int32 -> n:int -> int - val mask64 : m:int32 -> n:int -> int64 - end - module Filename = begin - val fullpath : cwd:string -> nm:string -> string - val hasSuffixCaseInsensitive : suffix:string -> filename:string -> bool - val isDll : file:string -> bool - end - module Bool = begin - val order : System.Collections.Generic.IComparer - end - module Int32 = begin - val order : System.Collections.Generic.IComparer - end - module Int64 = begin - val order : System.Collections.Generic.IComparer - end - module Pair = begin - val order : - compare1:System.Collections.Generic.IComparer<'T1> * - compare2:System.Collections.Generic.IComparer<'T2> -> - System.Collections.Generic.IComparer<'T1 * 'T2> - end - type NameSet = AbstractIL.Internal.Zset - module NameSet = begin - val ofList : l:string list -> NameSet - end - module NameMap = begin - val domain : m:Map -> AbstractIL.Internal.Zset - val domainL : m:Map -> string list - end - module Check = begin - val NotNone : argName:string -> arg:'T option -> 'T - val ArgumentNotNull : arg:'a -> argName:string -> unit - val ArrayArgumentNotNullOrEmpty : arr:'T [] -> argName:string -> unit - val StringArgumentNotNullOrEmpty : s:string -> argName:string -> unit - end - type IntMap<'T> = AbstractIL.Internal.Zmap - module IntMap = begin - val empty : unit -> AbstractIL.Internal.Zmap - val add : - k:int -> v:'T -> t:IntMap<'T> -> AbstractIL.Internal.Zmap - val find : k:int -> t:IntMap<'T> -> 'T - val tryFind : k:int -> t:IntMap<'T> -> 'T option - val remove : k:int -> t:IntMap<'T> -> AbstractIL.Internal.Zmap - val mem : k:int -> t:IntMap<'T> -> bool - val iter : f:(int -> 'T -> unit) -> t:IntMap<'T> -> unit - val map : f:('T -> 'a) -> t:IntMap<'T> -> AbstractIL.Internal.Zmap - val fold : f:(int -> 'T -> 'a -> 'a) -> t:IntMap<'T> -> z:'a -> 'a - end - module ListAssoc = begin - val find : f:('a -> 'b -> bool) -> x:'a -> l:('b * 'c) list -> 'c - val tryFind : - f:('key -> 'key -> bool) -> - x:'key -> l:('key * 'value) list -> 'value option - end - module ListSet = begin - val inline contains : f:('a -> 'b -> bool) -> x:'a -> l:'b list -> bool - val insert : f:('a -> 'a -> bool) -> x:'a -> l:'a list -> 'a list - val unionFavourRight : - f:('a -> 'a -> bool) -> l1:'a list -> l2:'a list -> 'a list - val private findIndexAux : - eq:('a -> 'b -> bool) -> x:'b -> l:'a list -> n:int -> int - val findIndex : eq:('a -> 'b -> bool) -> x:'b -> l:'a list -> int - val remove : f:('a -> 'b -> bool) -> x:'a -> l:'b list -> 'b list - val subtract : f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> 'a list - val isSubsetOf : f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool - val isSupersetOf : - f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool - val equals : f:('a -> 'b -> bool) -> l1:'a list -> l2:'b list -> bool - val unionFavourLeft : - f:('a -> 'a -> bool) -> l1:'a list -> l2:'a list -> 'a list - val intersect : - f:('a -> 'b -> bool) -> l1:'b list -> l2:'a list -> 'a list - val setify : f:('a -> 'a -> bool) -> l:'a list -> 'a list - val hasDuplicates : f:('a -> 'a -> bool) -> l:'a list -> bool - end - val mapFoldFst : - f:('a -> 'b -> 'c * 'd) -> s:'a -> x:'b * y:'e -> ('c * 'e) * 'd - val mapFoldSnd : - f:('a -> 'b -> 'c * 'd) -> s:'a -> x:'e * y:'b -> ('e * 'c) * 'd - val pair : a:'a -> b:'b -> 'a * 'b - val p13 : x:'a * _y:'b * _z:'c -> 'a - val p23 : _x:'a * y:'b * _z:'c -> 'b - val p33 : _x:'a * _y:'b * z:'c -> 'c - val map1Of2 : f:('a -> 'b) -> a1:'a * a2:'c -> 'b * 'c - val map2Of2 : f:('a -> 'b) -> a1:'c * a2:'a -> 'c * 'b - val map1Of3 : f:('a -> 'b) -> a1:'a * a2:'c * a3:'d -> 'b * 'c * 'd - val map2Of3 : f:('a -> 'b) -> a1:'c * a2:'a * a3:'d -> 'c * 'b * 'd - val map3Of3 : f:('a -> 'b) -> a1:'c * a2:'d * a3:'a -> 'c * 'd * 'b - val map3Of4 : - f:('a -> 'b) -> a1:'c * a2:'d * a3:'a * a4:'e -> 'c * 'd * 'b * 'e - val map4Of4 : - f:('a -> 'b) -> a1:'c * a2:'d * a3:'e * a4:'a -> 'c * 'd * 'e * 'b - val map5Of5 : - f:('a -> 'b) -> - a1:'c * a2:'d * a3:'e * a4:'f * a5:'a -> 'c * 'd * 'e * 'f * 'b - val map6Of6 : - f:('a -> 'b) -> - a1:'c * a2:'d * a3:'e * a4:'f * a5:'g * a6:'a -> - 'c * 'd * 'e * 'f * 'g * 'b - val foldPair : - f1:('a -> 'b -> 'c) * f2:('c -> 'd -> 'e) -> acc:'a -> a1:'b * a2:'d -> 'e - val fold1Of2 : f1:('a -> 'b -> 'c) -> acc:'a -> a1:'b * _a2:'d -> 'c - val foldTriple : - f1:('a -> 'b -> 'c) * f2:('c -> 'd -> 'e) * f3:('e -> 'f -> 'g) -> - acc:'a -> a1:'b * a2:'d * a3:'f -> 'g - val foldQuadruple : - f1:('a -> 'b -> 'c) * f2:('c -> 'd -> 'e) * f3:('e -> 'f -> 'g) * - f4:('g -> 'h -> 'i) -> acc:'a -> a1:'b * a2:'d * a3:'f * a4:'h -> 'i - val mapPair : f1:('a -> 'b) * f2:('c -> 'd) -> a1:'a * a2:'c -> 'b * 'd - val mapTriple : - f1:('a -> 'b) * f2:('c -> 'd) * f3:('e -> 'f) -> - a1:'a * a2:'c * a3:'e -> 'b * 'd * 'f - val mapQuadruple : - f1:('a -> 'b) * f2:('c -> 'd) * f3:('e -> 'f) * f4:('g -> 'h) -> - a1:'a * a2:'c * a3:'e * a4:'g -> 'b * 'd * 'f * 'h - val fmap2Of2 : - f:('a -> 'b -> 'c * 'd) -> z:'a -> a1:'e * a2:'b -> 'c * ('e * 'd) - module Zmap = begin - val force : k:'a -> mp:AbstractIL.Internal.Zmap<'a,'b> -> 'b - val mapKey : - key:'a -> - f:('b option -> 'b option) -> - mp:AbstractIL.Internal.Zmap<'a,'b> -> - AbstractIL.Internal.Zmap<'a,'b> - end - module Zset = begin - val ofList : - order:System.Collections.Generic.IComparer<'a> -> - xs:'a list -> AbstractIL.Internal.Zset<'a> - val fixpoint : - f:(AbstractIL.Internal.Zset<'a> -> AbstractIL.Internal.Zset<'a>) -> - AbstractIL.Internal.Zset<'a> -> AbstractIL.Internal.Zset<'a> - end - val equalOn : f:('a -> 'b) -> x:'a -> y:'a -> bool when 'b : equality - val bufs : f:(System.Text.StringBuilder -> unit) -> string - val writeViaBuffer : - os:System.IO.TextWriter -> - f:(System.Text.StringBuilder -> 'a -> unit) -> x:'a -> unit - type GraphNode<'Data,'Id> = - { nodeId: 'Id - nodeData: 'Data - mutable nodeNeighbours: GraphNode<'Data,'Id> list } - type Graph<'Data,'Id when 'Id : comparison> = - class - new : nodeIdentity:('Data -> 'Id) * nodes:'Data list * - edges:('Data * 'Data) list -> Graph<'Data,'Id> - member GetNodeData : nodeId:'Id -> 'Data - member IterateCycles : f:('Data list -> unit) -> unit - end - type NonNullSlot<'T> = 'T - val nullableSlotEmpty : unit -> 'T - val nullableSlotFull : x:'a -> 'a - type cache<'T> = - { mutable cacheVal: NonNullSlot<'T> } - val newCache : unit -> cache<'a> - val inline cached : cache:cache<'a> -> resF:(unit -> 'a) -> 'a - val inline cacheOptByref : cache:byref<'T option> -> f:(unit -> 'T) -> 'T - val inline cacheOptRef : cache:'a option ref -> f:(unit -> 'a) -> 'a - val inline tryGetCacheValue : cache:cache<'a> -> NonNullSlot<'a> voption - module AsyncUtil = begin - [] - type AsyncResult<'T> = - | AsyncOk of 'T - | AsyncException of exn - | AsyncCanceled of System.OperationCanceledException - with - static member Commit : res:AsyncResult<'T> -> Async<'T> - end - [] - type AsyncResultCell<'T> = - class - new : unit -> AsyncResultCell<'T> - member RegisterResult : res:AsyncResult<'T> -> unit - member private AsyncPrimitiveResult : Async> - member AsyncResult : Async<'T> - end - end - module UnmanagedProcessExecutionOptions = begin - val private GetProcessHeap : unit -> System.UIntPtr - val private HeapSetInformation : - _HeapHandle:System.UIntPtr * _HeapInformationClass:System.UInt32 * - _HeapInformation:System.UIntPtr * _HeapInformationLength:System.UIntPtr -> - bool - val private GetLastError : unit -> System.UInt32 - [ (3))>] - val EnableHeapTerminationOnCorruption : unit -> unit - end - module StackGuard = begin - [] - val private MaxUncheckedRecursionDepth : int = 20 - val EnsureSufficientExecutionStack : recursionDepth:int -> unit - end - [] - type MaybeLazy<'T> = - | Strict of 'T - | Lazy of System.Lazy<'T> - with - member Force : unit -> 'T - member Value : 'T - end - val inline vsnd : struct ('T * 'T) -> 'T - type DisposablesTracker = - class - interface System.IDisposable - new : unit -> DisposablesTracker - member Register : i:System.IDisposable -> unit - end - end - -namespace FSharp.Compiler - module internal Rational = begin - type Rational = - { numerator: System.Numerics.BigInteger - denominator: System.Numerics.BigInteger } - val gcd : - a:System.Numerics.BigInteger -> - b:System.Numerics.BigInteger -> System.Numerics.BigInteger - val lcm : - a:System.Numerics.BigInteger -> - b:System.Numerics.BigInteger -> System.Numerics.BigInteger - val mkRational : - p:System.Numerics.BigInteger -> q:System.Numerics.BigInteger -> Rational - val intToRational : int -> Rational - val ZeroRational : Rational - val OneRational : Rational - val AddRational : Rational -> Rational -> Rational - val NegRational : Rational -> Rational - val MulRational : Rational -> Rational -> Rational - val DivRational : Rational -> Rational -> Rational - val AbsRational : Rational -> Rational - val RationalToString : Rational -> string - val GcdRational : Rational -> Rational -> Rational - val GetNumerator : Rational -> int - val GetDenominator : Rational -> int - val SignRational : Rational -> int - end - -namespace Internal.Utilities - type PathMap = | PathMap of Map - module internal PathMap = begin - val dirSepStr : string - val empty : PathMap - val addMapping : string -> string -> PathMap -> PathMap - val apply : PathMap -> string -> string - val applyDir : PathMap -> string -> string - end - -namespace Internal.Utilities - module internal RidHelpers = begin - val probingRids : string [] - val platformRid : string - val baseRid : string - end - -namespace FSharp.Compiler - module Range = begin - type FileIndex = int32 - [] - val columnBitCount : int = 20 - [] - val lineBitCount : int = 31 - val posBitCount : int - val posColumnMask : int64 - val lineColumnMask : int64 - [] - type pos = - struct - new : l:int * c:int -> pos - new : code:int64 -> pos - static member Decode : int64 -> pos - override Equals : obj:obj -> bool - override GetHashCode : unit -> int - override ToString : unit -> string - member Column : int32 - member Encoding : int64 - member Line : int32 - static member EncodingSize : int - end - [] - val fileIndexBitCount : int = 24 - [] - val startColumnBitCount : int = 20 - [] - val endColumnBitCount : int = 20 - [] - val startLineBitCount : int = 31 - [] - val heightBitCount : int = 27 - [] - val isSyntheticBitCount : int = 1 - [] - val fileIndexShift : int = 0 - [] - val startColumnShift : int = 24 - [] - val endColumnShift : int = 44 - [] - val startLineShift : int = 0 - [] - val heightShift : int = 31 - [] - val isSyntheticShift : int = 58 - [] - val fileIndexMask : int64 = 16777215L - [] - val startColumnMask : int64 = 17592169267200L - [] - val endColumnMask : int64 = -17592186044416L - [] - val startLineMask : int64 = 2147483647L - [] - val heightMask : int64 = 288230374004228096L - [] - val isSyntheticMask : int64 = 288230376151711744L - val normalizeFilePath : filePath:string -> string - type FileIndexTable = - class - new : unit -> FileIndexTable - member FileToIndex : normalize:bool -> filePath:string -> int - member IndexToFile : n:int -> string - end - val maxFileIndex : int - val fileIndexTable : FileIndexTable - val fileIndexOfFileAux : normalize:bool -> f:string -> int - val fileIndexOfFile : filePath:string -> int - val fileOfFileIndex : int -> string - val mkPos : line:int -> column:int -> pos - val unknownFileName : string - val startupFileName : string - val commandLineArgsFileName : string - [ {DebugCode}")>] - type range = - struct - new : fIdx:int32 * b:pos * e:pos -> range - new : fIdx:int32 * bl:int32 * bc:int32 * el:int32 * ec:int32 -> range - new : code1:int64 * code2:int64 -> range - override Equals : obj:obj -> bool - override GetHashCode : unit -> int - member MakeSynthetic : unit -> range - member ToShortString : unit -> string - override ToString : unit -> string - member Code1 : int64 - member Code2 : int64 - member DebugCode : string - member End : pos - member EndColumn : int32 - member EndLine : int32 - member EndRange : range - member FileIndex : int32 - member FileName : string - member IsSynthetic : bool - member ShortFileName : string - member Start : pos - member StartColumn : int32 - member StartLine : int32 - member StartRange : range - static member Zero : range - end - val mkRange : string -> pos -> pos -> range - val equals : range -> range -> bool - val mkFileIndexRange : int32 -> pos -> pos -> range - val posOrder : System.Collections.Generic.IComparer - val rangeOrder : System.Collections.Generic.IComparer - val outputPos : System.IO.TextWriter -> pos -> unit - val outputRange : System.IO.TextWriter -> range -> unit - val posGt : pos -> pos -> bool - val posEq : pos -> pos -> bool - val posGeq : pos -> pos -> bool - val posLt : pos -> pos -> bool - val unionRanges : range -> range -> range - val rangeContainsRange : range -> range -> bool - val rangeContainsPos : range -> pos -> bool - val rangeBeforePos : range -> pos -> bool - val rangeN : string -> int -> range - val pos0 : pos - val range0 : range - val rangeStartup : range - val rangeCmdArgs : range - val trimRangeToLine : range -> range - val stringOfPos : pos -> string - val stringOfRange : range -> string - type Line0 = int - type Pos01 = Line0 * int - type Range01 = Pos01 * Pos01 - module Line = begin - val fromZ : Line0 -> int - val toZ : int -> Line0 - end - module Pos = begin - val fromZ : line:Line0 -> column:int -> pos - val toZ : pos -> Line0 * int32 - end - module Range = begin - val toZ : range -> (Line0 * int32) * (Line0 * int32) - val toFileZ : range -> string * ((Line0 * int32) * (Line0 * int32)) - val comparer : System.Collections.Generic.IEqualityComparer - end - end - -namespace FSharp.Compiler - module ErrorLogger = begin - [] - type ErrorStyle = - | DefaultErrors - | EmacsErrors - | TestErrors - | VSErrors - | GccErrors - exception WrappedError of exn * Range.range - exception ReportedError of exn option - val findOriginalException : err:exn -> exn - type Suggestions = (string -> unit) -> unit - val NoSuggestions : Suggestions - exception StopProcessingExn of exn option - val ( |StopProcessing|_| ) : exn:exn -> unit option - val StopProcessing<'T> : exn - exception NumberedError of (int * string) * Range.range - exception Error of (int * string) * Range.range - exception InternalError of msg: string * Range.range - exception UserCompilerMessage of string * int * Range.range - exception LibraryUseOnly of Range.range - exception Deprecated of string * Range.range - exception Experimental of string * Range.range - exception PossibleUnverifiableCode of Range.range - exception UnresolvedReferenceNoRange of string - exception UnresolvedReferenceError of string * Range.range - exception UnresolvedPathReferenceNoRange of string * string - exception UnresolvedPathReference of string * string * Range.range - exception ErrorWithSuggestions of - (int * string) * Range.range * string * - Suggestions - val inline protectAssemblyExploration : dflt:'a -> f:(unit -> 'a) -> 'a - val inline protectAssemblyExplorationF : - dflt:(string * string -> 'a) -> f:(unit -> 'a) -> 'a - val inline protectAssemblyExplorationNoReraise : - dflt1:'a -> dflt2:'a -> f:(unit -> 'a) -> 'a - val AttachRange : m:Range.range -> exn:exn -> exn - type Exiter = - interface - abstract member Exit : int -> 'T - end - val QuitProcessExiter : Exiter - [] - type BuildPhase = - | DefaultPhase - | Compile - | Parameter - | Parse - | TypeCheck - | CodeGen - | Optimize - | IlxGen - | IlGen - | Output - | Interactive - module BuildPhaseSubcategory = begin - [] - val DefaultPhase : string = "" - [] - val Compile : string = "compile" - [] - val Parameter : string = "parameter" - [] - val Parse : string = "parse" - [] - val TypeCheck : string = "typecheck" - [] - val CodeGen : string = "codegen" - [] - val Optimize : string = "optimize" - [] - val IlxGen : string = "ilxgen" - [] - val IlGen : string = "ilgen" - [] - val Output : string = "output" - [] - val Interactive : string = "interactive" - [] - val Internal : string = "internal" - end - [] - type PhasedDiagnostic = - { Exception: exn - Phase: BuildPhase } - with - static member Create : exn:exn * phase:BuildPhase -> PhasedDiagnostic - static member IsSubcategoryOfCompile : subcategory:string -> bool - member DebugDisplay : unit -> string - member IsPhaseInCompile : unit -> bool - member Subcategory : unit -> string - end - [] - type ErrorLogger = - class - new : nameForDebugging:string -> ErrorLogger - member DebugDisplay : unit -> string - abstract member - DiagnosticSink : phasedError:PhasedDiagnostic * isError:bool -> unit - abstract member ErrorCount : int - end - val DiscardErrorsLogger : ErrorLogger - val AssertFalseErrorLogger : ErrorLogger - type CapturingErrorLogger = - class - inherit ErrorLogger - new : nm:string -> CapturingErrorLogger - member CommitDelayedDiagnostics : errorLogger:ErrorLogger -> unit - override - DiagnosticSink : phasedError:PhasedDiagnostic * isError:bool -> unit - member Diagnostics : (PhasedDiagnostic * bool) list - override ErrorCount : int - end - [] - type internal CompileThreadStatic = - class - static member BuildPhase : BuildPhase - static member BuildPhaseUnchecked : BuildPhase - static member ErrorLogger : ErrorLogger - static val mutable private buildPhase: BuildPhase - static val mutable private errorLogger: ErrorLogger - end - module ErrorLoggerExtensions = begin - val tryAndDetectDev15 : bool - val PreserveStackTrace : exn:'a -> unit - val ReraiseIfWatsonable : exn:exn -> unit - type ErrorLogger with - member ErrorR : exn:exn -> unit - type ErrorLogger with - member Warning : exn:exn -> unit - type ErrorLogger with - member Error : exn:exn -> 'b - type ErrorLogger with - member SimulateError : ph:PhasedDiagnostic -> 'a - type ErrorLogger with - member ErrorRecovery : exn:exn -> m:Range.range -> unit - type ErrorLogger with - member StopProcessingRecovery : exn:exn -> m:Range.range -> unit - type ErrorLogger with - member ErrorRecoveryNoRange : exn:exn -> unit - end - val PushThreadBuildPhaseUntilUnwind : phase:BuildPhase -> System.IDisposable - val PushErrorLoggerPhaseUntilUnwind : - errorLoggerTransformer:(ErrorLogger -> #ErrorLogger) -> System.IDisposable - val SetThreadBuildPhaseNoUnwind : phase:BuildPhase -> unit - val SetThreadErrorLoggerNoUnwind : errorLogger:ErrorLogger -> unit - val errorR : exn:exn -> unit - val warning : exn:exn -> unit - val error : exn:exn -> 'a - val simulateError : p:PhasedDiagnostic -> 'a - val diagnosticSink : phasedError:PhasedDiagnostic * isError:bool -> unit - val errorSink : pe:PhasedDiagnostic -> unit - val warnSink : pe:PhasedDiagnostic -> unit - val errorRecovery : exn:exn -> m:Range.range -> unit - val stopProcessingRecovery : exn:exn -> m:Range.range -> unit - val errorRecoveryNoRange : exn:exn -> unit - val report : f:(unit -> 'a) -> 'a - val deprecatedWithError : s:string -> m:Range.range -> unit - val mutable reportLibraryOnlyFeatures : bool - val libraryOnlyError : m:Range.range -> unit - val libraryOnlyWarning : m:Range.range -> unit - val deprecatedOperator : m:Range.range -> unit - val mlCompatWarning : s:System.String -> m:Range.range -> unit - val suppressErrorReporting : f:(unit -> 'a) -> 'a - val conditionallySuppressErrorReporting : cond:bool -> f:(unit -> 'a) -> 'a - [] - type OperationResult<'T> = - | OkResult of warnings: exn list * 'T - | ErrorResult of warnings: exn list * exn - type ImperativeOperationResult = OperationResult - val ReportWarnings : warns:#exn list -> unit - val CommitOperationResult : res:OperationResult<'a> -> 'a - val RaiseOperationResult : res:OperationResult -> unit - val ErrorD : err:exn -> OperationResult<'a> - val WarnD : err:exn -> OperationResult - val CompleteD : OperationResult - val ResultD : x:'a -> OperationResult<'a> - val CheckNoErrorsAndGetWarnings : res:OperationResult<'a> -> exn list option - val ( ++ ) : - res:OperationResult<'a> -> - f:('a -> OperationResult<'b>) -> OperationResult<'b> - val IterateD : - f:('a -> OperationResult) -> xs:'a list -> OperationResult - val WhileD : - gd:(unit -> bool) -> - body:(unit -> OperationResult) -> OperationResult - val MapD : - f:('a -> OperationResult<'b>) -> xs:'a list -> OperationResult<'b list> - type TrackErrorsBuilder = - class - new : unit -> TrackErrorsBuilder - member - Bind : res:OperationResult<'h> * k:('h -> OperationResult<'i>) -> - OperationResult<'i> - member - Combine : expr1:OperationResult<'c> * - expr2:('c -> OperationResult<'d>) -> OperationResult<'d> - member Delay : fn:(unit -> 'b) -> (unit -> 'b) - member - For : seq:'e list * k:('e -> OperationResult) -> - OperationResult - member Return : res:'g -> OperationResult<'g> - member ReturnFrom : res:'f -> 'f - member Run : fn:(unit -> 'a) -> 'a - member - While : gd:(unit -> bool) * k:(unit -> OperationResult) -> - OperationResult - member Zero : unit -> OperationResult - end - val trackErrors : TrackErrorsBuilder - val OptionD : - f:('a -> OperationResult) -> xs:'a option -> OperationResult - val IterateIdxD : - f:(int -> 'a -> OperationResult) -> - xs:'a list -> OperationResult - val Iterate2D : - f:('a -> 'b -> OperationResult) -> - xs:'a list -> ys:'b list -> OperationResult - val TryD : - f:(unit -> OperationResult<'a>) -> - g:(exn -> OperationResult<'a>) -> OperationResult<'a> - val RepeatWhileD : - nDeep:int -> body:(int -> OperationResult) -> OperationResult - val AtLeastOneD : - f:('a -> OperationResult) -> l:'a list -> OperationResult - module OperationResult = begin - val inline ignore : res:OperationResult<'a> -> OperationResult - end - val stringThatIsAProxyForANewlineInFlatErrors : System.String - val NewlineifyErrorString : message:string -> string - val NormalizeErrorString : text:string -> string - type FSharpErrorSeverityOptions = - { WarnLevel: int - GlobalWarnAsError: bool - WarnOff: int list - WarnOn: int list - WarnAsError: int list - WarnAsWarn: int list } - with - static member Default : FSharpErrorSeverityOptions - end - val private tryLanguageFeatureErrorAux : - langVersion:Features.LanguageVersion -> - langFeature:Features.LanguageFeature -> m:Range.range -> exn option - val internal checkLanguageFeatureError : - langVersion:Features.LanguageVersion -> - langFeature:Features.LanguageFeature -> m:Range.range -> unit - val internal checkLanguageFeatureErrorRecover : - langVersion:Features.LanguageVersion -> - langFeature:Features.LanguageFeature -> m:Range.range -> unit - val internal tryLanguageFeatureErrorOption : - langVersion:Features.LanguageVersion -> - langFeature:Features.LanguageFeature -> m:Range.range -> exn option - val internal languageFeatureNotSupportedInLibraryError : - langVersion:Features.LanguageVersion -> - langFeature:Features.LanguageFeature -> m:Range.range -> 'a - end - -namespace FSharp.Compiler - module internal ErrorResolutionHints = begin - val maxSuggestions : int - val minThresholdForSuggestions : float - val highConfidenceThreshold : float - val minStringLengthForSuggestion : int - val IsInEditDistanceProximity : idText:string -> suggestion:string -> bool - val DemangleOperator : nm:string -> string - type SuggestionBufferEnumerator = - class - interface System.IDisposable - interface System.Collections.IEnumerator - interface System.Collections.Generic.IEnumerator - new : tail:int * - data:System.Collections.Generic.KeyValuePair [] -> - SuggestionBufferEnumerator - end - type SuggestionBuffer = - class - interface System.Collections.IEnumerable - interface System.Collections.Generic.IEnumerable - new : idText:string -> SuggestionBuffer - member Add : suggestion:string -> unit - member Disabled : bool - member IsEmpty : bool - end - end - -namespace FSharp.Compiler.AbstractIL - module IL = begin - val logging : bool - val int_order : System.Collections.Generic.IComparer - val notlazy : v:'a -> System.Lazy<'a> - val lazyMap : f:('a -> 'b) -> x:System.Lazy<'a> -> System.Lazy<'b> - [] - type PrimaryAssembly = - | Mscorlib - | System_Runtime - | NetStandard - with - member Name : string - end - val splitNameAt : nm:string -> idx:int -> string * string - val splitNamespaceAux : nm:string -> string list - val memoizeNamespaceTable : - System.Collections.Concurrent.ConcurrentDictionary - val memoizeNamespaceRightTable : - System.Collections.Concurrent.ConcurrentDictionary - val splitNamespace : string -> string list - val splitNamespaceMemoized : nm:string -> string list - val memoizeNamespaceArrayTable : - System.Collections.Concurrent.ConcurrentDictionary - val splitNamespaceToArray : string -> string [] - val splitILTypeName : string -> string list * string - val emptyStringArray : string [] - val splitILTypeNameWithPossibleStaticArguments : - string -> string [] * string - val unsplitTypeName : ns:string list * n:string -> string - val splitTypeNameRightAux : nm:string -> string option * string - val splitTypeNameRight : string -> string option * string - type LazyOrderedMultiMap<'Key,'Data when 'Key : equality> = - class - new : keyf:('Data -> 'Key) * lazyItems:System.Lazy<'Data list> -> - LazyOrderedMultiMap<'Key,'Data> - member Add : y:'Data -> LazyOrderedMultiMap<'Key,'Data> - member Entries : unit -> 'Data list - member Filter : f:('Data -> bool) -> LazyOrderedMultiMap<'Key,'Data> - member Item : x:'Key -> 'Data list with get - end - val b0 : n:int -> int - val b1 : n:int -> int - val b2 : n:int -> int - val b3 : n:int -> int - module SHA1 = begin - val inline ( >>>& ) : x:int -> y:int -> int32 - val f : t:int * b:int * c:int * d:int -> int - [] - val k0to19 : int = 1518500249 - [] - val k20to39 : int = 1859775393 - [] - val k40to59 : int = -1894007588 - [] - val k60to79 : int = -899497514 - val k : t:int -> int - type SHAStream = - { stream: byte [] - mutable pos: int - mutable eof: bool } - val rotLeft32 : x:int32 -> n:int32 -> int32 - val shaAfterEof : sha:SHAStream -> int - val shaRead8 : sha:SHAStream -> int - val shaRead32 : sha:SHAStream -> int - val sha1Hash : sha:SHAStream -> int * int * int * int * int - val sha1HashBytes : s:byte [] -> byte [] - val sha1HashInt64 : s:byte [] -> int64 - end - val sha1HashBytes : byte [] -> byte [] - val sha1HashInt64 : byte [] -> int64 - [] - type ILVersionInfo = - struct - new : major:uint16 * minor:uint16 * build:uint16 * revision:uint16 -> - ILVersionInfo - val Major: uint16 - val Minor: uint16 - val Build: uint16 - val Revision: uint16 - override ToString : unit -> string - end - type Locale = string - [] - type PublicKey = - | PublicKey of byte [] - | PublicKeyToken of byte [] - with - static member KeyAsToken : byte [] -> PublicKey - member ToToken : unit -> byte [] - member IsKey : bool - member IsKeyToken : bool - member Key : byte [] - member KeyToken : byte [] - end - [] - type AssemblyRefData = - { assemRefName: string - assemRefHash: byte [] option - assemRefPublicKeyInfo: PublicKey option - assemRefRetargetable: bool - assemRefVersion: ILVersionInfo option - assemRefLocale: Locale option } - val AssemblyRefUniqueStampGenerator : - Internal.Library.UniqueStampGenerator - val isMscorlib : data:AssemblyRefData -> bool - [] - type ILAssemblyRef = - class - interface System.IComparable - new : data:AssemblyRefData -> ILAssemblyRef - static member - Create : name:string * hash:byte [] option * - publicKey:PublicKey option * retargetable:bool * - version:ILVersionInfo option * locale:Locale option -> - ILAssemblyRef - static member - FromAssemblyName : System.Reflection.AssemblyName -> ILAssemblyRef - override Equals : yobj:obj -> bool - member EqualsIgnoringVersion : ILAssemblyRef -> bool - override GetHashCode : unit -> int - member Hash : byte [] option - member Locale : Locale option - member Name : string - member PublicKey : PublicKey option - member QualifiedName : string - member Retargetable : bool - member UniqueIgnoringVersionStamp : int - member UniqueStamp : int - member Version : ILVersionInfo option - end - [] - type ILModuleRef = - { name: string - hasMetadata: bool - hash: byte [] option } - with - static member - Create : name:string * hasMetadata:bool * hash:byte [] option -> - ILModuleRef - member HasMetadata : bool - member Hash : byte [] option - member Name : string - end - [] - type ILScopeRef = - | Local - | Module of ILModuleRef - | Assembly of ILAssemblyRef - | PrimaryAssembly - with - member IsLocalRef : bool - member QualifiedName : string - end - type ILArrayBound = int32 option - type ILArrayBounds = ILArrayBound * ILArrayBound - [] - type ILArrayShape = - | ILArrayShape of ILArrayBounds list - with - static member FromRank : int -> ILArrayShape - member Rank : int - static member SingleDimensional : ILArrayShape - end - and ILArrayShapeStatics = - class - new : unit -> ILArrayShapeStatics - static member SingleDimensional : ILArrayShape - end - [] - type ILArgConvention = - | Default - | CDecl - | StdCall - | ThisCall - | FastCall - | VarArg - [] - type ILThisConvention = - | Instance - | InstanceExplicit - | Static - [] - type ILCallingConv = - | Callconv of ILThisConvention * ILArgConvention - with - member BasicConv : ILArgConvention - member IsInstance : bool - member IsInstanceExplicit : bool - member IsStatic : bool - member ThisConv : ILThisConvention - static member Instance : ILCallingConv - static member Static : ILCallingConv - end - and ILCallingConvStatics = - class - new : unit -> ILCallingConvStatics - static member Instance : ILCallingConv - static member Static : ILCallingConv - end - type ILBoxity = - | AsObject - | AsValue - [] - type ILTypeRef = - { trefScope: ILScopeRef - trefEnclosing: string list - trefName: string - hashCode: int - mutable asBoxedType: ILType } - with - interface System.IComparable - static member - ComputeHash : scope:'a * enclosing:'b * name:'c -> int - when 'a : equality and 'b : equality and 'c : equality - static member - Create : scope:ILScopeRef * enclosing:string list * name:string -> - ILTypeRef - member AddQualifiedNameExtension : basic:string -> string - member AsBoxedType : tspec:ILTypeSpec -> ILType - override Equals : yobj:obj -> bool - member EqualsWithPrimaryScopeRef : ILScopeRef * obj -> bool - override GetHashCode : unit -> int - override ToString : unit -> string - member ApproxId : int - member BasicQualifiedName : string - [ (0))>] - member DebugText : string - member Enclosing : string list - member FullName : string - member Name : string - member QualifiedName : string - member Scope : ILScopeRef - end - [] - and ILTypeSpec = - { tspecTypeRef: ILTypeRef - tspecInst: ILGenericArgs } - with - static member - Create : typeRef:ILTypeRef * instantiation:ILGenericArgs -> ILTypeSpec - member AddQualifiedNameExtension : basic:string -> string - member EqualsWithPrimaryScopeRef : ILScopeRef * obj -> bool - override ToString : unit -> string - member BasicQualifiedName : string - [ (0))>] - member DebugText : string - member Enclosing : string list - member FullName : string - member GenericArgs : ILGenericArgs - member Name : string - member Scope : ILScopeRef - member TypeRef : ILTypeRef - end - [] - and ILType = - | Void - | Array of ILArrayShape * ILType - | Value of ILTypeSpec - | Boxed of ILTypeSpec - | Ptr of ILType - | Byref of ILType - | FunctionPointer of ILCallingSignature - | TypeVar of uint16 - | Modified of bool * ILTypeRef * ILType - with - member AddQualifiedNameExtension : basic:string -> string - override ToString : unit -> string - member BasicQualifiedName : string - member Boxity : ILBoxity - [ (0))>] - member DebugText : string - member GenericArgs : ILGenericArgs - member IsNominal : bool - member IsTyvar : bool - member QualifiedName : string - member TypeRef : ILTypeRef - member TypeSpec : ILTypeSpec - end - [] - and ILCallingSignature = - { CallingConv: ILCallingConv - ArgTypes: ILTypes - ReturnType: ILType } - and ILGenericArgs = ILType list - and ILTypes = ILType list - val mkILCallSig : ILCallingConv * ILTypes * ILType -> ILCallingSignature - val mkILBoxedType : ILTypeSpec -> ILType - [] - type ILMethodRef = - { mrefParent: ILTypeRef - mrefCallconv: ILCallingConv - mrefGenericArity: int - mrefName: string - mrefArgs: ILTypes - mrefReturn: ILType } - with - static member - Create : enclosingTypeRef:ILTypeRef * callingConv:ILCallingConv * - name:string * genericArity:int * argTypes:ILTypes * - returnType:ILType -> ILMethodRef - override ToString : unit -> string - member ArgCount : int - member ArgTypes : ILTypes - member CallingConv : ILCallingConv - member CallingSignature : ILCallingSignature - [ (0))>] - member DebugText : string - member DeclaringTypeRef : ILTypeRef - member GenericArity : int - member Name : string - member ReturnType : ILType - end - [] - type ILFieldRef = - { DeclaringTypeRef: ILTypeRef - Name: string - Type: ILType } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - type ILMethodSpec = - { mspecMethodRef: ILMethodRef - mspecDeclaringType: ILType - mspecMethodInst: ILGenericArgs } - with - static member - Create : ILType * ILMethodRef * ILGenericArgs -> ILMethodSpec - override ToString : unit -> string - member CallingConv : ILCallingConv - [ (0))>] - member DebugText : string - member DeclaringType : ILType - member FormalArgTypes : ILTypes - member FormalReturnType : ILType - member GenericArgs : ILGenericArgs - member GenericArity : int - member MethodRef : ILMethodRef - member Name : string - end - [] - type ILFieldSpec = - { FieldRef: ILFieldRef - DeclaringType: ILType } - with - override ToString : unit -> string - member ActualType : ILType - [ (0))>] - member DebugText : string - member DeclaringTypeRef : ILTypeRef - member FormalType : ILType - member Name : string - end - type ILGuid = byte [] - [] - type ILPlatform = - | X86 - | AMD64 - | IA64 - [] - type ILSourceDocument = - { sourceLanguage: ILGuid option - sourceVendor: ILGuid option - sourceDocType: ILGuid option - sourceFile: string } - with - static member - Create : language:ILGuid option * vendor:ILGuid option * - documentType:ILGuid option * file:string -> ILSourceDocument - member DocumentType : ILGuid option - member File : string - member Language : ILGuid option - member Vendor : ILGuid option - end - [] - type ILSourceMarker = - { sourceDocument: ILSourceDocument - sourceLine: int - sourceColumn: int - sourceEndLine: int - sourceEndColumn: int } - with - static member - Create : document:ILSourceDocument * line:int * column:int * - endLine:int * endColumn:int -> ILSourceMarker - override ToString : unit -> string - member Column : int - [ (0))>] - member DebugText : string - member Document : ILSourceDocument - member EndColumn : int - member EndLine : int - member Line : int - end - [] - type ILAttribElem = - | String of string option - | Bool of bool - | Char of char - | SByte of int8 - | Int16 of int16 - | Int32 of int32 - | Int64 of int64 - | Byte of uint8 - | UInt16 of uint16 - | UInt32 of uint32 - | UInt64 of uint64 - | Single of single - | Double of double - | Null - | Type of ILType option - | TypeRef of ILTypeRef option - | Array of ILType * ILAttribElem list - type ILAttributeNamedArg = string * ILType * bool * ILAttribElem - [] - type ILAttribute = - | Encoded of - method: ILMethodSpec * data: byte [] * elements: ILAttribElem list - | Decoded of - method: ILMethodSpec * fixedArgs: ILAttribElem list * - namedArgs: ILAttributeNamedArg list - with - override ToString : unit -> string - member WithMethod : method:ILMethodSpec -> ILAttribute - [ (0))>] - member DebugText : string - member Elements : ILAttribElem list - member Method : ILMethodSpec - end - [] - type ILAttributes = - struct - new : array:ILAttribute [] -> ILAttributes - member AsArray : ILAttribute [] - member AsList : ILAttribute list - end - [] - type ILAttributesStored = - | Reader of (int32 -> ILAttribute []) - | Given of ILAttributes - with - member GetCustomAttrs : metadataIndex:int32 -> ILAttributes - end - val emptyILCustomAttrs : ILAttributes - val mkILCustomAttrsFromArray : ILAttribute [] -> ILAttributes - val mkILCustomAttrs : ILAttribute list -> ILAttributes - val emptyILCustomAttrsStored : ILAttributesStored - val storeILCustomAttrs : ILAttributes -> ILAttributesStored - val mkILCustomAttrsReader : (int32 -> ILAttribute []) -> ILAttributesStored - type ILCodeLabel = int - [] - type ILBasicType = - | DT_R - | DT_I1 - | DT_U1 - | DT_I2 - | DT_U2 - | DT_I4 - | DT_U4 - | DT_I8 - | DT_U8 - | DT_R4 - | DT_R8 - | DT_I - | DT_U - | DT_REF - [] - type ILToken = - | ILType of ILType - | ILMethod of ILMethodSpec - | ILField of ILFieldSpec - [] - type ILConst = - | I4 of int32 - | I8 of int64 - | R4 of single - | R8 of double - type ILTailcall = - | Tailcall - | Normalcall - type ILAlignment = - | Aligned - | Unaligned1 - | Unaligned2 - | Unaligned4 - type ILVolatility = - | Volatile - | Nonvolatile - type ILReadonly = - | ReadonlyAddress - | NormalAddress - type ILVarArgs = ILTypes option - [] - type ILComparisonInstr = - | BI_beq - | BI_bge - | BI_bge_un - | BI_bgt - | BI_bgt_un - | BI_ble - | BI_ble_un - | BI_blt - | BI_blt_un - | BI_bne_un - | BI_brfalse - | BI_brtrue - [] - type ILInstr = - | AI_add - | AI_add_ovf - | AI_add_ovf_un - | AI_and - | AI_div - | AI_div_un - | AI_ceq - | AI_cgt - | AI_cgt_un - | AI_clt - | AI_clt_un - | AI_conv of ILBasicType - | AI_conv_ovf of ILBasicType - | AI_conv_ovf_un of ILBasicType - | AI_mul - | AI_mul_ovf - | AI_mul_ovf_un - | AI_rem - | AI_rem_un - | AI_shl - | AI_shr - | AI_shr_un - | AI_sub - | AI_sub_ovf - | AI_sub_ovf_un - | AI_xor - | AI_or - | AI_neg - | AI_not - | AI_ldnull - | AI_dup - | AI_pop - | AI_ckfinite - | AI_nop - | AI_ldc of ILBasicType * ILConst - | I_ldarg of uint16 - | I_ldarga of uint16 - | I_ldind of ILAlignment * ILVolatility * ILBasicType - | I_ldloc of uint16 - | I_ldloca of uint16 - | I_starg of uint16 - | I_stind of ILAlignment * ILVolatility * ILBasicType - | I_stloc of uint16 - | I_br of ILCodeLabel - | I_jmp of ILMethodSpec - | I_brcmp of ILComparisonInstr * ILCodeLabel - | I_switch of ILCodeLabel list - | I_ret - | I_call of ILTailcall * ILMethodSpec * ILVarArgs - | I_callvirt of ILTailcall * ILMethodSpec * ILVarArgs - | I_callconstraint of ILTailcall * ILType * ILMethodSpec * ILVarArgs - | I_calli of ILTailcall * ILCallingSignature * ILVarArgs - | I_ldftn of ILMethodSpec - | I_newobj of ILMethodSpec * ILVarArgs - | I_throw - | I_endfinally - | I_endfilter - | I_leave of ILCodeLabel - | I_rethrow - | I_ldsfld of ILVolatility * ILFieldSpec - | I_ldfld of ILAlignment * ILVolatility * ILFieldSpec - | I_ldsflda of ILFieldSpec - | I_ldflda of ILFieldSpec - | I_stsfld of ILVolatility * ILFieldSpec - | I_stfld of ILAlignment * ILVolatility * ILFieldSpec - | I_ldstr of string - | I_isinst of ILType - | I_castclass of ILType - | I_ldtoken of ILToken - | I_ldvirtftn of ILMethodSpec - | I_cpobj of ILType - | I_initobj of ILType - | I_ldobj of ILAlignment * ILVolatility * ILType - | I_stobj of ILAlignment * ILVolatility * ILType - | I_box of ILType - | I_unbox of ILType - | I_unbox_any of ILType - | I_sizeof of ILType - | I_ldelem of ILBasicType - | I_stelem of ILBasicType - | I_ldelema of ILReadonly * bool * ILArrayShape * ILType - | I_ldelem_any of ILArrayShape * ILType - | I_stelem_any of ILArrayShape * ILType - | I_newarr of ILArrayShape * ILType - | I_ldlen - | I_mkrefany of ILType - | I_refanytype - | I_refanyval of ILType - | I_break - | I_seqpoint of ILSourceMarker - | I_arglist - | I_localloc - | I_cpblk of ILAlignment * ILVolatility - | I_initblk of ILAlignment * ILVolatility - | EI_ilzero of ILType - | EI_ldlen_multi of int32 * int32 - [] - type ILExceptionClause = - | Finally of (ILCodeLabel * ILCodeLabel) - | Fault of (ILCodeLabel * ILCodeLabel) - | FilterCatch of - filterRange: ILCodeLabel * ILCodeLabel * - handlerRange: ILCodeLabel * ILCodeLabel - | TypeCatch of ILType * (ILCodeLabel * ILCodeLabel) - [] - type ILExceptionSpec = - { Range: ILCodeLabel * ILCodeLabel - Clause: ILExceptionClause } - [] - type ILLocalDebugMapping = - { LocalIndex: int - LocalName: string } - [] - type ILLocalDebugInfo = - { Range: ILCodeLabel * ILCodeLabel - DebugMappings: ILLocalDebugMapping list } - [] - type ILCode = - { Labels: System.Collections.Generic.Dictionary - Instrs: ILInstr [] - Exceptions: ILExceptionSpec list - Locals: ILLocalDebugInfo list } - [] - type ILLocal = - { Type: ILType - IsPinned: bool - DebugInfo: (string * int * int) option } - type ILLocals = ILLocal list - [] - type ILMethodBody = - { IsZeroInit: bool - MaxStack: int32 - NoInlining: bool - AggressiveInlining: bool - Locals: ILLocals - Code: ILCode - SourceMarker: ILSourceMarker option } - [] - type ILMemberAccess = - | Assembly - | CompilerControlled - | FamilyAndAssembly - | FamilyOrAssembly - | Family - | Private - | Public - [] - type ILFieldInit = - | String of string - | Bool of bool - | Char of uint16 - | Int8 of int8 - | Int16 of int16 - | Int32 of int32 - | Int64 of int64 - | UInt8 of uint8 - | UInt16 of uint16 - | UInt32 of uint32 - | UInt64 of uint64 - | Single of single - | Double of double - | Null - with - member AsObject : unit -> obj - end - [] - type ILNativeType = - | Empty - | Custom of - ILGuid * nativeTypeName: string * custMarshallerName: string * - cookieString: byte [] - | FixedSysString of int32 - | FixedArray of int32 - | Currency - | LPSTR - | LPWSTR - | LPTSTR - | LPUTF8STR - | ByValStr - | TBSTR - | LPSTRUCT - | Struct - | Void - | Bool - | Int8 - | Int16 - | Int32 - | Int64 - | Single - | Double - | Byte - | UInt16 - | UInt32 - | UInt64 - | Array of ILNativeType option * (int32 * int32 option) option - | Int - | UInt - | Method - | AsAny - | BSTR - | IUnknown - | IDispatch - | Interface - | Error - | SafeArray of ILNativeVariant * string option - | ANSIBSTR - | VariantBool - [] - and ILNativeVariant = - | Empty - | Null - | Variant - | Currency - | Decimal - | Date - | BSTR - | LPSTR - | LPWSTR - | IUnknown - | IDispatch - | SafeArray - | Error - | HRESULT - | CArray - | UserDefined - | Record - | FileTime - | Blob - | Stream - | Storage - | StreamedObject - | StoredObject - | BlobObject - | CF - | CLSID - | Void - | Bool - | Int8 - | Int16 - | Int32 - | Int64 - | Single - | Double - | UInt8 - | UInt16 - | UInt32 - | UInt64 - | PTR - | Array of ILNativeVariant - | Vector of ILNativeVariant - | Byref of ILNativeVariant - | Int - | UInt - [] - type ILSecurityAction = - | Request - | Demand - | Assert - | Deny - | PermitOnly - | LinkCheck - | InheritCheck - | ReqMin - | ReqOpt - | ReqRefuse - | PreJitGrant - | PreJitDeny - | NonCasDemand - | NonCasLinkDemand - | NonCasInheritance - | LinkDemandChoice - | InheritanceDemandChoice - | DemandChoice - [] - type ILSecurityDecl = | ILSecurityDecl of ILSecurityAction * byte [] - [] - type ILSecurityDecls = - struct - new : array:ILSecurityDecl [] -> ILSecurityDecls - member AsArray : ILSecurityDecl [] - member AsList : ILSecurityDecl list - end - [] - type ILSecurityDeclsStored = - | Reader of (int32 -> ILSecurityDecl []) - | Given of ILSecurityDecls - with - member GetSecurityDecls : metadataIndex:int32 -> ILSecurityDecls - end - val emptyILSecurityDecls : ILSecurityDecls - val emptyILSecurityDeclsStored : ILSecurityDeclsStored - val mkILSecurityDecls : ILSecurityDecl list -> ILSecurityDecls - val storeILSecurityDecls : ILSecurityDecls -> ILSecurityDeclsStored - val mkILSecurityDeclsReader : - (int32 -> ILSecurityDecl []) -> ILSecurityDeclsStored - [] - type PInvokeCharBestFit = - | UseAssembly - | Enabled - | Disabled - [] - type PInvokeThrowOnUnmappableChar = - | UseAssembly - | Enabled - | Disabled - [] - type PInvokeCallingConvention = - | None - | Cdecl - | Stdcall - | Thiscall - | Fastcall - | WinApi - [] - type PInvokeCharEncoding = - | None - | Ansi - | Unicode - | Auto - [] - type PInvokeMethod = - { Where: ILModuleRef - Name: string - CallingConv: PInvokeCallingConvention - CharEncoding: PInvokeCharEncoding - NoMangle: bool - LastError: bool - ThrowOnUnmappableChar: PInvokeThrowOnUnmappableChar - CharBestFit: PInvokeCharBestFit } - [] - type ILParameter = - { Name: string option - Type: ILType - Default: ILFieldInit option - Marshal: ILNativeType option - IsIn: bool - IsOut: bool - IsOptional: bool - CustomAttrsStored: ILAttributesStored - MetadataIndex: int32 } - with - member CustomAttrs : ILAttributes - end - type ILParameters = ILParameter list - [] - type ILReturn = - { Marshal: ILNativeType option - Type: ILType - CustomAttrsStored: ILAttributesStored - MetadataIndex: int32 } - with - member WithCustomAttrs : customAttrs:ILAttributes -> ILReturn - member CustomAttrs : ILAttributes - end - type ILOverridesSpec = - | OverridesSpec of ILMethodRef * ILType - with - member DeclaringType : ILType - member MethodRef : ILMethodRef - end - type ILMethodVirtualInfo = - { IsFinal: bool - IsNewSlot: bool - IsCheckAccessOnOverride: bool - IsAbstract: bool } - [] - type MethodKind = - | Static - | Cctor - | Ctor - | NonVirtual - | Virtual of ILMethodVirtualInfo - [] - type MethodBody = - | IL of ILMethodBody - | PInvoke of PInvokeMethod - | Abstract - | Native - | NotAvailable - [] - type ILLazyMethodBody = - | ILLazyMethodBody of System.Lazy - with - member Contents : MethodBody - end - [] - type MethodCodeKind = - | IL - | Native - | Runtime - val mkMethBodyAux : MethodBody -> ILLazyMethodBody - val mkMethBodyLazyAux : System.Lazy -> ILLazyMethodBody - val typesOfILParams : ILParameters -> ILTypes - [] - type ILGenericVariance = - | NonVariant - | CoVariant - | ContraVariant - [] - type ILGenericParameterDef = - { Name: string - Constraints: ILTypes - Variance: ILGenericVariance - HasReferenceTypeConstraint: bool - HasNotNullableValueTypeConstraint: bool - HasDefaultConstructorConstraint: bool - CustomAttrsStored: ILAttributesStored - MetadataIndex: int32 } - with - override ToString : unit -> string - member CustomAttrs : ILAttributes - [ (0))>] - member DebugText : string - end - type ILGenericParameterDefs = ILGenericParameterDef list - val memberAccessOfFlags : flags:int -> ILMemberAccess - val convertMemberAccess : - ilMemberAccess:ILMemberAccess -> System.Reflection.MethodAttributes - val inline conditionalAdd : - condition:bool -> flagToAdd: ^a -> source: ^a -> ^a - when ^a : (static member ( ~~~ ) : ^a -> ^a) and - ^a : (static member ( ||| ) : ^a * ^a -> ^a) and - ^a : (static member ( &&& ) : ^a * ^a -> ^a) - val NoMetadataIdx : int - [] - type ILMethodDef = - class - new : name:string * attributes:System.Reflection.MethodAttributes * - implAttributes:System.Reflection.MethodImplAttributes * - callingConv:ILCallingConv * parameters:ILParameters * ret:ILReturn * - body:ILLazyMethodBody * isEntryPoint:bool * - genericParams:ILGenericParameterDefs * - securityDecls:ILSecurityDecls * customAttrs:ILAttributes -> - ILMethodDef - new : name:string * attributes:System.Reflection.MethodAttributes * - implAttributes:System.Reflection.MethodImplAttributes * - callingConv:ILCallingConv * parameters:ILParameters * ret:ILReturn * - body:ILLazyMethodBody * isEntryPoint:bool * - genericParams:ILGenericParameterDefs * - securityDeclsStored:ILSecurityDeclsStored * - customAttrsStored:ILAttributesStored * metadataIndex:int32 -> - ILMethodDef - member - With : ?name:string * ?attributes:System.Reflection.MethodAttributes * - ?implAttributes:System.Reflection.MethodImplAttributes * - ?callingConv:ILCallingConv * ?parameters:ILParameters * - ?ret:ILReturn * ?body:ILLazyMethodBody * - ?securityDecls:ILSecurityDecls * ?isEntryPoint:bool * - ?genericParams:ILGenericParameterDefs * - ?customAttrs:ILAttributes -> ILMethodDef - member WithAbstract : bool -> ILMethodDef - member WithAccess : ILMemberAccess -> ILMethodDef - member WithAggressiveInlining : bool -> ILMethodDef - member WithFinal : bool -> ILMethodDef - member WithHideBySig : unit -> ILMethodDef - member WithHideBySig : bool -> ILMethodDef - member WithNoInlining : bool -> ILMethodDef - member WithPInvoke : bool -> ILMethodDef - member WithPreserveSig : bool -> ILMethodDef - member WithRuntime : bool -> ILMethodDef - member WithSecurity : bool -> ILMethodDef - member WithSynchronized : bool -> ILMethodDef - member Access : ILMemberAccess - member Attributes : System.Reflection.MethodAttributes - member Body : ILLazyMethodBody - member CallingConv : ILCallingConv - member CallingSignature : ILCallingSignature - member Code : ILCode option - member CustomAttrs : ILAttributes - member CustomAttrsStored : ILAttributesStored - member GenericParams : ILGenericParameterDefs - member HasSecurity : bool - member ImplAttributes : System.Reflection.MethodImplAttributes - member IsAbstract : bool - member IsAggressiveInline : bool - member IsCheckAccessOnOverride : bool - member IsClassInitializer : bool - member IsConstructor : bool - member IsEntryPoint : bool - member IsFinal : bool - member IsForwardRef : bool - member IsHideBySig : bool - member IsIL : bool - member IsInternalCall : bool - member IsManaged : bool - member IsMustRun : bool - member IsNewSlot : bool - member IsNoInline : bool - member IsNonVirtualInstance : bool - member IsPreserveSig : bool - member IsReqSecObj : bool - member IsSpecialName : bool - member IsStatic : bool - member IsSynchronized : bool - member IsUnmanagedExport : bool - member IsVirtual : bool - member IsZeroInit : bool - member Locals : ILLocals - member MaxStack : int32 - member MetadataIndex : int32 - member MethodBody : ILMethodBody - member Name : string - member ParameterTypes : ILTypes - member Parameters : ILParameters - member Return : ILReturn - member SecurityDecls : ILSecurityDecls - member SecurityDeclsStored : ILSecurityDeclsStored - member SourceMarker : ILSourceMarker option - member WithNewSlot : ILMethodDef - member WithSpecialName : ILMethodDef - end - type MethodDefMap = Map - [] - type ILMethodDefs = - class - interface System.Collections.Generic.IEnumerable - interface System.Collections.IEnumerable - new : f:(unit -> ILMethodDef []) -> ILMethodDefs - member FindByName : string -> ILMethodDef list - member FindByNameAndArity : nm:string * arity:int -> ILMethodDef list - member - TryFindInstanceByNameAndCallingSignature : string * ILCallingSignature -> - ILMethodDef option - member AsArray : ILMethodDef [] - member AsList : ILMethodDef list - end - [] - type ILEventDef = - class - new : eventType:ILType option * name:string * - attributes:System.Reflection.EventAttributes * - addMethod:ILMethodRef * removeMethod:ILMethodRef * - fireMethod:ILMethodRef option * otherMethods:ILMethodRef list * - customAttrs:ILAttributes -> ILEventDef - new : eventType:ILType option * name:string * - attributes:System.Reflection.EventAttributes * - addMethod:ILMethodRef * removeMethod:ILMethodRef * - fireMethod:ILMethodRef option * otherMethods:ILMethodRef list * - customAttrsStored:ILAttributesStored * metadataIndex:int32 -> - ILEventDef - override ToString : unit -> string - member - With : ?eventType:ILType option * ?name:string * - ?attributes:System.Reflection.EventAttributes * - ?addMethod:ILMethodRef * ?removeMethod:ILMethodRef * - ?fireMethod:ILMethodRef option * ?otherMethods:ILMethodRef list * - ?customAttrs:ILAttributes -> ILEventDef - member AddMethod : ILMethodRef - member Attributes : System.Reflection.EventAttributes - member CustomAttrs : ILAttributes - member CustomAttrsStored : ILAttributesStored - [ (0))>] - member DebugText : string - member EventType : ILType option - member FireMethod : ILMethodRef option - member IsRTSpecialName : bool - member IsSpecialName : bool - member MetadataIndex : int32 - member Name : string - member OtherMethods : ILMethodRef list - member RemoveMethod : ILMethodRef - end - [] - type ILEventDefs = - | ILEvents of LazyOrderedMultiMap - with - member LookupByName : string -> ILEventDef list - member AsList : ILEventDef list - end - [] - type ILPropertyDef = - class - new : name:string * attributes:System.Reflection.PropertyAttributes * - setMethod:ILMethodRef option * getMethod:ILMethodRef option * - callingConv:ILThisConvention * propertyType:ILType * - init:ILFieldInit option * args:ILTypes * customAttrs:ILAttributes -> - ILPropertyDef - new : name:string * attributes:System.Reflection.PropertyAttributes * - setMethod:ILMethodRef option * getMethod:ILMethodRef option * - callingConv:ILThisConvention * propertyType:ILType * - init:ILFieldInit option * args:ILTypes * - customAttrsStored:ILAttributesStored * metadataIndex:int32 -> - ILPropertyDef - override ToString : unit -> string - member - With : ?name:string * ?attributes:System.Reflection.PropertyAttributes * - ?setMethod:ILMethodRef option * ?getMethod:ILMethodRef option * - ?callingConv:ILThisConvention * ?propertyType:ILType * - ?init:ILFieldInit option * ?args:ILTypes * - ?customAttrs:ILAttributes -> ILPropertyDef - member Args : ILTypes - member Attributes : System.Reflection.PropertyAttributes - member CallingConv : ILThisConvention - member CustomAttrs : ILAttributes - member CustomAttrsStored : ILAttributesStored - [ (0))>] - member DebugText : string - member GetMethod : ILMethodRef option - member Init : ILFieldInit option - member IsRTSpecialName : bool - member IsSpecialName : bool - member MetadataIndex : int32 - member Name : string - member PropertyType : ILType - member SetMethod : ILMethodRef option - end - [] - type ILPropertyDefs = - | ILProperties of LazyOrderedMultiMap - with - member LookupByName : string -> ILPropertyDef list - member AsList : ILPropertyDef list - end - val convertFieldAccess : - ilMemberAccess:ILMemberAccess -> System.Reflection.FieldAttributes - [] - type ILFieldDef = - class - new : name:string * fieldType:ILType * - attributes:System.Reflection.FieldAttributes * data:byte [] option * - literalValue:ILFieldInit option * offset:int32 option * - marshal:ILNativeType option * customAttrs:ILAttributes -> - ILFieldDef - new : name:string * fieldType:ILType * - attributes:System.Reflection.FieldAttributes * data:byte [] option * - literalValue:ILFieldInit option * offset:int32 option * - marshal:ILNativeType option * customAttrsStored:ILAttributesStored * - metadataIndex:int32 -> ILFieldDef - member - With : ?name:string * ?fieldType:ILType * - ?attributes:System.Reflection.FieldAttributes * - ?data:byte [] option * ?literalValue:ILFieldInit option * - ?offset:int32 option * ?marshal:ILNativeType option * - ?customAttrs:ILAttributes -> ILFieldDef - member WithAccess : ILMemberAccess -> ILFieldDef - member WithFieldMarshal : ILNativeType option -> ILFieldDef - member WithInitOnly : bool -> ILFieldDef - member WithLiteralDefaultValue : ILFieldInit option -> ILFieldDef - member WithNotSerialized : bool -> ILFieldDef - member WithSpecialName : bool -> ILFieldDef - member WithStatic : bool -> ILFieldDef - member Access : ILMemberAccess - member Attributes : System.Reflection.FieldAttributes - member CustomAttrs : ILAttributes - member CustomAttrsStored : ILAttributesStored - member Data : byte [] option - member FieldType : ILType - member IsInitOnly : bool - member IsLiteral : bool - member IsSpecialName : bool - member IsStatic : bool - member LiteralValue : ILFieldInit option - member Marshal : ILNativeType option - member MetadataIndex : int32 - member Name : string - member NotSerialized : bool - member Offset : int32 option - end - [] - type ILFieldDefs = - | ILFields of LazyOrderedMultiMap - with - member LookupByName : string -> ILFieldDef list - member AsList : ILFieldDef list - end - type ILMethodImplDef = - { Overrides: ILOverridesSpec - OverrideBy: ILMethodSpec } - [] - type ILMethodImplDefs = - | ILMethodImpls of System.Lazy - with - member AsList : ILMethodImplDef list - end - and MethodImplsMap = Map<(string * int),ILMethodImplDef list> - [] - type ILTypeDefLayout = - | Auto - | Sequential of ILTypeDefLayoutInfo - | Explicit of ILTypeDefLayoutInfo - and ILTypeDefLayoutInfo = - { Size: int32 option - Pack: uint16 option } - [] - type ILTypeInit = - | BeforeField - | OnAny - [] - type ILDefaultPInvokeEncoding = - | Ansi - | Auto - | Unicode - [] - type ILTypeDefAccess = - | Public - | Private - | Nested of ILMemberAccess - val typeAccessOfFlags : flags:int -> ILTypeDefAccess - val typeEncodingOfFlags : flags:int -> ILDefaultPInvokeEncoding - [] - type ILTypeDefKind = - | Class - | ValueType - | Interface - | Enum - | Delegate - val typeKindOfFlags : - nm:string -> super:ILType option -> flags:int -> ILTypeDefKind - val convertTypeAccessFlags : - access:ILTypeDefAccess -> System.Reflection.TypeAttributes - val convertTypeKind : kind:ILTypeDefKind -> System.Reflection.TypeAttributes - val convertLayout : - layout:ILTypeDefLayout -> System.Reflection.TypeAttributes - val convertEncoding : - encoding:ILDefaultPInvokeEncoding -> System.Reflection.TypeAttributes - val convertToNestedTypeAccess : - ilMemberAccess:ILMemberAccess -> System.Reflection.TypeAttributes - val convertInitSemantics : - init:ILTypeInit -> System.Reflection.TypeAttributes - [] - type ILTypeDef = - class - new : name:string * attributes:System.Reflection.TypeAttributes * - layout:ILTypeDefLayout * implements:ILTypes * - genericParams:ILGenericParameterDefs * extends:ILType option * - methods:ILMethodDefs * nestedTypes:ILTypeDefs * fields:ILFieldDefs * - methodImpls:ILMethodImplDefs * events:ILEventDefs * - properties:ILPropertyDefs * securityDecls:ILSecurityDecls * - customAttrs:ILAttributes -> ILTypeDef - new : name:string * attributes:System.Reflection.TypeAttributes * - layout:ILTypeDefLayout * implements:ILTypes * - genericParams:ILGenericParameterDefs * extends:ILType option * - methods:ILMethodDefs * nestedTypes:ILTypeDefs * fields:ILFieldDefs * - methodImpls:ILMethodImplDefs * events:ILEventDefs * - properties:ILPropertyDefs * - securityDeclsStored:ILSecurityDeclsStored * - customAttrsStored:ILAttributesStored * metadataIndex:int32 -> - ILTypeDef - member - With : ?name:string * ?attributes:System.Reflection.TypeAttributes * - ?layout:ILTypeDefLayout * ?implements:ILTypes * - ?genericParams:ILGenericParameterDefs * ?extends:ILType option * - ?methods:ILMethodDefs * ?nestedTypes:ILTypeDefs * - ?fields:ILFieldDefs * ?methodImpls:ILMethodImplDefs * - ?events:ILEventDefs * ?properties:ILPropertyDefs * - ?customAttrs:ILAttributes * ?securityDecls:ILSecurityDecls -> - ILTypeDef - member WithAbstract : bool -> ILTypeDef - member WithAccess : ILTypeDefAccess -> ILTypeDef - member WithEncoding : ILDefaultPInvokeEncoding -> ILTypeDef - member WithHasSecurity : bool -> ILTypeDef - member WithImport : bool -> ILTypeDef - member WithInitSemantics : ILTypeInit -> ILTypeDef - member WithKind : ILTypeDefKind -> ILTypeDef - member WithLayout : ILTypeDefLayout -> ILTypeDef - member WithNestedAccess : ILMemberAccess -> ILTypeDef - member WithSealed : bool -> ILTypeDef - member WithSerializable : bool -> ILTypeDef - member WithSpecialName : bool -> ILTypeDef - member Access : ILTypeDefAccess - member Attributes : System.Reflection.TypeAttributes - member CustomAttrs : ILAttributes - member CustomAttrsStored : ILAttributesStored - member Encoding : ILDefaultPInvokeEncoding - member Events : ILEventDefs - member Extends : ILType option - member Fields : ILFieldDefs - member GenericParams : ILGenericParameterDefs - member HasSecurity : bool - member Implements : ILTypes - member IsAbstract : bool - member IsClass : bool - member IsComInterop : bool - member IsDelegate : bool - member IsEnum : bool - member IsInterface : bool - member IsSealed : bool - member IsSerializable : bool - member IsSpecialName : bool - member IsStruct : bool - member IsStructOrEnum : bool - member Layout : ILTypeDefLayout - member MetadataIndex : int32 - member MethodImpls : ILMethodImplDefs - member Methods : ILMethodDefs - member Name : string - member NestedTypes : ILTypeDefs - member Properties : ILPropertyDefs - member SecurityDecls : ILSecurityDecls - member SecurityDeclsStored : ILSecurityDeclsStored - end - [] - and ILTypeDefs = - class - interface System.Collections.Generic.IEnumerable - interface System.Collections.IEnumerable - new : f:(unit -> ILPreTypeDef []) -> ILTypeDefs - member FindByName : string -> ILTypeDef - member AsArray : ILTypeDef [] - member AsArrayOfPreTypeDefs : ILPreTypeDef [] - member AsList : ILTypeDef list - end - [] - and ILPreTypeDef = - interface - abstract member GetTypeDef : unit -> ILTypeDef - abstract member Name : string - abstract member Namespace : string list - end - [] - and ILPreTypeDefImpl = - class - interface ILPreTypeDef - new : nameSpace:string list * name:string * metadataIndex:int32 * - storage:ILTypeDefStored -> ILPreTypeDefImpl - end - [] - and ILTypeDefStored = - | Given of ILTypeDef - | Reader of (int32 -> ILTypeDef) - | Computed of (unit -> ILTypeDef) - val mkILTypeDefReader : (int32 -> ILTypeDef) -> ILTypeDefStored - type ILNestedExportedType = - { Name: string - Access: ILMemberAccess - Nested: ILNestedExportedTypes - CustomAttrsStored: ILAttributesStored - MetadataIndex: int32 } - with - member CustomAttrs : ILAttributes - end - [] - and ILNestedExportedTypes = - | ILNestedExportedTypes of System.Lazy> - with - member AsList : ILNestedExportedType list - end - [] - and ILExportedTypeOrForwarder = - { ScopeRef: ILScopeRef - Name: string - Attributes: System.Reflection.TypeAttributes - Nested: ILNestedExportedTypes - CustomAttrsStored: ILAttributesStored - MetadataIndex: int32 } - with - member Access : ILTypeDefAccess - member CustomAttrs : ILAttributes - member IsForwarder : bool - end - [] - and ILExportedTypesAndForwarders = - | ILExportedTypesAndForwarders of - System.Lazy> - with - member TryFindByName : string -> ILExportedTypeOrForwarder option - member AsList : ILExportedTypeOrForwarder list - end - [] - type ILResourceAccess = - | Public - | Private - [] - type ILResourceLocation = - | Local of Internal.ByteStorage - | File of ILModuleRef * int32 - | Assembly of ILAssemblyRef - type ILResource = - { Name: string - Location: ILResourceLocation - Access: ILResourceAccess - CustomAttrsStored: ILAttributesStored - MetadataIndex: int32 } - with - member GetBytes : unit -> Internal.ReadOnlyByteMemory - member CustomAttrs : ILAttributes - end - [] - type ILResources = - | ILResources of ILResource list - with - member AsList : ILResource list - end - [] - type ILAssemblyLongevity = - | Unspecified - | Library - | PlatformAppDomain - | PlatformProcess - | PlatformSystem - type ILAssemblyManifest = - { Name: string - AuxModuleHashAlgorithm: int32 - SecurityDeclsStored: ILSecurityDeclsStored - PublicKey: byte [] option - Version: ILVersionInfo option - Locale: Locale option - CustomAttrsStored: ILAttributesStored - AssemblyLongevity: ILAssemblyLongevity - DisableJitOptimizations: bool - JitTracking: bool - IgnoreSymbolStoreSequencePoints: bool - Retargetable: bool - ExportedTypes: ILExportedTypesAndForwarders - EntrypointElsewhere: ILModuleRef option - MetadataIndex: int32 } - with - member CustomAttrs : ILAttributes - member SecurityDecls : ILSecurityDecls - end - [] - type ILNativeResource = - | In of - fileName: string * linkedResourceBase: int * linkedResourceStart: int * - linkedResourceLength: int - | Out of unlinkedResource: byte [] - type ILModuleDef = - { Manifest: ILAssemblyManifest option - Name: string - TypeDefs: ILTypeDefs - SubsystemVersion: int * int - UseHighEntropyVA: bool - SubSystemFlags: int32 - IsDLL: bool - IsILOnly: bool - Platform: ILPlatform option - StackReserveSize: int32 option - Is32Bit: bool - Is32BitPreferred: bool - Is64Bit: bool - VirtualAlignment: int32 - PhysicalAlignment: int32 - ImageBase: int32 - MetadataVersion: string - Resources: ILResources - NativeResources: ILNativeResource list - CustomAttrsStored: ILAttributesStored - MetadataIndex: int32 } - with - member CustomAttrs : ILAttributes - member HasManifest : bool - member ManifestOfAssembly : ILAssemblyManifest - end - val mkILEmptyGenericParams : ILGenericParameterDefs - val emptyILGenericArgsList : ILType list - val mkILNestedTyRef : ILScopeRef * string list * string -> ILTypeRef - val mkILTyRef : ILScopeRef * string -> ILTypeRef - type ILGenericArgsList = ILType list - val mkILTySpec : ILTypeRef * ILGenericArgs -> ILTypeSpec - val mkILNonGenericTySpec : ILTypeRef -> ILTypeSpec - val mkILTyRefInTyRef : ILTypeRef * string -> ILTypeRef - val mkILTy : ILBoxity -> ILTypeSpec -> ILType - val mkILNamedTy : ILBoxity -> ILTypeRef -> ILGenericArgs -> ILType - val mkILValueTy : ILTypeRef -> ILGenericArgs -> ILType - val mkILBoxedTy : ILTypeRef -> ILGenericArgs -> ILType - val mkILNonGenericValueTy : ILTypeRef -> ILType - val mkILNonGenericBoxedTy : ILTypeRef -> ILType - val mkSimpleAssemblyRef : string -> ILAssemblyRef - val mkSimpleModRef : string -> ILModuleRef - val typeNameForGlobalFunctions : string - val mkILTypeForGlobalFunctions : ILScopeRef -> ILType - val isTypeNameForGlobalFunctions : string -> bool - val mkILMethRef : - ILTypeRef * ILCallingConv * string * int * ILTypes * ILType -> ILMethodRef - val mkILMethSpecForMethRefInTy : - ILMethodRef * ILType * ILGenericArgs -> ILMethodSpec - val mkILMethSpec : - ILMethodRef * ILBoxity * ILGenericArgs * ILGenericArgs -> ILMethodSpec - val mkILMethSpecInTypeRef : - tref:ILTypeRef * vc:ILBoxity * cc:ILCallingConv * nm:string * args:ILTypes * - rty:ILType * tinst:ILGenericArgs * minst:ILType list -> ILMethodSpec - val mkILMethSpecInTy : - ILType * ILCallingConv * string * ILTypes * ILType * ILGenericArgs -> - ILMethodSpec - val mkILNonGenericMethSpecInTy : - ILType * ILCallingConv * string * ILTypes * ILType -> ILMethodSpec - val mkILInstanceMethSpecInTy : - ILType * string * ILTypes * ILType * ILGenericArgs -> ILMethodSpec - val mkILNonGenericInstanceMethSpecInTy : - ILType * string * ILTypes * ILType -> ILMethodSpec - val mkILStaticMethSpecInTy : - ILType * string * ILTypes * ILType * ILGenericArgs -> ILMethodSpec - val mkILNonGenericStaticMethSpecInTy : - ILType * string * ILTypes * ILType -> ILMethodSpec - val mkILCtorMethSpec : - tref:ILTypeRef * args:ILTypes * cinst:ILGenericArgs -> ILMethodSpec - val mkILCtorMethSpecForTy : ILType * ILTypes -> ILMethodSpec - val mkILNonGenericCtorMethSpec : - tref:ILTypeRef * args:ILTypes -> ILMethodSpec - val mkILFieldRef : ILTypeRef * string * ILType -> ILFieldRef - val mkILFieldSpec : ILFieldRef * ILType -> ILFieldSpec - val mkILFieldSpecInTy : ILType * string * ILType -> ILFieldSpec - val andTailness : ILTailcall -> bool -> ILTailcall - val formatCodeLabel : int -> string - val codeLabelCount : int ref - val generateCodeLabel : unit -> int - val instrIsRet : i:ILInstr -> bool - val nonBranchingInstrsToCode : ILInstr list -> ILCode - val mkILTyvarTy : uint16 -> ILType - val mkILSimpleTypar : string -> ILGenericParameterDef - val gparam_of_gactual : _ga:ILType -> ILGenericParameterDef - val mkILFormalTypars : ILGenericArgsList -> ILGenericParameterDef list - val mkILFormalGenericArgs : int -> ILGenericParameterDefs -> ILType list - val mkILFormalBoxedTy : ILTypeRef -> ILGenericParameterDefs -> ILType - val mkILFormalNamedTy : - ILBoxity -> ILTypeRef -> ILGenericParameterDefs -> ILType - val mkRefForNestedILTypeDef : - ILScopeRef -> ILTypeDef list * ILTypeDef -> ILTypeRef - val mkILPreTypeDef : ILTypeDef -> ILPreTypeDef - val mkILPreTypeDefComputed : - string list * string * (unit -> ILTypeDef) -> ILPreTypeDef - val mkILPreTypeDefRead : - string list * string * int32 * ILTypeDefStored -> ILPreTypeDef - val addILTypeDef : ILTypeDef -> ILTypeDefs -> ILTypeDefs - val mkILTypeDefsFromArray : ILTypeDef [] -> ILTypeDefs - val mkILTypeDefs : ILTypeDef list -> ILTypeDefs - val mkILTypeDefsComputed : (unit -> ILPreTypeDef []) -> ILTypeDefs - val emptyILTypeDefs : ILTypeDefs - val mkILMethodsFromArray : ILMethodDef [] -> ILMethodDefs - val mkILMethods : ILMethodDef list -> ILMethodDefs - val mkILMethodsComputed : (unit -> ILMethodDef []) -> ILMethodDefs - val emptyILMethods : ILMethodDefs - val filterILMethodDefs : - f:(ILMethodDef -> bool) -> mdefs:ILMethodDefs -> ILMethodDefs - val defaultSubSystem : int - val defaultPhysAlignment : int - val defaultVirtAlignment : int - val defaultImageBase : int - val mkILArrTy : ILType * ILArrayShape -> ILType - val mkILArr1DTy : ILType -> ILType - val isILArrTy : ILType -> bool - val destILArrTy : ILType -> ILArrayShape * ILType - [] - val tname_Object : string = "System.Object" - [] - val tname_String : string = "System.String" - [] - val tname_Array : string = "System.Array" - [] - val tname_Type : string = "System.Type" - [] - val tname_Int64 : string = "System.Int64" - [] - val tname_UInt64 : string = "System.UInt64" - [] - val tname_Int32 : string = "System.Int32" - [] - val tname_UInt32 : string = "System.UInt32" - [] - val tname_Int16 : string = "System.Int16" - [] - val tname_UInt16 : string = "System.UInt16" - [] - val tname_SByte : string = "System.SByte" - [] - val tname_Byte : string = "System.Byte" - [] - val tname_Single : string = "System.Single" - [] - val tname_Double : string = "System.Double" - [] - val tname_Bool : string = "System.Boolean" - [] - val tname_Char : string = "System.Char" - [] - val tname_IntPtr : string = "System.IntPtr" - [] - val tname_UIntPtr : string = "System.UIntPtr" - [] - val tname_TypedReference : string = "System.TypedReference" - [] - type ILGlobals = - class - new : primaryScopeRef:ILScopeRef * - assembliesThatForwardToPrimaryAssembly:ILAssemblyRef list -> - ILGlobals - member IsPossiblePrimaryAssemblyRef : ILAssemblyRef -> bool - override ToString : unit -> string - [ (0))>] - member DebugText : string - member primaryAssemblyName : string - member primaryAssemblyRef : ILAssemblyRef - member primaryAssemblyScopeRef : ILScopeRef - member typ_Array : ILType - member typ_Bool : ILType - member typ_Byte : ILType - member typ_Char : ILType - member typ_Double : ILType - member typ_Int16 : ILType - member typ_Int32 : ILType - member typ_Int64 : ILType - member typ_IntPtr : ILType - member typ_Object : ILType - member typ_SByte : ILType - member typ_Single : ILType - member typ_String : ILType - member typ_Type : ILType - member typ_TypedReference : ILType - member typ_UInt16 : ILType - member typ_UInt32 : ILType - member typ_UInt64 : ILType - member typ_UIntPtr : ILType - end - val mkILGlobals : - primaryScopeRef:ILScopeRef * - assembliesThatForwardToPrimaryAssembly:ILAssemblyRef list -> ILGlobals - val mkNormalCall : ILMethodSpec -> ILInstr - val mkNormalCallvirt : ILMethodSpec -> ILInstr - val mkNormalCallconstraint : ILType * ILMethodSpec -> ILInstr - val mkNormalNewobj : ILMethodSpec -> ILInstr - val ldargs : ILInstr [] - val mkLdarg : uint16 -> ILInstr - val mkLdarg0 : ILInstr - val ldlocs : ILInstr [] - val mkLdloc : uint16 -> ILInstr - val stlocs : ILInstr [] - val mkStloc : uint16 -> ILInstr - val ldi32s : ILInstr [] - val mkLdcInt32 : int -> ILInstr - val tname_CompilerGeneratedAttribute : string - val tname_DebuggableAttribute : string - val ecmaPublicKey : PublicKey - val isILBoxedTy : _arg1:ILType -> bool - val isILValueTy : _arg1:ILType -> bool - val isBuiltInTySpec : ilg:ILGlobals -> tspec:ILTypeSpec -> n:string -> bool - val isILBoxedBuiltInTy : ilg:ILGlobals -> ty:ILType -> n:string -> bool - val isILValueBuiltInTy : ilg:ILGlobals -> ty:ILType -> n:string -> bool - val isILObjectTy : ILGlobals -> ILType -> bool - val isILStringTy : ILGlobals -> ILType -> bool - val isILTypedReferenceTy : ILGlobals -> ILType -> bool - val isILSByteTy : ILGlobals -> ILType -> bool - val isILByteTy : ILGlobals -> ILType -> bool - val isILInt16Ty : ILGlobals -> ILType -> bool - val isILUInt16Ty : ILGlobals -> ILType -> bool - val isILInt32Ty : ILGlobals -> ILType -> bool - val isILUInt32Ty : ILGlobals -> ILType -> bool - val isILInt64Ty : ILGlobals -> ILType -> bool - val isILUInt64Ty : ILGlobals -> ILType -> bool - val isILIntPtrTy : ILGlobals -> ILType -> bool - val isILUIntPtrTy : ILGlobals -> ILType -> bool - val isILBoolTy : ILGlobals -> ILType -> bool - val isILCharTy : ILGlobals -> ILType -> bool - val isILSingleTy : ILGlobals -> ILType -> bool - val isILDoubleTy : ILGlobals -> ILType -> bool - val rescopeILScopeRef : ILScopeRef -> ILScopeRef -> ILScopeRef - val rescopeILTypeRef : scoref:ILScopeRef -> tref1:ILTypeRef -> ILTypeRef - val rescopeILTypeSpec : ILScopeRef -> ILTypeSpec -> ILTypeSpec - val rescopeILType : ILScopeRef -> ILType -> ILType - val rescopeILTypes : scoref:ILScopeRef -> i:ILGenericArgs -> ILGenericArgs - val rescopeILCallSig : - scoref:ILScopeRef -> csig:ILCallingSignature -> ILCallingSignature - val rescopeILMethodRef : ILScopeRef -> ILMethodRef -> ILMethodRef - val rescopeILFieldRef : ILScopeRef -> ILFieldRef -> ILFieldRef - val instILTypeSpecAux : - numFree:int -> inst:ILGenericArgs -> tspec:ILTypeSpec -> ILTypeSpec - val instILTypeAux : int -> ILGenericArgs -> ILType -> ILType - val instILGenericArgsAux : - numFree:int -> inst:ILGenericArgs -> i:ILGenericArgs -> ILGenericArgs - val instILCallSigAux : - numFree:int -> - inst:ILGenericArgs -> csig:ILCallingSignature -> ILCallingSignature - val instILType : ILGenericArgs -> ILType -> ILType - val mkILParam : string option * ILType -> ILParameter - val mkILParamNamed : string * ILType -> ILParameter - val mkILParamAnon : ILType -> ILParameter - val mkILReturn : ILType -> ILReturn - val mkILLocal : ILType -> (string * int * int) option -> ILLocal - val mkILMethodBody : - initlocals:bool * ILLocals * int32 * ILCode * ILSourceMarker option -> - ILMethodBody - val mkMethodBody : - bool * ILLocals * int32 * ILCode * ILSourceMarker option -> MethodBody - val mkILVoidReturn : ILReturn - val methBodyNotAvailable : ILLazyMethodBody - val methBodyAbstract : ILLazyMethodBody - val methBodyNative : ILLazyMethodBody - val mkILCtor : ILMemberAccess * ILParameters * MethodBody -> ILMethodDef - val mkCallBaseConstructor : ILType * ILType list -> ILInstr list - val mkNormalStfld : ILFieldSpec -> ILInstr - val mkNormalStsfld : ILFieldSpec -> ILInstr - val mkNormalLdsfld : ILFieldSpec -> ILInstr - val mkNormalLdfld : ILFieldSpec -> ILInstr - val mkNormalLdflda : ILFieldSpec -> ILInstr - val mkNormalLdobj : ILType -> ILInstr - val mkNormalStobj : ILType -> ILInstr - val mkILNonGenericEmptyCtor : ILSourceMarker option -> ILType -> ILMethodDef - val mkILStaticMethod : - ILGenericParameterDefs * string * ILMemberAccess * ILParameters * ILReturn * - MethodBody -> ILMethodDef - val mkILNonGenericStaticMethod : - string * ILMemberAccess * ILParameters * ILReturn * MethodBody -> - ILMethodDef - val mkILClassCtor : MethodBody -> ILMethodDef - val mk_ospec : - ty:ILType * callconv:ILCallingConv * nm:string * genparams:int * - formal_args:ILTypes * formal_ret:ILType -> ILOverridesSpec - val mkILGenericVirtualMethod : - string * ILMemberAccess * ILGenericParameterDefs * ILParameters * ILReturn * - MethodBody -> ILMethodDef - val mkILNonGenericVirtualMethod : - string * ILMemberAccess * ILParameters * ILReturn * MethodBody -> - ILMethodDef - val mkILGenericNonVirtualMethod : - string * ILMemberAccess * ILGenericParameterDefs * ILParameters * ILReturn * - MethodBody -> ILMethodDef - val mkILNonGenericInstanceMethod : - string * ILMemberAccess * ILParameters * ILReturn * MethodBody -> - ILMethodDef - val ilmbody_code2code : - f:(ILCode -> ILCode) -> il:ILMethodBody -> ILMethodBody - val mdef_code2code : f:(ILCode -> ILCode) -> md:ILMethodDef -> ILMethodDef - val prependInstrsToCode : ILInstr list -> ILCode -> ILCode - val prependInstrsToMethod : ILInstr list -> ILMethodDef -> ILMethodDef - val cdef_cctorCode2CodeOrCreate : - tag:ILSourceMarker option -> - f:(ILMethodDef -> ILMethodDef) -> cd:ILTypeDef -> ILTypeDef - val code_of_mdef : md:ILMethodDef -> ILCode - val mkRefToILMethod : ILTypeRef * ILMethodDef -> ILMethodRef - val mkRefToILField : ILTypeRef * ILFieldDef -> ILFieldRef - val mkRefForILMethod : - ILScopeRef -> ILTypeDef list * ILTypeDef -> ILMethodDef -> ILMethodRef - val mkRefForILField : - ILScopeRef -> ILTypeDef list * ILTypeDef -> ILFieldDef -> ILFieldRef - val prependInstrsToClassCtor : - ILInstr list -> ILSourceMarker option -> ILTypeDef -> ILTypeDef - val mkILField : - isStatic:bool * nm:string * ty:ILType * init:ILFieldInit option * - at:byte [] option * access:ILMemberAccess * isLiteral:bool -> ILFieldDef - val mkILInstanceField : - string * ILType * ILFieldInit option * ILMemberAccess -> ILFieldDef - val mkILStaticField : - string * ILType * ILFieldInit option * byte [] option * ILMemberAccess -> - ILFieldDef - val mkILLiteralField : - string * ILType * ILFieldInit * byte [] option * ILMemberAccess -> - ILFieldDef - type ILLocalsAllocator = - class - new : preAlloc:int -> ILLocalsAllocator - member AllocLocal : ILLocal -> uint16 - member Close : unit -> ILLocal list - end - val mkILFieldsLazy : System.Lazy -> ILFieldDefs - val mkILFields : ILFieldDef list -> ILFieldDefs - val emptyILFields : ILFieldDefs - val mkILEventsLazy : System.Lazy -> ILEventDefs - val mkILEvents : ILEventDef list -> ILEventDefs - val emptyILEvents : ILEventDefs - val mkILPropertiesLazy : System.Lazy -> ILPropertyDefs - val mkILProperties : ILPropertyDef list -> ILPropertyDefs - val emptyILProperties : ILPropertyDefs - val addExportedTypeToTable : - y:ILExportedTypeOrForwarder -> - tab:Map -> - Map - val mkILExportedTypes : - ILExportedTypeOrForwarder list -> ILExportedTypesAndForwarders - val mkILExportedTypesLazy : - System.Lazy -> - ILExportedTypesAndForwarders - val addNestedExportedTypeToTable : - y:ILNestedExportedType -> - tab:Map -> Map - val mkTypeForwarder : - ILScopeRef -> - string -> - ILNestedExportedTypes -> - ILAttributes -> ILTypeDefAccess -> ILExportedTypeOrForwarder - val mkILNestedExportedTypes : - ILNestedExportedType list -> ILNestedExportedTypes - val mkILNestedExportedTypesLazy : - System.Lazy -> ILNestedExportedTypes - val mkILResources : ILResource list -> ILResources - val addMethodImplToTable : - y:ILMethodImplDef -> - tab:Map<(string * int),ILMethodImplDef list> -> - Map<(string * int),ILMethodImplDef list> - val mkILMethodImpls : ILMethodImplDef list -> ILMethodImplDefs - val mkILMethodImplsLazy : - System.Lazy -> ILMethodImplDefs - val emptyILMethodImpls : ILMethodImplDefs - val mkILStorageCtorWithParamNames : - tag:ILSourceMarker option * preblock:ILInstr list * ty:ILType * - extraParams:ILParameter list * flds:(string * string * ILType) list * - access:ILMemberAccess -> ILMethodDef - val mkILSimpleStorageCtorWithParamNames : - ILSourceMarker option * ILTypeSpec option * ILType * ILParameter list * - (string * string * ILType) list * ILMemberAccess -> ILMethodDef - val addParamNames : flds:('a * 'b) list -> ('a * 'a * 'b) list - val mkILSimpleStorageCtor : - ILSourceMarker option * ILTypeSpec option * ILType * ILParameter list * - (string * ILType) list * ILMemberAccess -> ILMethodDef - val mkILStorageCtor : - ILSourceMarker option * ILInstr list * ILType * (string * ILType) list * - ILMemberAccess -> ILMethodDef - val mkILGenericClass : - string * ILTypeDefAccess * ILGenericParameterDefs * ILType * ILTypes * - ILMethodDefs * ILFieldDefs * ILTypeDefs * ILPropertyDefs * ILEventDefs * - ILAttributes * ILTypeInit -> ILTypeDef - val mkRawDataValueTypeDef : - ILType -> string * size:int32 * pack:uint16 -> ILTypeDef - val mkILSimpleClass : - ILGlobals -> - string * ILTypeDefAccess * ILMethodDefs * ILFieldDefs * ILTypeDefs * - ILPropertyDefs * ILEventDefs * ILAttributes * ILTypeInit -> ILTypeDef - val mkILTypeDefForGlobalFunctions : - ILGlobals -> ILMethodDefs * ILFieldDefs -> ILTypeDef - val destTypeDefsWithGlobalFunctionsFirst : - ILGlobals -> ILTypeDefs -> ILTypeDef list - val mkILSimpleModule : - assemblyName:string -> - moduleName:string -> - dll:bool -> - subsystemVersion:(int * int) -> - useHighEntropyVA:bool -> - ILTypeDefs -> - int32 option -> - Locale option -> - int -> - ILExportedTypesAndForwarders -> string -> ILModuleDef - val buildILCode : - string -> - lab2pc:System.Collections.Generic.Dictionary -> - instrs:ILInstr [] -> - ILExceptionSpec list -> ILLocalDebugInfo list -> ILCode - val mkILDelegateMethods : - ILMemberAccess -> - ILGlobals -> - ILType * ILType -> ILParameters * ILReturn -> ILMethodDef list - val mkCtorMethSpecForDelegate : ILGlobals -> ILType * bool -> ILMethodSpec - type ILEnumInfo = - { enumValues: (string * ILFieldInit) list - enumType: ILType } - val getTyOfILEnumInfo : ILEnumInfo -> ILType - val computeILEnumInfo : string * ILFieldDefs -> ILEnumInfo - val sigptr_get_byte : bytes:byte [] -> sigptr:int -> int * int - val sigptr_get_bool : bytes:byte [] -> sigptr:int -> bool * int - val sigptr_get_u8 : bytes:byte [] -> sigptr:int -> byte * int - val sigptr_get_i8 : bytes:byte [] -> sigptr:int -> sbyte * int - val sigptr_get_u16 : bytes:byte [] -> sigptr:int -> uint16 * int - val sigptr_get_i16 : bytes:byte [] -> sigptr:int -> int16 * int - val sigptr_get_i32 : bytes:byte [] -> sigptr:int -> int * int - val sigptr_get_u32 : bytes:byte [] -> sigptr:int -> uint32 * int - val sigptr_get_i64 : bytes:byte [] -> sigptr:int -> int64 * int - val sigptr_get_u64 : bytes:byte [] -> sigptr:int -> uint64 * int - val float32_of_bits : x:int32 -> float32 - val float_of_bits : x:int64 -> float - val sigptr_get_ieee32 : bytes:byte [] -> sigptr:int -> float32 * int - val sigptr_get_ieee64 : bytes:byte [] -> sigptr:int -> float * int - val sigptr_get_intarray : - n:int -> bytes:byte [] -> sigptr:int -> byte [] * int - val sigptr_get_string : n:int -> bytes:byte [] -> sigptr:int -> string * int - val sigptr_get_z_i32 : bytes:byte [] -> sigptr:int -> int * int - val sigptr_get_serstring : bytes:byte [] -> sigptr:int -> string * int - val sigptr_get_serstring_possibly_null : - bytes:byte [] -> sigptr:int -> string option * int - val mkRefToILAssembly : ILAssemblyManifest -> ILAssemblyRef - val z_unsigned_int_size : n:int -> int - val z_unsigned_int : n:int -> byte [] - val string_as_utf8_bytes : s:string -> byte [] - val dw7 : n:int64 -> byte - val dw6 : n:int64 -> byte - val dw5 : n:int64 -> byte - val dw4 : n:int64 -> byte - val dw3 : n:int64 -> byte - val dw2 : n:int64 -> byte - val dw1 : n:int64 -> byte - val dw0 : n:int64 -> byte - val u8AsBytes : i:byte -> byte [] - val u16AsBytes : x:uint16 -> byte [] - val i32AsBytes : i:int -> byte [] - val i64AsBytes : i:int64 -> byte [] - val i8AsBytes : i:sbyte -> byte [] - val i16AsBytes : i:int16 -> byte [] - val u32AsBytes : i:uint32 -> byte [] - val u64AsBytes : i:uint64 -> byte [] - val bits_of_float32 : x:float32 -> int - val bits_of_float : x:float -> int64 - val ieee32AsBytes : i:float32 -> byte [] - val ieee64AsBytes : i:float -> byte [] - val et_END : byte - val et_VOID : byte - val et_BOOLEAN : byte - val et_CHAR : byte - val et_I1 : byte - val et_U1 : byte - val et_I2 : byte - val et_U2 : byte - val et_I4 : byte - val et_U4 : byte - val et_I8 : byte - val et_U8 : byte - val et_R4 : byte - val et_R8 : byte - val et_STRING : byte - val et_PTR : byte - val et_BYREF : byte - val et_VALUETYPE : byte - val et_CLASS : byte - val et_VAR : byte - val et_ARRAY : byte - val et_WITH : byte - val et_TYPEDBYREF : byte - val et_I : byte - val et_U : byte - val et_FNPTR : byte - val et_OBJECT : byte - val et_SZARRAY : byte - val et_MVAR : byte - val et_CMOD_REQD : byte - val et_CMOD_OPT : byte - val formatILVersion : ILVersionInfo -> string - val encodeCustomAttrString : s:string -> byte [] - val encodeCustomAttrElemType : x:ILType -> byte [] - val encodeCustomAttrElemTypeForObject : x:ILAttribElem -> byte [] - val decodeCustomAttrElemType : - ilg:ILGlobals -> bytes:byte [] -> sigptr:int -> x:byte -> ILType * int - val encodeCustomAttrPrimValue : ilg:'a -> c:ILAttribElem -> byte [] - val encodeCustomAttrValue : ilg:'a -> ty:ILType -> c:ILAttribElem -> byte [] - val encodeCustomAttrNamedArg : - ilg:'a -> nm:string * ty:ILType * prop:bool * elem:ILAttribElem -> byte [] - val encodeCustomAttrArgs : - ilg:ILGlobals -> - mspec:ILMethodSpec -> - fixedArgs:ILAttribElem list -> - namedArgs:(string * ILType * bool * ILAttribElem) list -> byte [] - val encodeCustomAttr : - ilg:ILGlobals -> - mspec:ILMethodSpec * fixedArgs:ILAttribElem list * - namedArgs:(string * ILType * bool * ILAttribElem) list -> ILAttribute - val mkILCustomAttribMethRef : - ILGlobals -> - ILMethodSpec * ILAttribElem list * - (string * ILType * bool * ILAttribElem) list -> ILAttribute - val mkILCustomAttribute : - ILGlobals -> - ILTypeRef * ILTypes * ILAttribElem list * - (string * ILType * bool * ILAttribElem) list -> ILAttribute - val getCustomAttrData : ILGlobals -> ILAttribute -> byte [] - val MscorlibScopeRef : ILScopeRef - val EcmaMscorlibILGlobals : ILGlobals - val PrimaryAssemblyILGlobals : ILGlobals - val mkPermissionSet : - ILGlobals -> - ILSecurityAction * - (ILTypeRef * (string * ILType * ILAttribElem) list) list -> - ILSecurityDecl - type ILTypeSigParser = - class - new : tstring:string -> ILTypeSigParser - member private ParseType : unit -> ILType - member ParseTypeSpec : unit -> ILAttribElem - end - val decodeILAttribData : - ILGlobals -> ILAttribute -> ILAttribElem list * ILAttributeNamedArg list - type ILReferences = - { AssemblyReferences: ILAssemblyRef list - ModuleReferences: ILModuleRef list } - type ILReferencesAccumulator = - { ilg: ILGlobals - refsA: System.Collections.Generic.HashSet - refsM: System.Collections.Generic.HashSet } - val emptyILRefs : ILReferences - val refs_of_assemblyRef : - s:ILReferencesAccumulator -> x:ILAssemblyRef -> unit - val refs_of_modref : s:ILReferencesAccumulator -> x:ILModuleRef -> unit - val refs_of_scoref : s:ILReferencesAccumulator -> x:ILScopeRef -> unit - val refs_of_tref : s:ILReferencesAccumulator -> x:ILTypeRef -> unit - val refs_of_typ : s:ILReferencesAccumulator -> x:ILType -> unit - val refs_of_inst : s:ILReferencesAccumulator -> i:ILGenericArgs -> unit - val refs_of_tspec : s:ILReferencesAccumulator -> x:ILTypeSpec -> unit - val refs_of_callsig : - s:ILReferencesAccumulator -> csig:ILCallingSignature -> unit - val refs_of_genparam : - s:ILReferencesAccumulator -> x:ILGenericParameterDef -> unit - val refs_of_genparams : - s:ILReferencesAccumulator -> b:ILGenericParameterDef list -> unit - val refs_of_dloc : s:ILReferencesAccumulator -> ts:ILTypeRef -> unit - val refs_of_mref : s:ILReferencesAccumulator -> x:ILMethodRef -> unit - val refs_of_fref : s:ILReferencesAccumulator -> x:ILFieldRef -> unit - val refs_of_ospec : s:ILReferencesAccumulator -> ILOverridesSpec -> unit - val refs_of_mspec : s:ILReferencesAccumulator -> x:ILMethodSpec -> unit - val refs_of_fspec : s:ILReferencesAccumulator -> x:ILFieldSpec -> unit - val refs_of_tys : s:ILReferencesAccumulator -> l:ILGenericArgs -> unit - val refs_of_token : s:ILReferencesAccumulator -> x:ILToken -> unit - val refs_of_custom_attr : - s:ILReferencesAccumulator -> cattr:ILAttribute -> unit - val refs_of_custom_attrs : - s:ILReferencesAccumulator -> cas:ILAttributes -> unit - val refs_of_varargs : - s:ILReferencesAccumulator -> tyso:ILGenericArgs option -> unit - val refs_of_instr : s:ILReferencesAccumulator -> x:ILInstr -> unit - val refs_of_il_code : s:ILReferencesAccumulator -> c:ILCode -> unit - val refs_of_ilmbody : s:ILReferencesAccumulator -> il:ILMethodBody -> unit - val refs_of_local : s:ILReferencesAccumulator -> loc:ILLocal -> unit - val refs_of_mbody : s:ILReferencesAccumulator -> x:MethodBody -> unit - val refs_of_mdef : s:ILReferencesAccumulator -> md:ILMethodDef -> unit - val refs_of_param : s:ILReferencesAccumulator -> p:ILParameter -> unit - val refs_of_return : s:ILReferencesAccumulator -> rt:ILReturn -> unit - val refs_of_mdefs : s:ILReferencesAccumulator -> x:seq<#ILMethodDef> -> unit - val refs_of_event_def : s:ILReferencesAccumulator -> ed:ILEventDef -> unit - val refs_of_events : s:ILReferencesAccumulator -> x:ILEventDefs -> unit - val refs_of_property_def : - s:ILReferencesAccumulator -> pd:ILPropertyDef -> unit - val refs_of_properties : - s:ILReferencesAccumulator -> x:ILPropertyDefs -> unit - val refs_of_fdef : s:ILReferencesAccumulator -> fd:ILFieldDef -> unit - val refs_of_fields : - s:ILReferencesAccumulator -> fields:#ILFieldDef list -> unit - val refs_of_method_impls : - s:ILReferencesAccumulator -> mimpls:ILMethodImplDef list -> unit - val refs_of_method_impl : - s:ILReferencesAccumulator -> m:ILMethodImplDef -> unit - val refs_of_tdef_kind : _s:'c -> _k:'d -> unit - val refs_of_tdef : s:ILReferencesAccumulator -> td:ILTypeDef -> unit - val refs_of_string : _s:'e -> 'f -> unit - val refs_of_types : s:ILReferencesAccumulator -> types:ILTypeDefs -> unit - val refs_of_exported_type : - s:ILReferencesAccumulator -> c:ILExportedTypeOrForwarder -> unit - val refs_of_exported_types : - s:ILReferencesAccumulator -> tab:ILExportedTypesAndForwarders -> unit - val refs_of_resource_where : - s:ILReferencesAccumulator -> x:ILResourceLocation -> unit - val refs_of_resource : s:ILReferencesAccumulator -> x:ILResource -> unit - val refs_of_resources : s:ILReferencesAccumulator -> tab:ILResources -> unit - val refs_of_modul : s:ILReferencesAccumulator -> m:ILModuleDef -> unit - val refs_of_manifest : - s:ILReferencesAccumulator -> m:ILAssemblyManifest -> unit - val computeILRefs : ILGlobals -> ILModuleDef -> ILReferences - val tspan : System.TimeSpan - val parseILVersion : string -> ILVersionInfo - val compareILVersions : ILVersionInfo -> ILVersionInfo -> int - val unscopeILTypeRef : x:ILTypeRef -> ILTypeRef - val unscopeILTypeSpec : tspec:ILTypeSpec -> ILTypeSpec - val unscopeILType : ILType -> ILType - val unscopeILTypes : i:ILGenericArgs -> ILGenericArgs - val unscopeILCallSig : csig:ILCallingSignature -> ILCallingSignature - val resolveILMethodRefWithRescope : - (ILType -> ILType) -> ILTypeDef -> ILMethodRef -> ILMethodDef - val resolveILMethodRef : ILTypeDef -> ILMethodRef -> ILMethodDef - val mkRefToILModule : ILModuleDef -> ILModuleRef - [] - type ILEventRef = - { erA: ILTypeRef - erB: string } - with - static member Create : ILTypeRef * string -> ILEventRef - member DeclaringTypeRef : ILTypeRef - member Name : string - end - [] - type ILPropertyRef = - { prA: ILTypeRef - prB: string } - with - static member Create : ILTypeRef * string -> ILPropertyRef - member DeclaringTypeRef : ILTypeRef - member Name : string - end - end - -namespace FSharp.Compiler.AbstractIL.Extensions.ILX - module internal Types = begin - val mkLowerName : nm:string -> string - [] - type IlxUnionField = - class - new : IL.ILFieldDef -> IlxUnionField - member ILField : IL.ILFieldDef - member LowerName : string - member Name : string - member Type : IL.ILType - end - type IlxUnionAlternative = - { altName: string - altFields: IlxUnionField [] - altCustomAttrs: IL.ILAttributes } - with - member FieldDef : int -> IlxUnionField - member FieldDefs : IlxUnionField [] - member FieldTypes : IL.ILType [] - member IsNullary : bool - member Name : string - end - type IlxUnionHasHelpers = - | NoHelpers - | AllHelpers - | SpecialFSharpListHelpers - | SpecialFSharpOptionHelpers - type IlxUnionRef = - | IlxUnionRef of - boxity: IL.ILBoxity * IL.ILTypeRef * IlxUnionAlternative [] * bool * - IlxUnionHasHelpers - type IlxUnionSpec = - | IlxUnionSpec of IlxUnionRef * IL.ILGenericArgs - with - member Alternative : int -> IlxUnionAlternative - member FieldDef : int -> int -> IlxUnionField - member Alternatives : IlxUnionAlternative list - member AlternativesArray : IlxUnionAlternative [] - member Boxity : IL.ILBoxity - member DeclaringType : IL.ILType - member GenericArgs : IL.ILGenericArgs - member HasHelpers : IlxUnionHasHelpers - member IsNullPermitted : bool - member TypeRef : IL.ILTypeRef - end - type IlxClosureLambdas = - | Lambdas_forall of IL.ILGenericParameterDef * IlxClosureLambdas - | Lambdas_lambda of IL.ILParameter * IlxClosureLambdas - | Lambdas_return of IL.ILType - type IlxClosureApps = - | Apps_tyapp of IL.ILType * IlxClosureApps - | Apps_app of IL.ILType * IlxClosureApps - | Apps_done of IL.ILType - val instAppsAux : - int -> IL.ILGenericArgs -> IlxClosureApps -> IlxClosureApps - val instLambdasAux : - n:int -> - inst:IL.ILGenericArgs -> _arg1:IlxClosureLambdas -> IlxClosureLambdas - val instLambdas : - i:IL.ILGenericArgs -> t:IlxClosureLambdas -> IlxClosureLambdas - type IlxClosureFreeVar = - { fvName: string - fvCompilerGenerated: bool - fvType: IL.ILType } - val mkILFreeVar : string * bool * IL.ILType -> IlxClosureFreeVar - type IlxClosureRef = - | IlxClosureRef of IL.ILTypeRef * IlxClosureLambdas * IlxClosureFreeVar [] - type IlxClosureSpec = - | IlxClosureSpec of - IlxClosureRef * IL.ILGenericArgs * IL.ILType * useStaticField: bool - with - static member - Create : IlxClosureRef * IL.ILGenericArgs * useStaticField:bool -> - IlxClosureSpec - member GetStaticFieldSpec : unit -> IL.ILFieldSpec - member ClosureRef : IlxClosureRef - member Constructor : IL.ILMethodSpec - member FormalFreeVars : IlxClosureFreeVar [] - member FormalLambdas : IlxClosureLambdas - member GenericArgs : IL.ILGenericArgs - member ILType : IL.ILType - member TypeRef : IL.ILTypeRef - member UseStaticField : bool - end - type IlxClosureInfo = - { cloStructure: IlxClosureLambdas - cloFreeVars: IlxClosureFreeVar [] - cloCode: Lazy - cloUseStaticField: bool } - type IlxUnionInfo = - { cudReprAccess: IL.ILMemberAccess - cudHelpersAccess: IL.ILMemberAccess - cudHasHelpers: IlxUnionHasHelpers - cudDebugProxies: bool - cudDebugDisplayAttributes: IL.ILAttribute list - cudAlternatives: IlxUnionAlternative [] - cudNullPermitted: bool - cudWhere: IL.ILSourceMarker option } - val destTyFuncApp : IlxClosureApps -> IL.ILType * IlxClosureApps - val mkILFormalCloRef : - IL.ILGenericParameterDefs -> - IlxClosureRef -> useStaticField:bool -> IlxClosureSpec - val actualTypOfIlxUnionField : IlxUnionSpec -> int -> int -> IL.ILType - end - -namespace FSharp.Compiler.AbstractIL.Internal - module internal AsciiConstants = begin - val noArgInstrs : Lazy<(string list * IL.ILInstr) list> - val wordsOfNoArgInstr : (IL.ILInstr -> string list) - val isNoArgInstr : (IL.ILInstr -> bool) - val mk_stind : nm:'a * dt:IL.ILBasicType -> 'a * (unit -> IL.ILInstr) - val mk_ldind : nm:'a * dt:IL.ILBasicType -> 'a * (unit -> IL.ILInstr) - type NoArgInstr = unit -> IL.ILInstr - type Int32Instr = int32 -> IL.ILInstr - type Int32Int32Instr = int32 * int32 -> IL.ILInstr - type Int64Instr = int64 -> IL.ILInstr - type DoubleInstr = IL.ILConst -> IL.ILInstr - type MethodSpecInstr = IL.ILMethodSpec * IL.ILVarArgs -> IL.ILInstr - type TypeInstr = IL.ILType -> IL.ILInstr - type IntTypeInstr = int * IL.ILType -> IL.ILInstr - type ValueTypeInstr = IL.ILType -> IL.ILInstr - type StringInstr = string -> IL.ILInstr - type TokenInstr = IL.ILToken -> IL.ILInstr - type SwitchInstr = IL.ILCodeLabel list * IL.ILCodeLabel -> IL.ILInstr - type InstrTable<'T> = (string list * 'T) list - type LazyInstrTable<'T> = Lazy> - val NoArgInstrs : Lazy> - val Int64Instrs : Lazy> - val Int32Instrs : Lazy> - val Int32Int32Instrs : Lazy> - val DoubleInstrs : Lazy> - val StringInstrs : Lazy> - val TokenInstrs : Lazy> - val TypeInstrs : Lazy> - val IntTypeInstrs : Lazy> - val ValueTypeInstrs : Lazy> - end - -namespace FSharp.Compiler.AbstractIL - module internal ILAsciiWriter = begin - val pretty : unit -> bool - val tyvar_generator : (string -> string) - type ppenv = - { ilGlobals: IL.ILGlobals - ppenvClassFormals: int - ppenvMethodFormals: int } - val ppenv_enter_method : mgparams:int -> env:ppenv -> ppenv - val ppenv_enter_tdef : gparams:'a list -> env:ppenv -> ppenv - val mk_ppenv : ilg:IL.ILGlobals -> ppenv - val debug_ppenv : (IL.ILGlobals -> ppenv) - val ppenv_enter_modul : env:ppenv -> ppenv - val output_string : os:System.IO.TextWriter -> s:string -> unit - val output_char : os:System.IO.TextWriter -> c:char -> unit - val output_int : os:System.IO.TextWriter -> i:int -> unit - val output_hex_digit : os:System.IO.TextWriter -> i:int -> unit - val output_qstring : os:System.IO.TextWriter -> s:string -> unit - val output_sqstring : os:System.IO.TextWriter -> s:string -> unit - val output_seq : - sep:string -> f:('a -> 'b -> unit) -> os:'a -> a:seq<'b> -> unit - when 'a :> System.IO.TextWriter - val output_array : - sep:string -> f:('a -> 'b -> unit) -> os:'a -> a:'b [] -> unit - when 'a :> System.IO.TextWriter - val output_parens : - f:('a -> 'b -> unit) -> os:'a -> a:'b -> unit - when 'a :> System.IO.TextWriter - val output_angled : - f:('a -> 'b -> unit) -> os:'a -> a:'b -> unit - when 'a :> System.IO.TextWriter - val output_bracks : - f:('a -> 'b -> unit) -> os:'a -> a:'b -> unit - when 'a :> System.IO.TextWriter - val output_id : os:System.IO.TextWriter -> n:string -> unit - val output_label : os:System.IO.TextWriter -> n:string -> unit - val output_lid : os:System.IO.TextWriter -> lid:seq -> unit - val string_of_type_name : 'a * n:'b -> 'b - val output_byte : os:System.IO.TextWriter -> i:int -> unit - val output_bytes : os:System.IO.TextWriter -> bytes:byte [] -> unit - val bits_of_float32 : x:float32 -> int - val bits_of_float : x:float -> int64 - val output_u8 : os:System.IO.TextWriter -> x:byte -> unit - val output_i8 : os:System.IO.TextWriter -> x:sbyte -> unit - val output_u16 : os:System.IO.TextWriter -> x:uint16 -> unit - val output_i16 : os:System.IO.TextWriter -> x:int16 -> unit - val output_u32 : os:System.IO.TextWriter -> x:uint32 -> unit - val output_i32 : os:System.IO.TextWriter -> x:int32 -> unit - val output_u64 : os:System.IO.TextWriter -> x:uint64 -> unit - val output_i64 : os:System.IO.TextWriter -> x:int64 -> unit - val output_ieee32 : os:System.IO.TextWriter -> x:float32 -> unit - val output_ieee64 : os:System.IO.TextWriter -> x:float -> unit - val goutput_scoref : - env:ppenv -> os:System.IO.TextWriter -> _arg2:IL.ILScopeRef -> unit - val goutput_type_name_ref : - env:ppenv -> - os:System.IO.TextWriter -> - scoref:IL.ILScopeRef * enc:string list * n:string -> unit - val goutput_tref : - env:ppenv -> os:System.IO.TextWriter -> x:IL.ILTypeRef -> unit - val goutput_typ : - env:ppenv -> os:System.IO.TextWriter -> ty:IL.ILType -> unit - val output_tyvar : os:System.IO.TextWriter -> d:uint16 -> unit - val goutput_ldtoken_info : - env:ppenv -> os:System.IO.TextWriter -> _arg3:IL.ILToken -> unit - val goutput_typ_with_shortened_class_syntax : - env:ppenv -> os:System.IO.TextWriter -> _arg4:IL.ILType -> unit - val goutput_gactuals : - env:ppenv -> os:System.IO.TextWriter -> inst:IL.ILGenericArgs -> unit - val goutput_gactual : - env:ppenv -> os:System.IO.TextWriter -> ty:IL.ILType -> unit - val goutput_tspec : - env:ppenv -> os:System.IO.TextWriter -> tspec:IL.ILTypeSpec -> unit - val output_arr_bounds : - os:System.IO.TextWriter -> _arg5:IL.ILArrayShape -> unit - val goutput_permission : - _env:'a -> os:System.IO.TextWriter -> p:IL.ILSecurityDecl -> unit - val goutput_security_decls : - env:'b -> os:System.IO.TextWriter -> ps:IL.ILSecurityDecls -> unit - val goutput_gparam : - env:ppenv -> - os:System.IO.TextWriter -> gf:IL.ILGenericParameterDef -> unit - val goutput_gparams : - env:ppenv -> - os:System.IO.TextWriter -> b:IL.ILGenericParameterDef list -> unit - val output_bcc : os:System.IO.TextWriter -> bcc:IL.ILArgConvention -> unit - val output_callconv : os:System.IO.TextWriter -> IL.ILCallingConv -> unit - val goutput_dlocref : - env:ppenv -> os:System.IO.TextWriter -> dref:IL.ILType -> unit - val goutput_callsig : - env:ppenv -> os:System.IO.TextWriter -> csig:IL.ILCallingSignature -> unit - val goutput_mref : - env:ppenv -> os:System.IO.TextWriter -> mref:IL.ILMethodRef -> unit - val goutput_mspec : - env:ppenv -> os:System.IO.TextWriter -> mspec:IL.ILMethodSpec -> unit - val goutput_vararg_mspec : - env:ppenv -> - os:System.IO.TextWriter -> - mspec:IL.ILMethodSpec * varargs:#seq option -> unit - val goutput_vararg_sig : - env:ppenv -> - os:System.IO.TextWriter -> - csig:IL.ILCallingSignature * varargs:IL.ILVarArgs -> unit - val goutput_fspec : - env:ppenv -> os:System.IO.TextWriter -> x:IL.ILFieldSpec -> unit - val output_member_access : - os:System.IO.TextWriter -> access:IL.ILMemberAccess -> unit - val output_type_access : - os:System.IO.TextWriter -> access:IL.ILTypeDefAccess -> unit - val output_encoding : - os:System.IO.TextWriter -> e:IL.ILDefaultPInvokeEncoding -> unit - val output_field_init : - os:System.IO.TextWriter -> _arg1:IL.ILFieldInit -> unit - val output_at : os:System.IO.TextWriter -> b:byte [] -> unit - val output_option : f:('a -> 'b -> unit) -> os:'a -> _arg1:'b option -> unit - val goutput_alternative_ref : - env:ppenv -> - os:System.IO.TextWriter -> - alt:Extensions.ILX.Types.IlxUnionAlternative -> unit - val goutput_curef : - env:ppenv -> - os:System.IO.TextWriter -> Extensions.ILX.Types.IlxUnionRef -> unit - val goutput_cuspec : - env:ppenv -> - os:System.IO.TextWriter -> Extensions.ILX.Types.IlxUnionSpec -> unit - val output_basic_type : os:System.IO.TextWriter -> x:IL.ILBasicType -> unit - val output_custom_attr_data : - os:System.IO.TextWriter -> data:byte [] -> unit - val goutput_custom_attr : - env:ppenv -> os:System.IO.TextWriter -> attr:IL.ILAttribute -> unit - val goutput_custom_attrs : - env:ppenv -> os:System.IO.TextWriter -> attrs:IL.ILAttributes -> unit - val goutput_fdef : - _tref:'a -> - env:ppenv -> os:System.IO.TextWriter -> fd:IL.ILFieldDef -> unit - val output_alignment : - os:System.IO.TextWriter -> _arg1:IL.ILAlignment -> unit - val output_volatility : - os:System.IO.TextWriter -> _arg1:IL.ILVolatility -> unit - val output_tailness : os:System.IO.TextWriter -> _arg1:IL.ILTailcall -> unit - val output_after_tailcall : - os:System.IO.TextWriter -> _arg1:IL.ILTailcall -> unit - val goutput_apps : - env:ppenv -> - os:System.IO.TextWriter -> - _arg1:Extensions.ILX.Types.IlxClosureApps -> unit - val output_short_u16 : os:System.IO.TextWriter -> x:uint16 -> unit - val output_short_i32 : os:System.IO.TextWriter -> i32:int -> unit - val output_code_label : - os:System.IO.TextWriter -> lab:IL.ILCodeLabel -> unit - val goutput_local : - env:ppenv -> os:System.IO.TextWriter -> l:IL.ILLocal -> unit - val goutput_param : - env:ppenv -> os:System.IO.TextWriter -> l:IL.ILParameter -> unit - val goutput_params : - env:ppenv -> os:System.IO.TextWriter -> ps:seq -> unit - val goutput_freevar : - env:ppenv -> - os:System.IO.TextWriter -> - l:Extensions.ILX.Types.IlxClosureFreeVar -> unit - val goutput_freevars : - env:ppenv -> - os:System.IO.TextWriter -> - ps:seq -> unit - val output_source : os:System.IO.TextWriter -> s:IL.ILSourceMarker -> unit - val goutput_instr : - env:ppenv -> os:System.IO.TextWriter -> inst:IL.ILInstr -> unit - val goutput_ilmbody : - env:ppenv -> os:System.IO.TextWriter -> il:IL.ILMethodBody -> unit - val goutput_mbody : - is_entrypoint:bool -> - env:ppenv -> os:System.IO.TextWriter -> md:IL.ILMethodDef -> unit - val goutput_mdef : - env:ppenv -> os:System.IO.TextWriter -> md:IL.ILMethodDef -> unit - val goutput_pdef : - env:ppenv -> os:System.IO.TextWriter -> pd:IL.ILPropertyDef -> unit - val goutput_superclass : - env:ppenv -> os:System.IO.TextWriter -> _arg1:IL.ILType option -> unit - val goutput_superinterfaces : - env:ppenv -> os:System.IO.TextWriter -> imp:IL.ILType list -> unit - val goutput_implements : - env:ppenv -> os:System.IO.TextWriter -> imp:IL.ILTypes -> unit - val the : _arg1:'a option -> 'a - val output_type_layout_info : - os:System.IO.TextWriter -> info:IL.ILTypeDefLayoutInfo -> unit - val splitTypeLayout : - _arg1:IL.ILTypeDefLayout -> - string * (#System.IO.TextWriter -> unit -> unit) - val goutput_fdefs : - tref:'a -> - env:ppenv -> os:System.IO.TextWriter -> fdefs:IL.ILFieldDefs -> unit - val goutput_mdefs : - env:ppenv -> os:System.IO.TextWriter -> mdefs:IL.ILMethodDefs -> unit - val goutput_pdefs : - env:ppenv -> os:System.IO.TextWriter -> pdefs:IL.ILPropertyDefs -> unit - val goutput_tdef : - enc:string list -> - env:ppenv -> - contents:bool -> os:System.IO.TextWriter -> cd:IL.ILTypeDef -> unit - val output_init_semantics : - os:System.IO.TextWriter -> f:System.Reflection.TypeAttributes -> unit - val goutput_lambdas : - env:ppenv -> - os:System.IO.TextWriter -> - lambdas:Extensions.ILX.Types.IlxClosureLambdas -> unit - val goutput_tdefs : - contents:bool -> - enc:string list -> - env:ppenv -> os:System.IO.TextWriter -> td:IL.ILTypeDefs -> unit - val output_ver : os:System.IO.TextWriter -> version:IL.ILVersionInfo -> unit - val output_locale : os:System.IO.TextWriter -> s:string -> unit - val output_hash : os:System.IO.TextWriter -> x:byte [] -> unit - val output_publickeytoken : os:System.IO.TextWriter -> x:byte [] -> unit - val output_publickey : os:System.IO.TextWriter -> x:byte [] -> unit - val output_publickeyinfo : - os:System.IO.TextWriter -> _arg1:IL.PublicKey -> unit - val output_assemblyRef : - os:System.IO.TextWriter -> aref:IL.ILAssemblyRef -> unit - val output_modref : os:System.IO.TextWriter -> modref:IL.ILModuleRef -> unit - val goutput_resource : - env:ppenv -> os:System.IO.TextWriter -> r:IL.ILResource -> unit - val goutput_manifest : - env:ppenv -> os:System.IO.TextWriter -> m:IL.ILAssemblyManifest -> unit - val output_module_fragment_aux : - _refs:'a -> - os:System.IO.TextWriter -> - ilg:IL.ILGlobals -> modul:IL.ILModuleDef -> unit - val output_module_fragment : - os:System.IO.TextWriter -> - ilg:IL.ILGlobals -> modul:IL.ILModuleDef -> IL.ILReferences - val output_module_refs : - os:System.IO.TextWriter -> refs:IL.ILReferences -> unit - val goutput_module_manifest : - env:ppenv -> os:System.IO.TextWriter -> modul:IL.ILModuleDef -> unit - val output_module : - System.IO.TextWriter -> ilg:IL.ILGlobals -> IL.ILModuleDef -> unit - end - -namespace FSharp.Compiler.AbstractIL - module internal Morphs = begin - val mutable morphCustomAttributeData : bool - val enableMorphCustomAttributeData : unit -> unit - val disableMorphCustomAttributeData : unit -> unit - val code_instr2instr : - f:(IL.ILInstr -> IL.ILInstr) -> code:IL.ILCode -> IL.ILCode - val code_instr2instrs : - f:(IL.ILInstr -> IL.ILInstr list) -> code:IL.ILCode -> IL.ILCode - val code_instr2instr_ty2ty : - finstr:(IL.ILInstr -> IL.ILInstr) * fty:(IL.ILType -> IL.ILType) -> - c:IL.ILCode -> IL.ILCode - val ty_tref2tref : - f:(IL.ILTypeRef -> IL.ILTypeRef) -> x:IL.ILType -> IL.ILType - val tspec_tref2tref : - f:(IL.ILTypeRef -> IL.ILTypeRef) -> x:IL.ILTypeSpec -> IL.ILTypeSpec - val ty_scoref2scoref_tyvar2ty : - (IL.ILScopeRef -> IL.ILScopeRef) * (uint16 -> IL.ILType) -> - x:IL.ILType -> IL.ILType - val tspec_scoref2scoref_tyvar2ty : - (IL.ILScopeRef -> IL.ILScopeRef) * (uint16 -> IL.ILType) -> - x:IL.ILTypeSpec -> IL.ILTypeSpec - val callsig_scoref2scoref_tyvar2ty : - (IL.ILScopeRef -> IL.ILScopeRef) * (uint16 -> IL.ILType) -> - x:IL.ILCallingSignature -> IL.ILCallingSignature - val tys_scoref2scoref_tyvar2ty : - (IL.ILScopeRef -> IL.ILScopeRef) * (uint16 -> IL.ILType) -> - i:IL.ILGenericArgs -> IL.ILGenericArgs - val gparams_scoref2scoref_tyvar2ty : f:'a -> i:'b list -> 'b list - val gparam_scoref2scoref_tyvar2ty : _f:'a -> i:'b -> 'b - val morphILScopeRefsInILTypeRef : - (IL.ILScopeRef -> IL.ILScopeRef) -> IL.ILTypeRef -> IL.ILTypeRef - val callsig_ty2ty : - f:(IL.ILType -> IL.ILType) -> - x:IL.ILCallingSignature -> IL.ILCallingSignature - val gparam_ty2ty : - f:(IL.ILType -> IL.ILType) -> - gf:IL.ILGenericParameterDef -> IL.ILGenericParameterDef - val gparams_ty2ty : - f:(IL.ILType -> IL.ILType) -> - gfs:IL.ILGenericParameterDef list -> IL.ILGenericParameterDef list - val tys_ty2ty : - f:(IL.ILType -> IL.ILType) -> x:IL.ILType list -> IL.ILType list - val mref_ty2ty : - f:(IL.ILType -> IL.ILType) -> x:IL.ILMethodRef -> IL.ILMethodRef - type formal_scopeCtxt = Choice - val mspec_ty2ty : - (IL.ILType -> IL.ILType) * (formal_scopeCtxt -> IL.ILType -> IL.ILType) -> - x:IL.ILMethodSpec -> IL.ILMethodSpec - val fref_ty2ty : - f:(IL.ILType -> IL.ILType) -> x:IL.ILFieldRef -> IL.ILFieldRef - val fspec_ty2ty : - (IL.ILType -> IL.ILType) * (formal_scopeCtxt -> IL.ILType -> IL.ILType) -> - x:IL.ILFieldSpec -> IL.ILFieldSpec - val celem_ty2ty : - f:(IL.ILType -> IL.ILType) -> celem:IL.ILAttribElem -> IL.ILAttribElem - val cnamedarg_ty2ty : - f:(IL.ILType -> IL.ILType) -> - string * IL.ILType * bool * IL.ILAttribElem -> - string * IL.ILType * bool * IL.ILAttribElem - val cattr_ty2ty : - ilg:IL.ILGlobals -> - f:(IL.ILType -> IL.ILType) -> c:IL.ILAttribute -> IL.ILAttribute - val cattrs_ty2ty : - ilg:IL.ILGlobals -> - f:(IL.ILType -> IL.ILType) -> cs:IL.ILAttributes -> IL.ILAttributes - val fdef_ty2ty : - ilg:IL.ILGlobals -> - ftye:(IL.ILType -> IL.ILType) -> fd:IL.ILFieldDef -> IL.ILFieldDef - val local_ty2ty : f:(IL.ILType -> IL.ILType) -> l:IL.ILLocal -> IL.ILLocal - val varargs_ty2ty : - f:(IL.ILType -> 'a) -> varargs:IL.ILVarArgs -> 'a list option - val morphILTypesInILInstr : - (IL.ILInstr option -> IL.ILType -> IL.ILType) * - (IL.ILInstr option -> formal_scopeCtxt -> IL.ILType -> IL.ILType) -> - i:IL.ILInstr -> IL.ILInstr - val return_ty2ty : - ilg:IL.ILGlobals -> - f:(IL.ILType -> IL.ILType) -> r:IL.ILReturn -> IL.ILReturn - val param_ty2ty : - ilg:IL.ILGlobals -> - f:(IL.ILType -> IL.ILType) -> p:IL.ILParameter -> IL.ILParameter - val morphILMethodDefs : - f:(IL.ILMethodDef -> IL.ILMethodDef) -> - m:IL.ILMethodDefs -> IL.ILMethodDefs - val fdefs_fdef2fdef : - f:(IL.ILFieldDef -> IL.ILFieldDef) -> m:IL.ILFieldDefs -> IL.ILFieldDefs - val morphILTypeDefs : - f:(IL.ILTypeDef -> IL.ILTypeDef) -> m:IL.ILTypeDefs -> IL.ILTypeDefs - val locals_ty2ty : - f:(IL.ILType -> IL.ILType) -> ls:IL.ILLocal list -> IL.ILLocal list - val ilmbody_instr2instr_ty2ty : - (IL.ILInstr -> IL.ILInstr) * (IL.ILType -> IL.ILType) -> - il:IL.ILMethodBody -> IL.ILMethodBody - val morphILMethodBody : - filmbody:(IL.ILMethodBody -> IL.ILMethodBody) -> - x:IL.ILLazyMethodBody -> IL.ILLazyMethodBody - val ospec_ty2ty : - f:(IL.ILType -> IL.ILType) -> IL.ILOverridesSpec -> IL.ILOverridesSpec - val mdef_ty2ty_ilmbody2ilmbody : - ilg:IL.ILGlobals -> - (IL.ILMethodDef option -> IL.ILType -> IL.ILType) * - (IL.ILMethodDef option -> IL.ILMethodBody -> IL.ILMethodBody) -> - md:IL.ILMethodDef -> IL.ILMethodDef - val fdefs_ty2ty : - ilg:IL.ILGlobals -> - f:(IL.ILType -> IL.ILType) -> x:IL.ILFieldDefs -> IL.ILFieldDefs - val mdefs_ty2ty_ilmbody2ilmbody : - ilg:IL.ILGlobals -> - (IL.ILMethodDef option -> IL.ILType -> IL.ILType) * - (IL.ILMethodDef option -> IL.ILMethodBody -> IL.ILMethodBody) -> - x:IL.ILMethodDefs -> IL.ILMethodDefs - val mimpl_ty2ty : - f:(IL.ILType -> IL.ILType) -> e:IL.ILMethodImplDef -> IL.ILMethodImplDef - val edef_ty2ty : - ilg:IL.ILGlobals -> - f:(IL.ILType -> IL.ILType) -> e:IL.ILEventDef -> IL.ILEventDef - val pdef_ty2ty : - ilg:IL.ILGlobals -> - f:(IL.ILType -> IL.ILType) -> p:IL.ILPropertyDef -> IL.ILPropertyDef - val pdefs_ty2ty : - ilg:IL.ILGlobals -> - f:(IL.ILType -> IL.ILType) -> - pdefs:IL.ILPropertyDefs -> IL.ILPropertyDefs - val edefs_ty2ty : - ilg:IL.ILGlobals -> - f:(IL.ILType -> IL.ILType) -> edefs:IL.ILEventDefs -> IL.ILEventDefs - val mimpls_ty2ty : - f:(IL.ILType -> IL.ILType) -> - mimpls:IL.ILMethodImplDefs -> IL.ILMethodImplDefs - val tdef_ty2ty_ilmbody2ilmbody_mdefs2mdefs : - ilg:IL.ILGlobals -> - enc:IL.ILTypeDef list -> - ((IL.ILTypeDef list * IL.ILTypeDef) option -> 'a option -> - IL.ILType -> IL.ILType) * - (IL.ILTypeDef list * IL.ILTypeDef -> IL.ILMethodDefs -> - IL.ILMethodDefs) -> td:IL.ILTypeDef -> IL.ILTypeDef - val tdefs_ty2ty_ilmbody2ilmbody_mdefs2mdefs : - ilg:IL.ILGlobals -> - enc:IL.ILTypeDef list -> - ((IL.ILTypeDef list * IL.ILTypeDef) option -> 'a option -> - IL.ILType -> IL.ILType) * - (IL.ILTypeDef list * IL.ILTypeDef -> IL.ILMethodDefs -> - IL.ILMethodDefs) -> tdefs:IL.ILTypeDefs -> IL.ILTypeDefs - val manifest_ty2ty : - ilg:IL.ILGlobals -> - f:(IL.ILType -> IL.ILType) -> - m:IL.ILAssemblyManifest -> IL.ILAssemblyManifest - val morphILTypeInILModule_ilmbody2ilmbody_mdefs2mdefs : - ilg:IL.ILGlobals -> - ftye:(IL.ILModuleDef -> (IL.ILTypeDef list * IL.ILTypeDef) option -> - IL.ILMethodDef option -> IL.ILType -> IL.ILType) * - fmdefs:(IL.ILModuleDef -> IL.ILTypeDef list * IL.ILTypeDef -> - IL.ILMethodDefs -> IL.ILMethodDefs) -> - m:IL.ILModuleDef -> IL.ILModuleDef - val module_instr2instr_ty2ty : - ilg:IL.ILGlobals -> - (IL.ILModuleDef -> IL.ILTypeDef list * IL.ILTypeDef -> - IL.ILMethodDef option -> IL.ILInstr -> IL.ILInstr) * - (IL.ILModuleDef -> (IL.ILTypeDef list * IL.ILTypeDef) option -> - IL.ILMethodDef option -> IL.ILType -> IL.ILType) -> - x:IL.ILModuleDef -> IL.ILModuleDef - val morphILInstrsAndILTypesInILModule : - ilg:IL.ILGlobals -> - f1:(IL.ILModuleDef -> IL.ILTypeDef list * IL.ILTypeDef -> - IL.ILMethodDef option -> IL.ILInstr -> IL.ILInstr) * - f2:(IL.ILModuleDef -> (IL.ILTypeDef list * IL.ILTypeDef) option -> - IL.ILMethodDef option -> IL.ILType -> IL.ILType) -> - x:IL.ILModuleDef -> IL.ILModuleDef - val morphILInstrsInILCode : - (IL.ILInstr -> IL.ILInstr list) -> IL.ILCode -> IL.ILCode - val morphILTypeInILModule : - ilg:IL.ILGlobals -> - ftye:(IL.ILModuleDef -> (IL.ILTypeDef list * IL.ILTypeDef) option -> - IL.ILMethodDef option -> IL.ILType -> IL.ILType) -> - y:IL.ILModuleDef -> IL.ILModuleDef - val morphILTypeRefsInILModuleMemoized : - IL.ILGlobals -> - (IL.ILTypeRef -> IL.ILTypeRef) -> IL.ILModuleDef -> IL.ILModuleDef - val morphILScopeRefsInILModuleMemoized : - IL.ILGlobals -> - (IL.ILScopeRef -> IL.ILScopeRef) -> IL.ILModuleDef -> IL.ILModuleDef - end - -namespace FSharp.Compiler.AbstractIL.Internal - module internal StrongNameSign = begin - type KeyType = - | Public - | KeyPair - val ALG_TYPE_RSA : int - val ALG_CLASS_KEY_EXCHANGE : int - val ALG_CLASS_SIGNATURE : int - val CALG_RSA_KEYX : int - val CALG_RSA_SIGN : int - val ALG_CLASS_HASH : int - val ALG_TYPE_ANY : int - val CALG_SHA1 : int - val CALG_SHA_256 : int - val CALG_SHA_384 : int - val CALG_SHA_512 : int - val PUBLICKEYBLOB : int - val PRIVATEKEYBLOB : int - val BLOBHEADER_CURRENT_BVERSION : int - val BLOBHEADER_LENGTH : int - val RSA_PUB_MAGIC : int - val RSA_PRIV_MAGIC : int - val getResourceString : 'a * str:'b -> 'b - val check : _action:'a -> hresult:int -> unit - [] - type ByteArrayUnion = - struct - new : immutableArray:System.Collections.Immutable.ImmutableArray -> - ByteArrayUnion - val UnderlyingArray: byte [] - val ImmutableArray: System.Collections.Immutable.ImmutableArray - end - val getUnderlyingArray : - array:System.Collections.Immutable.ImmutableArray -> byte [] - val hashAssembly : - peReader:System.Reflection.PortableExecutable.PEReader -> - hashAlgorithm:System.Security.Cryptography.IncrementalHash -> byte [] - type BlobReader = - class - new : blob:byte [] -> BlobReader - member ReadBigInteger : length:int -> byte [] - member ReadInt32 : int - end - val RSAParamatersFromBlob : - blob:byte [] -> - keyType:KeyType -> System.Security.Cryptography.RSAParameters - val toCLRKeyBlob : - rsaParameters:System.Security.Cryptography.RSAParameters -> - algId:int -> byte [] - val createSignature : - hash:byte [] -> keyBlob:byte [] -> keyType:KeyType -> byte [] - val patchSignature : - stream:System.IO.Stream -> - peReader:System.Reflection.PortableExecutable.PEReader -> - signature:byte [] -> unit - val signStream : stream:System.IO.Stream -> keyBlob:byte [] -> unit - val signFile : filename:string -> keyBlob:byte [] -> unit - val signatureSize : pk:byte [] -> int - val getPublicKeyForKeyPair : keyBlob:byte [] -> byte [] - type keyContainerName = string - type keyPair = byte [] - type pubkey = byte [] - type pubkeyOptions = byte [] * bool - val signerOpenPublicKeyFile : filePath:string -> byte [] - val signerOpenKeyPairFile : filePath:string -> byte [] - val signerGetPublicKeyForKeyPair : kp:keyPair -> pubkey - val signerGetPublicKeyForKeyContainer : _kcName:keyContainerName -> pubkey - val signerCloseKeyContainer : _kc:keyContainerName -> unit - val signerSignatureSize : pk:pubkey -> int - val signerSignFileWithKeyPair : fileName:string -> kp:keyPair -> unit - val signerSignFileWithKeyContainer : - _fileName:string -> _kcName:keyContainerName -> unit - [] - type ILStrongNameSigner = - | PublicKeySigner of pubkey - | PublicKeyOptionsSigner of pubkeyOptions - | KeyPair of keyPair - | KeyContainer of keyContainerName - with - static member OpenKeyContainer : keyContainerName -> ILStrongNameSigner - static member OpenKeyPairFile : string -> ILStrongNameSigner - static member OpenPublicKey : pubkey -> ILStrongNameSigner - static member - OpenPublicKeyOptions : string -> bool -> ILStrongNameSigner - member Close : unit -> unit - member SignFile : string -> unit - member IsFullySigned : bool - member PublicKey : pubkey - member SignatureSize : int - end - end - -namespace FSharp.Compiler.AbstractIL.Internal - module internal NativeRes = begin - type BYTE = byte - type DWORD = uint32 - type WCHAR = System.Char - type WORD = uint16 - val inline WORD : - s: ^a -> uint16 when ^a : (static member op_Explicit : ^a -> uint16) - val inline DWORD : - s: ^a -> uint32 when ^a : (static member op_Explicit : ^a -> uint32) - val inline WCHAR : - s: ^a -> char when ^a : (static member op_Explicit : ^a -> char) - val inline BYTE : - s: ^a -> byte when ^a : (static member op_Explicit : ^a -> byte) - type ResourceException = - class - inherit System.Exception - new : name:string * ?inner:System.Exception -> ResourceException - end - [] - type RESOURCE_STRING = - class - new : unit -> RESOURCE_STRING - member Ordinal : WORD - member theString : string - end - [] - type RESOURCE = - class - new : unit -> RESOURCE - member Characteristics : DWORD - member DataSize : DWORD - member DataVersion : DWORD - member HeaderSize : DWORD - member LanguageId : WORD - member MemoryFlags : WORD - member Version : DWORD - member data : byte [] - member pstringName : RESOURCE_STRING - member pstringType : RESOURCE_STRING - end - [] - type CvtResFile = - class - new : unit -> CvtResFile - static member - ReadResFile : stream:System.IO.Stream -> - System.Collections.Generic.List - static member - private ReadStringOrID : fhIn:System.IO.BinaryReader -> - RESOURCE_STRING - static member private RT_DLGINCLUDE : int - end - [] - type SectionCharacteristics = - | TypeReg = 0u - | TypeDSect = 1u - | TypeNoLoad = 2u - | TypeGroup = 4u - | TypeNoPad = 8u - | TypeCopy = 16u - | ContainsCode = 32u - | ContainsInitializedData = 64u - | ContainsUninitializedData = 128u - | LinkerOther = 256u - | LinkerInfo = 512u - | TypeOver = 1024u - | LinkerRemove = 2048u - | LinkerComdat = 4096u - | MemProtected = 16384u - | NoDeferSpecExc = 16384u - | GPRel = 32768u - | MemFardata = 32768u - | MemSysheap = 65536u - | MemPurgeable = 131072u - | Mem16Bit = 131072u - | MemLocked = 262144u - | MemPreload = 524288u - | Align1Bytes = 1048576u - | Align2Bytes = 2097152u - | Align4Bytes = 3145728u - | Align8Bytes = 4194304u - | Align16Bytes = 5242880u - | Align32Bytes = 6291456u - | Align64Bytes = 7340032u - | Align128Bytes = 8388608u - | Align256Bytes = 9437184u - | Align512Bytes = 10485760u - | Align1024Bytes = 11534336u - | Align2048Bytes = 12582912u - | Align4096Bytes = 13631488u - | Align8192Bytes = 14680064u - | AlignMask = 15728640u - | LinkerNRelocOvfl = 16777216u - | MemDiscardable = 33554432u - | MemNotCached = 67108864u - | MemNotPaged = 134217728u - | MemShared = 268435456u - | MemExecute = 536870912u - | MemRead = 1073741824u - | MemWrite = 2147483648u - type ResourceSection = - class - new : sectionBytes:byte [] * relocations:uint32 [] -> ResourceSection - new : unit -> ResourceSection - member Relocations : uint32 [] - member SectionBytes : byte [] - end - [] - type StreamExtensions = - class - new : unit -> StreamExtensions - [] - static member - TryReadAll : stream:System.IO.Stream * buffer:byte [] * offset:int * - count:int -> int - end - type COFFResourceReader = - class - new : unit -> COFFResourceReader - static member - private ConfirmSectionValues : hdr:System.Reflection.PortableExecutable.SectionHeader * - fileSize:int64 -> unit - static member - ReadWin32ResourcesFromCOFF : stream:System.IO.Stream -> - ResourceSection - end - [] - type ICONDIRENTRY = - struct - val mutable bWidth: BYTE - val mutable bHeight: BYTE - val mutable bColorCount: BYTE - val mutable bReserved: BYTE - val mutable wPlanes: WORD - val mutable wBitCount: WORD - val mutable dwBytesInRes: DWORD - val mutable dwImageOffset: DWORD - end - type VersionHelper = - class - new : unit -> VersionHelper - static member - GenerateVersionFromPatternAndCurrentTime : time:System.DateTime * - pattern:System.Version -> - System.Version - static member - private TryGetValue : s:string * value:byref -> bool - static member - TryParse : s:string * version:byref -> bool - static member - private TryParse : s:string * allowWildcard:bool * maxValue:uint16 * - allowPartialParse:bool * - version:byref -> bool - static member - TryParseAssemblyVersion : s:string * allowWildcard:bool * - version:byref -> bool - static member private NullVersion : System.Version - end - type VersionResourceSerializer = - class - new : isDll:bool * comments:string * companyName:string * - fileDescription:string * fileVersion:string * internalName:string * - legalCopyright:string * legalTrademark:string * - originalFileName:string * productName:string * - productVersion:string * assemblyVersion:System.Version -> - VersionResourceSerializer - new : unit -> VersionResourceSerializer - static member private KEYBYTES : sz:string -> int - static member private KEYSIZE : sz:string -> int - static member private PadKeyLen : cb:int -> int - static member private PadToDword : cb:int -> int - static member - private SizeofVerString : lpszKey:string * lpszValue:string -> int - static member - private WriteVersionString : keyValuePair:System.Collections.Generic.KeyValuePair * - writer:System.IO.BinaryWriter -> unit - member GetDataSize : unit -> int - member private GetStringsSize : unit -> int - member - private GetVerStrings : unit -> - seq> - member - private WriteVSFixedFileInfo : writer:System.IO.BinaryWriter -> unit - member WriteVerResource : writer:System.IO.BinaryWriter -> unit - member private FileType : uint32 - member private _assemblyVersionContents : System.Version - member private _commentsContents : string - member private _companyNameContents : string - member private _fileDescriptionContents : string - member private _fileVersionContents : string - member private _internalNameContents : string - member private _isDll : bool - member private _langIdAndCodePageKey : string - member private _legalCopyrightContents : string - member private _legalTrademarksContents : string - member private _originalFileNameContents : string - member private _productNameContents : string - member private _productVersionContents : string - static member private CP_WINUNICODE : uint32 - static member private HDRSIZE : int - static member private VFT_APP : uint32 - static member private VFT_DLL : uint32 - static member private sizeVS_FIXEDFILEINFO : uint16 - static member private stringFileInfoKey : string - static member private translationKey : string - static member private varFileInfoKey : string - static member private vsVersionInfoKey : string - end - [] - type Win32ResourceConversions = - class - new : unit -> Win32ResourceConversions - static member - AppendIconToResourceStream : resStream:System.IO.Stream * - iconStream:System.IO.Stream -> unit - static member - AppendManifestToResourceStream : resStream:System.IO.Stream * - manifestStream:System.IO.Stream * - isDll:bool -> unit - static member - AppendVersionToResourceStream : resStream:System.IO.Stream * - isDll:bool * fileVersion:string * - originalFileName:string * - internalName:string * - productVersion:string * - assemblyVersion:System.Version * - ?fileDescription:string * - ?legalCopyright:string * - ?legalTrademarks:string * - ?productName:string * ?comments:string * - ?companyName:string -> unit - end - type Win32Resource = - class - new : data:byte [] * codePage:DWORD * languageId:DWORD * id:int * - name:string * typeId:int * typeName:string -> Win32Resource - member CodePage : DWORD - member Data : byte [] - member Id : int - member LanguageId : DWORD - member Name : string - member TypeId : int - member TypeName : string - end - type Directory = - class - new : name:string * id:int -> Directory - member Entries : System.Collections.Generic.List - member ID : int - member Name : string - member NumberOfIdEntries : uint16 - member NumberOfNamedEntries : uint16 - end - [] - type NativeResourceWriter = - class - new : unit -> NativeResourceWriter - static member - private CompareResourceIdentifiers : xOrdinal:int * xString:string * - yOrdinal:int * yString:string -> - int - static member - private CompareResources : left:Win32Resource -> - right:Win32Resource -> int - static member - SerializeWin32Resources : builder:System.Reflection.Metadata.BlobBuilder * - theResources:System.Collections.Generic.IEnumerable * - resourcesRva:int -> unit - static member private SizeOfDirectory : directory:Directory -> uint32 - static member - SortResources : resources:System.Collections.Generic.IEnumerable -> - System.Collections.Generic.IEnumerable - static member - private WriteDirectory : directory:Directory * - writer:System.Reflection.Metadata.BlobBuilder * - offset:uint32 * level:uint32 * - sizeOfDirectoryTree:uint32 * - virtualAddressBase:int * - dataWriter:System.Reflection.Metadata.BlobBuilder -> - unit - end - end - -namespace FSharp.Compiler.AbstractIL.Internal - module internal Support = begin - val DateTime1970Jan01 : System.DateTime - val absilWriteGetTimeStamp : unit -> int - val inline ignore : _x:'a -> unit - type IStream = System.Runtime.InteropServices.ComTypes.IStream - val check : _action:'a -> hresult:int -> unit - val MAX_PATH : int - val E_FAIL : int - val bytesToWord : b0:byte * b1:byte -> int16 - val bytesToDWord : b0:byte * b1:byte * b2:byte * b3:byte -> int - val bytesToQWord : - b0:byte * b1:byte * b2:byte * b3:byte * b4:byte * b5:byte * b6:byte * - b7:byte -> int64 - val dwToBytes : n:int -> byte [] * int - val wToBytes : n:int16 -> byte [] * int - type IMAGE_FILE_HEADER = - class - new : m:int16 * secs:int16 * tds:int32 * ptst:int32 * nos:int32 * - soh:int16 * c:int16 -> IMAGE_FILE_HEADER - member toBytes : unit -> byte [] - member Characteristics : int16 - member Machine : int16 - member NumberOfSections : int16 - member NumberOfSymbols : int32 - member PointerToSymbolTable : int32 - member SizeOfOptionalHeader : int16 - member TimeDateStamp : int32 - static member Width : int - end - val bytesToIFH : buffer:byte [] -> offset:int -> IMAGE_FILE_HEADER - type IMAGE_SECTION_HEADER = - class - new : n:int64 * ai:int32 * va:int32 * srd:int32 * prd:int32 * pr:int32 * - pln:int32 * nr:int16 * nl:int16 * c:int32 -> IMAGE_SECTION_HEADER - member toBytes : unit -> byte [] - member Characteristics : int32 - member Name : int64 - member NumberOfLineNumbers : int16 - member NumberOfRelocations : int16 - member PhysicalAddress : int32 - member PointerToLineNumbers : int32 - member PointerToRawData : int32 - member PointerToRelocations : int32 - member SizeOfRawData : int32 - member VirtualAddress : int32 - member VirtualSize : int32 - static member Width : int - end - val bytesToISH : buffer:byte [] -> offset:int -> IMAGE_SECTION_HEADER - type IMAGE_SYMBOL = - class - new : n:int64 * v:int32 * sn:int16 * t:int16 * sc:byte * nas:byte -> - IMAGE_SYMBOL - member toBytes : unit -> byte [] - member Name : int64 - member NumberOfAuxSymbols : byte - member SectionNumber : int16 - member StorageClass : byte - member Type : int16 - member Value : int32 - static member Width : int - end - val bytesToIS : buffer:byte [] -> offset:int -> IMAGE_SYMBOL - type IMAGE_RELOCATION = - class - new : va:int32 * sti:int32 * t:int16 -> IMAGE_RELOCATION - member toBytes : unit -> byte [] - member RelocCount : int32 - member SymbolTableIndex : int32 - member Type : int16 - member VirtualAddress : int32 - static member Width : int - end - val bytesToIR : buffer:byte [] -> offset:int -> IMAGE_RELOCATION - type IMAGE_RESOURCE_DIRECTORY = - class - new : c:int32 * tds:int32 * mjv:int16 * mnv:int16 * nne:int16 * - nie:int16 -> IMAGE_RESOURCE_DIRECTORY - member toBytes : unit -> byte [] - member Characteristics : int32 - member MajorVersion : int16 - member MinorVersion : int16 - member NumberOfIdEntries : int16 - member NumberOfNamedEntries : int16 - member TimeDateStamp : int32 - static member Width : int - end - val bytesToIRD : buffer:byte [] -> offset:int -> IMAGE_RESOURCE_DIRECTORY - type IMAGE_RESOURCE_DIRECTORY_ENTRY = - class - new : n:int32 * o:int32 -> IMAGE_RESOURCE_DIRECTORY_ENTRY - member toBytes : unit -> byte [] - member DataIsDirectory : bool - member Name : int32 - member OffsetToData : int32 - member OffsetToDirectory : int32 - static member Width : int - end - val bytesToIRDE : - buffer:byte [] -> offset:int -> IMAGE_RESOURCE_DIRECTORY_ENTRY - type IMAGE_RESOURCE_DATA_ENTRY = - class - new : o:int32 * s:int32 * c:int32 * r:int32 -> IMAGE_RESOURCE_DATA_ENTRY - member toBytes : unit -> unit - member CodePage : int32 - member OffsetToData : int32 - member Reserved : int32 - member Size : int32 - static member Width : int - end - val bytesToIRDataE : - buffer:byte [] -> offset:int -> IMAGE_RESOURCE_DATA_ENTRY - type ResFormatHeader = - class - new : unit -> ResFormatHeader - member toBytes : unit -> byte [] - member Characteristics : int - member DataSize : int - member DataVersion : int - member HeaderSize : int - member LangID : int16 - member MemFlags : int16 - member NameID : int - member TypeID : int - member Version : int - static member Width : int - end - type ResFormatNode = - class - new : tid:int32 * nid:int32 * lid:int32 * dataOffset:int32 * - pbLinkedResource:byte [] -> ResFormatNode - member - Save : ulLinkedResourceBaseRVA:int32 * pbLinkedResource:byte [] * - pUnlinkedResource:byte [] * offset:int -> int - member DataEntry : IMAGE_RESOURCE_DATA_ENTRY - member Name : byte [] - member ResHdr : ResFormatHeader - member Type : byte [] - end - val linkNativeResources : - unlinkedResources:byte [] list -> rva:int32 -> byte [] - val unlinkResource : int32 -> byte [] -> byte [] - end - -namespace FSharp.Compiler.AbstractIL.Internal - module internal AsciiParser = begin - val pfailwith : s:string -> 'a - type ResolvedAtMethodSpecScope<'T> = - | ResolvedAtMethodSpecScope of (IL.ILGenericParameterDefs -> 'T) - val noMethodSpecScope : x:'a -> ResolvedAtMethodSpecScope<'a> - val resolveMethodSpecScope : - ResolvedAtMethodSpecScope<'a> -> x:IL.ILGenericParameterDefs -> 'a - val resolveMethodSpecScopeThen : - ResolvedAtMethodSpecScope<'a> -> - g:('a -> ResolvedAtMethodSpecScope<'b>) -> ResolvedAtMethodSpecScope<'b> - val resolveCurrentMethodSpecScope : obj:ResolvedAtMethodSpecScope<'a> -> 'a - type token = - | VOID - | VARARG - | VALUETYPE - | VALUE - | UNSIGNED - | UNMANAGED - | UINT8 - | UINT64 - | UINT32 - | UINT16 - | UINT - | STRING - | STAR - | SLASH - | RPAREN - | RBRACK - | PLUS - | OBJECT - | NATIVE - | METHOD - | LPAREN - | LESS - | LBRACK - | INT8 - | INT64 - | INT32 - | INT16 - | INT - | INSTANCE - | GREATER - | FLOAT64 - | FLOAT32 - | FIELD - | EXPLICIT - | EOF - | ELIPSES - | DOT - | DEFAULT - | DCOLON - | COMMA - | CLASS - | CHAR - | BYTEARRAY - | BOOL - | BANG - | AMP - | VAL_SQSTRING of string - | VAL_QSTRING of string - | VAL_DOTTEDNAME of string - | VAL_ID of string - | VAL_HEXBYTE of int - | INSTR_VALUETYPE of AsciiConstants.ValueTypeInstr - | INSTR_INT_TYPE of AsciiConstants.IntTypeInstr - | INSTR_TYPE of AsciiConstants.TypeInstr - | INSTR_TOK of AsciiConstants.TokenInstr - | INSTR_STRING of AsciiConstants.StringInstr - | INSTR_NONE of AsciiConstants.NoArgInstr - | INSTR_R of AsciiConstants.DoubleInstr - | INSTR_I8 of AsciiConstants.Int64Instr - | INSTR_I32_I32 of AsciiConstants.Int32Int32Instr - | INSTR_I of AsciiConstants.Int32Instr - | VAL_FLOAT64 of double - | VAL_INT32_ELIPSES of int32 - | VAL_INT64 of int64 - type tokenId = - | TOKEN_VOID - | TOKEN_VARARG - | TOKEN_VALUETYPE - | TOKEN_VALUE - | TOKEN_UNSIGNED - | TOKEN_UNMANAGED - | TOKEN_UINT8 - | TOKEN_UINT64 - | TOKEN_UINT32 - | TOKEN_UINT16 - | TOKEN_UINT - | TOKEN_STRING - | TOKEN_STAR - | TOKEN_SLASH - | TOKEN_RPAREN - | TOKEN_RBRACK - | TOKEN_PLUS - | TOKEN_OBJECT - | TOKEN_NATIVE - | TOKEN_METHOD - | TOKEN_LPAREN - | TOKEN_LESS - | TOKEN_LBRACK - | TOKEN_INT8 - | TOKEN_INT64 - | TOKEN_INT32 - | TOKEN_INT16 - | TOKEN_INT - | TOKEN_INSTANCE - | TOKEN_GREATER - | TOKEN_FLOAT64 - | TOKEN_FLOAT32 - | TOKEN_FIELD - | TOKEN_EXPLICIT - | TOKEN_EOF - | TOKEN_ELIPSES - | TOKEN_DOT - | TOKEN_DEFAULT - | TOKEN_DCOLON - | TOKEN_COMMA - | TOKEN_CLASS - | TOKEN_CHAR - | TOKEN_BYTEARRAY - | TOKEN_BOOL - | TOKEN_BANG - | TOKEN_AMP - | TOKEN_VAL_SQSTRING - | TOKEN_VAL_QSTRING - | TOKEN_VAL_DOTTEDNAME - | TOKEN_VAL_ID - | TOKEN_VAL_HEXBYTE - | TOKEN_INSTR_VALUETYPE - | TOKEN_INSTR_INT_TYPE - | TOKEN_INSTR_TYPE - | TOKEN_INSTR_TOK - | TOKEN_INSTR_STRING - | TOKEN_INSTR_NONE - | TOKEN_INSTR_R - | TOKEN_INSTR_I8 - | TOKEN_INSTR_I32_I32 - | TOKEN_INSTR_I - | TOKEN_VAL_FLOAT64 - | TOKEN_VAL_INT32_ELIPSES - | TOKEN_VAL_INT64 - | TOKEN_end_of_input - | TOKEN_error - type nonTerminalId = - | NONTERM__startilInstrs - | NONTERM__startilType - | NONTERM_ilType - | NONTERM_ilInstrs - | NONTERM_compQstring - | NONTERM_methodName - | NONTERM_instrs2 - | NONTERM_instr - | NONTERM_name1 - | NONTERM_className - | NONTERM_slashedName - | NONTERM_typeNameInst - | NONTERM_typeName - | NONTERM_typSpec - | NONTERM_callConv - | NONTERM_callKind - | NONTERM_typ - | NONTERM_bounds1 - | NONTERM_bound - | NONTERM_id - | NONTERM_int32 - | NONTERM_int64 - | NONTERM_float64 - | NONTERM_opt_actual_tyargs - | NONTERM_actual_tyargs - | NONTERM_actualTypSpecs - val tagOfToken : t:token -> int - val tokenTagToTokenId : tokenIdx:int -> tokenId - val prodIdxToNonTerminal : prodIdx:int -> nonTerminalId - val _fsyacc_endOfInputTag : int - val _fsyacc_tagOfErrorTerminal : int - val token_to_string : t:token -> string - val _fsyacc_dataOfToken : t:token -> System.Object - val _fsyacc_gotos : uint16 [] - val _fsyacc_sparseGotoTableRowOffsets : uint16 [] - val _fsyacc_stateToProdIdxsTableElements : uint16 [] - val _fsyacc_stateToProdIdxsTableRowOffsets : uint16 [] - val _fsyacc_action_rows : int - val _fsyacc_actionTableElements : uint16 [] - val _fsyacc_actionTableRowOffsets : uint16 [] - val _fsyacc_reductionSymbolCounts : uint16 [] - val _fsyacc_productionToNonTerminalTable : uint16 [] - val _fsyacc_immediateActions : uint16 [] - val _fsyacc_reductions : - unit -> (Internal.Utilities.Text.Parsing.IParseState -> obj) [] - val tables : unit -> Internal.Utilities.Text.Parsing.Tables - val engine : - lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - startState:int -> obj - val ilInstrs : - lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - IL.ILInstr array - val ilType : - lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> IL.ILType - end - -namespace FSharp.Compiler.AbstractIL.Internal - module internal AsciiLexer = begin - val lexeme : lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> string - val lexemeChar : - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> n:int -> char - val unexpectedChar : _lexbuf:'a -> 'b - val keywords : Lazy<(string * AsciiParser.token) list> - val kwdInstrTable : - Lazy> - val kwdOrInstr : s:string -> AsciiParser.token - val evalDigit : ch:char -> int - val kwdOrInstrOrId : s:string -> AsciiParser.token - val trans : uint16 [] array - val actions : uint16 [] - val _fslex_tables : Internal.Utilities.Text.Lexing.UnicodeTables - val _fslex_dummy : unit -> 'a - val token : - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> AsciiParser.token - end - -namespace FSharp.Compiler.AbstractIL.Internal - module internal BinaryConstants = begin - [] - type TableName = - struct - new : idx:int -> TableName - static member FromIndex : int -> TableName - member Index : int - end - module TableNames = begin - val Module : TableName - val TypeRef : TableName - val TypeDef : TableName - val FieldPtr : TableName - val Field : TableName - val MethodPtr : TableName - val Method : TableName - val ParamPtr : TableName - val Param : TableName - val InterfaceImpl : TableName - val MemberRef : TableName - val Constant : TableName - val CustomAttribute : TableName - val FieldMarshal : TableName - val Permission : TableName - val ClassLayout : TableName - val FieldLayout : TableName - val StandAloneSig : TableName - val EventMap : TableName - val EventPtr : TableName - val Event : TableName - val PropertyMap : TableName - val PropertyPtr : TableName - val Property : TableName - val MethodSemantics : TableName - val MethodImpl : TableName - val ModuleRef : TableName - val TypeSpec : TableName - val ImplMap : TableName - val FieldRVA : TableName - val ENCLog : TableName - val ENCMap : TableName - val Assembly : TableName - val AssemblyProcessor : TableName - val AssemblyOS : TableName - val AssemblyRef : TableName - val AssemblyRefProcessor : TableName - val AssemblyRefOS : TableName - val File : TableName - val ExportedType : TableName - val ManifestResource : TableName - val Nested : TableName - val GenericParam : TableName - val MethodSpec : TableName - val GenericParamConstraint : TableName - val UserStrings : TableName - end - val sortedTableInfo : (TableName * int) list - [] - type TypeDefOrRefTag = - struct - new : tag:int32 -> TypeDefOrRefTag - member Tag : int32 - end - val tdor_TypeDef : TypeDefOrRefTag - val tdor_TypeRef : TypeDefOrRefTag - val tdor_TypeSpec : TypeDefOrRefTag - val mkTypeDefOrRefOrSpecTag : int -> TypeDefOrRefTag - [] - type HasConstantTag = - struct - new : tag:int32 -> HasConstantTag - member Tag : int32 - end - val hc_FieldDef : HasConstantTag - val hc_ParamDef : HasConstantTag - val hc_Property : HasConstantTag - val mkHasConstantTag : int -> HasConstantTag - [] - type HasCustomAttributeTag = - struct - new : tag:int32 -> HasCustomAttributeTag - member Tag : int32 - end - val hca_MethodDef : HasCustomAttributeTag - val hca_FieldDef : HasCustomAttributeTag - val hca_TypeRef : HasCustomAttributeTag - val hca_TypeDef : HasCustomAttributeTag - val hca_ParamDef : HasCustomAttributeTag - val hca_InterfaceImpl : HasCustomAttributeTag - val hca_MemberRef : HasCustomAttributeTag - val hca_Module : HasCustomAttributeTag - val hca_Permission : HasCustomAttributeTag - val hca_Property : HasCustomAttributeTag - val hca_Event : HasCustomAttributeTag - val hca_StandAloneSig : HasCustomAttributeTag - val hca_ModuleRef : HasCustomAttributeTag - val hca_TypeSpec : HasCustomAttributeTag - val hca_Assembly : HasCustomAttributeTag - val hca_AssemblyRef : HasCustomAttributeTag - val hca_File : HasCustomAttributeTag - val hca_ExportedType : HasCustomAttributeTag - val hca_ManifestResource : HasCustomAttributeTag - val hca_GenericParam : HasCustomAttributeTag - val hca_GenericParamConstraint : HasCustomAttributeTag - val hca_MethodSpec : HasCustomAttributeTag - val mkHasCustomAttributeTag : int -> HasCustomAttributeTag - [] - type HasFieldMarshalTag = - struct - new : tag:int32 -> HasFieldMarshalTag - member Tag : int32 - end - val hfm_FieldDef : HasFieldMarshalTag - val hfm_ParamDef : HasFieldMarshalTag - val mkHasFieldMarshalTag : int -> HasFieldMarshalTag - [] - type HasDeclSecurityTag = - struct - new : tag:int32 -> HasDeclSecurityTag - member Tag : int32 - end - val hds_TypeDef : HasDeclSecurityTag - val hds_MethodDef : HasDeclSecurityTag - val hds_Assembly : HasDeclSecurityTag - val mkHasDeclSecurityTag : int -> HasDeclSecurityTag - [] - type MemberRefParentTag = - struct - new : tag:int32 -> MemberRefParentTag - member Tag : int32 - end - val mrp_TypeRef : MemberRefParentTag - val mrp_ModuleRef : MemberRefParentTag - val mrp_MethodDef : MemberRefParentTag - val mrp_TypeSpec : MemberRefParentTag - val mkMemberRefParentTag : int -> MemberRefParentTag - [] - type HasSemanticsTag = - struct - new : tag:int32 -> HasSemanticsTag - member Tag : int32 - end - val hs_Event : HasSemanticsTag - val hs_Property : HasSemanticsTag - val mkHasSemanticsTag : int -> HasSemanticsTag - [] - type MethodDefOrRefTag = - struct - new : tag:int32 -> MethodDefOrRefTag - member Tag : int32 - end - val mdor_MethodDef : MethodDefOrRefTag - val mdor_MemberRef : MethodDefOrRefTag - val mdor_MethodSpec : MethodDefOrRefTag - val mkMethodDefOrRefTag : int -> MethodDefOrRefTag - [] - type MemberForwardedTag = - struct - new : tag:int32 -> MemberForwardedTag - member Tag : int32 - end - val mf_FieldDef : MemberForwardedTag - val mf_MethodDef : MemberForwardedTag - val mkMemberForwardedTag : int -> MemberForwardedTag - [] - type ImplementationTag = - struct - new : tag:int32 -> ImplementationTag - member Tag : int32 - end - val i_File : ImplementationTag - val i_AssemblyRef : ImplementationTag - val i_ExportedType : ImplementationTag - val mkImplementationTag : int -> ImplementationTag - [] - type CustomAttributeTypeTag = - struct - new : tag:int32 -> CustomAttributeTypeTag - member Tag : int32 - end - val cat_MethodDef : CustomAttributeTypeTag - val cat_MemberRef : CustomAttributeTypeTag - val mkILCustomAttributeTypeTag : int -> CustomAttributeTypeTag - [] - type ResolutionScopeTag = - struct - new : tag:int32 -> ResolutionScopeTag - member Tag : int32 - end - val rs_Module : ResolutionScopeTag - val rs_ModuleRef : ResolutionScopeTag - val rs_AssemblyRef : ResolutionScopeTag - val rs_TypeRef : ResolutionScopeTag - val mkResolutionScopeTag : int -> ResolutionScopeTag - [] - type TypeOrMethodDefTag = - struct - new : tag:int32 -> TypeOrMethodDefTag - member Tag : int32 - end - val tomd_TypeDef : TypeOrMethodDefTag - val tomd_MethodDef : TypeOrMethodDefTag - val mkTypeOrMethodDefTag : int -> TypeOrMethodDefTag - val et_END : byte - val et_VOID : byte - val et_BOOLEAN : byte - val et_CHAR : byte - val et_I1 : byte - val et_U1 : byte - val et_I2 : byte - val et_U2 : byte - val et_I4 : byte - val et_U4 : byte - val et_I8 : byte - val et_U8 : byte - val et_R4 : byte - val et_R8 : byte - val et_STRING : byte - val et_PTR : byte - val et_BYREF : byte - val et_VALUETYPE : byte - val et_CLASS : byte - val et_VAR : byte - val et_ARRAY : byte - val et_WITH : byte - val et_TYPEDBYREF : byte - val et_I : byte - val et_U : byte - val et_FNPTR : byte - val et_OBJECT : byte - val et_SZARRAY : byte - val et_MVAR : byte - val et_CMOD_REQD : byte - val et_CMOD_OPT : byte - val et_SENTINEL : byte - val et_PINNED : byte - val i_nop : int - val i_break : int - val i_ldarg_0 : int - val i_ldarg_1 : int - val i_ldarg_2 : int - val i_ldarg_3 : int - val i_ldloc_0 : int - val i_ldloc_1 : int - val i_ldloc_2 : int - val i_ldloc_3 : int - val i_stloc_0 : int - val i_stloc_1 : int - val i_stloc_2 : int - val i_stloc_3 : int - val i_ldarg_s : int - val i_ldarga_s : int - val i_starg_s : int - val i_ldloc_s : int - val i_ldloca_s : int - val i_stloc_s : int - val i_ldnull : int - val i_ldc_i4_m1 : int - val i_ldc_i4_0 : int - val i_ldc_i4_1 : int - val i_ldc_i4_2 : int - val i_ldc_i4_3 : int - val i_ldc_i4_4 : int - val i_ldc_i4_5 : int - val i_ldc_i4_6 : int - val i_ldc_i4_7 : int - val i_ldc_i4_8 : int - val i_ldc_i4_s : int - val i_ldc_i4 : int - val i_ldc_i8 : int - val i_ldc_r4 : int - val i_ldc_r8 : int - val i_dup : int - val i_pop : int - val i_jmp : int - val i_call : int - val i_calli : int - val i_ret : int - val i_br_s : int - val i_brfalse_s : int - val i_brtrue_s : int - val i_beq_s : int - val i_bge_s : int - val i_bgt_s : int - val i_ble_s : int - val i_blt_s : int - val i_bne_un_s : int - val i_bge_un_s : int - val i_bgt_un_s : int - val i_ble_un_s : int - val i_blt_un_s : int - val i_br : int - val i_brfalse : int - val i_brtrue : int - val i_beq : int - val i_bge : int - val i_bgt : int - val i_ble : int - val i_blt : int - val i_bne_un : int - val i_bge_un : int - val i_bgt_un : int - val i_ble_un : int - val i_blt_un : int - val i_switch : int - val i_ldind_i1 : int - val i_ldind_u1 : int - val i_ldind_i2 : int - val i_ldind_u2 : int - val i_ldind_i4 : int - val i_ldind_u4 : int - val i_ldind_i8 : int - val i_ldind_i : int - val i_ldind_r4 : int - val i_ldind_r8 : int - val i_ldind_ref : int - val i_stind_ref : int - val i_stind_i1 : int - val i_stind_i2 : int - val i_stind_i4 : int - val i_stind_i8 : int - val i_stind_r4 : int - val i_stind_r8 : int - val i_add : int - val i_sub : int - val i_mul : int - val i_div : int - val i_div_un : int - val i_rem : int - val i_rem_un : int - val i_and : int - val i_or : int - val i_xor : int - val i_shl : int - val i_shr : int - val i_shr_un : int - val i_neg : int - val i_not : int - val i_conv_i1 : int - val i_conv_i2 : int - val i_conv_i4 : int - val i_conv_i8 : int - val i_conv_r4 : int - val i_conv_r8 : int - val i_conv_u4 : int - val i_conv_u8 : int - val i_callvirt : int - val i_cpobj : int - val i_ldobj : int - val i_ldstr : int - val i_newobj : int - val i_castclass : int - val i_isinst : int - val i_conv_r_un : int - val i_unbox : int - val i_throw : int - val i_ldfld : int - val i_ldflda : int - val i_stfld : int - val i_ldsfld : int - val i_ldsflda : int - val i_stsfld : int - val i_stobj : int - val i_conv_ovf_i1_un : int - val i_conv_ovf_i2_un : int - val i_conv_ovf_i4_un : int - val i_conv_ovf_i8_un : int - val i_conv_ovf_u1_un : int - val i_conv_ovf_u2_un : int - val i_conv_ovf_u4_un : int - val i_conv_ovf_u8_un : int - val i_conv_ovf_i_un : int - val i_conv_ovf_u_un : int - val i_box : int - val i_newarr : int - val i_ldlen : int - val i_ldelema : int - val i_ldelem_i1 : int - val i_ldelem_u1 : int - val i_ldelem_i2 : int - val i_ldelem_u2 : int - val i_ldelem_i4 : int - val i_ldelem_u4 : int - val i_ldelem_i8 : int - val i_ldelem_i : int - val i_ldelem_r4 : int - val i_ldelem_r8 : int - val i_ldelem_ref : int - val i_stelem_i : int - val i_stelem_i1 : int - val i_stelem_i2 : int - val i_stelem_i4 : int - val i_stelem_i8 : int - val i_stelem_r4 : int - val i_stelem_r8 : int - val i_stelem_ref : int - val i_conv_ovf_i1 : int - val i_conv_ovf_u1 : int - val i_conv_ovf_i2 : int - val i_conv_ovf_u2 : int - val i_conv_ovf_i4 : int - val i_conv_ovf_u4 : int - val i_conv_ovf_i8 : int - val i_conv_ovf_u8 : int - val i_refanyval : int - val i_ckfinite : int - val i_mkrefany : int - val i_ldtoken : int - val i_conv_u2 : int - val i_conv_u1 : int - val i_conv_i : int - val i_conv_ovf_i : int - val i_conv_ovf_u : int - val i_add_ovf : int - val i_add_ovf_un : int - val i_mul_ovf : int - val i_mul_ovf_un : int - val i_sub_ovf : int - val i_sub_ovf_un : int - val i_endfinally : int - val i_leave : int - val i_leave_s : int - val i_stind_i : int - val i_conv_u : int - val i_arglist : int - val i_ceq : int - val i_cgt : int - val i_cgt_un : int - val i_clt : int - val i_clt_un : int - val i_ldftn : int - val i_ldvirtftn : int - val i_ldarg : int - val i_ldarga : int - val i_starg : int - val i_ldloc : int - val i_ldloca : int - val i_stloc : int - val i_localloc : int - val i_endfilter : int - val i_unaligned : int - val i_volatile : int - val i_constrained : int - val i_readonly : int - val i_tail : int - val i_initobj : int - val i_cpblk : int - val i_initblk : int - val i_rethrow : int - val i_sizeof : int - val i_refanytype : int - val i_ldelem_any : int - val i_stelem_any : int - val i_unbox_any : int - val mk_ldc : i:int32 -> IL.ILInstr - val noArgInstrs : Lazy<(int * IL.ILInstr) list> - val isNoArgInstr : IL.ILInstr -> bool - val ILCmpInstrMap : - Lazy> - val ILCmpInstrRevMap : - Lazy> - val nt_VOID : byte - val nt_BOOLEAN : byte - val nt_I1 : byte - val nt_U1 : byte - val nt_I2 : byte - val nt_U2 : byte - val nt_I4 : byte - val nt_U4 : byte - val nt_I8 : byte - val nt_U8 : byte - val nt_R4 : byte - val nt_R8 : byte - val nt_SYSCHAR : byte - val nt_VARIANT : byte - val nt_CURRENCY : byte - val nt_PTR : byte - val nt_DECIMAL : byte - val nt_DATE : byte - val nt_BSTR : byte - val nt_LPSTR : byte - val nt_LPWSTR : byte - val nt_LPTSTR : byte - val nt_FIXEDSYSSTRING : byte - val nt_OBJECTREF : byte - val nt_IUNKNOWN : byte - val nt_IDISPATCH : byte - val nt_STRUCT : byte - val nt_INTF : byte - val nt_SAFEARRAY : byte - val nt_FIXEDARRAY : byte - val nt_INT : byte - val nt_UINT : byte - val nt_NESTEDSTRUCT : byte - val nt_BYVALSTR : byte - val nt_ANSIBSTR : byte - val nt_TBSTR : byte - val nt_VARIANTBOOL : byte - val nt_FUNC : byte - val nt_ASANY : byte - val nt_ARRAY : byte - val nt_LPSTRUCT : byte - val nt_CUSTOMMARSHALER : byte - val nt_ERROR : byte - val nt_LPUTF8STR : byte - val nt_MAX : byte - val vt_EMPTY : int - val vt_NULL : int - val vt_I2 : int - val vt_I4 : int - val vt_R4 : int - val vt_R8 : int - val vt_CY : int - val vt_DATE : int - val vt_BSTR : int - val vt_DISPATCH : int - val vt_ERROR : int - val vt_BOOL : int - val vt_VARIANT : int - val vt_UNKNOWN : int - val vt_DECIMAL : int - val vt_I1 : int - val vt_UI1 : int - val vt_UI2 : int - val vt_UI4 : int - val vt_I8 : int - val vt_UI8 : int - val vt_INT : int - val vt_UINT : int - val vt_VOID : int - val vt_HRESULT : int - val vt_PTR : int - val vt_SAFEARRAY : int - val vt_CARRAY : int - val vt_USERDEFINED : int - val vt_LPSTR : int - val vt_LPWSTR : int - val vt_RECORD : int - val vt_FILETIME : int - val vt_BLOB : int - val vt_STREAM : int - val vt_STORAGE : int - val vt_STREAMED_OBJECT : int - val vt_STORED_OBJECT : int - val vt_BLOB_OBJECT : int - val vt_CF : int - val vt_CLSID : int - val vt_VECTOR : int - val vt_ARRAY : int - val vt_BYREF : int - val ILNativeTypeMap : Lazy<(byte * IL.ILNativeType) list> - val ILNativeTypeRevMap : Lazy<(IL.ILNativeType * byte) list> - val ILVariantTypeMap : Lazy<(IL.ILNativeVariant * int) list> - val ILVariantTypeRevMap : Lazy<(int * IL.ILNativeVariant) list> - val ILSecurityActionMap : Lazy<(IL.ILSecurityAction * int) list> - val ILSecurityActionRevMap : Lazy<(int * IL.ILSecurityAction) list> - val e_CorILMethod_TinyFormat : byte - val e_CorILMethod_FatFormat : byte - val e_CorILMethod_FormatMask : byte - val e_CorILMethod_MoreSects : byte - val e_CorILMethod_InitLocals : byte - val e_CorILMethod_Sect_EHTable : byte - val e_CorILMethod_Sect_FatFormat : byte - val e_CorILMethod_Sect_MoreSects : byte - val e_COR_ILEXCEPTION_CLAUSE_EXCEPTION : int - val e_COR_ILEXCEPTION_CLAUSE_FILTER : int - val e_COR_ILEXCEPTION_CLAUSE_FINALLY : int - val e_COR_ILEXCEPTION_CLAUSE_FAULT : int - val e_IMAGE_CEE_CS_CALLCONV_FASTCALL : byte - val e_IMAGE_CEE_CS_CALLCONV_STDCALL : byte - val e_IMAGE_CEE_CS_CALLCONV_THISCALL : byte - val e_IMAGE_CEE_CS_CALLCONV_CDECL : byte - val e_IMAGE_CEE_CS_CALLCONV_VARARG : byte - val e_IMAGE_CEE_CS_CALLCONV_FIELD : byte - val e_IMAGE_CEE_CS_CALLCONV_LOCAL_SIG : byte - val e_IMAGE_CEE_CS_CALLCONV_PROPERTY : byte - val e_IMAGE_CEE_CS_CALLCONV_GENERICINST : byte - val e_IMAGE_CEE_CS_CALLCONV_GENERIC : byte - val e_IMAGE_CEE_CS_CALLCONV_INSTANCE : byte - val e_IMAGE_CEE_CS_CALLCONV_INSTANCE_EXPLICIT : byte - end - -namespace FSharp.Compiler.AbstractIL - module ILBinaryReader = begin - val checking : bool - val logging : bool - val noStableFileHeuristic : bool - val alwaysMemoryMapFSC : bool - val stronglyHeldReaderCacheSizeDefault : int - val stronglyHeldReaderCacheSize : int - val singleOfBits : x:int32 -> float32 - val doubleOfBits : x:int64 -> float - val align : alignment:int -> n:int -> int - val uncodedToken : tab:Internal.BinaryConstants.TableName -> idx:int -> int - val i32ToUncodedToken : tok:int -> Internal.BinaryConstants.TableName * int - [] - type TaggedIndex<'T> = - struct - new : tag:'T * index:int32 -> TaggedIndex<'T> - val tag: 'T - val index: int32 - end - val uncodedTokenToTypeDefOrRefOrSpec : - tab:Internal.BinaryConstants.TableName * tok:int32 -> - TaggedIndex - val uncodedTokenToMethodDefOrRef : - tab:Internal.BinaryConstants.TableName * tok:int32 -> - TaggedIndex - val ( |TaggedIndex| ) : x:TaggedIndex<'T> -> 'T * int32 - val inline tokToTaggedIdx : - f:(int -> 'a) -> nbits:int -> tok:int -> TaggedIndex<'a> - type Statistics = - { mutable rawMemoryFileCount: int - mutable memoryMapFileOpenedCount: int - mutable memoryMapFileClosedCount: int - mutable weakByteFileCount: int - mutable byteFileCount: int } - val stats : Statistics - val GetStatistics : unit -> Statistics - type private BinaryView = Internal.ReadOnlyByteMemory - type BinaryFile = - interface - abstract member GetView : unit -> BinaryView - end - type RawMemoryFile = - class - interface BinaryFile - new : fileName:string * obj:obj * addr:nativeint * length:int -> - RawMemoryFile - member HoldObj : unit -> obj - member FileName : string - end - [] - type ByteFile = - class - interface BinaryFile - new : fileName:string * bytes:byte [] -> ByteFile - member FileName : string - end - [] - type WeakByteFile = - class - interface BinaryFile - new : fileName:string * chunk:(int * int) option -> WeakByteFile - member FileName : string - end - val seekReadByte : mdv:BinaryView -> addr:int -> byte - val seekReadBytes : mdv:BinaryView -> addr:int -> len:int -> byte [] - val seekReadInt32 : mdv:BinaryView -> addr:int -> int - val seekReadUInt16 : mdv:BinaryView -> addr:int -> uint16 - val seekReadByteAsInt32 : mdv:BinaryView -> addr:int -> int32 - val seekReadInt64 : mdv:BinaryView -> addr:int -> int64 - val seekReadUInt16AsInt32 : mdv:BinaryView -> addr:int -> int32 - val seekReadCompressedUInt32 : - mdv:BinaryView -> addr:int -> struct (int * int) - val seekReadSByte : mdv:BinaryView -> addr:int -> sbyte - val seekReadSingle : mdv:BinaryView -> addr:int -> float32 - val seekReadDouble : mdv:BinaryView -> addr:int -> float - val seekCountUtf8String : mdv:BinaryView -> addr:int -> n:int -> int - val seekReadUTF8String : mdv:BinaryView -> addr:int -> string - val seekReadBlob : mdv:BinaryView -> addr:int -> byte [] - val seekReadUserString : mdv:BinaryView -> addr:int -> string - val seekReadGuid : mdv:BinaryView -> addr:int -> byte [] - val seekReadUncodedToken : - mdv:BinaryView -> addr:int -> Internal.BinaryConstants.TableName * int - val sigptrCheck : bytes:byte [] -> sigptr:int -> unit - val sigptrGetByte : bytes:byte [] -> sigptr:int -> byte * int - val sigptrGetBool : bytes:byte [] -> sigptr:int -> bool * int - val sigptrGetSByte : bytes:byte [] -> sigptr:int -> sbyte * int - val sigptrGetUInt16 : bytes:byte [] -> sigptr:int -> uint16 * int - val sigptrGetInt16 : bytes:byte [] -> sigptr:int -> int16 * int - val sigptrGetInt32 : bytes:byte [] -> sigptr:int -> int * int - val sigptrGetUInt32 : bytes:byte [] -> sigptr:int -> uint32 * int - val sigptrGetUInt64 : bytes:byte [] -> sigptr:int -> uint64 * int - val sigptrGetInt64 : bytes:byte [] -> sigptr:int -> int64 * int - val sigptrGetSingle : bytes:byte [] -> sigptr:int -> float32 * int - val sigptrGetDouble : bytes:byte [] -> sigptr:int -> float * int - val sigptrGetZInt32 : bytes:byte [] -> sigptr:int -> struct (int * int) - val sigptrFoldAcc : - f:(byte [] -> int -> 'a * int) -> - n:int -> - bytes:byte [] -> sigptr:int -> i:int -> acc:'a list -> 'a list * int - val sigptrFold : - f:(byte [] -> int -> 'a * int) -> - n:int -> bytes:byte [] -> sigptr:int -> 'a list * int - val sigptrFoldStruct : - f:(byte [] -> int -> struct ('a * int)) -> - n:int -> bytes:byte [] -> sigptr:int -> struct ('a list * int) - val sigptrGetBytes : n:int -> bytes:byte [] -> sigptr:int -> byte [] * int - val sigptrGetString : n:int -> bytes:byte [] -> sigptr:int -> string * int - [] - type ILInstrPrefixesRegister = - { mutable al: IL.ILAlignment - mutable tl: IL.ILTailcall - mutable vol: IL.ILVolatility - mutable ro: IL.ILReadonly - mutable constrained: IL.ILType option } - val noPrefixes : mk:'a -> prefixes:ILInstrPrefixesRegister -> 'a - val volatileOrUnalignedPrefix : - mk:(IL.ILAlignment * IL.ILVolatility -> 'a) -> - prefixes:ILInstrPrefixesRegister -> 'a - val volatilePrefix : - mk:(IL.ILVolatility -> 'a) -> prefixes:ILInstrPrefixesRegister -> 'a - val tailPrefix : - mk:(IL.ILTailcall -> 'a) -> prefixes:ILInstrPrefixesRegister -> 'a - val constraintOrTailPrefix : - mk:(IL.ILType option * IL.ILTailcall -> 'a) -> - prefixes:ILInstrPrefixesRegister -> 'a - val readonlyPrefix : - mk:(IL.ILReadonly -> 'a) -> prefixes:ILInstrPrefixesRegister -> 'a - [] - type ILInstrDecoder = - | I_u16_u8_instr of (ILInstrPrefixesRegister -> uint16 -> IL.ILInstr) - | I_u16_u16_instr of (ILInstrPrefixesRegister -> uint16 -> IL.ILInstr) - | I_none_instr of (ILInstrPrefixesRegister -> IL.ILInstr) - | I_i64_instr of (ILInstrPrefixesRegister -> int64 -> IL.ILInstr) - | I_i32_i32_instr of (ILInstrPrefixesRegister -> int32 -> IL.ILInstr) - | I_i32_i8_instr of (ILInstrPrefixesRegister -> int32 -> IL.ILInstr) - | I_r4_instr of (ILInstrPrefixesRegister -> single -> IL.ILInstr) - | I_r8_instr of (ILInstrPrefixesRegister -> double -> IL.ILInstr) - | I_field_instr of - (ILInstrPrefixesRegister -> IL.ILFieldSpec -> IL.ILInstr) - | I_method_instr of - (ILInstrPrefixesRegister -> IL.ILMethodSpec * IL.ILVarArgs -> IL.ILInstr) - | I_unconditional_i32_instr of - (ILInstrPrefixesRegister -> IL.ILCodeLabel -> IL.ILInstr) - | I_unconditional_i8_instr of - (ILInstrPrefixesRegister -> IL.ILCodeLabel -> IL.ILInstr) - | I_conditional_i32_instr of - (ILInstrPrefixesRegister -> IL.ILCodeLabel -> IL.ILInstr) - | I_conditional_i8_instr of - (ILInstrPrefixesRegister -> IL.ILCodeLabel -> IL.ILInstr) - | I_string_instr of (ILInstrPrefixesRegister -> string -> IL.ILInstr) - | I_switch_instr of - (ILInstrPrefixesRegister -> IL.ILCodeLabel list -> IL.ILInstr) - | I_tok_instr of (ILInstrPrefixesRegister -> IL.ILToken -> IL.ILInstr) - | I_sig_instr of - (ILInstrPrefixesRegister -> IL.ILCallingSignature * IL.ILVarArgs -> - IL.ILInstr) - | I_type_instr of (ILInstrPrefixesRegister -> IL.ILType -> IL.ILInstr) - | I_invalid_instr - val mkStind : dt:IL.ILBasicType -> (ILInstrPrefixesRegister -> IL.ILInstr) - val mkLdind : dt:IL.ILBasicType -> (ILInstrPrefixesRegister -> IL.ILInstr) - val instrs : unit -> (int * ILInstrDecoder) list - val oneByteInstrs : ILInstrDecoder [] option ref - val twoByteInstrs : ILInstrDecoder [] option ref - val fillInstrs : unit -> unit - val getOneByteInstr : i:int -> ILInstrDecoder - val getTwoByteInstr : i:int -> ILInstrDecoder - type ImageChunk = - { size: int32 - addr: int32 } - val chunk : sz:int32 -> next:int32 -> ImageChunk * int32 - val nochunk : next:'a -> ImageChunk * 'a - type RowElementKind = - | UShort - | ULong - | Byte - | Data - | GGuid - | Blob - | SString - | SimpleIndex of Internal.BinaryConstants.TableName - | TypeDefOrRefOrSpec - | TypeOrMethodDef - | HasConstant - | HasCustomAttribute - | HasFieldMarshal - | HasDeclSecurity - | MemberRefParent - | HasSemantics - | MethodDefOrRef - | MemberForwarded - | Implementation - | CustomAttributeType - | ResolutionScope - type RowKind = | RowKind of RowElementKind list - val kindAssemblyRef : RowKind - val kindModuleRef : RowKind - val kindFileRef : RowKind - val kindTypeRef : RowKind - val kindTypeSpec : RowKind - val kindTypeDef : RowKind - val kindPropertyMap : RowKind - val kindEventMap : RowKind - val kindInterfaceImpl : RowKind - val kindNested : RowKind - val kindCustomAttribute : RowKind - val kindDeclSecurity : RowKind - val kindMemberRef : RowKind - val kindStandAloneSig : RowKind - val kindFieldDef : RowKind - val kindFieldRVA : RowKind - val kindFieldMarshal : RowKind - val kindConstant : RowKind - val kindFieldLayout : RowKind - val kindParam : RowKind - val kindMethodDef : RowKind - val kindMethodImpl : RowKind - val kindImplMap : RowKind - val kindMethodSemantics : RowKind - val kindProperty : RowKind - val kindEvent : RowKind - val kindManifestResource : RowKind - val kindClassLayout : RowKind - val kindExportedType : RowKind - val kindAssembly : RowKind - val kindGenericParam_v1_1 : RowKind - val kindGenericParam_v2_0 : RowKind - val kindMethodSpec : RowKind - val kindGenericParamConstraint : RowKind - val kindModule : RowKind - val kindIllegal : RowKind - val hcCompare : - TaggedIndex -> - TaggedIndex -> int - val hsCompare : - TaggedIndex -> - TaggedIndex -> int - val hcaCompare : - TaggedIndex -> - TaggedIndex -> int - val mfCompare : - TaggedIndex -> - TaggedIndex -> int - val hdsCompare : - TaggedIndex -> - TaggedIndex -> int - val hfmCompare : - TaggedIndex -> - TaggedIndex -> int - val tomdCompare : - TaggedIndex -> - TaggedIndex -> int - val simpleIndexCompare : idx1:int -> idx2:int -> int - type TypeDefAsTypIdx = - | TypeDefAsTypIdx of IL.ILBoxity * IL.ILGenericArgs * int - type TypeRefAsTypIdx = - | TypeRefAsTypIdx of IL.ILBoxity * IL.ILGenericArgs * int - type BlobAsMethodSigIdx = - | BlobAsMethodSigIdx of numtypars: int * blobIdx: int32 - type BlobAsFieldSigIdx = - | BlobAsFieldSigIdx of numtypars: int * blobIdx: int32 - type BlobAsPropSigIdx = - | BlobAsPropSigIdx of numtypars: int * blobIdx: int32 - type BlobAsLocalSigIdx = - | BlobAsLocalSigIdx of numtypars: int * blobIdx: int32 - type MemberRefAsMspecIdx = - | MemberRefAsMspecIdx of numtypars: int * idx: int - type MethodSpecAsMspecIdx = - | MethodSpecAsMspecIdx of numtypars: int * idx: int - type MemberRefAsFspecIdx = - | MemberRefAsFspecIdx of numtypars: int * idx: int - type CustomAttrIdx = - | CustomAttrIdx of - Internal.BinaryConstants.CustomAttributeTypeTag * idx: int * - valIdx: int32 - type GenericParamsIdx = - | GenericParamsIdx of - numtypars: int * Internal.BinaryConstants.TypeOrMethodDefTag * idx: int - val mkCacheInt32 : - lowMem:bool -> - _inbase:'a -> _nm:'b -> _sz:'c -> ((int32 -> 'd) -> int32 -> 'd) - val mkCacheGeneric : - lowMem:bool -> _inbase:'a -> _nm:'b -> _sz:'c -> (('T -> 'd) -> 'T -> 'd) - val seekFindRow : numRows:int -> rowChooser:(int -> bool) -> int - val seekReadIndexedRows : - numRows:int * rowReader:(int -> 'a) * keyFunc:('a -> 'b) * - keyComparer:('b -> int) * binaryChop:bool * rowConverter:('a -> 'c) -> - 'c list - val seekReadOptionalIndexedRow : - int * (int -> 'a) * ('a -> 'b) * ('b -> int) * bool * ('a -> 'c) -> - 'c option - val seekReadIndexedRow : - int * (int -> 'a) * ('a -> 'b) * ('b -> int) * bool * ('a -> 'c) -> 'c - type MethodData = - | MethodData of - enclTy: IL.ILType * IL.ILCallingConv * name: string * argtys: IL.ILTypes * - retty: IL.ILType * minst: IL.ILTypes - type VarArgMethodData = - | VarArgMethodData of - enclTy: IL.ILType * IL.ILCallingConv * name: string * argtys: IL.ILTypes * - IL.ILVarArgs * retty: IL.ILType * minst: IL.ILTypes - [] - type PEReader = - { fileName: string - pdb: obj option - entryPointToken: Internal.BinaryConstants.TableName * int - pefile: BinaryFile - textSegmentPhysicalLoc: int32 - textSegmentPhysicalSize: int32 - dataSegmentPhysicalLoc: int32 - dataSegmentPhysicalSize: int32 - anyV2P: string * int32 -> int32 - metadataAddr: int32 - sectionHeaders: (int32 * int32 * int32) list - nativeResourcesAddr: int32 - nativeResourcesSize: int32 - resourcesAddr: int32 - strongnameAddr: int32 - vtableFixupsAddr: int32 - noFileOnDisk: bool } - [] - type ILMetadataReader = - { sorted: int64 - mdfile: BinaryFile - pectxtCaptured: PEReader option - entryPointToken: Internal.BinaryConstants.TableName * int - dataEndPoints: System.Lazy - fileName: string - getNumRows: Internal.BinaryConstants.TableName -> int - userStringsStreamPhysicalLoc: int32 - stringsStreamPhysicalLoc: int32 - blobsStreamPhysicalLoc: int32 - blobsStreamSize: int32 - readUserStringHeap: int32 -> string - memoizeString: string -> string - readStringHeap: int32 -> string - readBlobHeap: int32 -> byte [] - guidsStreamPhysicalLoc: int32 - rowAddr: Internal.BinaryConstants.TableName -> int -> int32 - tableBigness: bool [] - rsBigness: bool - tdorBigness: bool - tomdBigness: bool - hcBigness: bool - hcaBigness: bool - hfmBigness: bool - hdsBigness: bool - mrpBigness: bool - hsBigness: bool - mdorBigness: bool - mfBigness: bool - iBigness: bool - catBigness: bool - stringsBigness: bool - guidsBigness: bool - blobsBigness: bool - seekReadNestedRow: int -> int * int - seekReadConstantRow: - int -> - uint16 * TaggedIndex * - int32 - seekReadMethodSemanticsRow: - int -> - int32 * int * TaggedIndex - seekReadTypeDefRow: - int -> - int32 * int32 * int32 * - TaggedIndex * int * int - seekReadAssemblyRef: int -> IL.ILAssemblyRef - seekReadMethodSpecAsMethodData: MethodSpecAsMspecIdx -> VarArgMethodData - seekReadMemberRefAsMethodData: MemberRefAsMspecIdx -> VarArgMethodData - seekReadMemberRefAsFieldSpec: MemberRefAsFspecIdx -> IL.ILFieldSpec - seekReadCustomAttr: CustomAttrIdx -> IL.ILAttribute - seekReadTypeRef: int -> IL.ILTypeRef - seekReadTypeRefAsType: TypeRefAsTypIdx -> IL.ILType - readBlobHeapAsPropertySig: - BlobAsPropSigIdx -> IL.ILThisConvention * IL.ILType * IL.ILTypes - readBlobHeapAsFieldSig: BlobAsFieldSigIdx -> IL.ILType - readBlobHeapAsMethodSig: - BlobAsMethodSigIdx -> - bool * int32 * IL.ILCallingConv * IL.ILType * IL.ILTypes * - IL.ILVarArgs - readBlobHeapAsLocalsSig: BlobAsLocalSigIdx -> IL.ILLocal list - seekReadTypeDefAsType: TypeDefAsTypIdx -> IL.ILType - seekReadMethodDefAsMethodData: int -> MethodData - seekReadGenericParams: GenericParamsIdx -> IL.ILGenericParameterDef list - seekReadFieldDefAsFieldSpec: int -> IL.ILFieldSpec - customAttrsReader_Module: IL.ILAttributesStored - customAttrsReader_Assembly: IL.ILAttributesStored - customAttrsReader_TypeDef: IL.ILAttributesStored - customAttrsReader_GenericParam: IL.ILAttributesStored - customAttrsReader_FieldDef: IL.ILAttributesStored - customAttrsReader_MethodDef: IL.ILAttributesStored - customAttrsReader_ParamDef: IL.ILAttributesStored - customAttrsReader_Event: IL.ILAttributesStored - customAttrsReader_Property: IL.ILAttributesStored - customAttrsReader_ManifestResource: IL.ILAttributesStored - customAttrsReader_ExportedType: IL.ILAttributesStored - securityDeclsReader_TypeDef: IL.ILSecurityDeclsStored - securityDeclsReader_MethodDef: IL.ILSecurityDeclsStored - securityDeclsReader_Assembly: IL.ILSecurityDeclsStored - typeDefReader: IL.ILTypeDefStored } - type ISeekReadIndexedRowReader<'RowT,'KeyT,'T when 'RowT : struct> = - interface - abstract member CompareKey : 'KeyT -> int - abstract member ConvertRow : byref<'RowT> -> 'T - abstract member GetKey : byref<'RowT> -> 'KeyT - abstract member GetRow : int * byref<'RowT> -> unit - end - val seekReadIndexedRowsByInterface : - numRows:int -> - binaryChop:bool -> - reader:ISeekReadIndexedRowReader<'RowT,'a,'b> -> 'b [] - when 'RowT : struct - [] - type CustomAttributeRow = - struct - val mutable parentIndex: - TaggedIndex - val mutable typeIndex: - TaggedIndex - val mutable valueIndex: int - end - val seekReadUInt16Adv : mdv:BinaryView -> addr:byref -> uint16 - val seekReadInt32Adv : mdv:BinaryView -> addr:byref -> int - val seekReadUInt16AsInt32Adv : mdv:BinaryView -> addr:byref -> int32 - val inline seekReadTaggedIdx : - f:(int -> 'a) -> - nbits:int -> - big:bool -> mdv:BinaryView -> addr:byref -> TaggedIndex<'a> - val seekReadIdx : big:bool -> mdv:BinaryView -> addr:byref -> int - val seekReadUntaggedIdx : - tab:Internal.BinaryConstants.TableName -> - ctxt:ILMetadataReader -> mdv:BinaryView -> addr:byref -> int - val seekReadResolutionScopeIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadTypeDefOrRefOrSpecIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadTypeOrMethodDefIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadHasConstantIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadHasCustomAttributeIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadHasFieldMarshalIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadHasDeclSecurityIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadMemberRefParentIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadHasSemanticsIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadMethodDefOrRefIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadMemberForwardedIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadImplementationIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadCustomAttributeTypeIdx : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - addr:byref -> - TaggedIndex - val seekReadStringIdx : - ctxt:ILMetadataReader -> mdv:BinaryView -> addr:byref -> int - val seekReadGuidIdx : - ctxt:ILMetadataReader -> mdv:BinaryView -> addr:byref -> int - val seekReadBlobIdx : - ctxt:ILMetadataReader -> mdv:BinaryView -> addr:byref -> int - val seekReadModuleRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> idx:int -> uint16 * int * int * int * int - val seekReadTypeRefRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - TaggedIndex * int * int - val seekReadTypeDefRow : - ctxt:ILMetadataReader -> - idx:int -> - int32 * int32 * int32 * - TaggedIndex * int * int - val seekReadTypeDefRowUncached : - ctxtH:ILMetadataReader option ref -> - idx:int -> - int * int * int * - TaggedIndex * int * int - val seekReadFieldRow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int32 * int * int - val seekReadMethodRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> idx:int -> int * int32 * int32 * int * int * int - val seekReadParamRow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int32 * int32 * int - val seekReadInterfaceImplRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> int * TaggedIndex - val seekReadMemberRefRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - TaggedIndex * int * int - val seekReadConstantRow : - ctxt:ILMetadataReader -> - idx:int -> - uint16 * TaggedIndex * int32 - val seekReadConstantRowUncached : - ctxtH:ILMetadataReader option ref -> - idx:int -> - uint16 * TaggedIndex * int - val seekReadCustomAttributeRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> idx:int -> attrRow:byref -> unit - val seekReadFieldMarshalRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - TaggedIndex * int - val seekReadPermissionRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - uint16 * TaggedIndex * - int - val seekReadClassLayoutRow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> uint16 * int * int - val seekReadFieldLayoutRow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int * int - val seekReadStandAloneSigRow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int - val seekReadEventMapRow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int * int - val seekReadEventRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - int32 * int * TaggedIndex - val seekReadPropertyMapRow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int * int - val seekReadPropertyRow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int32 * int * int - val seekReadMethodSemanticsRow : - ctxt:ILMetadataReader -> - idx:int -> - int32 * int * TaggedIndex - val seekReadMethodSemanticsRowUncached : - ctxtH:ILMetadataReader option ref -> - idx:int -> - int32 * int * TaggedIndex - val seekReadMethodImplRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - int * TaggedIndex * - TaggedIndex - val seekReadModuleRefRow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int - val seekReadTypeSpecRow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int - val seekReadImplMapRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - int32 * TaggedIndex * - int * int - val seekReadFieldRVARow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int * int - val seekReadAssemblyRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - int * uint16 * uint16 * uint16 * uint16 * int * int * int * int - val seekReadAssemblyRefRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - uint16 * uint16 * uint16 * uint16 * int * int * int * int * int - val seekReadFileRow : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> int * int * int - val seekReadExportedTypeRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - int * int * int * int * - TaggedIndex - val seekReadManifestResourceRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - int * int * int * - TaggedIndex - val seekReadNestedRow : ctxt:ILMetadataReader -> idx:int -> int * int - val seekReadNestedRowUncached : - ctxtH:ILMetadataReader option ref -> idx:int -> int * int - val seekReadGenericParamRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - int * uint16 * uint16 * - TaggedIndex * int - val seekReadGenericParamConstraintRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> int * TaggedIndex - val seekReadMethodSpecRow : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - idx:int -> - TaggedIndex * int - val readUserStringHeapUncached : - ctxtH:ILMetadataReader option ref -> idx:int32 -> string - val readUserStringHeap : ctxt:ILMetadataReader -> idx:int32 -> string - val readStringHeapUncached : - ctxtH:ILMetadataReader option ref -> idx:int32 -> string - val readStringHeap : ctxt:ILMetadataReader -> idx:int32 -> string - val readStringHeapOption : ctxt:ILMetadataReader -> idx:int -> string option - val emptyByteArray : byte [] - val readBlobHeapUncached : - ctxtH:ILMetadataReader option ref -> idx:int -> byte [] - val readBlobHeap : ctxt:ILMetadataReader -> idx:int32 -> byte [] - val readBlobHeapOption : ctxt:ILMetadataReader -> idx:int -> byte [] option - val readBlobHeapAsBool : ctxt:ILMetadataReader -> vidx:int32 -> bool - val readBlobHeapAsSByte : ctxt:ILMetadataReader -> vidx:int32 -> sbyte - val readBlobHeapAsInt16 : ctxt:ILMetadataReader -> vidx:int32 -> int16 - val readBlobHeapAsInt32 : ctxt:ILMetadataReader -> vidx:int32 -> int - val readBlobHeapAsInt64 : ctxt:ILMetadataReader -> vidx:int32 -> int64 - val readBlobHeapAsByte : ctxt:ILMetadataReader -> vidx:int32 -> byte - val readBlobHeapAsUInt16 : ctxt:ILMetadataReader -> vidx:int32 -> uint16 - val readBlobHeapAsUInt32 : ctxt:ILMetadataReader -> vidx:int32 -> uint32 - val readBlobHeapAsUInt64 : ctxt:ILMetadataReader -> vidx:int32 -> uint64 - val readBlobHeapAsSingle : ctxt:ILMetadataReader -> vidx:int32 -> float32 - val readBlobHeapAsDouble : ctxt:ILMetadataReader -> vidx:int32 -> float - val readNativeResources : pectxt:PEReader -> IL.ILNativeResource list - val getDataEndPointsDelayed : - pectxt:PEReader -> ctxtH:ILMetadataReader option ref -> Lazy - val rvaToData : - ctxt:ILMetadataReader -> - pectxt:PEReader -> nm:string -> rva:int -> byte [] - val isSorted : - ctxt:ILMetadataReader -> tab:Internal.BinaryConstants.TableName -> bool - val seekReadModule : - ctxt:ILMetadataReader -> - canReduceMemory:bool -> - pectxtEager:PEReader -> - pevEager:BinaryView -> - uint16 * (int * int) * bool * bool * bool * bool * bool * - IL.ILPlatform option * bool * int32 * int32 * int32 -> - ilMetadataVersion:string -> idx:int -> IL.ILModuleDef - val seekReadAssemblyManifest : - ctxt:ILMetadataReader -> - pectxt:PEReader -> idx:int -> IL.ILAssemblyManifest - val seekReadAssemblyRef : - ctxt:ILMetadataReader -> idx:int -> IL.ILAssemblyRef - val seekReadAssemblyRefUncached : - ctxtH:ILMetadataReader option ref -> idx:int -> IL.ILAssemblyRef - val seekReadModuleRef : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> IL.ILModuleRef - val seekReadFile : - ctxt:ILMetadataReader -> mdv:BinaryView -> idx:int -> IL.ILModuleRef - val seekReadClassLayout : - ctxt:ILMetadataReader -> - mdv:BinaryView -> idx:int -> IL.ILTypeDefLayoutInfo - val typeAccessOfFlags : flags:int -> IL.ILTypeDefAccess - val typeLayoutOfFlags : - ctxt:ILMetadataReader -> - mdv:BinaryView -> flags:int -> tidx:int -> IL.ILTypeDefLayout - val isTopTypeDef : flags:int -> bool - val seekIsTopTypeDefOfIdx : ctxt:ILMetadataReader -> idx:int -> bool - val readBlobHeapAsSplitTypeName : - ctxt:ILMetadataReader -> - nameIdx:int32 * namespaceIdx:int -> string list * string - val readBlobHeapAsTypeName : - ctxt:ILMetadataReader -> nameIdx:int32 * namespaceIdx:int -> string - val seekReadTypeDefRowExtents : - ctxt:ILMetadataReader -> _info:'a -> idx:int -> struct (int * int) - val seekReadTypeDefRowWithExtents : - ctxt:ILMetadataReader -> - idx:int -> - (int32 * int32 * int32 * - TaggedIndex * int * int) * - struct (int * int) - val seekReadPreTypeDef : - ctxt:ILMetadataReader -> toponly:bool -> idx:int -> IL.ILPreTypeDef option - val typeDefReader : ctxtH:ILMetadataReader option ref -> IL.ILTypeDefStored - val seekReadTopTypeDefs : ctxt:ILMetadataReader -> IL.ILPreTypeDef [] - val seekReadNestedTypeDefs : - ctxt:ILMetadataReader -> tidx:int32 -> IL.ILTypeDefs - val seekReadInterfaceImpls : - ctxt:ILMetadataReader -> - mdv:BinaryView -> numtypars:int -> tidx:int32 -> IL.ILTypes - val seekReadGenericParams : - ctxt:ILMetadataReader -> - numtypars:int -> - a:Internal.BinaryConstants.TypeOrMethodDefTag * b:int32 -> - IL.ILGenericParameterDefs - val seekReadGenericParamsUncached : - ctxtH:ILMetadataReader option ref -> - GenericParamsIdx -> IL.ILGenericParameterDef list - val seekReadGenericParamConstraints : - ctxt:ILMetadataReader -> - mdv:BinaryView -> numtypars:int -> gpidx:int -> IL.ILTypes - val seekReadTypeDefAsType : - ctxt:ILMetadataReader -> - boxity:IL.ILBoxity -> ginst:IL.ILTypes -> idx:int -> IL.ILType - val seekReadTypeDefAsTypeUncached : - ctxtH:ILMetadataReader option ref -> TypeDefAsTypIdx -> IL.ILType - val seekReadTypeDefAsTypeRef : - ctxt:ILMetadataReader -> idx:int -> IL.ILTypeRef - val seekReadTypeRef : ctxt:ILMetadataReader -> idx:int -> IL.ILTypeRef - val seekReadTypeRefUncached : - ctxtH:ILMetadataReader option ref -> idx:int -> IL.ILTypeRef - val seekReadTypeRefAsType : - ctxt:ILMetadataReader -> - boxity:IL.ILBoxity -> ginst:IL.ILGenericArgs -> idx:int -> IL.ILType - val seekReadTypeRefAsTypeUncached : - ctxtH:ILMetadataReader option ref -> TypeRefAsTypIdx -> IL.ILType - val seekReadTypeDefOrRef : - ctxt:ILMetadataReader -> - numtypars:int -> - boxity:IL.ILBoxity -> - ginst:IL.ILTypes -> - TaggedIndex -> IL.ILType - val seekReadTypeDefOrRefAsTypeRef : - ctxt:ILMetadataReader -> - TaggedIndex -> IL.ILTypeRef - val seekReadMethodRefParent : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - numtypars:int -> - TaggedIndex -> - IL.ILType - val seekReadMethodDefOrRef : - ctxt:ILMetadataReader -> - numtypars:int -> - TaggedIndex -> - VarArgMethodData - val seekReadMethodDefOrRefNoVarargs : - ctxt:ILMetadataReader -> - numtypars:int -> - x:TaggedIndex -> - MethodData - val seekReadCustomAttrType : - ctxt:ILMetadataReader -> - TaggedIndex -> - IL.ILMethodSpec - val seekReadImplAsScopeRef : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - TaggedIndex -> - IL.ILScopeRef - val seekReadTypeRefScope : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - TaggedIndex -> - IL.ILScopeRef * string list - val seekReadOptionalTypeDefOrRef : - ctxt:ILMetadataReader -> - numtypars:int -> - boxity:IL.ILBoxity -> - idx:TaggedIndex -> - IL.ILType option - val seekReadField : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - numtypars:int * hasLayout:bool -> idx:int -> IL.ILFieldDef - val seekReadFields : - ctxt:ILMetadataReader -> - numtypars:int * hasLayout:bool -> - fidx1:int -> fidx2:int -> IL.ILFieldDefs - val seekReadMethods : - ctxt:ILMetadataReader -> - numtypars:int -> midx1:int -> midx2:int -> IL.ILMethodDefs - val sigptrGetTypeDefOrRefOrSpecIdx : - bytes:byte [] -> - sigptr:int -> - TaggedIndex * int - val sigptrGetTy : - ctxt:ILMetadataReader -> - numtypars:int -> bytes:byte [] -> sigptr:int -> IL.ILType * int - val sigptrGetVarArgTys : - ctxt:ILMetadataReader -> - n:int -> - numtypars:int -> bytes:byte [] -> sigptr:int -> IL.ILType list * int - val sigptrGetArgTys : - ctxt:ILMetadataReader -> - n:int -> - numtypars:int -> - bytes:byte [] -> - sigptr:int -> - acc:IL.ILType list -> - (IL.ILType list * IL.ILType list option) * int - val sigptrGetLocal : - ctxt:ILMetadataReader -> - numtypars:int -> bytes:byte [] -> sigptr:int -> IL.ILLocal * int - val readBlobHeapAsMethodSig : - ctxt:ILMetadataReader -> - numtypars:int -> - blobIdx:int32 -> - bool * int32 * IL.ILCallingConv * IL.ILType * IL.ILTypes * - IL.ILVarArgs - val readBlobHeapAsMethodSigUncached : - ctxtH:ILMetadataReader option ref -> - BlobAsMethodSigIdx -> - bool * int * IL.ILCallingConv * IL.ILType * IL.ILType list * - IL.ILType list option - val readBlobHeapAsType : - ctxt:ILMetadataReader -> numtypars:int -> blobIdx:int -> IL.ILType - val readBlobHeapAsFieldSig : - ctxt:ILMetadataReader -> numtypars:int -> blobIdx:int -> IL.ILType - val readBlobHeapAsFieldSigUncached : - ctxtH:ILMetadataReader option ref -> BlobAsFieldSigIdx -> IL.ILType - val readBlobHeapAsPropertySig : - ctxt:ILMetadataReader -> - numtypars:int -> - blobIdx:int32 -> IL.ILThisConvention * IL.ILType * IL.ILTypes - val readBlobHeapAsPropertySigUncached : - ctxtH:ILMetadataReader option ref -> - BlobAsPropSigIdx -> IL.ILThisConvention * IL.ILType * IL.ILType list - val readBlobHeapAsLocalsSig : - ctxt:ILMetadataReader -> numtypars:int -> blobIdx:int32 -> IL.ILLocal list - val readBlobHeapAsLocalsSigUncached : - ctxtH:ILMetadataReader option ref -> BlobAsLocalSigIdx -> IL.ILLocal list - val byteAsHasThis : b:byte -> IL.ILThisConvention - val byteAsCallConv : b:byte -> bool * IL.ILCallingConv - val seekReadMemberRefAsMethodData : - ctxt:ILMetadataReader -> numtypars:int -> idx:int32 -> VarArgMethodData - val seekReadMemberRefAsMethodDataUncached : - ctxtH:ILMetadataReader option ref -> - MemberRefAsMspecIdx -> VarArgMethodData - val seekReadMemberRefAsMethDataNoVarArgs : - ctxt:ILMetadataReader -> numtypars:int -> idx:int32 -> MethodData - val seekReadMethodSpecAsMethodData : - ctxt:ILMetadataReader -> numtypars:int -> idx:int -> VarArgMethodData - val seekReadMethodSpecAsMethodDataUncached : - ctxtH:ILMetadataReader option ref -> - MethodSpecAsMspecIdx -> VarArgMethodData - val seekReadMemberRefAsFieldSpec : - ctxt:ILMetadataReader -> numtypars:int -> idx:int -> IL.ILFieldSpec - val seekReadMemberRefAsFieldSpecUncached : - ctxtH:ILMetadataReader option ref -> MemberRefAsFspecIdx -> IL.ILFieldSpec - val seekReadMethodDefAsMethodData : - ctxt:ILMetadataReader -> idx:int32 -> MethodData - val seekReadMethodDefAsMethodDataUncached : - ctxtH:ILMetadataReader option ref -> idx:int -> MethodData - val seekReadFieldDefAsFieldSpec : - ctxt:ILMetadataReader -> idx:int -> IL.ILFieldSpec - val seekReadFieldDefAsFieldSpecUncached : - ctxtH:ILMetadataReader option ref -> idx:int -> IL.ILFieldSpec - val seekReadMethod : - ctxt:ILMetadataReader -> - mdv:BinaryView -> numtypars:int -> idx:int -> IL.ILMethodDef - val seekReadParams : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - retty:IL.ILType * argtys:IL.ILTypes -> - pidx1:int -> pidx2:int -> IL.ILReturn * IL.ILParameters - val seekReadParamExtras : - ctxt:ILMetadataReader -> - mdv:BinaryView -> - retRes:IL.ILReturn ref * paramsRes:IL.ILParameter [] -> - idx:int -> unit - val seekReadMethodImpls : - ctxt:ILMetadataReader -> - numtypars:int -> tidx:int32 -> IL.ILMethodImplDefs - val seekReadMultipleMethodSemantics : - ctxt:ILMetadataReader -> - flags:int32 * id:TaggedIndex -> - IL.ILMethodRef list - val seekReadoptional_MethodSemantics : - ctxt:ILMetadataReader -> - int32 * TaggedIndex -> - IL.ILMethodRef option - val seekReadMethodSemantics : - ctxt:ILMetadataReader -> - int32 * TaggedIndex -> - IL.ILMethodRef - val seekReadEvent : - ctxt:ILMetadataReader -> - mdv:BinaryView -> numtypars:int -> idx:int -> IL.ILEventDef - val seekReadEvents : - ctxt:ILMetadataReader -> numtypars:int -> tidx:int32 -> IL.ILEventDefs - val seekReadProperty : - ctxt:ILMetadataReader -> - mdv:BinaryView -> numtypars:int -> idx:int -> IL.ILPropertyDef - val seekReadProperties : - ctxt:ILMetadataReader -> numtypars:int -> tidx:int32 -> IL.ILPropertyDefs - val customAttrsReader : - ctxtH:ILMetadataReader option ref -> - tag:Internal.BinaryConstants.HasCustomAttributeTag -> - IL.ILAttributesStored - val seekReadCustomAttr : - ctxt:ILMetadataReader -> - TaggedIndex * b:int -> - IL.ILAttribute - val seekReadCustomAttrUncached : - ctxtH:ILMetadataReader option ref -> CustomAttrIdx -> IL.ILAttribute - val securityDeclsReader : - ctxtH:ILMetadataReader option ref -> - tag:Internal.BinaryConstants.HasDeclSecurityTag -> - IL.ILSecurityDeclsStored - val seekReadSecurityDecl : - ctxt:ILMetadataReader -> act:uint16 * ty:int -> IL.ILSecurityDecl - val seekReadConstant : - ctxt:ILMetadataReader -> - idx:TaggedIndex -> - IL.ILFieldInit - val seekReadImplMap : - ctxt:ILMetadataReader -> nm:string -> midx:int -> IL.ILLazyMethodBody - val seekReadTopCode : - ctxt:ILMetadataReader -> - pev:BinaryView -> - mdv:BinaryView -> - numtypars:int -> - sz:int -> - start:int -> - seqpoints:(int * IL.ILSourceMarker) list -> - IL.ILInstr [] * (int -> IL.ILCodeLabel) * - System.Collections.Generic.Dictionary * - (int -> IL.ILCodeLabel) - val seekReadMethodRVA : - pectxt:PEReader -> - ctxt:ILMetadataReader -> - _idx:int * nm:string * _internalcall:bool * noinline:bool * - aggressiveinline:bool * numtypars:int -> - rva:int -> IL.ILLazyMethodBody - val int32AsILVariantType : - ctxt:ILMetadataReader -> n:int32 -> IL.ILNativeVariant - val readBlobHeapAsNativeType : - ctxt:ILMetadataReader -> blobIdx:int -> IL.ILNativeType - val sigptrGetILNativeType : - ctxt:ILMetadataReader -> - bytes:byte [] -> sigptr:int -> IL.ILNativeType * int - val seekReadManifestResources : - ctxt:ILMetadataReader -> - canReduceMemory:bool -> - mdv:BinaryView -> - pectxtEager:PEReader -> pevEager:BinaryView -> IL.ILResources - val seekReadNestedExportedTypes : - ctxt:ILMetadataReader -> - exported:(int * 'b * int32 * int * 'c) [] -> - nested:System.Lazy -> - parentIdx:int32 -> IL.ILNestedExportedTypes - val seekReadTopExportedTypes : - ctxt:ILMetadataReader -> IL.ILExportedTypesAndForwarders - val openMetadataReader : - fileName:string * mdfile:BinaryFile * metadataPhysLoc:int * - peinfo:(uint16 * (int * int) * bool * bool * bool * bool * bool * - IL.ILPlatform option * bool * int32 * int32 * int32) * - pectxtEager:PEReader * pevEager:BinaryView * - pectxtCaptured:PEReader option * reduceMemoryUsage:bool -> - IL.ILModuleDef * Lazy - val openPEFileReader : - fileName:string * pefile:BinaryFile * pdbDirPath:'a * noFileOnDisk:bool -> - int * int * - (uint16 * (int32 * int32) * bool * bool * bool * bool * bool * - IL.ILPlatform option * bool * int * int * int) * PEReader * BinaryView * - obj option - val openPE : - fileName:string * pefile:BinaryFile * pdbDirPath:'a * - reduceMemoryUsage:bool * noFileOnDisk:bool -> - IL.ILModuleDef * Lazy * obj option - val openPEMetadataOnly : - fileName:string * - peinfo:(uint16 * (int * int) * bool * bool * bool * bool * bool * - IL.ILPlatform option * bool * int32 * int32 * int32) * - pectxtEager:PEReader * pevEager:BinaryView * mdfile:BinaryFile * - reduceMemoryUsage:bool -> IL.ILModuleDef * Lazy - val ClosePdbReader : pdb:'a -> unit - type ILReaderMetadataSnapshot = obj * nativeint * int - type ILReaderTryGetMetadataSnapshot = - string * System.DateTime -> ILReaderMetadataSnapshot option - [] - type MetadataOnlyFlag = - | Yes - | No - [] - type ReduceMemoryFlag = - | Yes - | No - type ILReaderOptions = - { pdbDirPath: string option - reduceMemoryUsage: ReduceMemoryFlag - metadataOnly: MetadataOnlyFlag - tryGetMetadataSnapshot: ILReaderTryGetMetadataSnapshot } - type ILModuleReader = - interface - inherit System.IDisposable - abstract member ILAssemblyRefs : IL.ILAssemblyRef list - abstract member ILModuleDef : IL.ILModuleDef - end - [] - type ILModuleReaderImpl = - class - interface ILModuleReader - new : ilModule:IL.ILModuleDef * - ilAssemblyRefs:System.Lazy * - dispose:(unit -> unit) -> ILModuleReaderImpl - end - type ILModuleReaderCacheKey = - | ILModuleReaderCacheKey of - string * System.DateTime * bool * ReduceMemoryFlag * MetadataOnlyFlag - type ILModuleReaderCache1LockToken = - class - interface Internal.Library.LockToken - new : unit -> ILModuleReaderCache1LockToken - end - val ilModuleReaderCache1 : - Internal.Utilities.Collections.AgedLookup - val ilModuleReaderCache1Lock : - Internal.Library.Lock - val ilModuleReaderCache2 : - System.Collections.Concurrent.ConcurrentDictionary> - val stableFileHeuristicApplies : fileName:string -> bool - val createByteFileChunk : - opts:ILReaderOptions -> - fileName:string -> chunk:(int * int) option -> BinaryFile - val createMemoryMapFile : fileName:string -> System.IDisposable * BinaryFile - val OpenILModuleReaderFromBytes : - fileName:string -> - assemblyContents:byte [] -> options:ILReaderOptions -> ILModuleReader - val ClearAllILModuleReaderCache : unit -> unit - val OpenILModuleReader : string -> ILReaderOptions -> ILModuleReader - module Shim = begin - type IAssemblyReader = - interface - abstract member - GetILModuleReader : filename:string * readerOptions:ILReaderOptions -> - ILModuleReader - end - [] - type DefaultAssemblyReader = - class - interface IAssemblyReader - new : unit -> DefaultAssemblyReader - end - val mutable AssemblyReader : IAssemblyReader - end - end - -namespace FSharp.Compiler.AbstractIL - module internal ILPdbWriter = begin - type BlobBuildingStream = - class - inherit System.IO.Stream - new : unit -> BlobBuildingStream - override Dispose : _disposing:bool -> unit - override Flush : unit -> unit - override Read : _buffer:byte [] * _offset:int * _count:int -> int - override Seek : _offset:int64 * _origin:System.IO.SeekOrigin -> int64 - override SetLength : _value:int64 -> unit - member - ToImmutableArray : unit -> - System.Collections.Immutable.ImmutableArray - member TryWriteBytes : stream:System.IO.Stream * length:int -> int - override Write : buffer:byte [] * offset:int * count:int -> unit - override WriteByte : value:byte -> unit - member WriteInt32 : value:int -> unit - override CanRead : bool - override CanSeek : bool - override CanWrite : bool - override Length : int64 - override Position : int64 - end - type PdbDocumentData = IL.ILSourceDocument - type PdbLocalVar = - { Name: string - Signature: byte [] - Index: int32 } - type PdbMethodScope = - { Children: PdbMethodScope array - StartOffset: int - EndOffset: int - Locals: PdbLocalVar array } - type PdbSourceLoc = - { Document: int - Line: int - Column: int } - type PdbSequencePoint = - { Document: int - Offset: int - Line: int - Column: int - EndLine: int - EndColumn: int } - with - override ToString : unit -> string - end - type PdbMethodData = - { MethToken: int32 - MethName: string - LocalSignatureToken: int32 - Params: PdbLocalVar array - RootScope: PdbMethodScope option - Range: (PdbSourceLoc * PdbSourceLoc) option - SequencePoints: PdbSequencePoint array } - module SequencePoint = begin - val orderBySource : sp1:PdbSequencePoint -> sp2:PdbSequencePoint -> int - val orderByOffset : sp1:PdbSequencePoint -> sp2:PdbSequencePoint -> int - end - val sizeof_IMAGE_DEBUG_DIRECTORY : int - [] - type PdbData = - { EntryPoint: int32 option - Timestamp: int32 - ModuleID: byte [] - Documents: PdbDocumentData [] - Methods: PdbMethodData [] - TableRowCounts: int [] } - type BinaryChunk = - { size: int32 - addr: int32 } - type idd = - { iddCharacteristics: int32 - iddMajorVersion: int32 - iddMinorVersion: int32 - iddType: int32 - iddTimestamp: int32 - iddData: byte [] - iddChunk: BinaryChunk } - type HashAlgorithm = - | Sha1 - | Sha256 - val guidSha1 : System.Guid - val guidSha2 : System.Guid - val checkSum : - url:string -> - checksumAlgorithm:HashAlgorithm -> (System.Guid * byte []) option - val cvMagicNumber : int64 - val pdbGetCvDebugInfo : - mvid:byte [] -> - timestamp:int32 -> filepath:string -> cvChunk:BinaryChunk -> idd - val pdbMagicNumber : int64 - val pdbGetEmbeddedPdbDebugInfo : - embeddedPdbChunk:BinaryChunk -> - uncompressedLength:int64 -> stream:System.IO.MemoryStream -> idd - val pdbChecksumDebugInfo : - timestamp:int32 -> - checksumPdbChunk:BinaryChunk -> - algorithmName:string -> checksum:byte [] -> idd - val pdbGetPdbDebugDeterministicInfo : - deterministicPdbChunk:BinaryChunk -> idd - val pdbGetDebugInfo : - contentId:byte [] -> - timestamp:int32 -> - filepath:string -> - cvChunk:BinaryChunk -> - embeddedPdbChunk:BinaryChunk option -> - deterministicPdbChunk:BinaryChunk -> - checksumPdbChunk:BinaryChunk -> - algorithmName:string -> - checksum:byte [] -> - uncompressedLength:int64 -> - stream:System.IO.MemoryStream option -> - embeddedPdb:bool -> deterministic:bool -> idd [] - val getDebugFileName : string -> bool -> string - val sortMethods : showTimes:bool -> info:PdbData -> unit - val getRowCounts : - tableRowCounts:int [] -> System.Collections.Immutable.ImmutableArray - val generatePortablePdb : - embedAllSource:bool -> - embedSourceList:string list -> - sourceLink:string -> - checksumAlgorithm:HashAlgorithm -> - showTimes:bool -> - info:PdbData -> - pathMap:Internal.Utilities.PathMap -> - int64 * System.Reflection.Metadata.BlobContentId * - System.IO.MemoryStream * string * byte [] - val compressPortablePdbStream : - uncompressedLength:int64 -> - contentId:System.Reflection.Metadata.BlobContentId -> - stream:System.IO.MemoryStream -> - int64 * System.Reflection.Metadata.BlobContentId * - System.IO.MemoryStream - val writePortablePdbInfo : - contentId:System.Reflection.Metadata.BlobContentId -> - stream:System.IO.MemoryStream -> - showTimes:bool -> - fpdb:string -> - pathMap:Internal.Utilities.PathMap -> - cvChunk:BinaryChunk -> - deterministicPdbChunk:BinaryChunk -> - checksumPdbChunk:BinaryChunk -> - algorithmName:string -> - checksum:byte [] -> - embeddedPdb:bool -> deterministic:bool -> idd [] - val embedPortablePdbInfo : - uncompressedLength:int64 -> - contentId:System.Reflection.Metadata.BlobContentId -> - stream:System.IO.MemoryStream -> - showTimes:bool -> - fpdb:string -> - cvChunk:BinaryChunk -> - pdbChunk:BinaryChunk -> - deterministicPdbChunk:BinaryChunk -> - checksumPdbChunk:BinaryChunk -> - algorithmName:string -> - checksum:byte [] -> - embeddedPdb:bool -> deterministic:bool -> idd [] - val ( ? ) : this:'a -> memb:string -> args:'Args -> 'R - val monoCompilerSvc : System.Reflection.AssemblyName - val ctor : - asmName:System.Reflection.AssemblyName -> - clsName:string -> args:obj [] -> obj - val createSourceMethodImpl : - name:string -> token:int -> namespaceID:int -> obj - val createWriter : f:string -> obj - val writeMdbInfo : string -> string -> PdbData -> 'a - val logDebugInfo : string -> PdbData -> unit - end - -namespace FSharp.Compiler.AbstractIL - module internal ILBinaryWriter = begin - val showEntryLookups : bool - val b0 : n:int -> byte - val b1 : n:int -> byte - val b2 : n:int -> byte - val b3 : n:int -> byte - val dw7 : n:int64 -> byte - val dw6 : n:int64 -> byte - val dw5 : n:int64 -> byte - val dw4 : n:int64 -> byte - val dw3 : n:int64 -> byte - val dw2 : n:int64 -> byte - val dw1 : n:int64 -> byte - val dw0 : n:int64 -> byte - val bitsOfSingle : x:float32 -> int - val bitsOfDouble : x:float -> int64 - val emitBytesViaBuffer : f:(Internal.ByteBuffer -> unit) -> byte [] - val align : alignment:int -> n:int -> int - type ByteBuffer with - static member Z32Size : n:int -> int - type ByteBuffer with - member EmitZ32 : n:int -> unit - type ByteBuffer with - member EmitPadding : n:int -> unit - type ByteBuffer with - member EmitZUntaggedIndex : big:bool -> idx:int32 -> unit - type ByteBuffer with - member - EmitZTaggedIndex : tag:int32 -> - nbits:int32 -> big:bool -> idx:int32 -> unit - val getUncodedToken : - tab:Internal.BinaryConstants.TableName -> idx:int -> int - val markerForUnicodeBytes : b:byte [] -> int - val checkFixup32 : data:byte [] -> offset:int -> exp:int -> unit - val applyFixup32 : data:byte [] -> offset:int -> v:int -> unit - module RowElementTags = begin - [] - val UShort : int = 0 - [] - val ULong : int = 1 - [] - val Data : int = 2 - [] - val DataResources : int = 3 - [] - val Guid : int = 4 - [] - val Blob : int = 5 - [] - val String : int = 6 - [] - val SimpleIndexMin : int = 7 - val SimpleIndex : t:Internal.BinaryConstants.TableName -> int - [] - val SimpleIndexMax : int = 119 - [] - val TypeDefOrRefOrSpecMin : int = 120 - val TypeDefOrRefOrSpec : t:Internal.BinaryConstants.TypeDefOrRefTag -> int - [] - val TypeDefOrRefOrSpecMax : int = 122 - [] - val TypeOrMethodDefMin : int = 123 - val TypeOrMethodDef : t:Internal.BinaryConstants.TypeOrMethodDefTag -> int - [] - val TypeOrMethodDefMax : int = 124 - [] - val HasConstantMin : int = 125 - val HasConstant : t:Internal.BinaryConstants.HasConstantTag -> int - [] - val HasConstantMax : int = 127 - [] - val HasCustomAttributeMin : int = 128 - val HasCustomAttribute : - t:Internal.BinaryConstants.HasCustomAttributeTag -> int - [] - val HasCustomAttributeMax : int = 149 - [] - val HasFieldMarshalMin : int = 150 - val HasFieldMarshal : t:Internal.BinaryConstants.HasFieldMarshalTag -> int - [] - val HasFieldMarshalMax : int = 151 - [] - val HasDeclSecurityMin : int = 152 - val HasDeclSecurity : t:Internal.BinaryConstants.HasDeclSecurityTag -> int - [] - val HasDeclSecurityMax : int = 154 - [] - val MemberRefParentMin : int = 155 - val MemberRefParent : t:Internal.BinaryConstants.MemberRefParentTag -> int - [] - val MemberRefParentMax : int = 159 - [] - val HasSemanticsMin : int = 160 - val HasSemantics : t:Internal.BinaryConstants.HasSemanticsTag -> int - [] - val HasSemanticsMax : int = 161 - [] - val MethodDefOrRefMin : int = 162 - val MethodDefOrRef : t:Internal.BinaryConstants.MethodDefOrRefTag -> int - [] - val MethodDefOrRefMax : int = 164 - [] - val MemberForwardedMin : int = 165 - val MemberForwarded : t:Internal.BinaryConstants.MemberForwardedTag -> int - [] - val MemberForwardedMax : int = 166 - [] - val ImplementationMin : int = 167 - val Implementation : t:Internal.BinaryConstants.ImplementationTag -> int - [] - val ImplementationMax : int = 169 - [] - val CustomAttributeTypeMin : int = 170 - val CustomAttributeType : - t:Internal.BinaryConstants.CustomAttributeTypeTag -> int - [] - val CustomAttributeTypeMax : int = 173 - [] - val ResolutionScopeMin : int = 174 - val ResolutionScope : t:Internal.BinaryConstants.ResolutionScopeTag -> int - [] - val ResolutionScopeMax : int = 178 - end - [] - type RowElement = - struct - new : tag:int32 * idx:int32 -> RowElement - member Tag : int32 - member Val : int32 - end - val UShort : x:uint16 -> RowElement - val ULong : x:int32 -> RowElement - val Data : x:int * k:bool -> RowElement - val Guid : x:int -> RowElement - val Blob : x:int -> RowElement - val StringE : x:int -> RowElement - val SimpleIndex : t:Internal.BinaryConstants.TableName * x:int -> RowElement - val TypeDefOrRefOrSpec : - t:Internal.BinaryConstants.TypeDefOrRefTag * x:int -> RowElement - val TypeOrMethodDef : - t:Internal.BinaryConstants.TypeOrMethodDefTag * x:int -> RowElement - val HasConstant : - t:Internal.BinaryConstants.HasConstantTag * x:int -> RowElement - val HasCustomAttribute : - t:Internal.BinaryConstants.HasCustomAttributeTag * x:int -> RowElement - val HasFieldMarshal : - t:Internal.BinaryConstants.HasFieldMarshalTag * x:int -> RowElement - val HasDeclSecurity : - t:Internal.BinaryConstants.HasDeclSecurityTag * x:int -> RowElement - val MemberRefParent : - t:Internal.BinaryConstants.MemberRefParentTag * x:int -> RowElement - val HasSemantics : - t:Internal.BinaryConstants.HasSemanticsTag * x:int -> RowElement - val MethodDefOrRef : - t:Internal.BinaryConstants.MethodDefOrRefTag * x:int -> RowElement - val MemberForwarded : - t:Internal.BinaryConstants.MemberForwardedTag * x:int -> RowElement - val Implementation : - t:Internal.BinaryConstants.ImplementationTag * x:int -> RowElement - val CustomAttributeType : - t:Internal.BinaryConstants.CustomAttributeTypeTag * x:int -> RowElement - val ResolutionScope : - t:Internal.BinaryConstants.ResolutionScopeTag * x:int -> RowElement - type BlobIndex = int - type StringIndex = int - val BlobIndex : x:BlobIndex -> int - val StringIndex : x:StringIndex -> int - val inline combineHash : x2:int -> acc:int -> int - val hashRow : elems:RowElement [] -> int - val equalRows : elems:RowElement [] -> elems2:RowElement [] -> bool - type GenericRow = RowElement [] - [] - type SharedRow = - struct - new : elems:RowElement [] * hashCode:int -> SharedRow - override Equals : obj:obj -> bool - override GetHashCode : unit -> int - member GenericRow : RowElement [] - end - val SharedRow : elems:RowElement [] -> SharedRow - val AssemblyRefRow : - s1:uint16 * s2:uint16 * s3:uint16 * s4:uint16 * l1:int32 * b1:int * - nameIdx:int * str2:int * b2:int -> SharedRow - val MemberRefRow : - mrp:RowElement * nmIdx:StringIndex * blobIdx:BlobIndex -> SharedRow - [] - type UnsharedRow = - struct - new : elems:RowElement [] -> UnsharedRow - override Equals : obj:obj -> bool - override GetHashCode : unit -> int - member GenericRow : RowElement [] - end - type ILTypeWriterEnv = - { EnclosingTyparCount: int } - val envForTypeDef : td:IL.ILTypeDef -> ILTypeWriterEnv - val envForMethodRef : env:ILTypeWriterEnv -> ty:IL.ILType -> ILTypeWriterEnv - val envForNonGenericMethodRef : _mref:'a -> ILTypeWriterEnv - val envForFieldSpec : fspec:IL.ILFieldSpec -> ILTypeWriterEnv - val envForOverrideSpec : ospec:IL.ILOverridesSpec -> ILTypeWriterEnv - [] - type MetadataTable<'T> = - { name: string - dict: System.Collections.Generic.Dictionary<'T,int> - mutable lookups: int - mutable rows: ResizeArray<'T> } - with - static member - New : nm:string * - hashEq:System.Collections.Generic.IEqualityComparer<'a> -> - MetadataTable<'a> - member AddSharedEntry : x:'T -> int - member - AddUniqueEntry : nm:string -> getter:('T -> string) -> x:'T -> int - member AddUnsharedEntry : x:'T -> int - member FindOrAddSharedEntry : x:'T -> int - member GetTableEntry : x:'T -> int - member SetRowsOfTable : t:'T [] -> unit - member Count : int - member Entries : 'T list - member EntriesAsArray : 'T [] - end - type MethodDefKey = - class - new : ilg:IL.ILGlobals * tidx:int * garity:int * nm:string * - rty:IL.ILType * argtys:IL.ILTypes * isStatic:bool -> MethodDefKey - override Equals : obj:obj -> bool - override GetHashCode : unit -> int - member ArgTypes : IL.ILTypes - member GenericArity : int - member IsStatic : bool - member Name : string - member ReturnType : IL.ILType - member TypeIdx : int - end - type FieldDefKey = - class - new : tidx:int * nm:string * ty:IL.ILType -> FieldDefKey - override Equals : obj:obj -> bool - override GetHashCode : unit -> int - member Name : string - member Type : IL.ILType - member TypeIdx : int - end - type PropertyTableKey = | PropKey of int * string * IL.ILType * IL.ILTypes - type EventTableKey = | EventKey of int * string - type TypeDefTableKey = | TdKey of string list * string - [] - type MetadataTable = - | Shared of MetadataTable - | Unshared of MetadataTable - with - member AddSharedEntry : x:SharedRow -> int - member AddUnsharedEntry : x:UnsharedRow -> int - member FindOrAddSharedEntry : x:SharedRow -> int - member SetRowsOfSharedTable : rows:RowElement [] [] -> unit - member Count : int - member GenericRowsOfTable : RowElement [] [] - end - [] - type cenv = - { ilg: IL.ILGlobals - emitTailcalls: bool - deterministic: bool - showTimes: bool - desiredMetadataVersion: IL.ILVersionInfo - requiredDataFixups: (int32 * (int * bool)) list ref - mutable requiredStringFixups: (int32 * (int * int) list) list - codeChunks: Internal.ByteBuffer - mutable nextCodeAddr: int32 - mutable moduleGuid: byte [] - generatePdb: bool - pdbinfo: ResizeArray - documents: MetadataTable - data: Internal.ByteBuffer - resources: Internal.ByteBuffer - mutable entrypoint: (bool * int) option - trefCache: System.Collections.Generic.Dictionary - tables: MetadataTable [] - AssemblyRefs: MetadataTable - fieldDefs: MetadataTable - methodDefIdxsByKey: MetadataTable - methodDefIdxs: System.Collections.Generic.Dictionary - propertyDefs: MetadataTable - eventDefs: MetadataTable - typeDefs: MetadataTable - guids: MetadataTable - blobs: MetadataTable - strings: MetadataTable - userStrings: MetadataTable - normalizeAssemblyRefs: IL.ILAssemblyRef -> IL.ILAssemblyRef } - with - member AddCode : (int32 * (int * int) list) * code:byte [] -> unit - member GetCode : unit -> byte [] - member - GetTable : tab:Internal.BinaryConstants.TableName -> MetadataTable - override ToString : unit -> string - end - val FindOrAddSharedRow : - cenv:cenv -> tbl:Internal.BinaryConstants.TableName -> x:SharedRow -> int - val AddSharedRow : - cenv:cenv -> tbl:Internal.BinaryConstants.TableName -> x:SharedRow -> int - val AddUnsharedRow : - cenv:cenv -> - tbl:Internal.BinaryConstants.TableName -> x:UnsharedRow -> int - val metadataSchemaVersionSupportedByCLRVersion : - v:IL.ILVersionInfo -> int * int - val headerVersionSupportedByCLRVersion : v:IL.ILVersionInfo -> int * int - val peOptionalHeaderByteByCLRVersion : v:IL.ILVersionInfo -> int - [] - type ILTokenMappings = - { TypeDefTokenMap: IL.ILTypeDef list * IL.ILTypeDef -> int32 - FieldDefTokenMap: - IL.ILTypeDef list * IL.ILTypeDef -> IL.ILFieldDef -> int32 - MethodDefTokenMap: - IL.ILTypeDef list * IL.ILTypeDef -> IL.ILMethodDef -> int32 - PropertyTokenMap: - IL.ILTypeDef list * IL.ILTypeDef -> IL.ILPropertyDef -> int32 - EventTokenMap: - IL.ILTypeDef list * IL.ILTypeDef -> IL.ILEventDef -> int32 } - val recordRequiredDataFixup : - requiredDataFixups:('a * 'b) list ref -> - buf:Internal.ByteBuffer -> pos:'a -> lab:'b -> unit - val GetUserStringHeapIdx : cenv:cenv -> s:string -> int - val GetBytesAsBlobIdx : cenv:cenv -> bytes:byte [] -> int - val GetStringHeapIdx : cenv:cenv -> s:string -> int - val GetGuidIdx : cenv:cenv -> info:byte [] -> int - val GetStringHeapIdxOption : cenv:cenv -> sopt:string option -> int - val GetTypeNameAsElemPair : cenv:cenv -> n:string -> RowElement * RowElement - val GenTypeDefPass1 : - enc:string list -> cenv:cenv -> td:IL.ILTypeDef -> unit - val GenTypeDefsPass1 : - enc:string list -> cenv:cenv -> tds:IL.ILTypeDef list -> unit - val GetIdxForTypeDef : cenv:cenv -> key:TypeDefTableKey -> int - val GetAssemblyRefAsRow : cenv:cenv -> aref:IL.ILAssemblyRef -> SharedRow - val GetAssemblyRefAsIdx : cenv:cenv -> aref:IL.ILAssemblyRef -> int - val GetModuleRefAsRow : cenv:cenv -> mref:IL.ILModuleRef -> SharedRow - val GetModuleRefAsFileRow : cenv:cenv -> mref:IL.ILModuleRef -> SharedRow - val GetModuleRefAsIdx : cenv:cenv -> mref:IL.ILModuleRef -> int - val GetModuleRefAsFileIdx : cenv:cenv -> mref:IL.ILModuleRef -> int - val isScopeRefLocal : scoref:IL.ILScopeRef -> bool - val isTypeRefLocal : tref:IL.ILTypeRef -> bool - val isTypeLocal : ty:IL.ILType -> bool - val GetScopeRefAsImplementationElem : - cenv:cenv -> - scoref:IL.ILScopeRef -> Internal.BinaryConstants.ImplementationTag * int - val GetTypeRefAsTypeRefRow : cenv:cenv -> tref:IL.ILTypeRef -> SharedRow - val GetTypeRefAsTypeRefIdx : cenv:cenv -> tref:IL.ILTypeRef -> int - val GetTypeDescAsTypeRefIdx : - cenv:cenv -> scoref:IL.ILScopeRef * enc:string list * n:string -> int - val GetResolutionScopeAsElem : - cenv:cenv -> - scoref:IL.ILScopeRef * enc:string list -> - Internal.BinaryConstants.ResolutionScopeTag * int - val emitTypeInfoAsTypeDefOrRefEncoded : - cenv:cenv -> - bb:Internal.ByteBuffer -> - scoref:IL.ILScopeRef * enc:string list * nm:string -> unit - val getTypeDefOrRefAsUncodedToken : - tag:Internal.BinaryConstants.TypeDefOrRefTag * idx:int -> int - val EmitArrayShape : bb:Internal.ByteBuffer -> IL.ILArrayShape -> unit - val hasthisToByte : hasthis:IL.ILThisConvention -> byte - val callconvToByte : ntypars:int -> IL.ILCallingConv -> byte - val EmitTypeSpec : - cenv:cenv -> - env:ILTypeWriterEnv -> - bb:Internal.ByteBuffer -> et:byte * tspec:IL.ILTypeSpec -> unit - val GetTypeAsTypeDefOrRef : - cenv:cenv -> - env:ILTypeWriterEnv -> - ty:IL.ILType -> Internal.BinaryConstants.TypeDefOrRefTag * int - val GetTypeAsBytes : - cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> byte [] - val GetTypeOfLocalAsBytes : - cenv:cenv -> env:ILTypeWriterEnv -> l:IL.ILLocal -> byte [] - val GetTypeAsBlobIdx : - cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> int - val GetTypeAsTypeSpecRow : - cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> SharedRow - val GetTypeAsTypeSpecIdx : - cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> int - val EmitType : - cenv:cenv -> - env:ILTypeWriterEnv -> bb:Internal.ByteBuffer -> ty:IL.ILType -> unit - val EmitLocalInfo : - cenv:cenv -> - env:ILTypeWriterEnv -> bb:Internal.ByteBuffer -> l:IL.ILLocal -> unit - val EmitCallsig : - cenv:cenv -> - env:ILTypeWriterEnv -> - bb:Internal.ByteBuffer -> - callconv:IL.ILCallingConv * args:IL.ILTypes * ret:IL.ILType * - varargs:IL.ILVarArgs * genarity:int -> unit - val GetCallsigAsBytes : - cenv:cenv -> - env:ILTypeWriterEnv -> - IL.ILCallingConv * IL.ILTypes * IL.ILType * IL.ILVarArgs * int -> - byte [] - val EmitTypes : - cenv:cenv -> - env:ILTypeWriterEnv -> bb:Internal.ByteBuffer -> inst:IL.ILTypes -> unit - val GetTypeAsMemberRefParent : - cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> RowElement - val GetVariantTypeAsInt32 : ty:IL.ILNativeVariant -> int32 - val GetNativeTypeAsBlobIdx : cenv:cenv -> ty:IL.ILNativeType -> int - val GetNativeTypeAsBytes : ty:IL.ILNativeType -> byte [] - val EmitNativeType : bb:Internal.ByteBuffer -> ty:IL.ILNativeType -> unit - val GetFieldInitAsBlobIdx : cenv:cenv -> x:IL.ILFieldInit -> int - val GetFieldInit : bb:Internal.ByteBuffer -> x:IL.ILFieldInit -> unit - val GetFieldInitFlags : i:IL.ILFieldInit -> RowElement - val GetMemberAccessFlags : access:IL.ILMemberAccess -> int - val GetTypeAccessFlags : access:IL.ILTypeDefAccess -> int - val GetTypeDefAsRow : - cenv:cenv -> - env:ILTypeWriterEnv -> _enc:'a -> td:IL.ILTypeDef -> UnsharedRow - val GetTypeOptionAsTypeDefOrRef : - cenv:cenv -> - env:ILTypeWriterEnv -> - tyOpt:IL.ILType option -> - Internal.BinaryConstants.TypeDefOrRefTag * int - val GetTypeDefAsPropertyMapRow : cenv:cenv -> tidx:int -> UnsharedRow - val GetTypeDefAsEventMapRow : cenv:cenv -> tidx:int -> UnsharedRow - val GetKeyForFieldDef : tidx:int -> fd:IL.ILFieldDef -> FieldDefKey - val GenFieldDefPass2 : cenv:cenv -> tidx:int -> fd:IL.ILFieldDef -> unit - val GetKeyForMethodDef : - cenv:cenv -> tidx:int -> md:IL.ILMethodDef -> MethodDefKey - val GenMethodDefPass2 : cenv:cenv -> tidx:int -> md:IL.ILMethodDef -> unit - val GetKeyForPropertyDef : - tidx:int -> x:IL.ILPropertyDef -> PropertyTableKey - val GenPropertyDefPass2 : - cenv:cenv -> tidx:int -> x:IL.ILPropertyDef -> unit - val GetTypeAsImplementsRow : - cenv:cenv -> - env:ILTypeWriterEnv -> tidx:int -> ty:IL.ILType -> UnsharedRow - val GenImplementsPass2 : - cenv:cenv -> env:ILTypeWriterEnv -> tidx:int -> ty:IL.ILType -> unit - val GetKeyForEvent : tidx:int -> x:IL.ILEventDef -> EventTableKey - val GenEventDefPass2 : cenv:cenv -> tidx:int -> x:IL.ILEventDef -> unit - val GenTypeDefPass2 : - pidx:int -> enc:string list -> cenv:cenv -> td:IL.ILTypeDef -> unit - val GenTypeDefsPass2 : - pidx:int -> enc:string list -> cenv:cenv -> tds:IL.ILTypeDef list -> unit - exception MethodDefNotFound - val FindMethodDefIdx : cenv:cenv -> mdkey:MethodDefKey -> int - val GetMethodDefIdx : cenv:cenv -> md:IL.ILMethodDef -> int - val FindFieldDefIdx : cenv:cenv -> fdkey:FieldDefKey -> int - val GetFieldDefAsFieldDefIdx : - cenv:cenv -> tidx:int -> fd:IL.ILFieldDef -> int - val GetMethodRefAsMethodDefIdx : cenv:cenv -> mref:IL.ILMethodRef -> int - val MethodRefInfoAsMemberRefRow : - cenv:cenv -> - env:ILTypeWriterEnv -> - fenv:ILTypeWriterEnv -> - nm:string * ty:IL.ILType * callconv:IL.ILCallingConv * - args:IL.ILTypes * ret:IL.ILType * varargs:IL.ILVarArgs * - genarity:int -> SharedRow - val GetMethodRefInfoAsBlobIdx : - cenv:cenv -> - env:ILTypeWriterEnv -> - IL.ILCallingConv * IL.ILTypes * IL.ILType * IL.ILVarArgs * int -> - BlobIndex - val GetMethodRefInfoAsMemberRefIdx : - cenv:cenv -> - env:ILTypeWriterEnv -> - string * IL.ILType * IL.ILCallingConv * IL.ILTypes * IL.ILType * - IL.ILVarArgs * int -> int - val GetMethodRefInfoAsMethodRefOrDef : - isAlwaysMethodDef:bool -> - cenv:cenv -> - env:ILTypeWriterEnv -> - string * IL.ILType * IL.ILCallingConv * IL.ILType list * IL.ILType * - IL.ILTypes option * int -> - Internal.BinaryConstants.MethodDefOrRefTag * int - val GetMethodSpecInfoAsMethodSpecIdx : - cenv:cenv -> - env:ILTypeWriterEnv -> - nm:string * ty:IL.ILType * cc:IL.ILCallingConv * args:IL.ILType list * - ret:IL.ILType * varargs:IL.ILTypes option * minst:IL.ILGenericArgs -> - int - val GetMethodDefOrRefAsUncodedToken : - tag:Internal.BinaryConstants.MethodDefOrRefTag * idx:int -> int - val GetMethodSpecInfoAsUncodedToken : - cenv:cenv -> - env:ILTypeWriterEnv -> - string * IL.ILType * IL.ILCallingConv * IL.ILType list * IL.ILType * - IL.ILTypes option * IL.ILGenericArgs -> int - val GetMethodSpecAsUncodedToken : - cenv:cenv -> - env:ILTypeWriterEnv -> IL.ILMethodSpec * IL.ILTypes option -> int - val GetMethodRefInfoOfMethodSpecInfo : - nm:string * ty:IL.ILType * cc:IL.ILCallingConv * args:IL.ILType list * - ret:IL.ILType * varargs:IL.ILTypes option * minst:IL.ILGenericArgs -> - string * IL.ILType * IL.ILCallingConv * IL.ILType list * IL.ILType * - IL.ILTypes option * int - val GetMethodSpecAsMethodDefOrRef : - cenv:cenv -> - env:ILTypeWriterEnv -> - mspec:IL.ILMethodSpec * varargs:IL.ILTypes option -> - Internal.BinaryConstants.MethodDefOrRefTag * int - val GetMethodSpecAsMethodDef : - cenv:cenv -> - env:ILTypeWriterEnv -> - mspec:IL.ILMethodSpec * varargs:IL.ILTypes option -> - Internal.BinaryConstants.MethodDefOrRefTag * int - val InfoOfMethodSpec : - mspec:IL.ILMethodSpec * varargs:IL.ILTypes option -> - string * IL.ILType * IL.ILCallingConv * IL.ILType list * IL.ILType * - IL.ILTypes option * IL.ILGenericArgs - val GetOverridesSpecAsMemberRefIdx : - cenv:cenv -> env:ILTypeWriterEnv -> ospec:IL.ILOverridesSpec -> int - val GetOverridesSpecAsMethodDefOrRef : - cenv:cenv -> - env:ILTypeWriterEnv -> - ospec:IL.ILOverridesSpec -> - Internal.BinaryConstants.MethodDefOrRefTag * int - val GetMethodRefAsMemberRefIdx : - cenv:cenv -> - env:ILTypeWriterEnv -> - fenv:ILTypeWriterEnv -> mref:IL.ILMethodRef -> int - val GetMethodRefAsCustomAttribType : - cenv:cenv -> - mref:IL.ILMethodRef -> - Internal.BinaryConstants.CustomAttributeTypeTag * int - val GetCustomAttrDataAsBlobIdx : cenv:cenv -> data:byte [] -> int - val GetCustomAttrRow : - cenv:cenv -> - Internal.BinaryConstants.HasCustomAttributeTag * int -> - attr:IL.ILAttribute -> UnsharedRow - val GenCustomAttrPass3Or4 : - cenv:cenv -> - Internal.BinaryConstants.HasCustomAttributeTag * int -> - attr:IL.ILAttribute -> unit - val GenCustomAttrsPass3Or4 : - cenv:cenv -> - Internal.BinaryConstants.HasCustomAttributeTag * int -> - attrs:IL.ILAttributes -> unit - val GetSecurityDeclRow : - cenv:cenv -> - Internal.BinaryConstants.HasDeclSecurityTag * int -> - IL.ILSecurityDecl -> UnsharedRow - val GenSecurityDeclPass3 : - cenv:cenv -> - Internal.BinaryConstants.HasDeclSecurityTag * int -> - attr:IL.ILSecurityDecl -> unit - val GenSecurityDeclsPass3 : - cenv:cenv -> - Internal.BinaryConstants.HasDeclSecurityTag * int -> - attrs:IL.ILSecurityDecl list -> unit - val GetFieldSpecAsMemberRefRow : - cenv:cenv -> - env:ILTypeWriterEnv -> - fenv:ILTypeWriterEnv -> fspec:IL.ILFieldSpec -> SharedRow - val GetFieldSpecAsMemberRefIdx : - cenv:cenv -> env:ILTypeWriterEnv -> fspec:IL.ILFieldSpec -> int - val EmitFieldSpecSig : - cenv:cenv -> - env:ILTypeWriterEnv -> - bb:Internal.ByteBuffer -> fspec:IL.ILFieldSpec -> unit - val GetFieldSpecSigAsBytes : - cenv:cenv -> env:ILTypeWriterEnv -> x:IL.ILFieldSpec -> byte [] - val GetFieldSpecSigAsBlobIdx : - cenv:cenv -> env:ILTypeWriterEnv -> x:IL.ILFieldSpec -> BlobIndex - val GetFieldSpecAsFieldDefOrRef : - cenv:cenv -> env:ILTypeWriterEnv -> fspec:IL.ILFieldSpec -> bool * int - val GetFieldDefOrRefAsUncodedToken : tag:bool * idx:int -> int - val GetCallsigAsBlobIdx : - cenv:cenv -> - env:ILTypeWriterEnv -> - callsig:IL.ILCallingSignature * varargs:IL.ILVarArgs -> int - val GetCallsigAsStandAloneSigRow : - cenv:cenv -> - env:ILTypeWriterEnv -> IL.ILCallingSignature * IL.ILVarArgs -> SharedRow - val GetCallsigAsStandAloneSigIdx : - cenv:cenv -> - env:ILTypeWriterEnv -> IL.ILCallingSignature * IL.ILVarArgs -> int - val EmitLocalSig : - cenv:cenv -> - env:ILTypeWriterEnv -> - bb:Internal.ByteBuffer -> locals:IL.ILLocals -> unit - val GetLocalSigAsBlobHeapIdx : - cenv:cenv -> env:ILTypeWriterEnv -> locals:IL.ILLocals -> int - val GetLocalSigAsStandAloneSigIdx : - cenv:cenv -> env:ILTypeWriterEnv -> locals:IL.ILLocals -> SharedRow - type ExceptionClauseKind = - | FinallyClause - | FaultClause - | TypeFilterClause of int32 - | FilterClause of int - type ExceptionClauseSpec = int * int * int * int * ExceptionClauseKind - type CodeBuffer = - { code: Internal.ByteBuffer - mutable reqdBrFixups: - ((int * int option) * int * IL.ILCodeLabel list) list - availBrFixups: System.Collections.Generic.Dictionary - mutable reqdStringFixupsInMethod: (int * int) list - mutable seh: ExceptionClauseSpec list - seqpoints: ResizeArray } - with - static member Create : _nm:'a -> CodeBuffer - member EmitByte : x:int -> unit - member EmitExceptionClause : seh:ExceptionClauseSpec -> unit - member EmitInt32 : x:int32 -> unit - member EmitInt64 : x:int64 -> unit - member EmitSeqPoint : cenv:cenv -> m:IL.ILSourceMarker -> unit - member EmitUInt16 : x:uint16 -> unit - member EmitUncodedToken : u:int32 -> unit - member RecordAvailBrFixup : tg:IL.ILCodeLabel -> unit - member - RecordReqdBrFixup : i:(int * int option) -> tg:IL.ILCodeLabel -> unit - member - RecordReqdBrFixups : i:(int * int option) -> - tgs:IL.ILCodeLabel list -> unit - member RecordReqdStringFixup : stringIdx:int -> unit - end - module Codebuf = begin - val binaryChop : p:('T -> int) -> arr:'T [] -> int - val applyBrFixups : - origCode:byte [] -> - origExnClauses:(int * int * int * int * ExceptionClauseKind) list -> - origReqdStringFixups:(int * 'a) list -> - origAvailBrFixups:System.Collections.Generic.Dictionary -> - origReqdBrFixups:((int * int option) * int * IL.ILCodeLabel list) list -> - origSeqPoints:ILPdbWriter.PdbSequencePoint [] -> - origScopes:ILPdbWriter.PdbMethodScope list -> - byte [] * (int * 'a) list * - (int * int * int * int * ExceptionClauseKind) list * - ILPdbWriter.PdbSequencePoint [] * - ILPdbWriter.PdbMethodScope list - type SEHTree = | Node of ExceptionClauseSpec option * SEHTree list - val encodingsForNoArgInstrs : - System.Collections.Generic.Dictionary - val encodingsOfNoArgInstr : si:IL.ILInstr -> int - val emitInstrCode : codebuf:CodeBuffer -> i:int -> unit - val emitTypeInstr : - cenv:cenv -> - codebuf:CodeBuffer -> - env:ILTypeWriterEnv -> i:int -> ty:IL.ILType -> unit - val emitMethodSpecInfoInstr : - cenv:cenv -> - codebuf:CodeBuffer -> - env:ILTypeWriterEnv -> - i:int -> - string * IL.ILType * IL.ILCallingConv * IL.ILType list * - IL.ILType * IL.ILTypes option * IL.ILGenericArgs -> unit - val emitMethodSpecInstr : - cenv:cenv -> - codebuf:CodeBuffer -> - env:ILTypeWriterEnv -> - i:int -> IL.ILMethodSpec * IL.ILTypes option -> unit - val emitFieldSpecInstr : - cenv:cenv -> - codebuf:CodeBuffer -> - env:ILTypeWriterEnv -> i:int -> fspec:IL.ILFieldSpec -> unit - val emitShortUInt16Instr : - codebuf:CodeBuffer -> i_short:int * i:int -> x:uint16 -> unit - val emitShortInt32Instr : - codebuf:CodeBuffer -> i_short:int * i:int -> x:int -> unit - val emitTailness : - cenv:cenv -> codebuf:CodeBuffer -> tl:IL.ILTailcall -> unit - val emitVolatility : codebuf:CodeBuffer -> tl:IL.ILVolatility -> unit - val emitConstrained : - cenv:cenv -> - codebuf:CodeBuffer -> env:ILTypeWriterEnv -> ty:IL.ILType -> unit - val emitAlignment : codebuf:CodeBuffer -> tl:IL.ILAlignment -> unit - val emitInstr : - cenv:cenv -> - codebuf:CodeBuffer -> env:ILTypeWriterEnv -> instr:IL.ILInstr -> unit - val mkScopeNode : - cenv:cenv -> - localSigs:byte [] [] -> - startOffset:int * endOffset:int * ls:IL.ILLocalDebugMapping list * - childScopes:ILPdbWriter.PdbMethodScope list -> - ILPdbWriter.PdbMethodScope list - val rangeInsideRange : - start_pc1:int * end_pc1:int -> start_pc2:int * end_pc2:int -> bool - val lranges_of_clause : - cl:IL.ILExceptionClause -> (IL.ILCodeLabel * IL.ILCodeLabel) list - val labelsToRange : - lab2pc:System.Collections.Generic.Dictionary -> - IL.ILCodeLabel * IL.ILCodeLabel -> int * int - val labelRangeInsideLabelRange : - lab2pc:System.Collections.Generic.Dictionary -> - IL.ILCodeLabel * IL.ILCodeLabel -> - IL.ILCodeLabel * IL.ILCodeLabel -> bool - val findRoots : - contains:('a -> 'a -> bool) -> vs:'a list -> ('a * 'a list) list - val makeSEHTree : - cenv:cenv -> - env:ILTypeWriterEnv -> - pc2pos:int [] -> - lab2pc:System.Collections.Generic.Dictionary -> - exs:IL.ILExceptionSpec list -> SEHTree list - val makeLocalsTree : - cenv:cenv -> - localSigs:byte [] [] -> - pc2pos:int [] -> - lab2pc:System.Collections.Generic.Dictionary -> - exs:IL.ILLocalDebugInfo list -> ILPdbWriter.PdbMethodScope list - val emitExceptionHandlerTree : codebuf:CodeBuffer -> SEHTree -> unit - val emitCode : - cenv:cenv -> - localSigs:byte [] [] -> - codebuf:CodeBuffer -> - env:ILTypeWriterEnv -> - code:IL.ILCode -> ILPdbWriter.PdbMethodScope list - val EmitTopCode : - cenv:cenv -> - localSigs:byte [] [] -> - env:ILTypeWriterEnv -> - nm:'a -> - code:IL.ILCode -> - (int * int) list * - (int * int * int * int * ExceptionClauseKind) list * byte [] * - ILPdbWriter.PdbSequencePoint [] * ILPdbWriter.PdbMethodScope - end - val GetFieldDefTypeAsBlobIdx : - cenv:cenv -> env:ILTypeWriterEnv -> ty:IL.ILType -> int - val GenILMethodBody : - mname:'a -> - cenv:cenv -> - env:ILTypeWriterEnv -> - il:IL.ILMethodBody -> - int * ((int * (int * int) list) * byte []) * - ILPdbWriter.PdbSequencePoint [] * ILPdbWriter.PdbMethodScope - val GetFieldDefAsFieldDefRow : - cenv:cenv -> env:ILTypeWriterEnv -> fd:IL.ILFieldDef -> UnsharedRow - val GetFieldDefSigAsBlobIdx : - cenv:cenv -> env:ILTypeWriterEnv -> fd:IL.ILFieldDef -> int - val GenFieldDefPass3 : - cenv:cenv -> env:ILTypeWriterEnv -> fd:IL.ILFieldDef -> unit - val GetGenericParamAsGenericParamRow : - cenv:cenv -> - _env:'a -> - idx:int -> - Internal.BinaryConstants.TypeOrMethodDefTag * int -> - gp:IL.ILGenericParameterDef -> SharedRow - val GenTypeAsGenericParamConstraintRow : - cenv:cenv -> - env:ILTypeWriterEnv -> gpidx:int -> ty:IL.ILType -> UnsharedRow - val GenGenericParamConstraintPass4 : - cenv:cenv -> env:ILTypeWriterEnv -> gpidx:int -> ty:IL.ILType -> unit - val GenGenericParamPass3 : - cenv:cenv -> - env:'a -> - idx:int -> - Internal.BinaryConstants.TypeOrMethodDefTag * int -> - gp:IL.ILGenericParameterDef -> unit - val GenGenericParamPass4 : - cenv:cenv -> - env:ILTypeWriterEnv -> - idx:int -> - Internal.BinaryConstants.TypeOrMethodDefTag * int -> - gp:IL.ILGenericParameterDef -> unit - val GetParamAsParamRow : - cenv:cenv -> _env:'a -> seq:int -> param:IL.ILParameter -> UnsharedRow - val GenParamPass3 : - cenv:cenv -> env:'a -> seq:int -> param:IL.ILParameter -> unit - val GenReturnAsParamRow : returnv:IL.ILReturn -> UnsharedRow - val GenReturnPass3 : cenv:cenv -> returnv:IL.ILReturn -> unit - val GetMethodDefSigAsBytes : - cenv:cenv -> env:ILTypeWriterEnv -> mdef:IL.ILMethodDef -> byte [] - val GenMethodDefSigAsBlobIdx : - cenv:cenv -> env:ILTypeWriterEnv -> mdef:IL.ILMethodDef -> int - val GenMethodDefAsRow : - cenv:cenv -> - env:ILTypeWriterEnv -> midx:int -> md:IL.ILMethodDef -> UnsharedRow - val GenMethodImplPass3 : - cenv:cenv -> - env:ILTypeWriterEnv -> - _tgparams:'a -> tidx:int -> mimpl:IL.ILMethodImplDef -> unit - val GenMethodDefPass3 : - cenv:cenv -> env:ILTypeWriterEnv -> md:IL.ILMethodDef -> unit - val GenMethodDefPass4 : - cenv:cenv -> env:ILTypeWriterEnv -> md:IL.ILMethodDef -> unit - val GenPropertyMethodSemanticsPass3 : - cenv:cenv -> pidx:int -> kind:int -> mref:IL.ILMethodRef -> unit - val GetPropertySigAsBlobIdx : - cenv:cenv -> env:ILTypeWriterEnv -> prop:IL.ILPropertyDef -> int - val GetPropertySigAsBytes : - cenv:cenv -> env:ILTypeWriterEnv -> prop:IL.ILPropertyDef -> byte [] - val GetPropertyAsPropertyRow : - cenv:cenv -> env:ILTypeWriterEnv -> prop:IL.ILPropertyDef -> UnsharedRow - val GenPropertyPass3 : - cenv:cenv -> env:ILTypeWriterEnv -> prop:IL.ILPropertyDef -> unit - val GenEventMethodSemanticsPass3 : - cenv:cenv -> eidx:int -> kind:int -> mref:IL.ILMethodRef -> unit - val GenEventAsEventRow : - cenv:cenv -> env:ILTypeWriterEnv -> md:IL.ILEventDef -> UnsharedRow - val GenEventPass3 : - cenv:cenv -> env:ILTypeWriterEnv -> md:IL.ILEventDef -> unit - val GetResourceAsManifestResourceRow : - cenv:cenv -> r:IL.ILResource -> UnsharedRow - val GenResourcePass3 : cenv:cenv -> r:IL.ILResource -> unit - val GenTypeDefPass3 : - enc:string list -> cenv:cenv -> td:IL.ILTypeDef -> unit - val GenTypeDefsPass3 : - enc:string list -> cenv:cenv -> tds:IL.ILTypeDef list -> unit - val GenTypeDefPass4 : - enc:string list -> cenv:cenv -> td:IL.ILTypeDef -> unit - val GenTypeDefsPass4 : - enc:string list -> cenv:cenv -> tds:IL.ILTypeDef list -> unit - val timestamp : int32 - val GenNestedExportedTypePass3 : - cenv:cenv -> cidx:int -> ce:IL.ILNestedExportedType -> unit - val GenNestedExportedTypesPass3 : - cenv:cenv -> nidx:int -> nce:IL.ILNestedExportedTypes -> unit - val GenExportedTypePass3 : - cenv:cenv -> ce:IL.ILExportedTypeOrForwarder -> unit - val GenExportedTypesPass3 : - cenv:cenv -> ce:IL.ILExportedTypesAndForwarders -> unit - val GetManifestAsAssemblyRow : - cenv:cenv -> m:IL.ILAssemblyManifest -> UnsharedRow - val GenManifestPass3 : cenv:cenv -> m:IL.ILAssemblyManifest -> unit - val newGuid : modul:IL.ILModuleDef -> byte [] - val deterministicGuid : modul:IL.ILModuleDef -> byte [] - val GetModuleAsRow : cenv:cenv -> modul:IL.ILModuleDef -> UnsharedRow - val rowElemCompare : e1:RowElement -> e2:RowElement -> int - val TableRequiresSorting : tab:Internal.BinaryConstants.TableName -> bool - val SortTableRows : - tab:Internal.BinaryConstants.TableName -> - rows:GenericRow [] -> GenericRow [] - val GenModule : cenv:cenv -> modul:IL.ILModuleDef -> unit - val generateIL : - requiredDataFixups:(int32 * (int * bool)) list ref -> - desiredMetadataVersion:IL.ILVersionInfo * generatePdb:bool * - ilg:IL.ILGlobals * emitTailcalls:bool * deterministic:bool * - showTimes:bool -> - m:IL.ILModuleDef -> - cilStartAddress:int32 -> - normalizeAssemblyRefs:(IL.ILAssemblyRef -> IL.ILAssemblyRef) -> - byte [] [] * byte [] [] * byte [] [] * byte [] [] * - MetadataTable [] * int * byte [] * - (int32 * (int * int) list) list * byte [] * byte [] * - ILPdbWriter.PdbData * ILTokenMappings - val chunk : sz:int32 -> next:int32 -> ILPdbWriter.BinaryChunk * int32 - val emptychunk : next:int32 -> ILPdbWriter.BinaryChunk * int32 - val nochunk : next:'a -> ILPdbWriter.BinaryChunk * 'a - val count : f:('a -> int) -> arr:'a [] -> int - module FileSystemUtilities = begin - val progress : bool - val setExecutablePermission : filename:string -> unit - end - val writeILMetadataAndCode : - generatePdb:bool * desiredMetadataVersion:IL.ILVersionInfo * - ilg:IL.ILGlobals * emitTailcalls:bool * deterministic:bool * - showTimes:bool -> - modul:IL.ILModuleDef -> - cilStartAddress:int32 -> - normalizeAssemblyRefs:(IL.ILAssemblyRef -> IL.ILAssemblyRef) -> - int * byte [] * byte [] * byte [] * byte [] * byte [] * - (int32 * (int * bool)) list * ILPdbWriter.PdbData * - ILTokenMappings * int - val msdosHeader : byte [] - val writeInt64 : os:System.IO.BinaryWriter -> x:int64 -> unit - val writeInt32 : os:System.IO.BinaryWriter -> x:int -> unit - val writeInt32AsUInt16 : os:System.IO.BinaryWriter -> x:int -> unit - val writeDirectory : - os:System.IO.BinaryWriter -> dict:ILPdbWriter.BinaryChunk -> unit - val writeBytes : os:System.IO.BinaryWriter -> chunk:byte [] -> unit - val writeBinaryAndReportMappings : - outfile:string * ilg:IL.ILGlobals * pdbfile:string option * - signer:Internal.StrongNameSign.ILStrongNameSigner option * - portablePDB:bool * embeddedPDB:bool * embedAllSource:bool * - embedSourceList:string list * sourceLink:string * - checksumAlgorithm:ILPdbWriter.HashAlgorithm * emitTailcalls:bool * - deterministic:bool * showTimes:bool * dumpDebugInfo:bool * - pathMap:Internal.Utilities.PathMap -> - modul:IL.ILModuleDef -> - normalizeAssemblyRefs:(IL.ILAssemblyRef -> IL.ILAssemblyRef) -> - ILTokenMappings - type options = - { ilg: IL.ILGlobals - pdbfile: string option - portablePDB: bool - embeddedPDB: bool - embedAllSource: bool - embedSourceList: string list - sourceLink: string - checksumAlgorithm: ILPdbWriter.HashAlgorithm - signer: Internal.StrongNameSign.ILStrongNameSigner option - emitTailcalls: bool - deterministic: bool - showTimes: bool - dumpDebugInfo: bool - pathMap: Internal.Utilities.PathMap } - val WriteILBinary : - filename:string * options:options * inputModule:IL.ILModuleDef * - (IL.ILAssemblyRef -> IL.ILAssemblyRef) -> unit - end - -namespace FSharp.Compiler.AbstractIL - module internal ILRuntimeWriter = begin - val codeLabelOrder : System.Collections.Generic.IComparer - val wrapCustomAttr : - setCustomAttr:('a * 'b -> 'c) -> cinfo:'a * bytes:'b -> 'c - val logRefEmitCalls : bool - type AssemblyBuilder with - member - DefineDynamicModuleAndLog : a:string * b:'a * c:'b -> - System.Reflection.Emit.ModuleBuilder - type AssemblyBuilder with - member - SetCustomAttributeAndLog : cinfo:System.Reflection.ConstructorInfo * - bytes:byte [] -> unit - type AssemblyBuilder with - member - SetCustomAttributeAndLog : cab:System.Reflection.Emit.CustomAttributeBuilder -> - unit - type ModuleBuilder with - member - GetArrayMethodAndLog : aty:System.Type * nm:string * - flags:System.Reflection.CallingConventions * - rty:System.Type * tys:System.Type [] -> - System.Reflection.MethodInfo - type ModuleBuilder with - member - GetTypeAndLog : nameInModule:string * flag1:bool * flag2:bool -> - System.Type - type ModuleBuilder with - member - DefineTypeAndLog : name:string * attrs:System.Reflection.TypeAttributes -> - System.Reflection.Emit.TypeBuilder - type ModuleBuilder with - member - SetCustomAttributeAndLog : cinfo:System.Reflection.ConstructorInfo * - bytes:byte [] -> unit - type ConstructorBuilder with - member - SetImplementationFlagsAndLog : attrs:System.Reflection.MethodImplAttributes -> - unit - type ConstructorBuilder with - member - DefineParameterAndLog : n:int * - attr:System.Reflection.ParameterAttributes * - nm:string -> - System.Reflection.Emit.ParameterBuilder - type ConstructorBuilder with - member GetILGeneratorAndLog : unit -> System.Reflection.Emit.ILGenerator - type MethodBuilder with - member - SetImplementationFlagsAndLog : attrs:System.Reflection.MethodImplAttributes -> - unit - type MethodBuilder with - member - SetSignatureAndLog : returnType:System.Type * - returnTypeRequiredCustomModifiers:System.Type [] * - returnTypeOptionalCustomModifiers:System.Type [] * - parameterTypes:System.Type [] * - parameterTypeRequiredCustomModifiers:System.Type [] [] * - parameterTypeOptionalCustomModifiers:System.Type [] [] -> - unit - type MethodBuilder with - member - DefineParameterAndLog : n:int * - attr:System.Reflection.ParameterAttributes * - nm:string -> - System.Reflection.Emit.ParameterBuilder - type MethodBuilder with - member - DefineGenericParametersAndLog : gps:string [] -> - System.Reflection.Emit.GenericTypeParameterBuilder [] - type MethodBuilder with - member GetILGeneratorAndLog : unit -> System.Reflection.Emit.ILGenerator - type MethodBuilder with - member - SetCustomAttributeAndLog : cinfo:System.Reflection.ConstructorInfo * - bytes:byte [] -> unit - type TypeBuilder with - member CreateTypeAndLog : unit -> System.Type - type TypeBuilder with - member - DefineNestedTypeAndLog : name:string * - attrs:System.Reflection.TypeAttributes -> - System.Reflection.Emit.TypeBuilder - type TypeBuilder with - member - DefineMethodAndLog : name:string * - attrs:System.Reflection.MethodAttributes * - cconv:System.Reflection.CallingConventions -> - System.Reflection.Emit.MethodBuilder - type TypeBuilder with - member - DefineGenericParametersAndLog : gps:string [] -> - System.Reflection.Emit.GenericTypeParameterBuilder [] - type TypeBuilder with - member - DefineConstructorAndLog : attrs:System.Reflection.MethodAttributes * - cconv:System.Reflection.CallingConventions * - parms:System.Type [] -> - System.Reflection.Emit.ConstructorBuilder - type TypeBuilder with - member - DefineFieldAndLog : nm:string * ty:System.Type * - attrs:System.Reflection.FieldAttributes -> - System.Reflection.Emit.FieldBuilder - type TypeBuilder with - member - DefinePropertyAndLog : nm:string * - attrs:System.Reflection.PropertyAttributes * - ty:System.Type * args:System.Type [] -> - System.Reflection.Emit.PropertyBuilder - type TypeBuilder with - member - DefineEventAndLog : nm:string * attrs:System.Reflection.EventAttributes * - ty:System.Type -> - System.Reflection.Emit.EventBuilder - type TypeBuilder with - member SetParentAndLog : ty:System.Type -> unit - type TypeBuilder with - member AddInterfaceImplementationAndLog : ty:System.Type -> unit - type TypeBuilder with - member InvokeMemberAndLog : nm:string * _flags:'a * args:obj [] -> obj - type TypeBuilder with - member - SetCustomAttributeAndLog : cinfo:System.Reflection.ConstructorInfo * - bytes:byte [] -> unit - type OpCode with - member RefEmitName : string - type ILGenerator with - member - DeclareLocalAndLog : ty:System.Type * isPinned:bool -> - System.Reflection.Emit.LocalBuilder - type ILGenerator with - member MarkLabelAndLog : lab:System.Reflection.Emit.Label -> unit - type ILGenerator with - member BeginExceptionBlockAndLog : unit -> System.Reflection.Emit.Label - type ILGenerator with - member EndExceptionBlockAndLog : unit -> unit - type ILGenerator with - member BeginFinallyBlockAndLog : unit -> unit - type ILGenerator with - member BeginCatchBlockAndLog : ty:System.Type -> unit - type ILGenerator with - member BeginExceptFilterBlockAndLog : unit -> unit - type ILGenerator with - member BeginFaultBlockAndLog : unit -> unit - type ILGenerator with - member DefineLabelAndLog : unit -> System.Reflection.Emit.Label - type ILGenerator with - member EmitAndLog : op:System.Reflection.Emit.OpCode -> unit - type ILGenerator with - member - EmitAndLog : op:System.Reflection.Emit.OpCode * - v:System.Reflection.Emit.Label -> unit - type ILGenerator with - member EmitAndLog : op:System.Reflection.Emit.OpCode * v:int16 -> unit - type ILGenerator with - member EmitAndLog : op:System.Reflection.Emit.OpCode * v:int32 -> unit - type ILGenerator with - member - EmitAndLog : op:System.Reflection.Emit.OpCode * - v:System.Reflection.MethodInfo -> unit - type ILGenerator with - member EmitAndLog : op:System.Reflection.Emit.OpCode * v:string -> unit - type ILGenerator with - member - EmitAndLog : op:System.Reflection.Emit.OpCode * v:System.Type -> unit - type ILGenerator with - member - EmitAndLog : op:System.Reflection.Emit.OpCode * - v:System.Reflection.FieldInfo -> unit - type ILGenerator with - member - EmitAndLog : op:System.Reflection.Emit.OpCode * - v:System.Reflection.ConstructorInfo -> unit - val inline flagsIf : b:bool -> x: ^a -> ^a when ^a : enum - module Zmap = begin - val force : x:'a -> m:Internal.Zmap<'a,'b> -> str:string -> 'b - end - val equalTypes : s:System.Type -> t:System.Type -> bool - val equalTypeLists : ss:#System.Type list -> tt:#System.Type list -> bool - val equalTypeArrays : ss:#System.Type [] -> tt:#System.Type [] -> bool - val getGenericArgumentsOfType : typT:System.Type -> System.Type [] - val getGenericArgumentsOfMethod : - methI:System.Reflection.MethodInfo -> System.Type [] - val getTypeConstructor : ty:System.Type -> System.Type - val convAssemblyRef : - aref:IL.ILAssemblyRef -> System.Reflection.AssemblyName - type cenv = - { ilg: IL.ILGlobals - tryFindSysILTypeRef: string -> IL.ILTypeRef option - generatePdb: bool - resolveAssemblyRef: - IL.ILAssemblyRef -> Choice option } - with - override ToString : unit -> string - end - val convResolveAssemblyRef : - cenv:cenv -> - asmref:IL.ILAssemblyRef -> qualifiedName:string -> System.Type - val convTypeRefAux : cenv:cenv -> tref:IL.ILTypeRef -> System.Type - type emEnv = - { emTypMap: - Internal.Zmap - emConsMap: - Internal.Zmap - emMethMap: - Internal.Zmap - emFieldMap: - Internal.Zmap - emPropMap: - Internal.Zmap - emLocals: System.Reflection.Emit.LocalBuilder [] - emLabels: Internal.Zmap - emTyvars: System.Type [] list - emEntryPts: (System.Reflection.Emit.TypeBuilder * string) list - delayedFieldInits: (unit -> unit) list } - val orderILTypeRef : System.Collections.Generic.IComparer - val orderILMethodRef : System.Collections.Generic.IComparer - val orderILFieldRef : System.Collections.Generic.IComparer - val orderILPropertyRef : - System.Collections.Generic.IComparer - val emEnv0 : emEnv - val envBindTypeRef : - emEnv:emEnv -> - tref:IL.ILTypeRef -> - typT:System.Type * typB:System.Reflection.Emit.TypeBuilder * - typeDef:IL.ILTypeDef -> emEnv - val envUpdateCreatedTypeRef : emEnv:emEnv -> tref:IL.ILTypeRef -> emEnv - val convTypeRef : - cenv:cenv -> - emEnv:emEnv -> preferCreated:bool -> tref:IL.ILTypeRef -> System.Type - val envBindConsRef : - emEnv:emEnv -> - mref:IL.ILMethodRef -> - consB:System.Reflection.Emit.ConstructorBuilder -> emEnv - val envGetConsB : - emEnv:emEnv -> - mref:IL.ILMethodRef -> System.Reflection.Emit.ConstructorBuilder - val envBindMethodRef : - emEnv:emEnv -> - mref:IL.ILMethodRef -> - methB:System.Reflection.Emit.MethodBuilder -> emEnv - val envGetMethB : - emEnv:emEnv -> mref:IL.ILMethodRef -> System.Reflection.Emit.MethodBuilder - val envBindFieldRef : - emEnv:emEnv -> - fref:IL.ILFieldRef -> - fieldB:System.Reflection.Emit.FieldBuilder -> emEnv - val envGetFieldB : - emEnv:emEnv -> fref:IL.ILFieldRef -> System.Reflection.Emit.FieldBuilder - val envBindPropRef : - emEnv:emEnv -> - pref:IL.ILPropertyRef -> - propB:System.Reflection.Emit.PropertyBuilder -> emEnv - val envGetPropB : - emEnv:emEnv -> - pref:IL.ILPropertyRef -> System.Reflection.Emit.PropertyBuilder - val envGetTypB : - emEnv:emEnv -> tref:IL.ILTypeRef -> System.Reflection.Emit.TypeBuilder - val envGetTypeDef : emEnv:emEnv -> tref:IL.ILTypeRef -> IL.ILTypeDef - val envSetLocals : - emEnv:emEnv -> locs:System.Reflection.Emit.LocalBuilder [] -> emEnv - val envGetLocal : - emEnv:emEnv -> i:int -> System.Reflection.Emit.LocalBuilder - val envSetLabel : - emEnv:emEnv -> - name:IL.ILCodeLabel -> lab:System.Reflection.Emit.Label -> emEnv - val envGetLabel : - emEnv:emEnv -> name:IL.ILCodeLabel -> System.Reflection.Emit.Label - val envPushTyvars : emEnv:emEnv -> tys:System.Type [] -> emEnv - val envPopTyvars : emEnv:emEnv -> emEnv - val envGetTyvar : emEnv:emEnv -> u16:uint16 -> System.Type - val isEmittedTypeRef : emEnv:emEnv -> tref:IL.ILTypeRef -> bool - val envAddEntryPt : - emEnv:emEnv -> System.Reflection.Emit.TypeBuilder * string -> emEnv - val envPopEntryPts : - emEnv:emEnv -> emEnv * (System.Reflection.Emit.TypeBuilder * string) list - val convCallConv : IL.ILCallingConv -> System.Reflection.CallingConventions - val convTypeSpec : - cenv:cenv -> - emEnv:emEnv -> preferCreated:bool -> tspec:IL.ILTypeSpec -> System.Type - val convTypeAux : - cenv:cenv -> - emEnv:emEnv -> preferCreated:bool -> ty:IL.ILType -> System.Type - val convType : cenv:cenv -> emEnv:emEnv -> ty:IL.ILType -> System.Type - val convTypeOrTypeDef : - cenv:cenv -> emEnv:emEnv -> ty:IL.ILType -> System.Type - val convTypes : - cenv:cenv -> emEnv:emEnv -> tys:IL.ILTypes -> System.Type list - val convTypesToArray : - cenv:cenv -> emEnv:emEnv -> tys:IL.ILTypes -> System.Type [] - val convCreatedType : - cenv:cenv -> emEnv:emEnv -> ty:IL.ILType -> System.Type - val convCreatedTypeRef : - cenv:cenv -> emEnv:emEnv -> ty:IL.ILTypeRef -> System.Type - val convParamModifiersOfType : - cenv:cenv -> emEnv:emEnv -> pty:IL.ILType -> (bool * System.Type) [] - val splitModifiers : mods:(bool * 'a) [] -> 'a [] * 'a [] - val convParamModifiers : - cenv:cenv -> - emEnv:emEnv -> p:IL.ILParameter -> System.Type [] * System.Type [] - val convReturnModifiers : - cenv:cenv -> - emEnv:emEnv -> p:IL.ILReturn -> System.Type [] * System.Type [] - val TypeBuilderInstantiationT : System.Type - val typeIsNotQueryable : ty:System.Type -> bool - val queryableTypeGetField : - _emEnv:'a -> - parentT:System.Type -> fref:IL.ILFieldRef -> System.Reflection.FieldInfo - val nonQueryableTypeGetField : - parentTI:System.Type -> - fieldInfo:System.Reflection.FieldInfo -> System.Reflection.FieldInfo - val convFieldSpec : - cenv:cenv -> - emEnv:emEnv -> fspec:IL.ILFieldSpec -> System.Reflection.FieldInfo - val queryableTypeGetMethodBySearch : - cenv:cenv -> - emEnv:emEnv -> - parentT:System.Type -> - mref:IL.ILMethodRef -> System.Reflection.MethodInfo - val queryableTypeGetMethod : - cenv:cenv -> - emEnv:emEnv -> - parentT:System.Type -> - mref:IL.ILMethodRef -> System.Reflection.MethodInfo - val nonQueryableTypeGetMethod : - parentTI:System.Type -> - methInfo:System.Reflection.MethodInfo -> System.Reflection.MethodInfo - val convMethodRef : - cenv:cenv -> - emEnv:emEnv -> - parentTI:System.Type -> - mref:IL.ILMethodRef -> System.Reflection.MethodInfo - val convMethodSpec : - cenv:cenv -> - emEnv:emEnv -> mspec:IL.ILMethodSpec -> System.Reflection.MethodInfo - val queryableTypeGetConstructor : - cenv:cenv -> - emEnv:emEnv -> - parentT:System.Type -> - mref:IL.ILMethodRef -> System.Reflection.ConstructorInfo - val nonQueryableTypeGetConstructor : - parentTI:System.Type -> - consInfo:System.Reflection.ConstructorInfo -> - System.Reflection.ConstructorInfo - val convConstructorSpec : - cenv:cenv -> - emEnv:emEnv -> - mspec:IL.ILMethodSpec -> System.Reflection.ConstructorInfo - val emitLabelMark : - emEnv:emEnv -> - ilG:System.Reflection.Emit.ILGenerator -> label:IL.ILCodeLabel -> unit - val emitInstrCompare : - emEnv:emEnv -> - ilG:System.Reflection.Emit.ILGenerator -> - comp:IL.ILComparisonInstr -> targ:IL.ILCodeLabel -> unit - val emitInstrVolatile : - ilG:System.Reflection.Emit.ILGenerator -> _arg1:IL.ILVolatility -> unit - val emitInstrAlign : - ilG:System.Reflection.Emit.ILGenerator -> _arg1:IL.ILAlignment -> unit - val emitInstrTail : - ilG:System.Reflection.Emit.ILGenerator -> - tail:IL.ILTailcall -> emitTheCall:(unit -> unit) -> unit - val emitInstrNewobj : - cenv:cenv -> - emEnv:emEnv -> - ilG:System.Reflection.Emit.ILGenerator -> - mspec:IL.ILMethodSpec -> varargs:'a option -> unit - val emitSilverlightCheck : ilG:System.Reflection.Emit.ILGenerator -> unit - val emitInstrCall : - cenv:cenv -> - emEnv:emEnv -> - ilG:System.Reflection.Emit.ILGenerator -> - opCall:System.Reflection.Emit.OpCode -> - tail:IL.ILTailcall -> - mspec:IL.ILMethodSpec -> varargs:IL.ILTypes option -> unit - val getGenericMethodDefinition : - q:Quotations.Expr -> ty:System.Type -> System.Reflection.MethodInfo - val getArrayMethInfo : - n:int -> ty:System.Type -> System.Reflection.MethodInfo - val setArrayMethInfo : - n:int -> ty:System.Type -> System.Reflection.MethodInfo - val emitInstr : - cenv:cenv -> - modB:System.Reflection.Emit.ModuleBuilder -> - emEnv:emEnv -> - ilG:System.Reflection.Emit.ILGenerator -> instr:IL.ILInstr -> unit - val emitCode : - cenv:cenv -> - modB:System.Reflection.Emit.ModuleBuilder -> - emEnv:emEnv -> - ilG:System.Reflection.Emit.ILGenerator -> code:IL.ILCode -> unit - val emitLocal : - cenv:cenv -> - emEnv:emEnv -> - ilG:System.Reflection.Emit.ILGenerator -> - local:IL.ILLocal -> System.Reflection.Emit.LocalBuilder - val emitILMethodBody : - cenv:cenv -> - modB:System.Reflection.Emit.ModuleBuilder -> - emEnv:emEnv -> - ilG:System.Reflection.Emit.ILGenerator -> - ilmbody:IL.ILMethodBody -> unit - val emitMethodBody : - cenv:cenv -> - modB:System.Reflection.Emit.ModuleBuilder -> - emEnv:emEnv -> - ilG:(unit -> #System.Reflection.Emit.ILGenerator) -> - _name:'b -> mbody:IL.ILLazyMethodBody -> unit - val convCustomAttr : - cenv:cenv -> - emEnv:emEnv -> - cattr:IL.ILAttribute -> System.Reflection.ConstructorInfo * byte [] - val emitCustomAttr : - cenv:cenv -> - emEnv:emEnv -> - add:(System.Reflection.ConstructorInfo * byte [] -> 'a) -> - cattr:IL.ILAttribute -> 'a - val emitCustomAttrs : - cenv:cenv -> - emEnv:emEnv -> - add:(System.Reflection.ConstructorInfo * byte [] -> unit) -> - cattrs:IL.ILAttributes -> unit - val buildGenParamsPass1 : - _emEnv:'a -> - defineGenericParameters:(string [] -> 'b) -> - gps:IL.ILGenericParameterDefs -> unit - val buildGenParamsPass1b : - cenv:cenv -> - emEnv:emEnv -> - genArgs:System.Type array -> gps:IL.ILGenericParameterDefs -> unit - val emitParameter : - cenv:cenv -> - emEnv:emEnv -> - defineParameter:(int * System.Reflection.ParameterAttributes * string -> - System.Reflection.Emit.ParameterBuilder) -> - i:int -> param:IL.ILParameter -> unit - val definePInvokeMethod : System.Reflection.MethodInfo - val enablePInvoke : bool - val buildMethodPass2 : - cenv:cenv -> - tref:IL.ILTypeRef -> - typB:System.Reflection.Emit.TypeBuilder -> - emEnv:emEnv -> mdef:IL.ILMethodDef -> emEnv - val buildMethodPass3 : - cenv:cenv -> - tref:IL.ILTypeRef -> - modB:System.Reflection.Emit.ModuleBuilder -> - typB:System.Reflection.Emit.TypeBuilder -> - emEnv:emEnv -> mdef:IL.ILMethodDef -> unit - val buildFieldPass2 : - cenv:cenv -> - tref:IL.ILTypeRef -> - typB:System.Reflection.Emit.TypeBuilder -> - emEnv:emEnv -> fdef:IL.ILFieldDef -> emEnv - val buildFieldPass3 : - cenv:cenv -> - tref:IL.ILTypeRef -> - _typB:System.Reflection.Emit.TypeBuilder -> - emEnv:emEnv -> fdef:IL.ILFieldDef -> unit - val buildPropertyPass2 : - cenv:cenv -> - tref:IL.ILTypeRef -> - typB:System.Reflection.Emit.TypeBuilder -> - emEnv:emEnv -> prop:IL.ILPropertyDef -> emEnv - val buildPropertyPass3 : - cenv:cenv -> - tref:IL.ILTypeRef -> - _typB:System.Reflection.Emit.TypeBuilder -> - emEnv:emEnv -> prop:IL.ILPropertyDef -> unit - val buildEventPass3 : - cenv:cenv -> - typB:System.Reflection.Emit.TypeBuilder -> - emEnv:emEnv -> eventDef:IL.ILEventDef -> unit - val buildMethodImplsPass3 : - cenv:cenv -> - _tref:'a -> - typB:System.Reflection.Emit.TypeBuilder -> - emEnv:emEnv -> mimpl:IL.ILMethodImplDef -> emEnv - val typeAttributesOfTypeDefKind : - x:IL.ILTypeDefKind -> System.Reflection.TypeAttributes - val typeAttributesOfTypeAccess : - x:IL.ILTypeDefAccess -> System.Reflection.TypeAttributes - val typeAttributesOfTypeEncoding : - x:IL.ILDefaultPInvokeEncoding -> System.Reflection.TypeAttributes - val typeAttributesOfTypeLayout : - cenv:cenv -> - emEnv:emEnv -> - x:IL.ILTypeDefLayout -> - (System.Reflection.ConstructorInfo * byte []) option - val buildTypeDefPass1 : - cenv:cenv -> - emEnv:emEnv -> - modB:System.Reflection.Emit.ModuleBuilder -> - rootTypeBuilder:(string * System.Reflection.TypeAttributes -> - System.Reflection.Emit.TypeBuilder) -> - nesting:IL.ILTypeDef list -> tdef:IL.ILTypeDef -> emEnv - val buildTypeTypeDef : - cenv:cenv -> - emEnv:emEnv -> - modB:System.Reflection.Emit.ModuleBuilder -> - typB:System.Reflection.Emit.TypeBuilder -> - nesting:IL.ILTypeDef list -> tdef:IL.ILTypeDef -> emEnv - val buildTypeDefPass1b : - cenv:cenv -> - nesting:IL.ILTypeDef list -> emEnv:emEnv -> tdef:IL.ILTypeDef -> unit - val buildTypeDefPass2 : - cenv:cenv -> - nesting:IL.ILTypeDef list -> emEnv:emEnv -> tdef:IL.ILTypeDef -> emEnv - val buildTypeDefPass3 : - cenv:cenv -> - nesting:IL.ILTypeDef list -> - modB:System.Reflection.Emit.ModuleBuilder -> - emEnv:emEnv -> tdef:IL.ILTypeDef -> emEnv - val getEnclosingTypeRefs : tref:IL.ILTypeRef -> IL.ILTypeRef list - [] - type CollectTypes = - | ValueTypesOnly - | All - val getTypeRefsInType : - allTypes:CollectTypes -> - ty:IL.ILType -> acc:IL.ILTypeRef list -> IL.ILTypeRef list - val verbose2 : bool - val createTypeRef : - visited:System.Collections.Generic.Dictionary * - created:System.Collections.Generic.Dictionary -> - emEnv:emEnv -> tref:IL.ILTypeRef -> unit - val buildTypeDefPass4 : - visited:System.Collections.Generic.Dictionary * - created:System.Collections.Generic.Dictionary -> - nesting:IL.ILTypeDef list -> emEnv:emEnv -> tdef:IL.ILTypeDef -> unit - val buildModuleTypePass1 : - cenv:cenv -> - modB:System.Reflection.Emit.ModuleBuilder -> - emEnv:emEnv -> tdef:IL.ILTypeDef -> emEnv - val buildModuleTypePass1b : - cenv:cenv -> emEnv:emEnv -> tdef:IL.ILTypeDef -> unit - val buildModuleTypePass2 : - cenv:cenv -> emEnv:emEnv -> tdef:IL.ILTypeDef -> emEnv - val buildModuleTypePass3 : - cenv:cenv -> - modB:System.Reflection.Emit.ModuleBuilder -> - emEnv:emEnv -> tdef:IL.ILTypeDef -> emEnv - val buildModuleTypePass4 : - System.Collections.Generic.Dictionary * - System.Collections.Generic.Dictionary -> - emEnv:emEnv -> tdef:IL.ILTypeDef -> unit - val buildModuleFragment : - cenv:cenv -> - emEnv:emEnv -> - asmB:System.Reflection.Emit.AssemblyBuilder -> - modB:System.Reflection.Emit.ModuleBuilder -> - m:IL.ILModuleDef -> emEnv - val defineDynamicAssemblyAndLog : - asmName:System.Reflection.AssemblyName * - flags:System.Reflection.Emit.AssemblyBuilderAccess * asmDir:string -> - System.Reflection.Emit.AssemblyBuilder - val mkDynamicAssemblyAndModule : - assemblyName:string * optimize:bool * debugInfo:'a * collectible:bool -> - System.Reflection.Emit.AssemblyBuilder * - System.Reflection.Emit.ModuleBuilder - val emitModuleFragment : - ilg:IL.ILGlobals * emEnv:emEnv * - asmB:System.Reflection.Emit.AssemblyBuilder * - modB:System.Reflection.Emit.ModuleBuilder * modul:IL.ILModuleDef * - debugInfo:bool * - resolveAssemblyRef:(IL.ILAssemblyRef -> - Choice option) * - tryFindSysILTypeRef:(string -> IL.ILTypeRef option) -> - emEnv * (unit -> exn option) list - val LookupTypeRef : - cenv:cenv -> emEnv:emEnv -> tref:IL.ILTypeRef -> System.Type - val LookupType : cenv:cenv -> emEnv:emEnv -> ty:IL.ILType -> System.Type - val LookupFieldRef : - emEnv:emEnv -> fref:IL.ILFieldRef -> System.Reflection.FieldInfo option - val LookupMethodRef : - emEnv:emEnv -> mref:IL.ILMethodRef -> System.Reflection.MethodInfo option - end - -namespace FSharp.Compiler - module ReferenceResolver = begin - exception internal ResolutionFailure - [] - type ResolutionEnvironment = - | EditingOrCompilation of isEditing: bool - | CompilationAndEvaluation - type ResolvedFile = - { itemSpec: string - prepareToolTip: string * string -> string - baggage: string } - with - override ToString : unit -> string - end - [] - type Resolver = - interface - abstract member HighestInstalledNetFrameworkVersion : unit -> string - abstract member - Resolve : resolutionEnvironment:ResolutionEnvironment * - references:(string * string) [] * - targetFrameworkVersion:string * - targetFrameworkDirectories:string list * - targetProcessorArchitecture:string * fsharpCoreDir:string * - explicitIncludeDirs:string list * implicitIncludeDir:string * - logMessage:(string -> unit) * - logDiagnostic:(bool -> string -> string -> unit) -> - ResolvedFile [] - abstract member DotNetFrameworkReferenceAssembliesRootDirectory : string - end - end - -namespace FSharp.Compiler - module internal SimulatedMSBuildReferenceResolver = begin - [] - val private Net45 : string = "v4.5" - [] - val private Net451 : string = "v4.5.1" - [] - val private Net452 : string = "v4.5.2" - [] - val private Net46 : string = "v4.6" - [] - val private Net461 : string = "v4.6.1" - [] - val private Net462 : string = "v4.6.2" - [] - val private Net47 : string = "v4.7" - [] - val private Net471 : string = "v4.7.1" - [] - val private Net472 : string = "v4.7.2" - [] - val private Net48 : string = "v4.8" - val SupportedDesktopFrameworkVersions : string list - val private SimulatedMSBuildResolver : ReferenceResolver.Resolver - val getResolver : unit -> ReferenceResolver.Resolver - end - -namespace Internal.Utilities - module internal FSharpEnvironment = begin - val FSharpBannerVersion : string - val FSharpProductName : string - val versionOf<'t> : string - val FSharpCoreLibRunningVersion : string option - val FSharpBinaryMetadataFormatRevision : string - val isRunningOnCoreClr : bool - module Option = begin - val ofString : s:string -> string option - end - val maxPath : int - val maxDataLength : int - val tryCurrentDomain : unit -> string option - val tryAppConfig : _appConfigKey:string -> 'a option - val BinFolderOfDefaultFSharpCompiler : - probePoint:string option -> string option - val toolingCompatibleTypeProviderProtocolMonikers : unit -> string list - val toolingCompatibleVersions : string [] - val toolPaths : string [] - val toolingCompatiblePaths : unit -> string list - val searchToolPaths : - path:string option -> compilerToolPaths:seq -> seq - val getTypeProviderAssembly : - runTimeAssemblyFileName:string * designTimeAssemblyName:string * - compilerToolPaths:string list * - raiseError:(string option -> exn -> System.Reflection.Assembly option) -> - System.Reflection.Assembly option - val getCompilerToolsDesignTimeAssemblyPaths : - compilerToolPaths:seq -> seq - end - -namespace FSharp.Compiler - module PrettyNaming = begin - [] - val parenGet : string = ".()" - [] - val parenSet : string = ".()<-" - [] - val qmark : string = "?" - [] - val qmarkSet : string = "?<-" - [] - val opNamePrefix : string = "op_" - val private opNameTable : (string * string) [] - val private opCharTranslateTable : (char * string) [] - val private opCharSet : System.Collections.Generic.HashSet - val IsOperatorOrBacktickedName : name:string -> bool - val IsOperatorName : name:string -> bool - val IsMangledOpName : n:string -> bool - val private compileCustomOpName : (string -> string) - val CompileOpName : (string -> string) - val private decompileCustomOpName : (string -> string) - val DecompileOpName : (string -> string) - val DemangleOperatorName : nm:string -> string - val DemangleOperatorNameAsLayout : - nonOpTagged:(string -> #Internal.Utilities.StructuredFormat.TaggedText) -> - nm:string -> Internal.Utilities.StructuredFormat.Layout - val opNameCons : string - val opNameNil : string - val opNameEquals : string - val opNameEqualsNullable : string - val opNameNullableEquals : string - val opNameNullableEqualsNullable : string - val IsIdentifierFirstCharacter : c:char -> bool - val IsIdentifierPartCharacter : c:char -> bool - val IsLongIdentifierPartCharacter : c:char -> bool - val isTildeOnlyString : s:string -> bool - val IsValidPrefixOperatorUse : s:string -> bool - val IsValidPrefixOperatorDefinitionName : s:string -> bool - val IsPrefixOperator : s:string -> bool - val IsPunctuation : s:string -> bool - val IsTernaryOperator : s:string -> bool - val IsInfixOperator : (string -> bool) - val ( |Control|Equality|Relational|Indexer|FixedTypes|Other| ) : - opName:string -> Choice - [] - val private compilerGeneratedMarker : string = "@" - [] - val private compilerGeneratedMarkerChar : char = '@' - val IsCompilerGeneratedName : nm:string -> bool - val CompilerGeneratedName : nm:string -> string - val GetBasicNameOfPossibleCompilerGeneratedName : name:string -> string - val CompilerGeneratedNameSuffix : - basicName:string -> suffix:string -> string - [] - val private mangledGenericTypeNameSym : char = '`' - val TryDemangleGenericNameAndPos : n:string -> int voption - type NameArityPair = | NameArityPair of string * int - val DemangleGenericTypeNameWithPos : pos:int -> mangledName:string -> string - val DecodeGenericTypeNameWithPos : - pos:int -> mangledName:string -> NameArityPair - val DemangleGenericTypeName : mangledName:string -> string - val DecodeGenericTypeName : mangledName:string -> NameArityPair - val private chopStringTo : s:string -> c:char -> string - val TryChopPropertyName : s:string -> string option - val ChopPropertyName : s:string -> string - val SplitNamesForILPath : s:string -> string list - val inline private isNotQuotedQuotation : text:string -> n:int -> bool - val private splitAroundQuotation : - text:string -> separator:char -> string [] - val private splitAroundQuotationWithCount : - text:string -> separator:char -> count:int -> string [] - [] - val FSharpModuleSuffix : string = "Module" - [] - val MangledGlobalName : string = "`global`" - val IllegalCharactersInTypeAndNamespaceNames : char [] - val IsActivePatternName : name:string -> bool - type ActivePatternInfo = - | APInfo of bool * (string * Range.range) list * Range.range - with - member ActiveTags : string list - member ActiveTagsWithRanges : (string * Range.range) list - member IsTotal : bool - member Range : Range.range - end - val ActivePatternInfoOfValName : - nm:string -> m:Range.range -> ActivePatternInfo option - val private mangleStaticStringArg : nm:string * v:string -> string - val private tryDemangleStaticStringArg : - mangledText:string -> (string * string) option - exception InvalidMangledStaticArg of string - val demangleProvidedTypeName : - typeLogicalName:string -> string * (string * string) [] - val mangleProvidedTypeName : - typeLogicalName:string * nonDefaultArgs:(string * string) [] -> string - val computeMangledNameWithoutDefaultArgValues : - nm:string * staticArgs:'a [] * - defaultArgValues:(string * string option) [] -> string - val outArgCompilerGeneratedName : string - val ExtraWitnessMethodName : nm:string -> string - val mkUnionCaseFieldName : (int -> int -> string) - val mkExceptionFieldName : (int -> string) - val FsiDynamicModulePrefix : string - module FSharpLib = begin - val Root : string - val RootPath : string list - val Core : string - val CorePath : string list - end - module CustomOperations = begin - [] - val Into : string = "into" - end - val unassignedTyparName : string - val FSharpOptimizationDataResourceName : string - val FSharpSignatureDataResourceName : string - val FSharpOptimizationDataResourceName2 : string - val FSharpSignatureDataResourceName2 : string - end - -namespace FSharp.Compiler.AbstractIL.Extensions.ILX - module internal IlxSettings = begin - type IlxCallImplementation = | VirtEntriesVirtCode - val mutable ilxCompilingFSharpCoreLib : bool - val mutable ilxFsharpCoreLibAssemRef : IL.ILAssemblyRef option - val ilxFsharpCoreLibScopeRef : unit -> IL.ILScopeRef - val ilxNamespace : unit -> string - end - -namespace FSharp.Compiler.AbstractIL.Extensions.ILX - module internal EraseClosures = begin - val notlazy : v:'a -> System.Lazy<'a> - val stripUpTo : - n:int -> test:('a -> bool) -> dest:('a -> 'b * 'a) -> x:'a -> 'b list * 'a - val destTyLambda : - _arg1:Types.IlxClosureLambdas -> - IL.ILGenericParameterDef * Types.IlxClosureLambdas - val isTyLambda : _arg1:Types.IlxClosureLambdas -> bool - val isTyApp : _arg1:Types.IlxClosureApps -> bool - val stripTyLambdasUpTo : - n:int -> - lambdas:Types.IlxClosureLambdas -> - IL.ILGenericParameterDef list * Types.IlxClosureLambdas - val stripSupportedIndirectCall : - apps:Types.IlxClosureApps -> - IL.ILType list * IL.ILType list * Types.IlxClosureApps - val stripSupportedAbstraction : - lambdas:Types.IlxClosureLambdas -> - IL.ILGenericParameterDef list * IL.ILParameter list * - Types.IlxClosureLambdas - val isSupportedDirectCall : apps:Types.IlxClosureApps -> bool - val mkFuncTypeRef : n:int -> IL.ILTypeRef - type cenv = - { ilg: IL.ILGlobals - tref_Func: IL.ILTypeRef [] - mkILTyFuncTy: IL.ILType - addFieldGeneratedAttrs: IL.ILFieldDef -> IL.ILFieldDef - addFieldNeverAttrs: IL.ILFieldDef -> IL.ILFieldDef - addMethodGeneratedAttrs: IL.ILMethodDef -> IL.ILMethodDef } - with - override ToString : unit -> string - end - val addMethodGeneratedAttrsToTypeDef : - cenv:cenv -> tdef:IL.ILTypeDef -> IL.ILTypeDef - val newIlxPubCloEnv : - IL.ILGlobals * addMethodGeneratedAttrs:(IL.ILMethodDef -> IL.ILMethodDef) * - addFieldGeneratedAttrs:(IL.ILFieldDef -> IL.ILFieldDef) * - addFieldNeverAttrs:(IL.ILFieldDef -> IL.ILFieldDef) -> cenv - val mkILTyFuncTy : cenv -> IL.ILType - val mkILFuncTy : cenv -> IL.ILType -> IL.ILType -> IL.ILType - val mkILCurriedFuncTy : - cenv:cenv -> dtys:IL.ILType list -> rty:IL.ILType -> IL.ILType - val typ_Func : - cenv:cenv -> dtys:IL.ILType list -> rty:IL.ILType -> IL.ILType - val mkTyOfApps : cenv:cenv -> apps:Types.IlxClosureApps -> IL.ILType - val mkTyOfLambdas : cenv -> Types.IlxClosureLambdas -> IL.ILType - val mkMethSpecForMultiApp : - cenv:cenv -> - argtys':IL.ILType list * rty:IL.ILType -> bool * IL.ILMethodSpec - val mkCallBlockForMultiValueApp : - cenv:cenv -> - doTailCall:IL.ILTailcall -> - args':IL.ILType list * rty':IL.ILType -> IL.ILInstr list - val mkMethSpecForClosureCall : - cenv:cenv -> clospec:Types.IlxClosureSpec -> IL.ILMethodSpec - val mkLdFreeVar : - clospec:Types.IlxClosureSpec -> - fv:Types.IlxClosureFreeVar -> IL.ILInstr list - val mkCallFunc : - cenv -> - allocLocal:(IL.ILType -> uint16) -> - numThisGenParams:int -> - IL.ILTailcall -> Types.IlxClosureApps -> IL.ILInstr list - val convReturnInstr : ty:IL.ILType -> instr:IL.ILInstr -> IL.ILInstr list - val convILMethodBody : - thisClo:'a option * boxReturnTy:IL.ILType option -> - il:IL.ILMethodBody -> IL.ILMethodBody - val convMethodBody : - thisClo:'a option -> _arg1:IL.MethodBody -> IL.MethodBody - val convMethodDef : thisClo:'a option -> md:IL.ILMethodDef -> IL.ILMethodDef - val mkILFreeVarForParam : p:IL.ILParameter -> Types.IlxClosureFreeVar - val mkILLocalForFreeVar : p:Types.IlxClosureFreeVar -> IL.ILLocal - val mkILCloFldSpecs : - _cenv:'a -> flds:Types.IlxClosureFreeVar [] -> (string * IL.ILType) list - val mkILCloFldDefs : - cenv:cenv -> flds:Types.IlxClosureFreeVar [] -> IL.ILFieldDef list - val convIlxClosureDef : - cenv -> - encl:string list -> - IL.ILTypeDef -> Types.IlxClosureInfo -> IL.ILTypeDef list - end - -namespace FSharp.Compiler.AbstractIL.Extensions.ILX - module internal EraseUnions = begin - [] - val TagNil : int = 0 - [] - val TagCons : int = 1 - [] - val ALT_NAME_CONS : string = "Cons" - type DiscriminationTechnique = - | TailOrNull - | RuntimeTypes - | SingleCase - | IntegerTag - type UnionReprDecisions<'Union,'Alt,'Type> = - class - new : getAlternatives:('Union -> 'Alt []) * - nullPermitted:('Union -> bool) * isNullary:('Alt -> bool) * - isList:('Union -> bool) * isStruct:('Union -> bool) * - nameOfAlt:('Alt -> string) * makeRootType:('Union -> 'Type) * - makeNestedType:('Union * string -> 'Type) -> - UnionReprDecisions<'Union,'Alt,'Type> - member DiscriminationTechnique : cu:'Union -> DiscriminationTechnique - member Flatten : cu:'Union -> bool - member - MaintainPossiblyUniqueConstantFieldForAlternative : cu:'Union * - alt:'Alt -> bool - member OptimizeAlternativeToRootClass : cu:'Union * alt:'Alt -> bool - member - RepresentAllAlternativesAsConstantFieldsInRootClass : cu:'Union -> - bool - member - RepresentAlternativeAsConstantFieldInTaggedRootClass : cu:'Union * - alt:'Alt -> - bool - member - RepresentAlternativeAsFreshInstancesOfRootClass : cu:'Union * alt:'Alt -> - bool - member RepresentAlternativeAsNull : cu:'Union * alt:'Alt -> bool - member RepresentAlternativeAsStructValue : cu:'Union -> bool - member RepresentOneAlternativeAsNull : cu:'Union -> bool - member - RepresentSingleNonNullaryAlternativeAsInstancesOfRootClassAndAnyOtherAlternativesAsNull : cu:'Union * - alt:'Alt -> - bool - member TypeForAlternative : cuspec:'Union * alt:'Alt -> 'Type - end - val baseTyOfUnionSpec : cuspec:Types.IlxUnionSpec -> IL.ILType - val mkMakerName : cuspec:Types.IlxUnionSpec -> nm:string -> string - val mkCasesTypeRef : cuspec:Types.IlxUnionSpec -> IL.ILTypeRef - val cuspecRepr : - UnionReprDecisions - type NoTypesGeneratedViaThisReprDecider = - | NoTypesGeneratedViaThisReprDecider - val cudefRepr : - UnionReprDecisions<(IL.ILTypeDef * Types.IlxUnionInfo), - Types.IlxUnionAlternative, - NoTypesGeneratedViaThisReprDecider> - val mkTesterName : nm:string -> string - val tagPropertyName : string - val mkUnionCaseFieldId : fdef:Types.IlxUnionField -> string * IL.ILType - val refToFieldInTy : - ty:IL.ILType -> nm:string * fldTy:IL.ILType -> IL.ILFieldSpec - val formalTypeArgs : baseTy:IL.ILType -> IL.ILType list - val constFieldName : nm:string -> string - val constFormalFieldTy : baseTy:IL.ILType -> IL.ILType - val mkConstFieldSpecFromId : - baseTy:IL.ILType -> string * IL.ILType -> IL.ILFieldSpec - val mkConstFieldSpec : nm:string -> baseTy:IL.ILType -> IL.ILFieldSpec - val tyForAlt : - cuspec:Types.IlxUnionSpec -> alt:Types.IlxUnionAlternative -> IL.ILType - val GetILTypeForAlternative : Types.IlxUnionSpec -> int -> IL.ILType - val mkTagFieldType : ilg:IL.ILGlobals -> _cuspec:'a -> IL.ILType - val mkTagFieldFormalType : ilg:IL.ILGlobals -> _cuspec:'a -> IL.ILType - val mkTagFieldId : ilg:IL.ILGlobals -> cuspec:'a -> string * IL.ILType - val mkTailOrNullId : baseTy:IL.ILType -> string * IL.ILType - val altOfUnionSpec : - cuspec:Types.IlxUnionSpec -> cidx:int -> Types.IlxUnionAlternative - val doesRuntimeTypeDiscriminateUseHelper : - avoidHelpers:bool -> - cuspec:Types.IlxUnionSpec -> alt:Types.IlxUnionAlternative -> bool - val mkRuntimeTypeDiscriminate : - ilg:IL.ILGlobals -> - avoidHelpers:bool -> - cuspec:Types.IlxUnionSpec -> - alt:Types.IlxUnionAlternative -> - altName:string -> altTy:IL.ILType -> IL.ILInstr list - val mkRuntimeTypeDiscriminateThen : - ilg:IL.ILGlobals -> - avoidHelpers:bool -> - cuspec:Types.IlxUnionSpec -> - alt:Types.IlxUnionAlternative -> - altName:string -> - altTy:IL.ILType -> after:IL.ILInstr -> IL.ILInstr list - val mkGetTagFromField : - ilg:IL.ILGlobals -> cuspec:'a -> baseTy:IL.ILType -> IL.ILInstr list - val adjustFieldName : - hasHelpers:Types.IlxUnionHasHelpers -> nm:string -> string - val mkLdData : bool * Types.IlxUnionSpec * int * int -> IL.ILInstr list - val mkLdDataAddr : bool * Types.IlxUnionSpec * int * int -> IL.ILInstr list - val mkGetTailOrNull : - avoidHelpers:bool -> cuspec:Types.IlxUnionSpec -> IL.ILInstr list - val mkGetTagFromHelpers : - ilg:IL.ILGlobals -> cuspec:Types.IlxUnionSpec -> IL.ILInstr - val mkGetTag : - ilg:IL.ILGlobals -> cuspec:Types.IlxUnionSpec -> IL.ILInstr list - val mkCeqThen : after:IL.ILInstr -> IL.ILInstr list - val mkTagDiscriminate : - ilg:IL.ILGlobals -> - cuspec:Types.IlxUnionSpec -> _baseTy:'a -> cidx:int32 -> IL.ILInstr list - val mkTagDiscriminateThen : - ilg:IL.ILGlobals -> - cuspec:Types.IlxUnionSpec -> - cidx:int32 -> after:IL.ILInstr -> IL.ILInstr list - val extraTysAndInstrsForStructCtor : - ilg:IL.ILGlobals -> cidx:int -> IL.ILType list * IL.ILInstr list - val takesExtraParams : alts:Types.IlxUnionAlternative [] -> bool - val convNewDataInstrInternal : - ilg:IL.ILGlobals -> - cuspec:Types.IlxUnionSpec -> cidx:int -> IL.ILInstr list - val mkStData : Types.IlxUnionSpec * int * int -> IL.ILInstr list - val mkNewData : IL.ILGlobals -> Types.IlxUnionSpec * int -> IL.ILInstr list - val mkIsData : - IL.ILGlobals -> bool * Types.IlxUnionSpec * int -> IL.ILInstr list - type ICodeGen<'Mark> = - interface - abstract member CodeLabel : 'Mark -> IL.ILCodeLabel - abstract member EmitInstr : IL.ILInstr -> unit - abstract member EmitInstrs : IL.ILInstr list -> unit - abstract member GenLocal : IL.ILType -> uint16 - abstract member GenerateDelayMark : unit -> 'Mark - abstract member MkInvalidCastExnNewobj : unit -> IL.ILInstr - abstract member SetMarkToHere : 'Mark -> unit - end - val genWith : g:(ICodeGen -> unit) -> IL.ILCode - val mkBrIsData : - IL.ILGlobals -> - sense:bool -> - avoidHelpers:bool * Types.IlxUnionSpec * int * IL.ILCodeLabel -> - IL.ILInstr list - val emitLdDataTagPrim : - ilg:IL.ILGlobals -> - ldOpt:IL.ILInstr option -> - cg:ICodeGen<'Mark> -> - avoidHelpers:bool * cuspec:Types.IlxUnionSpec -> unit - val emitLdDataTag : - IL.ILGlobals -> - ICodeGen<'Mark> -> avoidHelpers:bool * Types.IlxUnionSpec -> unit - val emitCastData : - IL.ILGlobals -> - ICodeGen<'Mark> -> - canfail:bool * avoidHelpers:bool * Types.IlxUnionSpec * int -> unit - val emitDataSwitch : - IL.ILGlobals -> - ICodeGen<'Mark> -> - avoidHelpers:bool * Types.IlxUnionSpec * (int * IL.ILCodeLabel) list -> - unit - val mkMethodsAndPropertiesForFields : - addMethodGeneratedAttrs:(IL.ILMethodDef -> 'a) * - addPropertyGeneratedAttrs:(IL.ILPropertyDef -> 'b) -> - access:IL.ILMemberAccess -> - attr:IL.ILSourceMarker option -> - hasHelpers:Types.IlxUnionHasHelpers -> - ilTy:IL.ILType -> - fields:Types.IlxUnionField [] -> 'b list * 'a list - val convAlternativeDef : - addMethodGeneratedAttrs:(IL.ILMethodDef -> IL.ILMethodDef) * - addPropertyGeneratedAttrs:(IL.ILPropertyDef -> IL.ILPropertyDef) * - addPropertyNeverAttrs:(IL.ILPropertyDef -> 'a) * - addFieldGeneratedAttrs:('b -> IL.ILFieldDef) * - addFieldNeverAttrs:(IL.ILFieldDef -> 'b) * - mkDebuggerTypeProxyAttribute:(IL.ILType -> IL.ILAttribute) -> - ilg:IL.ILGlobals -> - num:int -> - td:IL.ILTypeDef -> - cud:Types.IlxUnionInfo -> - IL.ILTypeDef * Types.IlxUnionInfo -> - cuspec:Types.IlxUnionSpec -> - baseTy:IL.ILType -> - alt:Types.IlxUnionAlternative -> - IL.ILMethodDef list * 'a list * IL.ILMethodDef list * - IL.ILTypeDef list * IL.ILTypeDef list * - ((IL.ILTypeDef * Types.IlxUnionInfo) * - Types.IlxUnionAlternative * IL.ILType * int * - IL.ILFieldDef * bool) list - val mkClassUnionDef : - addMethodGeneratedAttrs:(IL.ILMethodDef -> IL.ILMethodDef) * - addPropertyGeneratedAttrs:(IL.ILPropertyDef -> IL.ILPropertyDef) * - addPropertyNeverAttrs:(IL.ILPropertyDef -> IL.ILPropertyDef) * - addFieldGeneratedAttrs:(IL.ILFieldDef -> IL.ILFieldDef) * - addFieldNeverAttrs:(IL.ILFieldDef -> IL.ILFieldDef) * - mkDebuggerTypeProxyAttribute:(IL.ILType -> IL.ILAttribute) -> - ilg:IL.ILGlobals -> - tref:IL.ILTypeRef -> - td:IL.ILTypeDef -> cud:Types.IlxUnionInfo -> IL.ILTypeDef - end - -namespace FSharp.Compiler - module internal UnicodeLexing = begin - type Lexbuf = Internal.Utilities.Text.Lexing.LexBuffer - val StringAsLexbuf : - (Features.LanguageFeature -> bool) * string -> - Internal.Utilities.Text.Lexing.LexBuffer - val FunctionAsLexbuf : - (Features.LanguageFeature -> bool) * (char [] * int * int -> int) -> - Internal.Utilities.Text.Lexing.LexBuffer - val SourceTextAsLexbuf : - (Features.LanguageFeature -> bool) * Text.ISourceText -> - Internal.Utilities.Text.Lexing.LexBuffer - val StreamReaderAsLexbuf : - (Features.LanguageFeature -> bool) * System.IO.StreamReader -> - Internal.Utilities.Text.Lexing.LexBuffer - end - -namespace FSharp.Compiler - module Layout = begin - type layout = Internal.Utilities.StructuredFormat.Layout - type LayoutTag = Internal.Utilities.StructuredFormat.LayoutTag - type TaggedText = Internal.Utilities.StructuredFormat.TaggedText - type NavigableTaggedText = - class - interface TaggedText - new : TaggedText * Range.range -> NavigableTaggedText - member Range : Range.range - end - val mkNav : Range.range -> TaggedText -> TaggedText - val spaces : n:int -> System.String - val emptyL : Internal.Utilities.StructuredFormat.Layout - val isEmptyL : Internal.Utilities.StructuredFormat.Layout -> bool - val mkNode : - l:Internal.Utilities.StructuredFormat.Layout -> - r:Internal.Utilities.StructuredFormat.Layout -> - joint:Internal.Utilities.StructuredFormat.Joint -> - Internal.Utilities.StructuredFormat.Layout - val wordL : TaggedText -> Internal.Utilities.StructuredFormat.Layout - val sepL : TaggedText -> Internal.Utilities.StructuredFormat.Layout - val rightL : TaggedText -> Internal.Utilities.StructuredFormat.Layout - val leftL : TaggedText -> Internal.Utilities.StructuredFormat.Layout - module TaggedTextOps = begin - val tagActivePatternCase : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagActivePatternResult : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagAlias : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagClass : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagUnion : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagUnionCase : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagDelegate : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagEnum : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagEvent : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagField : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagInterface : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagKeyword : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagLineBreak : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagLocal : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagRecord : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagRecordField : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagMethod : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagMember : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagModule : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagModuleBinding : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagFunction : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagNamespace : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagNumericLiteral : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagOperator : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagParameter : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagProperty : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagSpace : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagStringLiteral : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagStruct : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagTypeParameter : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagText : (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagPunctuation : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagUnknownEntity : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - val tagUnknownType : - (string -> Internal.Utilities.StructuredFormat.TaggedText) - module Literals = begin - val lineBreak : Internal.Utilities.StructuredFormat.TaggedText - val space : Internal.Utilities.StructuredFormat.TaggedText - val comma : Internal.Utilities.StructuredFormat.TaggedText - val semicolon : Internal.Utilities.StructuredFormat.TaggedText - val leftParen : Internal.Utilities.StructuredFormat.TaggedText - val rightParen : Internal.Utilities.StructuredFormat.TaggedText - val leftBracket : Internal.Utilities.StructuredFormat.TaggedText - val rightBracket : Internal.Utilities.StructuredFormat.TaggedText - val leftBrace : Internal.Utilities.StructuredFormat.TaggedText - val rightBrace : Internal.Utilities.StructuredFormat.TaggedText - val leftBraceBar : Internal.Utilities.StructuredFormat.TaggedText - val rightBraceBar : Internal.Utilities.StructuredFormat.TaggedText - val equals : Internal.Utilities.StructuredFormat.TaggedText - val arrow : Internal.Utilities.StructuredFormat.TaggedText - val questionMark : Internal.Utilities.StructuredFormat.TaggedText - val dot : Internal.Utilities.StructuredFormat.TaggedText - val leftAngle : Internal.Utilities.StructuredFormat.TaggedText - val rightAngle : Internal.Utilities.StructuredFormat.TaggedText - val star : Internal.Utilities.StructuredFormat.TaggedText - val colon : Internal.Utilities.StructuredFormat.TaggedText - val minus : Internal.Utilities.StructuredFormat.TaggedText - val keywordNew : Internal.Utilities.StructuredFormat.TaggedText - val leftBracketAngle : Internal.Utilities.StructuredFormat.TaggedText - val rightBracketAngle : Internal.Utilities.StructuredFormat.TaggedText - val structUnit : Internal.Utilities.StructuredFormat.TaggedText - val keywordStatic : Internal.Utilities.StructuredFormat.TaggedText - val keywordMember : Internal.Utilities.StructuredFormat.TaggedText - val keywordVal : Internal.Utilities.StructuredFormat.TaggedText - val keywordEvent : Internal.Utilities.StructuredFormat.TaggedText - val keywordWith : Internal.Utilities.StructuredFormat.TaggedText - val keywordSet : Internal.Utilities.StructuredFormat.TaggedText - val keywordGet : Internal.Utilities.StructuredFormat.TaggedText - val keywordTrue : Internal.Utilities.StructuredFormat.TaggedText - val keywordFalse : Internal.Utilities.StructuredFormat.TaggedText - val bar : Internal.Utilities.StructuredFormat.TaggedText - val keywordStruct : Internal.Utilities.StructuredFormat.TaggedText - val keywordInherit : Internal.Utilities.StructuredFormat.TaggedText - val keywordEnd : Internal.Utilities.StructuredFormat.TaggedText - val keywordNested : Internal.Utilities.StructuredFormat.TaggedText - val keywordType : Internal.Utilities.StructuredFormat.TaggedText - val keywordDelegate : Internal.Utilities.StructuredFormat.TaggedText - val keywordOf : Internal.Utilities.StructuredFormat.TaggedText - val keywordInternal : Internal.Utilities.StructuredFormat.TaggedText - val keywordPrivate : Internal.Utilities.StructuredFormat.TaggedText - val keywordAbstract : Internal.Utilities.StructuredFormat.TaggedText - val keywordOverride : Internal.Utilities.StructuredFormat.TaggedText - val keywordEnum : Internal.Utilities.StructuredFormat.TaggedText - val leftBracketBar : Internal.Utilities.StructuredFormat.TaggedText - val rightBracketBar : Internal.Utilities.StructuredFormat.TaggedText - val keywordTypeof : Internal.Utilities.StructuredFormat.TaggedText - val keywordTypedefof : Internal.Utilities.StructuredFormat.TaggedText - end - end - module SepL = begin - val dot : Internal.Utilities.StructuredFormat.Layout - val star : Internal.Utilities.StructuredFormat.Layout - val colon : Internal.Utilities.StructuredFormat.Layout - val questionMark : Internal.Utilities.StructuredFormat.Layout - val leftParen : Internal.Utilities.StructuredFormat.Layout - val comma : Internal.Utilities.StructuredFormat.Layout - val space : Internal.Utilities.StructuredFormat.Layout - val leftBracket : Internal.Utilities.StructuredFormat.Layout - val leftAngle : Internal.Utilities.StructuredFormat.Layout - val lineBreak : Internal.Utilities.StructuredFormat.Layout - val rightParen : Internal.Utilities.StructuredFormat.Layout - end - module WordL = begin - val arrow : Internal.Utilities.StructuredFormat.Layout - val star : Internal.Utilities.StructuredFormat.Layout - val colon : Internal.Utilities.StructuredFormat.Layout - val equals : Internal.Utilities.StructuredFormat.Layout - val keywordNew : Internal.Utilities.StructuredFormat.Layout - val structUnit : Internal.Utilities.StructuredFormat.Layout - val keywordStatic : Internal.Utilities.StructuredFormat.Layout - val keywordMember : Internal.Utilities.StructuredFormat.Layout - val keywordVal : Internal.Utilities.StructuredFormat.Layout - val keywordEvent : Internal.Utilities.StructuredFormat.Layout - val keywordWith : Internal.Utilities.StructuredFormat.Layout - val keywordSet : Internal.Utilities.StructuredFormat.Layout - val keywordGet : Internal.Utilities.StructuredFormat.Layout - val keywordTrue : Internal.Utilities.StructuredFormat.Layout - val keywordFalse : Internal.Utilities.StructuredFormat.Layout - val bar : Internal.Utilities.StructuredFormat.Layout - val keywordStruct : Internal.Utilities.StructuredFormat.Layout - val keywordInherit : Internal.Utilities.StructuredFormat.Layout - val keywordEnd : Internal.Utilities.StructuredFormat.Layout - val keywordNested : Internal.Utilities.StructuredFormat.Layout - val keywordType : Internal.Utilities.StructuredFormat.Layout - val keywordDelegate : Internal.Utilities.StructuredFormat.Layout - val keywordOf : Internal.Utilities.StructuredFormat.Layout - val keywordInternal : Internal.Utilities.StructuredFormat.Layout - val keywordPrivate : Internal.Utilities.StructuredFormat.Layout - val keywordAbstract : Internal.Utilities.StructuredFormat.Layout - val keywordOverride : Internal.Utilities.StructuredFormat.Layout - val keywordEnum : Internal.Utilities.StructuredFormat.Layout - end - module LeftL = begin - val leftParen : Internal.Utilities.StructuredFormat.Layout - val questionMark : Internal.Utilities.StructuredFormat.Layout - val colon : Internal.Utilities.StructuredFormat.Layout - val leftBracketAngle : Internal.Utilities.StructuredFormat.Layout - val leftBracketBar : Internal.Utilities.StructuredFormat.Layout - val keywordTypeof : Internal.Utilities.StructuredFormat.Layout - val keywordTypedefof : Internal.Utilities.StructuredFormat.Layout - end - module RightL = begin - val comma : Internal.Utilities.StructuredFormat.Layout - val rightParen : Internal.Utilities.StructuredFormat.Layout - val colon : Internal.Utilities.StructuredFormat.Layout - val rightBracket : Internal.Utilities.StructuredFormat.Layout - val rightAngle : Internal.Utilities.StructuredFormat.Layout - val rightBracketAngle : Internal.Utilities.StructuredFormat.Layout - val rightBracketBar : Internal.Utilities.StructuredFormat.Layout - end - val aboveL : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val tagAttrL : - str:string -> - attrs:(string * string) list -> - ly:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val apply2 : - f:(Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout) -> - l:Internal.Utilities.StructuredFormat.Layout -> - r:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val ( ^^ ) : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val ( ++ ) : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val ( -- ) : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val ( --- ) : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val ( ---- ) : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val ( ----- ) : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val ( @@ ) : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val ( @@- ) : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val ( @@-- ) : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val tagListL : - tagger:(Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout) -> - _arg1:Internal.Utilities.StructuredFormat.Layout list -> - Internal.Utilities.StructuredFormat.Layout - val commaListL : - Internal.Utilities.StructuredFormat.Layout list -> - Internal.Utilities.StructuredFormat.Layout - val semiListL : - Internal.Utilities.StructuredFormat.Layout list -> - Internal.Utilities.StructuredFormat.Layout - val spaceListL : - Internal.Utilities.StructuredFormat.Layout list -> - Internal.Utilities.StructuredFormat.Layout - val sepListL : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout list -> - Internal.Utilities.StructuredFormat.Layout - val bracketL : - Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val tupleL : - Internal.Utilities.StructuredFormat.Layout list -> - Internal.Utilities.StructuredFormat.Layout - val aboveListL : - Internal.Utilities.StructuredFormat.Layout list -> - Internal.Utilities.StructuredFormat.Layout - val optionL : - ('a -> Internal.Utilities.StructuredFormat.Layout) -> - 'a option -> Internal.Utilities.StructuredFormat.Layout - val listL : - ('a -> Internal.Utilities.StructuredFormat.Layout) -> - 'a list -> Internal.Utilities.StructuredFormat.Layout - type LayoutRenderer<'a,'b> = - interface - abstract member AddBreak : 'b -> int -> 'b - abstract member - AddTag : 'b -> string * (string * string) list * bool -> 'b - abstract member AddText : 'b -> TaggedText -> 'b - abstract member Finish : 'b -> 'a - abstract member Start : unit -> 'b - end - val renderL : - LayoutRenderer<'b,'a> -> Internal.Utilities.StructuredFormat.Layout -> 'b - val stringR : LayoutRenderer - type NoState = | NoState - type NoResult = | NoResult - val taggedTextListR : - collector:(TaggedText -> unit) -> LayoutRenderer - val channelR : System.IO.TextWriter -> LayoutRenderer - val bufferR : System.Text.StringBuilder -> LayoutRenderer - val showL : Internal.Utilities.StructuredFormat.Layout -> string - val outL : - System.IO.TextWriter -> Internal.Utilities.StructuredFormat.Layout -> unit - val bufferL : - System.Text.StringBuilder -> - Internal.Utilities.StructuredFormat.Layout -> unit - end - -namespace FSharp.Compiler - module XmlDoc = begin - [] - type XmlDoc = - class - new : unprocessedLines:string [] * range:Range.range -> XmlDoc - static member Merge : doc1:XmlDoc -> doc2:XmlDoc -> XmlDoc - member Check : paramNamesOpt:string list option -> unit - member GetElaboratedXmlLines : unit -> string [] - member GetXmlText : unit -> string - member IsEmpty : bool - member NonEmpty : bool - member Range : Range.range - member UnprocessedLines : string [] - static member Empty : XmlDoc - end - and XmlDocStatics = - class - new : unit -> XmlDocStatics - static member Empty : XmlDoc - end - type XmlDocCollector = - class - new : unit -> XmlDocCollector - member AddGrabPoint : pos:Range.pos -> unit - member AddXmlDocLine : line:string * range:Range.range -> unit - member LinesBefore : grabPointPos:Range.pos -> (string * Range.range) [] - end - type PreXmlDoc = - | PreXmlMerge of PreXmlDoc * PreXmlDoc - | PreXmlDoc of Range.pos * XmlDocCollector - | PreXmlDocEmpty - with - static member - CreateFromGrabPoint : collector:XmlDocCollector * - grabPointPos:Range.pos -> PreXmlDoc - static member Merge : a:PreXmlDoc -> b:PreXmlDoc -> PreXmlDoc - member - ToXmlDoc : check:bool * paramNamesOpt:string list option -> XmlDoc - static member Empty : PreXmlDoc - end - end - -namespace FSharp.Compiler - module SyntaxTree = begin - [] - type Ident = - struct - new : text:string * range:Range.range -> Ident - override ToString : unit -> string - member idRange : Range.range - member idText : string - end - and LongIdent = Ident list - and LongIdentWithDots = - | LongIdentWithDots of id: LongIdent * dotms: Range.range list - with - member Lid : LongIdent - member Range : Range.range - member RangeSansAnyExtraDot : Range.range - member ThereIsAnExtraDotAtTheEnd : bool - end - [] - and ParserDetail = - | Ok - | ErrorRecovery - and TyparStaticReq = - | NoStaticReq - | HeadTypeStaticReq - [] - and SynTypar = - | Typar of ident: Ident * staticReq: TyparStaticReq * isCompGen: bool - with - member Range : Range.range - end - [] - and SynConst = - | Unit - | Bool of bool - | SByte of sbyte - | Byte of byte - | Int16 of int16 - | UInt16 of uint16 - | Int32 of int32 - | UInt32 of uint32 - | Int64 of int64 - | UInt64 of uint64 - | IntPtr of int64 - | UIntPtr of uint64 - | Single of single - | Double of double - | Char of char - | Decimal of System.Decimal - | UserNum of value: string * suffix: string - | String of text: string * range: Range.range - | Bytes of bytes: byte [] * range: Range.range - | UInt16s of uint16 [] - | Measure of constant: SynConst * SynMeasure - with - member Range : dflt:Range.range -> Range.range - end - [] - and SynMeasure = - | Named of longId: LongIdent * range: Range.range - | Product of SynMeasure * SynMeasure * range: Range.range - | Seq of SynMeasure list * range: Range.range - | Divide of SynMeasure * SynMeasure * range: Range.range - | Power of SynMeasure * SynRationalConst * range: Range.range - | One - | Anon of range: Range.range - | Var of SynTypar * range: Range.range - [] - and SynRationalConst = - | Integer of int32 - | Rational of int32 * int32 * range: Range.range - | Negate of SynRationalConst - [] - and SynAccess = - | Public - | Internal - | Private - with - override ToString : unit -> string - end - [] - and DebugPointForTarget = - | Yes - | No - [] - and DebugPointAtSequential = - | Both - | StmtOnly - | ExprOnly - [] - and DebugPointAtTry = - | Yes of range: Range.range - | Body - | No - [] - and DebugPointAtWith = - | Yes of range: Range.range - | No - [] - and DebugPointAtFinally = - | Yes of range: Range.range - | No - [] - and DebugPointAtFor = - | Yes of range: Range.range - | No - [] - and DebugPointAtWhile = - | Yes of range: Range.range - | No - and DebugPointForBinding = - | DebugPointAtBinding of range: Range.range - | NoDebugPointAtDoBinding - | NoDebugPointAtLetBinding - | NoDebugPointAtStickyBinding - | NoDebugPointAtInvisibleBinding - with - member Combine : y:DebugPointForBinding -> DebugPointForBinding - end - and SeqExprOnly = | SeqExprOnly of bool - and BlockSeparator = Range.range * Range.pos option - and RecordFieldName = LongIdentWithDots * bool - and ExprAtomicFlag = - | Atomic = 0 - | NonAtomic = 1 - and SynBindingKind = - | StandaloneExpression - | NormalBinding - | DoBinding - [] - and SynTyparDecl = | TyparDecl of attributes: SynAttributes * SynTypar - [] - and SynTypeConstraint = - | WhereTyparIsValueType of typar: SynTypar * range: Range.range - | WhereTyparIsReferenceType of typar: SynTypar * range: Range.range - | WhereTyparIsUnmanaged of typar: SynTypar * range: Range.range - | WhereTyparSupportsNull of typar: SynTypar * range: Range.range - | WhereTyparIsComparable of typar: SynTypar * range: Range.range - | WhereTyparIsEquatable of typar: SynTypar * range: Range.range - | WhereTyparDefaultsToType of - typar: SynTypar * typeName: SynType * range: Range.range - | WhereTyparSubtypeOfType of - typar: SynTypar * typeName: SynType * range: Range.range - | WhereTyparSupportsMember of - typars: SynType list * memberSig: SynMemberSig * range: Range.range - | WhereTyparIsEnum of - typar: SynTypar * typeArgs: SynType list * range: Range.range - | WhereTyparIsDelegate of - typar: SynTypar * typeArgs: SynType list * range: Range.range - [] - and SynType = - | LongIdent of longDotId: LongIdentWithDots - | App of - typeName: SynType * lessRange: Range.range option * - typeArgs: SynType list * commaRanges: Range.range list * - greaterRange: Range.range option * isPostfix: bool * range: Range.range - | LongIdentApp of - typeName: SynType * longDotId: LongIdentWithDots * - lessRange: Range.range option * typeArgs: SynType list * - commaRanges: Range.range list * greaterRange: Range.range option * - range: Range.range - | Tuple of - isStruct: bool * elementTypes: (bool * SynType) list * - range: Range.range - | AnonRecd of - isStruct: bool * fields: (Ident * SynType) list * range: Range.range - | Array of rank: int * elementType: SynType * range: Range.range - | Fun of argType: SynType * returnType: SynType * range: Range.range - | Var of typar: SynTypar * range: Range.range - | Anon of range: Range.range - | WithGlobalConstraints of - typeName: SynType * constraints: SynTypeConstraint list * - range: Range.range - | HashConstraint of innerType: SynType * range: Range.range - | MeasureDivide of - dividend: SynType * divisor: SynType * range: Range.range - | MeasurePower of - baseMeasure: SynType * exponent: SynRationalConst * range: Range.range - | StaticConstant of constant: SynConst * range: Range.range - | StaticConstantExpr of expr: SynExpr * range: Range.range - | StaticConstantNamed of - ident: SynType * value: SynType * range: Range.range - | Paren of innerType: SynType * range: Range.range - with - member Range : Range.range - end - [] - and SynExpr = - | Paren of - expr: SynExpr * leftParenRange: Range.range * - rightParenRange: Range.range option * range: Range.range - | Quote of - operator: SynExpr * isRaw: bool * quotedExpr: SynExpr * - isFromQueryExpression: bool * range: Range.range - | Const of constant: SynConst * range: Range.range - | Typed of expr: SynExpr * targetType: SynType * range: Range.range - | Tuple of - isStruct: bool * exprs: SynExpr list * commaRanges: Range.range list * - range: Range.range - | AnonRecd of - isStruct: bool * copyInfo: (SynExpr * BlockSeparator) option * - recordFields: (Ident * SynExpr) list * range: Range.range - | ArrayOrList of isList: bool * exprs: SynExpr list * range: Range.range - | Record of - baseInfo: - (SynType * SynExpr * Range.range * BlockSeparator option * Range.range) option * - copyInfo: (SynExpr * BlockSeparator) option * - recordFields: - (RecordFieldName * SynExpr option * BlockSeparator option) list * - range: Range.range - | New of - isProtected: bool * targetType: SynType * expr: SynExpr * - range: Range.range - | ObjExpr of - objType: SynType * argOptions: (SynExpr * Ident option) option * - bindings: SynBinding list * extraImpls: SynInterfaceImpl list * - newExprRange: Range.range * range: Range.range - | While of - whileSeqPoint: DebugPointAtWhile * whileExpr: SynExpr * doExpr: SynExpr * - range: Range.range - | For of - forSeqPoint: DebugPointAtFor * ident: Ident * identBody: SynExpr * - direction: bool * toBody: SynExpr * doBody: SynExpr * range: Range.range - | ForEach of - forSeqPoint: DebugPointAtFor * seqExprOnly: SeqExprOnly * - isFromSource: bool * pat: SynPat * enumExpr: SynExpr * bodyExpr: SynExpr * - range: Range.range - | ArrayOrListOfSeqExpr of - isArray: bool * expr: SynExpr * range: Range.range - | CompExpr of - isArrayOrList: bool * isNotNakedRefCell: bool ref * expr: SynExpr * - range: Range.range - | Lambda of - fromMethod: bool * inLambdaSeq: bool * args: SynSimplePats * - body: SynExpr * parsedData: (SynPat list * SynExpr) option * - range: Range.range - | MatchLambda of - isExnMatch: bool * keywordRange: Range.range * - matchClauses: SynMatchClause list * matchSeqPoint: DebugPointForBinding * - range: Range.range - | Match of - matchSeqPoint: DebugPointForBinding * expr: SynExpr * - clauses: SynMatchClause list * range: Range.range - | Do of expr: SynExpr * range: Range.range - | Assert of expr: SynExpr * range: Range.range - | App of - flag: ExprAtomicFlag * isInfix: bool * funcExpr: SynExpr * - argExpr: SynExpr * range: Range.range - | TypeApp of - expr: SynExpr * lessRange: Range.range * typeArgs: SynType list * - commaRanges: Range.range list * greaterRange: Range.range option * - typeArgsRange: Range.range * range: Range.range - | LetOrUse of - isRecursive: bool * isUse: bool * bindings: SynBinding list * - body: SynExpr * range: Range.range - | TryWith of - tryExpr: SynExpr * tryRange: Range.range * - withCases: SynMatchClause list * withRange: Range.range * - range: Range.range * trySeqPoint: DebugPointAtTry * - withSeqPoint: DebugPointAtWith - | TryFinally of - tryExpr: SynExpr * finallyExpr: SynExpr * range: Range.range * - trySeqPoint: DebugPointAtTry * finallySeqPoint: DebugPointAtFinally - | Lazy of expr: SynExpr * range: Range.range - | Sequential of - seqPoint: DebugPointAtSequential * isTrueSeq: bool * expr1: SynExpr * - expr2: SynExpr * range: Range.range - | IfThenElse of - ifExpr: SynExpr * thenExpr: SynExpr * elseExpr: SynExpr option * - spIfToThen: DebugPointForBinding * isFromErrorRecovery: bool * - ifToThenRange: Range.range * range: Range.range - | Ident of ident: Ident - | LongIdent of - isOptional: bool * longDotId: LongIdentWithDots * - altNameRefCell: SynSimplePatAlternativeIdInfo ref option * - range: Range.range - | LongIdentSet of - longDotId: LongIdentWithDots * expr: SynExpr * range: Range.range - | DotGet of - expr: SynExpr * rangeOfDot: Range.range * longDotId: LongIdentWithDots * - range: Range.range - | DotSet of - targetExpr: SynExpr * longDotId: LongIdentWithDots * rhsExpr: SynExpr * - range: Range.range - | Set of targetExpr: SynExpr * rhsExpr: SynExpr * range: Range.range - | DotIndexedGet of - objectExpr: SynExpr * indexExprs: SynIndexerArg list * - dotRange: Range.range * range: Range.range - | DotIndexedSet of - objectExpr: SynExpr * indexExprs: SynIndexerArg list * - valueExpr: SynExpr * leftOfSetRange: Range.range * dotRange: Range.range * - range: Range.range - | NamedIndexedPropertySet of - longDotId: LongIdentWithDots * expr1: SynExpr * expr2: SynExpr * - range: Range.range - | DotNamedIndexedPropertySet of - targetExpr: SynExpr * longDotId: LongIdentWithDots * argExpr: SynExpr * - rhsExpr: SynExpr * range: Range.range - | TypeTest of expr: SynExpr * targetType: SynType * range: Range.range - | Upcast of expr: SynExpr * targetType: SynType * range: Range.range - | Downcast of expr: SynExpr * targetType: SynType * range: Range.range - | InferredUpcast of expr: SynExpr * range: Range.range - | InferredDowncast of expr: SynExpr * range: Range.range - | Null of range: Range.range - | AddressOf of - isByref: bool * expr: SynExpr * opRange: Range.range * - range: Range.range - | TraitCall of - supportTys: SynTypar list * traitSig: SynMemberSig * argExpr: SynExpr * - range: Range.range - | JoinIn of - lhsExpr: SynExpr * lhsRange: Range.range * rhsExpr: SynExpr * - range: Range.range - | ImplicitZero of range: Range.range - | SequentialOrImplicitYield of - seqPoint: DebugPointAtSequential * expr1: SynExpr * expr2: SynExpr * - ifNotStmt: SynExpr * range: Range.range - | YieldOrReturn of flags: bool * bool * expr: SynExpr * range: Range.range - | YieldOrReturnFrom of - flags: bool * bool * expr: SynExpr * range: Range.range - | LetOrUseBang of - bindSeqPoint: DebugPointForBinding * isUse: bool * isFromSource: bool * - pat: SynPat * rhs: SynExpr * - andBangs: - (DebugPointForBinding * bool * bool * SynPat * SynExpr * Range.range) list * - body: SynExpr * range: Range.range - | MatchBang of - matchSeqPoint: DebugPointForBinding * expr: SynExpr * - clauses: SynMatchClause list * range: Range.range - | DoBang of expr: SynExpr * range: Range.range - | LibraryOnlyILAssembly of - ilCode: AbstractIL.IL.ILInstr array * typeArgs: SynType list * - args: SynExpr list * retTy: SynType list * range: Range.range - | LibraryOnlyStaticOptimization of - constraints: SynStaticOptimizationConstraint list * expr: SynExpr * - optimizedExpr: SynExpr * range: Range.range - | LibraryOnlyUnionCaseFieldGet of - expr: SynExpr * longId: LongIdent * fieldNum: int * range: Range.range - | LibraryOnlyUnionCaseFieldSet of - expr: SynExpr * longId: LongIdent * fieldNum: int * rhsExpr: SynExpr * - range: Range.range - | ArbitraryAfterError of debugStr: string * range: Range.range - | FromParseError of expr: SynExpr * range: Range.range - | DiscardAfterMissingQualificationAfterDot of - expr: SynExpr * range: Range.range - | Fixed of expr: SynExpr * range: Range.range - | InterpolatedString of - contents: SynInterpolatedStringPart list * range: Range.range - with - member IsArbExprAndThusAlreadyReportedError : bool - member Range : Range.range - member RangeOfFirstPortion : Range.range - member RangeSansAnyExtraDot : Range.range - end - [] - and SynInterpolatedStringPart = - | String of string * Range.range - | FillExpr of SynExpr * Ident option - [] - and SynIndexerArg = - | Two of - expr1: SynExpr * fromEnd1: bool * expr2: SynExpr * fromEnd2: bool * - range1: Range.range * range2: Range.range - | One of expr: SynExpr * fromEnd: bool * Range.range - with - member Exprs : SynExpr list - member Range : Range.range - end - [] - and SynSimplePat = - | Id of - ident: Ident * altNameRefCell: SynSimplePatAlternativeIdInfo ref option * - isCompilerGenerated: bool * isThisVar: bool * isOptArg: bool * - range: Range.range - | Typed of pat: SynSimplePat * targetType: SynType * range: Range.range - | Attrib of - pat: SynSimplePat * attributes: SynAttributes * range: Range.range - and SynSimplePatAlternativeIdInfo = - | Undecided of Ident - | Decided of Ident - [] - and SynStaticOptimizationConstraint = - | WhenTyparTyconEqualsTycon of - typar: SynTypar * rhsType: SynType * range: Range.range - | WhenTyparIsStruct of typar: SynTypar * range: Range.range - [] - and SynSimplePats = - | SimplePats of pats: SynSimplePat list * range: Range.range - | Typed of pats: SynSimplePats * targetType: SynType * range: Range.range - and SynArgPats = - | Pats of pats: SynPat list - | NamePatPairs of pats: (Ident * SynPat) list * range: Range.range - [] - and SynPat = - | Const of constant: SynConst * range: Range.range - | Wild of range: Range.range - | Named of - pat: SynPat * ident: Ident * isSelfIdentifier: bool * - accessibility: SynAccess option * range: Range.range - | Typed of pat: SynPat * targetType: SynType * range: Range.range - | Attrib of pat: SynPat * attributes: SynAttributes * range: Range.range - | Or of lhsPat: SynPat * rhsPat: SynPat * range: Range.range - | Ands of pats: SynPat list * range: Range.range - | LongIdent of - longDotId: LongIdentWithDots * extraId: Ident option * - typarDecls: SynValTyparDecls option * argPats: SynArgPats * - accessibility: SynAccess option * range: Range.range - | Tuple of isStruct: bool * elementPats: SynPat list * range: Range.range - | Paren of pat: SynPat * range: Range.range - | ArrayOrList of - isArray: bool * elementPats: SynPat list * range: Range.range - | Record of - fieldPats: ((LongIdent * Ident) * SynPat) list * range: Range.range - | Null of range: Range.range - | OptionalVal of ident: Ident * range: Range.range - | IsInst of pat: SynType * range: Range.range - | QuoteExpr of expr: SynExpr * range: Range.range - | DeprecatedCharRange of - startChar: char * endChar: char * range: Range.range - | InstanceMember of - thisId: Ident * memberId: Ident * toolingId: Ident option * - accessibility: SynAccess option * range: Range.range - | FromParseError of pat: SynPat * range: Range.range - with - member Range : Range.range - end - [] - and SynInterfaceImpl = - | InterfaceImpl of SynType * SynBinding list * range: Range.range - [] - and SynMatchClause = - | Clause of - pat: SynPat * whenExpr: SynExpr option * resultExpr: SynExpr * - range: Range.range * spInfo: DebugPointForTarget - with - member Range : Range.range - member RangeOfGuardAndRhs : Range.range - end - [] - and SynAttribute = - { TypeName: LongIdentWithDots - ArgExpr: SynExpr - Target: Ident option - AppliesToGetterAndSetter: bool - Range: Range.range } - and SynAttributeList = - { Attributes: SynAttribute list - Range: Range.range } - and SynAttributes = SynAttributeList list - [] - and SynValData = - | SynValData of MemberFlags option * SynValInfo * Ident option - with - member SynValInfo : SynValInfo - end - [] - and SynBinding = - | Binding of - accessibility: SynAccess option * kind: SynBindingKind * - mustInline: bool * isMutable: bool * attributes: SynAttributes * - xmlDoc: XmlDoc.PreXmlDoc * valData: SynValData * headPat: SynPat * - returnInfo: SynBindingReturnInfo option * expr: SynExpr * - range: Range.range * seqPoint: DebugPointForBinding - with - member RangeOfBindingAndRhs : Range.range - member RangeOfBindingSansRhs : Range.range - member RangeOfHeadPat : Range.range - end - [] - and SynBindingReturnInfo = - | SynBindingReturnInfo of - typeName: SynType * range: Range.range * attributes: SynAttributes - [] - and MemberFlags = - { IsInstance: bool - IsDispatchSlot: bool - IsOverrideOrExplicitImpl: bool - IsFinal: bool - MemberKind: MemberKind } - [] - and MemberKind = - | ClassConstructor - | Constructor - | Member - | PropertyGet - | PropertySet - | PropertyGetSet - [] - and SynMemberSig = - | Member of memberSig: SynValSig * flags: MemberFlags * range: Range.range - | Interface of interfaceType: SynType * range: Range.range - | Inherit of inheritedType: SynType * range: Range.range - | ValField of field: SynField * range: Range.range - | NestedType of nestedType: SynTypeDefnSig * range: Range.range - [] - and SynTypeDefnKind = - | TyconUnspecified - | TyconClass - | TyconInterface - | TyconStruct - | TyconRecord - | TyconUnion - | TyconAbbrev - | TyconHiddenRepr - | TyconAugmentation - | TyconILAssemblyCode - | TyconDelegate of SynType * SynValInfo - [] - and SynTypeDefnSimpleRepr = - | Union of - accessibility: SynAccess option * unionCases: SynUnionCase list * - range: Range.range - | Enum of cases: SynEnumCase list * range: Range.range - | Record of - accessibility: SynAccess option * recordFields: SynField list * - range: Range.range - | General of - kind: SynTypeDefnKind * - inherits: (SynType * Range.range * Ident option) list * - slotsigs: (SynValSig * MemberFlags) list * fields: SynField list * - isConcrete: bool * isIncrClass: bool * - implicitCtorSynPats: SynSimplePats option * range: Range.range - | LibraryOnlyILAssembly of - ilType: AbstractIL.IL.ILType * range: Range.range - | TypeAbbrev of - detail: ParserDetail * rhsType: SynType * range: Range.range - | None of range: Range.range - | Exception of exnRepr: SynExceptionDefnRepr - with - member Range : Range.range - end - [] - and SynEnumCase = - | EnumCase of - attributes: SynAttributes * ident: Ident * SynConst * - xmldoc: XmlDoc.PreXmlDoc * range: Range.range - with - member Range : Range.range - end - [] - and SynUnionCase = - | UnionCase of - attributes: SynAttributes * ident: Ident * caseType: SynUnionCaseType * - xmlDoc: XmlDoc.PreXmlDoc * accessibility: SynAccess option * - range: Range.range - with - member Range : Range.range - end - [] - and SynUnionCaseType = - | UnionCaseFields of cases: SynField list - | UnionCaseFullType of SynType * SynValInfo - [] - and SynTypeDefnSigRepr = - | ObjectModel of - kind: SynTypeDefnKind * memberSigs: SynMemberSig list * - range: Range.range - | Simple of repr: SynTypeDefnSimpleRepr * range: Range.range - | Exception of SynExceptionDefnRepr - with - member Range : Range.range - end - [] - and SynTypeDefnSig = - | TypeDefnSig of - SynComponentInfo * SynTypeDefnSigRepr * SynMemberSig list * - range: Range.range - [] - and SynField = - | Field of - attributes: SynAttributes * isStatic: bool * idOpt: Ident option * - fieldType: SynType * isMutable: bool * xmlDoc: XmlDoc.PreXmlDoc * - accessibility: SynAccess option * range: Range.range - [] - and SynComponentInfo = - | ComponentInfo of - attributes: SynAttributes * typeParams: SynTyparDecl list * - constraints: SynTypeConstraint list * longId: LongIdent * - xmlDoc: XmlDoc.PreXmlDoc * preferPostfix: bool * - accessibility: SynAccess option * range: Range.range - with - member Range : Range.range - end - [] - and SynValSig = - | ValSpfn of - attributes: SynAttributes * ident: Ident * - explicitValDecls: SynValTyparDecls * synType: SynType * - arity: SynValInfo * isInline: bool * isMutable: bool * - xmlDoc: XmlDoc.PreXmlDoc * accessibility: SynAccess option * - synExpr: SynExpr option * range: Range.range - with - member RangeOfId : Range.range - member SynInfo : SynValInfo - member SynType : SynType - end - [] - and SynValInfo = - | SynValInfo of - curriedArgInfos: SynArgInfo list list * returnInfo: SynArgInfo - with - member ArgNames : string list - member CurriedArgInfos : SynArgInfo list list - end - [] - and SynArgInfo = - | SynArgInfo of - attributes: SynAttributes * optional: bool * ident: Ident option - with - member Ident : Ident option - end - [] - and SynValTyparDecls = - | SynValTyparDecls of - typars: SynTyparDecl list * canInfer: bool * - constraints: SynTypeConstraint list - and SynReturnInfo = - | SynReturnInfo of returnType: SynType * SynArgInfo * range: Range.range - [] - and SynExceptionDefnRepr = - | SynExceptionDefnRepr of - attributes: SynAttributes * caseName: SynUnionCase * - longId: LongIdent option * xmlDoc: XmlDoc.PreXmlDoc * - accessibility: SynAccess option * range: Range.range - with - member Range : Range.range - end - [] - and SynExceptionDefn = - | SynExceptionDefn of - exnRepr: SynExceptionDefnRepr * members: SynMemberDefns * - range: Range.range - with - member Range : Range.range - end - [] - and SynTypeDefnRepr = - | ObjectModel of - kind: SynTypeDefnKind * members: SynMemberDefns * range: Range.range - | Simple of simpleRepr: SynTypeDefnSimpleRepr * range: Range.range - | Exception of exnRepr: SynExceptionDefnRepr - with - member Range : Range.range - end - [] - and SynTypeDefn = - | TypeDefn of - typeInfo: SynComponentInfo * typeRepr: SynTypeDefnRepr * - members: SynMemberDefns * range: Range.range - with - member Range : Range.range - end - [] - and SynMemberDefn = - | Open of target: SynOpenDeclTarget * range: Range.range - | Member of memberDefn: SynBinding * range: Range.range - | ImplicitCtor of - accessibility: SynAccess option * attributes: SynAttributes * - ctorArgs: SynSimplePats * selfIdentifier: Ident option * - doc: XmlDoc.PreXmlDoc * range: Range.range - | ImplicitInherit of - inheritType: SynType * inheritArgs: SynExpr * inheritAlias: Ident option * - range: Range.range - | LetBindings of - bindings: SynBinding list * isStatic: bool * isRecursive: bool * - range: Range.range - | AbstractSlot of - slotSig: SynValSig * flags: MemberFlags * range: Range.range - | Interface of - interfaceType: SynType * members: SynMemberDefns option * - range: Range.range - | Inherit of - baseType: SynType * asIdent: Ident option * range: Range.range - | ValField of fieldInfo: SynField * range: Range.range - | NestedType of - typeDefn: SynTypeDefn * accessibility: SynAccess option * - range: Range.range - | AutoProperty of - attributes: SynAttributes * isStatic: bool * ident: Ident * - typeOpt: SynType option * propKind: MemberKind * - memberFlags: MemberKind -> MemberFlags * xmlDoc: XmlDoc.PreXmlDoc * - accessibility: SynAccess option * synExpr: SynExpr * - getSetRange: Range.range option * range: Range.range - with - member Range : Range.range - end - and SynMemberDefns = SynMemberDefn list - [] - and SynModuleDecl = - | ModuleAbbrev of ident: Ident * longId: LongIdent * range: Range.range - | NestedModule of - moduleInfo: SynComponentInfo * isRecursive: bool * - decls: SynModuleDecl list * isContinuing: bool * range: Range.range - | Let of - isRecursive: bool * bindings: SynBinding list * range: Range.range - | DoExpr of - spInfo: DebugPointForBinding * expr: SynExpr * range: Range.range - | Types of typeDefns: SynTypeDefn list * range: Range.range - | Exception of exnDefn: SynExceptionDefn * range: Range.range - | Open of target: SynOpenDeclTarget * range: Range.range - | Attributes of attributes: SynAttributes * range: Range.range - | HashDirective of hashDirective: ParsedHashDirective * range: Range.range - | NamespaceFragment of fragment: SynModuleOrNamespace - with - member Range : Range.range - end - [] - and SynOpenDeclTarget = - | ModuleOrNamespace of longId: LongIdent * range: Range.range - | Type of typeName: SynType * range: Range.range - with - member Range : Range.range - end - [] - and SynExceptionSig = - | SynExceptionSig of - exnRepr: SynExceptionDefnRepr * members: SynMemberSig list * - range: Range.range - [] - and SynModuleSigDecl = - | ModuleAbbrev of ident: Ident * longId: LongIdent * range: Range.range - | NestedModule of - moduleInfo: SynComponentInfo * isRecursive: bool * - moduleDecls: SynModuleSigDecl list * range: Range.range - | Val of valSig: SynValSig * range: Range.range - | Types of types: SynTypeDefnSig list * range: Range.range - | Exception of exnSig: SynExceptionSig * range: Range.range - | Open of target: SynOpenDeclTarget * range: Range.range - | HashDirective of hashDirective: ParsedHashDirective * range: Range.range - | NamespaceFragment of SynModuleOrNamespaceSig - with - member Range : Range.range - end - [] - and SynModuleOrNamespaceKind = - | NamedModule - | AnonModule - | DeclaredNamespace - | GlobalNamespace - with - member IsModule : bool - end - [] - and SynModuleOrNamespace = - | SynModuleOrNamespace of - longId: LongIdent * isRecursive: bool * kind: SynModuleOrNamespaceKind * - decls: SynModuleDecl list * xmlDoc: XmlDoc.PreXmlDoc * - attribs: SynAttributes * accessibility: SynAccess option * - range: Range.range - with - member Range : Range.range - end - [] - and SynModuleOrNamespaceSig = - | SynModuleOrNamespaceSig of - longId: LongIdent * isRecursive: bool * kind: SynModuleOrNamespaceKind * - decls: SynModuleSigDecl list * xmlDoc: XmlDoc.PreXmlDoc * - attribs: SynAttributes * accessibility: SynAccess option * - range: Range.range - [] - and ParsedHashDirective = - | ParsedHashDirective of - ident: string * args: string list * range: Range.range - [] - and ParsedImplFileFragment = - | AnonModule of decls: SynModuleDecl list * range: Range.range - | NamedModule of namedModule: SynModuleOrNamespace - | NamespaceFragment of - longId: LongIdent * isRecursive: bool * kind: SynModuleOrNamespaceKind * - decls: SynModuleDecl list * xmlDoc: XmlDoc.PreXmlDoc * - attributes: SynAttributes * range: Range.range - [] - and ParsedSigFileFragment = - | AnonModule of decls: SynModuleSigDecl list * range: Range.range - | NamedModule of namedModule: SynModuleOrNamespaceSig - | NamespaceFragment of - longId: LongIdent * isRecursive: bool * kind: SynModuleOrNamespaceKind * - decls: SynModuleSigDecl list * xmlDoc: XmlDoc.PreXmlDoc * - attributes: SynAttributes * range: Range.range - [] - and ParsedFsiInteraction = - | IDefns of defns: SynModuleDecl list * range: Range.range - | IHash of hashDirective: ParsedHashDirective * range: Range.range - [] - and ParsedImplFile = - | ParsedImplFile of - hashDirectives: ParsedHashDirective list * - fragments: ParsedImplFileFragment list - [] - and ParsedSigFile = - | ParsedSigFile of - hashDirectives: ParsedHashDirective list * - fragments: ParsedSigFileFragment list - [] - and ScopedPragma = | WarningOff of range: Range.range * warningNumber: int - [] - and QualifiedNameOfFile = - | QualifiedNameOfFile of Ident - with - member Id : Ident - member Range : Range.range - member Text : string - end - [] - and ParsedImplFileInput = - | ParsedImplFileInput of - fileName: string * isScript: bool * - qualifiedNameOfFile: QualifiedNameOfFile * - scopedPragmas: ScopedPragma list * - hashDirectives: ParsedHashDirective list * - modules: SynModuleOrNamespace list * isLastCompiland: bool * bool - [] - and ParsedSigFileInput = - | ParsedSigFileInput of - fileName: string * qualifiedNameOfFile: QualifiedNameOfFile * - scopedPragmas: ScopedPragma list * - hashDirectives: ParsedHashDirective list * - modules: SynModuleOrNamespaceSig list - [] - and ParsedInput = - | ImplFile of ParsedImplFileInput - | SigFile of ParsedSigFileInput - with - member Range : Range.range - end - end - -namespace FSharp.Compiler - module SyntaxTreeOps = begin - [] - type SynArgNameGenerator = - class - new : unit -> SynArgNameGenerator - member New : unit -> string - member Reset : unit -> unit - end - val ident : s:string * r:Range.range -> SyntaxTree.Ident - val textOfId : id:SyntaxTree.Ident -> string - val pathOfLid : lid:SyntaxTree.Ident list -> string list - val arrPathOfLid : lid:SyntaxTree.Ident list -> string [] - val textOfPath : path:seq -> string - val textOfLid : lid:SyntaxTree.Ident list -> string - val rangeOfLid : lid:SyntaxTree.Ident list -> Range.range - val mkSynId : m:Range.range -> s:string -> SyntaxTree.Ident - val pathToSynLid : m:Range.range -> p:string list -> SyntaxTree.Ident list - val mkSynIdGet : m:Range.range -> n:string -> SyntaxTree.SynExpr - val mkSynLidGet : - m:Range.range -> path:string list -> n:string -> SyntaxTree.SynExpr - val mkSynIdGetWithAlt : - m:Range.range -> - id:SyntaxTree.Ident -> - altInfo:SyntaxTree.SynSimplePatAlternativeIdInfo ref option -> - SyntaxTree.SynExpr - val mkSynSimplePatVar : - isOpt:bool -> id:SyntaxTree.Ident -> SyntaxTree.SynSimplePat - val mkSynCompGenSimplePatVar : - id:SyntaxTree.Ident -> SyntaxTree.SynSimplePat - val ( |LongOrSingleIdent|_| ) : - inp:SyntaxTree.SynExpr -> - (bool * SyntaxTree.LongIdentWithDots * - SyntaxTree.SynSimplePatAlternativeIdInfo ref option * Range.range) option - val ( |SingleIdent|_| ) : inp:SyntaxTree.SynExpr -> SyntaxTree.Ident option - val IsControlFlowExpression : e:SyntaxTree.SynExpr -> bool - val mkAnonField : ty:SyntaxTree.SynType -> SyntaxTree.SynField - val mkNamedField : - ident:SyntaxTree.Ident * ty:SyntaxTree.SynType * m:Range.range -> - SyntaxTree.SynField - val mkSynPatVar : - vis:SyntaxTree.SynAccess option -> - id:SyntaxTree.Ident -> SyntaxTree.SynPat - val mkSynThisPatVar : id:SyntaxTree.Ident -> SyntaxTree.SynPat - val mkSynPatMaybeVar : - lidwd:SyntaxTree.LongIdentWithDots -> - vis:SyntaxTree.SynAccess option -> m:Range.range -> SyntaxTree.SynPat - val ( |SynPatForConstructorDecl|_| ) : - x:SyntaxTree.SynPat -> SyntaxTree.SynPat option - val ( |SynPatForNullaryArgs|_| ) : x:SyntaxTree.SynPat -> unit option - val ( |SynExprErrorSkip| ) : p:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val ( |SynExprParen|_| ) : - e:SyntaxTree.SynExpr -> - (SyntaxTree.SynExpr * Range.range * Range.range option * Range.range) option - val ( |SynPatErrorSkip| ) : p:SyntaxTree.SynPat -> SyntaxTree.SynPat - val SimplePatOfPat : - synArgNameGenerator:SynArgNameGenerator -> - p:SyntaxTree.SynPat -> - SyntaxTree.SynSimplePat * - (SyntaxTree.SynExpr -> SyntaxTree.SynExpr) option - val appFunOpt : funOpt:('a -> 'a) option -> x:'a -> 'a - val composeFunOpt : - funOpt1:('a -> 'a) option -> - funOpt2:('a -> 'a) option -> ('a -> 'a) option - val SimplePatsOfPat : - synArgNameGenerator:SynArgNameGenerator -> - p:SyntaxTree.SynPat -> - SyntaxTree.SynSimplePats * - (SyntaxTree.SynExpr -> SyntaxTree.SynExpr) option - val PushPatternToExpr : - synArgNameGenerator:SynArgNameGenerator -> - isMember:bool -> - pat:SyntaxTree.SynPat -> - rhs:SyntaxTree.SynExpr -> - SyntaxTree.SynSimplePats * SyntaxTree.SynExpr - val private isSimplePattern : pat:SyntaxTree.SynPat -> bool - val PushCurriedPatternsToExpr : - synArgNameGenerator:SynArgNameGenerator -> - wholem:Range.range -> - isMember:bool -> - pats:SyntaxTree.SynPat list -> - rhs:SyntaxTree.SynExpr -> - SyntaxTree.SynSimplePats list * SyntaxTree.SynExpr - val opNameParenGet : string - val opNameQMark : string - val mkSynOperator : opm:Range.range -> oper:string -> SyntaxTree.SynExpr - val mkSynInfix : - opm:Range.range -> - l:SyntaxTree.SynExpr -> - oper:string -> r:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val mkSynBifix : - m:Range.range -> - oper:string -> - x1:SyntaxTree.SynExpr -> x2:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val mkSynTrifix : - m:Range.range -> - oper:string -> - x1:SyntaxTree.SynExpr -> - x2:SyntaxTree.SynExpr -> x3:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val mkSynPrefixPrim : - opm:Range.range -> - m:Range.range -> - oper:string -> x:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val mkSynPrefix : - opm:Range.range -> - m:Range.range -> - oper:string -> x:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val mkSynCaseName : m:Range.range -> n:string -> SyntaxTree.Ident list - val mkSynApp1 : - f:SyntaxTree.SynExpr -> - x1:SyntaxTree.SynExpr -> m:Range.range -> SyntaxTree.SynExpr - val mkSynApp2 : - f:SyntaxTree.SynExpr -> - x1:SyntaxTree.SynExpr -> - x2:SyntaxTree.SynExpr -> m:Range.range -> SyntaxTree.SynExpr - val mkSynApp3 : - f:SyntaxTree.SynExpr -> - x1:SyntaxTree.SynExpr -> - x2:SyntaxTree.SynExpr -> - x3:SyntaxTree.SynExpr -> m:Range.range -> SyntaxTree.SynExpr - val mkSynApp4 : - f:SyntaxTree.SynExpr -> - x1:SyntaxTree.SynExpr -> - x2:SyntaxTree.SynExpr -> - x3:SyntaxTree.SynExpr -> - x4:SyntaxTree.SynExpr -> m:Range.range -> SyntaxTree.SynExpr - val mkSynApp5 : - f:SyntaxTree.SynExpr -> - x1:SyntaxTree.SynExpr -> - x2:SyntaxTree.SynExpr -> - x3:SyntaxTree.SynExpr -> - x4:SyntaxTree.SynExpr -> - x5:SyntaxTree.SynExpr -> m:Range.range -> SyntaxTree.SynExpr - val mkSynDotParenSet : - m:Range.range -> - a:SyntaxTree.SynExpr -> - b:SyntaxTree.SynExpr -> c:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val mkSynDotBrackGet : - m:Range.range -> - mDot:Range.range -> - a:SyntaxTree.SynExpr -> - b:SyntaxTree.SynExpr -> fromEnd:bool -> SyntaxTree.SynExpr - val mkSynQMarkSet : - m:Range.range -> - a:SyntaxTree.SynExpr -> - b:SyntaxTree.SynExpr -> c:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val mkSynDotBrackSliceGet : - m:Range.range -> - mDot:Range.range -> - arr:SyntaxTree.SynExpr -> - sliceArg:SyntaxTree.SynIndexerArg -> SyntaxTree.SynExpr - val mkSynDotBrackSeqSliceGet : - m:Range.range -> - mDot:Range.range -> - arr:SyntaxTree.SynExpr -> - argsList:SyntaxTree.SynIndexerArg list -> SyntaxTree.SynExpr - val mkSynDotParenGet : - lhsm:Range.range -> - dotm:Range.range -> - a:SyntaxTree.SynExpr -> b:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val mkSynUnit : m:Range.range -> SyntaxTree.SynExpr - val mkSynUnitPat : m:Range.range -> SyntaxTree.SynPat - val mkSynDelay : m:Range.range -> e:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val mkSynAssign : - l:SyntaxTree.SynExpr -> r:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val mkSynDot : - dotm:Range.range -> - m:Range.range -> - l:SyntaxTree.SynExpr -> r:SyntaxTree.Ident -> SyntaxTree.SynExpr - val mkSynDotMissing : - dotm:Range.range -> - m:Range.range -> l:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val mkSynFunMatchLambdas : - synArgNameGenerator:SynArgNameGenerator -> - isMember:bool -> - wholem:Range.range -> - ps:SyntaxTree.SynPat list -> - e:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val arbExpr : debugStr:string * range:Range.range -> SyntaxTree.SynExpr - val unionRangeWithListBy : - projectRangeFromThing:('a -> Range.range) -> - m:Range.range -> listOfThing:'a list -> Range.range - val mkAttributeList : - attrs:SyntaxTree.SynAttribute list -> - range:Range.range -> SyntaxTree.SynAttributeList list - val ConcatAttributesLists : - attrsLists:SyntaxTree.SynAttributeList list -> - SyntaxTree.SynAttribute list - val ( |Attributes| ) : - synAttributes:SyntaxTree.SynAttributeList list -> - SyntaxTree.SynAttribute list - val rangeOfNonNilAttrs : attrs:SyntaxTree.SynAttributes -> Range.range - val stripParenTypes : synType:SyntaxTree.SynType -> SyntaxTree.SynType - val ( |StripParenTypes| ) : synType:SyntaxTree.SynType -> SyntaxTree.SynType - module SynInfo = begin - val unnamedTopArg1 : SyntaxTree.SynArgInfo - val unnamedTopArg : SyntaxTree.SynArgInfo list - val unitArgData : SyntaxTree.SynArgInfo list - val unnamedRetVal : SyntaxTree.SynArgInfo - val selfMetadata : SyntaxTree.SynArgInfo list - val HasNoArgs : SyntaxTree.SynValInfo -> bool - val IsOptionalArg : SyntaxTree.SynArgInfo -> bool - val HasOptionalArgs : SyntaxTree.SynValInfo -> bool - val IncorporateEmptyTupledArgForPropertyGetter : - SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo - val IncorporateSelfArg : SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo - val IncorporateSetterArg : SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo - val AritiesOfArgs : SyntaxTree.SynValInfo -> int list - val AttribsOfArgData : - SyntaxTree.SynArgInfo -> SyntaxTree.SynAttribute list - val InferSynArgInfoFromSimplePat : - attribs:SyntaxTree.SynAttributes -> - p:SyntaxTree.SynSimplePat -> SyntaxTree.SynArgInfo - val InferSynArgInfoFromSimplePats : - x:SyntaxTree.SynSimplePats -> SyntaxTree.SynArgInfo list - val InferSynArgInfoFromPat : - p:SyntaxTree.SynPat -> SyntaxTree.SynArgInfo list - val AdjustArgsForUnitElimination : - infosForArgs:SyntaxTree.SynArgInfo list list -> - SyntaxTree.SynArgInfo list list - val AdjustMemberArgs : - memFlags:SyntaxTree.MemberKind -> - infosForArgs:'a list list -> 'a list list - val InferLambdaArgs : - origRhsExpr:SyntaxTree.SynExpr -> SyntaxTree.SynArgInfo list list - val InferSynReturnData : - retInfo:SyntaxTree.SynReturnInfo option -> SyntaxTree.SynArgInfo - val private emptySynValInfo : SyntaxTree.SynValInfo - val emptySynValData : SyntaxTree.SynValData - val InferSynValData : - memberFlagsOpt:SyntaxTree.MemberFlags option * - pat:SyntaxTree.SynPat option * retInfo:SyntaxTree.SynReturnInfo option * - origRhsExpr:SyntaxTree.SynExpr -> SyntaxTree.SynValData - end - val mkSynBindingRhs : - staticOptimizations:(SyntaxTree.SynStaticOptimizationConstraint list * - SyntaxTree.SynExpr) list -> - rhsExpr:SyntaxTree.SynExpr -> - mRhs:Range.range -> - retInfo:SyntaxTree.SynReturnInfo option -> - SyntaxTree.SynExpr * SyntaxTree.SynBindingReturnInfo option - val mkSynBinding : - xmlDoc:XmlDoc.PreXmlDoc * headPat:SyntaxTree.SynPat -> - vis:SyntaxTree.SynAccess option * isInline:bool * isMutable:bool * - mBind:Range.range * spBind:SyntaxTree.DebugPointForBinding * - retInfo:SyntaxTree.SynReturnInfo option * origRhsExpr:SyntaxTree.SynExpr * - mRhs:Range.range * - staticOptimizations:(SyntaxTree.SynStaticOptimizationConstraint list * - SyntaxTree.SynExpr) list * - attrs:SyntaxTree.SynAttributes * - memberFlagsOpt:SyntaxTree.MemberFlags option -> SyntaxTree.SynBinding - val NonVirtualMemberFlags : - k:SyntaxTree.MemberKind -> SyntaxTree.MemberFlags - val CtorMemberFlags : SyntaxTree.MemberFlags - val ClassCtorMemberFlags : SyntaxTree.MemberFlags - val OverrideMemberFlags : k:SyntaxTree.MemberKind -> SyntaxTree.MemberFlags - val AbstractMemberFlags : k:SyntaxTree.MemberKind -> SyntaxTree.MemberFlags - val StaticMemberFlags : k:SyntaxTree.MemberKind -> SyntaxTree.MemberFlags - val inferredTyparDecls : SyntaxTree.SynValTyparDecls - val noInferredTypars : SyntaxTree.SynValTyparDecls - val synExprContainsError : inpExpr:SyntaxTree.SynExpr -> bool - end - -namespace FSharp.Compiler - module ParseHelpers = begin - exception SyntaxError of obj * range: Range.range - exception IndentationProblem of string * Range.range - val warningStringOfCoords : line:int -> column:int -> string - val warningStringOfPos : p:Range.pos -> string - val internal posOfLexPosition : - p:Internal.Utilities.Text.Lexing.Position -> Range.pos - val internal mkSynRange : - p1:Internal.Utilities.Text.Lexing.Position -> - p2:Internal.Utilities.Text.Lexing.Position -> Range.range - type internal LexBuffer<'Char> with - member internal LexemeRange : Range.range - val internal lhs : - parseState:Internal.Utilities.Text.Parsing.IParseState -> Range.range - val internal rhs2 : - parseState:Internal.Utilities.Text.Parsing.IParseState -> - i:int -> j:int -> Range.range - val internal rhs : - parseState:Internal.Utilities.Text.Parsing.IParseState -> - i:int -> Range.range - type internal IParseState with - member internal SynArgNameGenerator : SyntaxTreeOps.SynArgNameGenerator - type internal IParseState with - member internal ResetSynArgNameGenerator : unit -> unit - module LexbufLocalXmlDocStore = begin - val private xmlDocKey : string - val internal ClearXmlDoc : lexbuf:UnicodeLexing.Lexbuf -> unit - val internal SaveXmlDocLine : - lexbuf:UnicodeLexing.Lexbuf * lineText:string * range:Range.range -> - unit - val internal GrabXmlDocBeforeMarker : - lexbuf:UnicodeLexing.Lexbuf * markerRange:Range.range -> - XmlDoc.PreXmlDoc - end - type LexerIfdefStackEntry = - | IfDefIf - | IfDefElse - type LexerIfdefStackEntries = (LexerIfdefStackEntry * Range.range) list - type LexerIfdefStack = LexerIfdefStackEntries - type LexerEndlineContinuation = - | Token - | Skip of int * range: Range.range - type LexerIfdefExpression = - | IfdefAnd of LexerIfdefExpression * LexerIfdefExpression - | IfdefOr of LexerIfdefExpression * LexerIfdefExpression - | IfdefNot of LexerIfdefExpression - | IfdefId of string - val LexerIfdefEval : - lookup:(string -> bool) -> _arg1:LexerIfdefExpression -> bool - [] - type LexerStringStyle = - | Verbatim - | TripleQuote - | SingleQuote - [] - type LexerStringKind = - { IsByteString: bool - IsInterpolated: bool - IsInterpolatedFirst: bool } - with - static member ByteString : LexerStringKind - static member InterpolatedStringFirst : LexerStringKind - static member InterpolatedStringPart : LexerStringKind - static member String : LexerStringKind - end - type LexerInterpolatedStringNesting = - (int * LexerStringStyle * Range.range) list - [] - type LexerContinuation = - | Token of - ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting - | IfDefSkip of - ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * - int * range: Range.range - | String of - ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * - style: LexerStringStyle * kind: LexerStringKind * range: Range.range - | Comment of - ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * - int * range: Range.range - | SingleLineComment of - ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * - int * range: Range.range - | StringInComment of - ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * - style: LexerStringStyle * int * range: Range.range - | MLOnly of - ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * - range: Range.range - | EndLine of - ifdef: LexerIfdefStackEntries * nesting: LexerInterpolatedStringNesting * - LexerEndlineContinuation - with - member LexerIfdefStack : LexerIfdefStackEntries - member LexerInterpStringNesting : LexerInterpolatedStringNesting - static member Default : LexerContinuation - end - and LexCont = LexerContinuation - val internal internalParseAssemblyCodeInstructions : - s:string -> - isFeatureSupported:(Features.LanguageFeature -> bool) -> - m:Range.range -> AbstractIL.IL.ILInstr [] - val ParseAssemblyCodeInstructions : - s:string -> m:Range.range -> AbstractIL.IL.ILInstr [] - val internal internalParseAssemblyCodeType : - s:string -> - isFeatureSupported:(Features.LanguageFeature -> bool) -> - m:Range.range -> AbstractIL.IL.ILType - val ParseAssemblyCodeType : - s:string -> m:Range.range -> AbstractIL.IL.ILType - end - -namespace FSharp.Compiler - module internal PPParser = begin - val dummy : ParseHelpers.LexerIfdefExpression - val doNothing : 'a -> dflt:'b -> 'b - val fail : - ps:Internal.Utilities.Text.Parsing.IParseState -> - i:int -> int * string -> ParseHelpers.LexerIfdefExpression - type token = - | OP_NOT - | OP_AND - | OP_OR - | LPAREN - | RPAREN - | PRELUDE - | EOF - | ID of string - type tokenId = - | TOKEN_OP_NOT - | TOKEN_OP_AND - | TOKEN_OP_OR - | TOKEN_LPAREN - | TOKEN_RPAREN - | TOKEN_PRELUDE - | TOKEN_EOF - | TOKEN_ID - | TOKEN_end_of_input - | TOKEN_error - type nonTerminalId = - | NONTERM__startstart - | NONTERM_start - | NONTERM_Recover - | NONTERM_Full - | NONTERM_Expr - val tagOfToken : t:token -> int - val tokenTagToTokenId : tokenIdx:int -> tokenId - val prodIdxToNonTerminal : prodIdx:int -> nonTerminalId - val _fsyacc_endOfInputTag : int - val _fsyacc_tagOfErrorTerminal : int - val token_to_string : t:token -> string - val _fsyacc_dataOfToken : t:token -> System.Object - val _fsyacc_gotos : uint16 [] - val _fsyacc_sparseGotoTableRowOffsets : uint16 [] - val _fsyacc_stateToProdIdxsTableElements : uint16 [] - val _fsyacc_stateToProdIdxsTableRowOffsets : uint16 [] - val _fsyacc_action_rows : int - val _fsyacc_actionTableElements : uint16 [] - val _fsyacc_actionTableRowOffsets : uint16 [] - val _fsyacc_reductionSymbolCounts : uint16 [] - val _fsyacc_productionToNonTerminalTable : uint16 [] - val _fsyacc_immediateActions : uint16 [] - val _fsyacc_reductions : - unit -> (Internal.Utilities.Text.Parsing.IParseState -> obj) [] - val tables : unit -> Internal.Utilities.Text.Parsing.Tables - val engine : - lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - startState:int -> obj - val start : - lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - ParseHelpers.LexerIfdefExpression - end - -namespace FSharp.Compiler - module internal Parser = begin - val debugPrint : s:string -> unit - val exprFromParseError : e:SyntaxTree.SynExpr -> SyntaxTree.SynExpr - val patFromParseError : e:SyntaxTree.SynPat -> SyntaxTree.SynPat - val mkSynOptionalExpr : - m:Range.range -> xopt:SyntaxTree.SynExpr option -> SyntaxTree.SynExpr - val rebindRanges : - 'a * 'b -> - fields:(('a * 'b) * 'c) list -> lastSep:'c -> ('a * 'b * 'c) list - val mkUnderscoreRecdField : - m:Range.range -> SyntaxTree.LongIdentWithDots * bool - val mkRecdField : lidwd:'a -> 'a * bool - val mkSynDoBinding : - vis:'a option * strict:bool * expr:SyntaxTree.SynExpr * m:Range.range -> - SyntaxTree.SynBinding - val mkSynDoDecl : e:SyntaxTree.SynExpr -> SyntaxTree.SynModuleDecl - val addAttribs : - attrs:SyntaxTree.SynAttributes -> p:SyntaxTree.SynPat -> SyntaxTree.SynPat - val parse_error_rich : - (Internal.Utilities.Text.Parsing.ParseErrorContext<'a> -> unit) option - val reportParseErrorAt : m:Range.range -> int * string -> unit - val unionRangeWithPos : r:Range.range -> p:Range.pos -> Range.range - val raiseParseErrorAt : m:Range.range -> int * string -> 'a - val checkEndOfFileError : t:ParseHelpers.LexerContinuation -> unit - type BindingSet = - | BindingSetPreAttrs of - Range.range * bool * bool * - (SyntaxTree.SynAttributes -> SyntaxTree.SynAccess option -> - SyntaxTree.SynAttributes * SyntaxTree.SynBinding list) * Range.range - val mkClassMemberLocalBindings : - isStatic:bool * initialRangeOpt:Range.range option * - attrs:SyntaxTree.SynAttributes * vis:SyntaxTree.SynAccess option * - BindingSet -> SyntaxTree.SynMemberDefn - val mkLocalBindings : - mWhole:Range.range * BindingSet * body:SyntaxTree.SynExpr -> - SyntaxTree.SynExpr - val mkDefnBindings : - mWhole:Range.range * BindingSet * attrs:SyntaxTree.SynAttributes * - vis:SyntaxTree.SynAccess option * attrsm:Range.range -> - SyntaxTree.SynModuleDecl list - val idOfPat : - parseState:Internal.Utilities.Text.Parsing.IParseState -> - m:Range.range -> p:SyntaxTree.SynPat -> SyntaxTree.Ident - val checkForMultipleAugmentations : - m:Range.range -> a1:'a list -> a2:'a list -> 'a list - val grabXmlDoc : - parseState:Internal.Utilities.Text.Parsing.IParseState * elemIdx:int -> - XmlDoc.PreXmlDoc - val rangeOfLongIdent : lid:SyntaxTree.LongIdent -> Range.range - type token = - | HASH_IF of (Range.range * string * ParseHelpers.LexerContinuation) - | HASH_ELSE of (Range.range * string * ParseHelpers.LexerContinuation) - | HASH_ENDIF of (Range.range * string * ParseHelpers.LexerContinuation) - | COMMENT of ParseHelpers.LexerContinuation - | WHITESPACE of ParseHelpers.LexerContinuation - | HASH_LINE of ParseHelpers.LexerContinuation - | HASH_LIGHT of ParseHelpers.LexerContinuation - | INACTIVECODE of ParseHelpers.LexerContinuation - | LINE_COMMENT of ParseHelpers.LexerContinuation - | STRING_TEXT of ParseHelpers.LexerContinuation - | EOF of ParseHelpers.LexerContinuation - | LEX_FAILURE of string - | ODUMMY of token - | FIXED - | OINTERFACE_MEMBER - | OBLOCKEND - | OBLOCKEND_COMING_SOON - | OBLOCKEND_IS_HERE - | ORIGHT_BLOCK_END - | ODECLEND - | OEND - | OBLOCKSEP - | OBLOCKBEGIN - | ORESET - | OFUN - | OFUNCTION - | OWITH - | OELSE - | OTHEN - | ODO_BANG - | ODO - | OAND_BANG of bool - | OBINDER of string - | OLET of bool - | HIGH_PRECEDENCE_TYAPP - | HIGH_PRECEDENCE_PAREN_APP - | HIGH_PRECEDENCE_BRACK_APP - | TYPE_COMING_SOON - | TYPE_IS_HERE - | MODULE_COMING_SOON - | MODULE_IS_HERE - | EXTERN - | VOID - | PUBLIC - | PRIVATE - | INTERNAL - | GLOBAL - | STATIC - | MEMBER - | CLASS - | ABSTRACT - | OVERRIDE - | DEFAULT - | CONSTRUCTOR - | INHERIT - | GREATER_RBRACK - | STRUCT - | SIG - | BAR - | RBRACK - | RBRACE_COMING_SOON - | RBRACE_IS_HERE - | MINUS - | DOLLAR - | BAR_RBRACK - | BAR_RBRACE - | UNDERSCORE - | SEMICOLON_SEMICOLON - | LARROW - | EQUALS - | LBRACK - | LBRACK_BAR - | LBRACE_BAR - | LBRACK_LESS - | QMARK - | QMARK_QMARK - | DOT - | COLON - | COLON_COLON - | COLON_GREATER - | COLON_QMARK_GREATER - | COLON_QMARK - | COLON_EQUALS - | SEMICOLON - | WHEN - | WHILE - | WITH - | HASH - | AMP - | AMP_AMP - | QUOTE - | LPAREN - | RPAREN - | RPAREN_COMING_SOON - | RPAREN_IS_HERE - | STAR - | COMMA - | RARROW - | GREATER_BAR_RBRACK - | LPAREN_STAR_RPAREN - | OPEN - | OR - | REC - | THEN - | TO - | TRUE - | TRY - | TYPE - | VAL - | INLINE - | INTERFACE - | INSTANCE - | CONST - | LAZY - | OLAZY - | MATCH - | MATCH_BANG - | MUTABLE - | NEW - | OF - | EXCEPTION - | FALSE - | FOR - | FUN - | FUNCTION - | IF - | IN - | JOIN_IN - | FINALLY - | DO_BANG - | AND - | AS - | ASSERT - | OASSERT - | ASR - | BEGIN - | DO - | DONE - | DOWNTO - | ELSE - | ELIF - | END - | DOT_DOT - | DOT_DOT_HAT - | BAR_BAR - | UPCAST - | DOWNCAST - | NULL - | RESERVED - | MODULE - | NAMESPACE - | DELEGATE - | CONSTRAINT - | BASE - | LQUOTE of (string * bool) - | RQUOTE of (string * bool) - | RQUOTE_DOT of (string * bool) - | PERCENT_OP of string - | BINDER of string - | LESS of bool - | GREATER of bool - | LET of bool - | YIELD of bool - | YIELD_BANG of bool - | AND_BANG of bool - | BIGNUM of (string * string) - | DECIMAL of System.Decimal - | CHAR of char - | IEEE64 of double - | IEEE32 of single - | UNATIVEINT of uint64 - | UINT64 of uint64 - | UINT32 of uint32 - | UINT16 of uint16 - | UINT8 of byte - | NATIVEINT of (int64 * bool) - | INT64 of (int64 * bool) - | INT32 of (int32 * bool) - | INT32_DOT_DOT of (int32 * bool) - | INT16 of (int16 * bool) - | INT8 of (sbyte * bool) - | FUNKY_OPERATOR_NAME of string - | ADJACENT_PREFIX_OP of string - | PLUS_MINUS_OP of string - | INFIX_AMP_OP of string - | INFIX_STAR_DIV_MOD_OP of string - | PREFIX_OP of string - | INFIX_BAR_OP of string - | INFIX_AT_HAT_OP of string - | INFIX_COMPARE_OP of string - | INFIX_STAR_STAR_OP of string - | IDENT of string - | KEYWORD_STRING of string - | LBRACE of ParseHelpers.LexerContinuation - | RBRACE of ParseHelpers.LexerContinuation - | INTERP_STRING_END of (string * ParseHelpers.LexerContinuation) - | INTERP_STRING_PART of (string * ParseHelpers.LexerContinuation) - | INTERP_STRING_BEGIN_PART of (string * ParseHelpers.LexerContinuation) - | INTERP_STRING_BEGIN_END of (string * ParseHelpers.LexerContinuation) - | STRING of (string * ParseHelpers.LexerContinuation) - | BYTEARRAY of (byte [] * ParseHelpers.LexerContinuation) - type tokenId = - | TOKEN_HASH_IF - | TOKEN_HASH_ELSE - | TOKEN_HASH_ENDIF - | TOKEN_COMMENT - | TOKEN_WHITESPACE - | TOKEN_HASH_LINE - | TOKEN_HASH_LIGHT - | TOKEN_INACTIVECODE - | TOKEN_LINE_COMMENT - | TOKEN_STRING_TEXT - | TOKEN_EOF - | TOKEN_LEX_FAILURE - | TOKEN_ODUMMY - | TOKEN_FIXED - | TOKEN_OINTERFACE_MEMBER - | TOKEN_OBLOCKEND - | TOKEN_OBLOCKEND_COMING_SOON - | TOKEN_OBLOCKEND_IS_HERE - | TOKEN_ORIGHT_BLOCK_END - | TOKEN_ODECLEND - | TOKEN_OEND - | TOKEN_OBLOCKSEP - | TOKEN_OBLOCKBEGIN - | TOKEN_ORESET - | TOKEN_OFUN - | TOKEN_OFUNCTION - | TOKEN_OWITH - | TOKEN_OELSE - | TOKEN_OTHEN - | TOKEN_ODO_BANG - | TOKEN_ODO - | TOKEN_OAND_BANG - | TOKEN_OBINDER - | TOKEN_OLET - | TOKEN_HIGH_PRECEDENCE_TYAPP - | TOKEN_HIGH_PRECEDENCE_PAREN_APP - | TOKEN_HIGH_PRECEDENCE_BRACK_APP - | TOKEN_TYPE_COMING_SOON - | TOKEN_TYPE_IS_HERE - | TOKEN_MODULE_COMING_SOON - | TOKEN_MODULE_IS_HERE - | TOKEN_EXTERN - | TOKEN_VOID - | TOKEN_PUBLIC - | TOKEN_PRIVATE - | TOKEN_INTERNAL - | TOKEN_GLOBAL - | TOKEN_STATIC - | TOKEN_MEMBER - | TOKEN_CLASS - | TOKEN_ABSTRACT - | TOKEN_OVERRIDE - | TOKEN_DEFAULT - | TOKEN_CONSTRUCTOR - | TOKEN_INHERIT - | TOKEN_GREATER_RBRACK - | TOKEN_STRUCT - | TOKEN_SIG - | TOKEN_BAR - | TOKEN_RBRACK - | TOKEN_RBRACE_COMING_SOON - | TOKEN_RBRACE_IS_HERE - | TOKEN_MINUS - | TOKEN_DOLLAR - | TOKEN_BAR_RBRACK - | TOKEN_BAR_RBRACE - | TOKEN_UNDERSCORE - | TOKEN_SEMICOLON_SEMICOLON - | TOKEN_LARROW - | TOKEN_EQUALS - | TOKEN_LBRACK - | TOKEN_LBRACK_BAR - | TOKEN_LBRACE_BAR - | TOKEN_LBRACK_LESS - | TOKEN_QMARK - | TOKEN_QMARK_QMARK - | TOKEN_DOT - | TOKEN_COLON - | TOKEN_COLON_COLON - | TOKEN_COLON_GREATER - | TOKEN_COLON_QMARK_GREATER - | TOKEN_COLON_QMARK - | TOKEN_COLON_EQUALS - | TOKEN_SEMICOLON - | TOKEN_WHEN - | TOKEN_WHILE - | TOKEN_WITH - | TOKEN_HASH - | TOKEN_AMP - | TOKEN_AMP_AMP - | TOKEN_QUOTE - | TOKEN_LPAREN - | TOKEN_RPAREN - | TOKEN_RPAREN_COMING_SOON - | TOKEN_RPAREN_IS_HERE - | TOKEN_STAR - | TOKEN_COMMA - | TOKEN_RARROW - | TOKEN_GREATER_BAR_RBRACK - | TOKEN_LPAREN_STAR_RPAREN - | TOKEN_OPEN - | TOKEN_OR - | TOKEN_REC - | TOKEN_THEN - | TOKEN_TO - | TOKEN_TRUE - | TOKEN_TRY - | TOKEN_TYPE - | TOKEN_VAL - | TOKEN_INLINE - | TOKEN_INTERFACE - | TOKEN_INSTANCE - | TOKEN_CONST - | TOKEN_LAZY - | TOKEN_OLAZY - | TOKEN_MATCH - | TOKEN_MATCH_BANG - | TOKEN_MUTABLE - | TOKEN_NEW - | TOKEN_OF - | TOKEN_EXCEPTION - | TOKEN_FALSE - | TOKEN_FOR - | TOKEN_FUN - | TOKEN_FUNCTION - | TOKEN_IF - | TOKEN_IN - | TOKEN_JOIN_IN - | TOKEN_FINALLY - | TOKEN_DO_BANG - | TOKEN_AND - | TOKEN_AS - | TOKEN_ASSERT - | TOKEN_OASSERT - | TOKEN_ASR - | TOKEN_BEGIN - | TOKEN_DO - | TOKEN_DONE - | TOKEN_DOWNTO - | TOKEN_ELSE - | TOKEN_ELIF - | TOKEN_END - | TOKEN_DOT_DOT - | TOKEN_DOT_DOT_HAT - | TOKEN_BAR_BAR - | TOKEN_UPCAST - | TOKEN_DOWNCAST - | TOKEN_NULL - | TOKEN_RESERVED - | TOKEN_MODULE - | TOKEN_NAMESPACE - | TOKEN_DELEGATE - | TOKEN_CONSTRAINT - | TOKEN_BASE - | TOKEN_LQUOTE - | TOKEN_RQUOTE - | TOKEN_RQUOTE_DOT - | TOKEN_PERCENT_OP - | TOKEN_BINDER - | TOKEN_LESS - | TOKEN_GREATER - | TOKEN_LET - | TOKEN_YIELD - | TOKEN_YIELD_BANG - | TOKEN_AND_BANG - | TOKEN_BIGNUM - | TOKEN_DECIMAL - | TOKEN_CHAR - | TOKEN_IEEE64 - | TOKEN_IEEE32 - | TOKEN_UNATIVEINT - | TOKEN_UINT64 - | TOKEN_UINT32 - | TOKEN_UINT16 - | TOKEN_UINT8 - | TOKEN_NATIVEINT - | TOKEN_INT64 - | TOKEN_INT32 - | TOKEN_INT32_DOT_DOT - | TOKEN_INT16 - | TOKEN_INT8 - | TOKEN_FUNKY_OPERATOR_NAME - | TOKEN_ADJACENT_PREFIX_OP - | TOKEN_PLUS_MINUS_OP - | TOKEN_INFIX_AMP_OP - | TOKEN_INFIX_STAR_DIV_MOD_OP - | TOKEN_PREFIX_OP - | TOKEN_INFIX_BAR_OP - | TOKEN_INFIX_AT_HAT_OP - | TOKEN_INFIX_COMPARE_OP - | TOKEN_INFIX_STAR_STAR_OP - | TOKEN_IDENT - | TOKEN_KEYWORD_STRING - | TOKEN_LBRACE - | TOKEN_RBRACE - | TOKEN_INTERP_STRING_END - | TOKEN_INTERP_STRING_PART - | TOKEN_INTERP_STRING_BEGIN_PART - | TOKEN_INTERP_STRING_BEGIN_END - | TOKEN_STRING - | TOKEN_BYTEARRAY - | TOKEN_end_of_input - | TOKEN_error - type nonTerminalId = - | NONTERM__startsignatureFile - | NONTERM__startimplementationFile - | NONTERM__startinteraction - | NONTERM__starttypedSeqExprEOF - | NONTERM__starttypEOF - | NONTERM_interaction - | NONTERM_interactiveTerminator - | NONTERM_interactiveItemsTerminator - | NONTERM_interactiveDefns - | NONTERM_interactiveExpr - | NONTERM_interactiveHash - | NONTERM_interactiveSeparators - | NONTERM_interactiveSeparator - | NONTERM_hashDirective - | NONTERM_hashDirectiveArgs - | NONTERM_hashDirectiveArg - | NONTERM_signatureFile - | NONTERM_moduleIntro - | NONTERM_namespaceIntro - | NONTERM_fileNamespaceSpecs - | NONTERM_fileNamespaceSpecList - | NONTERM_fileNamespaceSpec - | NONTERM_fileModuleSpec - | NONTERM_moduleSpfnsPossiblyEmptyBlock - | NONTERM_moduleSpfnsPossiblyEmpty - | NONTERM_moduleSpfns - | NONTERM_moduleSpfn - | NONTERM_valSpfn - | NONTERM_optLiteralValueSpfn - | NONTERM_moduleSpecBlock - | NONTERM_tyconSpfns - | NONTERM_tyconSpfnList - | NONTERM_tyconSpfn - | NONTERM_tyconSpfnRhsBlock - | NONTERM_tyconSpfnRhs - | NONTERM_tyconClassSpfn - | NONTERM_classSpfnBlockKindUnspecified - | NONTERM_classSpfnBlock - | NONTERM_classSpfnMembers - | NONTERM_classSpfnMembersAtLeastOne - | NONTERM_classMemberSpfn - | NONTERM_classMemberSpfnGetSet - | NONTERM_classMemberSpfnGetSetElements - | NONTERM_memberSpecFlags - | NONTERM_exconSpfn - | NONTERM_opt_classSpfn - | NONTERM_implementationFile - | NONTERM_fileNamespaceImpls - | NONTERM_fileNamespaceImplList - | NONTERM_fileNamespaceImpl - | NONTERM_fileModuleImpl - | NONTERM_moduleDefnsOrExprPossiblyEmptyOrBlock - | NONTERM_moduleDefnsOrExprPossiblyEmpty - | NONTERM_moduleDefnsOrExpr - | NONTERM_moduleDefns - | NONTERM_moduleDefnOrDirective - | NONTERM_moduleDefn - | NONTERM_openDecl - | NONTERM_namedModuleAbbrevBlock - | NONTERM_namedModuleDefnBlock - | NONTERM_wrappedNamedModuleDefn - | NONTERM_tyconDefnAugmentation - | NONTERM_opt_attributes - | NONTERM_attributes - | NONTERM_attributeList - | NONTERM_attributeListElements - | NONTERM_attribute - | NONTERM_attributeTarget - | NONTERM_memberFlags - | NONTERM_typeNameInfo - | NONTERM_tyconDefnList - | NONTERM_tyconDefn - | NONTERM_tyconDefnRhsBlock - | NONTERM_tyconDefnRhs - | NONTERM_tyconClassDefn - | NONTERM_classDefnBlockKindUnspecified - | NONTERM_classDefnBlock - | NONTERM_classDefnMembers - | NONTERM_classDefnMembersAtLeastOne - | NONTERM_classDefnMemberGetSet - | NONTERM_classDefnMemberGetSetElements - | NONTERM_classDefnMemberGetSetElement - | NONTERM_memberCore - | NONTERM_abstractMemberFlags - | NONTERM_classDefnMember - | NONTERM_valDefnDecl - | NONTERM_autoPropsDefnDecl - | NONTERM_opt_typ - | NONTERM_atomicPatternLongIdent - | NONTERM_opt_access - | NONTERM_access - | NONTERM_opt_declVisibility - | NONTERM_opt_interfaceImplDefn - | NONTERM_opt_classDefn - | NONTERM_inheritsDefn - | NONTERM_optAsSpec - | NONTERM_asSpec - | NONTERM_optBaseSpec - | NONTERM_baseSpec - | NONTERM_objectImplementationBlock - | NONTERM_objectImplementationMembers - | NONTERM_objectImplementationMember - | NONTERM_memberOrOverride - | NONTERM_tyconDefnOrSpfnSimpleRepr - | NONTERM_braceFieldDeclList - | NONTERM_anonRecdType - | NONTERM_braceBarFieldDeclListCore - | NONTERM_inlineAssemblyTyconRepr - | NONTERM_classOrInterfaceOrStruct - | NONTERM_interfaceMember - | NONTERM_tyconNameAndTyparDecls - | NONTERM_prefixTyparDecls - | NONTERM_typarDeclList - | NONTERM_typarDecl - | NONTERM_postfixTyparDecls - | NONTERM_explicitValTyparDeclsCore - | NONTERM_explicitValTyparDecls - | NONTERM_opt_explicitValTyparDecls - | NONTERM_opt_explicitValTyparDecls2 - | NONTERM_opt_typeConstraints - | NONTERM_typeConstraints - | NONTERM_typeConstraint - | NONTERM_typarAlts - | NONTERM_unionTypeRepr - | NONTERM_barAndgrabXmlDoc - | NONTERM_attrUnionCaseDecls - | NONTERM_attrUnionCaseDecl - | NONTERM_unionCaseName - | NONTERM_firstUnionCaseDeclOfMany - | NONTERM_firstUnionCaseDecl - | NONTERM_unionCaseReprElements - | NONTERM_unionCaseReprElement - | NONTERM_unionCaseRepr - | NONTERM_recdFieldDeclList - | NONTERM_recdFieldDecl - | NONTERM_fieldDecl - | NONTERM_exconDefn - | NONTERM_exceptionAndGrabDoc - | NONTERM_exconCore - | NONTERM_exconIntro - | NONTERM_exconRepr - | NONTERM_defnBindings - | NONTERM_doBinding - | NONTERM_hardwhiteLetBindings - | NONTERM_hardwhiteDoBinding - | NONTERM_classDefnBindings - | NONTERM_hardwhiteDefnBindingsTerminator - | NONTERM_cPrototype - | NONTERM_cArgs - | NONTERM_cMoreArgs - | NONTERM_cArg - | NONTERM_cType - | NONTERM_cRetType - | NONTERM_localBindings - | NONTERM_moreLocalBindings - | NONTERM_attr_localBinding - | NONTERM_localBinding - | NONTERM_typedExprWithStaticOptimizationsBlock - | NONTERM_typedExprWithStaticOptimizations - | NONTERM_opt_staticOptimizations - | NONTERM_staticOptimization - | NONTERM_staticOptimizationConditions - | NONTERM_staticOptimizationCondition - | NONTERM_rawConstant - | NONTERM_rationalConstant - | NONTERM_atomicUnsignedRationalConstant - | NONTERM_atomicRationalConstant - | NONTERM_constant - | NONTERM_bindingPattern - | NONTERM_simplePattern - | NONTERM_simplePatternCommaList - | NONTERM_simplePatterns - | NONTERM_headBindingPattern - | NONTERM_tuplePatternElements - | NONTERM_conjPatternElements - | NONTERM_namePatPairs - | NONTERM_namePatPair - | NONTERM_constrPattern - | NONTERM_atomicPatsOrNamePatPairs - | NONTERM_atomicPatterns - | NONTERM_atomicPattern - | NONTERM_parenPatternBody - | NONTERM_parenPattern - | NONTERM_tupleParenPatternElements - | NONTERM_conjParenPatternElements - | NONTERM_recordPatternElementsAux - | NONTERM_recordPatternElement - | NONTERM_listPatternElements - | NONTERM_typedSeqExprBlock - | NONTERM_declExprBlock - | NONTERM_typedSeqExprBlockR - | NONTERM_typedSeqExpr - | NONTERM_typedSeqExprEOF - | NONTERM_seqExpr - | NONTERM_recover - | NONTERM_moreBinders - | NONTERM_declExpr - | NONTERM_dynamicArg - | NONTERM_withClauses - | NONTERM_withPatternClauses - | NONTERM_patternAndGuard - | NONTERM_patternClauses - | NONTERM_patternGuard - | NONTERM_patternResult - | NONTERM_ifExprCases - | NONTERM_ifExprThen - | NONTERM_ifExprElifs - | NONTERM_tupleExpr - | NONTERM_minusExpr - | NONTERM_appExpr - | NONTERM_argExpr - | NONTERM_atomicExpr - | NONTERM_atomicExprQualification - | NONTERM_optRangeSeqExpr - | NONTERM_optRange - | NONTERM_rangeDeclExpr - | NONTERM_atomicExprAfterType - | NONTERM_beginEndExpr - | NONTERM_quoteExpr - | NONTERM_arrayExpr - | NONTERM_parenExpr - | NONTERM_parenExprBody - | NONTERM_staticallyKnownHeadTypars - | NONTERM_staticallyKnownHeadTyparAlts - | NONTERM_braceExpr - | NONTERM_braceExprBody - | NONTERM_listExprElements - | NONTERM_monadicExprInitial - | NONTERM_rangeSequenceExpr - | NONTERM_arrowThenExprR - | NONTERM_forLoopBinder - | NONTERM_forLoopRange - | NONTERM_forLoopDirection - | NONTERM_inlineAssemblyExpr - | NONTERM_optCurriedArgExprs - | NONTERM_opt_atomicExprAfterType - | NONTERM_opt_inlineAssemblyTypeArg - | NONTERM_optInlineAssemblyReturnTypes - | NONTERM_recdExpr - | NONTERM_recdExprCore - | NONTERM_opt_seps_recd - | NONTERM_seps_recd - | NONTERM_pathOrUnderscore - | NONTERM_recdExprBindings - | NONTERM_recdBinding - | NONTERM_objExpr - | NONTERM_objExprBaseCall - | NONTERM_opt_objExprBindings - | NONTERM_objExprBindings - | NONTERM_objExprInterfaces - | NONTERM_opt_objExprInterfaces - | NONTERM_objExprInterface - | NONTERM_braceBarExpr - | NONTERM_braceBarExprCore - | NONTERM_anonLambdaExpr - | NONTERM_anonMatchingExpr - | NONTERM_typeWithTypeConstraints - | NONTERM_topTypeWithTypeConstraints - | NONTERM_opt_topReturnTypeWithTypeConstraints - | NONTERM_topType - | NONTERM_topTupleType - | NONTERM_topTupleTypeElements - | NONTERM_topAppType - | NONTERM_typ - | NONTERM_typEOF - | NONTERM_tupleType - | NONTERM_tupleOrQuotTypeElements - | NONTERM_appTypeCon - | NONTERM_appTypeConPower - | NONTERM_appType - | NONTERM_arrayTypeSuffix - | NONTERM_appTypePrefixArguments - | NONTERM_typeArgListElements - | NONTERM_powerType - | NONTERM_atomTypeNonAtomicDeprecated - | NONTERM_atomTypeOrAnonRecdType - | NONTERM_atomType - | NONTERM_typeArgsNoHpaDeprecated - | NONTERM_typeArgsActual - | NONTERM_typeArgActual - | NONTERM_typeArgActualOrDummyIfEmpty - | NONTERM_dummyTypeArg - | NONTERM_measureTypeArg - | NONTERM_measureTypeAtom - | NONTERM_measureTypePower - | NONTERM_measureTypeSeq - | NONTERM_measureTypeExpr - | NONTERM_typar - | NONTERM_staticallyKnownHeadTypar - | NONTERM_ident - | NONTERM_path - | NONTERM_opName - | NONTERM_operatorName - | NONTERM_activePatternCaseName - | NONTERM_activePatternCaseNames - | NONTERM_identOrOp - | NONTERM_pathOp - | NONTERM_nameop - | NONTERM_identExpr - | NONTERM_topSeparator - | NONTERM_topSeparators - | NONTERM_opt_topSeparators - | NONTERM_seps - | NONTERM_declEnd - | NONTERM_opt_declEnd - | NONTERM_opt_ODECLEND - | NONTERM_deprecated_opt_equals - | NONTERM_opt_equals - | NONTERM_opt_OBLOCKSEP - | NONTERM_opt_seps - | NONTERM_opt_rec - | NONTERM_opt_bar - | NONTERM_opt_inline - | NONTERM_opt_mutable - | NONTERM_doToken - | NONTERM_doneDeclEnd - | NONTERM_structOrBegin - | NONTERM_sigOrBegin - | NONTERM_colonOrEquals - | NONTERM_stringOrKeywordString - | NONTERM_interpolatedStringFill - | NONTERM_interpolatedStringParts - | NONTERM_interpolatedString - | NONTERM_opt_HIGH_PRECEDENCE_APP - | NONTERM_opt_HIGH_PRECEDENCE_TYAPP - | NONTERM_typeKeyword - | NONTERM_moduleKeyword - | NONTERM_rbrace - | NONTERM_bar_rbrace - | NONTERM_rparen - | NONTERM_oblockend - | NONTERM_ends_other_than_rparen_coming_soon_or_recover - | NONTERM_ends_coming_soon_or_recover - val tagOfToken : t:token -> int - val tokenTagToTokenId : tokenIdx:int -> tokenId - val prodIdxToNonTerminal : prodIdx:int -> nonTerminalId - val _fsyacc_endOfInputTag : int - val _fsyacc_tagOfErrorTerminal : int - val token_to_string : t:token -> string - val _fsyacc_dataOfToken : t:token -> obj - val _fsyacc_gotos : uint16 [] - val _fsyacc_sparseGotoTableRowOffsets : uint16 [] - val _fsyacc_stateToProdIdxsTableElements : uint16 [] - val _fsyacc_stateToProdIdxsTableRowOffsets : uint16 [] - val _fsyacc_action_rows : int - val _fsyacc_actionTableElements : uint16 [] - val _fsyacc_actionTableRowOffsets : uint16 [] - val _fsyacc_reductionSymbolCounts : uint16 [] - val _fsyacc_productionToNonTerminalTable : uint16 [] - val _fsyacc_immediateActions : uint16 [] - val _fsyacc_reductions : - unit -> (Internal.Utilities.Text.Parsing.IParseState -> obj) [] - val tables : unit -> Internal.Utilities.Text.Parsing.Tables - val engine : - lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - startState:int -> obj - val signatureFile : - lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - SyntaxTree.ParsedSigFile - val implementationFile : - lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - SyntaxTree.ParsedImplFile - val interaction : - lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - SyntaxTree.ParsedFsiInteraction - val typedSeqExprEOF : - lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - SyntaxTree.SynExpr - val typEOF : - lexer:(Internal.Utilities.Text.Lexing.LexBuffer -> token) -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - SyntaxTree.SynType - end - -namespace FSharp.Compiler - module internal Lexhelp = begin - val stdinMockFilename : string - [] - type LightSyntaxStatus = - class - new : initial:bool * warn:bool -> LightSyntaxStatus - member ExplicitlySet : bool - member Status : bool - member WarnOnMultipleTokens : bool - end - [] - type LexResourceManager = - class - new : ?capacity:int -> LexResourceManager - member InternIdentifierToken : s:string -> Parser.token - end - type LexArgs = - { defines: string list - resourceManager: LexResourceManager - errorLogger: ErrorLogger.ErrorLogger - applyLineDirectives: bool - pathMap: Internal.Utilities.PathMap - mutable ifdefStack: ParseHelpers.LexerIfdefStack - mutable lightStatus: LightSyntaxStatus - mutable stringNest: ParseHelpers.LexerInterpolatedStringNesting } - type LongUnicodeLexResult = - | SurrogatePair of uint16 * uint16 - | SingleChar of uint16 - | Invalid - val mkLexargs : - string list * LightSyntaxStatus * LexResourceManager * - ParseHelpers.LexerIfdefStack * ErrorLogger.ErrorLogger * - Internal.Utilities.PathMap -> LexArgs - val reusingLexbufForParsing : UnicodeLexing.Lexbuf -> (unit -> 'a) -> 'a - val resetLexbufPos : string -> UnicodeLexing.Lexbuf -> unit - val usingLexbufForParsing : - UnicodeLexing.Lexbuf * string -> (UnicodeLexing.Lexbuf -> 'a) -> 'a - val stringBufferAsString : AbstractIL.Internal.ByteBuffer -> System.String - val stringBufferAsBytes : AbstractIL.Internal.ByteBuffer -> byte [] - type LexerStringFinisher = - | LexerStringFinisher of - (AbstractIL.Internal.ByteBuffer -> ParseHelpers.LexerStringKind -> - bool -> ParseHelpers.LexerContinuation -> Parser.token) - with - member - Finish : buf:AbstractIL.Internal.ByteBuffer -> - kind:ParseHelpers.LexerStringKind -> - isInterpolatedStringPart:bool -> - cont:ParseHelpers.LexerContinuation -> Parser.token - static member Default : LexerStringFinisher - end - val addUnicodeString : AbstractIL.Internal.ByteBuffer -> string -> unit - val addIntChar : buf:AbstractIL.Internal.ByteBuffer -> c:int -> unit - val addUnicodeChar : AbstractIL.Internal.ByteBuffer -> int -> unit - val addByteChar : AbstractIL.Internal.ByteBuffer -> char -> unit - val stringBufferIsBytes : AbstractIL.Internal.ByteBuffer -> bool - val newline : Internal.Utilities.Text.Lexing.LexBuffer<'a> -> unit - val advanceColumnBy : - Internal.Utilities.Text.Lexing.LexBuffer<'a> -> n:int -> unit - val trigraph : char -> char -> char -> char - val digit : char -> int32 - val hexdigit : char -> int32 - val unicodeGraphShort : string -> uint16 - val hexGraphShort : string -> uint16 - val unicodeGraphLong : string -> LongUnicodeLexResult - val escape : char -> char - exception ReservedKeyword of string * Range.range - module Keywords = begin - type private compatibilityMode = - | ALWAYS - | FSHARP - val private keywordList : (compatibilityMode * string * Parser.token) list - val private unreserveWords : string list - val keywordNames : string list - val keywordTable : - System.Collections.Generic.Dictionary - val KeywordToken : s:string -> Parser.token - val IdentifierToken : - LexArgs -> UnicodeLexing.Lexbuf -> string -> Parser.token - val KeywordOrIdentifierToken : - LexArgs -> UnicodeLexing.Lexbuf -> string -> Parser.token - val DoesIdentifierNeedQuotation : string -> bool - val QuoteIdentifierIfNeeded : string -> string - val NormalizeIdentifierBackticks : string -> string - val keywordsWithDescription : (string * string) list - end - end - -namespace FSharp.Compiler - module internal PPLexer = begin - val lexeme : lexbuf:UnicodeLexing.Lexbuf -> string - val fail : - args:Lexhelp.LexArgs -> - lexbuf:UnicodeLexing.Lexbuf -> int * string -> PPParser.token - val trans : uint16 [] array - val actions : uint16 [] - val _fslex_tables : Internal.Utilities.Text.Lexing.UnicodeTables - val _fslex_dummy : unit -> 'a - val tokenstream : - args:Lexhelp.LexArgs -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> PPParser.token - val rest : lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> unit - end - -namespace FSharp.Compiler - module internal Lexer = begin - module Ranges = begin - val isInt8BadMax : x:int -> bool - val isInt16BadMax : x:int -> bool - val isInt32BadMax : (string -> bool) - val isInt64BadMax : (string -> bool) - end - val lexeme : lexbuf:UnicodeLexing.Lexbuf -> string - val lexemeTrimBoth : lexbuf:UnicodeLexing.Lexbuf -> n:int -> m:int -> string - val lexemeTrimRight : lexbuf:UnicodeLexing.Lexbuf -> n:int -> string - val lexemeTrimLeft : lexbuf:UnicodeLexing.Lexbuf -> n:int -> string - val fail : - args:Lexhelp.LexArgs -> - lexbuf:UnicodeLexing.Lexbuf -> int * string -> dflt:'a -> 'a - val getSign32 : s:string -> p:byref -> l:int -> int - val isOXB : c:char -> bool - val is0OXB : s:string -> p:int -> l:int -> bool - val get0OXB : s:string -> p:byref -> l:int -> char - val formatError : unit -> 'a - val parseBinaryUInt64 : s:string -> uint64 - val parseOctalUInt64 : s:string -> uint64 - val removeUnderscores : s:string -> string - val parseInt32 : s:string -> int - val lexemeTrimRightToInt32 : - args:Lexhelp.LexArgs -> lexbuf:UnicodeLexing.Lexbuf -> n:int -> int - val checkExprOp : lexbuf:UnicodeLexing.Lexbuf -> unit - val unexpectedChar : lexbuf:UnicodeLexing.Lexbuf -> Parser.token - val startString : - args:Lexhelp.LexArgs -> - lexbuf:UnicodeLexing.Lexbuf -> - AbstractIL.Internal.ByteBuffer * Lexhelp.LexerStringFinisher * - Range.range - val trySaveXmlDoc : - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - buff:(Range.range * System.Text.StringBuilder) option -> unit - val tryAppendXmlDoc : - buff:(Range.range * System.Text.StringBuilder) option -> s:string -> unit - val shouldStartLine : - args:Lexhelp.LexArgs -> - lexbuf:UnicodeLexing.Lexbuf -> - m:Range.range -> int * string -> tok:'a -> 'a - val shouldStartFile : - args:Lexhelp.LexArgs -> - lexbuf:UnicodeLexing.Lexbuf -> - m:Range.range -> int * string -> tok:'a -> 'a - val evalIfDefExpression : - startPos:Internal.Utilities.Text.Lexing.Position -> - isFeatureSupported:(Features.LanguageFeature -> bool) -> - args:Lexhelp.LexArgs -> - lookup:(string -> bool) -> lexed:string -> bool - val evalFloat : - args:Lexhelp.LexArgs -> lexbuf:UnicodeLexing.Lexbuf -> float32 - val trans : uint16 [] array - val actions : uint16 [] - val _fslex_tables : Internal.Utilities.Text.Lexing.UnicodeTables - val _fslex_dummy : unit -> 'a - val token : - args:Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token - val ifdefSkip : - n:int -> - m:Range.range -> - args:Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - Parser.token - val endline : - cont:ParseHelpers.LexerEndlineContinuation -> - args:Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - Parser.token - val singleQuoteString : - AbstractIL.Internal.ByteBuffer * Lexhelp.LexerStringFinisher * Range.range * - ParseHelpers.LexerStringKind * Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token - val verbatimString : - AbstractIL.Internal.ByteBuffer * Lexhelp.LexerStringFinisher * Range.range * - ParseHelpers.LexerStringKind * Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token - val tripleQuoteString : - AbstractIL.Internal.ByteBuffer * Lexhelp.LexerStringFinisher * Range.range * - ParseHelpers.LexerStringKind * Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token - val singleLineComment : - (Range.range * System.Text.StringBuilder) option * int * Range.range * - Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token - val comment : - int * Range.range * Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token - val stringInComment : - n:int -> - m:Range.range -> - args:Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - Parser.token - val verbatimStringInComment : - n:int -> - m:Range.range -> - args:Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - Parser.token - val tripleQuoteStringInComment : - n:int -> - m:Range.range -> - args:Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - Parser.token - val mlOnly : - m:Range.range -> - args:Lexhelp.LexArgs -> - skip:bool -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - Parser.token - end - -namespace FSharp.Compiler - module internal LexFilter = begin - val debug : bool - val stringOfPos : p:Internal.Utilities.Text.Lexing.Position -> string - val outputPos : - os:System.IO.TextWriter -> - p:Internal.Utilities.Text.Lexing.Position -> unit - val warningStringOfPosition : - p:Internal.Utilities.Text.Lexing.Position -> string - type Context = - | CtxtLetDecl of bool * Internal.Utilities.Text.Lexing.Position - | CtxtIf of Internal.Utilities.Text.Lexing.Position - | CtxtTry of Internal.Utilities.Text.Lexing.Position - | CtxtFun of Internal.Utilities.Text.Lexing.Position - | CtxtFunction of Internal.Utilities.Text.Lexing.Position - | CtxtWithAsLet of Internal.Utilities.Text.Lexing.Position - | CtxtWithAsAugment of Internal.Utilities.Text.Lexing.Position - | CtxtMatch of Internal.Utilities.Text.Lexing.Position - | CtxtFor of Internal.Utilities.Text.Lexing.Position - | CtxtWhile of Internal.Utilities.Text.Lexing.Position - | CtxtWhen of Internal.Utilities.Text.Lexing.Position - | CtxtVanilla of Internal.Utilities.Text.Lexing.Position * bool - | CtxtThen of Internal.Utilities.Text.Lexing.Position - | CtxtElse of Internal.Utilities.Text.Lexing.Position - | CtxtDo of Internal.Utilities.Text.Lexing.Position - | CtxtInterfaceHead of Internal.Utilities.Text.Lexing.Position - | CtxtTypeDefns of Internal.Utilities.Text.Lexing.Position - | CtxtNamespaceHead of - Internal.Utilities.Text.Lexing.Position * Parser.token - | CtxtModuleHead of Internal.Utilities.Text.Lexing.Position * Parser.token - | CtxtMemberHead of Internal.Utilities.Text.Lexing.Position - | CtxtMemberBody of Internal.Utilities.Text.Lexing.Position - | CtxtModuleBody of Internal.Utilities.Text.Lexing.Position * bool - | CtxtNamespaceBody of Internal.Utilities.Text.Lexing.Position - | CtxtException of Internal.Utilities.Text.Lexing.Position - | CtxtParen of Parser.token * Internal.Utilities.Text.Lexing.Position - | CtxtSeqBlock of - FirstInSequence * Internal.Utilities.Text.Lexing.Position * AddBlockEnd - | CtxtMatchClauses of bool * Internal.Utilities.Text.Lexing.Position - with - override ToString : unit -> string - member StartCol : int - member StartPos : Internal.Utilities.Text.Lexing.Position - end - and AddBlockEnd = - | AddBlockEnd - | NoAddBlockEnd - | AddOneSidedBlockEnd - and FirstInSequence = - | FirstInSeqBlock - | NotFirstInSeqBlock - val isInfix : token:Parser.token -> bool - val isNonAssocInfixToken : token:Parser.token -> bool - val infixTokenLength : token:Parser.token -> int - val isIfBlockContinuator : token:Parser.token -> bool - val isTryBlockContinuator : token:Parser.token -> bool - val isThenBlockContinuator : token:Parser.token -> bool - val isDoContinuator : token:Parser.token -> bool - val isInterfaceContinuator : token:Parser.token -> bool - val isNamespaceContinuator : token:Parser.token -> bool - val isTypeContinuator : token:Parser.token -> bool - val isForLoopContinuator : token:Parser.token -> bool - val isWhileBlockContinuator : token:Parser.token -> bool - val isLetContinuator : token:Parser.token -> bool - val isTypeSeqBlockElementContinuator : token:Parser.token -> bool - val isSeqBlockElementContinuator : token:Parser.token -> bool - val isWithAugmentBlockContinuator : token:Parser.token -> bool - val isLongIdentifier : token:Parser.token -> bool - val isLongIdentifierOrGlobal : token:Parser.token -> bool - val isAtomicExprEndToken : token:Parser.token -> bool - val parenTokensBalance : t1:Parser.token -> t2:Parser.token -> bool - [] - type LexbufState = - struct - new : startPos:Internal.Utilities.Text.Lexing.Position * - endPos:Internal.Utilities.Text.Lexing.Position * pastEOF:bool -> - LexbufState - member EndPos : Internal.Utilities.Text.Lexing.Position - member PastEOF : bool - member StartPos : Internal.Utilities.Text.Lexing.Position - end - [] - type TokenTup = - class - new : token:Parser.token * state:LexbufState * - lastTokenPos:Internal.Utilities.Text.Lexing.Position -> TokenTup - val mutable Token: Parser.token - val mutable LexbufState: LexbufState - val mutable LastTokenPos: Internal.Utilities.Text.Lexing.Position - member EndPos : Internal.Utilities.Text.Lexing.Position - member StartPos : Internal.Utilities.Text.Lexing.Position - end - type TokenTupPool = - class - new : unit -> TokenTupPool - member Rent : unit -> TokenTup - member Return : x:TokenTup -> unit - member UseLocation : x:TokenTup * tok:Parser.token -> TokenTup - member - UseShiftedLocation : x:TokenTup * tok:Parser.token * shiftLeft:int * - shiftRight:int -> TokenTup - end - val ( |TyparsCloseOp|_| ) : - txt:string -> ((bool -> Parser.token) [] * Parser.token option) option - [] - type PositionWithColumn = - struct - new : position:Internal.Utilities.Text.Lexing.Position * column:int -> - PositionWithColumn - val Position: Internal.Utilities.Text.Lexing.Position - val Column: int - end - type LexFilterImpl = - class - new : lightStatus:Lexhelp.LightSyntaxStatus * compilingFsLib:bool * - lexer:(UnicodeLexing.Lexbuf -> Parser.token) * - lexbuf:UnicodeLexing.Lexbuf -> LexFilterImpl - member GetToken : unit -> Parser.token - member LexBuffer : UnicodeLexing.Lexbuf - end - type LexFilter = - class - new : lightStatus:Lexhelp.LightSyntaxStatus * compilingFsLib:bool * - lexer:(UnicodeLexing.Lexbuf -> Parser.token) * - lexbuf:UnicodeLexing.Lexbuf -> LexFilter - member GetToken : unit -> Parser.token - member LexBuffer : UnicodeLexing.Lexbuf - end - end - -namespace FSharp.Compiler - [] - type internal TypeProviderToken = - class - interface AbstractIL.Internal.Library.LockToken - new : unit -> TypeProviderToken - end - [] - type internal TypeProviderLock = - class - inherit AbstractIL.Internal.Library.Lock - new : unit -> TypeProviderLock - end - type internal TypeProviderError = - class - inherit System.Exception - new : int * string * Range.range * seq -> TypeProviderError - new : (int * string) * string * Range.range -> TypeProviderError - new : errNum:int * tpDesignation:string * m:Range.range * - errors:string list * typeNameContext:string option * - methodNameContext:string option -> TypeProviderError - member Iter : (TypeProviderError -> unit) -> unit - member - MapText : (string -> int * string) * string * Range.range -> - TypeProviderError - member WithContext : string * string -> TypeProviderError - member ContextualErrorMessage : string - override Message : string - member Number : int - member Range : Range.range - end - type TaintedContext = - { TypeProvider: CompilerServices.ITypeProvider - TypeProviderAssemblyRef: AbstractIL.IL.ILScopeRef - Lock: TypeProviderLock } - [] - type internal Tainted<'T> = - class - new : context:TaintedContext * value:'T -> Tainted<'T> - static member - CreateAll : (CompilerServices.ITypeProvider * AbstractIL.IL.ILScopeRef) list -> - Tainted list - member Coerce : range:Range.range -> Tainted<'U> - member OfType : unit -> Tainted<'U> option - member PApply : ('T -> 'U) * range:Range.range -> Tainted<'U> - member - PApply2 : ('T -> 'U1 * 'U2) * range:Range.range -> - Tainted<'U1> * Tainted<'U2> - member - PApply3 : ('T -> 'U1 * 'U2 * 'U3) * range:Range.range -> - Tainted<'U1> * Tainted<'U2> * Tainted<'U3> - member - PApply4 : ('T -> 'U1 * 'U2 * 'U3 * 'U4) * range:Range.range -> - Tainted<'U1> * Tainted<'U2> * Tainted<'U3> * Tainted<'U4> - member - PApplyArray : ('T -> 'U []) * System.String * range:Range.range -> - Tainted<'U> [] - member PApplyNoFailure : f:('T -> 'U) -> Tainted<'U> - member - PApplyOption : ('T -> 'U option) * range:Range.range -> - Tainted<'U> option - member - PApplyWithProvider : ('T * CompilerServices.ITypeProvider -> 'U) * - range:Range.range -> Tainted<'U> - member PUntaint : ('T -> 'U) * range:Range.range -> 'U - member PUntaintNoFailure : ('T -> 'U) -> 'U - member Protect : f:('T -> 'a) -> range:Range.range -> 'a - member AccessObjectDirectly : 'T - member TypeProvider : Tainted - member TypeProviderAssemblyRef : AbstractIL.IL.ILScopeRef - member TypeProviderDesignation : string - end - module internal Tainted = begin - val ( |Null|_| ) : Tainted<'T> -> unit option when 'T : null - val Eq : Tainted<'T> -> 'T -> bool when 'T : equality - val EqTainted : Tainted<'T> -> Tainted<'T> -> bool when 'T : not struct - val GetHashCodeTainted : Tainted<'T> -> int when 'T : equality - end - -namespace FSharp.Compiler - module internal ExtensionTyping = begin - type TypeProviderDesignation = | TypeProviderDesignation of string - exception ProvidedTypeResolution of Range.range * System.Exception - exception ProvidedTypeResolutionNoRange of System.Exception - val toolingCompatiblePaths : unit -> string list - type ResolutionEnvironment = - { resolutionFolder: string - outputFile: string option - showResolutionMessages: bool - referencedAssemblies: string [] - temporaryFolder: string } - val GetTypeProviderImplementationTypes : - runTimeAssemblyFileName:string * - designTimeAssemblyNameString:System.String * m:Range.range * - compilerToolPaths:string list -> System.Type list - val StripException : e:exn -> exn - val CreateTypeProvider : - typeProviderImplementationType:System.Type * runtimeAssemblyPath:string * - resolutionEnvironment:ResolutionEnvironment * isInvalidationSupported:bool * - isInteractive:bool * systemRuntimeContainsType:(string -> bool) * - systemRuntimeAssemblyVersion:System.Version * m:Range.range -> - CompilerServices.ITypeProvider - val GetTypeProvidersOfAssembly : - runtimeAssemblyFilename:string * - ilScopeRefOfRuntimeAssembly:AbstractIL.IL.ILScopeRef * - designTimeName:string * resolutionEnvironment:ResolutionEnvironment * - isInvalidationSupported:bool * isInteractive:bool * - systemRuntimeContainsType:(string -> bool) * - systemRuntimeAssemblyVersion:System.Version * - compilerToolPaths:string list * Range.range -> - Tainted list - val unmarshal : t:Tainted<'a> -> 'a - val TryTypeMember : - st:Tainted<'a> * fullName:System.String * memberName:System.String * - m:Range.range * recover:'b * f:('a -> 'b) -> Tainted<'b> - val TryTypeMemberArray : - st:Tainted<'a> * fullName:System.String * memberName:string * - m:Range.range * f:('a -> 'b []) -> Tainted<'b> [] - val TryTypeMemberNonNull : - st:Tainted<'a> * fullName:System.String * memberName:System.String * - m:Range.range * recover:'b * f:('a -> 'b) -> Tainted<'b> when 'b : null - val TryMemberMember : - mi:Tainted<'a> * typeName:System.String * memberName:System.String * - memberMemberName:System.String * m:Range.range * recover:'b * f:('a -> 'b) -> - Tainted<'b> - val DisplayNameOfTypeProvider : - Tainted * Range.range -> string - val ValidateNamespaceName : - name:System.String * typeProvider:Tainted * - m:Range.range * nsp:string -> unit - val bindingFlags : System.Reflection.BindingFlags - type CustomAttributeData = System.Reflection.CustomAttributeData - type CustomAttributeNamedArgument = - System.Reflection.CustomAttributeNamedArgument - type CustomAttributeTypedArgument = - System.Reflection.CustomAttributeTypedArgument - type ProvidedTypeComparer = - class - interface System.Collections.Generic.IEqualityComparer - new : unit -> ProvidedTypeComparer - static member Instance : ProvidedTypeComparer - end - [] - and ProvidedTypeContext = - | NoEntries - | Entries of - System.Collections.Generic.Dictionary * - System.Lazy> - with - static member - Create : System.Collections.Generic.Dictionary * - System.Collections.Generic.Dictionary -> - ProvidedTypeContext - member - GetDictionaries : unit -> - System.Collections.Generic.Dictionary * - System.Collections.Generic.Dictionary - member RemapTyconRefs : (obj -> obj) -> ProvidedTypeContext - member TryGetILTypeRef : ProvidedType -> AbstractIL.IL.ILTypeRef option - member TryGetTyconRef : ProvidedType -> obj option - static member Empty : ProvidedTypeContext - end - [] - and ProvidedType = - class - inherit ProvidedMemberInfo - interface IProvidedCustomAttributeProvider - new : x:System.Type * ctxt:ProvidedTypeContext -> ProvidedType - static member - ApplyContext : ProvidedType * ProvidedTypeContext -> ProvidedType - static member - Create : ctxt:ProvidedTypeContext -> x:System.Type -> ProvidedType - static member - CreateArray : ctxt:ProvidedTypeContext -> - xs:System.Type [] -> ProvidedType [] - static member CreateNoContext : System.Type -> ProvidedType - static member - CreateWithNullCheck : ctxt:ProvidedTypeContext -> - name:string -> x:System.Type -> ProvidedType - static member - TaintedEquals : Tainted * Tainted -> bool - member - ApplyStaticArguments : provider:CompilerServices.ITypeProvider * - fullTypePathAfterArguments:string [] * - staticArgs:obj [] -> ProvidedType - member AsProvidedVar : name:string -> ProvidedVar - override Equals : y:obj -> bool - member GetAllNestedTypes : unit -> ProvidedType [] - member GetArrayRank : unit -> int - member GetConstructors : unit -> ProvidedConstructorInfo [] - member GetElementType : unit -> ProvidedType - member GetEnumUnderlyingType : unit -> ProvidedType - member GetEvent : string -> ProvidedEventInfo - member GetEvents : unit -> ProvidedEventInfo [] - member GetField : string -> ProvidedFieldInfo - member GetFields : unit -> ProvidedFieldInfo [] - member GetGenericArguments : unit -> ProvidedType [] - member GetGenericTypeDefinition : unit -> ProvidedType - override GetHashCode : unit -> int - member GetInterfaces : unit -> ProvidedType [] - member GetMethods : unit -> ProvidedMethodInfo [] - member GetNestedType : string -> ProvidedType - member GetNestedTypes : unit -> ProvidedType [] - member GetProperties : unit -> ProvidedPropertyInfo [] - member GetProperty : string -> ProvidedPropertyInfo - member - GetStaticParameters : CompilerServices.ITypeProvider -> - ProvidedParameterInfo [] - member MakeArrayType : unit -> ProvidedType - member MakeArrayType : rank:int -> ProvidedType - member MakeByRefType : unit -> ProvidedType - member MakeGenericType : args:ProvidedType [] -> ProvidedType - member MakePointerType : unit -> ProvidedType - member TryGetILTypeRef : unit -> AbstractIL.IL.ILTypeRef option - member TryGetTyconRef : unit -> obj option - member Assembly : ProvidedAssembly - member BaseType : ProvidedType - member Context : ProvidedTypeContext - member FullName : string - member GenericParameterPosition : int - member Handle : System.Type - member IsAbstract : bool - member IsArray : bool - member IsByRef : bool - member IsClass : bool - member IsEnum : bool - member IsErased : bool - member IsGenericParameter : bool - member IsGenericType : bool - member IsInterface : bool - member IsMeasure : bool - member IsNestedPublic : bool - member IsPointer : bool - member IsPublic : bool - member IsSealed : bool - member IsSuppressRelocate : bool - member IsValueType : bool - member IsVoid : bool - member Namespace : string - member RawSystemType : System.Type - static member Void : ProvidedType - end - [] - and IProvidedCustomAttributeProvider = - interface - abstract member - GetAttributeConstructorArgs : provider:CompilerServices.ITypeProvider * - attribName:string -> - (obj option list * - (string * obj option) list) option - abstract member - GetDefinitionLocationAttribute : provider:CompilerServices.ITypeProvider -> - (string * int * int) option - abstract member - GetHasTypeProviderEditorHideMethodsAttribute : provider:CompilerServices.ITypeProvider -> - bool - abstract member - GetXmlDocAttributes : provider:CompilerServices.ITypeProvider -> - string [] - end - and ProvidedCustomAttributeProvider = - class - static member - Create : attributes:(CompilerServices.ITypeProvider -> - seq) -> - IProvidedCustomAttributeProvider - end - [] - and ProvidedMemberInfo = - class - interface IProvidedCustomAttributeProvider - new : x:System.Reflection.MemberInfo * ctxt:ProvidedTypeContext -> - ProvidedMemberInfo - member DeclaringType : ProvidedType - member Name : string - end - [] - and ProvidedParameterInfo = - class - interface IProvidedCustomAttributeProvider - new : x:System.Reflection.ParameterInfo * ctxt:ProvidedTypeContext -> - ProvidedParameterInfo - static member - Create : ctxt:ProvidedTypeContext -> - x:System.Reflection.ParameterInfo -> ProvidedParameterInfo - static member - CreateArray : ctxt:ProvidedTypeContext -> - xs:System.Reflection.ParameterInfo [] -> - ProvidedParameterInfo [] - override Equals : y:obj -> bool - override GetHashCode : unit -> int - member Handle : System.Reflection.ParameterInfo - member HasDefaultValue : bool - member IsIn : bool - member IsOptional : bool - member IsOut : bool - member Name : string - member ParameterType : ProvidedType - member RawDefaultValue : obj - end - [] - and ProvidedAssembly = - class - new : x:System.Reflection.Assembly -> ProvidedAssembly - static member Create : x:System.Reflection.Assembly -> ProvidedAssembly - override Equals : y:obj -> bool - override GetHashCode : unit -> int - member - GetManifestModuleContents : CompilerServices.ITypeProvider -> byte [] - member GetName : unit -> System.Reflection.AssemblyName - member FullName : string - member Handle : System.Reflection.Assembly - end - [] - and ProvidedMethodBase = - class - inherit ProvidedMemberInfo - new : x:System.Reflection.MethodBase * ctxt:ProvidedTypeContext -> - ProvidedMethodBase - static member - TaintedEquals : Tainted * - Tainted -> bool - static member TaintedGetHashCode : Tainted -> int - member - ApplyStaticArgumentsForMethod : provider:CompilerServices.ITypeProvider * - fullNameAfterArguments:string * - staticArgs:obj [] -> - ProvidedMethodBase - member GetGenericArguments : unit -> ProvidedType [] - member GetParameters : unit -> ProvidedParameterInfo [] - member - GetStaticParametersForMethod : CompilerServices.ITypeProvider -> - ProvidedParameterInfo [] - member Context : ProvidedTypeContext - member Handle : System.Reflection.MethodBase - member IsAbstract : bool - member IsConstructor : bool - member IsFamily : bool - member IsFamilyAndAssembly : bool - member IsFamilyOrAssembly : bool - member IsFinal : bool - member IsGenericMethod : bool - member IsHideBySig : bool - member IsPublic : bool - member IsStatic : bool - member IsVirtual : bool - end - [] - and ProvidedFieldInfo = - class - inherit ProvidedMemberInfo - new : x:System.Reflection.FieldInfo * ctxt:ProvidedTypeContext -> - ProvidedFieldInfo - static member - Create : ctxt:ProvidedTypeContext -> - x:System.Reflection.FieldInfo -> ProvidedFieldInfo - static member - CreateArray : ctxt:ProvidedTypeContext -> - xs:System.Reflection.FieldInfo [] -> - ProvidedFieldInfo [] - static member - TaintedEquals : Tainted * - Tainted -> bool - override Equals : y:obj -> bool - override GetHashCode : unit -> int - member GetRawConstantValue : unit -> obj - member FieldType : ProvidedType - member Handle : System.Reflection.FieldInfo - member IsFamily : bool - member IsFamilyAndAssembly : bool - member IsFamilyOrAssembly : bool - member IsInitOnly : bool - member IsLiteral : bool - member IsPrivate : bool - member IsPublic : bool - member IsSpecialName : bool - member IsStatic : bool - end - [] - and ProvidedMethodInfo = - class - inherit ProvidedMethodBase - new : x:System.Reflection.MethodInfo * ctxt:ProvidedTypeContext -> - ProvidedMethodInfo - static member - Create : ctxt:ProvidedTypeContext -> - x:System.Reflection.MethodInfo -> ProvidedMethodInfo - static member - CreateArray : ctxt:ProvidedTypeContext -> - xs:System.Reflection.MethodInfo [] -> - ProvidedMethodInfo [] - override Equals : y:obj -> bool - override GetHashCode : unit -> int - member Handle : System.Reflection.MethodInfo - member MetadataToken : int - member ReturnType : ProvidedType - end - [] - and ProvidedPropertyInfo = - class - inherit ProvidedMemberInfo - new : x:System.Reflection.PropertyInfo * ctxt:ProvidedTypeContext -> - ProvidedPropertyInfo - static member - Create : ctxt:ProvidedTypeContext -> - x:System.Reflection.PropertyInfo -> ProvidedPropertyInfo - static member - CreateArray : ctxt:ProvidedTypeContext -> - xs:System.Reflection.PropertyInfo [] -> - ProvidedPropertyInfo [] - static member - TaintedEquals : Tainted * - Tainted -> bool - static member TaintedGetHashCode : Tainted -> int - override Equals : y:obj -> bool - member GetGetMethod : unit -> ProvidedMethodInfo - override GetHashCode : unit -> int - member GetIndexParameters : unit -> ProvidedParameterInfo [] - member GetSetMethod : unit -> ProvidedMethodInfo - member CanRead : bool - member CanWrite : bool - member Handle : System.Reflection.PropertyInfo - member PropertyType : ProvidedType - end - [] - and ProvidedEventInfo = - class - inherit ProvidedMemberInfo - new : x:System.Reflection.EventInfo * ctxt:ProvidedTypeContext -> - ProvidedEventInfo - static member - Create : ctxt:ProvidedTypeContext -> - x:System.Reflection.EventInfo -> ProvidedEventInfo - static member - CreateArray : ctxt:ProvidedTypeContext -> - xs:System.Reflection.EventInfo [] -> - ProvidedEventInfo [] - static member - TaintedEquals : Tainted * - Tainted -> bool - static member TaintedGetHashCode : Tainted -> int - override Equals : y:obj -> bool - member GetAddMethod : unit -> ProvidedMethodInfo - override GetHashCode : unit -> int - member GetRemoveMethod : unit -> ProvidedMethodInfo - member EventHandlerType : ProvidedType - member Handle : System.Reflection.EventInfo - end - [] - and ProvidedConstructorInfo = - class - inherit ProvidedMethodBase - new : x:System.Reflection.ConstructorInfo * ctxt:ProvidedTypeContext -> - ProvidedConstructorInfo - static member - Create : ctxt:ProvidedTypeContext -> - x:System.Reflection.ConstructorInfo -> - ProvidedConstructorInfo - static member - CreateArray : ctxt:ProvidedTypeContext -> - xs:System.Reflection.ConstructorInfo [] -> - ProvidedConstructorInfo [] - override Equals : y:obj -> bool - override GetHashCode : unit -> int - member Handle : System.Reflection.ConstructorInfo - end - and ProvidedExprType = - | ProvidedNewArrayExpr of ProvidedType * ProvidedExpr [] - | ProvidedNewObjectExpr of ProvidedConstructorInfo * ProvidedExpr [] - | ProvidedWhileLoopExpr of ProvidedExpr * ProvidedExpr - | ProvidedNewDelegateExpr of ProvidedType * ProvidedVar [] * ProvidedExpr - | ProvidedForIntegerRangeLoopExpr of - ProvidedVar * ProvidedExpr * ProvidedExpr * ProvidedExpr - | ProvidedSequentialExpr of ProvidedExpr * ProvidedExpr - | ProvidedTryWithExpr of - ProvidedExpr * ProvidedVar * ProvidedExpr * ProvidedVar * ProvidedExpr - | ProvidedTryFinallyExpr of ProvidedExpr * ProvidedExpr - | ProvidedLambdaExpr of ProvidedVar * ProvidedExpr - | ProvidedCallExpr of - ProvidedExpr option * ProvidedMethodInfo * ProvidedExpr [] - | ProvidedConstantExpr of obj * ProvidedType - | ProvidedDefaultExpr of ProvidedType - | ProvidedNewTupleExpr of ProvidedExpr [] - | ProvidedTupleGetExpr of ProvidedExpr * int - | ProvidedTypeAsExpr of ProvidedExpr * ProvidedType - | ProvidedTypeTestExpr of ProvidedExpr * ProvidedType - | ProvidedLetExpr of ProvidedVar * ProvidedExpr * ProvidedExpr - | ProvidedVarSetExpr of ProvidedVar * ProvidedExpr - | ProvidedIfThenElseExpr of ProvidedExpr * ProvidedExpr * ProvidedExpr - | ProvidedVarExpr of ProvidedVar - [] - and ProvidedExpr = - class - new : x:Quotations.Expr * ctxt:ProvidedTypeContext -> ProvidedExpr - static member - Create : ctxt:ProvidedTypeContext -> t:Quotations.Expr -> ProvidedExpr - static member - CreateArray : ctxt:ProvidedTypeContext -> - xs:Quotations.Expr [] -> ProvidedExpr [] - override Equals : y:obj -> bool - member GetExprType : unit -> ProvidedExprType option - override GetHashCode : unit -> int - member Context : ProvidedTypeContext - member Handle : Quotations.Expr - member Type : ProvidedType - member UnderlyingExpressionString : string - end - [] - and ProvidedVar = - class - new : x:Quotations.Var * ctxt:ProvidedTypeContext -> ProvidedVar - static member - Create : ctxt:ProvidedTypeContext -> t:Quotations.Var -> ProvidedVar - static member - CreateArray : ctxt:ProvidedTypeContext -> - xs:Quotations.Var [] -> ProvidedVar [] - override Equals : obj -> bool - override GetHashCode : unit -> int - member Context : ProvidedTypeContext - member Handle : Quotations.Var - member IsMutable : bool - member Name : string - member Type : ProvidedType - end - val GetInvokerExpression : - CompilerServices.ITypeProvider * ProvidedMethodBase * ProvidedVar [] -> - ProvidedExpr - val CheckAndComputeProvidedNameProperty : - m:Range.range * st:Tainted * proj:(ProvidedType -> string) * - propertyString:System.String -> string - val ValidateAttributesOfProvidedType : - m:Range.range * st:Tainted -> unit - val ValidateExpectedName : - m:Range.range -> - expectedPath:string [] -> - expectedName:string -> st:Tainted -> unit - val ValidateProvidedTypeAfterStaticInstantiation : - Range.range * Tainted * expectedPath:string [] * - expectedName:string -> unit - val ValidateProvidedTypeDefinition : - m:Range.range * st:Tainted * expectedPath:string [] * - expectedName:string -> unit - val ResolveProvidedType : - resolver:Tainted * m:Range.range * - moduleOrNamespace:string [] * typeName:string -> Tainted - val TryResolveProvidedType : - Tainted * Range.range * string [] * - typeName:string -> Tainted option - val ILPathToProvidedType : - st:Tainted * m:Range.range -> string list * string - val ComputeMangledNameForApplyStaticParameters : - nm:string * staticArgs:'a [] * - staticParams:Tainted * m:Range.range -> string - val TryApplyProvidedMethod : - methBeforeArgs:Tainted * staticArgs:obj [] * - Range.range -> Tainted option - val TryApplyProvidedType : - typeBeforeArguments:Tainted * - optGeneratedTypePath:string list option * staticArgs:obj [] * Range.range -> - (Tainted * (unit -> unit)) option - val TryLinkProvidedType : - Tainted * string [] * - typeLogicalName:string * range:Range.range -> Tainted option - val GetPartsOfNamespaceRecover : namespaceName:string -> string list - val GetProvidedNamespaceAsPath : - Range.range * Tainted * string -> - string list - val GetFSharpPathToProvidedType : - Tainted * range:Range.range -> string list - val GetOriginalILAssemblyRefOfProvidedAssembly : - assembly:Tainted * m:Range.range -> - AbstractIL.IL.ILAssemblyRef - val GetOriginalILTypeRefOfProvidedType : - Tainted * range:Range.range -> AbstractIL.IL.ILTypeRef - val GetILTypeRefOfProvidedType : - Tainted * range:Range.range -> AbstractIL.IL.ILTypeRef - type ProviderGeneratedType = - | ProviderGeneratedType of - AbstractIL.IL.ILTypeRef * AbstractIL.IL.ILTypeRef * - ProviderGeneratedType list - type ProvidedAssemblyStaticLinkingMap = - { ILTypeMap: - System.Collections.Generic.Dictionary } - with - static member CreateNew : unit -> ProvidedAssemblyStaticLinkingMap - end - val IsGeneratedTypeDirectReference : - Tainted * Range.range -> bool - end - -namespace FSharp.Compiler - module internal QuotationPickler = begin - val mkRLinear : mk:('a * 'b -> 'b) -> vs:'a list * body:'b -> 'b - type TypeVarData = - { tvName: string } - type NamedTypeData = - | Idx of int - | Named of string * string - type TypeCombOp = - | ArrayTyOp of int - | FunTyOp - | NamedTyOp of NamedTypeData - type TypeData = - | VarType of int - | AppType of TypeCombOp * TypeData list - val mkVarTy : int -> TypeData - val mkFunTy : (TypeData * TypeData) -> TypeData - val mkArrayTy : (int * TypeData) -> TypeData - val mkILNamedTy : (NamedTypeData * TypeData list) -> TypeData - type CtorData = - { ctorParent: NamedTypeData - ctorArgTypes: TypeData list } - type MethodData = - { methParent: NamedTypeData - methName: string - methArgTypes: TypeData list - methRetType: TypeData - numGenericArgs: int } - type VarData = - { vText: string - vType: TypeData - vMutable: bool } - type PropInfoData = NamedTypeData * string * TypeData * TypeData list - type CombOp = - | AppOp - | CondOp - | ModuleValueOp of NamedTypeData * string * bool - | ModuleValueWOp of NamedTypeData * string * bool * string * int - | LetRecOp - | LetRecCombOp - | LetOp - | RecdMkOp of NamedTypeData - | RecdGetOp of NamedTypeData * string - | RecdSetOp of NamedTypeData * string - | SumMkOp of NamedTypeData * string - | SumFieldGetOp of NamedTypeData * string * int - | SumTagTestOp of NamedTypeData * string - | TupleMkOp - | TupleGetOp of int - | UnitOp - | BoolOp of bool - | StringOp of string - | SingleOp of float32 - | DoubleOp of float - | CharOp of char - | SByteOp of sbyte - | ByteOp of byte - | Int16Op of int16 - | UInt16Op of uint16 - | Int32Op of int32 - | UInt32Op of uint32 - | Int64Op of int64 - | UInt64Op of uint64 - | PropGetOp of PropInfoData - | FieldGetOp of NamedTypeData * string - | CtorCallOp of CtorData - | MethodCallOp of MethodData - | MethodCallWOp of MethodData * MethodData * int - | CoerceOp - | NewArrayOp - | DelegateOp - | SeqOp - | ForLoopOp - | WhileLoopOp - | NullOp - | DefaultValueOp - | PropSetOp of PropInfoData - | FieldSetOp of NamedTypeData * string - | AddressOfOp - | ExprSetOp - | AddressSetOp - | TypeTestOp - | TryFinallyOp - | TryWithOp - type ExprData = - | AttrExpr of ExprData * ExprData list - | CombExpr of CombOp * TypeData list * ExprData list - | VarExpr of int - | QuoteExpr of ExprData - | LambdaExpr of VarData * ExprData - | HoleExpr of TypeData * int - | ThisVarExpr of TypeData - | QuoteRawExpr of ExprData - val mkVar : int -> ExprData - val mkHole : TypeData * int -> ExprData - val mkApp : ExprData * ExprData -> ExprData - val mkLambda : VarData * ExprData -> ExprData - val mkQuote : ExprData -> ExprData - val mkQuoteRaw40 : ExprData -> ExprData - val mkCond : ExprData * ExprData * ExprData -> ExprData - val mkModuleValueApp : - NamedTypeData * string * bool * TypeData list * ExprData list -> ExprData - val mkModuleValueWApp : - NamedTypeData * string * bool * string * int * TypeData list * - ExprData list -> ExprData - val mkTuple : TypeData * ExprData list -> ExprData - val mkLet : (VarData * ExprData) * ExprData -> ExprData - val mkUnit : unit -> ExprData - val mkNull : TypeData -> ExprData - val mkLetRecRaw : e1:ExprData -> ExprData - val mkLetRecCombRaw : args:ExprData list -> ExprData - val mkLetRec : (VarData * ExprData) list * ExprData -> ExprData - val mkRecdMk : NamedTypeData * TypeData list * ExprData list -> ExprData - val mkRecdGet : - NamedTypeData * string * TypeData list * ExprData list -> ExprData - val mkRecdSet : - NamedTypeData * string * TypeData list * ExprData list -> ExprData - val mkUnion : - NamedTypeData * string * TypeData list * ExprData list -> ExprData - val mkUnionFieldGet : - NamedTypeData * string * int * TypeData list * ExprData -> ExprData - val mkUnionCaseTagTest : - NamedTypeData * string * TypeData list * ExprData -> ExprData - val mkTupleGet : TypeData * int * ExprData -> ExprData - val mkCoerce : TypeData * ExprData -> ExprData - val mkTypeTest : TypeData * ExprData -> ExprData - val mkAddressOf : ExprData -> ExprData - val mkAddressSet : ExprData * ExprData -> ExprData - val mkVarSet : ExprData * ExprData -> ExprData - val mkDefaultValue : TypeData -> ExprData - val mkThisVar : TypeData -> ExprData - val mkNewArray : TypeData * ExprData list -> ExprData - val mkBool : bool * TypeData -> ExprData - val mkString : string * TypeData -> ExprData - val mkSingle : float32 * TypeData -> ExprData - val mkDouble : float * TypeData -> ExprData - val mkChar : char * TypeData -> ExprData - val mkSByte : sbyte * TypeData -> ExprData - val mkByte : byte * TypeData -> ExprData - val mkInt16 : int16 * TypeData -> ExprData - val mkUInt16 : uint16 * TypeData -> ExprData - val mkInt32 : int32 * TypeData -> ExprData - val mkUInt32 : uint32 * TypeData -> ExprData - val mkInt64 : int64 * TypeData -> ExprData - val mkUInt64 : uint64 * TypeData -> ExprData - val mkSequential : ExprData * ExprData -> ExprData - val mkForLoop : ExprData * ExprData * ExprData -> ExprData - val mkWhileLoop : ExprData * ExprData -> ExprData - val mkTryFinally : ExprData * ExprData -> ExprData - val mkTryWith : - ExprData * VarData * ExprData * VarData * ExprData -> ExprData - val mkDelegate : TypeData * ExprData -> ExprData - val mkPropGet : PropInfoData * TypeData list * ExprData list -> ExprData - val mkPropSet : PropInfoData * TypeData list * ExprData list -> ExprData - val mkFieldGet : - NamedTypeData * string * TypeData list * ExprData list -> ExprData - val mkFieldSet : - NamedTypeData * string * TypeData list * ExprData list -> ExprData - val mkCtorCall : CtorData * TypeData list * ExprData list -> ExprData - val mkMethodCall : MethodData * TypeData list * ExprData list -> ExprData - val mkMethodCallW : - MethodData * MethodData * int * TypeData list * ExprData list -> ExprData - val mkAttributedExpression : ExprData * ExprData -> ExprData - val isAttributedExpression : ExprData -> bool - val SerializedReflectedDefinitionsResourceNameBase : string - val freshVar : string * TypeData * bool -> VarData - module SimplePickle = begin - type Table<'T> = - { tbl: Internal.Utilities.Collections.HashMultiMap<'T,int> - mutable rows: 'T list - mutable count: int } - with - static member Create : unit -> Table<'a> when 'a : equality - member Add : x:'T -> int - member ContainsKey : x:'T -> bool - member Find : x:'T -> int - member FindOrAdd : x:'T -> int - member AsList : 'T list - member Count : int - end - type QuotationPickleOutState = - { os: AbstractIL.Internal.ByteBuffer - ostrings: Table } - val p_byte : b:int -> st:QuotationPickleOutState -> unit - val p_bool : b:bool -> st:QuotationPickleOutState -> unit - val p_void : _os:QuotationPickleOutState -> unit - val p_unit : unit -> _os:QuotationPickleOutState -> unit - val prim_pint32 : i:int -> st:QuotationPickleOutState -> unit - val p_int32 : n:int -> st:QuotationPickleOutState -> unit - val p_bytes : s:byte [] -> st:QuotationPickleOutState -> unit - val prim_pstring : s:string -> st:QuotationPickleOutState -> unit - val p_int : c:int -> st:QuotationPickleOutState -> unit - val p_int8 : i:int8 -> st:QuotationPickleOutState -> unit - val p_uint8 : i:uint8 -> st:QuotationPickleOutState -> unit - val p_int16 : i:int16 -> st:QuotationPickleOutState -> unit - val p_uint16 : x:uint16 -> st:QuotationPickleOutState -> unit - val puint32 : x:uint32 -> st:QuotationPickleOutState -> unit - val p_int64 : i:int64 -> st:QuotationPickleOutState -> unit - val bits_of_float32 : x:float32 -> int - val bits_of_float : x:float -> int64 - val p_uint64 : x:uint64 -> st:QuotationPickleOutState -> unit - val p_double : i:float -> st:QuotationPickleOutState -> unit - val p_single : i:float32 -> st:QuotationPickleOutState -> unit - val p_char : i:char -> st:QuotationPickleOutState -> unit - val inline p_tup2 : - p1:('a -> QuotationPickleOutState -> unit) -> - p2:('b -> QuotationPickleOutState -> unit) -> - a:'a * b:'b -> st:QuotationPickleOutState -> unit - val inline p_tup3 : - p1:('a -> 'b -> unit) -> - p2:('c -> 'b -> unit) -> - p3:('d -> 'b -> unit) -> a:'a * b:'c * c:'d -> st:'b -> unit - val inline p_tup4 : - p1:('a -> 'b -> unit) -> - p2:('c -> 'b -> unit) -> - p3:('d -> 'b -> unit) -> - p4:('e -> 'b -> unit) -> - a:'a * b:'c * c:'d * d:'e -> st:'b -> unit - val inline p_tup5 : - p1:('a -> 'b -> unit) -> - p2:('c -> 'b -> unit) -> - p3:('d -> 'b -> unit) -> - p4:('e -> 'b -> unit) -> - p5:('f -> 'b -> unit) -> - a:'a * b:'c * c:'d * d:'e * e:'f -> st:'b -> unit - val puniq : tbl:Table<'a> -> key:'a -> st:QuotationPickleOutState -> unit - val p_string : s:string -> st:QuotationPickleOutState -> unit - val p_list : - f:('a -> QuotationPickleOutState -> unit) -> - x:'a list -> st:QuotationPickleOutState -> unit - val pickle_obj : - p:('a -> QuotationPickleOutState -> unit) -> x:'a -> byte [] - end - val p_assemblyref : - x:string -> st:SimplePickle.QuotationPickleOutState -> unit - val p_NamedType : - x:NamedTypeData -> st:SimplePickle.QuotationPickleOutState -> unit - val p_tycon : - x:TypeCombOp -> st:SimplePickle.QuotationPickleOutState -> unit - val p_type : x:TypeData -> st:SimplePickle.QuotationPickleOutState -> unit - val p_types : - x:TypeData list -> st:SimplePickle.QuotationPickleOutState -> unit - val p_varDecl : v:VarData -> st:SimplePickle.QuotationPickleOutState -> unit - val p_recdFieldSpec : - NamedTypeData * string -> st:SimplePickle.QuotationPickleOutState -> unit - val p_ucaseSpec : - NamedTypeData * string -> st:SimplePickle.QuotationPickleOutState -> unit - val p_MethodData : - a:MethodData -> st:SimplePickle.QuotationPickleOutState -> unit - val p_CtorData : - a:CtorData -> st:SimplePickle.QuotationPickleOutState -> unit - val p_PropInfoData : - NamedTypeData * string * TypeData * TypeData list -> - st:SimplePickle.QuotationPickleOutState -> unit - val p_CombOp : x:CombOp -> st:SimplePickle.QuotationPickleOutState -> unit - val p_expr : x:ExprData -> st:SimplePickle.QuotationPickleOutState -> unit - type ModuleDefnData = - { Module: NamedTypeData - Name: string - IsProperty: bool } - type MethodBaseData = - | ModuleDefn of ModuleDefnData * (string * int) option - | Method of MethodData - | Ctor of CtorData - val pickle : (ExprData -> byte []) - val p_MethodBase : - x:MethodBaseData -> st:SimplePickle.QuotationPickleOutState -> unit - val PickleDefns : ((MethodBaseData * ExprData) list -> byte []) - end - -namespace FSharp.Compiler - module CompilerGlobalState = begin - type NiceNameGenerator = - class - new : unit -> NiceNameGenerator - member - FreshCompilerGeneratedName : name:string * m:Range.range -> string - member Reset : unit -> unit - end - type StableNiceNameGenerator = - class - new : unit -> StableNiceNameGenerator - member - GetUniqueCompilerGeneratedName : name:string * m:Range.range * - uniq:int64 -> string - member Reset : unit -> unit - end - type internal CompilerGlobalState = - class - new : unit -> CompilerGlobalState - member IlxGenNiceNameGenerator : NiceNameGenerator - member NiceNameGenerator : NiceNameGenerator - member StableNameGenerator : StableNiceNameGenerator - end - type Unique = int64 - val newUnique : (unit -> int64) - val newStamp : (unit -> int64) - end - -namespace FSharp.Compiler - module internal TypedTree = begin - type Stamp = int64 - and StampMap<'T> = Map - [] - and ValInline = - | PseudoVal - | Always - | Optional - | Never - with - member MustInline : bool - end - and ValRecursiveScopeInfo = - | ValInRecScope of bool - | ValNotInRecScope - and ValMutability = - | Immutable - | Mutable - [] - and TyparDynamicReq = - | No - | Yes - and ValBaseOrThisInfo = - | CtorThisVal - | BaseVal - | NormalVal - | MemberThisVal - [] - and ValFlags = - struct - new : recValInfo:ValRecursiveScopeInfo * baseOrThis:ValBaseOrThisInfo * - isCompGen:bool * inlineInfo:ValInline * isMutable:ValMutability * - isModuleOrMemberBinding:bool * isExtensionMember:bool * - isIncrClassSpecialMember:bool * isTyFunc:bool * allowTypeInst:bool * - isGeneratedEventVal:bool -> ValFlags - new : flags:int64 -> ValFlags - member SetIsCompilerGenerated : isCompGen:bool -> ValFlags - member - WithRecursiveValInfo : recValInfo:ValRecursiveScopeInfo -> ValFlags - member BaseOrThisInfo : ValBaseOrThisInfo - member HasBeenReferenced : bool - member IgnoresByrefScope : bool - member InlineInfo : ValInline - member IsCompiledAsStaticPropertyWithoutField : bool - member IsCompilerGenerated : bool - member IsExtensionMember : bool - member IsFixed : bool - member IsGeneratedEventVal : bool - member IsIncrClassSpecialMember : bool - member IsMemberOrModuleBinding : bool - member IsTypeFunction : bool - member MakesNoCriticalTailcalls : bool - member MutabilityInfo : ValMutability - member PermitsExplicitTypeInstantiation : bool - member PickledBits : int64 - member RecursiveValInfo : ValRecursiveScopeInfo - member WithHasBeenReferenced : ValFlags - member WithIgnoresByrefScope : ValFlags - member WithIsCompiledAsStaticPropertyWithoutField : ValFlags - member WithIsFixed : ValFlags - member WithIsMemberOrModuleBinding : ValFlags - member WithMakesNoCriticalTailcalls : ValFlags - end - [] - and TyparKind = - | Type - | Measure - with - override ToString : unit -> string - member AttrName : string voption - end - [] - and TyparRigidity = - | Rigid - | WillBeRigid - | WarnIfNotRigid - | Flexible - | Anon - with - member ErrorIfUnified : bool - member WarnIfMissingConstraint : bool - member WarnIfUnified : bool - end - [] - and TyparFlags = - struct - new : kind:TyparKind * rigidity:TyparRigidity * isFromError:bool * - isCompGen:bool * staticReq:SyntaxTree.TyparStaticReq * - dynamicReq:TyparDynamicReq * equalityDependsOn:bool * - comparisonDependsOn:bool -> TyparFlags - new : flags:int32 -> TyparFlags - member WithCompatFlex : b:bool -> TyparFlags - member ComparisonConditionalOn : bool - member DynamicReq : TyparDynamicReq - member EqualityConditionalOn : bool - member IsCompatFlex : bool - member IsCompilerGenerated : bool - member IsFromError : bool - member Kind : TyparKind - member PickledBits : int32 - member Rigidity : TyparRigidity - member StaticReq : SyntaxTree.TyparStaticReq - end - [] - and EntityFlags = - struct - new : usesPrefixDisplay:bool * isModuleOrNamespace:bool * - preEstablishedHasDefaultCtor:bool * hasSelfReferentialCtor:bool * - isStructRecordOrUnionType:bool -> EntityFlags - new : flags:int64 -> EntityFlags - member WithIsAssumedReadOnly : flag:bool -> EntityFlags - member WithIsByRefLike : flag:bool -> EntityFlags - member WithIsReadOnly : flag:bool -> EntityFlags - member HasSelfReferentialConstructor : bool - member IsModuleOrNamespace : bool - member IsPrefixDisplay : bool - member IsStructRecordOrUnionType : bool - member PickledBits : int64 - member PreEstablishedHasDefaultConstructor : bool - member TryIsAssumedReadOnly : bool voption - member TryIsByRefLike : bool voption - member TryIsReadOnly : bool voption - static member ReservedBitForPickleFormatTyconReprFlag : int64 - end - and UndefinedName = - with - inherit exn - interface System.Collections.IStructuralEquatable - val Data0: int - val Data1: string -> string - val Data2: SyntaxTree.Ident - val Data3: ErrorLogger.Suggestions - end - and InternalUndefinedItemRef = - with - inherit exn - interface System.Collections.IStructuralEquatable - val Data0: string * string * string -> int * string - val Data1: string - val Data2: string - val Data3: string - end - and ModuleOrNamespaceKind = - | FSharpModuleWithSuffix - | ModuleOrType - | Namespace - and PublicPath = - | PubPath of string [] - with - member EnclosingPath : string [] - end - and CompilationPath = - | CompPath of - AbstractIL.IL.ILScopeRef * (string * ModuleOrNamespaceKind) list - with - static member - DemangleEntityName : nm:string -> k:ModuleOrNamespaceKind -> string - member - NestedCompPath : n:string -> - modKind:ModuleOrNamespaceKind -> CompilationPath - member NestedPublicPath : id:SyntaxTree.Ident -> PublicPath - member AccessPath : (string * ModuleOrNamespaceKind) list - member DemangledPath : string list - member ILScopeRef : AbstractIL.IL.ILScopeRef - member MangledPath : string list - member ParentCompPath : CompilationPath - end - [] - and EntityOptionalData = - { mutable entity_compiled_name: string option - mutable entity_other_range: (Range.range * bool) option - mutable entity_kind: TyparKind - mutable entity_xmldoc: XmlDoc.XmlDoc - mutable entity_xmldocsig: string - mutable entity_tycon_abbrev: TType option - mutable entity_tycon_repr_accessibility: Accessibility - mutable entity_accessibility: Accessibility - mutable entity_exn_info: ExceptionInfo } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and Entity = - { mutable entity_typars: - AbstractIL.Internal.Library.LazyWithContext - mutable entity_flags: EntityFlags - mutable entity_stamp: Stamp - mutable entity_logical_name: string - mutable entity_range: Range.range - mutable entity_attribs: Attribs - mutable entity_tycon_repr: TyconRepresentation - mutable entity_tycon_tcaug: TyconAugmentation - mutable entity_modul_contents: Lib.MaybeLazy - mutable entity_pubpath: PublicPath option - mutable entity_cpath: CompilationPath option - mutable entity_il_repr_cache: Lib.cache - mutable entity_opt_data: EntityOptionalData option } - with - static member New : _reason:'b -> data:Entity -> Entity - static member NewEmptyEntityOptData : unit -> EntityOptionalData - static member NewUnlinked : unit -> Entity - member - GetDisplayName : ?withStaticParameters:bool * ?withTypars:bool * - ?withUnderscoreTypars:bool -> string - member GetFieldByIndex : n:int -> RecdField - member GetFieldByName : n:string -> RecdField option - member GetUnionCaseByName : n:string -> UnionCase option - member Link : tg:EntityData -> unit - member SetAttribs : attribs:Attribs -> unit - member SetCompiledName : name:string option -> unit - member SetExceptionInfo : exn_info:ExceptionInfo -> unit - member SetIsAssumedReadOnly : b:bool -> unit - member SetIsByRefLike : b:bool -> unit - member SetIsReadOnly : b:bool -> unit - member SetIsStructRecordOrUnion : b:bool -> unit - member SetOtherRange : m:(Range.range * bool) -> unit - member SetTypeAbbrev : tycon_abbrev:TType option -> unit - member SetTypeOrMeasureKind : kind:TyparKind -> unit - override ToString : unit -> string - member Typars : m:Range.range -> Typars - member Accessibility : Accessibility - member AllFieldTable : TyconRecdFields - member AllFieldsArray : RecdField [] - member AllFieldsAsList : RecdField list - member AllGeneratedValues : ValRef list - member AllInstanceFieldsAsList : RecdField list - member Attribs : Attribs - member CompilationPath : CompilationPath - member CompilationPathOpt : CompilationPath option - member CompiledName : string - member CompiledReprCache : Lib.cache - member CompiledRepresentation : CompiledTypeRepr - member CompiledRepresentationForNamedType : AbstractIL.IL.ILTypeRef - [ (0))>] - member DebugText : string - member DefinitionRange : Range.range - member DemangledModuleOrNamespaceName : string - member DisplayName : string - member DisplayNameWithStaticParameters : string - member DisplayNameWithStaticParametersAndTypars : string - member DisplayNameWithStaticParametersAndUnderscoreTypars : string - member EntityCompiledName : string option - member ExceptionInfo : ExceptionInfo - member FSharpObjectModelTypeInfo : TyconObjModelData - member GeneratedCompareToValues : (ValRef * ValRef) option - member GeneratedCompareToWithComparerValues : ValRef option - member GeneratedHashAndEqualsValues : (ValRef * ValRef) option - member - GeneratedHashAndEqualsWithComparerValues : (ValRef * ValRef * ValRef) option - member HasSelfReferentialConstructor : bool - member ILTyconInfo : TILObjectReprData - member ILTyconRawMetadata : AbstractIL.IL.ILTypeDef - member Id : SyntaxTree.Ident - member ImmediateInterfaceTypesOfFSharpTycon : TType list - member - ImmediateInterfacesOfFSharpTycon : (TType * bool * Range.range) list - member IsAsmReprTycon : bool - member IsEnumTycon : bool - member IsErased : bool - member IsExceptionDecl : bool - member IsFSharpClassTycon : bool - member IsFSharpDelegateTycon : bool - member IsFSharpEnumTycon : bool - member IsFSharpInterfaceTycon : bool - member IsFSharpObjectModelTycon : bool - member IsFSharpStructOrEnumTycon : bool - member IsHiddenReprTycon : bool - member IsILEnumTycon : bool - member IsILStructOrEnumTycon : bool - member IsILTycon : bool - member IsLinked : bool - member IsMeasureableReprTycon : bool - member IsModule : bool - member IsModuleOrNamespace : bool - member IsNamespace : bool - member IsPrefixDisplay : bool - member IsProvided : bool - member IsProvidedErasedTycon : bool - member IsProvidedGeneratedTycon : bool - member IsProvidedNamespace : bool - member IsRecordTycon : bool - member IsStaticInstantiationTycon : bool - member IsStructOrEnumTycon : bool - member IsStructRecordOrUnionTycon : bool - member IsTypeAbbrev : bool - member IsUnionTycon : bool - member LogicalName : string - member - MembersOfFSharpTyconByName : AbstractIL.Internal.Library.NameMultiMap - member MembersOfFSharpTyconSorted : ValRef list - member ModuleOrNamespaceType : ModuleOrNamespaceType - member PreEstablishedHasDefaultConstructor : bool - member PublicPath : PublicPath option - member Range : Range.range - member SigRange : Range.range - member Stamp : Stamp - member TrueFieldsAsList : RecdField list - member TrueInstanceFieldsAsList : RecdField list - member TryIsAssumedReadOnly : bool voption - member TryIsByRefLike : bool voption - member TryIsReadOnly : bool voption - member TyparsNoRange : Typars - member TypeAbbrev : TType option - member TypeContents : TyconAugmentation - member TypeOrMeasureKind : TyparKind - member TypeReprAccessibility : Accessibility - member TypeReprInfo : TyconRepresentation - member UnionCasesArray : UnionCase [] - member UnionCasesAsList : UnionCase list - member UnionTypeInfo : TyconUnionData voption - member XmlDoc : XmlDoc.XmlDoc - member XmlDocSig : string - end - and EntityData = Entity - and ParentRef = - | Parent of EntityRef - | ParentNone - [] - and CompiledTypeRepr = - | ILAsmNamed of - AbstractIL.IL.ILTypeRef * AbstractIL.IL.ILBoxity * - AbstractIL.IL.ILType option - | ILAsmOpen of AbstractIL.IL.ILType - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and TyconAugmentation = - { mutable tcaug_compare: (ValRef * ValRef) option - mutable tcaug_compare_withc: ValRef option - mutable tcaug_equals: (ValRef * ValRef) option - mutable tcaug_hash_and_equals_withc: (ValRef * ValRef * ValRef) option - mutable tcaug_hasObjectGetHashCode: bool - tcaug_adhoc_list: ResizeArray - mutable tcaug_adhoc: AbstractIL.Internal.Library.NameMultiMap - mutable tcaug_interfaces: (TType * bool * Range.range) list - mutable tcaug_super: TType option - mutable tcaug_closed: bool - mutable tcaug_abstract: bool } - with - static member Create : unit -> TyconAugmentation - member SetCompare : x:(ValRef * ValRef) -> unit - member SetCompareWith : x:ValRef -> unit - member SetEquals : x:(ValRef * ValRef) -> unit - member SetHasObjectGetHashCode : b:bool -> unit - member SetHashAndEqualsWith : x:(ValRef * ValRef * ValRef) -> unit - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and TyconRepresentation = - | TFSharpObjectRepr of TyconObjModelData - | TRecdRepr of TyconRecdFields - | TUnionRepr of TyconUnionData - | TILObjectRepr of TILObjectReprData - | TAsmRepr of AbstractIL.IL.ILType - | TMeasureableRepr of TType - | TProvidedTypeExtensionPoint of TProvidedTypeInfo - | TProvidedNamespaceExtensionPoint of - ExtensionTyping.ResolutionEnvironment * - Tainted list - | TNoRepr - with - override ToString : unit -> string - end - [] - and TILObjectReprData = - | TILObjectReprData of - scope: AbstractIL.IL.ILScopeRef * nesting: AbstractIL.IL.ILTypeDef list * - definition: AbstractIL.IL.ILTypeDef - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and TProvidedTypeInfo = - { ResolutionEnvironment: ExtensionTyping.ResolutionEnvironment - ProvidedType: Tainted - LazyBaseType: - AbstractIL.Internal.Library.LazyWithContext - IsClass: bool - IsSealed: bool - IsAbstract: bool - IsInterface: bool - IsStructOrEnum: bool - IsEnum: bool - UnderlyingTypeOfEnum: unit -> TType - IsDelegate: unit -> bool - IsErased: bool - IsSuppressRelocate: bool } - with - member BaseTypeForErased : m:Range.range * objTy:TType -> TType - override ToString : unit -> string - [ (0))>] - member DebugText : string - member IsGenerated : bool - end - and TyconObjModelKind = - | TTyconClass - | TTyconInterface - | TTyconStruct - | TTyconDelegate of SlotSig - | TTyconEnum - with - member IsValueType : bool - end - [] - and TyconObjModelData = - { fsobjmodel_kind: TyconObjModelKind - fsobjmodel_vslots: ValRef list - fsobjmodel_rfields: TyconRecdFields } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and TyconRecdFields = - { FieldsByIndex: RecdField [] - FieldsByName: AbstractIL.Internal.Library.NameMap } - with - member FieldByIndex : n:int -> RecdField - member FieldByName : nm:string -> RecdField option - override ToString : unit -> string - member AllFieldsAsList : RecdField list - [ (0))>] - member DebugText : string - member TrueFieldsAsList : RecdField list - member TrueInstanceFieldsAsList : RecdField list - end - [] - and TyconUnionCases = - { CasesByIndex: UnionCase [] - CasesByName: AbstractIL.Internal.Library.NameMap } - with - member GetUnionCaseByIndex : n:int -> UnionCase - override ToString : unit -> string - [ (0))>] - member DebugText : string - member UnionCasesAsList : UnionCase list - end - [] - and TyconUnionData = - { CasesTable: TyconUnionCases - CompiledRepresentation: - Lib.cache } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - member UnionCasesAsList : UnionCase list - end - [] - and UnionCase = - { FieldTable: TyconRecdFields - ReturnType: TType - XmlDoc: XmlDoc.XmlDoc - mutable XmlDocSig: string - Id: SyntaxTree.Ident - mutable OtherRangeOpt: (Range.range * bool) option - Accessibility: Accessibility - mutable Attribs: Attribs } - with - member GetFieldByIndex : n:int -> RecdField - member GetFieldByName : nm:string -> RecdField option - override ToString : unit -> string - member CompiledName : string - [ (0))>] - member DebugText : string - member DefinitionRange : Range.range - member DisplayName : string - member IsNullary : bool - member Range : Range.range - member RecdFields : RecdField list - member RecdFieldsArray : RecdField [] - member SigRange : Range.range - end - [] - and RecdField = - { rfield_mutable: bool - rfield_xmldoc: XmlDoc.XmlDoc - mutable rfield_xmldocsig: string - rfield_type: TType - rfield_static: bool - rfield_volatile: bool - rfield_secret: bool - rfield_const: Const option - rfield_access: Accessibility - mutable rfield_pattribs: Attribs - mutable rfield_fattribs: Attribs - rfield_id: SyntaxTree.Ident - rfield_name_generated: bool - mutable rfield_other_range: (Range.range * bool) option } - with - override ToString : unit -> string - member Accessibility : Accessibility - [ (0))>] - member DebugText : string - member DefinitionRange : Range.range - member FieldAttribs : Attribs - member FormalType : TType - member Id : SyntaxTree.Ident - member IsCompilerGenerated : bool - member IsMutable : bool - member IsStatic : bool - member IsVolatile : bool - member IsZeroInit : bool - member LiteralValue : Const option - member Name : string - member PropertyAttribs : Attribs - member Range : Range.range - member SigRange : Range.range - member XmlDoc : XmlDoc.XmlDoc - member XmlDocSig : string - end - [] - and ExceptionInfo = - | TExnAbbrevRepr of TyconRef - | TExnAsmRepr of AbstractIL.IL.ILTypeRef - | TExnFresh of TyconRecdFields - | TExnNone - with - override ToString : unit -> string - end - [] - and ModuleOrNamespaceType = - class - new : kind:ModuleOrNamespaceKind * - vals:Internal.Utilities.QueueList * - entities:Internal.Utilities.QueueList -> - ModuleOrNamespaceType - member AddEntity : tycon:Tycon -> ModuleOrNamespaceType - member AddModuleOrNamespaceByMutation : modul:ModuleOrNamespace -> unit - member AddProvidedTypeEntity : entity:Entity -> unit - member AddVal : vspec:Val -> ModuleOrNamespaceType - override ToString : unit -> string - member TryLinkVal : ccu:CcuThunk * key:ValLinkageFullKey -> Val voption - member - ActivePatternElemRefLookupTable : AbstractIL.Internal.Library.NameMap option ref - member AllEntities : Internal.Utilities.QueueList - member - AllEntitiesByCompiledAndLogicalMangledNames : AbstractIL.Internal.Library.NameMap - member - AllEntitiesByLogicalMangledName : AbstractIL.Internal.Library.NameMap - member AllValsAndMembers : Internal.Utilities.QueueList - member - AllValsAndMembersByLogicalNameUncached : AbstractIL.Internal.Library.MultiMap - member - AllValsAndMembersByPartialLinkageKey : AbstractIL.Internal.Library.MultiMap - member AllValsByLogicalName : AbstractIL.Internal.Library.NameMap - [ (0))>] - member DebugText : string - member ExceptionDefinitions : Entity list - member - ExceptionDefinitionsByDemangledName : AbstractIL.Internal.Library.NameMap - member ModuleAndNamespaceDefinitions : Entity list - member ModuleOrNamespaceKind : ModuleOrNamespaceKind - member - ModulesAndNamespacesByDemangledName : AbstractIL.Internal.Library.NameMap - member TypeAndExceptionDefinitions : Entity list - member TypeDefinitions : Entity list - member - TypesByAccessNames : AbstractIL.Internal.Library.LayeredMultiMap - member - TypesByDemangledNameAndArity : AbstractIL.Internal.Library.LayeredMap - member TypesByMangledName : AbstractIL.Internal.Library.NameMap - end - and ModuleOrNamespace = Entity - and Tycon = Entity - [] - and Accessibility = - | TAccess of CompilationPath list - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and TyparOptionalData = - { mutable typar_il_name: string option - mutable typar_xmldoc: XmlDoc.XmlDoc - mutable typar_constraints: TyparConstraint list - mutable typar_attribs: Attribs } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - and TyparData = Typar - [] - and Typar = - { mutable typar_id: SyntaxTree.Ident - mutable typar_flags: TyparFlags - mutable typar_stamp: Stamp - mutable typar_solution: TType option - mutable typar_astype: TType - mutable typar_opt_data: TyparOptionalData option } - with - static member New : data:TyparData -> Typar - static member NewUnlinked : unit -> Typar - member Link : tg:TyparData -> unit - member SetAttribs : attribs:Attrib list -> unit - member SetComparisonDependsOn : b:bool -> unit - member SetCompilerGenerated : b:bool -> unit - member SetConstraints : cs:TyparConstraint list -> unit - member SetDynamicReq : b:TyparDynamicReq -> unit - member SetEqualityDependsOn : b:bool -> unit - member SetILName : il_name:string option -> unit - member SetIdent : id:SyntaxTree.Ident -> unit - member SetIsCompatFlex : b:bool -> unit - member SetRigidity : b:TyparRigidity -> unit - member SetStaticReq : b:SyntaxTree.TyparStaticReq -> unit - override ToString : unit -> string - member AsType : TType - member Attribs : Attribs - member ComparisonConditionalOn : bool - member Constraints : TyparConstraint list - [ (0))>] - member DebugText : string - member DisplayName : string - member DynamicReq : TyparDynamicReq - member EqualityConditionalOn : bool - member ILName : string option - member Id : SyntaxTree.Ident - member IsCompatFlex : bool - member IsCompilerGenerated : bool - member IsErased : bool - member IsFromError : bool - member IsLinked : bool - member IsSolved : bool - member Kind : TyparKind - member Name : string - member Range : Range.range - member Rigidity : TyparRigidity - member Solution : TType option - member Stamp : Stamp - member StaticReq : SyntaxTree.TyparStaticReq - member XmlDoc : XmlDoc.XmlDoc - end - [] - and TyparConstraint = - | CoercesTo of TType * Range.range - | DefaultsTo of int * TType * Range.range - | SupportsNull of Range.range - | MayResolveMember of TraitConstraintInfo * Range.range - | IsNonNullableStruct of Range.range - | IsReferenceType of Range.range - | SimpleChoice of TTypes * Range.range - | RequiresDefaultConstructor of Range.range - | IsEnum of TType * Range.range - | SupportsComparison of Range.range - | SupportsEquality of Range.range - | IsDelegate of TType * TType * Range.range - | IsUnmanaged of Range.range - with - override ToString : unit -> string - end - [] - and TraitWitnessInfo = - | TraitWitnessInfo of - TTypes * string * SyntaxTree.MemberFlags * TTypes * TType option - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - member MemberName : string - member ReturnType : TType option - end - [] - and TraitConstraintInfo = - | TTrait of - tys: TTypes * memberName: string * _memFlags: SyntaxTree.MemberFlags * - argTys: TTypes * returnTy: TType option * - solution: TraitConstraintSln option ref - with - override ToString : unit -> string - member ArgumentTypes : TTypes - [ (0))>] - member DebugText : string - member MemberFlags : SyntaxTree.MemberFlags - member MemberName : string - member ReturnType : TType option - member Solution : TraitConstraintSln option - member TraitKey : TraitWitnessInfo - end - [] - and TraitConstraintSln = - | FSMethSln of TType * ValRef * TypeInst - | FSRecdFieldSln of TypeInst * RecdFieldRef * bool - | FSAnonRecdFieldSln of AnonRecdTypeInfo * TypeInst * int - | ILMethSln of - TType * AbstractIL.IL.ILTypeRef option * AbstractIL.IL.ILMethodRef * - TypeInst - | ClosedExprSln of Expr - | BuiltInSln - with - override ToString : unit -> string - end - [] - and ValLinkagePartialKey = - { MemberParentMangledName: string option - MemberIsOverride: bool - LogicalName: string - TotalArgCount: int } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and ValLinkageFullKey = - class - new : partialKey:ValLinkagePartialKey * typeForLinkage:TType option -> - ValLinkageFullKey - override ToString : unit -> string - [ (0))>] - member DebugText : string - member PartialKey : ValLinkagePartialKey - member TypeForLinkage : TType option - end - [] - and ValOptionalData = - { mutable val_compiled_name: string option - mutable val_other_range: (Range.range * bool) option - mutable val_const: Const option - mutable val_defn: Expr option - mutable val_repr_info: ValReprInfo option - mutable val_access: Accessibility - mutable val_xmldoc: XmlDoc.XmlDoc - mutable val_member_info: ValMemberInfo option - mutable val_declaring_entity: ParentRef - mutable val_xmldocsig: string - mutable val_attribs: Attribs } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - and ValData = Val - [] - and Val = - { mutable val_logical_name: string - mutable val_range: Range.range - mutable val_type: TType - mutable val_stamp: Stamp - mutable val_flags: ValFlags - mutable val_opt_data: ValOptionalData option } - with - static member New : data:Val -> Val - static member NewEmptyValOptData : unit -> ValOptionalData - static member NewUnlinked : unit -> Val - member - CompiledName : compilerGlobalState:CompilerGlobalState.CompilerGlobalState option -> - string - member GetLinkageFullKey : unit -> ValLinkageFullKey - member GetLinkagePartialKey : unit -> ValLinkagePartialKey - member Link : tg:ValData -> unit - member SetAttribs : attribs:Attribs -> unit - member SetData : tg:ValData -> unit - member SetDeclaringEntity : parent:ParentRef -> unit - member SetHasBeenReferenced : unit -> unit - member SetIgnoresByrefScope : unit -> unit - member SetIsCompiledAsStaticPropertyWithoutField : unit -> unit - member SetIsFixed : unit -> unit - member SetIsMemberOrModuleBinding : unit -> unit - member SetMakesNoCriticalTailcalls : unit -> unit - member SetMemberInfo : member_info:ValMemberInfo -> unit - member SetOtherRange : m:(Range.range * bool) -> unit - member SetType : ty:TType -> unit - member SetValDefn : val_defn:Expr -> unit - member SetValRec : b:ValRecursiveScopeInfo -> unit - member SetValReprInfo : info:ValReprInfo option -> unit - override ToString : unit -> string - member Accessibility : Accessibility - member ApparentEnclosingEntity : ParentRef - member Attribs : Attrib list - member BaseOrThisInfo : ValBaseOrThisInfo - member CoreDisplayName : string - [ (0))>] - member DebugText : string - member DeclaringEntity : ParentRef - member DefinitionRange : Range.range - member DisplayName : string - member HasBeenReferenced : bool - member HasDeclaringEntity : bool - member Id : SyntaxTree.Ident - member IgnoresByrefScope : bool - member InlineInfo : ValInline - member IsClassConstructor : bool - member IsCompiledAsStaticPropertyWithoutField : bool - member IsCompiledAsTopLevel : bool - member IsCompiledIntoModule : bool - member IsCompilerGenerated : bool - member IsConstructor : bool - member IsDispatchSlot : bool - member IsExtensionMember : bool - member IsFixed : bool - member IsIncrClassConstructor : bool - member IsIncrClassGeneratedMember : bool - member IsInstanceMember : bool - member IsIntrinsicMember : bool - member IsLinked : bool - member IsMember : bool - member IsMemberOrModuleBinding : bool - member IsModuleBinding : bool - member IsMutable : bool - member IsOverrideOrExplicitImpl : bool - member IsTypeFunction : bool - member LiteralValue : Const option - member LogicalName : string - member MakesNoCriticalTailcalls : bool - member MemberApparentEntity : TyconRef - member MemberInfo : ValMemberInfo option - member MustInline : bool - member NumObjArgs : int - member PermitsExplicitTypeInstantiation : bool - member PropertyName : string - member PublicPath : ValPublicPath option - member Range : Range.range - member RecursiveValInfo : ValRecursiveScopeInfo - member ReflectedDefinition : Expr option - member SigRange : Range.range - member Stamp : Stamp - member TauType : TType - member TopValDeclaringEntity : EntityRef - member Typars : Typars - member Type : TType - member TypeScheme : Typars * TType - member ValCompiledName : string option - member ValReprInfo : ValReprInfo option - member XmlDoc : XmlDoc.XmlDoc - member XmlDocSig : string - end - [] - and ValMemberInfo = - { ApparentEnclosingEntity: TyconRef - mutable ImplementedSlotSigs: SlotSig list - mutable IsImplemented: bool - MemberFlags: SyntaxTree.MemberFlags } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and NonLocalValOrMemberRef = - { EnclosingEntity: EntityRef - ItemKey: ValLinkageFullKey } - with - override ToString : unit -> string - member AssemblyName : string - member Ccu : CcuThunk - [ (0))>] - member DebugText : string - end - [] - and ValPublicPath = - | ValPubPath of PublicPath * ValLinkageFullKey - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and NonLocalEntityRef = - | NonLocalEntityRef of CcuThunk * string [] - with - static member - TryDerefEntityPath : ccu:CcuThunk * path:string [] * i:int * - entity:Entity -> Entity voption - static member - TryDerefEntityPathViaProvidedType : ccu:CcuThunk * path:string [] * - i:int * entity:Entity -> - Entity voption - override ToString : unit -> string - member TryDeref : canError:bool -> Entity voption - member AssemblyName : string - member Ccu : CcuThunk - [ (0))>] - member DebugText : string - member Deref : Entity - member DisplayName : string - member EnclosingMangledPath : string [] - member LastItemMangledName : string - member ModuleOrNamespaceType : ModuleOrNamespaceType - member Path : string [] - end - [] - and EntityRef = - { mutable binding: Lib.NonNullSlot - nlr: NonLocalEntityRef } - with - member GetFieldByIndex : n:int -> RecdField - member GetFieldByName : n:string -> RecdField option - member GetUnionCaseByName : n:string -> UnionCase option - member MakeNestedRecdFieldRef : rf:RecdField -> RecdFieldRef - member MakeNestedUnionCaseRef : uc:UnionCase -> UnionCaseRef - member private Resolve : canError:bool -> unit - member SetIsAssumedReadOnly : b:bool -> unit - member SetIsByRefLike : b:bool -> unit - member SetIsReadOnly : b:bool -> unit - override ToString : unit -> string - member Typars : m:Range.range -> Typars - member Accessibility : Accessibility - member AllFieldAsRefList : RecdFieldRef list - member AllFieldTable : TyconRecdFields - member AllFieldsArray : RecdField [] - member AllFieldsAsList : RecdField list - member AllInstanceFieldsAsList : RecdField list - member Attribs : Attribs - member CanDeref : bool - member CompilationPath : CompilationPath - member CompilationPathOpt : CompilationPath option - member CompiledName : string - member CompiledReprCache : Lib.cache - member CompiledRepresentation : CompiledTypeRepr - member CompiledRepresentationForNamedType : AbstractIL.IL.ILTypeRef - [ (0))>] - member DebugText : string - member DefinitionRange : Range.range - member DemangledModuleOrNamespaceName : string - member Deref : Entity - member DisplayName : string - member DisplayNameWithStaticParameters : string - member DisplayNameWithStaticParametersAndTypars : string - member DisplayNameWithStaticParametersAndUnderscoreTypars : string - member ExceptionInfo : ExceptionInfo - member FSharpObjectModelTypeInfo : TyconObjModelData - member GeneratedCompareToValues : (ValRef * ValRef) option - member GeneratedCompareToWithComparerValues : ValRef option - member GeneratedHashAndEqualsValues : (ValRef * ValRef) option - member - GeneratedHashAndEqualsWithComparerValues : (ValRef * ValRef * ValRef) option - member HasSelfReferentialConstructor : bool - member ILTyconInfo : TILObjectReprData - member ILTyconRawMetadata : AbstractIL.IL.ILTypeDef - member Id : SyntaxTree.Ident - member ImmediateInterfaceTypesOfFSharpTycon : TType list - member - ImmediateInterfacesOfFSharpTycon : (TType * bool * Range.range) list - member IsAsmReprTycon : bool - member IsEnumTycon : bool - member IsErased : bool - member IsExceptionDecl : bool - member IsFSharpDelegateTycon : bool - member IsFSharpEnumTycon : bool - member IsFSharpInterfaceTycon : bool - member IsFSharpObjectModelTycon : bool - member IsFSharpStructOrEnumTycon : bool - member IsHiddenReprTycon : bool - member IsILEnumTycon : bool - member IsILStructOrEnumTycon : bool - member IsILTycon : bool - member IsLocalRef : bool - member IsMeasureableReprTycon : bool - member IsModule : bool - member IsModuleOrNamespace : bool - member IsNamespace : bool - member IsPrefixDisplay : bool - member IsProvided : bool - member IsProvidedErasedTycon : bool - member IsProvidedGeneratedTycon : bool - member IsProvidedNamespace : bool - member IsRecordTycon : bool - member IsResolved : bool - member IsStaticInstantiationTycon : bool - member IsStructOrEnumTycon : bool - member IsTypeAbbrev : bool - member IsUnionTycon : bool - member LogicalName : string - member - MembersOfFSharpTyconByName : AbstractIL.Internal.Library.NameMultiMap - member MembersOfFSharpTyconSorted : ValRef list - member ModuleOrNamespaceType : ModuleOrNamespaceType - member PreEstablishedHasDefaultConstructor : bool - member PublicPath : PublicPath option - member Range : Range.range - member ResolvedTarget : Lib.NonNullSlot - member SigRange : Range.range - member Stamp : Stamp - member TrueFieldsAsList : RecdField list - member TrueInstanceFieldsAsList : RecdField list - member TrueInstanceFieldsAsRefList : RecdFieldRef list - member TryDeref : Lib.NonNullSlot voption - member TryIsAssumedReadOnly : bool voption - member TryIsByRefLike : bool voption - member TryIsReadOnly : bool voption - member TyparsNoRange : Typars - member TypeAbbrev : TType option - member TypeContents : TyconAugmentation - member TypeOrMeasureKind : TyparKind - member TypeReprAccessibility : Accessibility - member TypeReprInfo : TyconRepresentation - member UnionCasesArray : UnionCase [] - member UnionCasesAsList : UnionCase list - member UnionCasesAsRefList : UnionCaseRef list - member UnionTypeInfo : TyconUnionData voption - member XmlDoc : XmlDoc.XmlDoc - member XmlDocSig : string - end - and ModuleOrNamespaceRef = EntityRef - and TyconRef = EntityRef - [] - and ValRef = - { mutable binding: Lib.NonNullSlot - nlr: NonLocalValOrMemberRef } - with - override ToString : unit -> string - member Accessibility : Accessibility - member ApparentEnclosingEntity : ParentRef - member Attribs : Attrib list - member BaseOrThisInfo : ValBaseOrThisInfo - member - CompiledName : (CompilerGlobalState.CompilerGlobalState option -> - string) - member CoreDisplayName : string - [ (0))>] - member DebugText : string - member DeclaringEntity : ParentRef - member DefinitionRange : Range.range - member Deref : Val - member DisplayName : string - member HasDeclaringEntity : bool - member Id : SyntaxTree.Ident - member InlineInfo : ValInline - member IsCompiledAsTopLevel : bool - member IsCompilerGenerated : bool - member IsConstructor : bool - member IsDispatchSlot : bool - member IsExtensionMember : bool - member IsIncrClassConstructor : bool - member IsIncrClassGeneratedMember : bool - member IsInstanceMember : bool - member IsLocalRef : bool - member IsMember : bool - member IsMemberOrModuleBinding : bool - member IsModuleBinding : bool - member IsMutable : bool - member IsOverrideOrExplicitImpl : bool - member IsPropertyGetterMethod : bool - member IsPropertySetterMethod : bool - member IsResolved : bool - member IsTypeFunction : bool - member LiteralValue : Const option - member LogicalName : string - member MakesNoCriticalTailcalls : bool - member MemberApparentEntity : TyconRef - member MemberInfo : ValMemberInfo option - member MustInline : bool - member NumObjArgs : int - member PermitsExplicitTypeInstantiation : bool - member PropertyName : string - member PublicPath : ValPublicPath option - member Range : Range.range - member RecursiveValInfo : ValRecursiveScopeInfo - member ReflectedDefinition : Expr option - member ResolvedTarget : Lib.NonNullSlot - member SigRange : Range.range - member Stamp : Stamp - member TauType : TType - member TopValDeclaringEntity : EntityRef - member TryDeref : Val voption - member Typars : Typars - member Type : TType - member TypeScheme : Typars * TType - member ValReprInfo : ValReprInfo option - member XmlDoc : XmlDoc.XmlDoc - member XmlDocSig : string - end - [] - and UnionCaseRef = - | UnionCaseRef of TyconRef * string - with - member FieldByIndex : n:int -> RecdField - override ToString : unit -> string - member AllFieldsAsList : RecdField list - member Attribs : Attribs - member CaseName : string - [ (0))>] - member DebugText : string - member DefinitionRange : Range.range - member Index : int - member Range : Range.range - member ReturnType : TType - member SigRange : Range.range - member TryUnionCase : UnionCase voption - member Tycon : Entity - member TyconRef : TyconRef - member UnionCase : UnionCase - end - [] - and RecdFieldRef = - | RecdFieldRef of TyconRef * string - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - member DefinitionRange : Range.range - member FieldName : string - member Index : int - member PropertyAttribs : Attribs - member Range : Range.range - member RecdField : RecdField - member SigRange : Range.range - member TryRecdField : RecdField voption - member Tycon : Entity - member TyconRef : TyconRef - end - [] - and TType = - | TType_forall of Typars * TType - | TType_app of TyconRef * TypeInst - | TType_anon of AnonRecdTypeInfo * TType list - | TType_tuple of TupInfo * TTypes - | TType_fun of TType * TType - | TType_ucase of UnionCaseRef * TypeInst - | TType_var of Typar - | TType_measure of Measure - with - member GetAssemblyName : unit -> string - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - and TypeInst = TType list - and TTypes = TType list - [] - and AnonRecdTypeInfo = - { mutable Assembly: CcuThunk - mutable TupInfo: TupInfo - mutable SortedIds: SyntaxTree.Ident [] - mutable Stamp: Stamp - mutable SortedNames: string [] } - with - static member - Create : ccu:CcuThunk * tupInfo:TupInfo * ids:SyntaxTree.Ident [] -> - AnonRecdTypeInfo - static member NewUnlinked : unit -> AnonRecdTypeInfo - member Link : d:AnonRecdTypeInfo -> unit - member ILTypeRef : AbstractIL.IL.ILTypeRef - member IsLinked : bool - end - [] - and TupInfo = | Const of bool - [] - and Measure = - | Var of Typar - | Con of TyconRef - | Prod of Measure * Measure - | Inv of Measure - | One - | RationalPower of Measure * Rational.Rational - with - override ToString : unit -> string - end - and Attribs = Attrib list - [] - and AttribKind = - | ILAttrib of AbstractIL.IL.ILMethodRef - | FSAttrib of ValRef - with - override ToString : unit -> string - end - [] - and Attrib = - | Attrib of - TyconRef * AttribKind * AttribExpr list * AttribNamedArg list * bool * - System.AttributeTargets option * Range.range - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - member Range : Range.range - member TyconRef : TyconRef - end - [] - and AttribExpr = - | AttribExpr of Expr * Expr - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and AttribNamedArg = - | AttribNamedArg of (string * TType * bool * AttribExpr) - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and Const = - | Bool of bool - | SByte of sbyte - | Byte of byte - | Int16 of int16 - | UInt16 of uint16 - | Int32 of int32 - | UInt32 of uint32 - | Int64 of int64 - | UInt64 of uint64 - | IntPtr of int64 - | UIntPtr of uint64 - | Single of single - | Double of double - | Char of char - | String of string - | Decimal of System.Decimal - | Unit - | Zero - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and DecisionTree = - | TDSwitch of - Expr * DecisionTreeCase list * DecisionTree option * Range.range - | TDSuccess of Exprs * int - | TDBind of Binding * DecisionTree - with - override ToString : unit -> string - end - [] - and DecisionTreeCase = - | TCase of DecisionTreeTest * DecisionTree - with - override ToString : unit -> string - member CaseTree : DecisionTree - [ (0))>] - member DebugText : string - member Discriminator : DecisionTreeTest - end - [] - and DecisionTreeTest = - | UnionCase of UnionCaseRef * TypeInst - | ArrayLength of int * TType - | Const of Const - | IsNull - | IsInst of TType * TType - | ActivePatternCase of - Expr * TTypes * (ValRef * TypeInst) option * int * - PrettyNaming.ActivePatternInfo - | Error of Range.range - with - override ToString : unit -> string - end - [] - and DecisionTreeTarget = - | TTarget of Val list * Expr * SyntaxTree.DebugPointForTarget - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - and Bindings = Binding list - [] - and Binding = - | TBind of Val * Expr * SyntaxTree.DebugPointForBinding - with - override ToString : unit -> string - member DebugPoint : SyntaxTree.DebugPointForBinding - [ (0))>] - member DebugText : string - member Expr : Expr - member Var : Val - end - [] - and ActivePatternElemRef = - | APElemRef of PrettyNaming.ActivePatternInfo * ValRef * int - with - override ToString : unit -> string - member ActivePatternInfo : PrettyNaming.ActivePatternInfo - member ActivePatternVal : ValRef - member CaseIndex : int - [ (0))>] - member DebugText : string - end - [] - and ValReprInfo = - | ValReprInfo of TyparReprInfo list * ArgReprInfo list list * ArgReprInfo - with - override ToString : unit -> string - member ArgInfos : ArgReprInfo list list - member ArgNames : string list option - member AritiesOfArgs : int list - [ (0))>] - member DebugText : string - member HasNoArgs : bool - member KindsOfTypars : TyparKind list - member NumCurriedArgs : int - member NumTypars : int - member TotalArgCount : int - end - [] - and ArgReprInfo = - { mutable Attribs: Attribs - mutable Name: SyntaxTree.Ident option } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - and TyparReprInfo = | TyparReprInfo of SyntaxTree.Ident * TyparKind - and Typars = Typar list - and Exprs = Expr list - and Vals = Val list - [] - and Expr = - | Const of value: Const * range: Range.range * constType: TType - | Val of valRef: ValRef * flags: ValUseFlag * range: Range.range - | Sequential of - expr1: Expr * expr2: Expr * kind: SequentialOpKind * - debugPoint: SyntaxTree.DebugPointAtSequential * range: Range.range - | Lambda of - unique: CompilerGlobalState.Unique * ctorThisValOpt: Val option * - baseValOpt: Val option * valParams: Val list * bodyExpr: Expr * - range: Range.range * overallType: TType - | TyLambda of - unique: CompilerGlobalState.Unique * typeParams: Typars * bodyExpr: Expr * - range: Range.range * overallType: TType - | App of - funcExpr: Expr * formalType: TType * typeArgs: TypeInst * args: Exprs * - range: Range.range - | LetRec of - bindings: Bindings * bodyExpr: Expr * range: Range.range * - frees: FreeVarsCache - | Let of - binding: Binding * bodyExpr: Expr * range: Range.range * - frees: FreeVarsCache - | Obj of - unique: CompilerGlobalState.Unique * objTy: TType * baseVal: Val option * - ctorCall: Expr * overrides: ObjExprMethod list * - interfaceImpls: (TType * ObjExprMethod list) list * range: Range.range - | Match of - debugPoint: SyntaxTree.DebugPointForBinding * inputRange: Range.range * - decision: DecisionTree * targets: DecisionTreeTarget array * - fullRange: Range.range * exprType: TType - | StaticOptimization of - conditions: StaticOptimization list * expr: Expr * alternativeExpr: Expr * - range: Range.range - | Op of op: TOp * typeArgs: TypeInst * args: Exprs * range: Range.range - | Quote of - quotedExpr: Expr * - quotationInfo: - ((AbstractIL.IL.ILTypeRef list * TTypes * Exprs * - QuotationPickler.ExprData) * - (AbstractIL.IL.ILTypeRef list * TTypes * Exprs * - QuotationPickler.ExprData)) option ref * isFromQueryExpression: bool * - range: Range.range * quotedType: TType - | WitnessArg of traitInfo: TraitConstraintInfo * range: Range.range - | TyChoose of typeParams: Typars * bodyExpr: Expr * range: Range.range - | Link of Expr ref - with - member ToDebugString : depth:int -> string - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and TOp = - | UnionCase of UnionCaseRef - | ExnConstr of TyconRef - | Tuple of TupInfo - | AnonRecd of AnonRecdTypeInfo - | AnonRecdGet of AnonRecdTypeInfo * int - | Array - | Bytes of byte [] - | UInt16s of uint16 [] - | While of SyntaxTree.DebugPointAtWhile * SpecialWhileLoopMarker - | For of SyntaxTree.DebugPointAtFor * ForLoopStyle - | TryWith of SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith - | TryFinally of - SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally - | Recd of RecordConstructionInfo * TyconRef - | ValFieldSet of RecdFieldRef - | ValFieldGet of RecdFieldRef - | ValFieldGetAddr of RecdFieldRef * readonly: bool - | UnionCaseTagGet of TyconRef - | UnionCaseProof of UnionCaseRef - | UnionCaseFieldGet of UnionCaseRef * int - | UnionCaseFieldGetAddr of UnionCaseRef * int * readonly: bool - | UnionCaseFieldSet of UnionCaseRef * int - | ExnFieldGet of TyconRef * int - | ExnFieldSet of TyconRef * int - | TupleFieldGet of TupInfo * int - | ILAsm of instrs: AbstractIL.IL.ILInstr list * retTypes: TTypes - | RefAddrGet of bool - | Coerce - | Reraise - | Return - | Goto of AbstractIL.IL.ILCodeLabel - | Label of AbstractIL.IL.ILCodeLabel - | TraitCall of TraitConstraintInfo - | LValueOp of LValueOperation * ValRef - | ILCall of - isVirtual: bool * isProtected: bool * isStruct: bool * isCtor: bool * - valUseFlag: ValUseFlag * isProperty: bool * noTailCall: bool * - ilMethRef: AbstractIL.IL.ILMethodRef * enclTypeInst: TypeInst * - methInst: TypeInst * retTypes: TTypes - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - and RecordConstructionInfo = - | RecdExprIsObjInit - | RecdExpr - and ConstrainedCallInfo = TType option - and SpecialWhileLoopMarker = - | NoSpecialWhileLoopMarker - | WhileLoopForCompiledForEachExprMarker - and ForLoopStyle = - | FSharpForLoopUp - | FSharpForLoopDown - | CSharpForLoopUp - and LValueOperation = - | LAddrOf of readonly: bool - | LByrefGet - | LSet - | LByrefSet - and SequentialOpKind = - | NormalSeq - | ThenDoSeq - and ValUseFlag = - | PossibleConstrainedCall of TType - | NormalValUse - | CtorValUsedAsSuperInit - | CtorValUsedAsSelfInit - | VSlotDirectCall - and StaticOptimization = - | TTyconEqualsTycon of TType * TType - | TTyconIsStruct of TType - [] - and ObjExprMethod = - | TObjExprMethod of - SlotSig * Attribs * Typars * Val list list * Expr * Range.range - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - member Id : SyntaxTree.Ident - end - [] - and SlotSig = - | TSlotSig of - methodName: string * implementedType: TType * classTypars: Typars * - methodTypars: Typars * formalParams: SlotParam list list * - formalReturn: TType option - with - override ToString : unit -> string - member ClassTypars : Typars - [ (0))>] - member DebugText : string - member FormalParams : SlotParam list list - member FormalReturnType : TType option - member ImplementedType : TType - member MethodTypars : Typars - member Name : string - end - [] - and SlotParam = - | TSlotParam of - paramName: string option * paramType: TType * isIn: bool * isOut: bool * - isOptional: bool * attributes: Attribs - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - member Type : TType - end - [] - and ModuleOrNamespaceExprWithSig = - | ModuleOrNamespaceExprWithSig of - moduleType: ModuleOrNamespaceType * contents: ModuleOrNamespaceExpr * - range: Range.range - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - member Type : ModuleOrNamespaceType - end - [] - and ModuleOrNamespaceExpr = - | TMAbstract of ModuleOrNamespaceExprWithSig - | TMDefs of ModuleOrNamespaceExpr list - | TMDefLet of Binding * Range.range - | TMDefDo of Expr * Range.range - | TMDefRec of - isRec: bool * Tycon list * ModuleOrNamespaceBinding list * Range.range - with - override ToString : unit -> string - member DebugText : string - end - [] - and ModuleOrNamespaceBinding = - | Binding of Binding - | Module of ModuleOrNamespace * ModuleOrNamespaceExpr - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and TypedImplFile = - | TImplFile of - SyntaxTree.QualifiedNameOfFile * SyntaxTree.ScopedPragma list * - ModuleOrNamespaceExprWithSig * bool * bool * StampMap - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and TypedImplFileAfterOptimization = - { ImplFile: TypedImplFile - OptimizeDuringCodeGen: bool -> Expr -> Expr } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and TypedAssemblyAfterOptimization = - | TypedAssemblyAfterOptimization of TypedImplFileAfterOptimization list - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and CcuData = - { FileName: string option - ILScopeRef: AbstractIL.IL.ILScopeRef - Stamp: Stamp - QualifiedName: string option - SourceCodeDirectory: string - IsFSharp: bool - IsProviderGenerated: bool - InvalidateEvent: IEvent - ImportProvidedType: Tainted -> TType - mutable UsesFSharp20PlusQuotations: bool - mutable Contents: ModuleOrNamespace - TryGetILModuleDef: unit -> AbstractIL.IL.ILModuleDef option - MemberSignatureEquality: TType -> TType -> bool - TypeForwarders: CcuTypeForwarderTable } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - and CcuTypeForwarderTable = Map<(string [] * string),System.Lazy> - and CcuReference = string - [] - and CcuThunk = - { mutable target: CcuData - name: CcuReference } - with - static member Create : nm:CcuReference * x:CcuData -> CcuThunk - static member CreateDelayed : nm:CcuReference -> CcuThunk - member EnsureDerefable : requiringPath:string [] -> unit - member Fixup : avail:CcuThunk -> unit - member - ImportProvidedType : ty:Tainted -> TType - member MemberSignatureEquality : ty1:TType * ty2:TType -> bool - override ToString : unit -> string - member TryForward : nlpath:string [] * item:string -> EntityRef option - member TryGetILModuleDef : unit -> AbstractIL.IL.ILModuleDef option - member AssemblyName : string - member Contents : Entity - [ (0))>] - member DebugText : string - member Deref : CcuData - member FileName : string option - member ILScopeRef : AbstractIL.IL.ILScopeRef - member IsFSharp : bool - member IsProviderGenerated : bool - member IsUnresolvedReference : bool - member QualifiedName : string option - member RootModulesAndNamespaces : Entity list - member RootTypeAndExceptionDefinitions : Entity list - member SourceCodeDirectory : string - member Stamp : Stamp - member TypeForwarders : Map<(string [] * string),System.Lazy> - member UsesFSharp20PlusQuotations : bool - end - [] - and CcuResolutionResult = - | ResolvedCcu of CcuThunk - | UnresolvedCcu of string - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - [] - and PickledCcuInfo = - { mspec: ModuleOrNamespace - compileTimeWorkingDir: string - usesQuotations: bool } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - and FreeLocals = AbstractIL.Internal.Zset - and FreeTypars = AbstractIL.Internal.Zset - and FreeTycons = AbstractIL.Internal.Zset - and FreeRecdFields = AbstractIL.Internal.Zset - and FreeUnionCases = AbstractIL.Internal.Zset - [] - and FreeTyvars = - { FreeTycons: FreeTycons - FreeTraitSolutions: FreeLocals - FreeTypars: FreeTypars } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - and FreeVarsCache = Lib.cache - [] - and FreeVars = - { FreeLocals: FreeLocals - UsesMethodLocalConstructs: bool - UsesUnboundRethrow: bool - FreeLocalTyconReprs: FreeTycons - FreeRecdFields: FreeRecdFields - FreeUnionCases: FreeUnionCases - FreeTyvars: FreeTyvars } - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - end - and Construct = - class - new : unit -> Construct - static member - ComputeDefinitionLocationOfProvidedItem : p:Tainted<#ExtensionTyping.IProvidedCustomAttributeProvider> -> - Range.range option - static member - KeyTyconByAccessNames : nm:string -> - x:'T -> - System.Collections.Generic.KeyValuePair [] - static member - KeyTyconByDecodedName : nm:string -> - x:'T -> - System.Collections.Generic.KeyValuePair - static member - MakeRecdFieldsTable : ucs:RecdField list -> TyconRecdFields - static member MakeUnionCases : ucs:UnionCase list -> TyconUnionData - static member MakeUnionRepr : ucs:UnionCase list -> TyconRepresentation - static member - NewCcuContents : sref:AbstractIL.IL.ILScopeRef -> - m:Range.range -> - nm:string -> - mty:ModuleOrNamespaceType -> ModuleOrNamespace - static member NewClonedModuleOrNamespace : orig:Tycon -> Entity - static member NewClonedTycon : orig:Tycon -> Entity - static member - NewEmptyModuleOrNamespaceType : mkind:ModuleOrNamespaceKind -> - ModuleOrNamespaceType - static member - NewExn : cpath:CompilationPath option -> - id:SyntaxTree.Ident -> - access:Accessibility -> - repr:ExceptionInfo -> - attribs:Attribs -> doc:XmlDoc.XmlDoc -> Entity - static member NewFreeVarsCache : unit -> Lib.cache<'a> - static member - NewILTycon : nlpath:CompilationPath option -> - nm:string * m:Range.range -> - tps:AbstractIL.Internal.Library.LazyWithContext -> - scoref:AbstractIL.IL.ILScopeRef * - enc:AbstractIL.IL.ILTypeDef list * - tdef:AbstractIL.IL.ILTypeDef -> - mtyp:Lib.MaybeLazy -> - Entity - static member - NewModifiedModuleOrNamespace : f:(ModuleOrNamespaceType -> - ModuleOrNamespaceType) -> - orig:Tycon -> Entity - static member - NewModifiedTycon : f:(Tycon -> Entity) -> orig:Tycon -> Entity - static member NewModifiedVal : f:(Val -> Val) -> orig:Val -> Val - static member - NewModuleOrNamespace : cpath:CompilationPath option -> - access:Accessibility -> - id:SyntaxTree.Ident -> - xml:XmlDoc.XmlDoc -> - attribs:Attrib list -> - mtype:Lib.MaybeLazy -> - ModuleOrNamespace - static member - NewModuleOrNamespaceType : mkind:ModuleOrNamespaceKind -> - tycons:Entity list -> - vals:Val list -> ModuleOrNamespaceType - static member - NewProvidedTycon : resolutionEnvironment:ExtensionTyping.ResolutionEnvironment * - st:Tainted * - importProvidedType:(Tainted -> - TType) * - isSuppressRelocate:bool * m:Range.range * - ?access:Accessibility * ?cpath:CompilationPath -> - Entity - static member - NewProvidedTyconRepr : resolutionEnvironment:ExtensionTyping.ResolutionEnvironment * - st:Tainted * - importProvidedType:(Tainted -> - TType) * - isSuppressRelocate:bool * m:Range.range -> - TyconRepresentation - static member - NewRecdField : stat:bool -> - konst:Const option -> - id:SyntaxTree.Ident -> - nameGenerated:bool -> - ty:TType -> - isMutable:bool -> - isVolatile:bool -> - pattribs:Attribs -> - fattribs:Attribs -> - docOption:XmlDoc.XmlDoc -> - access:Accessibility -> - secret:bool -> RecdField - static member NewRigidTypar : nm:string -> m:Range.range -> Typar - static member - NewTycon : cpath:CompilationPath option * nm:string * m:Range.range * - access:Accessibility * reprAccess:Accessibility * - kind:TyparKind * - typars:AbstractIL.Internal.Library.LazyWithContext * - doc:XmlDoc.XmlDoc * usesPrefixDisplay:bool * - preEstablishedHasDefaultCtor:bool * - hasSelfReferentialCtor:bool * - mtyp:Lib.MaybeLazy -> Entity - static member - NewTypar : kind:TyparKind * rigid:TyparRigidity * SyntaxTree.SynTypar * - isFromError:bool * dynamicReq:TyparDynamicReq * - attribs:Attrib list * eqDep:bool * compDep:bool -> Typar - static member - NewUnionCase : id:SyntaxTree.Ident -> - tys:RecdField list -> - rty:TType -> - attribs:Attribs -> - docOption:XmlDoc.XmlDoc -> - access:Accessibility -> UnionCase - static member - NewVal : logicalName:string * m:Range.range * - compiledName:string option * ty:TType * - isMutable:ValMutability * isCompGen:bool * - arity:ValReprInfo option * access:Accessibility * - recValInfo:ValRecursiveScopeInfo * - specialRepr:ValMemberInfo option * - baseOrThis:ValBaseOrThisInfo * attribs:Attrib list * - inlineInfo:ValInline * doc:XmlDoc.XmlDoc * - isModuleOrMemberBinding:bool * isExtensionMember:bool * - isIncrClassSpecialMember:bool * isTyFunc:bool * - allowTypeInst:bool * isGeneratedEventVal:bool * - konst:Const option * actualParent:ParentRef -> Val - end - end - -namespace FSharp.Compiler - module internal TypedTreeBasics = begin - val getNameOfScopeRef : sref:AbstractIL.IL.ILScopeRef -> string - module ValReprInfo = begin - val unnamedTopArg1 : TypedTree.ArgReprInfo - val unnamedTopArg : TypedTree.ArgReprInfo list - val unitArgData : TypedTree.ArgReprInfo list list - val unnamedRetVal : TypedTree.ArgReprInfo - val selfMetadata : TypedTree.ArgReprInfo list - val emptyValData : TypedTree.ValReprInfo - val InferTyparInfo : - tps:TypedTree.Typar list -> TypedTree.TyparReprInfo list - val InferArgReprInfo : v:TypedTree.Val -> TypedTree.ArgReprInfo - val InferArgReprInfos : - vs:TypedTree.Val list list -> TypedTree.ValReprInfo - val HasNoArgs : TypedTree.ValReprInfo -> bool - end - val typeOfVal : v:TypedTree.Val -> TypedTree.TType - val typesOfVals : v:TypedTree.Val list -> TypedTree.TType list - val nameOfVal : v:TypedTree.Val -> string - val arityOfVal : v:TypedTree.Val -> TypedTree.ValReprInfo - val tupInfoRef : TypedTree.TupInfo - val tupInfoStruct : TypedTree.TupInfo - val mkTupInfo : b:bool -> TypedTree.TupInfo - val structnessDefault : bool - val mkRawRefTupleTy : tys:TypedTree.TTypes -> TypedTree.TType - val mkRawStructTupleTy : tys:TypedTree.TTypes -> TypedTree.TType - val mapTImplFile : - f:(TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig) -> - TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val mapAccImplFile : - f:('a -> TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig * 'b) -> - z:'a -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile * 'b - val foldTImplFile : - f:('a -> TypedTree.ModuleOrNamespaceExprWithSig -> 'b) -> - z:'a -> TypedTree.TypedImplFile -> 'b - val typarEq : lv1:TypedTree.Typar -> lv2:TypedTree.Typar -> bool - val typarRefEq : tp1:TypedTree.Typar -> tp2:TypedTree.Typar -> bool - val valEq : lv1:TypedTree.Val -> lv2:TypedTree.Val -> bool - val ccuEq : mv1:TypedTree.CcuThunk -> mv2:TypedTree.CcuThunk -> bool - val ( |ValDeref| ) : vr:TypedTree.ValRef -> TypedTree.Val - val mkRecdFieldRef : - tcref:TypedTree.TyconRef -> f:string -> TypedTree.RecdFieldRef - val mkUnionCaseRef : - tcref:TypedTree.TyconRef -> c:string -> TypedTree.UnionCaseRef - val ERefLocal : x:Lib.NonNullSlot -> TypedTree.EntityRef - val ERefNonLocal : x:TypedTree.NonLocalEntityRef -> TypedTree.EntityRef - val ERefNonLocalPreResolved : - x:Lib.NonNullSlot -> - xref:TypedTree.NonLocalEntityRef -> TypedTree.EntityRef - val ( |ERefLocal|ERefNonLocal| ) : - x:TypedTree.EntityRef -> - Choice,TypedTree.NonLocalEntityRef> - val mkLocalTyconRef : - x:Lib.NonNullSlot -> TypedTree.EntityRef - val mkNonLocalEntityRef : - ccu:TypedTree.CcuThunk -> mp:string [] -> TypedTree.NonLocalEntityRef - val mkNestedNonLocalEntityRef : - nleref:TypedTree.NonLocalEntityRef -> - id:string -> TypedTree.NonLocalEntityRef - val mkNonLocalTyconRef : - nleref:TypedTree.NonLocalEntityRef -> id:string -> TypedTree.EntityRef - val mkNonLocalTyconRefPreResolved : - x:Lib.NonNullSlot -> - nleref:TypedTree.NonLocalEntityRef -> id:string -> TypedTree.EntityRef - type EntityRef with - member NestedTyconRef : x:TypedTree.Entity -> TypedTree.EntityRef - type EntityRef with - member - RecdFieldRefInNestedTycon : tycon:TypedTree.Entity -> - id:SyntaxTree.Ident -> - TypedTree.RecdFieldRef - val mkModuleUnionCaseRef : - modref:TypedTree.ModuleOrNamespaceRef -> - tycon:TypedTree.Entity -> - uc:TypedTree.UnionCase -> TypedTree.UnionCaseRef - val VRefLocal : x:Lib.NonNullSlot -> TypedTree.ValRef - val VRefNonLocal : x:TypedTree.NonLocalValOrMemberRef -> TypedTree.ValRef - val VRefNonLocalPreResolved : - x:Lib.NonNullSlot -> - xref:TypedTree.NonLocalValOrMemberRef -> TypedTree.ValRef - val ( |VRefLocal|VRefNonLocal| ) : - x:TypedTree.ValRef -> - Choice,TypedTree.NonLocalValOrMemberRef> - val mkNonLocalValRef : - mp:TypedTree.NonLocalEntityRef -> - id:TypedTree.ValLinkageFullKey -> TypedTree.ValRef - val mkNonLocalValRefPreResolved : - x:Lib.NonNullSlot -> - mp:TypedTree.NonLocalEntityRef -> - id:TypedTree.ValLinkageFullKey -> TypedTree.ValRef - val ccuOfValRef : vref:TypedTree.ValRef -> TypedTree.CcuThunk option - val ccuOfTyconRef : eref:TypedTree.EntityRef -> TypedTree.CcuThunk option - val mkTyparTy : tp:TypedTree.Typar -> TypedTree.TType - val copyTypar : tp:TypedTree.Typar -> TypedTree.Typar - val copyTypars : tps:TypedTree.Typar list -> TypedTree.Typar list - val tryShortcutSolvedUnitPar : - canShortcut:bool -> r:TypedTree.Typar -> TypedTree.Measure - val stripUnitEqnsAux : - canShortcut:bool -> unt:TypedTree.Measure -> TypedTree.Measure - val stripTyparEqnsAux : - canShortcut:bool -> ty:TypedTree.TType -> TypedTree.TType - val stripTyparEqns : ty:TypedTree.TType -> TypedTree.TType - val stripUnitEqns : unt:TypedTree.Measure -> TypedTree.Measure - val mkLocalValRef : v:TypedTree.Val -> TypedTree.ValRef - val mkLocalModRef : v:TypedTree.ModuleOrNamespace -> TypedTree.EntityRef - val mkLocalEntityRef : v:TypedTree.Entity -> TypedTree.EntityRef - val mkNonLocalCcuRootEntityRef : - ccu:TypedTree.CcuThunk -> x:TypedTree.Entity -> TypedTree.EntityRef - val mkNestedValRef : - cref:TypedTree.EntityRef -> v:TypedTree.Val -> TypedTree.ValRef - val rescopePubPathToParent : - viewedCcu:TypedTree.CcuThunk -> - TypedTree.PublicPath -> TypedTree.NonLocalEntityRef - val rescopePubPath : - viewedCcu:TypedTree.CcuThunk -> - TypedTree.PublicPath -> TypedTree.NonLocalEntityRef - val valRefInThisAssembly : compilingFslib:bool -> x:TypedTree.ValRef -> bool - val tyconRefUsesLocalXmlDoc : - compilingFslib:bool -> x:TypedTree.TyconRef -> bool - val entityRefInThisAssembly : - compilingFslib:bool -> x:TypedTree.EntityRef -> bool - val arrayPathEq : y1:string [] -> y2:string [] -> bool - val nonLocalRefEq : - TypedTree.NonLocalEntityRef -> TypedTree.NonLocalEntityRef -> bool - val nonLocalRefDefinitelyNotEq : - TypedTree.NonLocalEntityRef -> TypedTree.NonLocalEntityRef -> bool - val pubPathEq : TypedTree.PublicPath -> TypedTree.PublicPath -> bool - val fslibRefEq : - nlr1:TypedTree.NonLocalEntityRef -> TypedTree.PublicPath -> bool - val fslibEntityRefEq : - fslibCcu:TypedTree.CcuThunk -> - eref1:TypedTree.EntityRef -> eref2:TypedTree.EntityRef -> bool - val fslibValRefEq : - fslibCcu:TypedTree.CcuThunk -> - vref1:TypedTree.ValRef -> vref2:TypedTree.ValRef -> bool - val primEntityRefEq : - compilingFslib:bool -> - fslibCcu:TypedTree.CcuThunk -> - x:TypedTree.EntityRef -> y:TypedTree.EntityRef -> bool - val primUnionCaseRefEq : - compilingFslib:bool -> - fslibCcu:TypedTree.CcuThunk -> - TypedTree.UnionCaseRef -> TypedTree.UnionCaseRef -> bool - val primValRefEq : - compilingFslib:bool -> - fslibCcu:TypedTree.CcuThunk -> - x:TypedTree.ValRef -> y:TypedTree.ValRef -> bool - val fullCompPathOfModuleOrNamespace : - m:TypedTree.ModuleOrNamespace -> TypedTree.CompilationPath - val inline canAccessCompPathFrom : - TypedTree.CompilationPath -> TypedTree.CompilationPath -> bool - val canAccessFromOneOf : - cpaths:TypedTree.CompilationPath list -> - cpathTest:TypedTree.CompilationPath -> bool - val canAccessFrom : - TypedTree.Accessibility -> cpath:TypedTree.CompilationPath -> bool - val canAccessFromEverywhere : TypedTree.Accessibility -> bool - val canAccessFromSomewhere : TypedTree.Accessibility -> bool - val isLessAccessible : - TypedTree.Accessibility -> TypedTree.Accessibility -> bool - val accessSubstPaths : - newPath:TypedTree.CompilationPath * oldPath:TypedTree.CompilationPath -> - TypedTree.Accessibility -> TypedTree.Accessibility - val compPathOfCcu : ccu:TypedTree.CcuThunk -> TypedTree.CompilationPath - val taccessPublic : TypedTree.Accessibility - val taccessPrivate : - accessPath:TypedTree.CompilationPath -> TypedTree.Accessibility - val compPathInternal : TypedTree.CompilationPath - val taccessInternal : TypedTree.Accessibility - val combineAccess : - TypedTree.Accessibility -> - TypedTree.Accessibility -> TypedTree.Accessibility - exception Duplicate of string * string * Range.range - exception NameClash of - string * string * string * Range.range * string * - string * Range.range - end - -namespace FSharp.Compiler - module internal TcGlobals = begin - val DummyFileNameForRangesWithoutASpecificLocation : string - val private envRange : Range.range - [] - type IntrinsicValRef = - | IntrinsicValRef of - TypedTree.NonLocalEntityRef * string * bool * TypedTree.TType * - TypedTree.ValLinkageFullKey - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - member Name : string - end - val ValRefForIntrinsic : IntrinsicValRef -> TypedTree.ValRef - module FSharpLib = begin - val CoreOperatorsCheckedName : string - val ControlName : string - val LinqName : string - val CollectionsName : string - val LanguagePrimitivesName : string - val CompilerServicesName : string - val LinqRuntimeHelpersName : string - val RuntimeHelpersName : string - val ExtraTopLevelOperatorsName : string - val NativeInteropName : string - val QuotationsName : string - val ControlPath : string list - val LinqPath : string list - val CollectionsPath : string list - val NativeInteropPath : string [] - val CompilerServicesPath : string [] - val LinqRuntimeHelpersPath : string [] - val RuntimeHelpersPath : string [] - val QuotationsPath : string [] - val RootPathArray : string [] - val CorePathArray : string [] - val LinqPathArray : string [] - val ControlPathArray : string [] - val CollectionsPathArray : string [] - end - val private mkNonGenericTy : tcref:TypedTree.TyconRef -> TypedTree.TType - val mkNonLocalTyconRef2 : - ccu:TypedTree.CcuThunk -> - path:string [] -> n:string -> TypedTree.EntityRef - val mk_MFCore_tcref : - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFQuotations_tcref : - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFLinq_tcref : - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFCollections_tcref : - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFCompilerServices_tcref : - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFRuntimeHelpers_tcref : - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - val mk_MFControl_tcref : - ccu:TypedTree.CcuThunk -> n:string -> TypedTree.EntityRef - [] - type BuiltinAttribInfo = - | AttribInfo of AbstractIL.IL.ILTypeRef * TypedTree.TyconRef - with - override ToString : unit -> string - [ (0))>] - member DebugText : string - member TyconRef : TypedTree.TyconRef - member TypeRef : AbstractIL.IL.ILTypeRef - end - [] - val tname_DebuggerNonUserCodeAttribute : string - = "System.Diagnostics.DebuggerNonUserCodeAttribute" - [] - val tname_DebuggableAttribute_DebuggingModes : string = "DebuggingModes" - [] - val tname_DebuggerHiddenAttribute : string - = "System.Diagnostics.DebuggerHiddenAttribute" - [] - val tname_DebuggerDisplayAttribute : string - = "System.Diagnostics.DebuggerDisplayAttribute" - [] - val tname_DebuggerTypeProxyAttribute : string - = "System.Diagnostics.DebuggerTypeProxyAttribute" - [] - val tname_DebuggerStepThroughAttribute : string - = "System.Diagnostics.DebuggerStepThroughAttribute" - [] - val tname_DebuggerBrowsableAttribute : string - = "System.Diagnostics.DebuggerBrowsableAttribute" - [] - val tname_DebuggerBrowsableState : string - = "System.Diagnostics.DebuggerBrowsableState" - [] - val tname_StringBuilder : string = "System.Text.StringBuilder" - [] - val tname_IComparable : string = "System.IComparable" - [] - val tname_Exception : string = "System.Exception" - [] - val tname_Missing : string = "System.Reflection.Missing" - [] - val tname_FormattableString : string = "System.FormattableString" - [] - val tname_SerializationInfo : string - = "System.Runtime.Serialization.SerializationInfo" - [] - val tname_StreamingContext : string - = "System.Runtime.Serialization.StreamingContext" - [] - val tname_SecurityPermissionAttribute : string - = "System.Security.Permissions.SecurityPermissionAttribute" - [] - val tname_Delegate : string = "System.Delegate" - [] - val tname_ValueType : string = "System.ValueType" - [] - val tname_Enum : string = "System.Enum" - [] - val tname_Array : string = "System.Array" - [] - val tname_RuntimeArgumentHandle : string = "System.RuntimeArgumentHandle" - [] - val tname_RuntimeTypeHandle : string = "System.RuntimeTypeHandle" - [] - val tname_RuntimeMethodHandle : string = "System.RuntimeMethodHandle" - [] - val tname_RuntimeFieldHandle : string = "System.RuntimeFieldHandle" - [] - val tname_CompilerGeneratedAttribute : string - = "System.Runtime.CompilerServices.CompilerGeneratedAttribute" - [] - val tname_DebuggableAttribute : string - = "System.Diagnostics.DebuggableAttribute" - [] - val tname_AsyncCallback : string = "System.AsyncCallback" - [] - val tname_IAsyncResult : string = "System.IAsyncResult" - type TcGlobals = - class - new : compilingFslib:bool * ilg:AbstractIL.IL.ILGlobals * - fslibCcu:TypedTree.CcuThunk * - directoryToResolveRelativePaths:string * mlCompatibility:bool * - isInteractive:bool * - tryFindSysTypeCcu:(string list -> string -> - TypedTree.CcuThunk option) * - emitDebugInfoInQuotations:bool * noDebugData:bool * - pathMap:Internal.Utilities.PathMap * - langVersion:Features.LanguageVersion -> TcGlobals - member - AddFieldGeneratedAttrs : mdef:AbstractIL.IL.ILFieldDef -> - AbstractIL.IL.ILFieldDef - member - AddFieldNeverAttrs : mdef:AbstractIL.IL.ILFieldDef -> - AbstractIL.IL.ILFieldDef - member - AddMethodGeneratedAttributes : mdef:AbstractIL.IL.ILMethodDef -> - AbstractIL.IL.ILMethodDef - member - EraseClassUnionDef : cud:AbstractIL.IL.ILTypeRef -> - (AbstractIL.IL.ILTypeDef -> - AbstractIL.Extensions.ILX.Types.IlxUnionInfo -> - AbstractIL.IL.ILTypeDef) - member FindSysAttrib : nm:string -> BuiltinAttribInfo - member FindSysILTypeRef : nm:string -> AbstractIL.IL.ILTypeRef - member - FindSysTyconRef : path:string list -> nm:string -> TypedTree.EntityRef - member - MakeBuiltInWitnessInfo : t:TypedTree.TraitConstraintInfo -> - IntrinsicValRef * TypedTree.TType list - override ToString : unit -> string - member TryFindSysAttrib : nm:string -> BuiltinAttribInfo option - member TryFindSysILTypeRef : nm:string -> AbstractIL.IL.ILTypeRef option - member - TryFindSysTyconRef : path:string list -> - nm:string -> TypedTree.EntityRef option - member - TryMakeOperatorAsBuiltInWitnessInfo : isStringTy:(TcGlobals -> - TypedTree.TType -> - bool) -> - isArrayTy:(TcGlobals -> - TypedTree.TType -> - bool) -> - t:TypedTree.TraitConstraintInfo -> - argExprs:'a list -> - (IntrinsicValRef * - TypedTree.TType list * - 'a list) option - member - decompileType : tcref:TypedTree.EntityRef -> - tinst:TypedTree.TypeInst -> TypedTree.TType - member - improveType : tcref:TypedTree.EntityRef -> - tinst:TypedTree.TType list -> TypedTree.TType - member memoize_file : x:int -> AbstractIL.IL.ILSourceDocument - member - mkDebuggableAttribute : jitOptimizerDisabled:bool -> - AbstractIL.IL.ILAttribute - member - mkDebuggableAttributeV2 : jitTracking:bool * - ignoreSymbolStoreSequencePoints:bool * - jitOptimizerDisabled:bool * enableEnC:bool -> - AbstractIL.IL.ILAttribute - member - mkDebuggerDisplayAttribute : s:string -> AbstractIL.IL.ILAttribute - member mkDebuggerHiddenAttribute : unit -> AbstractIL.IL.ILAttribute - member - mkDebuggerStepThroughAttribute : unit -> AbstractIL.IL.ILAttribute - member - unionCaseRefEq : x:TypedTree.UnionCaseRef -> - y:TypedTree.UnionCaseRef -> bool - member valRefEq : x:TypedTree.ValRef -> y:TypedTree.ValRef -> bool - member CompilerGeneratedAttribute : AbstractIL.IL.ILAttribute - member - CompilerGlobalState : CompilerGlobalState.CompilerGlobalState option - member DebuggerBrowsableNeverAttribute : AbstractIL.IL.ILAttribute - member IComparer_ty : TypedTree.TType - member IEqualityComparer_ty : TypedTree.TType - member - System_Runtime_CompilerServices_RuntimeFeature_ty : TypedTree.TType option - member addrof2_vref : TypedTree.ValRef - member addrof_vref : TypedTree.ValRef - member and2_vref : TypedTree.ValRef - member and_vref : TypedTree.ValRef - member array2D_get_info : IntrinsicValRef - member array2D_get_vref : TypedTree.ValRef - member array2D_set_info : IntrinsicValRef - member array3D_get_info : IntrinsicValRef - member array3D_get_vref : TypedTree.ValRef - member array3D_set_info : IntrinsicValRef - member array4D_get_info : IntrinsicValRef - member array4D_get_vref : TypedTree.ValRef - member array4D_set_info : IntrinsicValRef - member array_get_info : IntrinsicValRef - member array_get_vref : TypedTree.ValRef - member array_length_info : IntrinsicValRef - member array_set_info : IntrinsicValRef - member array_tcr_nice : TypedTree.EntityRef - member attrib_AbstractClassAttribute : BuiltinAttribInfo - member attrib_AllowNullLiteralAttribute : BuiltinAttribInfo - member attrib_AttributeUsageAttribute : BuiltinAttribInfo - member attrib_AutoOpenAttribute : BuiltinAttribInfo - member attrib_AutoSerializableAttribute : BuiltinAttribInfo - member attrib_CLIEventAttribute : BuiltinAttribInfo - member attrib_CLIMutableAttribute : BuiltinAttribInfo - member attrib_CallerFilePathAttribute : BuiltinAttribInfo - member attrib_CallerLineNumberAttribute : BuiltinAttribInfo - member attrib_CallerMemberNameAttribute : BuiltinAttribInfo - member attrib_ClassAttribute : BuiltinAttribInfo - member attrib_ComImportAttribute : BuiltinAttribInfo option - member attrib_ComVisibleAttribute : BuiltinAttribInfo - member attrib_ComparisonConditionalOnAttribute : BuiltinAttribInfo - member attrib_CompilationArgumentCountsAttribute : BuiltinAttribInfo - member attrib_CompilationMappingAttribute : BuiltinAttribInfo - member attrib_CompilationRepresentationAttribute : BuiltinAttribInfo - member attrib_CompiledNameAttribute : BuiltinAttribInfo - member attrib_CompilerMessageAttribute : BuiltinAttribInfo - member attrib_ComponentModelEditorBrowsableAttribute : BuiltinAttribInfo - member attrib_ConditionalAttribute : BuiltinAttribInfo - member attrib_ContextStaticAttribute : BuiltinAttribInfo option - member attrib_CustomComparisonAttribute : BuiltinAttribInfo - member attrib_CustomEqualityAttribute : BuiltinAttribInfo - member attrib_CustomOperationAttribute : BuiltinAttribInfo - member attrib_DebuggerDisplayAttribute : BuiltinAttribInfo - member attrib_DebuggerTypeProxyAttribute : BuiltinAttribInfo - member attrib_DefaultAugmentationAttribute : BuiltinAttribInfo - member attrib_DefaultMemberAttribute : BuiltinAttribInfo - member attrib_DefaultParameterValueAttribute : BuiltinAttribInfo option - member attrib_DefaultValueAttribute : BuiltinAttribInfo - member attrib_DllImportAttribute : BuiltinAttribInfo option - member attrib_EntryPointAttribute : BuiltinAttribInfo - member attrib_EqualityConditionalOnAttribute : BuiltinAttribInfo - member attrib_ExperimentalAttribute : BuiltinAttribInfo - member attrib_ExtensionAttribute : BuiltinAttribInfo - member attrib_FieldOffsetAttribute : BuiltinAttribInfo - member attrib_FlagsAttribute : BuiltinAttribInfo - member attrib_GeneralizableValueAttribute : BuiltinAttribInfo - member attrib_IDispatchConstantAttribute : BuiltinAttribInfo option - member attrib_IUnknownConstantAttribute : BuiltinAttribInfo option - member attrib_InAttribute : BuiltinAttribInfo - member attrib_InterfaceAttribute : BuiltinAttribInfo - member attrib_InternalsVisibleToAttribute : BuiltinAttribInfo - member attrib_IsByRefLikeAttribute : BuiltinAttribInfo - member attrib_IsReadOnlyAttribute : BuiltinAttribInfo - member attrib_LiteralAttribute : BuiltinAttribInfo - member attrib_MarshalAsAttribute : BuiltinAttribInfo option - member attrib_MeasureAttribute : BuiltinAttribInfo - member attrib_MeasureableAttribute : BuiltinAttribInfo - member attrib_MethodImplAttribute : BuiltinAttribInfo - member attrib_NoComparisonAttribute : BuiltinAttribInfo - member attrib_NoDynamicInvocationAttribute : BuiltinAttribInfo - member attrib_NoEqualityAttribute : BuiltinAttribInfo - member attrib_NonSerializedAttribute : BuiltinAttribInfo option - member attrib_OptionalArgumentAttribute : BuiltinAttribInfo - member attrib_OptionalAttribute : BuiltinAttribInfo option - member attrib_OutAttribute : BuiltinAttribInfo - member attrib_ParamArrayAttribute : BuiltinAttribInfo - member attrib_PreserveSigAttribute : BuiltinAttribInfo option - member attrib_ProjectionParameterAttribute : BuiltinAttribInfo - member attrib_ReferenceEqualityAttribute : BuiltinAttribInfo - member attrib_ReflectedDefinitionAttribute : BuiltinAttribInfo - member attrib_RequireQualifiedAccessAttribute : BuiltinAttribInfo - member attrib_RequiresExplicitTypeArgumentsAttribute : BuiltinAttribInfo - member attrib_SealedAttribute : BuiltinAttribInfo - member attrib_SecurityAttribute : BuiltinAttribInfo option - member attrib_SecurityCriticalAttribute : BuiltinAttribInfo - member attrib_SecuritySafeCriticalAttribute : BuiltinAttribInfo - member attrib_SpecialNameAttribute : BuiltinAttribInfo option - member attrib_StructAttribute : BuiltinAttribInfo - member attrib_StructLayoutAttribute : BuiltinAttribInfo - member attrib_StructuralComparisonAttribute : BuiltinAttribInfo - member attrib_StructuralEqualityAttribute : BuiltinAttribInfo - member attrib_SystemObsolete : BuiltinAttribInfo - member attrib_ThreadStaticAttribute : BuiltinAttribInfo option - member attrib_TypeForwardedToAttribute : BuiltinAttribInfo - member attrib_UnverifiableAttribute : BuiltinAttribInfo - member attrib_VolatileFieldAttribute : BuiltinAttribInfo - member bitwise_and_info : IntrinsicValRef - member bitwise_and_vref : TypedTree.ValRef - member bitwise_or_info : IntrinsicValRef - member bitwise_or_vref : TypedTree.ValRef - member bitwise_shift_left_info : IntrinsicValRef - member bitwise_shift_left_vref : TypedTree.ValRef - member bitwise_shift_right_info : IntrinsicValRef - member bitwise_shift_right_vref : TypedTree.ValRef - member bitwise_unary_not_info : IntrinsicValRef - member bitwise_unary_not_vref : TypedTree.ValRef - member bitwise_xor_info : IntrinsicValRef - member bitwise_xor_vref : TypedTree.ValRef - member bool_tcr : TypedTree.EntityRef - member bool_ty : TypedTree.TType - member box_info : IntrinsicValRef - member byref2_tcr : TypedTree.EntityRef - member byref_tcr : TypedTree.EntityRef - member byrefkind_InOut_tcr : TypedTree.EntityRef - member byrefkind_In_tcr : TypedTree.EntityRef - member byrefkind_Out_tcr : TypedTree.EntityRef - member byte_checked_info : IntrinsicValRef - member byte_operator_info : IntrinsicValRef - member byte_tcr : TypedTree.EntityRef - member byte_ty : TypedTree.TType - member call_with_witnesses_info : IntrinsicValRef - member cast_quotation_info : IntrinsicValRef - member char_operator_info : IntrinsicValRef - member char_tcr : TypedTree.EntityRef - member char_ty : TypedTree.TType - member check_this_info : IntrinsicValRef - member checked_addition_info : IntrinsicValRef - member checked_multiply_info : IntrinsicValRef - member checked_subtraction_info : IntrinsicValRef - member checked_unary_minus_info : IntrinsicValRef - member choice2_tcr : TypedTree.EntityRef - member choice3_tcr : TypedTree.EntityRef - member choice4_tcr : TypedTree.EntityRef - member choice5_tcr : TypedTree.EntityRef - member choice6_tcr : TypedTree.EntityRef - member choice7_tcr : TypedTree.EntityRef - member compare_operator_vref : TypedTree.ValRef - member compilingFslib : bool - member cons_ucref : TypedTree.UnionCaseRef - member create_event_info : IntrinsicValRef - member create_instance_info : IntrinsicValRef - member date_tcr : TypedTree.EntityRef - member decimal_tcr : TypedTree.EntityRef - member decimal_ty : TypedTree.TType - member deserialize_quoted_FSharp_20_plus_info : IntrinsicValRef - member deserialize_quoted_FSharp_40_plus_info : IntrinsicValRef - member directoryToResolveRelativePaths : string - member dispose_info : IntrinsicValRef - member emitDebugInfoInQuotations : bool - member enumOfValue_vref : TypedTree.ValRef - member enum_operator_info : IntrinsicValRef - member enum_vref : TypedTree.ValRef - member equals_nullable_operator_vref : TypedTree.ValRef - member equals_operator_info : IntrinsicValRef - member equals_operator_vref : TypedTree.ValRef - member exn_tcr : TypedTree.EntityRef - member exn_ty : TypedTree.TType - member expr_tcr : TypedTree.EntityRef - member fail_init_info : IntrinsicValRef - member fail_static_init_info : IntrinsicValRef - member failwith_info : IntrinsicValRef - member failwith_vref : TypedTree.ValRef - member failwithf_info : IntrinsicValRef - member failwithf_vref : TypedTree.ValRef - member fastFunc_tcr : TypedTree.EntityRef - member float32_operator_info : IntrinsicValRef - member float32_tcr : TypedTree.EntityRef - member float32_ty : TypedTree.TType - member float_operator_info : IntrinsicValRef - member float_tcr : TypedTree.EntityRef - member float_ty : TypedTree.TType - member format_tcr : TypedTree.EntityRef - member fsharpref_vref : TypedTree.ValRef - member fslibCcu : TypedTree.CcuThunk - member fslib_IDelegateEvent_tcr : TypedTree.EntityRef - member fslib_IEvent2_tcr : TypedTree.EntityRef - member generateWitnesses : bool - member generic_compare_withc_tuple2_vref : TypedTree.ValRef - member generic_compare_withc_tuple3_vref : TypedTree.ValRef - member generic_compare_withc_tuple4_vref : TypedTree.ValRef - member generic_compare_withc_tuple5_vref : TypedTree.ValRef - member generic_comparison_inner_vref : TypedTree.ValRef - member generic_comparison_withc_inner_vref : TypedTree.ValRef - member generic_comparison_withc_outer_info : IntrinsicValRef - member generic_equality_er_inner_vref : TypedTree.ValRef - member generic_equality_er_outer_info : IntrinsicValRef - member generic_equality_per_inner_vref : TypedTree.ValRef - member generic_equality_withc_inner_vref : TypedTree.ValRef - member generic_equality_withc_outer_info : IntrinsicValRef - member generic_equality_withc_outer_vref : TypedTree.ValRef - member generic_equals_withc_tuple2_vref : TypedTree.ValRef - member generic_equals_withc_tuple3_vref : TypedTree.ValRef - member generic_equals_withc_tuple4_vref : TypedTree.ValRef - member generic_equals_withc_tuple5_vref : TypedTree.ValRef - member generic_hash_inner_vref : TypedTree.ValRef - member generic_hash_withc_inner_vref : TypedTree.ValRef - member generic_hash_withc_outer_info : IntrinsicValRef - member generic_hash_withc_tuple2_vref : TypedTree.ValRef - member generic_hash_withc_tuple3_vref : TypedTree.ValRef - member generic_hash_withc_tuple4_vref : TypedTree.ValRef - member generic_hash_withc_tuple5_vref : TypedTree.ValRef - member get_generic_comparer_info : IntrinsicValRef - member get_generic_er_equality_comparer_info : IntrinsicValRef - member get_generic_per_equality_comparer_info : IntrinsicValRef - member getstring_info : IntrinsicValRef - member greater_than_operator : IntrinsicValRef - member greater_than_operator_vref : TypedTree.ValRef - member greater_than_or_equals_operator : IntrinsicValRef - member greater_than_or_equals_operator_vref : TypedTree.ValRef - member hash_info : IntrinsicValRef - member il_arr_tcr_map : TypedTree.EntityRef [] - member ilg : AbstractIL.IL.ILGlobals - member ilsigptr_tcr : TypedTree.EntityRef - member iltyp_AsyncCallback : AbstractIL.IL.ILType - member iltyp_Exception : AbstractIL.IL.ILType - member iltyp_IAsyncResult : AbstractIL.IL.ILType - member iltyp_IComparable : AbstractIL.IL.ILType - member iltyp_Missing : AbstractIL.IL.ILType - member iltyp_RuntimeFieldHandle : AbstractIL.IL.ILType - member iltyp_RuntimeMethodHandle : AbstractIL.IL.ILType - member iltyp_RuntimeTypeHandle : AbstractIL.IL.ILType - member iltyp_SerializationInfo : AbstractIL.IL.ILType option - member iltyp_StreamingContext : AbstractIL.IL.ILType option - member iltyp_TypedReference : AbstractIL.IL.ILType option - member iltyp_ValueType : AbstractIL.IL.ILType - member ilxPubCloEnv : AbstractIL.Extensions.ILX.EraseClosures.cenv - member inref_tcr : TypedTree.EntityRef - member int16_checked_info : IntrinsicValRef - member int16_operator_info : IntrinsicValRef - member int16_tcr : TypedTree.EntityRef - member int16_ty : TypedTree.TType - member int32_checked_info : IntrinsicValRef - member int32_operator_info : IntrinsicValRef - member int32_tcr : TypedTree.EntityRef - member int32_ty : TypedTree.TType - member int64_checked_info : IntrinsicValRef - member int64_operator_info : IntrinsicValRef - member int64_tcr : TypedTree.EntityRef - member int64_ty : TypedTree.TType - member int_checked_info : IntrinsicValRef - member int_operator_info : IntrinsicValRef - member int_tcr : TypedTree.EntityRef - member int_ty : TypedTree.TType - member invalid_arg_info : IntrinsicValRef - member invalid_arg_vref : TypedTree.ValRef - member invalid_op_info : IntrinsicValRef - member invalid_op_vref : TypedTree.ValRef - member isInteractive : bool - member isnotnull_info : IntrinsicValRef - member isnull_info : IntrinsicValRef - member istype_fast_info : IntrinsicValRef - member istype_fast_vref : TypedTree.ValRef - member istype_info : IntrinsicValRef - member istype_vref : TypedTree.ValRef - member - knownFSharpCoreModules : System.Collections.Generic.IDictionary - member - knownIntrinsics : System.Collections.Concurrent.ConcurrentDictionary<(string * - string option * - string * - int), - TypedTree.ValRef> - member langVersion : Features.LanguageVersion - member lazy_create_info : IntrinsicValRef - member lazy_force_info : IntrinsicValRef - member lazy_tcr_canon : TypedTree.EntityRef - member lazy_tcr_nice : TypedTree.EntityRef - member less_than_operator : IntrinsicValRef - member less_than_operator_vref : TypedTree.ValRef - member less_than_or_equals_operator : IntrinsicValRef - member less_than_or_equals_operator_vref : TypedTree.ValRef - member lift_value_info : IntrinsicValRef - member lift_value_with_defn_info : IntrinsicValRef - member lift_value_with_name_info : IntrinsicValRef - member list_tcr_canon : TypedTree.EntityRef - member list_tcr_nice : TypedTree.EntityRef - member map_tcr_canon : TypedTree.EntityRef - member measureinverse_tcr : TypedTree.EntityRef - member measureone_tcr : TypedTree.EntityRef - member measureproduct_tcr : TypedTree.EntityRef - member methodhandleof_info : IntrinsicValRef - member methodhandleof_vref : TypedTree.ValRef - member mk_IComparable_ty : TypedTree.TType - member mk_IStructuralComparable_ty : TypedTree.TType - member mk_IStructuralEquatable_ty : TypedTree.TType - member mlCompatibility : bool - member nameof_vref : TypedTree.ValRef - member nativeint_checked_info : IntrinsicValRef - member nativeint_operator_info : IntrinsicValRef - member nativeint_tcr : TypedTree.EntityRef - member nativeint_ty : TypedTree.TType - member nativeptr_tcr : TypedTree.EntityRef - member nativeptr_tobyref_vref : TypedTree.ValRef - member new_decimal_info : IntrinsicValRef - member new_format_info : IntrinsicValRef - member new_format_vref : TypedTree.ValRef - member new_query_source_info : IntrinsicValRef - member nil_ucref : TypedTree.UnionCaseRef - member not_equals_operator : IntrinsicValRef - member not_equals_operator_vref : TypedTree.ValRef - member null_arg_info : IntrinsicValRef - member null_arg_vref : TypedTree.ValRef - member nullable_equals_nullable_operator_vref : TypedTree.ValRef - member nullable_equals_operator_vref : TypedTree.ValRef - member obj_ty : TypedTree.TType - member option_defaultValue_info : IntrinsicValRef - member option_tcr_canon : TypedTree.EntityRef - member option_tcr_nice : TypedTree.EntityRef - member option_toNullable_info : IntrinsicValRef - member or2_vref : TypedTree.ValRef - member or_vref : TypedTree.ValRef - member outref_tcr : TypedTree.EntityRef - member pathMap : Internal.Utilities.PathMap - member pdecimal_tcr : TypedTree.EntityRef - member pfloat32_tcr : TypedTree.EntityRef - member pfloat_tcr : TypedTree.EntityRef - member pint16_tcr : TypedTree.EntityRef - member pint64_tcr : TypedTree.EntityRef - member pint8_tcr : TypedTree.EntityRef - member pint_tcr : TypedTree.EntityRef - member pnativeint_tcr : TypedTree.EntityRef - member puint16_tcr : TypedTree.EntityRef - member puint64_tcr : TypedTree.EntityRef - member puint8_tcr : TypedTree.EntityRef - member puint_tcr : TypedTree.EntityRef - member punativeint_tcr : TypedTree.EntityRef - member query_builder_tcref : TypedTree.EntityRef - member query_for_vref : TypedTree.ValRef - member query_run_enumerable_vref : TypedTree.ValRef - member query_run_value_vref : TypedTree.ValRef - member query_select_vref : TypedTree.ValRef - member query_source_as_enum_info : IntrinsicValRef - member query_source_vref : TypedTree.ValRef - member query_value_vref : TypedTree.ValRef - member query_where_vref : TypedTree.ValRef - member query_yield_from_vref : TypedTree.ValRef - member query_yield_vref : TypedTree.ValRef - member query_zero_vref : TypedTree.ValRef - member quote_to_linq_lambda_info : IntrinsicValRef - member raise_info : IntrinsicValRef - member raise_vref : TypedTree.ValRef - member range_int32_op_vref : TypedTree.ValRef - member range_op_vref : TypedTree.ValRef - member range_step_op_vref : TypedTree.ValRef - member raw_expr_tcr : TypedTree.EntityRef - member ref_tuple1_tcr : TypedTree.EntityRef - member ref_tuple2_tcr : TypedTree.EntityRef - member ref_tuple3_tcr : TypedTree.EntityRef - member ref_tuple4_tcr : TypedTree.EntityRef - member ref_tuple5_tcr : TypedTree.EntityRef - member ref_tuple6_tcr : TypedTree.EntityRef - member ref_tuple7_tcr : TypedTree.EntityRef - member ref_tuple8_tcr : TypedTree.EntityRef - member refcell_tcr_canon : TypedTree.EntityRef - member refcell_tcr_nice : TypedTree.EntityRef - member reference_equality_inner_vref : TypedTree.ValRef - member reraise_info : IntrinsicValRef - member reraise_vref : TypedTree.ValRef - member sbyte_checked_info : IntrinsicValRef - member sbyte_operator_info : IntrinsicValRef - member sbyte_tcr : TypedTree.EntityRef - member sbyte_ty : TypedTree.TType - member seq_append_info : IntrinsicValRef - member seq_append_vref : TypedTree.ValRef - member seq_base_tcr : TypedTree.EntityRef - member seq_collect_info : IntrinsicValRef - member seq_collect_vref : TypedTree.ValRef - member seq_delay_info : IntrinsicValRef - member seq_delay_vref : TypedTree.ValRef - member seq_empty_info : IntrinsicValRef - member seq_empty_vref : TypedTree.ValRef - member seq_finally_info : IntrinsicValRef - member seq_finally_vref : TypedTree.ValRef - member seq_generated_info : IntrinsicValRef - member seq_generated_vref : TypedTree.ValRef - member seq_info : IntrinsicValRef - member seq_map_info : IntrinsicValRef - member seq_map_vref : TypedTree.ValRef - member seq_of_functions_info : IntrinsicValRef - member seq_of_functions_vref : TypedTree.ValRef - member seq_singleton_info : IntrinsicValRef - member seq_singleton_vref : TypedTree.ValRef - member seq_tcr : TypedTree.EntityRef - member seq_to_array_info : IntrinsicValRef - member seq_to_list_info : IntrinsicValRef - member seq_using_info : IntrinsicValRef - member seq_using_vref : TypedTree.ValRef - member seq_vref : TypedTree.ValRef - member set_tcr_canon : TypedTree.EntityRef - member sizeof_vref : TypedTree.ValRef - member splice_expr_vref : TypedTree.ValRef - member splice_raw_expr_vref : TypedTree.ValRef - member sprintf_info : IntrinsicValRef - member sprintf_vref : TypedTree.ValRef - member string_ty : TypedTree.TType - member struct_tuple1_tcr : TypedTree.EntityRef - member struct_tuple2_tcr : TypedTree.EntityRef - member struct_tuple3_tcr : TypedTree.EntityRef - member struct_tuple4_tcr : TypedTree.EntityRef - member struct_tuple5_tcr : TypedTree.EntityRef - member struct_tuple6_tcr : TypedTree.EntityRef - member struct_tuple7_tcr : TypedTree.EntityRef - member struct_tuple8_tcr : TypedTree.EntityRef - member suppressed_types : TypedTree.EntityRef list - member system_ArgIterator_tcref : TypedTree.EntityRef option - member system_Array_tcref : TypedTree.EntityRef - member system_Array_ty : TypedTree.TType - member system_Bool_tcref : TypedTree.EntityRef - member system_Byte_tcref : TypedTree.EntityRef - member system_Char_tcref : TypedTree.EntityRef - member system_Decimal_tcref : TypedTree.EntityRef - member system_Delegate_ty : TypedTree.TType - member system_Double_tcref : TypedTree.EntityRef - member system_Enum_ty : TypedTree.TType - member system_ExceptionDispatchInfo_ty : TypedTree.TType option - member system_Exception_ty : TypedTree.TType - member system_FormattableStringFactory_tcref : TypedTree.EntityRef - member system_FormattableStringFactory_ty : TypedTree.TType - member system_FormattableString_tcref : TypedTree.EntityRef - member system_FormattableString_ty : TypedTree.TType - member system_GenericIComparable_tcref : TypedTree.EntityRef - member system_GenericIEquatable_tcref : TypedTree.EntityRef - member system_IDisposable_ty : TypedTree.TType - member system_IFormattable_tcref : TypedTree.EntityRef - member system_IFormattable_ty : TypedTree.TType - member system_IndexOutOfRangeException_tcref : TypedTree.EntityRef - member system_Int16_tcref : TypedTree.EntityRef - member system_Int32_tcref : TypedTree.EntityRef - member system_Int32_ty : TypedTree.TType - member system_Int64_tcref : TypedTree.EntityRef - member system_IntPtr_tcref : TypedTree.EntityRef - member system_LinqExpression_tcref : TypedTree.EntityRef - member system_MarshalByRefObject_tcref : TypedTree.EntityRef option - member system_MarshalByRefObject_ty : TypedTree.TType option - member system_MulticastDelegate_ty : TypedTree.TType - member system_Nullable_tcref : TypedTree.EntityRef - member system_Object_tcref : TypedTree.EntityRef - member system_Object_ty : TypedTree.TType - member system_Reflection_MethodInfo_ty : TypedTree.TType - member system_RuntimeArgumentHandle_tcref : TypedTree.EntityRef option - member system_RuntimeHelpers_ty : TypedTree.TType - member system_RuntimeMethodHandle_ty : TypedTree.TType - member system_RuntimeTypeHandle_ty : TypedTree.TType - member system_SByte_tcref : TypedTree.EntityRef - member system_Single_tcref : TypedTree.EntityRef - member system_String_tcref : TypedTree.EntityRef - member system_String_typ : TypedTree.TType - member system_Type_ty : TypedTree.TType - member system_TypedReference_tcref : TypedTree.EntityRef option - member system_UInt16_tcref : TypedTree.EntityRef - member system_UInt32_tcref : TypedTree.EntityRef - member system_UInt64_tcref : TypedTree.EntityRef - member system_UIntPtr_tcref : TypedTree.EntityRef - member system_Value_tcref : TypedTree.EntityRef - member system_Value_ty : TypedTree.TType - member system_Void_tcref : TypedTree.EntityRef - member tcref_IObservable : TypedTree.EntityRef - member tcref_IObserver : TypedTree.EntityRef - member tcref_IQueryable : TypedTree.EntityRef - member tcref_LanguagePrimitives : TypedTree.EntityRef - member tcref_System_Attribute : TypedTree.EntityRef - member tcref_System_Collections_Generic_Dictionary : TypedTree.EntityRef - member - tcref_System_Collections_Generic_ICollection : TypedTree.EntityRef - member - tcref_System_Collections_Generic_IDictionary : TypedTree.EntityRef - member - tcref_System_Collections_Generic_IEnumerable : TypedTree.EntityRef - member - tcref_System_Collections_Generic_IEnumerator : TypedTree.EntityRef - member - tcref_System_Collections_Generic_IEqualityComparer : TypedTree.EntityRef - member tcref_System_Collections_Generic_IList : TypedTree.EntityRef - member - tcref_System_Collections_Generic_IReadOnlyCollection : TypedTree.EntityRef - member - tcref_System_Collections_Generic_IReadOnlyList : TypedTree.EntityRef - member tcref_System_Collections_Generic_List : TypedTree.EntityRef - member tcref_System_Collections_IComparer : TypedTree.EntityRef - member tcref_System_Collections_IEnumerable : TypedTree.EntityRef - member tcref_System_Collections_IEqualityComparer : TypedTree.EntityRef - member tcref_System_IComparable : TypedTree.EntityRef - member tcref_System_IDisposable : TypedTree.EntityRef - member tcref_System_IStructuralComparable : TypedTree.EntityRef - member tcref_System_IStructuralEquatable : TypedTree.EntityRef - member typedefof_info : IntrinsicValRef - member typedefof_vref : TypedTree.ValRef - member typeof_info : IntrinsicValRef - member typeof_vref : TypedTree.ValRef - member uint16_checked_info : IntrinsicValRef - member uint16_operator_info : IntrinsicValRef - member uint16_tcr : TypedTree.EntityRef - member uint16_ty : TypedTree.TType - member uint32_checked_info : IntrinsicValRef - member uint32_operator_info : IntrinsicValRef - member uint32_tcr : TypedTree.EntityRef - member uint32_ty : TypedTree.TType - member uint64_checked_info : IntrinsicValRef - member uint64_operator_info : IntrinsicValRef - member uint64_tcr : TypedTree.EntityRef - member uint64_ty : TypedTree.TType - member unativeint_checked_info : IntrinsicValRef - member unativeint_operator_info : IntrinsicValRef - member unativeint_tcr : TypedTree.EntityRef - member unativeint_ty : TypedTree.TType - member unbox_fast_info : IntrinsicValRef - member unbox_fast_vref : TypedTree.ValRef - member unbox_info : IntrinsicValRef - member unbox_vref : TypedTree.ValRef - member unchecked_addition_info : IntrinsicValRef - member unchecked_addition_vref : TypedTree.ValRef - member unchecked_defaultof_info : IntrinsicValRef - member unchecked_defaultof_vref : TypedTree.ValRef - member unchecked_division_info : IntrinsicValRef - member unchecked_modulus_info : IntrinsicValRef - member unchecked_multiply_info : IntrinsicValRef - member unchecked_multiply_vref : TypedTree.ValRef - member unchecked_subtraction_info : IntrinsicValRef - member unchecked_subtraction_vref : TypedTree.ValRef - member unchecked_unary_minus_info : IntrinsicValRef - member unchecked_unary_minus_vref : TypedTree.ValRef - member unchecked_unary_not_info : IntrinsicValRef - member unchecked_unary_not_vref : TypedTree.ValRef - member unchecked_unary_plus_info : IntrinsicValRef - member unchecked_unary_plus_vref : TypedTree.ValRef - member unit_tcr_canon : TypedTree.EntityRef - member unit_tcr_nice : TypedTree.EntityRef - member unit_ty : TypedTree.TType - member voidptr_tcr : TypedTree.EntityRef - end - val mutable global_g : TcGlobals option - end - -namespace FSharp.Compiler - module internal TypedTreeOps = begin - [] - type TyparMap<'T> = - | TPMap of TypedTree.StampMap<'T> - with - member Add : TypedTree.Typar * 'T -> TyparMap<'T> - member ContainsKey : TypedTree.Typar -> bool - member TryFind : TypedTree.Typar -> 'T option - member Item : TypedTree.Typar -> 'T with get - static member Empty : TyparMap<'T> - end - [] - type TyconRefMap<'T> = - class - new : imap:TypedTree.StampMap<'T> -> TyconRefMap<'T> - static member OfList : (TypedTree.TyconRef * 'T) list -> TyconRefMap<'T> - member Add : TypedTree.TyconRef -> 'T -> TyconRefMap<'T> - member ContainsKey : TypedTree.TyconRef -> bool - member Remove : TypedTree.TyconRef -> TyconRefMap<'T> - member TryFind : TypedTree.TyconRef -> 'T option - member IsEmpty : bool - member Item : TypedTree.TyconRef -> 'T with get - static member Empty : TyconRefMap<'T> - end - [] - type ValMap<'T> = - struct - new : imap:TypedTree.StampMap<'T> -> ValMap<'T> - static member OfList : (TypedTree.Val * 'T) list -> ValMap<'T> - member Add : TypedTree.Val -> 'T -> ValMap<'T> - member ContainsVal : TypedTree.Val -> bool - member Remove : TypedTree.Val -> ValMap<'T> - member TryFind : TypedTree.Val -> 'T option - member Contents : TypedTree.StampMap<'T> - member IsEmpty : bool - member Item : TypedTree.Val -> 'T with get - static member Empty : ValMap<'T> - end - type TyparInst = (TypedTree.Typar * TypedTree.TType) list - type TyconRefRemap = TyconRefMap - type ValRemap = ValMap - val emptyTyconRefRemap : TyconRefRemap - val emptyTyparInst : TyparInst - [] - type Remap = - { tpinst: TyparInst - valRemap: ValRemap - tyconRefRemap: TyconRefRemap - removeTraitSolutions: bool } - with - static member Empty : Remap - end - val emptyRemap : Remap - val addTyconRefRemap : - TypedTree.TyconRef -> TypedTree.TyconRef -> Remap -> Remap - val isRemapEmpty : remap:Remap -> bool - val instTyparRef : - tpinst:(TypedTree.Typar * 'a) list -> ty:'a -> tp:TypedTree.Typar -> 'a - val instMeasureTyparRef : - tpinst:(TypedTree.Typar * TypedTree.TType) list -> - unt:TypedTree.Measure -> tp:TypedTree.Typar -> TypedTree.Measure - val remapTyconRef : - TyconRefMap -> - TypedTree.TyconRef -> TypedTree.TyconRef - val remapUnionCaseRef : - TyconRefMap -> - TypedTree.UnionCaseRef -> TypedTree.UnionCaseRef - val remapRecdFieldRef : - TyconRefMap -> - TypedTree.RecdFieldRef -> TypedTree.RecdFieldRef - val mkTyparInst : TypedTree.Typars -> TypedTree.TType list -> TyparInst - val generalizeTypar : tp:TypedTree.Typar -> TypedTree.TType - val generalizeTypars : TypedTree.Typar list -> TypedTree.TType list - val remapTypeAux : tyenv:Remap -> ty:TypedTree.TType -> TypedTree.TType - val remapMeasureAux : - tyenv:Remap -> unt:TypedTree.Measure -> TypedTree.Measure - val remapTupInfoAux : - _tyenv:Remap -> unt:TypedTree.TupInfo -> TypedTree.TupInfo - val remapTypesAux : - tyenv:Remap -> types:TypedTree.TypeInst -> TypedTree.TypeInst - val remapTyparConstraintsAux : - tyenv:Remap -> - cs:TypedTree.TyparConstraint list -> TypedTree.TyparConstraint list - val remapTraitWitnessInfo : - tyenv:Remap -> TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo - val remapTraitInfo : - tyenv:Remap -> - TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo - val bindTypars : - tps:'a list -> tyargs:'b list -> tpinst:('a * 'b) list -> ('a * 'b) list - val copyAndRemapAndBindTyparsFull : - remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> - tyenv:Remap -> tps:TypedTree.Typar list -> TypedTree.Typar list * Remap - val copyAndRemapAndBindTypars : - tyenv:Remap -> tps:TypedTree.Typars -> TypedTree.Typars * Remap - val remapValLinkage : - tyenv:Remap -> - vlink:TypedTree.ValLinkageFullKey -> TypedTree.ValLinkageFullKey - val remapNonLocalValRef : - tyenv:Remap -> - nlvref:TypedTree.NonLocalValOrMemberRef -> - TypedTree.NonLocalValOrMemberRef - val remapValRef : Remap -> TypedTree.ValRef -> TypedTree.ValRef - val remapType : tyenv:Remap -> x:TypedTree.TType -> TypedTree.TType - val remapTypes : tyenv:Remap -> x:TypedTree.TypeInst -> TypedTree.TypeInst - val remapTypeFull : - remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> - tyenv:Remap -> ty:TypedTree.TType -> TypedTree.TType - val remapParam : tyenv:Remap -> TypedTree.SlotParam -> TypedTree.SlotParam - val remapSlotSig : - remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> - tyenv:Remap -> TypedTree.SlotSig -> TypedTree.SlotSig - val mkInstRemap : tpinst:TyparInst -> Remap - val instType : - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.TType -> TypedTree.TType - val instTypes : - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.TypeInst -> TypedTree.TypeInst - val instTrait : - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo - val instTyparConstraints : - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.TyparConstraint list -> TypedTree.TyparConstraint list - val instSlotSig : TyparInst -> TypedTree.SlotSig -> TypedTree.SlotSig - val copySlotSig : TypedTree.SlotSig -> TypedTree.SlotSig - val mkTyparToTyparRenaming : - TypedTree.Typars -> - TypedTree.Typar list -> TyparInst * TypedTree.TType list - val mkTyconInst : - tycon:TypedTree.Tycon -> tinst:TypedTree.TType list -> TyparInst - val mkTyconRefInst : TypedTree.TyconRef -> TypedTree.TType list -> TyparInst - val tyconRefEq : - TcGlobals.TcGlobals -> TypedTree.EntityRef -> TypedTree.EntityRef -> bool - val valRefEq : - TcGlobals.TcGlobals -> TypedTree.ValRef -> TypedTree.ValRef -> bool - val reduceTyconRefAbbrevMeasureable : - TypedTree.TyconRef -> TypedTree.Measure - val stripUnitEqnsFromMeasureAux : - canShortcut:bool -> unt:TypedTree.Measure -> TypedTree.Measure - val stripUnitEqnsFromMeasure : m:TypedTree.Measure -> TypedTree.Measure - val MeasureExprConExponent : - TcGlobals.TcGlobals -> - bool -> TypedTree.EntityRef -> TypedTree.Measure -> Rational.Rational - val MeasureConExponentAfterRemapping : - g:TcGlobals.TcGlobals -> - r:(TypedTree.TyconRef -> TypedTree.EntityRef) -> - ucref:TypedTree.EntityRef -> - unt:TypedTree.Measure -> Rational.Rational - val MeasureVarExponent : - TypedTree.Typar -> TypedTree.Measure -> Rational.Rational - val ListMeasureVarOccs : unt:TypedTree.Measure -> TypedTree.Typar list - val ListMeasureVarOccsWithNonZeroExponents : - TypedTree.Measure -> (TypedTree.Typar * Rational.Rational) list - val ListMeasureConOccsWithNonZeroExponents : - TcGlobals.TcGlobals -> - bool -> - TypedTree.Measure -> (TypedTree.EntityRef * Rational.Rational) list - val ListMeasureConOccsAfterRemapping : - g:TcGlobals.TcGlobals -> - r:(TypedTree.TyconRef -> TypedTree.EntityRef) -> - unt:TypedTree.Measure -> TypedTree.EntityRef list - val MeasurePower : TypedTree.Measure -> int -> TypedTree.Measure - val MeasureProdOpt : - m1:TypedTree.Measure -> m2:TypedTree.Measure -> TypedTree.Measure - val ProdMeasures : TypedTree.Measure list -> TypedTree.Measure - val isDimensionless : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val destUnitParMeasure : - g:TcGlobals.TcGlobals -> unt:TypedTree.Measure -> TypedTree.Typar - val isUnitParMeasure : - g:TcGlobals.TcGlobals -> unt:TypedTree.Measure -> bool - val normalizeMeasure : - TcGlobals.TcGlobals -> TypedTree.Measure -> TypedTree.Measure - val tryNormalizeMeasureInType : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkNativePtrTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkInByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkOutByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkByrefTyWithFlag : - g:TcGlobals.TcGlobals -> - readonly:bool -> ty:TypedTree.TType -> TypedTree.TType - val mkByref2Ty : - g:TcGlobals.TcGlobals -> - ty1:TypedTree.TType -> ty2:TypedTree.TType -> TypedTree.TType - val mkVoidPtrTy : TcGlobals.TcGlobals -> TypedTree.TType - val mkByrefTyWithInference : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType -> TypedTree.TType - val mkArrayTy : - TcGlobals.TcGlobals -> - int -> TypedTree.TType -> Range.range -> TypedTree.TType - val maxTuple : int - val goodTupleFields : int - val isCompiledTupleTyconRef : - TcGlobals.TcGlobals -> TypedTree.EntityRef -> bool - val mkCompiledTupleTyconRef : - TcGlobals.TcGlobals -> bool -> int -> TypedTree.EntityRef - val mkCompiledTupleTy : - TcGlobals.TcGlobals -> bool -> TypedTree.TType list -> TypedTree.TType - val mkOuterCompiledTupleTy : - g:TcGlobals.TcGlobals -> - isStruct:bool -> tupElemTys:TypedTree.TType list -> TypedTree.TType - val applyTyconAbbrev : - abbrevTy:TypedTree.TType -> - tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType - val reduceTyconAbbrev : - tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType - val reduceTyconRefAbbrev : - TypedTree.TyconRef -> TypedTree.TType list -> TypedTree.TType - val reduceTyconMeasureableOrProvided : - g:TcGlobals.TcGlobals -> - tycon:TypedTree.Tycon -> tyargs:TypedTree.TType list -> TypedTree.TType - val reduceTyconRefMeasureableOrProvided : - TcGlobals.TcGlobals -> - TypedTree.TyconRef -> TypedTree.TType list -> TypedTree.TType - val stripTyEqnsA : - TcGlobals.TcGlobals -> bool -> TypedTree.TType -> TypedTree.TType - val stripTyEqns : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val evalTupInfoIsStruct : TypedTree.TupInfo -> bool - val evalAnonInfoIsStruct : TypedTree.AnonRecdTypeInfo -> bool - val stripTyEqnsAndErase : - eraseFuncAndTuple:bool -> - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val stripTyEqnsAndMeasureEqns : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - type Erasure = - | EraseAll - | EraseMeasures - | EraseNone - val stripTyEqnsWrtErasure : - Erasure -> TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val stripExnEqns : TypedTree.TyconRef -> TypedTree.Entity - val primDestForallTy : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> TypedTree.Typars * TypedTree.TType - val destFunTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType * TypedTree.TType - val destAnyTupleTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TupInfo * TypedTree.TTypes - val destRefTupleTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes - val destStructTupleTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes - val destTyparTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar - val destAnyParTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar - val destMeasureTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Measure - val isFunTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isForallTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isAnyTupleTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isRefTupleTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isStructTupleTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isAnonRecdTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isStructAnonRecdTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isUnionTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isReprHiddenTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isFSharpObjModelTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isRecdTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isFSharpStructOrEnumTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isFSharpEnumTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isTyparTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isAnyParTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isMeasureTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isProvenUnionCaseTy : TypedTree.TType -> bool - val mkAppTy : TypedTree.TyconRef -> TypedTree.TypeInst -> TypedTree.TType - val mkProvenUnionCaseTy : - TypedTree.UnionCaseRef -> TypedTree.TypeInst -> TypedTree.TType - val isAppTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val tryAppTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> (TypedTree.TyconRef * TypedTree.TypeInst) voption - val destAppTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TyconRef * TypedTree.TypeInst - val tcrefOfAppTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TyconRef - val argsOfAppTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TypeInst - val tryDestTyparTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar voption - val tryDestFunTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> (TypedTree.TType * TypedTree.TType) voption - val tryTcrefOfAppTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TyconRef voption - val tryDestAnonRecdTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> - (TypedTree.AnonRecdTypeInfo * TypedTree.TType list) voption - val tryAnyParTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar voption - val tryAnyParTyOption : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.Typar option - val ( |AppTy|_| ) : - TcGlobals.TcGlobals -> - TypedTree.TType -> (TypedTree.TyconRef * TypedTree.TypeInst) option - val ( |RefTupleTy|_| ) : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TTypes option - val ( |FunTy|_| ) : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> (TypedTree.TType * TypedTree.TType) option - val tryNiceEntityRefOfTy : TypedTree.TType -> TypedTree.TyconRef voption - val tryNiceEntityRefOfTyOption : - TypedTree.TType -> TypedTree.TyconRef option - val mkInstForAppTy : TcGlobals.TcGlobals -> TypedTree.TType -> TyparInst - val domainOfFunTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val rangeOfFunTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val convertToTypeWithMetadataIfPossible : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val stripMeasuresFromTType : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - [] - type TypeEquivEnv = - { EquivTypars: TyparMap - EquivTycons: TyconRefRemap } - with - static member - FromEquivTypars : TypedTree.Typar list -> - TypedTree.Typar list -> TypeEquivEnv - static member - FromTyparInst : (TypedTree.Typar * TypedTree.TType) list -> - TypeEquivEnv - member - BindEquivTypars : TypedTree.Typar list -> - TypedTree.Typar list -> TypeEquivEnv - member - BindTyparsToTypes : tps1:TypedTree.Typar list -> - tys2:TypedTree.TType list -> TypeEquivEnv - static member Empty : TypeEquivEnv - end - val typeEquivEnvEmpty : TypeEquivEnv - val traitsAEquivAux : - Erasure -> - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TraitConstraintInfo -> - TypedTree.TraitConstraintInfo -> bool - val traitKeysAEquivAux : - Erasure -> - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo -> bool - val returnTypesAEquivAux : - Erasure -> - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TType option -> TypedTree.TType option -> bool - val typarConstraintsAEquivAux : - Erasure -> - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TyparConstraint -> TypedTree.TyparConstraint -> bool - val typarConstraintSetsAEquivAux : - erasureFlag:Erasure -> - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - tp1:TypedTree.Typar -> tp2:TypedTree.Typar -> bool - val typarsAEquivAux : - erasureFlag:Erasure -> - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - tps1:TypedTree.Typar list -> tps2:TypedTree.Typar list -> bool - val tcrefAEquiv : - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.EntityRef -> TypedTree.EntityRef -> bool - val typeAEquivAux : - Erasure -> - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.TType -> TypedTree.TType -> bool - val anonInfoEquiv : - TypedTree.AnonRecdTypeInfo -> TypedTree.AnonRecdTypeInfo -> bool - val structnessAEquiv : - un1:TypedTree.TupInfo -> un2:TypedTree.TupInfo -> bool - val measureAEquiv : - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - un1:TypedTree.Measure -> un2:TypedTree.Measure -> bool - val typesAEquivAux : - erasureFlag:Erasure -> - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - l1:TypedTree.TypeInst -> l2:TypedTree.TypeInst -> bool - val typeEquivAux : - Erasure -> - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType -> bool - val typeAEquiv : - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.TType -> TypedTree.TType -> bool - val typeEquiv : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType -> bool - val traitsAEquiv : - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TraitConstraintInfo -> TypedTree.TraitConstraintInfo -> bool - val traitKeysAEquiv : - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TraitWitnessInfo -> TypedTree.TraitWitnessInfo -> bool - val typarConstraintsAEquiv : - TcGlobals.TcGlobals -> - TypeEquivEnv -> - TypedTree.TyparConstraint -> TypedTree.TyparConstraint -> bool - val typarsAEquiv : - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.Typar list -> TypedTree.Typar list -> bool - val returnTypesAEquiv : - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.TType option -> TypedTree.TType option -> bool - val measureEquiv : - TcGlobals.TcGlobals -> TypedTree.Measure -> TypedTree.Measure -> bool - val getMeasureOfType : - TcGlobals.TcGlobals -> - TypedTree.TType -> (TypedTree.TyconRef * TypedTree.Measure) option - val isErasedType : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val getErasedTypes : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType list - val valOrder : System.Collections.Generic.IComparer - val tyconOrder : System.Collections.Generic.IComparer - val recdFieldRefOrder : - System.Collections.Generic.IComparer - val unionCaseRefOrder : - System.Collections.Generic.IComparer - val mkFunTy : TypedTree.TType -> TypedTree.TType -> TypedTree.TType - val ( --> ) : TypedTree.TType -> TypedTree.TType -> TypedTree.TType - val mkForallTy : d:TypedTree.Typars -> r:TypedTree.TType -> TypedTree.TType - val mkForallTyIfNeeded : - TypedTree.Typar list -> TypedTree.TType -> TypedTree.TType - val ( +-> ) : TypedTree.Typar list -> TypedTree.TType -> TypedTree.TType - val mkIteratedFunTy : - TypedTree.TType list -> TypedTree.TType -> TypedTree.TType - val mkLambdaArgTy : - m:Range.range -> tys:TypedTree.TType list -> TypedTree.TType - val typeOfLambdaArg : Range.range -> TypedTree.Val list -> TypedTree.TType - val mkMultiLambdaTy : - Range.range -> TypedTree.Val list -> TypedTree.TType -> TypedTree.TType - val mkLambdaTy : - TypedTree.Typar list -> - TypedTree.TType list -> TypedTree.TType -> TypedTree.TType - val ensureCcuHasModuleOrNamespaceAtPath : - TypedTree.CcuThunk -> - SyntaxTree.Ident list -> - TypedTree.CompilationPath -> XmlDoc.XmlDoc -> unit - val stripExpr : TypedTree.Expr -> TypedTree.Expr - val mkCase : - TypedTree.DecisionTreeTest * TypedTree.DecisionTree -> - TypedTree.DecisionTreeCase - val isRefTupleExpr : TypedTree.Expr -> bool - val tryDestRefTupleExpr : TypedTree.Expr -> TypedTree.Exprs - val rangeOfExpr : x:TypedTree.Expr -> Range.range - type Expr with - member Range : Range.range - val primMkMatch : - SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * - TypedTree.DecisionTreeTarget array * Range.range * TypedTree.TType -> - TypedTree.Expr - type MatchBuilder = - class - new : SyntaxTree.DebugPointForBinding * Range.range -> MatchBuilder - member - AddResultTarget : TypedTree.Expr * SyntaxTree.DebugPointForTarget -> - TypedTree.DecisionTree - member AddTarget : TypedTree.DecisionTreeTarget -> int - member - Close : TypedTree.DecisionTree * Range.range * TypedTree.TType -> - TypedTree.Expr - member CloseTargets : unit -> TypedTree.DecisionTreeTarget list - end - val mkBoolSwitch : - Range.range -> - TypedTree.Expr -> - TypedTree.DecisionTree -> - TypedTree.DecisionTree -> TypedTree.DecisionTree - val primMkCond : - SyntaxTree.DebugPointForBinding -> - SyntaxTree.DebugPointForTarget -> - SyntaxTree.DebugPointForTarget -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCond : - SyntaxTree.DebugPointForBinding -> - SyntaxTree.DebugPointForTarget -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val exprForValRef : Range.range -> TypedTree.ValRef -> TypedTree.Expr - val exprForVal : Range.range -> TypedTree.Val -> TypedTree.Expr - val mkLocalAux : - m:Range.range -> - s:string -> - ty:TypedTree.TType -> - mut:TypedTree.ValMutability -> - compgen:bool -> TypedTree.Val * TypedTree.Expr - val mkLocal : - Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val mkCompGenLocal : - Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val mkMutableCompGenLocal : - Range.range -> string -> TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val mkMultiLambda : - Range.range -> - TypedTree.Val list -> TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val rebuildLambda : - Range.range -> - TypedTree.Val option -> - TypedTree.Val option -> - TypedTree.Val list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkLambda : - Range.range -> - TypedTree.Val -> TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkTypeLambda : - Range.range -> - TypedTree.Typar list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkTypeChoose : - Range.range -> TypedTree.Typar list -> TypedTree.Expr -> TypedTree.Expr - val mkObjExpr : - TypedTree.TType * TypedTree.Val option * TypedTree.Expr * - TypedTree.ObjExprMethod list * - (TypedTree.TType * TypedTree.ObjExprMethod list) list * Range.range -> - TypedTree.Expr - val mkLambdas : - Range.range -> - TypedTree.Typar list -> - TypedTree.Val list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkMultiLambdasCore : - Range.range -> - TypedTree.Val list list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr * TypedTree.TType - val mkMultiLambdas : - Range.range -> - TypedTree.Typar list -> - TypedTree.Val list list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkMemberLambdas : - Range.range -> - TypedTree.Typar list -> - TypedTree.Val option -> - TypedTree.Val option -> - TypedTree.Val list list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Expr - val mkMultiLambdaBind : - TypedTree.Val -> - SyntaxTree.DebugPointForBinding -> - Range.range -> - TypedTree.Typar list -> - TypedTree.Val list list -> - TypedTree.Expr * TypedTree.TType -> TypedTree.Binding - val mkBind : - SyntaxTree.DebugPointForBinding -> - TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding - val mkLetBind : - Range.range -> TypedTree.Binding -> TypedTree.Expr -> TypedTree.Expr - val mkLetsBind : - Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr - val mkLetsFromBindings : - Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr - val mkLet : - SyntaxTree.DebugPointForBinding -> - Range.range -> - TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCompGenBind : TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding - val mkCompGenBinds : - TypedTree.Val list -> TypedTree.Expr list -> TypedTree.Binding list - val mkCompGenLet : - Range.range -> - TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCompGenLets : - m:Range.range -> - vs:TypedTree.Val list -> - xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr - val mkCompGenLetsFromBindings : - m:Range.range -> - vs:TypedTree.Val list -> - xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr - val mkInvisibleBind : TypedTree.Val -> TypedTree.Expr -> TypedTree.Binding - val mkInvisibleBinds : - TypedTree.Val list -> TypedTree.Expr list -> TypedTree.Binding list - val mkInvisibleLet : - Range.range -> - TypedTree.Val -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkInvisibleLets : - m:Range.range -> - vs:TypedTree.Val list -> - xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr - val mkInvisibleLetsFromBindings : - m:Range.range -> - vs:TypedTree.Val list -> - xs:TypedTree.Expr list -> body:TypedTree.Expr -> TypedTree.Expr - val mkLetRecBinds : - Range.range -> TypedTree.Binding list -> TypedTree.Expr -> TypedTree.Expr - val NormalizeDeclaredTyparsForEquiRecursiveInference : - TcGlobals.TcGlobals -> TypedTree.Typar list -> TypedTree.Typar list - type TypeScheme = | TypeScheme of TypedTree.Typars * TypedTree.TType - val mkGenericBindRhs : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Typar list -> TypeScheme -> TypedTree.Expr -> TypedTree.Expr - val isBeingGeneralized : TypedTree.Typar -> TypeScheme -> bool - val mkLazyAnd : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkLazyOr : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCoerceExpr : - TypedTree.Expr * TypedTree.TType * Range.range * TypedTree.TType -> - TypedTree.Expr - val mkAsmExpr : - AbstractIL.IL.ILInstr list * TypedTree.TypeInst * TypedTree.Exprs * - TypedTree.TTypes * Range.range -> TypedTree.Expr - val mkUnionCaseExpr : - TypedTree.UnionCaseRef * TypedTree.TypeInst * TypedTree.Exprs * - Range.range -> TypedTree.Expr - val mkExnExpr : - TypedTree.TyconRef * TypedTree.Exprs * Range.range -> TypedTree.Expr - val mkTupleFieldGetViaExprAddr : - tupInfo:TypedTree.TupInfo * e:TypedTree.Expr * tinst:TypedTree.TypeInst * - i:int * m:Range.range -> TypedTree.Expr - val mkAnonRecdFieldGetViaExprAddr : - TypedTree.AnonRecdTypeInfo * TypedTree.Expr * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkRecdFieldGetViaExprAddr : - TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> - TypedTree.Expr - val mkRecdFieldGetAddrViaExprAddr : - readonly:bool * TypedTree.Expr * TypedTree.RecdFieldRef * - TypedTree.TypeInst * Range.range -> TypedTree.Expr - val mkStaticRecdFieldGetAddr : - readonly:bool * TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> - TypedTree.Expr - val mkStaticRecdFieldGet : - TypedTree.RecdFieldRef * TypedTree.TypeInst * Range.range -> - TypedTree.Expr - val mkStaticRecdFieldSet : - TypedTree.RecdFieldRef * TypedTree.TypeInst * TypedTree.Expr * Range.range -> - TypedTree.Expr - val mkArrayElemAddress : - TcGlobals.TcGlobals -> - readonly:bool * AbstractIL.IL.ILReadonly * bool * - AbstractIL.IL.ILArrayShape * TypedTree.TType * TypedTree.Exprs * - Range.range -> TypedTree.Expr - val mkRecdFieldSetViaExprAddr : - TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * - TypedTree.Expr * Range.range -> TypedTree.Expr - val mkUnionCaseTagGetViaExprAddr : - TypedTree.Expr * TypedTree.TyconRef * TypedTree.TypeInst * Range.range -> - TypedTree.Expr - val mkUnionCaseProof : - TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * Range.range -> - TypedTree.Expr - val mkUnionCaseFieldGetProvenViaExprAddr : - TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkUnionCaseFieldGetAddrProvenViaExprAddr : - readonly:bool * TypedTree.Expr * TypedTree.UnionCaseRef * - TypedTree.TypeInst * int * Range.range -> TypedTree.Expr - val mkUnionCaseFieldGetUnprovenViaExprAddr : - TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkUnionCaseFieldSet : - TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * - TypedTree.Expr * Range.range -> TypedTree.Expr - val mkExnCaseFieldGet : - TypedTree.Expr * TypedTree.TyconRef * int * Range.range -> TypedTree.Expr - val mkExnCaseFieldSet : - TypedTree.Expr * TypedTree.TyconRef * int * TypedTree.Expr * Range.range -> - TypedTree.Expr - val mkDummyLambda : - g:TcGlobals.TcGlobals -> - e:TypedTree.Expr * ety:TypedTree.TType -> TypedTree.Expr - val mkWhile : - TcGlobals.TcGlobals -> - SyntaxTree.DebugPointAtWhile * TypedTree.SpecialWhileLoopMarker * - TypedTree.Expr * TypedTree.Expr * Range.range -> TypedTree.Expr - val mkFor : - TcGlobals.TcGlobals -> - SyntaxTree.DebugPointAtFor * TypedTree.Val * TypedTree.Expr * - TypedTree.ForLoopStyle * TypedTree.Expr * TypedTree.Expr * Range.range -> - TypedTree.Expr - val mkTryWith : - TcGlobals.TcGlobals -> - TypedTree.Expr * TypedTree.Val * TypedTree.Expr * TypedTree.Val * - TypedTree.Expr * Range.range * TypedTree.TType * - SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith -> - TypedTree.Expr - val mkTryFinally : - TcGlobals.TcGlobals -> - TypedTree.Expr * TypedTree.Expr * Range.range * TypedTree.TType * - SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally -> - TypedTree.Expr - val mkDefault : Range.range * TypedTree.TType -> TypedTree.Expr - val mkValSet : - Range.range -> TypedTree.ValRef -> TypedTree.Expr -> TypedTree.Expr - val mkAddrSet : - Range.range -> TypedTree.ValRef -> TypedTree.Expr -> TypedTree.Expr - val mkAddrGet : Range.range -> TypedTree.ValRef -> TypedTree.Expr - val mkValAddr : - Range.range -> readonly:bool -> TypedTree.ValRef -> TypedTree.Expr - [] - type ValHash<'T> = - | ValHash of System.Collections.Generic.Dictionary - with - static member Create : unit -> ValHash<'T> - member Add : TypedTree.Val * 'T -> unit - member TryFind : TypedTree.Val -> 'T option - member Values : seq<'T> - end - [] - type ValMultiMap<'T> = - struct - new : contents:TypedTree.StampMap<'T list> -> ValMultiMap<'T> - member Add : TypedTree.Val * 'T -> ValMultiMap<'T> - member ContainsKey : TypedTree.Val -> bool - member Find : TypedTree.Val -> 'T list - member Remove : TypedTree.Val -> ValMultiMap<'T> - member Contents : TypedTree.StampMap<'T list> - static member Empty : ValMultiMap<'T> - end - [] - type TyconRefMultiMap<'T> = - struct - new : contents:TyconRefMap<'T list> -> TyconRefMultiMap<'T> - static member - OfList : (TypedTree.TyconRef * 'T) list -> TyconRefMultiMap<'T> - member Add : TypedTree.TyconRef * 'T -> TyconRefMultiMap<'T> - member Find : TypedTree.TyconRef -> 'T list - static member Empty : TyconRefMultiMap<'T> - end - val tryRescopeEntity : - TypedTree.CcuThunk -> TypedTree.Entity -> ValueOption - val tryRescopeVal : - TypedTree.CcuThunk -> - Remap -> TypedTree.Val -> ValueOption - val actualTyOfRecdField : - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.RecdField -> TypedTree.TType - val actualTysOfRecdFields : - inst:(TypedTree.Typar * TypedTree.TType) list -> - rfields:TypedTree.RecdField list -> TypedTree.TType list - val actualTysOfInstanceRecdFields : - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.TyconRef -> TypedTree.TType list - val actualTysOfUnionCaseFields : - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.UnionCaseRef -> TypedTree.TType list - val actualResultTyOfUnionCase : - TypedTree.TType list -> TypedTree.UnionCaseRef -> TypedTree.TType - val recdFieldsOfExnDefRef : TypedTree.TyconRef -> TypedTree.RecdField list - val recdFieldOfExnDefRefByIdx : - x:TypedTree.TyconRef -> n:int -> TypedTree.RecdField - val recdFieldTysOfExnDefRef : TypedTree.TyconRef -> TypedTree.TType list - val recdFieldTyOfExnDefRefByIdx : - x:TypedTree.TyconRef -> j:int -> TypedTree.TType - val actualTyOfRecdFieldForTycon : - TypedTree.Tycon -> - TypedTree.TType list -> TypedTree.RecdField -> TypedTree.TType - val actualTyOfRecdFieldRef : - TypedTree.RecdFieldRef -> TypedTree.TType list -> TypedTree.TType - val actualTyOfUnionFieldRef : - fref:TypedTree.UnionCaseRef -> - n:int -> tinst:TypedTree.TType list -> TypedTree.TType - val destForallTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.Typar list * TypedTree.TType - val tryDestForallTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.Typar list * TypedTree.TType - val stripFunTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType list * TypedTree.TType - val applyForallTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType list -> TypedTree.TType - val reduceIteratedFunTy : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> args:'a list -> TypedTree.TType - val applyTyArgs : - g:TcGlobals.TcGlobals -> - functy:TypedTree.TType -> tyargs:TypedTree.TType list -> TypedTree.TType - val applyTys : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType list * 'T list -> TypedTree.TType - val formalApplyTys : - g:TcGlobals.TcGlobals -> - functy:TypedTree.TType -> - tyargs:'a list * args:'b list -> TypedTree.TType - val stripFunTyN : - TcGlobals.TcGlobals -> - int -> TypedTree.TType -> TypedTree.TType list * TypedTree.TType - val tryDestAnyTupleTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TupInfo * TypedTree.TTypes - val tryDestRefTupleTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes - type UncurriedArgInfos = (TypedTree.TType * TypedTree.ArgReprInfo) list - type CurriedArgInfos = (TypedTree.TType * TypedTree.ArgReprInfo) list list - type TraitWitnessInfos = TypedTree.TraitWitnessInfo list - val GetTopTauTypeInFSharpForm : - TcGlobals.TcGlobals -> - TypedTree.ArgReprInfo list list -> - TypedTree.TType -> - Range.range -> - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType - val destTopForallTy : - TcGlobals.TcGlobals -> - TypedTree.ValReprInfo -> - TypedTree.TType -> TypedTree.Typar list * TypedTree.TType - val GetTopValTypeInFSharpForm : - TcGlobals.TcGlobals -> - TypedTree.ValReprInfo -> - TypedTree.TType -> - Range.range -> - TypedTree.Typar list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType * TypedTree.ArgReprInfo - val IsCompiledAsStaticProperty : - TcGlobals.TcGlobals -> TypedTree.Val -> bool - val IsCompiledAsStaticPropertyWithField : - TcGlobals.TcGlobals -> TypedTree.Val -> bool - val isArrayTyconRef : TcGlobals.TcGlobals -> TypedTree.EntityRef -> bool - val rankOfArrayTyconRef : TcGlobals.TcGlobals -> TypedTree.EntityRef -> int - val destArrayTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val destListTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val tyconRefEqOpt : - g:TcGlobals.TcGlobals -> - tcOpt:TypedTree.EntityRef option -> tc:TypedTree.EntityRef -> bool - val isStringTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isListTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isArrayTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isArray1DTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isUnitTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isObjTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isValueTypeTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isVoidTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isILAppTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isNativePtrTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isInByrefTag : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isInByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isOutByrefTag : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isOutByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val extensionInfoOfTy : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> TypedTree.TyconRepresentation - type TypeDefMetadata = - | ILTypeMetadata of TypedTree.TILObjectReprData - | FSharpOrArrayOrByrefOrTupleOrExnTypeMetadata - | ProvidedTypeMetadata of TypedTree.TProvidedTypeInfo - val metadataOfTycon : TypedTree.Tycon -> TypeDefMetadata - val metadataOfTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypeDefMetadata - val isILReferenceTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isILInterfaceTycon : tycon:TypedTree.Tycon -> bool - val rankOfArrayTy : TcGlobals.TcGlobals -> TypedTree.TType -> int - val isFSharpObjModelRefTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isFSharpClassTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isFSharpStructTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isFSharpInterfaceTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isDelegateTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isInterfaceTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isClassTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isStructOrEnumTyconTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isStructRecordOrUnionTyconTy : - TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isStructTyconRef : tcref:TypedTree.TyconRef -> bool - val isStructTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isRefTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isForallFunctionTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isUnmanagedTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isInterfaceTycon : x:TypedTree.Tycon -> bool - val isInterfaceTyconRef : TypedTree.TyconRef -> bool - val isEnumTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val actualReturnTyOfSlotSig : - TypedTree.TType list -> - TypedTree.TType list -> TypedTree.SlotSig -> TypedTree.TType option - val slotSigHasVoidReturnTy : TypedTree.SlotSig -> bool - val returnTyOfMethod : - TcGlobals.TcGlobals -> TypedTree.ObjExprMethod -> TypedTree.TType option - val isAbstractTycon : TypedTree.Tycon -> bool - val MemberIsExplicitImpl : - TcGlobals.TcGlobals -> TypedTree.ValMemberInfo -> bool - val ValIsExplicitImpl : TcGlobals.TcGlobals -> TypedTree.Val -> bool - val ValRefIsExplicitImpl : TcGlobals.TcGlobals -> TypedTree.ValRef -> bool - val emptyFreeLocals : AbstractIL.Internal.Zset - val unionFreeLocals : - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset - val emptyFreeRecdFields : AbstractIL.Internal.Zset - val unionFreeRecdFields : - s1:AbstractIL.Internal.Zset -> - s2:AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset - val emptyFreeUnionCases : AbstractIL.Internal.Zset - val unionFreeUnionCases : - s1:AbstractIL.Internal.Zset -> - s2:AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset - val emptyFreeTycons : AbstractIL.Internal.Zset - val unionFreeTycons : - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset - val typarOrder : System.Collections.Generic.IComparer - val emptyFreeTypars : AbstractIL.Internal.Zset - val unionFreeTypars : - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset - val emptyFreeTyvars : TypedTree.FreeTyvars - val isEmptyFreeTyvars : TypedTree.FreeTyvars -> bool - val unionFreeTyvars : - TypedTree.FreeTyvars -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars - type FreeVarOptions = - { canCache: bool - collectInTypes: bool - includeLocalTycons: bool - includeTypars: bool - includeLocalTyconReprs: bool - includeRecdFields: bool - includeUnionCases: bool - includeLocals: bool } - val CollectAllNoCaching : FreeVarOptions - val CollectTyparsNoCaching : FreeVarOptions - val CollectLocalsNoCaching : FreeVarOptions - val CollectTyparsAndLocalsNoCaching : FreeVarOptions - val CollectAll : FreeVarOptions - val CollectTyparsAndLocals : FreeVarOptions - val CollectTypars : FreeVarOptions - val CollectLocals : FreeVarOptions - val accFreeLocalTycon : - opts:FreeVarOptions -> - x:TypedTree.Tycon -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeTycon : - opts:FreeVarOptions -> - tcref:TypedTree.TyconRef -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val boundTypars : - opts:FreeVarOptions -> - tps:TypedTree.Typar list -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTyparConstraints : - opts:FreeVarOptions -> - cxs:TypedTree.TyparConstraint list -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTyparConstraint : - opts:FreeVarOptions -> - tpc:TypedTree.TyparConstraint -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTrait : - opts:FreeVarOptions -> - TypedTree.TraitConstraintInfo -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInWitnessArg : - opts:FreeVarOptions -> - TypedTree.TraitWitnessInfo -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTraitSln : - opts:FreeVarOptions -> - sln:TypedTree.TraitConstraintSln -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeLocalValInTraitSln : - _opts:'a -> - v:TypedTree.Val -> fvs:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeValRefInTraitSln : - opts:FreeVarOptions -> - vref:TypedTree.ValRef -> - fvs:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeTyparRef : - opts:FreeVarOptions -> - tp:TypedTree.Typar -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInType : - FreeVarOptions -> - TypedTree.TType -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTupInfo : - _opts:FreeVarOptions -> - unt:TypedTree.TupInfo -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInMeasure : - opts:FreeVarOptions -> - unt:TypedTree.Measure -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val accFreeInTypes : - FreeVarOptions -> - TypedTree.TTypes -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val freeInType : FreeVarOptions -> TypedTree.TType -> TypedTree.FreeTyvars - val accFreeInVal : - opts:FreeVarOptions -> - v:TypedTree.Val -> acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val freeInTypes : FreeVarOptions -> TypedTree.TTypes -> TypedTree.FreeTyvars - val freeInVal : FreeVarOptions -> TypedTree.Val -> TypedTree.FreeTyvars - val freeInTyparConstraints : - opts:FreeVarOptions -> - v:TypedTree.TyparConstraint list -> TypedTree.FreeTyvars - val accFreeInTypars : - FreeVarOptions -> - TypedTree.Typar list -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val addFreeInModuleTy : - mtyp:TypedTree.ModuleOrNamespaceType -> - acc:TypedTree.FreeTyvars -> TypedTree.FreeTyvars - val freeInModuleTy : TypedTree.ModuleOrNamespaceType -> TypedTree.FreeTyvars - val emptyFreeTyparsLeftToRight : 'a list - val unionFreeTyparsLeftToRight : - fvs1:TypedTree.Typar list -> - fvs2:TypedTree.Typar list -> TypedTree.Typar list - val boundTyparsLeftToRight : - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - tps:TypedTree.Typar list -> TypedTree.Typar list - val accFreeInTyparConstraintsLeftToRight : - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - cxs:TypedTree.TyparConstraint list -> TypedTree.Typar list - val accFreeInTyparConstraintLeftToRight : - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - tpc:TypedTree.TyparConstraint -> TypedTree.Typar list - val accFreeInTraitLeftToRight : - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - TypedTree.TraitConstraintInfo -> TypedTree.Typar list - val accFreeTyparRefLeftToRight : - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - tp:TypedTree.Typar -> TypedTree.Typar list - val accFreeInTypeLeftToRight : - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - ty:TypedTree.TType -> TypedTree.Typar list - val accFreeInTupInfoLeftToRight : - _g:TcGlobals.TcGlobals -> - _cxFlag:bool -> - _thruFlag:bool -> - acc:TypedTree.Typar list -> - unt:TypedTree.TupInfo -> TypedTree.Typar list - val accFreeInTypesLeftToRight : - g:TcGlobals.TcGlobals -> - cxFlag:bool -> - thruFlag:bool -> - acc:TypedTree.Typar list -> - tys:TypedTree.TTypes -> TypedTree.Typar list - val freeInTypeLeftToRight : - TcGlobals.TcGlobals -> bool -> TypedTree.TType -> TypedTree.Typar list - val freeInTypesLeftToRight : - TcGlobals.TcGlobals -> bool -> TypedTree.TTypes -> TypedTree.Typar list - val freeInTypesLeftToRightSkippingConstraints : - TcGlobals.TcGlobals -> TypedTree.TTypes -> TypedTree.Typar list - val valOfBind : b:TypedTree.Binding -> TypedTree.Val - val valsOfBinds : TypedTree.Bindings -> TypedTree.Val list - val GetMemberTypeInFSharpForm : - g:TcGlobals.TcGlobals -> - memberFlags:SyntaxTree.MemberFlags -> - arities:TypedTree.ValReprInfo -> - ty:TypedTree.TType -> - m:Range.range -> - TypedTree.Typar list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType * TypedTree.ArgReprInfo - val checkMemberVal : - membInfo:'a option -> arity:'b option -> m:Range.range -> 'a * 'b - val checkMemberValRef : - vref:TypedTree.ValRef -> TypedTree.ValMemberInfo * TypedTree.ValReprInfo - val GetTraitConstraintInfosOfTypars : - TcGlobals.TcGlobals -> - TypedTree.Typars -> TypedTree.TraitConstraintInfo list - val GetTraitWitnessInfosOfTypars : - TcGlobals.TcGlobals -> - numParentTypars:int -> - typars:TypedTree.Typar list -> TypedTree.TraitWitnessInfo list - val CountEnclosingTyparsOfActualParentOfVal : TypedTree.Val -> int - val GetTopValTypeInCompiledForm : - TcGlobals.TcGlobals -> - TypedTree.ValReprInfo -> - int -> - TypedTree.TType -> - Range.range -> - TypedTree.Typar list * TypedTree.TraitWitnessInfo list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType option * TypedTree.ArgReprInfo - val GetMemberTypeInMemberForm : - TcGlobals.TcGlobals -> - SyntaxTree.MemberFlags -> - TypedTree.ValReprInfo -> - int -> - TypedTree.TType -> - Range.range -> - TypedTree.Typar list * TypedTree.TraitWitnessInfo list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType option * TypedTree.ArgReprInfo - val GetTypeOfMemberInMemberForm : - TcGlobals.TcGlobals -> - TypedTree.ValRef -> - TypedTree.Typar list * TypedTree.TraitWitnessInfo list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType option * TypedTree.ArgReprInfo - val GetTypeOfMemberInFSharpForm : - TcGlobals.TcGlobals -> - TypedTree.ValRef -> - TypedTree.Typar list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * TypedTree.TType * - TypedTree.ArgReprInfo - val PartitionValTyparsForApparentEnclosingType : - TcGlobals.TcGlobals -> - TypedTree.Val -> - (TypedTree.Typars * TypedTree.Typar list * TypedTree.Typar list * - TyparInst * TypedTree.TType list) option - val PartitionValTypars : - TcGlobals.TcGlobals -> - TypedTree.Val -> - (TypedTree.Typar list * TypedTree.Typar list * TypedTree.Typar list * - TyparInst * TypedTree.TType list) option - val PartitionValRefTypars : - TcGlobals.TcGlobals -> - TypedTree.ValRef -> - (TypedTree.Typar list * TypedTree.Typar list * TypedTree.Typar list * - TyparInst * TypedTree.TType list) option - val ArgInfosOfMemberVal : - g:TcGlobals.TcGlobals -> - v:TypedTree.Val -> (TypedTree.TType * TypedTree.ArgReprInfo) list list - val ArgInfosOfMember : - TcGlobals.TcGlobals -> - TypedTree.ValRef -> (TypedTree.TType * TypedTree.ArgReprInfo) list list - val GetFSharpViewOfReturnType : - TcGlobals.TcGlobals -> TypedTree.TType option -> TypedTree.TType - val ReturnTypeOfPropertyVal : - TcGlobals.TcGlobals -> TypedTree.Val -> TypedTree.TType - val ArgInfosOfPropertyVal : - TcGlobals.TcGlobals -> - TypedTree.Val -> (TypedTree.TType * TypedTree.ArgReprInfo) list - val generalTyconRefInst : tc:TypedTree.TyconRef -> TypedTree.TType list - val generalizeTyconRef : - TypedTree.TyconRef -> TypedTree.TType list * TypedTree.TType - val generalizedTyconRef : TypedTree.TyconRef -> TypedTree.TType - val isTTyparSupportsStaticMethod : _arg1:TypedTree.TyparConstraint -> bool - val isTTyparCoercesToType : _arg1:TypedTree.TyparConstraint -> bool - val prefixOfStaticReq : SyntaxTree.TyparStaticReq -> string - val prefixOfRigidTypar : TypedTree.Typar -> string - type TyparConstraintsWithTypars = - (TypedTree.Typar * TypedTree.TyparConstraint) list - module PrettyTypes = begin - val newPrettyTypar : tp:TypedTree.Typar -> nm:string -> TypedTree.Typar - val NewPrettyTypars : - (TypedTree.Typar * TypedTree.TType) list -> - TypedTree.Typar list -> - string list -> - TypedTree.Typar list * (TypedTree.Typar * TypedTree.TType) list - val NeedsPrettyTyparName : TypedTree.Typar -> bool - val PrettyTyparNames : - (TypedTree.Typar -> bool) -> - string list -> TypedTree.Typar list -> string list - val PrettifyThings : - g:TcGlobals.TcGlobals -> - foldTys:((TypedTree.Typar list -> TypedTree.TType -> - TypedTree.Typar list) -> 'a list -> 'b -> - TypedTree.Typar list) -> - mapTys:((TypedTree.TType -> TypedTree.TType) -> 'b -> 'b) -> - things:'b -> - 'b * (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyType : - TcGlobals.TcGlobals -> - TypedTree.TType -> - TypedTree.TType * (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyTypePair : - TcGlobals.TcGlobals -> - TypedTree.TType * TypedTree.TType -> - (TypedTree.TType * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyTypes : - TcGlobals.TcGlobals -> - TypedTree.TType list -> - TypedTree.TType list * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyDiscriminantAndTypePairs : - TcGlobals.TcGlobals -> - ('Discriminant * TypedTree.TType) list -> - ('Discriminant * TypedTree.TType) list * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyCurriedTypes : - TcGlobals.TcGlobals -> - TypedTree.TType list list -> - TypedTree.TType list list * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyCurriedSigTypes : - TcGlobals.TcGlobals -> - TypedTree.TType list list * TypedTree.TType -> - (TypedTree.TType list list * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val safeDestAnyParTy : - orig:TypedTree.Typar -> - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.Typar - val tee : f:('a -> 'a -> 'b) -> x:'a -> 'b - val foldUnurriedArgInfos : - f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:UncurriedArgInfos -> 'a - val mapUnurriedArgInfos : - f:(TypedTree.TType -> 'a) -> - x:UncurriedArgInfos -> ('a * TypedTree.ArgReprInfo) list - val foldTypar : - f:('a -> TypedTree.TType -> 'b) -> z:'a -> x:TypedTree.Typar -> 'b - val mapTypar : - g:TcGlobals.TcGlobals -> - f:(TypedTree.TType -> TypedTree.TType) -> - x:TypedTree.Typar -> TypedTree.Typar - val foldTypars : - f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:TypedTree.Typars -> 'a - val mapTypars : - g:TcGlobals.TcGlobals -> - f:(TypedTree.TType -> TypedTree.TType) -> - x:TypedTree.Typars -> TypedTree.Typars - val foldTyparInst : - f:('a -> TypedTree.TType -> 'a) -> z:'a -> x:TyparInst -> 'a - val mapTyparInst : - g:TcGlobals.TcGlobals -> - f:(TypedTree.TType -> TypedTree.TType) -> x:TyparInst -> TyparInst - val PrettifyInstAndTyparsAndType : - TcGlobals.TcGlobals -> - TyparInst * TypedTree.Typars * TypedTree.TType -> - (TyparInst * TypedTree.Typars * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInstAndUncurriedSig : - TcGlobals.TcGlobals -> - TyparInst * UncurriedArgInfos * TypedTree.TType -> - (TyparInst * UncurriedArgInfos * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInstAndCurriedSig : - TcGlobals.TcGlobals -> - TyparInst * TypedTree.TTypes * CurriedArgInfos * TypedTree.TType -> - (TyparInst * TypedTree.TType list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInstAndSig : - TcGlobals.TcGlobals -> - TyparInst * TypedTree.TType list * TypedTree.TType -> - (TyparInst * TypedTree.TType list * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInstAndTypes : - TcGlobals.TcGlobals -> - TyparInst * TypedTree.TType list -> - (TyparInst * TypedTree.TType list) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInstAndType : - TcGlobals.TcGlobals -> - TyparInst * TypedTree.TType -> - (TyparInst * TypedTree.TType) * - (TypedTree.Typar * TypedTree.TyparConstraint) list - val PrettifyInst : - TcGlobals.TcGlobals -> - TyparInst -> - TyparInst * (TypedTree.Typar * TypedTree.TyparConstraint) list - end - module SimplifyTypes = begin - val foldTypeButNotConstraints : - f:('a -> TypedTree.TType -> 'a) -> z:'a -> ty:TypedTree.TType -> 'a - val incM : - x:'a -> - m:AbstractIL.Internal.Zmap<'a,int> -> AbstractIL.Internal.Zmap<'a,int> - val accTyparCounts : - z:AbstractIL.Internal.Zmap -> - ty:TypedTree.TType -> AbstractIL.Internal.Zmap - val emptyTyparCounts : AbstractIL.Internal.Zmap - val accTyparCountsMulti : - acc:AbstractIL.Internal.Zmap -> - l:TypedTree.TType list -> - AbstractIL.Internal.Zmap - type TypeSimplificationInfo = - { singletons: AbstractIL.Internal.Zset - inplaceConstraints: - AbstractIL.Internal.Zmap - postfixConstraints: (TypedTree.Typar * TypedTree.TyparConstraint) list } - val typeSimplificationInfo0 : TypeSimplificationInfo - val categorizeConstraints : - simplify:bool -> - m:AbstractIL.Internal.Zmap -> - cxs:(TypedTree.Typar * TypedTree.TyparConstraint) list -> - TypeSimplificationInfo - val CollectInfo : - bool -> - TypedTree.TType list -> - (TypedTree.Typar * TypedTree.TyparConstraint) list -> - TypeSimplificationInfo - end - [] - type DisplayEnv = - { includeStaticParametersInTypeNames: bool - openTopPathsSorted: Lazy - openTopPathsRaw: string list list - shortTypeNames: bool - suppressNestedTypes: bool - maxMembers: int option - showObsoleteMembers: bool - showHiddenMembers: bool - showTyparBinding: bool - showImperativeTyparAnnotations: bool - suppressInlineKeyword: bool - suppressMutableKeyword: bool - showMemberContainers: bool - shortConstraints: bool - useColonForReturnType: bool - showAttributes: bool - showOverrides: bool - showConstraintTyparAnnotations: bool - abbreviateAdditionalConstraints: bool - showTyparDefaultConstraints: bool - shrinkOverloads: bool - printVerboseSignatures: bool - g: TcGlobals.TcGlobals - contextAccessibility: TypedTree.Accessibility - generatedValueLayout: TypedTree.Val -> Layout.layout option } - with - static member Empty : TcGlobals.TcGlobals -> DisplayEnv - member AddAccessibility : TypedTree.Accessibility -> DisplayEnv - member - AddOpenModuleOrNamespace : TypedTree.ModuleOrNamespaceRef -> - DisplayEnv - member AddOpenPath : string list -> DisplayEnv - member SetOpenPaths : string list list -> DisplayEnv - end - val ( +.+ ) : s1:string -> s2:string -> string - val layoutOfPath : - p:string list -> Internal.Utilities.StructuredFormat.Layout - val fullNameOfParentOfPubPath : pp:TypedTree.PublicPath -> string voption - val fullNameOfParentOfPubPathAsLayout : - pp:TypedTree.PublicPath -> - Internal.Utilities.StructuredFormat.Layout voption - val fullNameOfPubPath : TypedTree.PublicPath -> string - val fullNameOfPubPathAsLayout : - TypedTree.PublicPath -> Internal.Utilities.StructuredFormat.Layout - val fullNameOfParentOfNonLocalEntityRef : - nlr:TypedTree.NonLocalEntityRef -> string voption - val fullNameOfParentOfNonLocalEntityRefAsLayout : - nlr:TypedTree.NonLocalEntityRef -> - Internal.Utilities.StructuredFormat.Layout voption - val fullNameOfParentOfEntityRef : eref:TypedTree.EntityRef -> string voption - val fullNameOfParentOfEntityRefAsLayout : - eref:TypedTree.EntityRef -> - Internal.Utilities.StructuredFormat.Layout voption - val fullNameOfEntityRef : - nmF:(TypedTree.EntityRef -> string) -> xref:TypedTree.EntityRef -> string - val tagEntityRefName : - xref:TypedTree.EntityRef -> name:string -> Layout.TaggedText - val fullDisplayTextOfTyconRef : TypedTree.TyconRef -> string - val fullNameOfEntityRefAsLayout : - nmF:(TypedTree.EntityRef -> string) -> - xref:TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout - val fullNameOfParentOfValRef : vref:TypedTree.ValRef -> string voption - val fullNameOfParentOfValRefAsLayout : - vref:TypedTree.ValRef -> - Internal.Utilities.StructuredFormat.Layout voption - val fullDisplayTextOfParentOfModRef : TypedTree.EntityRef -> string voption - val fullDisplayTextOfModRef : TypedTree.EntityRef -> string - val fullDisplayTextOfTyconRefAsLayout : - TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout - val fullDisplayTextOfExnRef : TypedTree.EntityRef -> string - val fullDisplayTextOfExnRefAsLayout : - TypedTree.EntityRef -> Internal.Utilities.StructuredFormat.Layout - val fullDisplayTextOfUnionCaseRef : TypedTree.UnionCaseRef -> string - val fullDisplayTextOfRecdFieldRef : TypedTree.RecdFieldRef -> string - val fullDisplayTextOfValRef : TypedTree.ValRef -> string - val fullDisplayTextOfValRefAsLayout : - TypedTree.ValRef -> Internal.Utilities.StructuredFormat.Layout - val fullMangledPathToTyconRef : tcref:TypedTree.TyconRef -> string [] - val tyconRefToFullName : tc:TypedTree.TyconRef -> string - val qualifiedInterfaceImplementationNameAux : - g:TcGlobals.TcGlobals -> x:TypedTree.TType -> string - val qualifiedInterfaceImplementationName : - TcGlobals.TcGlobals -> TypedTree.TType -> string -> string - val qualifiedMangledNameOfTyconRef : TypedTree.TyconRef -> string -> string - val firstEq : p1:'a list -> p2:'a list -> bool when 'a : equality - val firstRem : p1:'a list -> p2:'b list -> 'b list - val trimPathByDisplayEnv : DisplayEnv -> string list -> string - val superOfTycon : TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.TType - val isILAttribByName : - tencl:string list * tname:string -> attr:AbstractIL.IL.ILAttribute -> bool - val isILAttrib : - tref:AbstractIL.IL.ILTypeRef -> attr:AbstractIL.IL.ILAttribute -> bool - val HasILAttribute : - tref:AbstractIL.IL.ILTypeRef -> attrs:AbstractIL.IL.ILAttributes -> bool - val TryDecodeILAttribute : - TcGlobals.TcGlobals -> - AbstractIL.IL.ILTypeRef -> - AbstractIL.IL.ILAttributes -> - (AbstractIL.IL.ILAttribElem list * - AbstractIL.IL.ILAttributeNamedArg list) option - val IsMatchingFSharpAttribute : - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib -> bool - val HasFSharpAttribute : - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool - val findAttrib : - g:TcGlobals.TcGlobals -> - tref:TcGlobals.BuiltinAttribInfo -> - attrs:TypedTree.Attrib list -> TypedTree.Attrib - val TryFindFSharpAttribute : - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> - TypedTree.Attrib list -> TypedTree.Attrib option - val TryFindFSharpAttributeOpt : - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo option -> - TypedTree.Attrib list -> TypedTree.Attrib option - val HasFSharpAttributeOpt : - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo option -> TypedTree.Attrib list -> bool - val IsMatchingFSharpAttributeOpt : - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo option -> TypedTree.Attrib -> bool - val ( |ExtractAttribNamedArg|_| ) : - string -> TypedTree.AttribNamedArg list -> TypedTree.AttribExpr option - val ( |AttribInt32Arg|_| ) : TypedTree.AttribExpr -> int32 option - val ( |AttribInt16Arg|_| ) : TypedTree.AttribExpr -> int16 option - val ( |AttribBoolArg|_| ) : TypedTree.AttribExpr -> bool option - val ( |AttribStringArg|_| ) : TypedTree.AttribExpr -> string option - val TryFindFSharpBoolAttributeWithDefault : - dflt:bool -> - g:TcGlobals.TcGlobals -> - nm:TcGlobals.BuiltinAttribInfo -> - attrs:TypedTree.Attrib list -> bool option - val TryFindFSharpBoolAttribute : - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool option - val TryFindFSharpBoolAttributeAssumeFalse : - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> bool option - val TryFindFSharpInt32Attribute : - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> int32 option - val TryFindFSharpStringAttribute : - TcGlobals.TcGlobals -> - TcGlobals.BuiltinAttribInfo -> TypedTree.Attrib list -> string option - val TryFindILAttribute : - TcGlobals.BuiltinAttribInfo -> AbstractIL.IL.ILAttributes -> bool - val TryFindILAttributeOpt : - TcGlobals.BuiltinAttribInfo option -> AbstractIL.IL.ILAttributes -> bool - val TryBindTyconRefAttribute : - g:TcGlobals.TcGlobals -> - m:Range.range -> - TcGlobals.BuiltinAttribInfo -> - tcref:TypedTree.TyconRef -> - f1:(AbstractIL.IL.ILAttribElem list * - AbstractIL.IL.ILAttributeNamedArg list -> 'a option) -> - f2:(TypedTree.Attrib -> 'a option) -> - f3:(obj option list * (string * obj option) list -> 'a option) -> - 'a option - val TryFindTyconRefBoolAttribute : - TcGlobals.TcGlobals -> - Range.range -> - TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> bool option - val TryFindAttributeUsageAttribute : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool option - val TryFindTyconRefStringAttribute : - TcGlobals.TcGlobals -> - Range.range -> - TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> string option - val TyconRefHasAttribute : - TcGlobals.TcGlobals -> - Range.range -> TcGlobals.BuiltinAttribInfo -> TypedTree.TyconRef -> bool - val isByrefTyconRef : TcGlobals.TcGlobals -> TypedTree.TyconRef -> bool - val isByrefLikeTyconRef : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool - val isSpanLikeTyconRef : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool - val isByrefLikeTy : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val isSpanLikeTy : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val isSpanTyconRef : - g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool - val isSpanTy : TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val tryDestSpanTy : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - struct (TypedTree.TyconRef * TypedTree.TType) voption - val destSpanTy : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> struct (TypedTree.TyconRef * TypedTree.TType) - val isReadOnlySpanTyconRef : - g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool - val isReadOnlySpanTy : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val tryDestReadOnlySpanTy : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - struct (TypedTree.TyconRef * TypedTree.TType) voption - val destReadOnlySpanTy : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> struct (TypedTree.TyconRef * TypedTree.TType) - val destByrefTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val ( |ByrefTy|_| ) : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option - val destNativePtrTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val isRefCellTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val destRefCellTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val StripSelfRefCell : - TcGlobals.TcGlobals * TypedTree.ValBaseOrThisInfo * TypedTree.TType -> - TypedTree.TType - val mkRefCellTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkLazyTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkPrintfFormatTy : - TcGlobals.TcGlobals -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.TType -> TypedTree.TType -> TypedTree.TType - val mkOptionTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkNullableTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkListTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val isOptionTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val tryDestOptionTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType voption - val destOptionTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val isNullableTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val tryDestNullableTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType voption - val destNullableTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val ( |NullableTy|_| ) : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option - val ( |StripNullableTy| ) : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val isLinqExpressionTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val tryDestLinqExpressionTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType option - val destLinqExpressionTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkNoneCase : TcGlobals.TcGlobals -> TypedTree.UnionCaseRef - val mkSomeCase : TcGlobals.TcGlobals -> TypedTree.UnionCaseRef - val mkSome : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr - val mkNone : - TcGlobals.TcGlobals -> TypedTree.TType -> Range.range -> TypedTree.Expr - val mkOptionGetValueUnprovenViaAddr : - TcGlobals.TcGlobals -> - TypedTree.Expr -> TypedTree.TType -> Range.range -> TypedTree.Expr - type ValRef with - member IsDispatchSlot : bool - val ( |UnopExpr|_| ) : - _g:'a -> expr:TypedTree.Expr -> (TypedTree.ValRef * TypedTree.Expr) option - val ( |BinopExpr|_| ) : - _g:'a -> - expr:TypedTree.Expr -> - (TypedTree.ValRef * TypedTree.Expr * TypedTree.Expr) option - val ( |SpecificUnopExpr|_| ) : - g:TcGlobals.TcGlobals -> - vrefReqd:TypedTree.ValRef -> - expr:TypedTree.Expr -> TypedTree.Expr option - val ( |SpecificBinopExpr|_| ) : - g:TcGlobals.TcGlobals -> - vrefReqd:TypedTree.ValRef -> - expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option - val ( |EnumExpr|_| ) : - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr option - val ( |BitwiseOrExpr|_| ) : - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option - val ( |AttribBitwiseOrExpr|_| ) : - TcGlobals.TcGlobals -> - TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option - val isUncheckedDefaultOfValRef : - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val isTypeOfValRef : g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val isSizeOfValRef : g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val isNameOfValRef : TcGlobals.TcGlobals -> TypedTree.ValRef -> bool - val isTypeDefOfValRef : - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val ( |UncheckedDefaultOfExpr|_| ) : - g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> TypedTree.TType option - val ( |TypeOfExpr|_| ) : - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option - val ( |SizeOfExpr|_| ) : - g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> TypedTree.TType option - val ( |TypeDefOfExpr|_| ) : - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option - val ( |NameOfExpr|_| ) : - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType option - val ( |SeqExpr|_| ) : TcGlobals.TcGlobals -> TypedTree.Expr -> unit option - module DebugPrint = begin - val layoutRanges : bool ref - val squareAngleL : - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val angleL : - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val braceL : - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val braceBarL : - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val boolL : _arg1:bool -> Internal.Utilities.StructuredFormat.Layout - val intL : int -> Internal.Utilities.StructuredFormat.Layout - val int64L : n:int64 -> Internal.Utilities.StructuredFormat.Layout - val jlistL : - xL:('a -> Internal.Utilities.StructuredFormat.Layout) -> - xmap:Internal.Utilities.QueueList<'a> -> - Internal.Utilities.StructuredFormat.Layout - val bracketIfL : - x:bool -> - lyt:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val lvalopL : - x:TypedTree.LValueOperation -> - Internal.Utilities.StructuredFormat.Layout - val angleBracketL : - l:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val angleBracketListL : - l:Internal.Utilities.StructuredFormat.Layout list -> - Internal.Utilities.StructuredFormat.Layout - val layoutMemberFlags : - memFlags:SyntaxTree.MemberFlags -> - Internal.Utilities.StructuredFormat.Layout - val stampL : _n:'a -> w:'b -> 'b - val layoutTyconRef : - tc:TypedTree.TyconRef -> Internal.Utilities.StructuredFormat.Layout - val auxTypeL : - env:SimplifyTypes.TypeSimplificationInfo -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val auxTypeAtomL : - env:SimplifyTypes.TypeSimplificationInfo -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val auxTyparsL : - env:SimplifyTypes.TypeSimplificationInfo -> - tcL:Internal.Utilities.StructuredFormat.Layout -> - prefix:bool -> - tinst:TypedTree.TType list -> - Internal.Utilities.StructuredFormat.Layout - val auxTypeWrapL : - env:SimplifyTypes.TypeSimplificationInfo -> - isAtomic:bool -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val auxTyparWrapL : - env:SimplifyTypes.TypeSimplificationInfo -> - isAtomic:bool -> - typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val auxTypar2L : - env:SimplifyTypes.TypeSimplificationInfo -> - typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val auxTyparAtomL : - env:SimplifyTypes.TypeSimplificationInfo -> - typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val auxTyparConstraintTypL : - env:SimplifyTypes.TypeSimplificationInfo -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val auxTraitL : - env:SimplifyTypes.TypeSimplificationInfo -> - ttrait:TypedTree.TraitConstraintInfo -> - Internal.Utilities.StructuredFormat.Layout - val auxTyparConstraintL : - env:SimplifyTypes.TypeSimplificationInfo -> - tp:TypedTree.Typar * tpc:TypedTree.TyparConstraint -> - Internal.Utilities.StructuredFormat.Layout - val auxTyparConstraintsL : - env:SimplifyTypes.TypeSimplificationInfo -> - x:(TypedTree.Typar * TypedTree.TyparConstraint) list -> - Internal.Utilities.StructuredFormat.Layout - val typarL : TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val typarAtomL : - tp:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val typeAtomL : - tau:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val typeL : TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val typarDeclL : - TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val layoutTyparDecls : - tps:TypedTree.Typars -> Internal.Utilities.StructuredFormat.Layout - val rangeL : m:Range.range -> Internal.Utilities.StructuredFormat.Layout - val instL : - tyL:('a -> Internal.Utilities.StructuredFormat.Layout) -> - tys:'a list -> Internal.Utilities.StructuredFormat.Layout - val valRefL : - TypedTree.ValRef -> Internal.Utilities.StructuredFormat.Layout - val layoutAttrib : - TypedTree.Attrib -> Internal.Utilities.StructuredFormat.Layout - val layoutAttribs : - attribs:TypedTree.Attrib list -> - Internal.Utilities.StructuredFormat.Layout - val arityInfoL : - TypedTree.ValReprInfo -> Internal.Utilities.StructuredFormat.Layout - val valL : TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val typeOfValL : - TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val tslotparamL : - TypedTree.SlotParam -> Internal.Utilities.StructuredFormat.Layout - val slotSigL : - TypedTree.SlotSig -> Internal.Utilities.StructuredFormat.Layout - val memberL : - g:TcGlobals.TcGlobals -> - v:TypedTree.Val -> - membInfo:TypedTree.ValMemberInfo -> - Internal.Utilities.StructuredFormat.Layout - val valAtBindL : - TcGlobals.TcGlobals -> - TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val unionCaseRefL : - TypedTree.UnionCaseRef -> Internal.Utilities.StructuredFormat.Layout - val recdFieldRefL : - TypedTree.RecdFieldRef -> Internal.Utilities.StructuredFormat.Layout - val identL : - id:SyntaxTree.Ident -> Internal.Utilities.StructuredFormat.Layout - val constL : - c:TypedTree.Const -> Internal.Utilities.StructuredFormat.Layout - val tyconL : - TcGlobals.TcGlobals -> - TypedTree.Tycon -> Internal.Utilities.StructuredFormat.Layout - val bindingL : - TcGlobals.TcGlobals -> - TypedTree.Binding -> Internal.Utilities.StructuredFormat.Layout - val exprL : - TcGlobals.TcGlobals -> - TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val atomL : - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val letRecL : - g:TcGlobals.TcGlobals -> - binds:TypedTree.Binding list -> - bodyL:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val letL : - g:TcGlobals.TcGlobals -> - bind:TypedTree.Binding -> - bodyL:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val exprWrapL : - g:TcGlobals.TcGlobals -> - isAtomic:bool -> - expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val implFilesL : - TcGlobals.TcGlobals -> - TypedTree.TypedImplFile list -> - Internal.Utilities.StructuredFormat.Layout - val appL : - g:TcGlobals.TcGlobals -> - flayout:Internal.Utilities.StructuredFormat.Layout -> - tys:TypedTree.TypeInst -> - args:TypedTree.Exprs -> Internal.Utilities.StructuredFormat.Layout - val implFileL : - TcGlobals.TcGlobals -> - TypedTree.TypedImplFile -> Internal.Utilities.StructuredFormat.Layout - val mexprL : - g:TcGlobals.TcGlobals -> - x:TypedTree.ModuleOrNamespaceExprWithSig -> - Internal.Utilities.StructuredFormat.Layout - val mdefsL : - g:TcGlobals.TcGlobals -> - defs:TypedTree.ModuleOrNamespaceExpr list -> - Internal.Utilities.StructuredFormat.Layout - val mdefL : - g:TcGlobals.TcGlobals -> - x:TypedTree.ModuleOrNamespaceExpr -> - Internal.Utilities.StructuredFormat.Layout - val mbindL : - g:TcGlobals.TcGlobals -> - x:TypedTree.ModuleOrNamespaceBinding -> - Internal.Utilities.StructuredFormat.Layout - val entityTypeL : - TcGlobals.TcGlobals -> - TypedTree.ModuleOrNamespaceType -> - Internal.Utilities.StructuredFormat.Layout - val entityL : - TcGlobals.TcGlobals -> - TypedTree.ModuleOrNamespace -> - Internal.Utilities.StructuredFormat.Layout - val ccuL : - g:TcGlobals.TcGlobals -> - ccu:TypedTree.CcuThunk -> Internal.Utilities.StructuredFormat.Layout - val decisionTreeL : - TcGlobals.TcGlobals -> - TypedTree.DecisionTree -> Internal.Utilities.StructuredFormat.Layout - val dcaseL : - g:TcGlobals.TcGlobals -> - TypedTree.DecisionTreeCase -> - Internal.Utilities.StructuredFormat.Layout - val dtestL : - g:TcGlobals.TcGlobals -> - x:TypedTree.DecisionTreeTest -> - Internal.Utilities.StructuredFormat.Layout - val targetL : - g:TcGlobals.TcGlobals -> - i:int -> - TypedTree.DecisionTreeTarget -> - Internal.Utilities.StructuredFormat.Layout - val flatValsL : - vs:TypedTree.Val list -> Internal.Utilities.StructuredFormat.Layout list - val tmethodL : - g:TcGlobals.TcGlobals -> - TypedTree.ObjExprMethod -> Internal.Utilities.StructuredFormat.Layout - val iimplL : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType * tmeths:TypedTree.ObjExprMethod list -> - Internal.Utilities.StructuredFormat.Layout - val showType : TypedTree.TType -> string - val showExpr : TcGlobals.TcGlobals -> TypedTree.Expr -> string - val traitL : - TypedTree.TraitConstraintInfo -> - Internal.Utilities.StructuredFormat.Layout - val typarsL : - TypedTree.Typars -> Internal.Utilities.StructuredFormat.Layout - end - val wrapModuleOrNamespaceType : - SyntaxTree.Ident -> - TypedTree.CompilationPath -> - TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespace - val wrapModuleOrNamespaceTypeInNamespace : - SyntaxTree.Ident -> - TypedTree.CompilationPath -> - TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType * TypedTree.ModuleOrNamespace - val wrapModuleOrNamespaceExprInNamespace : - SyntaxTree.Ident -> - TypedTree.CompilationPath -> - TypedTree.ModuleOrNamespaceExpr -> TypedTree.ModuleOrNamespaceExpr - val SigTypeOfImplFile : - TypedTree.TypedImplFile -> TypedTree.ModuleOrNamespaceType - type SignatureRepackageInfo = - { RepackagedVals: (TypedTree.ValRef * TypedTree.ValRef) list - RepackagedEntities: (TypedTree.TyconRef * TypedTree.TyconRef) list } - with - member ImplToSigMapping : TypeEquivEnv - static member Empty : SignatureRepackageInfo - end - type SignatureHidingInfo = - { HiddenTycons: AbstractIL.Internal.Zset - HiddenTyconReprs: AbstractIL.Internal.Zset - HiddenVals: AbstractIL.Internal.Zset - HiddenRecdFields: AbstractIL.Internal.Zset - HiddenUnionCases: AbstractIL.Internal.Zset } - with - static member Empty : SignatureHidingInfo - end - val addValRemap : TypedTree.Val -> TypedTree.Val -> Remap -> Remap - val mkRepackageRemapping : SignatureRepackageInfo -> Remap - val accEntityRemap : - msigty:TypedTree.ModuleOrNamespaceType -> - entity:TypedTree.Entity -> - mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accSubEntityRemap : - msigty:TypedTree.ModuleOrNamespaceType -> - entity:TypedTree.Entity -> - mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val valLinkageAEquiv : - TcGlobals.TcGlobals -> - TypeEquivEnv -> TypedTree.Val -> TypedTree.Val -> bool - val accValRemap : - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - msigty:TypedTree.ModuleOrNamespaceType -> - implVal:TypedTree.Val -> - mrpi:SignatureRepackageInfo * mhi:SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val getCorrespondingSigTy : - nm:string -> - msigty:TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType - val accEntityRemapFromModuleOrNamespaceType : - mty:TypedTree.ModuleOrNamespaceType -> - msigty:TypedTree.ModuleOrNamespaceType -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accValRemapFromModuleOrNamespaceType : - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - mty:TypedTree.ModuleOrNamespaceType -> - msigty:TypedTree.ModuleOrNamespaceType -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val ComputeRemappingFromInferredSignatureToExplicitSignature : - TcGlobals.TcGlobals -> - TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType -> - SignatureRepackageInfo * SignatureHidingInfo - val abstractSlotValRefsOfTycons : - TypedTree.Tycon list -> TypedTree.ValRef list - val abstractSlotValsOfTycons : TypedTree.Tycon list -> TypedTree.Val list - val accEntityRemapFromModuleOrNamespace : - msigty:TypedTree.ModuleOrNamespaceType -> - x:TypedTree.ModuleOrNamespaceExpr -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accEntityRemapFromModuleOrNamespaceDefs : - msigty:TypedTree.ModuleOrNamespaceType -> - mdefs:TypedTree.ModuleOrNamespaceExpr list -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accEntityRemapFromModuleOrNamespaceBind : - msigty:TypedTree.ModuleOrNamespaceType -> - x:TypedTree.ModuleOrNamespaceBinding -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accValRemapFromModuleOrNamespace : - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - msigty:TypedTree.ModuleOrNamespaceType -> - x:TypedTree.ModuleOrNamespaceExpr -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accValRemapFromModuleOrNamespaceBind : - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - msigty:TypedTree.ModuleOrNamespaceType -> - x:TypedTree.ModuleOrNamespaceBinding -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val accValRemapFromModuleOrNamespaceDefs : - g:TcGlobals.TcGlobals -> - aenv:TypeEquivEnv -> - msigty:TypedTree.ModuleOrNamespaceType -> - mdefs:TypedTree.ModuleOrNamespaceExpr list -> - SignatureRepackageInfo * SignatureHidingInfo -> - SignatureRepackageInfo * SignatureHidingInfo - val ComputeRemappingFromImplementationToSignature : - TcGlobals.TcGlobals -> - TypedTree.ModuleOrNamespaceExpr -> - TypedTree.ModuleOrNamespaceType -> - SignatureRepackageInfo * SignatureHidingInfo - val accTyconHidingInfoAtAssemblyBoundary : - tycon:TypedTree.Tycon -> mhi:SignatureHidingInfo -> SignatureHidingInfo - val accValHidingInfoAtAssemblyBoundary : - vspec:TypedTree.Val -> mhi:SignatureHidingInfo -> SignatureHidingInfo - val accModuleOrNamespaceHidingInfoAtAssemblyBoundary : - mty:TypedTree.ModuleOrNamespaceType -> - acc:SignatureHidingInfo -> SignatureHidingInfo - val ComputeHidingInfoAtAssemblyBoundary : - TypedTree.ModuleOrNamespaceType -> - SignatureHidingInfo -> SignatureHidingInfo - val IsHidden : - setF:('a -> AbstractIL.Internal.Zset<'b>) -> - accessF:('b -> TypedTree.Accessibility) -> - remapF:('c -> 'b -> 'b) -> (('c * 'a) list -> 'b -> bool) - val IsHiddenTycon : - (Remap * SignatureHidingInfo) list -> TypedTree.Tycon -> bool - val IsHiddenTyconRepr : - (Remap * SignatureHidingInfo) list -> TypedTree.Tycon -> bool - val IsHiddenVal : - (Remap * SignatureHidingInfo) list -> TypedTree.Val -> bool - val IsHiddenRecdField : - (Remap * SignatureHidingInfo) list -> TypedTree.RecdFieldRef -> bool - val foldModuleOrNamespaceTy : - ft:(TypedTree.Entity -> 'a -> 'a) -> - fv:(TypedTree.Val -> 'a -> 'a) -> - mty:TypedTree.ModuleOrNamespaceType -> acc:'a -> 'a - val allValsOfModuleOrNamespaceTy : - m:TypedTree.ModuleOrNamespaceType -> TypedTree.Val list - val allEntitiesOfModuleOrNamespaceTy : - m:TypedTree.ModuleOrNamespaceType -> TypedTree.Entity list - val isPublicVal : lv:TypedTree.Val -> bool - val isPublicUnionCase : ucr:TypedTree.UnionCaseRef -> bool - val isPublicRecdField : rfr:TypedTree.RecdFieldRef -> bool - val isPublicTycon : tcref:TypedTree.Tycon -> bool - val freeVarsAllPublic : TypedTree.FreeVars -> bool - val freeTyvarsAllPublic : TypedTree.FreeTyvars -> bool - val ( |LinearMatchExpr|_| ) : - TypedTree.Expr -> - (SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * - TypedTree.DecisionTreeTarget * TypedTree.Expr * - SyntaxTree.DebugPointForTarget * Range.range * TypedTree.TType) option - val rebuildLinearMatchExpr : - (SyntaxTree.DebugPointForBinding * Range.range * TypedTree.DecisionTree * - TypedTree.DecisionTreeTarget * TypedTree.Expr * - SyntaxTree.DebugPointForTarget * Range.range * TypedTree.TType) -> - TypedTree.Expr - val ( |LinearOpExpr|_| ) : - TypedTree.Expr -> - (TypedTree.TOp * TypedTree.TypeInst * TypedTree.Expr list * - TypedTree.Expr * Range.range) option - val rebuildLinearOpExpr : - (TypedTree.TOp * TypedTree.TypeInst * TypedTree.Expr list * TypedTree.Expr * - Range.range) -> TypedTree.Expr - val emptyFreeVars : TypedTree.FreeVars - val unionFreeVars : - TypedTree.FreeVars -> TypedTree.FreeVars -> TypedTree.FreeVars - val inline accFreeTyvars : - opts:FreeVarOptions -> - f:(FreeVarOptions -> 'a -> TypedTree.FreeTyvars -> TypedTree.FreeTyvars) -> - v:'a -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeVarsInTy : - opts:FreeVarOptions -> - ty:TypedTree.TType -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeVarsInTys : - opts:FreeVarOptions -> - tys:TypedTree.TType list -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreevarsInTycon : - opts:FreeVarOptions -> - tcref:TypedTree.TyconRef -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreevarsInVal : - opts:FreeVarOptions -> - v:TypedTree.Val -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeVarsInTraitSln : - opts:FreeVarOptions -> - tys:TypedTree.TraitConstraintSln -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeVarsInTraitInfo : - opts:FreeVarOptions -> - tys:TypedTree.TraitConstraintInfo -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val boundLocalVal : - opts:FreeVarOptions -> - v:TypedTree.Val -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val boundProtect : fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accUsesFunctionLocalConstructs : - flg:bool -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val bound_rethrow : fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accUsesRethrow : - flg:bool -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val boundLocalVals : - opts:FreeVarOptions -> - vs:TypedTree.Val list -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val bindLhs : - opts:FreeVarOptions -> - bind:TypedTree.Binding -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val freeVarsCacheCompute : - opts:FreeVarOptions -> cache:Lib.cache<'a> -> f:(unit -> 'a) -> 'a - val tryGetFreeVarsCacheValue : - opts:FreeVarOptions -> cache:Lib.cache<'a> -> Lib.NonNullSlot<'a> voption - val accBindRhs : - opts:FreeVarOptions -> - TypedTree.Binding -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInSwitchCases : - FreeVarOptions -> - TypedTree.DecisionTreeCase list -> - TypedTree.DecisionTree option -> - TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInSwitchCase : - opts:FreeVarOptions -> - TypedTree.DecisionTreeCase -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInTest : - opts:FreeVarOptions -> - discrim:TypedTree.DecisionTreeTest -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInDecisionTree : - FreeVarOptions -> - TypedTree.DecisionTree -> TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInValFlags : - opts:FreeVarOptions -> - flag:TypedTree.ValUseFlag -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeLocalVal : - opts:FreeVarOptions -> - v:TypedTree.Val -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accLocalTyconRepr : - opts:FreeVarOptions -> - b:TypedTree.Tycon -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accUsedRecdOrUnionTyconRepr : - opts:FreeVarOptions -> - tc:TypedTree.Tycon -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeUnionCaseRef : - opts:FreeVarOptions -> - ucref:TypedTree.UnionCaseRef -> - fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeRecdFieldRef : - opts:FreeVarOptions -> - rfref:TypedTree.RecdFieldRef -> - fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeExnRef : _exnc:'a -> fvs:'b -> 'b - val accFreeValRef : - opts:FreeVarOptions -> - vref:TypedTree.ValRef -> fvs:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInMethod : - opts:FreeVarOptions -> - TypedTree.ObjExprMethod -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInMethods : - opts:FreeVarOptions -> - methods:TypedTree.ObjExprMethod list -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInInterfaceImpl : - opts:FreeVarOptions -> - ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInExpr : - opts:FreeVarOptions -> - x:TypedTree.Expr -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInExprLinear : - opts:FreeVarOptions -> - x:TypedTree.Expr -> - acc:TypedTree.FreeVars -> - contf:(TypedTree.FreeVars -> TypedTree.FreeVars) -> - TypedTree.FreeVars - val accFreeInExprNonLinear : - opts:FreeVarOptions -> - x:TypedTree.Expr -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInOp : - opts:FreeVarOptions -> - op:TypedTree.TOp -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInTargets : - FreeVarOptions -> - TypedTree.DecisionTreeTarget array -> - TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInTarget : - opts:FreeVarOptions -> - TypedTree.DecisionTreeTarget -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInFlatExprs : - opts:FreeVarOptions -> - exprs:TypedTree.Exprs -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInExprs : - FreeVarOptions -> - TypedTree.Exprs -> TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInSlotSig : - opts:FreeVarOptions -> - TypedTree.SlotSig -> acc:TypedTree.FreeVars -> TypedTree.FreeVars - val freeInDecisionTree : - opts:FreeVarOptions -> dtree:TypedTree.DecisionTree -> TypedTree.FreeVars - val freeInExpr : FreeVarOptions -> TypedTree.Expr -> TypedTree.FreeVars - val accFreeInModuleOrNamespace : - opts:FreeVarOptions -> - mexpr:TypedTree.ModuleOrNamespaceExpr -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInModuleOrNamespaceBind : - opts:FreeVarOptions -> - mbind:TypedTree.ModuleOrNamespaceBinding -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val accFreeInModuleOrNamespaces : - opts:FreeVarOptions -> - mexprs:TypedTree.ModuleOrNamespaceExpr list -> - acc:TypedTree.FreeVars -> TypedTree.FreeVars - val freeInBindingRhs : - FreeVarOptions -> TypedTree.Binding -> TypedTree.FreeVars - val freeInModuleOrNamespace : - FreeVarOptions -> TypedTree.ModuleOrNamespaceExpr -> TypedTree.FreeVars - val stripLambda : - expr:TypedTree.Expr * ty:TypedTree.TType -> - TypedTree.Val list list * TypedTree.Expr * TypedTree.TType - val stripLambdaN : - n:int -> - expr:TypedTree.Expr -> TypedTree.Val list list * TypedTree.Expr * int - val tryStripLambdaN : - n:int -> - expr:TypedTree.Expr -> (TypedTree.Val list list * TypedTree.Expr) option - val stripTopLambda : - TypedTree.Expr * TypedTree.TType -> - TypedTree.Typars * TypedTree.Val list list * TypedTree.Expr * - TypedTree.TType - [] - type AllowTypeDirectedDetupling = - | Yes - | No - val InferArityOfExpr : - TcGlobals.TcGlobals -> - AllowTypeDirectedDetupling -> - TypedTree.TType -> - TypedTree.Attrib list list list -> - TypedTree.Attribs -> TypedTree.Expr -> TypedTree.ValReprInfo - val InferArityOfExprBinding : - TcGlobals.TcGlobals -> - AllowTypeDirectedDetupling -> - TypedTree.Val -> TypedTree.Expr -> TypedTree.ValReprInfo - val underlyingTypeOfEnumTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val setValHasNoArity : TypedTree.Val -> TypedTree.Val - val normalizeEnumTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - type StaticOptimizationAnswer = - | Yes = 1y - | No = -1y - | Unknown = 0y - val decideStaticOptimizationConstraint : - g:TcGlobals.TcGlobals -> - c:TypedTree.StaticOptimization -> - haveWitnesses:bool -> StaticOptimizationAnswer - val DecideStaticOptimizations : - TcGlobals.TcGlobals -> - TypedTree.StaticOptimization list -> - haveWitnesses:bool -> StaticOptimizationAnswer - val mkStaticOptimizationExpr : - TcGlobals.TcGlobals -> - TypedTree.StaticOptimization list * TypedTree.Expr * TypedTree.Expr * - Range.range -> TypedTree.Expr - type ValCopyFlag = - | CloneAll - | CloneAllAndMarkExprValsAsCompilerGenerated - | OnlyCloneExprVals - val fixValCopyFlagForQuotations : _arg1:ValCopyFlag -> ValCopyFlag - val markAsCompGen : compgen:ValCopyFlag -> d:TypedTree.Val -> TypedTree.Val - val bindLocalVal : - v:TypedTree.Val -> v':TypedTree.Val -> tmenv:Remap -> Remap - val bindLocalVals : - vs:TypedTree.Val list -> vs':TypedTree.Val list -> tmenv:Remap -> Remap - val bindTycon : - tc:TypedTree.Tycon -> tc':TypedTree.Tycon -> tyenv:Remap -> Remap - val bindTycons : - tcs:Lib.NonNullSlot list -> - tcs':Lib.NonNullSlot list -> tyenv:Remap -> Remap - val remapAttribKind : - tmenv:Remap -> k:TypedTree.AttribKind -> TypedTree.AttribKind - val tmenvCopyRemapAndBindTypars : - remapAttrib:(TypedTree.Attribs -> TypedTree.Attrib list) -> - tmenv:Remap -> tps:TypedTree.Typar list -> TypedTree.Typar list * Remap - val remapAttrib : - TcGlobals.TcGlobals -> Remap -> TypedTree.Attrib -> TypedTree.Attrib - val remapAttribExpr : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> TypedTree.AttribExpr -> TypedTree.AttribExpr - val remapAttribs : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> xs:TypedTree.Attrib list -> TypedTree.Attrib list - val remapPossibleForallTy : - TcGlobals.TcGlobals -> Remap -> TypedTree.TType -> TypedTree.TType - val remapArgData : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> argInfo:TypedTree.ArgReprInfo -> TypedTree.ArgReprInfo - val remapValReprInfo : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> TypedTree.ValReprInfo -> TypedTree.ValReprInfo - val remapValData : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> d:TypedTree.ValData -> TypedTree.ValData - val remapParentRef : - tyenv:Remap -> p:TypedTree.ParentRef -> TypedTree.ParentRef - val mapImmediateValsAndTycons : - ft:(TypedTree.Entity -> TypedTree.Entity) -> - fv:(TypedTree.Val -> TypedTree.Val) -> - x:TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespaceType - val copyVal : compgen:ValCopyFlag -> v:TypedTree.Val -> TypedTree.Val - val fixupValData : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> tmenv:Remap -> v2:TypedTree.Val -> unit - val copyAndRemapAndBindVals : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> vs:TypedTree.Val list -> TypedTree.Val list * Remap - val copyAndRemapAndBindVal : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> v:TypedTree.Val -> TypedTree.Val * Remap - val remapExpr : - TcGlobals.TcGlobals -> - ValCopyFlag -> Remap -> TypedTree.Expr -> TypedTree.Expr - val remapTarget : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - TypedTree.DecisionTreeTarget -> TypedTree.DecisionTreeTarget - val remapLinearExpr : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - expr:TypedTree.Expr -> - contf:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr - val remapConstraint : - tyenv:Remap -> - c:TypedTree.StaticOptimization -> TypedTree.StaticOptimization - val remapOp : tmenv:Remap -> op:TypedTree.TOp -> TypedTree.TOp - val remapValFlags : - tmenv:Remap -> x:TypedTree.ValUseFlag -> TypedTree.ValUseFlag - val remapExprs : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> es:TypedTree.Exprs -> TypedTree.Exprs - val remapFlatExprs : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> es:TypedTree.Expr list -> TypedTree.Expr list - val remapDecisionTree : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree - val copyAndRemapAndBindBinding : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> bind:TypedTree.Binding -> TypedTree.Binding * Remap - val copyAndRemapAndBindBindings : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> binds:TypedTree.Bindings -> TypedTree.Bindings * Remap - val remapAndRenameBinds : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenvinner:Remap -> - binds:TypedTree.Bindings -> - vs':TypedTree.Val list -> TypedTree.Bindings - val remapAndRenameBind : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenvinner:Remap -> - TypedTree.Binding -> v':TypedTree.Val -> TypedTree.Binding - val remapMethod : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod - val remapInterfaceImpl : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> - TypedTree.TType * TypedTree.ObjExprMethod list - val remapRecdField : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> x:TypedTree.RecdField -> TypedTree.RecdField - val remapRecdFields : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> x:TypedTree.TyconRecdFields -> TypedTree.TyconRecdFields - val remapUnionCase : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> x:TypedTree.UnionCase -> TypedTree.UnionCase - val remapUnionCases : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> x:TypedTree.TyconUnionData -> TypedTree.TyconUnionData - val remapFsObjData : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> - x:TypedTree.TyconObjModelData -> TypedTree.TyconObjModelData - val remapTyconRepr : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> - repr:TypedTree.TyconRepresentation -> TypedTree.TyconRepresentation - val remapTyconAug : - tmenv:Remap -> - x:TypedTree.TyconAugmentation -> TypedTree.TyconAugmentation - val remapTyconExnInfo : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> inp:TypedTree.ExceptionInfo -> TypedTree.ExceptionInfo - val remapMemberInfo : - g:TcGlobals.TcGlobals -> - m:Range.range -> - topValInfo:TypedTree.ValReprInfo option -> - ty:TypedTree.TType -> - ty':TypedTree.TType -> - tmenv:Remap -> - x:TypedTree.ValMemberInfo -> TypedTree.ValMemberInfo - val copyAndRemapAndBindModTy : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - mty:TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType * Remap - val remapModTy : - g:TcGlobals.TcGlobals -> - _compgen:ValCopyFlag -> - tmenv:Remap -> - mty:TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType - val renameTycon : - g:TcGlobals.TcGlobals -> - tyenv:Remap -> x:TypedTree.Entity -> TypedTree.Entity - val renameVal : tmenv:Remap -> x:TypedTree.Val -> TypedTree.Val - val copyTycon : - compgen:ValCopyFlag -> tycon:TypedTree.Tycon -> TypedTree.Tycon - val copyAndRemapAndBindTyconsAndVals : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - tycons:TypedTree.Entity list -> - vs:TypedTree.Val list -> - TypedTree.Tycon list * TypedTree.Val list * Remap - val allTyconsOfTycon : tycon:TypedTree.Tycon -> seq - val allEntitiesOfModDef : - mdef:TypedTree.ModuleOrNamespaceExpr -> seq - val allValsOfModDef : TypedTree.ModuleOrNamespaceExpr -> seq - val remapAndBindModuleOrNamespaceExprWithSig : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig * Remap - val remapModuleOrNamespaceExprWithSig : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig - val copyAndRemapModDef : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - mdef:TypedTree.ModuleOrNamespaceExpr -> - TypedTree.ModuleOrNamespaceExpr - val remapAndRenameModDefs : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - x:TypedTree.ModuleOrNamespaceExpr list -> - TypedTree.ModuleOrNamespaceExpr list - val remapAndRenameModDef : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - mdef:TypedTree.ModuleOrNamespaceExpr -> - TypedTree.ModuleOrNamespaceExpr - val remapAndRenameModBind : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - x:TypedTree.ModuleOrNamespaceBinding -> - TypedTree.ModuleOrNamespaceBinding - val remapImplFile : - g:TcGlobals.TcGlobals -> - compgen:ValCopyFlag -> - tmenv:Remap -> - mv:TypedTree.TypedImplFile -> TypedTree.TypedImplFile * Remap - val copyModuleOrNamespaceType : - TcGlobals.TcGlobals -> - ValCopyFlag -> - TypedTree.ModuleOrNamespaceType -> TypedTree.ModuleOrNamespaceType - val copyExpr : - TcGlobals.TcGlobals -> ValCopyFlag -> TypedTree.Expr -> TypedTree.Expr - val copyImplFile : - TcGlobals.TcGlobals -> - ValCopyFlag -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val instExpr : - TcGlobals.TcGlobals -> TyparInst -> TypedTree.Expr -> TypedTree.Expr - val remarkExpr : Range.range -> TypedTree.Expr -> TypedTree.Expr - val remarkObjExprMethod : - m:Range.range -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod - val remarkInterfaceImpl : - m:Range.range -> - ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> - TypedTree.TType * TypedTree.ObjExprMethod list - val remarkExprs : m:Range.range -> es:TypedTree.Exprs -> TypedTree.Exprs - val remarkFlatExprs : - m:Range.range -> es:TypedTree.Expr list -> TypedTree.Expr list - val remarkDecisionTree : - m:Range.range -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree - val remarkBinds : - m:Range.range -> binds:TypedTree.Bindings -> TypedTree.Bindings - val remarkBind : m:Range.range -> TypedTree.Binding -> TypedTree.Binding - val isRecdOrStructFieldDefinitelyMutable : f:TypedTree.RecdField -> bool - val isUnionCaseDefinitelyMutable : uc:TypedTree.UnionCase -> bool - val isUnionCaseRefDefinitelyMutable : TypedTree.UnionCaseRef -> bool - val isRecdOrUnionOrStructTyconRefDefinitelyMutable : - TypedTree.TyconRef -> bool - val isExnDefinitelyMutable : TypedTree.TyconRef -> bool - val isUnionCaseFieldMutable : - TcGlobals.TcGlobals -> TypedTree.UnionCaseRef -> int -> bool - val isExnFieldMutable : TypedTree.TyconRef -> int -> bool - val useGenuineField : TypedTree.Tycon -> TypedTree.RecdField -> bool - val ComputeFieldName : TypedTree.Tycon -> TypedTree.RecdField -> string - val isQuotedExprTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val destQuotedExprTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkQuotedExprTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkRawQuotedExprTy : TcGlobals.TcGlobals -> TypedTree.TType - val mkAnyTupledTy : - TcGlobals.TcGlobals -> - TypedTree.TupInfo -> TypedTree.TType list -> TypedTree.TType - val mkAnyAnonRecdTy : - TcGlobals.TcGlobals -> - TypedTree.AnonRecdTypeInfo -> TypedTree.TType list -> TypedTree.TType - val mkRefTupledTy : - TcGlobals.TcGlobals -> TypedTree.TType list -> TypedTree.TType - val mkRefTupledVarsTy : - TcGlobals.TcGlobals -> TypedTree.Val list -> TypedTree.TType - val mkMethodTy : - TcGlobals.TcGlobals -> - TypedTree.TType list list -> TypedTree.TType -> TypedTree.TType - val mkArrayType : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkByteArrayTy : TcGlobals.TcGlobals -> TypedTree.TType - val GenWitnessArgTys : - TcGlobals.TcGlobals -> - TypedTree.TraitWitnessInfo -> TypedTree.TType list list - val GenWitnessTy : - TcGlobals.TcGlobals -> TypedTree.TraitWitnessInfo -> TypedTree.TType - val GenWitnessTys : - TcGlobals.TcGlobals -> TraitWitnessInfos -> TypedTree.TType list - val tyOfExpr : TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.TType - val primMkApp : - (TypedTree.Expr * TypedTree.TType) -> - TypedTree.TypeInst -> TypedTree.Exprs -> Range.range -> TypedTree.Expr - val isExpansiveUnderInstantiation : - g:TcGlobals.TcGlobals -> - fty0:TypedTree.TType -> - tyargs:'a list -> pargs:'b list -> argsl:'c list -> bool - val mkExprAppAux : - g:TcGlobals.TcGlobals -> - f:TypedTree.Expr -> - fty:TypedTree.TType -> - argsl:TypedTree.Expr list -> m:Range.range -> TypedTree.Expr - val mkAppsAux : - g:TcGlobals.TcGlobals -> - f:TypedTree.Expr -> - fty:TypedTree.TType -> - tyargsl:TypedTree.TType list list -> - argsl:TypedTree.Expr list -> m:Range.range -> TypedTree.Expr - val mkApps : - TcGlobals.TcGlobals -> - (TypedTree.Expr * TypedTree.TType) * TypedTree.TType list list * - TypedTree.Expr list * Range.range -> TypedTree.Expr - val mkTyAppExpr : - Range.range -> - TypedTree.Expr * TypedTree.TType -> - TypedTree.TType list -> TypedTree.Expr - val accTargetsOfDecisionTree : - TypedTree.DecisionTree -> int list -> int list - val mapTargetsOfDecisionTree : - f:(int -> int) -> tree:TypedTree.DecisionTree -> TypedTree.DecisionTree - val mapTargetsOfDecisionTreeCase : - f:(int -> int) -> TypedTree.DecisionTreeCase -> TypedTree.DecisionTreeCase - val eliminateDeadTargetsFromMatch : - tree:TypedTree.DecisionTree -> - targets:'a [] -> TypedTree.DecisionTree * 'a [] - val targetOfSuccessDecisionTree : tree:TypedTree.DecisionTree -> int option - val decisionTreeHasNonTrivialBindings : tree:TypedTree.DecisionTree -> bool - val foldLinearBindingTargetsOfMatch : - tree:TypedTree.DecisionTree -> - targets:TypedTree.DecisionTreeTarget [] -> - TypedTree.DecisionTree * TypedTree.DecisionTreeTarget [] - val simplifyTrivialMatch : - spBind:SyntaxTree.DebugPointForBinding -> - exprm:Range.range -> - matchm:Range.range -> - ty:TypedTree.TType -> - tree:TypedTree.DecisionTree -> - targets:TypedTree.DecisionTreeTarget [] -> TypedTree.Expr - val mkAndSimplifyMatch : - SyntaxTree.DebugPointForBinding -> - Range.range -> - Range.range -> - TypedTree.TType -> - TypedTree.DecisionTree -> - TypedTree.DecisionTreeTarget list -> TypedTree.Expr - type Mutates = - | AddressOfOp - | DefinitelyMutates - | PossiblyMutates - | NeverMutates - exception DefensiveCopyWarning of string * Range.range - val isRecdOrStructTyconRefAssumedImmutable : - TcGlobals.TcGlobals -> TypedTree.TyconRef -> bool - val isTyconRefReadOnly : - g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool - val isTyconRefAssumedReadOnly : - g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> bool - val isRecdOrStructTyconRefReadOnlyAux : - g:TcGlobals.TcGlobals -> - m:Range.range -> isInref:bool -> tcref:TypedTree.TyconRef -> bool - val isRecdOrStructTyconRefReadOnly : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TyconRef -> bool - val isRecdOrStructTyReadOnlyAux : - g:TcGlobals.TcGlobals -> - m:Range.range -> isInref:bool -> ty:TypedTree.TType -> bool - val isRecdOrStructTyReadOnly : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val CanTakeAddressOf : - g:TcGlobals.TcGlobals -> - m:Range.range -> - isInref:bool -> ty:TypedTree.TType -> mut:Mutates -> bool - val CanTakeAddressOfImmutableVal : - g:TcGlobals.TcGlobals -> - m:Range.range -> vref:TypedTree.ValRef -> mut:Mutates -> bool - val MustTakeAddressOfVal : - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val MustTakeAddressOfByrefGet : - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val CanTakeAddressOfByrefGet : - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> mut:Mutates -> bool - val MustTakeAddressOfRecdField : rfref:TypedTree.RecdField -> bool - val MustTakeAddressOfRecdFieldRef : rfref:TypedTree.RecdFieldRef -> bool - val CanTakeAddressOfRecdFieldRef : - g:TcGlobals.TcGlobals -> - m:Range.range -> - rfref:TypedTree.RecdFieldRef -> - tinst:TypedTree.TType list -> mut:Mutates -> bool - val CanTakeAddressOfUnionFieldRef : - g:TcGlobals.TcGlobals -> - m:Range.range -> - uref:TypedTree.UnionCaseRef -> - cidx:int -> tinst:TypedTree.TType list -> mut:Mutates -> bool - val mkDerefAddrExpr : - mAddrGet:Range.range -> - expr:TypedTree.Expr -> - mExpr:Range.range -> exprTy:TypedTree.TType -> TypedTree.Expr - val mkExprAddrOfExprAux : - TcGlobals.TcGlobals -> - bool -> - bool -> - Mutates -> - TypedTree.Expr -> - TypedTree.ValRef option -> - Range.range -> - (TypedTree.Val * TypedTree.Expr) option * TypedTree.Expr * - bool * bool - val mkExprAddrOfExpr : - TcGlobals.TcGlobals -> - bool -> - bool -> - Mutates -> - TypedTree.Expr -> - TypedTree.ValRef option -> - Range.range -> - (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr * bool * - bool - val mkTupleFieldGet : - TcGlobals.TcGlobals -> - TypedTree.TupInfo * TypedTree.Expr * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkAnonRecdFieldGet : - TcGlobals.TcGlobals -> - TypedTree.AnonRecdTypeInfo * TypedTree.Expr * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkRecdFieldGet : - TcGlobals.TcGlobals -> - TypedTree.Expr * TypedTree.RecdFieldRef * TypedTree.TypeInst * - Range.range -> TypedTree.Expr - val mkUnionCaseFieldGetUnproven : - TcGlobals.TcGlobals -> - TypedTree.Expr * TypedTree.UnionCaseRef * TypedTree.TypeInst * int * - Range.range -> TypedTree.Expr - val mkArray : - TypedTree.TType * TypedTree.Exprs * Range.range -> TypedTree.Expr - val IterateRecursiveFixups : - TcGlobals.TcGlobals -> - TypedTree.Val option -> - (TypedTree.Val option -> TypedTree.Expr -> - (TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr -> unit) -> - TypedTree.Expr * (TypedTree.Expr -> TypedTree.Expr) -> - TypedTree.Expr -> unit - val JoinTyparStaticReq : - SyntaxTree.TyparStaticReq -> - SyntaxTree.TyparStaticReq -> SyntaxTree.TyparStaticReq - type ExprFolder<'State> = - { exprIntercept: - ('State -> TypedTree.Expr -> 'State) -> - ('State -> TypedTree.Expr -> 'State) -> 'State -> TypedTree.Expr -> - 'State - valBindingSiteIntercept: 'State -> bool * TypedTree.Val -> 'State - nonRecBindingsIntercept: 'State -> TypedTree.Binding -> 'State - recBindingsIntercept: 'State -> TypedTree.Bindings -> 'State - dtreeIntercept: 'State -> TypedTree.DecisionTree -> 'State - targetIntercept: - ('State -> TypedTree.Expr -> 'State) -> 'State -> - TypedTree.DecisionTreeTarget -> 'State option - tmethodIntercept: - ('State -> TypedTree.Expr -> 'State) -> 'State -> - TypedTree.ObjExprMethod -> 'State option } - val ExprFolder0 : ExprFolder<'State> - type ExprFolders<'State> = - class - new : folders:ExprFolder<'State> -> ExprFolders<'State> - member FoldExpr : ('State -> TypedTree.Expr -> 'State) - member FoldImplFile : ('State -> TypedTree.TypedImplFile -> 'State) - end - val FoldExpr : ExprFolder<'State> -> ('State -> TypedTree.Expr -> 'State) - val FoldImplFile : - ExprFolder<'State> -> ('State -> TypedTree.TypedImplFile -> 'State) - val ExprStats : TypedTree.Expr -> string - val mkString : - TcGlobals.TcGlobals -> Range.range -> string -> TypedTree.Expr - val mkBool : TcGlobals.TcGlobals -> Range.range -> bool -> TypedTree.Expr - val mkByte : TcGlobals.TcGlobals -> Range.range -> byte -> TypedTree.Expr - val mkUInt16 : - TcGlobals.TcGlobals -> Range.range -> uint16 -> TypedTree.Expr - val mkTrue : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkFalse : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkUnit : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkInt32 : TcGlobals.TcGlobals -> Range.range -> int32 -> TypedTree.Expr - val mkInt : TcGlobals.TcGlobals -> Range.range -> int32 -> TypedTree.Expr - val mkZero : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkOne : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkTwo : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkMinusOne : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val destInt32 : TypedTree.Expr -> int32 option - val isIDelegateEventType : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val destIDelegateEventType : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkIEventType : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.TType -> TypedTree.TType - val mkIObservableType : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkIObserverType : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkRefCellContentsRef : TcGlobals.TcGlobals -> TypedTree.RecdFieldRef - val mkSequential : - SyntaxTree.DebugPointAtSequential -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCompGenSequential : - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkSequentials : - SyntaxTree.DebugPointAtSequential -> - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr list -> TypedTree.Expr - val mkGetArg0 : Range.range -> TypedTree.TType -> TypedTree.Expr - val mkAnyTupled : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TupInfo -> - TypedTree.Expr list -> TypedTree.TypeInst -> TypedTree.Expr - val mkRefTupled : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr list -> TypedTree.TypeInst -> TypedTree.Expr - val mkRefTupledNoTypes : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr list -> TypedTree.Expr - val mkRefTupledVars : - TcGlobals.TcGlobals -> Range.range -> TypedTree.Val list -> TypedTree.Expr - val inversePerm : sigma:int array -> int [] - val permute : sigma:int [] -> data:'T [] -> 'T [] - val existsR : a:int -> b:int -> pred:(int -> bool) -> bool - val liftAllBefore : sigma:int array -> int - val permuteExprList : - sigma:int [] -> - exprs:TypedTree.Expr list -> - ty:TypedTree.TType list -> - names:string list -> TypedTree.Binding list * TypedTree.Expr list - val mkRecordExpr : - TcGlobals.TcGlobals -> - TypedTree.RecordConstructionInfo * TypedTree.TyconRef * - TypedTree.TypeInst * TypedTree.RecdFieldRef list * TypedTree.Expr list * - Range.range -> TypedTree.Expr - val mkAnonRecd : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.AnonRecdTypeInfo -> - SyntaxTree.Ident [] -> - TypedTree.Expr list -> TypedTree.TType list -> TypedTree.Expr - val mkRefCell : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkRefCellGet : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkRefCellSet : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkNil : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCons : - TcGlobals.TcGlobals -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCompGenLocalAndInvisibleBind : - TcGlobals.TcGlobals -> - string -> - Range.range -> - TypedTree.Expr -> TypedTree.Val * TypedTree.Expr * TypedTree.Binding - val box : AbstractIL.IL.ILInstr - val isinst : AbstractIL.IL.ILInstr - val unbox : AbstractIL.IL.ILInstr - val mkUnbox : - TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr - val mkBox : - TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr - val mkIsInst : - TypedTree.TType -> TypedTree.Expr -> Range.range -> TypedTree.Expr - val mspec_Type_GetTypeFromHandle : - TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mspec_String_Length : - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mspec_String_Concat2 : - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mspec_String_Concat3 : - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mspec_String_Concat4 : - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mspec_String_Concat_Array : - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val fspec_Missing_Value : TcGlobals.TcGlobals -> AbstractIL.IL.ILFieldSpec - val mkInitializeArrayMethSpec : - TcGlobals.TcGlobals -> AbstractIL.IL.ILMethodSpec - val mkInvalidCastExnNewobj : TcGlobals.TcGlobals -> AbstractIL.IL.ILInstr - val typedExprForIntrinsic : - _g:'a -> - m:Range.range -> - TcGlobals.IntrinsicValRef -> TypedTree.Expr * TypedTree.TType - val mkCallGetGenericComparer : - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkCallGetGenericEREqualityComparer : - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkCallGetGenericPEREqualityComparer : - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkCallUnbox : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallUnboxFast : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallTypeTest : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallTypeOf : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCallTypeDefOf : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCallDispose : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeq : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallCreateInstance : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCallGetQuerySourceAsEnumerable : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallNewQuerySource : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallCreateEvent : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGenericComparisonWithComparerOuter : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGenericEqualityEROuter : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGenericEqualityWithComparerOuter : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGenericHashWithComparerOuter : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallEqualsOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallNotEqualsOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallLessThanOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallLessThanOrEqualsOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGreaterThanOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallGreaterThanOrEqualsOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallAdditionOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSubtractionOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallMultiplyOperator : - TcGlobals.TcGlobals -> - Range.range -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> - rty:TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallDivisionOperator : - TcGlobals.TcGlobals -> - Range.range -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> - rty:TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallModulusOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallDefaultOf : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCallBitwiseAndOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallBitwiseOrOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallBitwiseXorOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallShiftLeftOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallShiftRightOperator : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallUnaryNegOperator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallUnaryNotOperator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallAdditionChecked : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSubtractionChecked : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallMultiplyChecked : - TcGlobals.TcGlobals -> - Range.range -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> - rty:TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallUnaryNegChecked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToByteChecked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToSByteChecked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt16Checked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt16Checked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToIntChecked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt32Checked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt32Checked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt64Checked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt64Checked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToIntPtrChecked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUIntPtrChecked : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToByteOperator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToSByteOperator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt16Operator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt16Operator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToIntOperator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt32Operator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt32Operator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToInt64Operator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUInt64Operator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToSingleOperator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToDoubleOperator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToIntPtrOperator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToUIntPtrOperator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToCharOperator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallToEnumOperator : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallArrayLength : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallArrayGet : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray2DGet : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray3DGet : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray4DGet : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArraySet : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray2DSet : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray3DSet : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallArray4DSet : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallHash : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallBox : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallIsNull : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallIsNotNull : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallRaise : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallNewDecimal : - g:TcGlobals.TcGlobals -> - m:Range.range -> - e1:TypedTree.Expr * e2:TypedTree.Expr * e3:TypedTree.Expr * - e4:TypedTree.Expr * e5:TypedTree.Expr -> TypedTree.Expr - val mkCallNewFormat : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.TType -> - formatStringExpr:TypedTree.Expr -> TypedTree.Expr - val tryMkCallBuiltInWitness : - TcGlobals.TcGlobals -> - TypedTree.TraitConstraintInfo -> - TypedTree.Expr list -> Range.range -> TypedTree.Expr option - val tryMkCallCoreFunctionAsBuiltInWitness : - TcGlobals.TcGlobals -> - TcGlobals.IntrinsicValRef -> - TypedTree.TType list -> - TypedTree.Expr list -> Range.range -> TypedTree.Expr option - val TryEliminateDesugaredConstants : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Const -> TypedTree.Expr option - val mkSeqTy : TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkIEnumeratorTy : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TType - val mkCallSeqCollect : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqUsing : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqDelay : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqAppend : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqGenerated : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqFinally : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqOfFunctions : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqToArray : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqToList : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqMap : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqSingleton : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallSeqEmpty : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> TypedTree.Expr - val mkCall_sprintf : - g:TcGlobals.TcGlobals -> - m:Range.range -> - funcTy:TypedTree.TType -> - fmtExpr:TypedTree.Expr -> - fillExprs:TypedTree.Expr list -> TypedTree.Expr - val mkCallDeserializeQuotationFSharp20Plus : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallDeserializeQuotationFSharp40Plus : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkCallCastQuotation : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallLiftValue : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallLiftValueWithName : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> string -> TypedTree.Expr -> TypedTree.Expr - val mkCallLiftValueWithDefn : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallCheckThis : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCallFailInit : TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkCallFailStaticInit : - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr - val mkCallQuoteToLinqLambdaExpression : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkOptionToNullable : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkOptionDefaultValue : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkLazyDelayed : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkLazyForce : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkGetString : - g:TcGlobals.TcGlobals -> - m:Range.range -> - e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkGetStringChar : - (TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr -> - TypedTree.Expr) - val mkGetStringLength : - g:TcGlobals.TcGlobals -> - m:Range.range -> e:TypedTree.Expr -> TypedTree.Expr - val mkStaticCall_String_Concat2 : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkStaticCall_String_Concat3 : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkStaticCall_String_Concat4 : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkStaticCall_String_Concat_Array : - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val mkDecr : - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val mkIncr : - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val mkLdlen : - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val mkLdelem : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkILAsmCeq : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkILAsmClt : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkNull : Range.range -> TypedTree.TType -> TypedTree.Expr - val mkThrow : - Range.range -> TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val destThrow : - _arg1:TypedTree.Expr -> - (Range.range * TypedTree.TType * TypedTree.Expr) option - val isThrow : TypedTree.Expr -> bool - val mkReraiseLibCall : - TcGlobals.TcGlobals -> TypedTree.TType -> Range.range -> TypedTree.Expr - val mkReraise : Range.range -> TypedTree.TType -> TypedTree.Expr - val tnameCompilationSourceNameAttr : string - val tnameCompilationArgumentCountsAttr : string - val tnameCompilationMappingAttr : string - val tnameSourceConstructFlags : string - val tref_CompilationArgumentCountsAttr : - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef - val tref_CompilationMappingAttr : - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef - val tref_CompilationSourceNameAttr : - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef - val tref_SourceConstructFlags : - g:TcGlobals.TcGlobals -> AbstractIL.IL.ILTypeRef - val mkCompilationMappingAttrPrim : - g:TcGlobals.TcGlobals -> - k:int32 -> nums:int32 list -> AbstractIL.IL.ILAttribute - val mkCompilationMappingAttr : - TcGlobals.TcGlobals -> int32 -> AbstractIL.IL.ILAttribute - val mkCompilationMappingAttrWithSeqNum : - TcGlobals.TcGlobals -> int32 -> int32 -> AbstractIL.IL.ILAttribute - val mkCompilationMappingAttrWithVariantNumAndSeqNum : - TcGlobals.TcGlobals -> - int32 -> int32 -> int32 -> AbstractIL.IL.ILAttribute - val mkCompilationArgumentCountsAttr : - TcGlobals.TcGlobals -> int32 list -> AbstractIL.IL.ILAttribute - val mkCompilationSourceNameAttr : - TcGlobals.TcGlobals -> string -> AbstractIL.IL.ILAttribute - val mkCompilationMappingAttrForQuotationResource : - TcGlobals.TcGlobals -> - string * AbstractIL.IL.ILTypeRef list -> AbstractIL.IL.ILAttribute - val isTypeProviderAssemblyAttr : cattr:AbstractIL.IL.ILAttribute -> bool - val TryDecodeTypeProviderAssemblyAttr : - AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option - val tname_SignatureDataVersionAttr : string - val tnames_SignatureDataVersionAttr : string list * string - val tref_SignatureDataVersionAttr : unit -> AbstractIL.IL.ILTypeRef - val mkSignatureDataVersionAttr : - TcGlobals.TcGlobals -> - AbstractIL.IL.ILVersionInfo -> AbstractIL.IL.ILAttribute - val tname_AutoOpenAttr : string - val IsSignatureDataVersionAttr : AbstractIL.IL.ILAttribute -> bool - val TryFindAutoOpenAttr : - AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option - val tname_InternalsVisibleToAttr : string - val TryFindInternalsVisibleToAttr : - AbstractIL.IL.ILGlobals -> AbstractIL.IL.ILAttribute -> string option - val IsMatchingSignatureDataVersionAttr : - AbstractIL.IL.ILGlobals -> - AbstractIL.IL.ILVersionInfo -> AbstractIL.IL.ILAttribute -> bool - val mkCompilerGeneratedAttr : - TcGlobals.TcGlobals -> int32 -> AbstractIL.IL.ILAttribute - val untupledToRefTupled : - g:TcGlobals.TcGlobals -> - vs:TypedTree.Val list -> - TypedTree.Val * (TypedTree.Expr -> TypedTree.Expr) - val AdjustArityOfLambdaBody : - TcGlobals.TcGlobals -> - int -> - TypedTree.Val list -> - TypedTree.Expr -> TypedTree.Val list * TypedTree.Expr - val MultiLambdaToTupledLambda : - TcGlobals.TcGlobals -> - TypedTree.Val list -> TypedTree.Expr -> TypedTree.Val * TypedTree.Expr - val ( |RefTuple|_| ) : expr:TypedTree.Expr -> TypedTree.Exprs option - val MultiLambdaToTupledLambdaIfNeeded : - g:TcGlobals.TcGlobals -> - vs:TypedTree.Val list * arg:TypedTree.Expr -> - body:TypedTree.Expr -> - (TypedTree.Val * TypedTree.Expr) list * TypedTree.Expr - val MakeApplicationAndBetaReduceAux : - g:TcGlobals.TcGlobals -> - f:TypedTree.Expr * fty:TypedTree.TType * - tyargsl:TypedTree.TType list list * argsl:TypedTree.Expr list * - m:Range.range -> TypedTree.Expr - val MakeApplicationAndBetaReduce : - TcGlobals.TcGlobals -> - TypedTree.Expr * TypedTree.TType * TypedTree.TType list list * - TypedTree.Expr list * Range.range -> TypedTree.Expr - val MakeArgsForTopArgs : - _g:'a -> - m:Range.range -> - argtysl:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> - tpenv:(TypedTree.Typar * TypedTree.TType) list -> - TypedTree.Val list list - val AdjustValForExpectedArity : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.ValRef -> - TypedTree.ValUseFlag -> - TypedTree.ValReprInfo -> TypedTree.Expr * TypedTree.TType - val IsSubsumptionExpr : g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> bool - val stripTupledFunTy : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> TypedTree.TTypes list * TypedTree.TType - val ( |ExprValWithPossibleTypeInst|_| ) : - TypedTree.Expr -> - (TypedTree.ValRef * TypedTree.ValUseFlag * TypedTree.TypeInst * - Range.range) option - val mkCoerceIfNeeded : - TcGlobals.TcGlobals -> - tgtTy:TypedTree.TType -> - srcTy:TypedTree.TType -> TypedTree.Expr -> TypedTree.Expr - val mkCompGenLetIn : - Range.range -> - string -> - TypedTree.TType -> - TypedTree.Expr -> - (TypedTree.Val * TypedTree.Expr -> TypedTree.Expr) -> - TypedTree.Expr - val AdjustPossibleSubsumptionExpr : - TcGlobals.TcGlobals -> - TypedTree.Expr -> - TypedTree.Expr list -> (TypedTree.Expr * TypedTree.Expr list) option - val NormalizeAndAdjustPossibleSubsumptionExprs : - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr - val etaExpandTypeLambda : - g:TcGlobals.TcGlobals -> - m:Range.range -> - tps:TypedTree.Typar list -> - tm:TypedTree.Expr * ty:TypedTree.TType -> TypedTree.Expr - val AdjustValToTopVal : - TypedTree.Val -> TypedTree.ParentRef -> TypedTree.ValReprInfo -> unit - val LinearizeTopMatchAux : - g:TcGlobals.TcGlobals -> - parent:TypedTree.ParentRef -> - spBind:SyntaxTree.DebugPointForBinding * m:Range.range * - tree:TypedTree.DecisionTree * targets:TypedTree.DecisionTreeTarget [] * - m2:Range.range * ty:TypedTree.TType -> TypedTree.Expr - val LinearizeTopMatch : - TcGlobals.TcGlobals -> - TypedTree.ParentRef -> TypedTree.Expr -> TypedTree.Expr - val commaEncs : strs:seq -> string - val angleEnc : str:string -> string - val ticksAndArgCountTextOfTyconRef : TypedTree.TyconRef -> string - val typarEnc : - _g:'a -> - gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> - typar:TypedTree.Typar -> string - val typeEnc : - g:TcGlobals.TcGlobals -> - gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> - ty:TypedTree.TType -> string - val tyargsEnc : - g:TcGlobals.TcGlobals -> - gtpsType:TypedTree.Typar list * gtpsMethod:TypedTree.Typar list -> - args:TypedTree.TypeInst -> string - val XmlDocArgsEnc : - TcGlobals.TcGlobals -> - TypedTree.Typar list * TypedTree.Typar list -> - TypedTree.TType list -> string - val buildAccessPath : TypedTree.CompilationPath option -> string - val prependPath : path:string -> name:string -> string - val XmlDocSigOfVal : - TcGlobals.TcGlobals -> full:bool -> string -> TypedTree.Val -> string - val BuildXmlDocSig : prefix:string -> paths:string list -> string - val XmlDocSigOfUnionCase : (string list -> string) - val XmlDocSigOfField : (string list -> string) - val XmlDocSigOfProperty : (string list -> string) - val XmlDocSigOfTycon : (string list -> string) - val XmlDocSigOfSubModul : (string list -> string) - val XmlDocSigOfEntity : TypedTree.EntityRef -> string - val enum_CompilationRepresentationAttribute_Static : int - val enum_CompilationRepresentationAttribute_Instance : int - val enum_CompilationRepresentationAttribute_StaticInstanceMask : int - val enum_CompilationRepresentationAttribute_ModuleSuffix : int - val enum_CompilationRepresentationAttribute_PermitNull : int - val HasUseNullAsTrueValueAttribute : - g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> bool - val TyconHasUseNullAsTrueValueAttribute : - TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val CanHaveUseNullAsTrueValueAttribute : - TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val IsUnionTypeWithNullAsTrueValue : - TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val TyconCompilesInstanceMembersAsStatic : - g:TcGlobals.TcGlobals -> tycon:TypedTree.Tycon -> bool - val TcrefCompilesInstanceMembersAsStatic : - g:TcGlobals.TcGlobals -> tcref:TypedTree.TyconRef -> bool - val isNonNullableStructTyparTy : - TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isReferenceTyparTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val TypeNullNever : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val TypeNullIsExtraValue : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val TypeNullIsTrueValue : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val TypeNullNotLiked : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val TypeSatisfiesNullConstraint : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val TypeHasDefaultValue : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val ( |SpecialComparableHeadType|_| ) : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes option - val ( |SpecialEquatableHeadType|_| ) : - TcGlobals.TcGlobals -> TypedTree.TType -> TypedTree.TTypes option - val ( |SpecialNotEquatableHeadType|_| ) : - TcGlobals.TcGlobals -> TypedTree.TType -> unit option - val canUseTypeTestFast : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val canUseUnboxFast : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> bool - val mkIsInstConditional : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> - TypedTree.Val -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkNullTest : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkNonNullTest : - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val mkNonNullCond : - TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val mkIfThen : - TcGlobals.TcGlobals -> - Range.range -> TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr - val ModuleNameIsMangled : - TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool - val CompileAsEvent : TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool - val MemberIsCompiledAsInstance : - TcGlobals.TcGlobals -> - TypedTree.TyconRef -> - bool -> TypedTree.ValMemberInfo -> TypedTree.Attrib list -> bool - val isSealedTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val isComInteropTy : TcGlobals.TcGlobals -> TypedTree.TType -> bool - val ValSpecIsCompiledAsInstance : - TcGlobals.TcGlobals -> TypedTree.Val -> bool - val ValRefIsCompiledAsInstanceMember : - TcGlobals.TcGlobals -> TypedTree.ValRef -> bool - val GetMemberCallInfo : - TcGlobals.TcGlobals -> - TypedTree.ValRef * TypedTree.ValUseFlag -> - int * bool * bool * bool * bool * bool * bool * bool - val TryGetActivePatternInfo : - TypedTree.ValRef -> PrettyNaming.ActivePatternInfo option - type ActivePatternElemRef with - member Name : string - val mkChoiceTyconRef : - g:TcGlobals.TcGlobals -> m:Range.range -> n:int -> TypedTree.EntityRef - val mkChoiceTy : - g:TcGlobals.TcGlobals -> - m:Range.range -> tinst:TypedTree.TType list -> TypedTree.TType - val mkChoiceCaseRef : - TcGlobals.TcGlobals -> Range.range -> int -> int -> TypedTree.UnionCaseRef - type ActivePatternInfo with - member Names : string list - type ActivePatternInfo with - member - ResultType : TcGlobals.TcGlobals -> - Range.range -> TypedTree.TType list -> TypedTree.TType - type ActivePatternInfo with - member - OverallType : TcGlobals.TcGlobals -> - Range.range -> - TypedTree.TType -> - TypedTree.TType list -> TypedTree.TType - val doesActivePatternHaveFreeTypars : - TcGlobals.TcGlobals -> TypedTree.ValRef -> bool - [] - type ExprRewritingEnv = - { PreIntercept: - ((TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr -> - TypedTree.Expr option) option - PostTransform: TypedTree.Expr -> TypedTree.Expr option - PreInterceptBinding: - ((TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Binding -> - TypedTree.Binding option) option - IsUnderQuotations: bool } - val rewriteBind : - env:ExprRewritingEnv -> bind:TypedTree.Binding -> TypedTree.Binding - val rewriteBindStructure : - env:ExprRewritingEnv -> TypedTree.Binding -> TypedTree.Binding - val rewriteBinds : - env:ExprRewritingEnv -> - binds:TypedTree.Binding list -> TypedTree.Binding list - val RewriteExpr : ExprRewritingEnv -> TypedTree.Expr -> TypedTree.Expr - val preRewriteExpr : - env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr option - val postRewriteExpr : - env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr - val rewriteExprStructure : - env:ExprRewritingEnv -> expr:TypedTree.Expr -> TypedTree.Expr - val rewriteLinearExpr : - env:ExprRewritingEnv -> - expr:TypedTree.Expr -> - contf:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr - val rewriteExprs : - env:ExprRewritingEnv -> exprs:TypedTree.Exprs -> TypedTree.Exprs - val rewriteFlatExprs : - env:ExprRewritingEnv -> exprs:TypedTree.Expr list -> TypedTree.Expr list - val RewriteDecisionTree : - env:ExprRewritingEnv -> x:TypedTree.DecisionTree -> TypedTree.DecisionTree - val rewriteTarget : - env:ExprRewritingEnv -> - TypedTree.DecisionTreeTarget -> TypedTree.DecisionTreeTarget - val rewriteTargets : - env:ExprRewritingEnv -> - targets:TypedTree.DecisionTreeTarget array -> - TypedTree.DecisionTreeTarget list - val rewriteObjExprOverride : - env:ExprRewritingEnv -> TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod - val rewriteObjExprInterfaceImpl : - env:ExprRewritingEnv -> - ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> - TypedTree.TType * TypedTree.ObjExprMethod list - val rewriteModuleOrNamespaceExpr : - env:ExprRewritingEnv -> - x:TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig - val rewriteModuleOrNamespaceDefs : - env:ExprRewritingEnv -> - x:TypedTree.ModuleOrNamespaceExpr list -> - TypedTree.ModuleOrNamespaceExpr list - val rewriteModuleOrNamespaceDef : - env:ExprRewritingEnv -> - x:TypedTree.ModuleOrNamespaceExpr -> TypedTree.ModuleOrNamespaceExpr - val rewriteModuleOrNamespaceBinding : - env:ExprRewritingEnv -> - x:TypedTree.ModuleOrNamespaceBinding -> - TypedTree.ModuleOrNamespaceBinding - val rewriteModuleOrNamespaceBindings : - env:ExprRewritingEnv -> - mbinds:TypedTree.ModuleOrNamespaceBinding list -> - TypedTree.ModuleOrNamespaceBinding list - val RewriteImplFile : - ExprRewritingEnv -> TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val MakeExportRemapping : - TypedTree.CcuThunk -> TypedTree.ModuleOrNamespace -> Remap - val remapEntityDataToNonLocal : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> d:TypedTree.Entity -> TypedTree.Entity - val remapTyconToNonLocal : - g:TcGlobals.TcGlobals -> - tmenv:Remap -> x:TypedTree.Entity -> TypedTree.Entity - val remapValToNonLocal : - g:TcGlobals.TcGlobals -> tmenv:Remap -> inp:TypedTree.Val -> TypedTree.Val - val ApplyExportRemappingToEntity : - TcGlobals.TcGlobals -> Remap -> TypedTree.Entity -> TypedTree.Entity - val isCompiledConstraint : cx:TypedTree.TyparConstraint -> bool - val IsGenericValWithGenericConstraints : - TcGlobals.TcGlobals -> TypedTree.Val -> bool - type Entity with - member HasInterface : TcGlobals.TcGlobals -> TypedTree.TType -> bool - type Entity with - member - HasOverride : TcGlobals.TcGlobals -> - string -> TypedTree.TType list -> bool - type Entity with - member - HasMember : TcGlobals.TcGlobals -> - string -> TypedTree.TType list -> bool - type EntityRef with - member HasInterface : TcGlobals.TcGlobals -> TypedTree.TType -> bool - type EntityRef with - member - HasOverride : TcGlobals.TcGlobals -> - string -> TypedTree.TType list -> bool - type EntityRef with - member - HasMember : TcGlobals.TcGlobals -> - string -> TypedTree.TType list -> bool - val mkFastForLoop : - TcGlobals.TcGlobals -> - SyntaxTree.DebugPointAtFor * Range.range * TypedTree.Val * - TypedTree.Expr * bool * TypedTree.Expr * TypedTree.Expr -> - TypedTree.Expr - val IsSimpleSyntacticConstantExpr : - TcGlobals.TcGlobals -> TypedTree.Expr -> bool - val EvalArithBinOp : - opInt8:(sbyte -> sbyte -> sbyte) * opInt16:(int16 -> int16 -> int16) * - opInt32:(int32 -> int32 -> int32) * opInt64:(int64 -> int64 -> int64) * - opUInt8:(byte -> byte -> byte) * opUInt16:(uint16 -> uint16 -> uint16) * - opUInt32:(uint32 -> uint32 -> uint32) * - opUInt64:(uint64 -> uint64 -> uint64) -> - arg1:TypedTree.Expr -> arg2:TypedTree.Expr -> TypedTree.Expr - val EvalAttribArgExpr : - g:TcGlobals.TcGlobals -> x:TypedTree.Expr -> TypedTree.Expr - val EvaledAttribExprEquality : - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr -> bool - val ( |ConstToILFieldInit|_| ) : - TypedTree.Const -> AbstractIL.IL.ILFieldInit option - val EvalLiteralExprOrAttribArg : - TcGlobals.TcGlobals -> TypedTree.Expr -> TypedTree.Expr - val GetTypeOfIntrinsicMemberInCompiledForm : - TcGlobals.TcGlobals -> - TypedTree.ValRef -> - TypedTree.Typar list * TypedTree.TraitWitnessInfo list * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.TType option * TypedTree.ArgReprInfo - val mkCompiledTuple : - TcGlobals.TcGlobals -> - bool -> - TypedTree.TType list * TypedTree.Expr list * Range.range -> - TypedTree.EntityRef * TypedTree.TType list * TypedTree.Expr list * - Range.range - val mkILMethodSpecForTupleItem : - _g:TcGlobals.TcGlobals -> - ty:AbstractIL.IL.ILType -> n:int -> AbstractIL.IL.ILMethodSpec - val mkILFieldSpecForTupleItem : - ty:AbstractIL.IL.ILType -> n:int -> AbstractIL.IL.ILFieldSpec - val mkGetTupleItemN : - TcGlobals.TcGlobals -> - Range.range -> - int -> - AbstractIL.IL.ILType -> - bool -> TypedTree.Expr -> TypedTree.TType -> TypedTree.Expr - val ( |Int32Expr|_| ) : TypedTree.Expr -> int32 option - val ( |TryFinally|_| ) : - expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.Expr) option - val ( |WhileLoopForCompiledForEachExpr|_| ) : - expr:TypedTree.Expr -> - (TypedTree.Expr * TypedTree.Expr * Range.range) option - val ( |Let|_| ) : - expr:TypedTree.Expr -> - (TypedTree.Val * TypedTree.Expr * SyntaxTree.DebugPointForBinding * - TypedTree.Expr) option - val ( |RangeInt32Step|_| ) : - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> (TypedTree.Expr * int * TypedTree.Expr) option - val ( |GetEnumeratorCall|_| ) : - expr:TypedTree.Expr -> TypedTree.ValRef option - val ( |CompiledForEachExpr|_| ) : - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> - (TypedTree.TType * TypedTree.Expr * TypedTree.Val * TypedTree.Expr * - (Range.range * Range.range * SyntaxTree.DebugPointAtFor * Range.range * - SyntaxTree.DebugPointAtWhile * Range.range)) option - val ( |CompiledInt32RangeForEachExpr|_| ) : - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> - (TypedTree.Expr * int * TypedTree.Expr * TypedTree.Val * - TypedTree.Expr * - (Range.range * Range.range * SyntaxTree.DebugPointAtFor * Range.range * - SyntaxTree.DebugPointAtWhile * Range.range)) option - type OptimizeForExpressionOptions = - | OptimizeIntRangesOnly - | OptimizeAllForExpressions - val DetectAndOptimizeForExpression : - TcGlobals.TcGlobals -> - OptimizeForExpressionOptions -> TypedTree.Expr -> TypedTree.Expr - val ( |InnerExprPat| ) : TypedTree.Expr -> TypedTree.Expr - val BindUnitVars : - TcGlobals.TcGlobals -> - (TypedTree.Val list * TypedTree.ArgReprInfo list * TypedTree.Expr) -> - TypedTree.Val list * TypedTree.Expr - val isThreadOrContextStatic : - TcGlobals.TcGlobals -> TypedTree.Attrib list -> bool - val mkUnitDelayLambda : - TcGlobals.TcGlobals -> Range.range -> TypedTree.Expr -> TypedTree.Expr - val ( |ValApp|_| ) : - TcGlobals.TcGlobals -> - TypedTree.ValRef -> - TypedTree.Expr -> - (TypedTree.TypeInst * TypedTree.Exprs * Range.range) option - val CombineCcuContentFragments : - Range.range -> - TypedTree.ModuleOrNamespaceType list -> TypedTree.ModuleOrNamespaceType - type TraitWitnessInfoHashMap<'T> = - System.Collections.Immutable.ImmutableDictionary - val EmptyTraitWitnessInfoHashMap : - TcGlobals.TcGlobals -> TraitWitnessInfoHashMap<'T> - val ( |WhileExpr|_| ) : - TypedTree.Expr -> - (SyntaxTree.DebugPointAtWhile * TypedTree.SpecialWhileLoopMarker * - TypedTree.Expr * TypedTree.Expr * Range.range) option - val ( |TryFinallyExpr|_| ) : - TypedTree.Expr -> - (SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtFinally * - TypedTree.TType * TypedTree.Expr * TypedTree.Expr * Range.range) option - val ( |ForLoopExpr|_| ) : - TypedTree.Expr -> - (SyntaxTree.DebugPointAtFor * TypedTree.ForLoopStyle * TypedTree.Expr * - TypedTree.Expr * TypedTree.Val * TypedTree.Expr * Range.range) option - val ( |TryWithExpr|_| ) : - TypedTree.Expr -> - (SyntaxTree.DebugPointAtTry * SyntaxTree.DebugPointAtWith * - TypedTree.TType * TypedTree.Expr * TypedTree.Val * TypedTree.Expr * - TypedTree.Val * TypedTree.Expr * Range.range) option - val mkLabelled : - Range.range -> - AbstractIL.IL.ILCodeLabel -> TypedTree.Expr -> TypedTree.Expr - end - -namespace FSharp.Compiler - module internal TypedTreePickle = begin - val verbose : bool - val ffailwith : fileName:System.String -> str:System.String -> 'a - [] - type PickledDataWithReferences<'RawData> = - { RawData: 'RawData - FixupThunks: TypedTree.CcuThunk [] } - with - member Fixup : (string -> TypedTree.CcuThunk) -> 'RawData - member OptionalFixup : (string -> TypedTree.CcuThunk option) -> 'RawData - end - [] - type Table<'T> = - { name: string - tbl: System.Collections.Generic.Dictionary<'T,int> - mutable rows: ResizeArray<'T> - mutable count: int } - with - static member Create : n:string -> Table<'a> when 'a : equality - member Add : x:'T -> int - member FindOrAdd : x:'T -> int - member AsArray : 'T [] - member Size : int - end - [] - type InputTable<'T> = - { itbl_name: string - itbl_rows: 'T array } - val new_itbl : n:string -> r:'a array -> InputTable<'a> - [] - type NodeOutTable<'Data,'Node> = - { NodeStamp: 'Node -> TypedTree.Stamp - NodeName: 'Node -> string - GetRange: 'Node -> Range.range - Deref: 'Node -> 'Data - Name: string - Table: Table } - with - static member - Create : stampF:('a -> TypedTree.Stamp) * nameF:('a -> string) * - rangeF:('a -> Range.range) * derefF:('a -> 'b) * nm:string -> - NodeOutTable<'b,'a> - member Size : int - end - [] - type WriterState = - { os: AbstractIL.Internal.ByteBuffer - oscope: TypedTree.CcuThunk - occus: Table - oentities: NodeOutTable - otypars: NodeOutTable - ovals: NodeOutTable - oanoninfos: - NodeOutTable - ostrings: Table - opubpaths: Table - onlerefs: Table - osimpletys: Table - oglobals: TcGlobals.TcGlobals - mutable isStructThisArgPos: bool - ofile: string - oInMem: bool } - val pfailwith : st:WriterState -> str:System.String -> 'a - [] - type NodeInTable<'Data,'Node> = - { LinkNode: 'Node -> 'Data -> unit - IsLinked: 'Node -> bool - Name: string - Nodes: 'Node [] } - with - static member - Create : mkEmpty:(unit -> 'a) * lnk:('a -> 'b -> unit) * - isLinked:('a -> bool) * nm:string * n:int -> - NodeInTable<'b,'a> - member Get : n:int -> 'Node - member Count : int - end - [] - type ReaderState = - { is: AbstractIL.Internal.ByteStream - iilscope: AbstractIL.IL.ILScopeRef - iccus: InputTable - ientities: NodeInTable - itypars: NodeInTable - ivals: NodeInTable - ianoninfos: - NodeInTable - istrings: InputTable - ipubpaths: InputTable - inlerefs: InputTable - isimpletys: InputTable - ifile: string - iILModule: AbstractIL.IL.ILModuleDef option } - val ufailwith : st:ReaderState -> str:System.String -> 'a - type 'T pickler = 'T -> WriterState -> unit - val p_byte : int -> WriterState -> unit - val p_bool : bool -> WriterState -> unit - val prim_p_int32 : i:int -> st:WriterState -> unit - val p_int32 : n:int -> st:WriterState -> unit - val space : unit - val p_space : n:int -> unit -> st:WriterState -> unit - val p_used_space1 : f:(WriterState -> unit) -> st:WriterState -> unit - val p_bytes : s:byte [] -> st:WriterState -> unit - val p_prim_string : s:string -> st:WriterState -> unit - val p_int : int -> WriterState -> unit - val p_int8 : i:sbyte -> st:WriterState -> unit - val p_uint8 : i:byte -> st:WriterState -> unit - val p_int16 : i:int16 -> st:WriterState -> unit - val p_uint16 : x:uint16 -> st:WriterState -> unit - val p_uint32 : x:uint32 -> st:WriterState -> unit - val p_int64 : i:int64 -> st:WriterState -> unit - val p_uint64 : x:uint64 -> st:WriterState -> unit - val bits_of_float32 : x:float32 -> int - val bits_of_float : x:float -> int64 - val p_single : i:float32 -> st:WriterState -> unit - val p_double : i:float -> st:WriterState -> unit - val p_ieee64 : i:float -> st:WriterState -> unit - val p_char : i:char -> st:WriterState -> unit - val inline p_tup2 : - ('T1 -> WriterState -> unit) -> - ('T2 -> WriterState -> unit) -> ('T1 * 'T2 -> WriterState -> unit) - val inline p_tup3 : - ('T1 -> WriterState -> unit) -> - ('T2 -> WriterState -> unit) -> - ('T3 -> WriterState -> unit) -> - ('T1 * 'T2 * 'T3 -> WriterState -> unit) - val inline p_tup4 : - ('T1 -> WriterState -> unit) -> - ('T2 -> WriterState -> unit) -> - ('T3 -> WriterState -> unit) -> - ('T4 -> WriterState -> unit) -> - ('T1 * 'T2 * 'T3 * 'T4 -> WriterState -> unit) - val inline p_tup5 : - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e -> st:WriterState -> unit - val inline p_tup6 : - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f -> - st:WriterState -> unit - val inline p_tup7 : - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - p7:('g -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g -> - st:WriterState -> unit - val inline p_tup8 : - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - p7:('g -> WriterState -> unit) -> - p8:('h -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * x8:'h -> - st:WriterState -> unit - val inline p_tup9 : - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - p7:('g -> WriterState -> unit) -> - p8:('h -> WriterState -> unit) -> - p9:('i -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * x8:'h * - x9:'i -> st:WriterState -> unit - val inline p_tup10 : - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - p7:('g -> WriterState -> unit) -> - p8:('h -> WriterState -> unit) -> - p9:('i -> WriterState -> unit) -> - p10:('j -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * - x8:'h * x9:'i * x10:'j -> st:WriterState -> unit - val inline p_tup11 : - p1:('a -> WriterState -> unit) -> - p2:('b -> WriterState -> unit) -> - p3:('c -> WriterState -> unit) -> - p4:('d -> WriterState -> unit) -> - p5:('e -> WriterState -> unit) -> - p6:('f -> WriterState -> unit) -> - p7:('g -> WriterState -> unit) -> - p8:('h -> WriterState -> unit) -> - p9:('i -> WriterState -> unit) -> - p10:('j -> WriterState -> unit) -> - p11:('k -> WriterState -> unit) -> - a:'a * b:'b * c:'c * d:'d * e:'e * f:'f * x7:'g * - x8:'h * x9:'i * x10:'j * x11:'k -> - st:WriterState -> unit - val u_byte : ReaderState -> int - type unpickler<'T> = ReaderState -> 'T - val u_bool : ReaderState -> bool - val prim_u_int32 : st:ReaderState -> int - val u_int32 : st:ReaderState -> int - val u_byte_memory : st:ReaderState -> AbstractIL.Internal.ReadOnlyByteMemory - val u_bytes : st:ReaderState -> byte [] - val u_prim_string : st:ReaderState -> string - val u_int : ReaderState -> int - val u_int8 : st:ReaderState -> sbyte - val u_uint8 : st:ReaderState -> byte - val u_int16 : st:ReaderState -> int16 - val u_uint16 : st:ReaderState -> uint16 - val u_uint32 : st:ReaderState -> uint32 - val u_int64 : st:ReaderState -> int64 - val u_uint64 : st:ReaderState -> uint64 - val float32_of_bits : x:int32 -> float32 - val float_of_bits : x:int64 -> float - val u_single : st:ReaderState -> float32 - val u_double : st:ReaderState -> float - val u_ieee64 : st:ReaderState -> float - val u_char : st:ReaderState -> char - val u_space : n:int -> st:ReaderState -> unit - val u_used_space1 : f:(ReaderState -> 'a) -> st:ReaderState -> 'a option - val inline u_tup2 : - (ReaderState -> 'T2) -> (ReaderState -> 'T3) -> (ReaderState -> 'T2 * 'T3) - val inline u_tup3 : - (ReaderState -> 'T2) -> - (ReaderState -> 'T3) -> - (ReaderState -> 'T4) -> (ReaderState -> 'T2 * 'T3 * 'T4) - val inline u_tup4 : - (ReaderState -> 'T2) -> - (ReaderState -> 'T3) -> - (ReaderState -> 'T4) -> - (ReaderState -> 'T5) -> (ReaderState -> 'T2 * 'T3 * 'T4 * 'T5) - val inline u_tup5 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> st:ReaderState -> 'a * 'b * 'c * 'd * 'e - val inline u_tup6 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f - val inline u_tup7 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f * 'g - val inline u_tup8 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - st:ReaderState -> 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h - val inline u_tup9 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i - val inline u_tup10 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j - val inline u_tup11 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j * - 'k - val inline u_tup12 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * 'j * - 'k * 'l - val inline u_tup13 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - p13:(ReaderState -> 'm) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * - 'j * 'k * 'l * 'm - val inline u_tup14 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - p13:(ReaderState -> 'm) -> - p14:(ReaderState -> 'n) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * - 'j * 'k * 'l * 'm * 'n - val inline u_tup15 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - p13:(ReaderState -> 'm) -> - p14:(ReaderState -> 'n) -> - p15:(ReaderState -> 'o) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i * - 'j * 'k * 'l * 'm * 'n * 'o - val inline u_tup16 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - p13:(ReaderState -> 'm) -> - p14:(ReaderState -> 'n) -> - p15:(ReaderState -> 'o) -> - p16:(ReaderState -> 'p) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * - 'i * 'j * 'k * 'l * 'm * 'n * 'o * 'p - val inline u_tup17 : - p1:(ReaderState -> 'a) -> - p2:(ReaderState -> 'b) -> - p3:(ReaderState -> 'c) -> - p4:(ReaderState -> 'd) -> - p5:(ReaderState -> 'e) -> - p6:(ReaderState -> 'f) -> - p7:(ReaderState -> 'g) -> - p8:(ReaderState -> 'h) -> - p9:(ReaderState -> 'i) -> - p10:(ReaderState -> 'j) -> - p11:(ReaderState -> 'k) -> - p12:(ReaderState -> 'l) -> - p13:(ReaderState -> 'm) -> - p14:(ReaderState -> 'n) -> - p15:(ReaderState -> 'o) -> - p16:(ReaderState -> 'p) -> - p17:(ReaderState -> 'q) -> - st:ReaderState -> - 'a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * - 'i * 'j * 'k * 'l * 'm * 'n * 'o * 'p * - 'q - val p_osgn_ref : - _ctxt:string -> - outMap:NodeOutTable<'a,'b> -> x:'b -> st:WriterState -> unit - val p_osgn_decl : - outMap:NodeOutTable<'a,'b> -> - p:('a -> WriterState -> unit) -> x:'b -> st:WriterState -> unit - val u_osgn_ref : inMap:NodeInTable<'a,'b> -> st:ReaderState -> 'b - val u_osgn_decl : - inMap:NodeInTable<'a,'b> -> u:(ReaderState -> 'a) -> st:ReaderState -> 'b - val encode_uniq : tbl:Table<'a> -> key:'a -> int - val lookup_uniq : st:ReaderState -> tbl:InputTable<'a> -> n:int -> 'a - val p_array_core : f:('T -> 'a -> unit) -> x:'T [] -> st:'a -> unit - val p_array : ('T -> WriterState -> unit) -> ('T [] -> WriterState -> unit) - val p_array_ext : - extraf:(WriterState -> unit) option -> - f:('T -> WriterState -> unit) -> x:'T [] -> st:WriterState -> unit - val p_list_core : f:('T -> 'a -> unit) -> xs:'T list -> st:'a -> unit - val p_list : - f:('a -> WriterState -> unit) -> x:'a list -> st:WriterState -> unit - val p_list_ext : - extraf:(WriterState -> unit) option -> - f:('a -> WriterState -> unit) -> x:'a list -> st:WriterState -> unit - val p_List : - f:('T -> WriterState -> unit) -> x:'T list -> st:WriterState -> unit - val p_wrap : f:('T -> 'U) -> p:'U pickler -> x:'T -> st:WriterState -> unit - val p_option : - f:('a -> WriterState -> unit) -> x:'a option -> st:WriterState -> unit - val private p_lazy_impl : - p:('a -> WriterState -> unit) -> v:'a -> st:WriterState -> unit - val p_lazy : - ('T -> WriterState -> unit) -> (System.Lazy<'T> -> WriterState -> unit) - val p_maybe_lazy : - p:('a -> WriterState -> unit) -> - x:Lib.MaybeLazy<'a> -> st:WriterState -> unit - val p_hole : - unit -> (('a -> WriterState -> 'b) -> unit) * ('a -> WriterState -> 'b) - val p_hole2 : - unit -> - (('a -> 'b -> WriterState -> 'c) -> unit) * - ('a -> 'b -> WriterState -> 'c) - val u_array_core : f:('a -> 'b) -> n:int -> st:'a -> 'b [] - val u_array : (ReaderState -> 'T) -> (ReaderState -> 'T []) - val u_array_ext : - extraf:(ReaderState -> 'a) -> - f:(ReaderState -> 'b) -> st:ReaderState -> 'a option * 'b [] - val u_list_core : f:('a -> 'b) -> n:int -> st:'a -> 'b list - val u_list : f:(ReaderState -> 'a) -> st:ReaderState -> 'a list - val u_list_ext : - extra:(ReaderState -> 'a) -> - f:(ReaderState -> 'b) -> st:ReaderState -> 'a option * 'b list - val u_List : f:(ReaderState -> 'a) -> st:ReaderState -> 'a list - val u_array_revi : f:(ReaderState -> int -> 'a) -> st:ReaderState -> 'a [] - val u_list_revi : f:(ReaderState -> int -> 'a) -> st:ReaderState -> 'a list - val u_wrap : f:('U -> 'T) -> u:unpickler<'U> -> st:ReaderState -> 'T - val u_option : f:(ReaderState -> 'a) -> st:ReaderState -> 'a option - val u_lazy : (ReaderState -> 'T) -> (ReaderState -> System.Lazy<'T>) - val u_hole : unit -> ((ReaderState -> 'a) -> unit) * (ReaderState -> 'a) - val encode_string : stringTab:Table<'a> -> x:'a -> int - val decode_string : x:'a -> 'a - val lookup_string : - st:ReaderState -> stringTab:InputTable<'a> -> x:int -> 'a - val u_encoded_string : (ReaderState -> string) - val u_string : ReaderState -> string - val u_strings : (ReaderState -> string list) - val u_ints : (ReaderState -> int list) - val p_encoded_string : (string -> WriterState -> unit) - val p_string : string -> WriterState -> unit - val p_strings : (string list -> WriterState -> unit) - val p_ints : (int list -> WriterState -> unit) - val encode_ccuref : ccuTab:Table -> x:TypedTree.CcuThunk -> int - val decode_ccuref : x:'a -> 'a - val lookup_ccuref : st:ReaderState -> ccuTab:InputTable<'a> -> x:int -> 'a - val u_encoded_ccuref : st:ReaderState -> string - val u_ccuref : st:ReaderState -> TypedTree.CcuThunk - val p_encoded_ccuref : x:string -> st:WriterState -> unit - val p_ccuref : s:TypedTree.CcuThunk -> st:WriterState -> unit - val decode_pubpath : - st:ReaderState -> - stringTab:InputTable -> a:int [] -> TypedTree.PublicPath - val lookup_pubpath : - st:ReaderState -> pubpathTab:InputTable<'a> -> x:int -> 'a - val u_encoded_pubpath : (ReaderState -> int []) - val u_pubpath : st:ReaderState -> TypedTree.PublicPath - val encode_pubpath : - stringTab:Table -> - pubpathTab:Table -> TypedTree.PublicPath -> int - val p_encoded_pubpath : (int [] -> WriterState -> unit) - val p_pubpath : x:TypedTree.PublicPath -> st:WriterState -> unit - val decode_nleref : - st:ReaderState -> - ccuTab:InputTable -> - stringTab:InputTable -> - a:int * b:int [] -> TypedTree.NonLocalEntityRef - val lookup_nleref : - st:ReaderState -> nlerefTab:InputTable<'a> -> x:int -> 'a - val u_encoded_nleref : (ReaderState -> int * int []) - val u_nleref : st:ReaderState -> TypedTree.NonLocalEntityRef - val encode_nleref : - ccuTab:Table -> - stringTab:Table -> - nlerefTab:Table -> - thisCcu:TypedTree.CcuThunk -> - nleref:TypedTree.NonLocalEntityRef -> int - val p_encoded_nleref : (int * int [] -> WriterState -> unit) - val p_nleref : x:TypedTree.NonLocalEntityRef -> st:WriterState -> unit - val decode_simpletyp : - st:ReaderState -> - _ccuTab:'a -> - _stringTab:'b -> - nlerefTab:InputTable -> - a:int -> TypedTree.TType - val lookup_simpletyp : - st:ReaderState -> simpleTyTab:InputTable<'a> -> x:int -> 'a - val u_encoded_simpletyp : st:ReaderState -> int - val u_encoded_anoninfo : st:ReaderState -> int - val u_simpletyp : st:ReaderState -> TypedTree.TType - val encode_simpletyp : - ccuTab:Table -> - stringTab:Table -> - nlerefTab:Table -> - simpleTyTab:Table -> - thisCcu:TypedTree.CcuThunk -> a:TypedTree.NonLocalEntityRef -> int - val p_encoded_simpletyp : x:int -> st:WriterState -> unit - val p_encoded_anoninfo : x:int -> st:WriterState -> unit - val p_simpletyp : x:TypedTree.NonLocalEntityRef -> st:WriterState -> unit - val pickleObjWithDanglingCcus : - inMem:bool -> - file:string -> - TcGlobals.TcGlobals -> - scope:TypedTree.CcuThunk -> - ('T -> WriterState -> unit) -> 'T -> byte [] - val check : - ilscope:AbstractIL.IL.ILScopeRef -> inMap:NodeInTable<'a,'b> -> unit - val unpickleObjWithDanglingCcus : - file:string -> - viewedScope:AbstractIL.IL.ILScopeRef -> - ilModule:AbstractIL.IL.ILModuleDef option -> - (ReaderState -> 'T) -> - AbstractIL.Internal.ReadOnlyByteMemory -> - PickledDataWithReferences<'T> - val p_ILPublicKey : x:AbstractIL.IL.PublicKey -> st:WriterState -> unit - val p_ILVersion : x:AbstractIL.IL.ILVersionInfo -> st:WriterState -> unit - val p_ILModuleRef : x:AbstractIL.IL.ILModuleRef -> st:WriterState -> unit - val p_ILAssemblyRef : - x:AbstractIL.IL.ILAssemblyRef -> st:WriterState -> unit - val p_ILScopeRef : x:AbstractIL.IL.ILScopeRef -> st:WriterState -> unit - val u_ILPublicKey : st:ReaderState -> AbstractIL.IL.PublicKey - val u_ILVersion : st:ReaderState -> AbstractIL.IL.ILVersionInfo - val u_ILModuleRef : st:ReaderState -> AbstractIL.IL.ILModuleRef - val u_ILAssemblyRef : st:ReaderState -> AbstractIL.IL.ILAssemblyRef - val u_ILScopeRef : st:ReaderState -> AbstractIL.IL.ILScopeRef - val p_ILHasThis : x:AbstractIL.IL.ILThisConvention -> st:WriterState -> unit - val p_ILArrayShape : AbstractIL.IL.ILArrayShape pickler - val p_ILType : ty:AbstractIL.IL.ILType -> st:WriterState -> unit - val p_ILTypes : tys:AbstractIL.IL.ILType list -> (WriterState -> unit) - val p_ILBasicCallConv : - x:AbstractIL.IL.ILArgConvention -> st:WriterState -> unit - val p_ILCallConv : AbstractIL.IL.ILCallingConv -> st:WriterState -> unit - val p_ILCallSig : - x:AbstractIL.IL.ILCallingSignature -> st:WriterState -> unit - val p_ILTypeRef : x:AbstractIL.IL.ILTypeRef -> st:WriterState -> unit - val p_ILTypeSpec : a:AbstractIL.IL.ILTypeSpec -> st:WriterState -> unit - val u_ILBasicCallConv : st:ReaderState -> AbstractIL.IL.ILArgConvention - val u_ILHasThis : st:ReaderState -> AbstractIL.IL.ILThisConvention - val u_ILCallConv : st:ReaderState -> AbstractIL.IL.ILCallingConv - val u_ILTypeRef : st:ReaderState -> AbstractIL.IL.ILTypeRef - val u_ILArrayShape : unpickler - val u_ILType : st:ReaderState -> AbstractIL.IL.ILType - val u_ILTypes : st:ReaderState -> AbstractIL.IL.ILType list - val u_ILCallSig : (ReaderState -> AbstractIL.IL.ILCallingSignature) - val u_ILTypeSpec : st:ReaderState -> AbstractIL.IL.ILTypeSpec - val p_ILMethodRef : x:AbstractIL.IL.ILMethodRef -> st:WriterState -> unit - val p_ILFieldRef : x:AbstractIL.IL.ILFieldRef -> st:WriterState -> unit - val p_ILMethodSpec : x:AbstractIL.IL.ILMethodSpec -> st:WriterState -> unit - val p_ILFieldSpec : x:AbstractIL.IL.ILFieldSpec -> st:WriterState -> unit - val p_ILBasicType : x:AbstractIL.IL.ILBasicType -> st:WriterState -> unit - val p_ILVolatility : x:AbstractIL.IL.ILVolatility -> st:WriterState -> unit - val p_ILReadonly : x:AbstractIL.IL.ILReadonly -> st:WriterState -> unit - val u_ILMethodRef : st:ReaderState -> AbstractIL.IL.ILMethodRef - val u_ILFieldRef : st:ReaderState -> AbstractIL.IL.ILFieldRef - val u_ILMethodSpec : st:ReaderState -> AbstractIL.IL.ILMethodSpec - val u_ILFieldSpec : st:ReaderState -> AbstractIL.IL.ILFieldSpec - val u_ILBasicType : st:ReaderState -> AbstractIL.IL.ILBasicType - val u_ILVolatility : st:ReaderState -> AbstractIL.IL.ILVolatility - val u_ILReadonly : st:ReaderState -> AbstractIL.IL.ILReadonly - [] - val itag_nop : int = 0 - [] - val itag_ldarg : int = 1 - [] - val itag_ldnull : int = 2 - [] - val itag_ilzero : int = 3 - [] - val itag_call : int = 4 - [] - val itag_add : int = 5 - [] - val itag_sub : int = 6 - [] - val itag_mul : int = 7 - [] - val itag_div : int = 8 - [] - val itag_div_un : int = 9 - [] - val itag_rem : int = 10 - [] - val itag_rem_un : int = 11 - [] - val itag_and : int = 12 - [] - val itag_or : int = 13 - [] - val itag_xor : int = 14 - [] - val itag_shl : int = 15 - [] - val itag_shr : int = 16 - [] - val itag_shr_un : int = 17 - [] - val itag_neg : int = 18 - [] - val itag_not : int = 19 - [] - val itag_conv : int = 20 - [] - val itag_conv_un : int = 21 - [] - val itag_conv_ovf : int = 22 - [] - val itag_conv_ovf_un : int = 23 - [] - val itag_callvirt : int = 24 - [] - val itag_ldobj : int = 25 - [] - val itag_ldstr : int = 26 - [] - val itag_castclass : int = 27 - [] - val itag_isinst : int = 28 - [] - val itag_unbox : int = 29 - [] - val itag_throw : int = 30 - [] - val itag_ldfld : int = 31 - [] - val itag_ldflda : int = 32 - [] - val itag_stfld : int = 33 - [] - val itag_ldsfld : int = 34 - [] - val itag_ldsflda : int = 35 - [] - val itag_stsfld : int = 36 - [] - val itag_stobj : int = 37 - [] - val itag_box : int = 38 - [] - val itag_newarr : int = 39 - [] - val itag_ldlen : int = 40 - [] - val itag_ldelema : int = 41 - [] - val itag_ckfinite : int = 42 - [] - val itag_ldtoken : int = 43 - [] - val itag_add_ovf : int = 44 - [] - val itag_add_ovf_un : int = 45 - [] - val itag_mul_ovf : int = 46 - [] - val itag_mul_ovf_un : int = 47 - [] - val itag_sub_ovf : int = 48 - [] - val itag_sub_ovf_un : int = 49 - [] - val itag_ceq : int = 50 - [] - val itag_cgt : int = 51 - [] - val itag_cgt_un : int = 52 - [] - val itag_clt : int = 53 - [] - val itag_clt_un : int = 54 - [] - val itag_ldvirtftn : int = 55 - [] - val itag_localloc : int = 56 - [] - val itag_rethrow : int = 57 - [] - val itag_sizeof : int = 58 - [] - val itag_ldelem_any : int = 59 - [] - val itag_stelem_any : int = 60 - [] - val itag_unbox_any : int = 61 - [] - val itag_ldlen_multi : int = 62 - [] - val itag_initobj : int = 63 - [] - val itag_initblk : int = 64 - [] - val itag_cpobj : int = 65 - [] - val itag_cpblk : int = 66 - val simple_instrs : (int * AbstractIL.IL.ILInstr) list - val encode_table : - System.Collections.Generic.Dictionary - val encode_instr : si:AbstractIL.IL.ILInstr -> int - val isNoArgInstr : s:AbstractIL.IL.ILInstr -> bool - val decoders : (int * (ReaderState -> AbstractIL.IL.ILInstr)) list - val decode_tab : (ReaderState -> AbstractIL.IL.ILInstr) [] - val p_ILInstr : x:AbstractIL.IL.ILInstr -> st:WriterState -> unit - val u_ILInstr : st:ReaderState -> AbstractIL.IL.ILInstr - val p_Map_core : - pk:('a -> 'b -> unit) -> - pv:('c -> 'b -> unit) -> xs:Map<'a,'c> -> st:'b -> unit - when 'a : comparison - val p_Map : - pk:('a -> WriterState -> unit) -> - pv:('b -> WriterState -> unit) -> x:Map<'a,'b> -> st:WriterState -> unit - when 'a : comparison - val p_qlist : - pv:('a -> WriterState -> unit) -> Internal.Utilities.QueueList<'a> pickler - val p_namemap : - ('T -> WriterState -> unit) -> (Map -> WriterState -> unit) - val u_Map_core : - uk:('a -> 'b) -> uv:('a -> 'c) -> n:int -> st:'a -> Map<'b,'c> - when 'b : comparison - val u_Map : - uk:(ReaderState -> 'a) -> - uv:(ReaderState -> 'b) -> st:ReaderState -> Map<'a,'b> - when 'a : comparison - val u_qlist : - uv:(ReaderState -> 'a) -> unpickler> - val u_namemap : (ReaderState -> 'T) -> (ReaderState -> Map) - val p_pos : x:Range.pos -> st:WriterState -> unit - val p_range : x:Range.range -> st:WriterState -> unit - val p_dummy_range : _x:Range.range -> _st:WriterState -> unit - val p_ident : x:SyntaxTree.Ident -> st:WriterState -> unit - val p_xmldoc : doc:XmlDoc.XmlDoc -> st:WriterState -> unit - val u_pos : st:ReaderState -> Range.pos - val u_range : st:ReaderState -> Range.range - val u_dummy_range : _st:ReaderState -> Range.range - val u_ident : st:ReaderState -> SyntaxTree.Ident - val u_xmldoc : st:ReaderState -> XmlDoc.XmlDoc - val p_local_item_ref : - ctxt:string -> tab:NodeOutTable<'a,'b> -> st:'b -> (WriterState -> unit) - val p_tcref : string -> (TypedTree.EntityRef -> WriterState -> unit) - val p_ucref : (TypedTree.UnionCaseRef -> WriterState -> unit) - val p_rfref : TypedTree.RecdFieldRef -> st:WriterState -> unit - val p_tpref : x:TypedTree.Typar -> st:WriterState -> unit - val u_local_item_ref : tab:NodeInTable<'a,'b> -> st:ReaderState -> 'b - val u_tcref : (ReaderState -> TypedTree.EntityRef) - val u_ucref : (ReaderState -> TypedTree.UnionCaseRef) - val u_rfref : st:ReaderState -> TypedTree.RecdFieldRef - val u_tpref : st:ReaderState -> TypedTree.Typar - val p_ty2 : (bool -> TypedTree.TType -> WriterState -> unit) - val fill_p_ty2 : ((bool -> TypedTree.TType -> WriterState -> unit) -> unit) - val p_ty : (TypedTree.TType -> WriterState -> unit) - val p_tys : (TypedTree.TType list -> WriterState -> unit) - val p_attribs : (TypedTree.Attribs -> WriterState -> unit) - val fill_p_attribs : ((TypedTree.Attribs -> WriterState -> unit) -> unit) - val checkForInRefStructThisArg : - st:WriterState -> ty:TypedTree.TType -> bool - val p_nonlocal_val_ref : - nlv:TypedTree.NonLocalValOrMemberRef -> st:WriterState -> unit - val p_vref : string -> (TypedTree.ValRef -> WriterState -> unit) - val p_vrefs : ctxt:string -> (TypedTree.ValRef list -> WriterState -> unit) - val u_ty : (ReaderState -> TypedTree.TType) - val fill_u_ty : ((ReaderState -> TypedTree.TType) -> unit) - val u_tys : (ReaderState -> TypedTree.TType list) - val u_attribs : (ReaderState -> TypedTree.Attrib list) - val fill_u_attribs : ((ReaderState -> TypedTree.Attrib list) -> unit) - val u_nonlocal_val_ref : st:ReaderState -> TypedTree.NonLocalValOrMemberRef - val u_vref : (ReaderState -> TypedTree.ValRef) - val u_vrefs : (ReaderState -> TypedTree.ValRef list) - val p_kind : x:TypedTree.TyparKind -> st:WriterState -> unit - val p_member_kind : x:SyntaxTree.MemberKind -> st:WriterState -> unit - val u_kind : st:ReaderState -> TypedTree.TyparKind - val u_member_kind : st:ReaderState -> SyntaxTree.MemberKind - val p_MemberFlags : x:SyntaxTree.MemberFlags -> st:WriterState -> unit - val u_MemberFlags : st:ReaderState -> SyntaxTree.MemberFlags - val u_expr_fwd : (ReaderState -> TypedTree.Expr) - val fill_u_Expr_hole : ((ReaderState -> TypedTree.Expr) -> unit) - val p_expr_fwd : (TypedTree.Expr -> WriterState -> unit) - val fill_p_Expr_hole : ((TypedTree.Expr -> WriterState -> unit) -> unit) - val p_anonInfo_data : - anonInfo:TypedTree.AnonRecdTypeInfo -> st:WriterState -> unit - val p_anonInfo : x:TypedTree.AnonRecdTypeInfo -> st:WriterState -> unit - val p_trait_sln : sln:TypedTree.TraitConstraintSln -> st:WriterState -> unit - val p_trait : TypedTree.TraitConstraintInfo -> st:WriterState -> unit - val u_anonInfo_data : st:ReaderState -> TypedTree.AnonRecdTypeInfo - val u_anonInfo : st:ReaderState -> TypedTree.AnonRecdTypeInfo - val u_trait_sln : st:ReaderState -> TypedTree.TraitConstraintSln - val u_trait : st:ReaderState -> TypedTree.TraitConstraintInfo - val p_rational : q:Rational.Rational -> st:WriterState -> unit - val p_measure_con : tcref:TypedTree.EntityRef -> st:WriterState -> unit - val p_measure_var : v:TypedTree.Typar -> st:WriterState -> unit - val p_measure_one : (WriterState -> unit) - val p_measure_varcon : unt:TypedTree.Measure -> st:WriterState -> unit - val p_measure_pospower : - unt:TypedTree.Measure -> n:int -> st:WriterState -> unit - val p_measure_intpower : - unt:TypedTree.Measure -> n:int -> st:WriterState -> unit - val p_measure_power : - unt:TypedTree.Measure -> q:Rational.Rational -> st:WriterState -> unit - val p_normalized_measure : unt:TypedTree.Measure -> st:WriterState -> unit - val p_measure_expr : unt:TypedTree.Measure -> st:WriterState -> unit - val u_rational : st:ReaderState -> Rational.Rational - val u_measure_expr : st:ReaderState -> TypedTree.Measure - val p_tyar_constraint : - x:TypedTree.TyparConstraint -> st:WriterState -> unit - val p_tyar_constraints : - (TypedTree.TyparConstraint list -> WriterState -> unit) - val u_tyar_constraint : st:ReaderState -> (int -> TypedTree.TyparConstraint) - val u_tyar_constraints : (ReaderState -> TypedTree.TyparConstraint list) - val p_tyar_spec_data : x:TypedTree.Typar -> st:WriterState -> unit - val p_tyar_spec : x:TypedTree.Typar -> st:WriterState -> unit - val p_tyar_specs : (TypedTree.Typar list -> WriterState -> unit) - val u_tyar_spec_data : st:ReaderState -> TypedTree.Typar - val u_tyar_spec : st:ReaderState -> TypedTree.Typar - val u_tyar_specs : (ReaderState -> TypedTree.Typar list) - val p_binds : (TypedTree.Bindings -> WriterState -> unit) - val fill_p_binds : ((TypedTree.Bindings -> WriterState -> unit) -> unit) - val p_targets : (TypedTree.DecisionTreeTarget array -> WriterState -> unit) - val fill_p_targets : - ((TypedTree.DecisionTreeTarget array -> WriterState -> unit) -> unit) - val p_Exprs : (TypedTree.Exprs -> WriterState -> unit) - val fill_p_Exprs : ((TypedTree.Exprs -> WriterState -> unit) -> unit) - val p_constraints : - (TypedTree.StaticOptimization list -> WriterState -> unit) - val fill_p_constraints : - ((TypedTree.StaticOptimization list -> WriterState -> unit) -> unit) - val p_Vals : (TypedTree.Val list -> WriterState -> unit) - val fill_p_Vals : ((TypedTree.Val list -> WriterState -> unit) -> unit) - val u_binds : (ReaderState -> TypedTree.Bindings) - val fill_u_binds : ((ReaderState -> TypedTree.Bindings) -> unit) - val u_targets : (ReaderState -> TypedTree.DecisionTreeTarget array) - val fill_u_targets : - ((ReaderState -> TypedTree.DecisionTreeTarget array) -> unit) - val u_Exprs : (ReaderState -> TypedTree.Exprs) - val fill_u_Exprs : ((ReaderState -> TypedTree.Exprs) -> unit) - val u_constraints : (ReaderState -> TypedTree.StaticOptimization list) - val fill_u_constraints : - ((ReaderState -> TypedTree.StaticOptimization list) -> unit) - val u_Vals : (ReaderState -> TypedTree.Val list) - val fill_u_Vals : ((ReaderState -> TypedTree.Val list) -> unit) - val p_ArgReprInfo : x:TypedTree.ArgReprInfo -> st:WriterState -> unit - val p_TyparReprInfo : TypedTree.TyparReprInfo -> st:WriterState -> unit - val p_ValReprInfo : TypedTree.ValReprInfo -> st:WriterState -> unit - val u_ArgReprInfo : st:ReaderState -> TypedTree.ArgReprInfo - val u_TyparReprInfo : st:ReaderState -> TypedTree.TyparReprInfo - val u_ValReprInfo : st:ReaderState -> TypedTree.ValReprInfo - val p_ranges : - x:(Range.range * Range.range) option -> st:WriterState -> unit - val p_istype : x:TypedTree.ModuleOrNamespaceKind -> st:WriterState -> unit - val p_cpath : TypedTree.CompilationPath -> st:WriterState -> unit - val u_ranges : st:ReaderState -> (Range.range * Range.range) option - val u_istype : st:ReaderState -> TypedTree.ModuleOrNamespaceKind - val u_cpath : st:ReaderState -> TypedTree.CompilationPath - val dummy : x:'a -> 'a - val p_tycon_repr : x:TypedTree.TyconRepresentation -> st:WriterState -> bool - val p_tycon_objmodel_data : - x:TypedTree.TyconObjModelData -> st:WriterState -> unit - val p_attribs_ext : - f:(WriterState -> unit) option -> - x:TypedTree.Attrib list -> st:WriterState -> unit - val p_unioncase_spec : x:TypedTree.UnionCase -> st:WriterState -> unit - val p_exnc_spec_data : x:TypedTree.Entity -> st:WriterState -> unit - val p_exnc_repr : x:TypedTree.ExceptionInfo -> st:WriterState -> unit - val p_exnc_spec : x:TypedTree.Entity -> st:WriterState -> unit - val p_access : TypedTree.Accessibility -> st:WriterState -> unit - val p_recdfield_spec : x:TypedTree.RecdField -> st:WriterState -> unit - val p_rfield_table : x:TypedTree.TyconRecdFields -> st:WriterState -> unit - val p_entity_spec_data : x:TypedTree.Entity -> st:WriterState -> unit - val p_tcaug : p:TypedTree.TyconAugmentation -> st:WriterState -> unit - val p_entity_spec : x:TypedTree.Entity -> st:WriterState -> unit - val p_parentref : x:TypedTree.ParentRef -> st:WriterState -> unit - val p_attribkind : x:TypedTree.AttribKind -> st:WriterState -> unit - val p_attrib : TypedTree.Attrib -> st:WriterState -> unit - val p_attrib_expr : TypedTree.AttribExpr -> st:WriterState -> unit - val p_attrib_arg : TypedTree.AttribNamedArg -> st:WriterState -> unit - val p_member_info : x:TypedTree.ValMemberInfo -> st:WriterState -> unit - val p_tycon_objmodel_kind : - x:TypedTree.TyconObjModelKind -> st:WriterState -> unit - val p_mustinline : x:TypedTree.ValInline -> st:WriterState -> unit - val p_basethis : x:TypedTree.ValBaseOrThisInfo -> st:WriterState -> unit - val p_vrefFlags : x:TypedTree.ValUseFlag -> st:WriterState -> unit - val p_ValData : x:TypedTree.Val -> st:WriterState -> unit - val p_Val : x:TypedTree.Val -> st:WriterState -> unit - val p_modul_typ : - x:TypedTree.ModuleOrNamespaceType -> st:WriterState -> unit - val u_tycon_repr : st:ReaderState -> (bool -> TypedTree.TyconRepresentation) - val u_tycon_objmodel_data : st:ReaderState -> TypedTree.TyconObjModelData - val u_attribs_ext : - extraf:(ReaderState -> 'a) -> - st:ReaderState -> 'a option * TypedTree.Attrib list - val u_unioncase_spec : st:ReaderState -> TypedTree.UnionCase - val u_exnc_spec_data : st:ReaderState -> TypedTree.Entity - val u_exnc_repr : st:ReaderState -> TypedTree.ExceptionInfo - val u_exnc_spec : st:ReaderState -> TypedTree.Tycon - val u_access : st:ReaderState -> TypedTree.Accessibility - val u_recdfield_spec : st:ReaderState -> TypedTree.RecdField - val u_rfield_table : st:ReaderState -> TypedTree.TyconRecdFields - val u_entity_spec_data : st:ReaderState -> TypedTree.Entity - val u_tcaug : st:ReaderState -> TypedTree.TyconAugmentation - val u_entity_spec : st:ReaderState -> TypedTree.Tycon - val u_parentref : st:ReaderState -> TypedTree.ParentRef - val u_attribkind : st:ReaderState -> TypedTree.AttribKind - val u_attrib : st:ReaderState -> TypedTree.Attrib - val u_attrib_expr : st:ReaderState -> TypedTree.AttribExpr - val u_attrib_arg : st:ReaderState -> TypedTree.AttribNamedArg - val u_member_info : st:ReaderState -> TypedTree.ValMemberInfo - val u_tycon_objmodel_kind : st:ReaderState -> TypedTree.TyconObjModelKind - val u_mustinline : st:ReaderState -> TypedTree.ValInline - val u_basethis : st:ReaderState -> TypedTree.ValBaseOrThisInfo - val u_vrefFlags : st:ReaderState -> TypedTree.ValUseFlag - val u_ValData : st:ReaderState -> TypedTree.Val - val u_Val : st:ReaderState -> TypedTree.Val - val u_modul_typ : st:ReaderState -> TypedTree.ModuleOrNamespaceType - val p_const : (TypedTree.Const -> WriterState -> unit) - val u_const : (ReaderState -> TypedTree.Const) - val p_dtree : x:TypedTree.DecisionTree -> st:WriterState -> unit - val p_dtree_case : TypedTree.DecisionTreeCase -> st:WriterState -> unit - val p_dtree_discrim : x:TypedTree.DecisionTreeTest -> st:WriterState -> unit - val p_target : TypedTree.DecisionTreeTarget -> st:WriterState -> unit - val p_bind : TypedTree.Binding -> st:WriterState -> unit - val p_lval_op_kind : x:TypedTree.LValueOperation -> st:WriterState -> unit - val p_recdInfo : - x:TypedTree.RecordConstructionInfo -> st:WriterState -> unit - val u_dtree : st:ReaderState -> TypedTree.DecisionTree - val u_dtree_case : st:ReaderState -> TypedTree.DecisionTreeCase - val u_dtree_discrim : st:ReaderState -> TypedTree.DecisionTreeTest - val u_target : st:ReaderState -> TypedTree.DecisionTreeTarget - val u_bind : st:ReaderState -> TypedTree.Binding - val u_lval_op_kind : st:ReaderState -> TypedTree.LValueOperation - val p_op : x:TypedTree.TOp -> st:WriterState -> unit - val u_op : st:ReaderState -> TypedTree.TOp - val p_expr : (TypedTree.Expr -> WriterState -> unit) - val u_expr : (ReaderState -> TypedTree.Expr) - val p_static_optimization_constraint : - x:TypedTree.StaticOptimization -> st:WriterState -> unit - val p_slotparam : TypedTree.SlotParam -> st:WriterState -> unit - val p_slotsig : TypedTree.SlotSig -> st:WriterState -> unit - val p_method : TypedTree.ObjExprMethod -> st:WriterState -> unit - val p_methods : x:TypedTree.ObjExprMethod list -> st:WriterState -> unit - val p_intf : - TypedTree.TType * TypedTree.ObjExprMethod list -> st:WriterState -> unit - val p_intfs : - x:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> - st:WriterState -> unit - val u_static_optimization_constraint : - st:ReaderState -> TypedTree.StaticOptimization - val u_slotparam : st:ReaderState -> TypedTree.SlotParam - val u_slotsig : st:ReaderState -> TypedTree.SlotSig - val u_method : st:ReaderState -> TypedTree.ObjExprMethod - val u_methods : st:ReaderState -> TypedTree.ObjExprMethod list - val u_intf : - st:ReaderState -> TypedTree.TType * TypedTree.ObjExprMethod list - val u_intfs : - st:ReaderState -> (TypedTree.TType * TypedTree.ObjExprMethod list) list - val pickleModuleOrNamespace : - mspec:TypedTree.Entity -> st:WriterState -> unit - val pickleCcuInfo : (TypedTree.PickledCcuInfo -> WriterState -> unit) - val unpickleModuleOrNamespace : st:ReaderState -> TypedTree.Tycon - val unpickleCcuInfo : ReaderState -> TypedTree.PickledCcuInfo - end - -namespace FSharp.Compiler - module internal Import = begin - type AssemblyLoader = - interface - abstract member - FindCcuFromAssemblyRef : AbstractIL.Internal.Library.CompilationThreadToken * - Range.range * AbstractIL.IL.ILAssemblyRef -> - TypedTree.CcuResolutionResult - abstract member - GetProvidedAssemblyInfo : AbstractIL.Internal.Library.CompilationThreadToken * - Range.range * - Tainted -> - bool * - ExtensionTyping.ProvidedAssemblyStaticLinkingMap option - abstract member - RecordGeneratedTypeRoot : ExtensionTyping.ProviderGeneratedType -> - unit - end - [] - type ImportMap = - class - new : g:TcGlobals.TcGlobals * assemblyLoader:AssemblyLoader -> ImportMap - member - ILTypeRefToTyconRefCache : System.Collections.Concurrent.ConcurrentDictionary - member assemblyLoader : AssemblyLoader - member g : TcGlobals.TcGlobals - end - val CanImportILScopeRef : - env:ImportMap -> m:Range.range -> scoref:AbstractIL.IL.ILScopeRef -> bool - val ImportTypeRefData : - env:ImportMap -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef * path:string [] * - typeName:System.String -> TypedTree.EntityRef - val ImportILTypeRefUncached : - env:ImportMap -> - m:Range.range -> tref:AbstractIL.IL.ILTypeRef -> TypedTree.EntityRef - val ImportILTypeRef : - ImportMap -> Range.range -> AbstractIL.IL.ILTypeRef -> TypedTree.TyconRef - val CanImportILTypeRef : - ImportMap -> Range.range -> AbstractIL.IL.ILTypeRef -> bool - val ImportTyconRefApp : - env:ImportMap -> - tcref:TypedTree.EntityRef -> - tyargs:TypedTree.TType list -> TypedTree.TType - val ImportILType : - ImportMap -> - Range.range -> - TypedTree.TType list -> AbstractIL.IL.ILType -> TypedTree.TType - val CanImportILType : - ImportMap -> Range.range -> AbstractIL.IL.ILType -> bool - val ImportProvidedNamedType : - ImportMap -> - Range.range -> - Tainted -> TypedTree.TyconRef - val ImportProvidedTypeAsILType : - ImportMap -> - Range.range -> - Tainted -> AbstractIL.IL.ILType - val ImportProvidedType : - ImportMap -> - Range.range -> Tainted -> TypedTree.TType - val ImportProvidedMethodBaseAsILMethodRef : - ImportMap -> - Range.range -> - Tainted -> - AbstractIL.IL.ILMethodRef - val ImportILGenericParameters : - (unit -> ImportMap) -> - Range.range -> - AbstractIL.IL.ILScopeRef -> - TypedTree.TType list -> - AbstractIL.IL.ILGenericParameterDefs -> TypedTree.Typar list - val multisetDiscriminateAndMap : - nodef:('Key -> ('Key list * 'Value) list -> 'a) -> - tipf:('Value -> 'a) -> items:('Key list * 'Value) list -> 'a list - when 'Key : equality - val ImportILTypeDef : - amap:(unit -> ImportMap) -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef -> - cpath:TypedTree.CompilationPath -> - enc:AbstractIL.IL.ILTypeDef list -> - nm:string -> tdef:AbstractIL.IL.ILTypeDef -> TypedTree.Entity - val ImportILTypeDefList : - amap:(unit -> ImportMap) -> - m:Range.range -> - cpath:TypedTree.CompilationPath -> - enc:AbstractIL.IL.ILTypeDef list -> - items:(string list * - (string * - Lazy)) list -> - TypedTree.ModuleOrNamespaceType - val ImportILTypeDefs : - amap:(unit -> ImportMap) -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef -> - cpath:TypedTree.CompilationPath -> - enc:AbstractIL.IL.ILTypeDef list -> - tdefs:AbstractIL.IL.ILTypeDefs -> - TypedTree.ModuleOrNamespaceType - val ImportILAssemblyMainTypeDefs : - amap:(unit -> ImportMap) -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef -> - modul:AbstractIL.IL.ILModuleDef -> TypedTree.ModuleOrNamespaceType - val ImportILAssemblyExportedType : - amap:(unit -> ImportMap) -> - m:Range.range -> - auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) -> - scoref:AbstractIL.IL.ILScopeRef -> - exportedType:AbstractIL.IL.ILExportedTypeOrForwarder -> - TypedTree.ModuleOrNamespaceType list - val ImportILAssemblyExportedTypes : - amap:(unit -> ImportMap) -> - m:Range.range -> - auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) -> - scoref:AbstractIL.IL.ILScopeRef -> - exportedTypes:AbstractIL.IL.ILExportedTypesAndForwarders -> - TypedTree.ModuleOrNamespaceType list - val ImportILAssemblyTypeDefs : - amap:(unit -> ImportMap) * m:Range.range * - auxModLoader:(AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) * - aref:AbstractIL.IL.ILAssemblyRef * mainmod:AbstractIL.IL.ILModuleDef -> - TypedTree.ModuleOrNamespaceType - val ImportILAssemblyTypeForwarders : - (unit -> ImportMap) * Range.range * - AbstractIL.IL.ILExportedTypesAndForwarders -> - Map<(string [] * string),Lazy> - val ImportILAssembly : - (unit -> ImportMap) * Range.range * - (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILModuleDef) * - AbstractIL.IL.ILScopeRef * sourceDir:string * filename:string option * - AbstractIL.IL.ILModuleDef * IEvent -> TypedTree.CcuThunk - end - -namespace FSharp.Compiler - module internal Infos = begin - val ImportILType : - scoref:AbstractIL.IL.ILScopeRef -> - amap:Import.ImportMap -> - m:Range.range -> - importInst:TypedTree.TType list -> - ilty:AbstractIL.IL.ILType -> TypedTree.TType - val CanImportILType : - scoref:AbstractIL.IL.ILScopeRef -> - amap:Import.ImportMap -> - m:Range.range -> ilty:AbstractIL.IL.ILType -> bool - val isExnDeclTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val GetSuperTypeOfType : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ty:TypedTree.TType -> TypedTree.TType option - val mkSystemCollectionsGenericIListTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - [] - type SkipUnrefInterfaces = - | Yes - | No - val GetImmediateInterfacesOfType : - skipUnref:SkipUnrefInterfaces -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ty:TypedTree.TType -> TypedTree.TType list - [] - type AllowMultiIntfInstantiations = - | Yes - | No - val private FoldHierarchyOfTypeAux : - followInterfaces:bool -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - skipUnref:SkipUnrefInterfaces -> - visitor:(TypedTree.TType -> 'a -> 'a) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ty:TypedTree.TType -> acc:'a -> 'a - val FoldPrimaryHierarchyOfType : - f:(TypedTree.TType -> 'a -> 'a) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> acc:'a -> 'a - val FoldEntireHierarchyOfType : - f:(TypedTree.TType -> 'a -> 'a) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> acc:'a -> 'a - val IterateEntireHierarchyOfType : - f:(TypedTree.TType -> unit) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> unit - val ExistsInEntireHierarchyOfType : - f:(TypedTree.TType -> bool) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> bool - val SearchEntireHierarchyOfType : - f:(TypedTree.TType -> bool) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ty:TypedTree.TType -> TypedTree.TType option - val AllSuperTypesOfType : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> TypedTree.TType list - val AllInterfacesOfType : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - allowMultiIntfInst:AllowMultiIntfInstantiations -> - ty:TypedTree.TType -> TypedTree.TType list - val HaveSameHeadType : - g:TcGlobals.TcGlobals -> - ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool - val HasHeadType : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> ty2:TypedTree.TType -> bool - val ExistsSameHeadTypeInHierarchy : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - typeToSearchFrom:TypedTree.TType -> - typeToLookFor:TypedTree.TType -> bool - val ExistsHeadTypeInEntireHierarchy : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - typeToSearchFrom:TypedTree.TType -> - tcrefToLookFor:TypedTree.TyconRef -> bool - val ImportILTypeFromMetadata : - amap:Import.ImportMap -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef -> - tinst:TypedTree.TType list -> - minst:TypedTree.TType list -> - ilty:AbstractIL.IL.ILType -> TypedTree.TType - val ImportILTypeFromMetadataWithAttributes : - amap:Import.ImportMap -> - m:Range.range -> - scoref:AbstractIL.IL.ILScopeRef -> - tinst:TypedTree.TType list -> - minst:TypedTree.TType list -> - ilty:AbstractIL.IL.ILType -> - cattrs:AbstractIL.IL.ILAttributes -> TypedTree.TType - val ImportParameterTypeFromMetadata : - amap:Import.ImportMap -> - m:Range.range -> - ilty:AbstractIL.IL.ILType -> - cattrs:AbstractIL.IL.ILAttributes -> - scoref:AbstractIL.IL.ILScopeRef -> - tinst:TypedTree.TType list -> - mist:TypedTree.TType list -> TypedTree.TType - val ImportReturnTypeFromMetadata : - amap:Import.ImportMap -> - m:Range.range -> - ilty:AbstractIL.IL.ILType -> - cattrs:AbstractIL.IL.ILAttributes -> - scoref:AbstractIL.IL.ILScopeRef -> - tinst:TypedTree.TType list -> - minst:TypedTree.TType list -> TypedTree.TType option - val CopyTyparConstraints : - m:Range.range -> - tprefInst:TypedTreeOps.TyparInst -> - tporig:TypedTree.Typar -> TypedTree.TyparConstraint list - val FixupNewTypars : - m:Range.range -> - formalEnclosingTypars:TypedTree.Typars -> - tinst:TypedTree.TType list -> - tpsorig:TypedTree.Typars -> - tps:TypedTree.Typars -> TypedTreeOps.TyparInst * TypedTree.TTypes - type ValRef with - member IsFSharpEventProperty : g:TcGlobals.TcGlobals -> bool - type ValRef with - member IsVirtualMember : bool - type ValRef with - member IsDispatchSlotMember : bool - type ValRef with - member IsDefiniteFSharpOverrideMember : bool - type ValRef with - member - IsFSharpExplicitInterfaceImplementation : g:TcGlobals.TcGlobals -> bool - type ValRef with - member ImplementedSlotSignatures : TypedTree.SlotSig list - val GetCompiledReturnTyOfProvidedMethodInfo : - amap:Import.ImportMap -> - m:Range.range -> - mi:Tainted -> - TypedTree.TType option - val ReparentSlotSigToUseMethodTypars : - g:TcGlobals.TcGlobals -> - m:Range.range -> - ovByMethValRef:TypedTree.ValRef -> - slotsig:TypedTree.SlotSig -> TypedTree.SlotSig - val MakeSlotParam : - ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo -> TypedTree.SlotParam - val MakeSlotSig : - nm:string * ty:TypedTree.TType * ctps:TypedTree.Typars * - mtps:TypedTree.Typars * paraml:TypedTree.SlotParam list list * - retTy:TypedTree.TType option -> TypedTree.SlotSig - val private AnalyzeTypeOfMemberVal : - isCSharpExt:bool -> - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType * vref:TypedTree.ValRef -> - TypedTree.Typar list * TypedTree.Typars * TypedTree.TType option * - TypedTree.TType list - val private GetObjTypeOfInstanceExtensionMethod : - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> TypedTree.TType - val private GetArgInfosOfMember : - isCSharpExt:bool -> - g:TcGlobals.TcGlobals -> - vref:TypedTree.ValRef -> - (TypedTree.TType * TypedTree.ArgReprInfo) list list - val private CombineMethInsts : - ttps:TypedTree.Typars -> - mtps:TypedTree.Typars -> - tinst:TypedTree.TTypes -> - minst:TypedTree.TTypes -> (TypedTree.Typar * TypedTree.TType) list - val private GetInstantiationForMemberVal : - g:TcGlobals.TcGlobals -> - isCSharpExt:bool -> - ty:TypedTree.TType * vref:TypedTree.ValRef * - methTyArgs:TypedTree.TypeInst -> - (TypedTree.Typar * TypedTree.TType) list - val private GetInstantiationForPropertyVal : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType * vref:TypedTree.ValRef -> - (TypedTree.Typar * TypedTree.TType) list - type ExtensionMethodPriority = uint64 - type OptionalArgCallerSideValue = - | Constant of AbstractIL.IL.ILFieldInit - | DefaultValue - | MissingValue - | WrapperForIDispatch - | WrapperForIUnknown - | PassByRef of TypedTree.TType * OptionalArgCallerSideValue - type OptionalArgInfo = - | NotOptional - | CalleeSide - | CallerSide of OptionalArgCallerSideValue - with - static member - FieldInitForDefaultParameterValueAttrib : attrib:TypedTree.Attrib -> - AbstractIL.IL.ILFieldInit option - static member - FromILParameter : g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - ilScope:AbstractIL.IL.ILScopeRef -> - ilTypeInst:TypedTree.TType list -> - ilParam:AbstractIL.IL.ILParameter -> - OptionalArgInfo - static member - ValueOfDefaultParameterValueAttrib : TypedTree.Attrib -> - TypedTree.Expr option - member IsOptional : bool - end - type CallerInfo = - | NoCallerInfo - | CallerLineNumber - | CallerMemberName - | CallerFilePath - with - override ToString : unit -> string - end - [] - type ReflectedArgInfo = - | None - | Quote of bool - with - member AutoQuote : bool - end - [] - type ParamNameAndType = - | ParamNameAndType of SyntaxTree.Ident option * TypedTree.TType - with - static member - FromArgInfo : ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo -> - ParamNameAndType - static member - FromMember : isCSharpExtMem:bool -> - g:TcGlobals.TcGlobals -> - vref:TypedTree.ValRef -> ParamNameAndType list list - static member - Instantiate : inst:TypedTreeOps.TyparInst -> - p:ParamNameAndType -> ParamNameAndType - static member - InstantiateCurried : inst:TypedTreeOps.TyparInst -> - paramTypes:ParamNameAndType list list -> - ParamNameAndType list list - end - [] - type ParamData = - | ParamData of - isParamArray: bool * isInArg: bool * isOut: bool * - optArgInfo: OptionalArgInfo * callerInfo: CallerInfo * - nameOpt: SyntaxTree.Ident option * reflArgInfo: ReflectedArgInfo * - ttype: TypedTree.TType - type ILFieldInit with - static member - FromProvidedObj : m:Range.range -> v:obj -> AbstractIL.IL.ILFieldInit - val OptionalArgInfoOfProvidedParameter : - amap:Import.ImportMap -> - m:Range.range -> - provParam:Tainted -> - OptionalArgInfo - val GetAndSanityCheckProviderMethod : - m:Range.range -> - mi:Tainted<'T> -> - get:('T -> ExtensionTyping.ProvidedMethodInfo) -> - err:(string * string -> int * string) -> - Tainted - when 'T :> ExtensionTyping.ProvidedMemberInfo - val ArbitraryMethodInfoOfPropertyInfo : - pi:Tainted -> - m:Range.range -> Tainted - [] - type ILTypeInfo = - | ILTypeInfo of - TcGlobals.TcGlobals * TypedTree.TType * AbstractIL.IL.ILTypeRef * - AbstractIL.IL.ILTypeDef - with - static member - FromType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> ILTypeInfo - member Instantiate : inst:TypedTreeOps.TyparInst -> ILTypeInfo - member ILScopeRef : AbstractIL.IL.ILScopeRef - member ILTypeRef : AbstractIL.IL.ILTypeRef - member IsValueType : bool - member Name : string - member RawMetadata : AbstractIL.IL.ILTypeDef - member TcGlobals : TcGlobals.TcGlobals - member ToAppType : TypedTree.TType - member ToType : TypedTree.TType - member TyconRefOfRawMetadata : TypedTree.TyconRef - member TypeInstOfRawMetadata : TypedTree.TypeInst - end - [] - type ILMethInfo = - | ILMethInfo of - g: TcGlobals.TcGlobals * ilApparentType: TypedTree.TType * - ilDeclaringTyconRefOpt: TypedTree.TyconRef option * - ilMethodDef: AbstractIL.IL.ILMethodDef * - ilGenericMethodTyArgs: TypedTree.Typars - with - member - GetCompiledReturnTy : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> - TypedTree.TType option - member - GetFSharpReturnTy : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> TypedTree.TType - member - GetObjArgTypes : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> TypedTree.TType list - member - GetParamNamesAndTypes : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> - ParamNameAndType list - member - GetParamTypes : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> TypedTree.TType list - member - GetRawArgTypes : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> TypedTree.TType list - member IsDllImport : g:TcGlobals.TcGlobals -> bool - member IsReadOnly : g:TcGlobals.TcGlobals -> bool - member ApparentEnclosingAppType : TypedTree.TType - member ApparentEnclosingType : TypedTree.TType - member DeclaringTyconRef : TypedTree.TyconRef - member DeclaringTypeInst : TypedTree.TType list - member FormalMethodTypars : TypedTree.Typars - member ILExtensionMethodDeclaringTyconRef : TypedTree.TyconRef option - member ILMethodRef : AbstractIL.IL.ILMethodRef - member ILName : string - member IsAbstract : bool - member IsClassConstructor : bool - member IsConstructor : bool - member IsFinal : bool - member IsILExtensionMethod : bool - member IsInstance : bool - member IsNewSlot : bool - member IsProtectedAccessibility : bool - member IsStatic : bool - member IsVirtual : bool - member MetadataScope : AbstractIL.IL.ILScopeRef - member NumParams : int - member ParamMetadata : AbstractIL.IL.ILParameter list - member RawMetadata : AbstractIL.IL.ILMethodDef - member TcGlobals : TcGlobals.TcGlobals - end - [] - type MethInfo = - | FSMeth of - tcGlobals: TcGlobals.TcGlobals * enclosingType: TypedTree.TType * - valRef: TypedTree.ValRef * - extensionMethodPriority: ExtensionMethodPriority option - | ILMeth of - tcGlobals: TcGlobals.TcGlobals * ilMethInfo: ILMethInfo * - extensionMethodPriority: ExtensionMethodPriority option - | DefaultStructCtor of - tcGlobals: TcGlobals.TcGlobals * structTy: TypedTree.TType - | ProvidedMeth of - amap: Import.ImportMap * - methodBase: Tainted * - extensionMethodPriority: ExtensionMethodPriority option * m: Range.range - with - static member - CreateILExtensionMeth : amap:Import.ImportMap * m:Range.range * - apparentTy:TypedTree.TType * - declaringTyconRef:TypedTree.TyconRef * - extMethPri:ExtensionMethodPriority option * - md:AbstractIL.IL.ILMethodDef -> MethInfo - static member - CreateILMeth : amap:Import.ImportMap * m:Range.range * - ty:TypedTree.TType * md:AbstractIL.IL.ILMethodDef -> - MethInfo - static member - MethInfosUseIdenticalDefinitions : x1:MethInfo -> x2:MethInfo -> bool - member - AdjustUserTypeInstForFSharpStyleIndexedExtensionMembers : tyargs:TypedTree.TType list -> - TypedTree.TType list - member ComputeHashCode : unit -> int - member - GetCompiledReturnTy : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> - TypedTree.TType option - member - GetFSharpReturnTy : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> TypedTree.TType - member - GetFormalTyparsOfDeclaringType : m:Range.range -> TypedTree.Typar list - member - GetObjArgTypes : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TypeInst -> TypedTree.TType list - member - GetParamAttribs : amap:Import.ImportMap * m:Range.range -> - (bool * bool * bool * OptionalArgInfo * CallerInfo * - ReflectedArgInfo) list list - member - GetParamDatas : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> ParamData list list - member - GetParamTypes : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> - TypedTree.TType list list - member - GetSlotSig : amap:Import.ImportMap * m:Range.range -> - TypedTree.SlotSig - member - HasParamArrayArg : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TType list -> bool - member - Instantiate : amap:Import.ImportMap * m:Range.range * - inst:TypedTreeOps.TyparInst -> MethInfo - member - IsReadOnlyExtensionMember : amap:Import.ImportMap * m:Range.range -> - bool - member - ObjArgNeedsAddress : amap:Import.ImportMap * m:Range.range -> bool - override ToString : unit -> string - member - TryObjArgByrefType : amap:Import.ImportMap * m:Range.range * - minst:TypedTree.TypeInst -> - TypedTree.TType option - member ApparentEnclosingAppType : TypedTree.TType - member ApparentEnclosingTyconRef : TypedTree.TyconRef - member ApparentEnclosingType : TypedTree.TType - member ArbitraryValRef : TypedTree.ValRef option - member DebuggerDisplayName : string - member DeclaringTyconRef : TypedTree.TyconRef - member DeclaringTypeInst : TypedTree.TType list - member DisplayName : string - member ExtensionMemberPriority : ExtensionMethodPriority - member ExtensionMemberPriorityOption : ExtensionMethodPriority option - member FormalMethodInst : TypedTree.TypeInst - member FormalMethodTyparInst : TypedTreeOps.TyparInst - member FormalMethodTypars : TypedTree.Typars - member GenericArity : int - member HasDirectXmlComment : bool - member ImplementedSlotSignatures : TypedTree.SlotSig list - member IsAbstract : bool - member IsCSharpStyleExtensionMember : bool - member IsClassConstructor : bool - member IsConstructor : bool - member IsCurried : bool - member IsDefiniteFSharpOverride : bool - member IsDispatchSlot : bool - member IsExtensionMember : bool - member IsFSharpEventPropertyMethod : bool - member IsFSharpExplicitInterfaceImplementation : bool - member IsFSharpStyleExtensionMember : bool - member IsFinal : bool - member IsILMethod : bool - member IsInstance : bool - member IsNewSlot : bool - member IsNullary : bool - member IsProtectedAccessibility : bool - member IsReadOnly : bool - member IsStruct : bool - member IsVirtual : bool - member LogicalName : string - member NumArgs : int list - member - ProvidedStaticParameterInfo : (Tainted * - Tainted []) option - member TcGlobals : TcGlobals.TcGlobals - member XmlDoc : XmlDoc.XmlDoc - end - [] - type ILFieldInfo = - | ILFieldInfo of - ilTypeInfo: ILTypeInfo * ilFieldDef: AbstractIL.IL.ILFieldDef - | ProvidedField of - amap: Import.ImportMap * - providedField: Tainted * - range: Range.range - with - static member - ILFieldInfosUseIdenticalDefinitions : x1:ILFieldInfo -> - x2:ILFieldInfo -> bool - member ComputeHashCode : unit -> int - member - FieldType : amap:Import.ImportMap * m:Range.range -> TypedTree.TType - override ToString : unit -> string - member ApparentEnclosingAppType : TypedTree.TType - member ApparentEnclosingTyconRef : TypedTree.TyconRef - member ApparentEnclosingType : TypedTree.TType - member DeclaringTyconRef : TypedTree.TyconRef - member FieldName : string - member ILFieldRef : AbstractIL.IL.ILFieldRef - member ILFieldType : AbstractIL.IL.ILType - member ILTypeRef : AbstractIL.IL.ILTypeRef - member IsInitOnly : bool - member IsSpecialName : bool - member IsStatic : bool - member IsValueType : bool - member LiteralValue : AbstractIL.IL.ILFieldInit option - member ScopeRef : AbstractIL.IL.ILScopeRef - member TcGlobals : TcGlobals.TcGlobals - member TypeInst : TypedTree.TypeInst - end - [] - type RecdFieldInfo = - | RecdFieldInfo of - typeInst: TypedTree.TypeInst * recdFieldRef: TypedTree.RecdFieldRef - with - override ToString : unit -> string - member DeclaringType : TypedTree.TType - member FieldType : TypedTree.TType - member IsStatic : bool - member LiteralValue : TypedTree.Const option - member Name : string - member RecdField : TypedTree.RecdField - member RecdFieldRef : TypedTree.RecdFieldRef - member Tycon : TypedTree.Entity - member TyconRef : TypedTree.TyconRef - member TypeInst : TypedTree.TypeInst - end - [] - type UnionCaseInfo = - | UnionCaseInfo of TypedTree.TypeInst * TypedTree.UnionCaseRef - with - member GetTyparInst : m:Range.range -> TypedTreeOps.TyparInst - override ToString : unit -> string - member Name : string - member Tycon : TypedTree.Entity - member TyconRef : TypedTree.TyconRef - member TypeInst : TypedTree.TypeInst - member UnionCase : TypedTree.UnionCase - member UnionCaseRef : TypedTree.UnionCaseRef - end - [] - type ILPropInfo = - | ILPropInfo of - ilTypeInfo: ILTypeInfo * ilPropertyDef: AbstractIL.IL.ILPropertyDef - with - member - GetParamNamesAndTypes : amap:Import.ImportMap * m:Range.range -> - ParamNameAndType list - member - GetParamTypes : amap:Import.ImportMap * m:Range.range -> - TypedTree.TType list - member - GetPropertyType : amap:Import.ImportMap * m:Range.range -> - TypedTree.TType - override ToString : unit -> string - member ApparentEnclosingAppType : TypedTree.TType - member ApparentEnclosingType : TypedTree.TType - member GetterMethod : ILMethInfo - member HasGetter : bool - member HasSetter : bool - member ILTypeInfo : ILTypeInfo - member IsNewSlot : bool - member IsStatic : bool - member IsVirtual : bool - member PropertyName : string - member RawMetadata : AbstractIL.IL.ILPropertyDef - member SetterMethod : ILMethInfo - member TcGlobals : TcGlobals.TcGlobals - end - [] - type PropInfo = - | FSProp of - tcGlobals: TcGlobals.TcGlobals * apparentEnclTy: TypedTree.TType * - getter: TypedTree.ValRef option * setter: TypedTree.ValRef option - | ILProp of ilPropInfo: ILPropInfo - | ProvidedProp of - amap: Import.ImportMap * - providedProp: Tainted * - range: Range.range - with - static member - PropInfosUseIdenticalDefinitions : x1:PropInfo -> x2:PropInfo -> bool - member ComputeHashCode : unit -> int - member DropGetter : unit -> PropInfo - member DropSetter : unit -> PropInfo - member - GetParamDatas : amap:Import.ImportMap * m:Range.range -> - ParamData list - member - GetParamNamesAndTypes : amap:Import.ImportMap * m:Range.range -> - ParamNameAndType list - member - GetParamTypes : amap:Import.ImportMap * m:Range.range -> - TypedTree.TType list - member - GetPropertyType : amap:Import.ImportMap * m:Range.range -> - TypedTree.TType - override ToString : unit -> string - member ApparentEnclosingAppType : TypedTree.TType - member ApparentEnclosingTyconRef : TypedTree.TyconRef - member ApparentEnclosingType : TypedTree.TType - member ArbitraryValRef : TypedTree.ValRef option - member DeclaringTyconRef : TypedTree.EntityRef - member GetterMethod : MethInfo - member HasDirectXmlComment : bool - member HasGetter : bool - member HasSetter : bool - member ImplementedSlotSignatures : TypedTree.SlotSig list - member IsDefiniteFSharpOverride : bool - member IsDispatchSlot : bool - member IsExtensionMember : bool - member IsFSharpEventProperty : bool - member IsFSharpExplicitInterfaceImplementation : bool - member IsIndexer : bool - member IsNewSlot : bool - member IsStatic : bool - member IsValueType : bool - member IsVirtualProperty : bool - member PropertyName : string - member SetterMethod : MethInfo - member TcGlobals : TcGlobals.TcGlobals - member XmlDoc : XmlDoc.XmlDoc - end - [] - type ILEventInfo = - | ILEventInfo of - ilTypeInfo: ILTypeInfo * ilEventDef: AbstractIL.IL.ILEventDef - with - override ToString : unit -> string - member AddMethod : ILMethInfo - member ApparentEnclosingAppType : TypedTree.TType - member ApparentEnclosingType : TypedTree.TType - member DeclaringTyconRef : TypedTree.TyconRef - member ILTypeInfo : ILTypeInfo - member IsStatic : bool - member Name : string - member RawMetadata : AbstractIL.IL.ILEventDef - member RemoveMethod : ILMethInfo - member TcGlobals : TcGlobals.TcGlobals - member TypeRef : AbstractIL.IL.ILTypeRef - end - exception BadEventTransformation of Range.range - val private tyConformsToIDelegateEvent : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val nonStandardEventError : nm:System.String -> m:Range.range -> exn - val FindDelegateTypeOfPropertyEvent : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - nm:System.String -> - m:Range.range -> ty:TypedTree.TType -> TypedTree.TType - [] - type EventInfo = - | FSEvent of - tcGlobals: TcGlobals.TcGlobals * propInfo: PropInfo * - addMethod: TypedTree.ValRef * removeMethod: TypedTree.ValRef - | ILEvent of ilEventInfo: ILEventInfo - | ProvidedEvent of - amap: Import.ImportMap * - providedEvent: Tainted * - range: Range.range - with - static member - EventInfosUseIdenticalDefinitions : x1:EventInfo -> - x2:EventInfo -> bool - member ComputeHashCode : unit -> int - member - GetDelegateType : amap:Import.ImportMap * m:Range.range -> - TypedTree.TType - override ToString : unit -> string - member AddMethod : MethInfo - member ApparentEnclosingAppType : TypedTree.TType - member ApparentEnclosingTyconRef : TypedTree.TyconRef - member ApparentEnclosingType : TypedTree.TType - member ArbitraryValRef : TypedTree.ValRef option - member DeclaringTyconRef : TypedTree.EntityRef - member EventName : string - member HasDirectXmlComment : bool - member IsExtensionMember : bool - member IsStatic : bool - member IsValueType : bool - member RemoveMethod : MethInfo - member TcGlobals : TcGlobals.TcGlobals - member XmlDoc : XmlDoc.XmlDoc - end - val stripByrefTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - type CompiledSig = - | CompiledSig of - argTys: TypedTree.TType list list * returnTy: TypedTree.TType option * - formalMethTypars: TypedTree.Typars * - formalMethTyparInst: TypedTreeOps.TyparInst - val CompiledSigOfMeth : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> m:Range.range -> minfo:MethInfo -> CompiledSig - val MethInfosEquivByPartialSig : - erasureFlag:TypedTreeOps.Erasure -> - ignoreFinal:bool -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool - val MethInfosEquivByNameAndPartialSig : - erasureFlag:TypedTreeOps.Erasure -> - ignoreFinal:bool -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool - val PropInfosEquivByNameAndPartialSig : - erasureFlag:TypedTreeOps.Erasure -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> pinfo:PropInfo -> pinfo2:PropInfo -> bool - val MethInfosEquivByNameAndSig : - erasureFlag:TypedTreeOps.Erasure -> - ignoreFinal:bool -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> minfo:MethInfo -> minfo2:MethInfo -> bool - val PropInfosEquivByNameAndSig : - erasureFlag:TypedTreeOps.Erasure -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> pinfo:PropInfo -> pinfo2:PropInfo -> bool - val SettersOfPropInfos : - pinfos:PropInfo list -> (MethInfo * PropInfo option) list - val GettersOfPropInfos : - pinfos:PropInfo list -> (MethInfo * PropInfo option) list - end - -namespace FSharp.Compiler - module internal AccessibilityLogic = begin - [] - type AccessorDomain = - | AccessibleFrom of - cpaths: TypedTree.CompilationPath list * - tyconRefOpt: TypedTree.TyconRef option - | AccessibleFromEverywhere - | AccessibleFromSomeFSharpCode - | AccessibleFromSomewhere - with - static member - CustomEquals : g:TcGlobals.TcGlobals * ad1:AccessorDomain * - ad2:AccessorDomain -> bool - static member CustomGetHashCode : ad:AccessorDomain -> int - end - val IsAccessible : - ad:AccessorDomain -> taccess:TypedTree.Accessibility -> bool - val private IsILMemberAccessible : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - tcrefOfViewedItem:TypedTree.TyconRef -> - ad:AccessorDomain -> access:AbstractIL.IL.ILMemberAccess -> bool - val private IsILTypeDefAccessible : - amap:Import.ImportMap -> - m:Range.range -> - ad:AccessorDomain -> - encTyconRefOpt:TypedTree.TyconRef option -> - tdef:AbstractIL.IL.ILTypeDef -> bool - val private IsTyconAccessibleViaVisibleTo : - ad:AccessorDomain -> tcrefOfViewedItem:TypedTree.TyconRef -> bool - val private IsILTypeInfoAccessible : - amap:Import.ImportMap -> - m:Range.range -> - ad:AccessorDomain -> tcrefOfViewedItem:TypedTree.TyconRef -> bool - val private IsILTypeAndMemberAccessible : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - adType:AccessorDomain -> - ad:AccessorDomain -> - ty:Infos.ILTypeInfo -> - access:AbstractIL.IL.ILMemberAccess -> bool - val IsEntityAccessible : - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool - val CheckTyconAccessible : - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool - val IsTyconReprAccessible : - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool - val CheckTyconReprAccessible : - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> tcref:TypedTree.TyconRef -> bool - val IsTypeAccessible : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> ty:TypedTree.TType -> bool - val IsTypeInstAccessible : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> tinst:TypedTree.TypeInst -> bool - val IsProvidedMemberAccessible : - amap:Import.ImportMap -> - m:Range.range -> - ad:AccessorDomain -> - ty:TypedTree.TType -> access:AbstractIL.IL.ILMemberAccess -> bool - val ComputeILAccess : - isPublic:bool -> - isFamily:bool -> - isFamilyOrAssembly:bool -> - isFamilyAndAssembly:bool -> AbstractIL.IL.ILMemberAccess - val IsILFieldInfoAccessible : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> x:Infos.ILFieldInfo -> bool - val GetILAccessOfILEventInfo : - Infos.ILEventInfo -> AbstractIL.IL.ILMemberAccess - val IsILEventInfoAccessible : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> einfo:Infos.ILEventInfo -> bool - val private IsILMethInfoAccessible : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - adType:AccessorDomain -> - ad:AccessorDomain -> ilminfo:Infos.ILMethInfo -> bool - val GetILAccessOfILPropInfo : - Infos.ILPropInfo -> AbstractIL.IL.ILMemberAccess - val IsILPropInfoAccessible : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> pinfo:Infos.ILPropInfo -> bool - val IsValAccessible : ad:AccessorDomain -> vref:TypedTree.ValRef -> bool - val CheckValAccessible : - m:Range.range -> ad:AccessorDomain -> vref:TypedTree.ValRef -> unit - val IsUnionCaseAccessible : - amap:Import.ImportMap -> - m:Range.range -> - ad:AccessorDomain -> ucref:TypedTree.UnionCaseRef -> bool - val CheckUnionCaseAccessible : - amap:Import.ImportMap -> - m:Range.range -> - ad:AccessorDomain -> ucref:TypedTree.UnionCaseRef -> bool - val IsRecdFieldAccessible : - amap:Import.ImportMap -> - m:Range.range -> - ad:AccessorDomain -> rfref:TypedTree.RecdFieldRef -> bool - val CheckRecdFieldAccessible : - amap:Import.ImportMap -> - m:Range.range -> - ad:AccessorDomain -> rfref:TypedTree.RecdFieldRef -> bool - val CheckRecdFieldInfoAccessible : - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> rfinfo:Infos.RecdFieldInfo -> unit - val CheckILFieldInfoAccessible : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> finfo:Infos.ILFieldInfo -> unit - val IsTypeAndMethInfoAccessible : - amap:Import.ImportMap -> - m:Range.range -> - accessDomainTy:AccessorDomain -> - ad:AccessorDomain -> _arg1:Infos.MethInfo -> bool - val IsMethInfoAccessible : - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> minfo:Infos.MethInfo -> bool - val IsPropInfoAccessible : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ad:AccessorDomain -> _arg1:Infos.PropInfo -> bool - val IsFieldInfoAccessible : - ad:AccessorDomain -> rfref:Infos.RecdFieldInfo -> bool - end - -namespace FSharp.Compiler - module internal AttributeChecking = begin - exception ObsoleteWarning of string * Range.range - exception ObsoleteError of string * Range.range - val fail : unit -> 'a - val private evalILAttribElem : e:AbstractIL.IL.ILAttribElem -> obj - val private evalFSharpAttribArg : - g:TcGlobals.TcGlobals -> e:TypedTree.Expr -> obj - type AttribInfo = - | FSAttribInfo of TcGlobals.TcGlobals * TypedTree.Attrib - | ILAttribInfo of - TcGlobals.TcGlobals * Import.ImportMap * AbstractIL.IL.ILScopeRef * - AbstractIL.IL.ILAttribute * Range.range - with - member ConstructorArguments : (TypedTree.TType * obj) list - member NamedArguments : (TypedTree.TType * string * bool * obj) list - member Range : Range.range - member TyconRef : TypedTree.TyconRef - end - val AttribInfosOfIL : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - scoref:AbstractIL.IL.ILScopeRef -> - m:Range.range -> - attribs:AbstractIL.IL.ILAttributes -> AttribInfo list - val AttribInfosOfFS : - g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> AttribInfo list - val GetAttribInfosOfEntity : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> tcref:TypedTree.TyconRef -> AttribInfo list - val GetAttribInfosOfMethod : - amap:Import.ImportMap -> - m:Range.range -> minfo:Infos.MethInfo -> AttribInfo list - val GetAttribInfosOfProp : - amap:Import.ImportMap -> - m:Range.range -> pinfo:Infos.PropInfo -> AttribInfo list - val GetAttribInfosOfEvent : - amap:Import.ImportMap -> - m:Range.range -> einfo:Infos.EventInfo -> AttribInfo list - val TryBindTyconRefAttribute : - g:TcGlobals.TcGlobals -> - m:Range.range -> - TcGlobals.BuiltinAttribInfo -> - tcref:TypedTree.TyconRef -> - f1:(AbstractIL.IL.ILAttribElem list * - AbstractIL.IL.ILAttributeNamedArg list -> 'a option) -> - f2:(TypedTree.Attrib -> 'a option) -> - f3:(obj option list * (string * obj option) list -> 'a option) -> - 'a option - val BindMethInfoAttributes : - m:Range.range -> - minfo:Infos.MethInfo -> - f1:(AbstractIL.IL.ILAttributes -> 'a) -> - f2:(TypedTree.Attrib list -> 'a) -> - f3:(Tainted -> - 'a) -> 'a - val TryBindMethInfoAttribute : - g:TcGlobals.TcGlobals -> - m:Range.range -> - TcGlobals.BuiltinAttribInfo -> - minfo:Infos.MethInfo -> - f1:(AbstractIL.IL.ILAttribElem list * - AbstractIL.IL.ILAttributeNamedArg list -> 'a option) -> - f2:(TypedTree.Attrib -> 'a option) -> - f3:(obj option list * (string * obj option) list -> 'a option) -> - 'a option - val TryFindMethInfoStringAttribute : - g:TcGlobals.TcGlobals -> - m:Range.range -> - attribSpec:TcGlobals.BuiltinAttribInfo -> - minfo:Infos.MethInfo -> string option - val MethInfoHasAttribute : - g:TcGlobals.TcGlobals -> - m:Range.range -> - attribSpec:TcGlobals.BuiltinAttribInfo -> minfo:Infos.MethInfo -> bool - val private CheckILAttributes : - g:TcGlobals.TcGlobals -> - isByrefLikeTyconRef:bool -> - cattrs:AbstractIL.IL.ILAttributes -> - m:Range.range -> ErrorLogger.OperationResult - val langVersionPrefix : string - val CheckFSharpAttributes : - g:TcGlobals.TcGlobals -> - attribs:TypedTree.Attrib list -> - m:Range.range -> ErrorLogger.OperationResult - val private CheckProvidedAttributes : - g:TcGlobals.TcGlobals -> - m:Range.range -> - provAttribs:Tainted -> - ErrorLogger.OperationResult - val CheckILAttributesForUnseen : - g:TcGlobals.TcGlobals -> - cattrs:AbstractIL.IL.ILAttributes -> _m:'a -> bool - val CheckFSharpAttributesForHidden : - g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> bool - val CheckFSharpAttributesForObsolete : - g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> bool - val CheckFSharpAttributesForUnseen : - g:TcGlobals.TcGlobals -> attribs:TypedTree.Attrib list -> _m:'a -> bool - val CheckProvidedAttributesForUnseen : - provAttribs:Tainted -> - m:Range.range -> bool - val CheckPropInfoAttributes : - pinfo:Infos.PropInfo -> m:Range.range -> ErrorLogger.OperationResult - val CheckILFieldAttributes : - g:TcGlobals.TcGlobals -> finfo:Infos.ILFieldInfo -> m:Range.range -> unit - val CheckMethInfoAttributes : - g:TcGlobals.TcGlobals -> - m:Range.range -> - tyargsOpt:'a option -> - minfo:Infos.MethInfo -> ErrorLogger.OperationResult - val MethInfoIsUnseen : - g:TcGlobals.TcGlobals -> - m:Range.range -> ty:TypedTree.TType -> minfo:Infos.MethInfo -> bool - val PropInfoIsUnseen : m:'a -> pinfo:Infos.PropInfo -> bool - val CheckEntityAttributes : - g:TcGlobals.TcGlobals -> - x:TypedTree.TyconRef -> - m:Range.range -> ErrorLogger.OperationResult - val CheckUnionCaseAttributes : - g:TcGlobals.TcGlobals -> - x:TypedTree.UnionCaseRef -> - m:Range.range -> ErrorLogger.OperationResult - val CheckRecdFieldAttributes : - g:TcGlobals.TcGlobals -> - x:TypedTree.RecdFieldRef -> - m:Range.range -> ErrorLogger.OperationResult - val CheckValAttributes : - g:TcGlobals.TcGlobals -> - x:TypedTree.ValRef -> m:Range.range -> ErrorLogger.OperationResult - val CheckRecdFieldInfoAttributes : - g:TcGlobals.TcGlobals -> - x:Infos.RecdFieldInfo -> - m:Range.range -> ErrorLogger.OperationResult - val IsSecurityAttribute : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - casmap:System.Collections.Generic.Dictionary -> - TypedTree.Attrib -> m:Range.range -> bool - val IsSecurityCriticalAttribute : - g:TcGlobals.TcGlobals -> TypedTree.Attrib -> bool - end - -namespace FSharp.Compiler - module internal TypeRelations = begin - val TypeDefinitelySubsumesTypeNoCoercion : - ndeep:int -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool - type CanCoerce = - | CanCoerce - | NoCoerce - val TypesFeasiblyEquivalent : - stripMeasures:bool -> - ndeep:int -> - g:TcGlobals.TcGlobals -> - amap:'a -> - m:Range.range -> - ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool - val TypesFeasiblyEquiv : - ndeep:int -> - g:TcGlobals.TcGlobals -> - amap:'a -> - m:Range.range -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool - val TypesFeasiblyEquivStripMeasures : - g:TcGlobals.TcGlobals -> - amap:'a -> - m:Range.range -> ty1:TypedTree.TType -> ty2:TypedTree.TType -> bool - val TypeFeasiblySubsumesType : - ndeep:int -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - ty1:TypedTree.TType -> - canCoerce:CanCoerce -> ty2:TypedTree.TType -> bool - val ChooseTyparSolutionAndRange : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - tp:TypedTree.Typar -> TypedTree.TType * Range.range - val ChooseTyparSolution : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> tp:TypedTree.Typar -> TypedTree.TType - val IterativelySubstituteTyparSolutions : - g:TcGlobals.TcGlobals -> - tps:TypedTree.Typars -> solutions:TypedTree.TTypes -> TypedTree.TypeInst - val ChooseTyparSolutionsForFreeChoiceTypars : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> e:TypedTree.Expr -> TypedTree.Expr - val tryDestTopLambda : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - TypedTree.ValReprInfo -> - e:TypedTree.Expr * ty:TypedTree.TType -> - (TypedTree.Typars * TypedTree.Val option * TypedTree.Val option * - TypedTree.Val list list * TypedTree.Expr * TypedTree.TType) option - val destTopLambda : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - topValInfo:TypedTree.ValReprInfo -> - e:TypedTree.Expr * ty:TypedTree.TType -> - TypedTree.Typars * TypedTree.Val option * TypedTree.Val option * - TypedTree.Val list list * TypedTree.Expr * TypedTree.TType - val IteratedAdjustArityOfLambdaBody : - g:TcGlobals.TcGlobals -> - arities:int list -> - vsl:TypedTree.Val list list -> - body:TypedTree.Expr -> TypedTree.Val list list * TypedTree.Expr - val IteratedAdjustArityOfLambda : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - topValInfo:TypedTree.ValReprInfo -> - e:TypedTree.Expr -> - TypedTree.Typars * TypedTree.Val option * TypedTree.Val option * - TypedTree.Val list list * TypedTree.Expr * TypedTree.TType - val FindUniqueFeasibleSupertype : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - ty1:TypedTree.TType -> ty2:TypedTree.TType -> TypedTree.TType option - end - -namespace FSharp.Compiler - module internal InfoReader = begin - val SelectImmediateMemberVals : - g:TcGlobals.TcGlobals -> - optFilter:string option -> - f:(TypedTree.ValMemberInfo -> TypedTree.ValRef -> 'a option) -> - tcref:TypedTree.TyconRef -> 'a list - val private checkFilter : optFilter:string option -> nm:string -> bool - val TrySelectMemberVal : - g:TcGlobals.TcGlobals -> - optFilter:string option -> - ty:TypedTree.TType -> - pri:Infos.ExtensionMethodPriority option -> - _membInfo:'a -> vref:TypedTree.ValRef -> Infos.MethInfo option - val GetImmediateIntrinsicMethInfosOfTypeAux : - optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - origTy:TypedTree.TType -> - metadataTy:TypedTree.TType -> Infos.MethInfo list - val GetImmediateIntrinsicMethInfosOfType : - optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list - type PropertyCollector = - class - new : g:TcGlobals.TcGlobals * amap:Import.ImportMap * m:Range.range * - ty:TypedTree.TType * optFilter:string option * - ad:AccessibilityLogic.AccessorDomain -> PropertyCollector - member Close : unit -> Infos.PropInfo list - member - Collect : membInfo:TypedTree.ValMemberInfo * vref:TypedTree.ValRef -> - unit - end - val GetImmediateIntrinsicPropInfosOfTypeAux : - optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - origTy:TypedTree.TType -> - metadataTy:TypedTree.TType -> Infos.PropInfo list - val GetImmediateIntrinsicPropInfosOfType : - optFilter:string option * ad:AccessibilityLogic.AccessorDomain -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list - val IsIndexerType : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> ty:TypedTree.TType -> bool - val GetMostSpecificItemsByType : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - f:('a -> (TypedTree.TType * Range.range) option) -> - xs:'a list -> 'a list - val GetMostSpecificMethodInfosByMethInfoSig : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - ty:TypedTree.TType * minfo:Infos.MethInfo -> - minfos:(TypedTree.TType * Infos.MethInfo) list -> - (TypedTree.TType * Infos.MethInfo) list - val FilterMostSpecificMethInfoSets : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - minfoSets:AbstractIL.Internal.Library.NameMultiMap -> - AbstractIL.Internal.Library.NameMultiMap - type HierarchyItem = - | MethodItem of Infos.MethInfo list list - | PropertyItem of Infos.PropInfo list list - | RecdFieldItem of Infos.RecdFieldInfo - | EventItem of Infos.EventInfo list - | ILFieldItem of Infos.ILFieldInfo list - type InfoReader = - class - new : g:TcGlobals.TcGlobals * amap:Import.ImportMap -> InfoReader - member - GetEntireTypeHierarchy : allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * - m:Range.range * ty:TypedTree.TType -> - TypedTree.TType list - member - GetEventInfosOfType : optFilter:string option * - ad:AccessibilityLogic.AccessorDomain * - m:Range.range * ty:TypedTree.TType -> - Infos.EventInfo list - member - GetILFieldInfosOfType : optFilter:string option * - ad:AccessibilityLogic.AccessorDomain * - m:Range.range * ty:TypedTree.TType -> - Infos.ILFieldInfo list - member - GetImmediateIntrinsicEventsOfType : optFilter:string option * - ad:AccessibilityLogic.AccessorDomain * - m:Range.range * ty:TypedTree.TType -> - Infos.EventInfo list - member - GetIntrinsicMostSpecificOverrideMethodSetsOfType : optFilter:string option * - ad:AccessibilityLogic.AccessorDomain * - allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * - m:Range.range * - ty:TypedTree.TType -> - AbstractIL.Internal.Library.NameMultiMap - member - GetPrimaryTypeHierarchy : allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * - m:Range.range * ty:TypedTree.TType -> - TypedTree.TType list - member - GetRawIntrinsicMethodSetsOfType : optFilter:string option * - ad:AccessibilityLogic.AccessorDomain * - allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * - m:Range.range * ty:TypedTree.TType -> - Infos.MethInfo list list - member - GetRawIntrinsicPropertySetsOfType : optFilter:string option * - ad:AccessibilityLogic.AccessorDomain * - allowMultiIntfInst:Infos.AllowMultiIntfInstantiations * - m:Range.range * ty:TypedTree.TType -> - Infos.PropInfo list list - member - GetRecordOrClassFieldsOfType : optFilter:string option * - ad:AccessibilityLogic.AccessorDomain * - m:Range.range * ty:TypedTree.TType -> - Infos.RecdFieldInfo list - member - IsLanguageFeatureRuntimeSupported : langFeature:Features.LanguageFeature -> - bool - member - TryFindNamedItemOfType : nm:string * - ad:AccessibilityLogic.AccessorDomain * - m:Range.range * ty:TypedTree.TType -> - HierarchyItem option - member - TryFindRecdOrClassFieldInfoOfType : nm:string * m:Range.range * - ty:TypedTree.TType -> - Infos.RecdFieldInfo voption - member amap : Import.ImportMap - member g : TcGlobals.TcGlobals - end - val private tryLanguageFeatureRuntimeErrorAux : - infoReader:InfoReader -> - langFeature:Features.LanguageFeature -> - m:Range.range -> error:(exn -> unit) -> bool - val checkLanguageFeatureRuntimeError : - infoReader:InfoReader -> - langFeature:Features.LanguageFeature -> m:Range.range -> unit - val checkLanguageFeatureRuntimeErrorRecover : - infoReader:InfoReader -> - langFeature:Features.LanguageFeature -> m:Range.range -> unit - val tryLanguageFeatureRuntimeErrorRecover : - infoReader:InfoReader -> - langFeature:Features.LanguageFeature -> m:Range.range -> bool - val GetIntrinsicConstructorInfosOfTypeAux : - infoReader:InfoReader -> - m:Range.range -> - origTy:TypedTree.TType -> - metadataTy:TypedTree.TType -> Infos.MethInfo list - val GetIntrinsicConstructorInfosOfType : - infoReader:InfoReader -> - m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list - type FindMemberFlag = - | IgnoreOverrides - | PreferOverrides - type private IndexedList<'T> = - class - new : itemLists:'T list list * - itemsByName:AbstractIL.Internal.Library.NameMultiMap<'T> -> - IndexedList<'T> - member AddItems : items:'T list * nmf:('T -> string) -> IndexedList<'T> - member - FilterNewItems : keepTest:('a -> 'T -> bool) -> - nmf:('a -> string) -> itemsToAdd:'a list -> 'a list - member ItemsWithName : nm:string -> 'T list - member Items : 'T list list - static member Empty : IndexedList<'T> - end - val private FilterItemsInSubTypesBasedOnItemsInSuperTypes : - nmf:('a -> string) -> - keepTest:('a -> 'a -> bool) -> itemLists:'a list list -> 'a list list - val private FilterItemsInSuperTypesBasedOnItemsInSubTypes : - nmf:('a -> string) -> - keepTest:('a -> 'a list -> bool) -> - itemLists:'a list list -> 'a list list - val private ExcludeItemsInSuperTypesBasedOnEquivTestWithItemsInSubTypes : - nmf:('a -> string) -> - equivTest:('a -> 'a -> bool) -> itemLists:'a list list -> 'a list list - val private FilterOverrides : - findFlag:FindMemberFlag -> - isVirt:('a -> bool) * isNewSlot:('a -> bool) * - isDefiniteOverride:('a -> bool) * isFinal:('a -> bool) * - equivSigs:('a -> 'a -> bool) * nmf:('a -> string) -> - items:'a list list -> 'a list list - val private FilterOverridesOfMethInfos : - findFlag:FindMemberFlag -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - minfos:Infos.MethInfo list list -> Infos.MethInfo list list - val private FilterOverridesOfPropInfos : - findFlag:FindMemberFlag -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - props:Infos.PropInfo list list -> Infos.PropInfo list list - val ExcludeHiddenOfMethInfos : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - minfos:Infos.MethInfo list list -> Infos.MethInfo list - val ExcludeHiddenOfPropInfos : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - pinfos:Infos.PropInfo list list -> Infos.PropInfo list - val GetIntrinsicMethInfoSetsOfType : - infoReader:InfoReader -> - optFilter:string option -> - ad:AccessibilityLogic.AccessorDomain -> - allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> - findFlag:FindMemberFlag -> - m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list list - val GetIntrinsicPropInfoSetsOfType : - infoReader:InfoReader -> - optFilter:string option -> - ad:AccessibilityLogic.AccessorDomain -> - allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> - findFlag:FindMemberFlag -> - m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list list - val GetIntrinsicMethInfosOfType : - infoReader:InfoReader -> - optFilter:string option -> - ad:AccessibilityLogic.AccessorDomain -> - allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> - findFlag:FindMemberFlag -> - m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list - val GetIntrinsicPropInfosOfType : - infoReader:InfoReader -> - optFilter:string option -> - ad:AccessibilityLogic.AccessorDomain -> - allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> - findFlag:FindMemberFlag -> - m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list - val TryFindIntrinsicNamedItemOfType : - infoReader:InfoReader -> - nm:string * ad:AccessibilityLogic.AccessorDomain -> - findFlag:FindMemberFlag -> - m:Range.range -> ty:TypedTree.TType -> HierarchyItem option - val TryFindIntrinsicMethInfo : - infoReader:InfoReader -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - nm:string -> ty:TypedTree.TType -> Infos.MethInfo list - val TryFindPropInfo : - infoReader:InfoReader -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - nm:string -> ty:TypedTree.TType -> Infos.PropInfo list - val GetIntrinisicMostSpecificOverrideMethInfoSetsOfType : - infoReader:InfoReader -> - m:Range.range -> - ty:TypedTree.TType -> - AbstractIL.Internal.Library.NameMultiMap - [] - type SigOfFunctionForDelegate = - | SigOfFunctionForDelegate of - Infos.MethInfo * TypedTree.TType list * TypedTree.TType * - TypedTree.TType - val GetSigOfFunctionForDelegate : - infoReader:InfoReader -> - delty:TypedTree.TType -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> SigOfFunctionForDelegate - val TryDestStandardDelegateType : - infoReader:InfoReader -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - delTy:TypedTree.TType -> (TypedTree.TType * TypedTree.TType) option - val IsStandardEventInfo : - infoReader:InfoReader -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> einfo:Infos.EventInfo -> bool - val ArgsTypOfEventInfo : - infoReader:InfoReader -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - einfo:Infos.EventInfo -> TypedTree.TType - val PropTypOfEventInfo : - infoReader:InfoReader -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - einfo:Infos.EventInfo -> TypedTree.TType - end - -namespace FSharp.Compiler - module internal NicePrint = begin - module PrintUtilities = begin - val bracketIfL : - x:bool -> - lyt:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val squareAngleL : - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val angleL : - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val braceL : - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val braceBarL : - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val comment : str:string -> Internal.Utilities.StructuredFormat.Layout - val layoutsL : ls:Layout.layout list -> Layout.layout - val suppressInheritanceAndInterfacesForTyInSimplifiedDisplays : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> m:Range.range -> ty:TypedTree.TType -> bool - val applyMaxMembers : - maxMembers:int option -> - allDecls:Internal.Utilities.StructuredFormat.Layout list -> - Internal.Utilities.StructuredFormat.Layout list - val adjustILName : n:string -> string - val shrinkOverloads : - layoutFunction:('a -> Internal.Utilities.StructuredFormat.Layout) -> - resultFunction:('a -> Internal.Utilities.StructuredFormat.Layout -> 'b) -> - group:'a list -> 'b list - val layoutTyconRefImpl : - isAttribute:bool -> - denv:TypedTreeOps.DisplayEnv -> - tcref:TypedTree.TyconRef -> - Internal.Utilities.StructuredFormat.Layout - val layoutBuiltinAttribute : - denv:TypedTreeOps.DisplayEnv -> - attrib:TcGlobals.BuiltinAttribInfo -> - Internal.Utilities.StructuredFormat.Layout - end - module private PrintIL = begin - val fullySplitILTypeRef : tref:AbstractIL.IL.ILTypeRef -> string list - val layoutILTypeRefName : - denv:TypedTreeOps.DisplayEnv -> - path:string list -> Internal.Utilities.StructuredFormat.Layout - val layoutILTypeRef : - denv:TypedTreeOps.DisplayEnv -> - tref:AbstractIL.IL.ILTypeRef -> - Internal.Utilities.StructuredFormat.Layout - val layoutILArrayShape : - AbstractIL.IL.ILArrayShape -> Internal.Utilities.StructuredFormat.Layout - val paramsL : ps:Layout.layout list -> Layout.layout - val pruneParams : - className:string -> - ilTyparSubst:Layout.layout list -> Layout.layout list - val layoutILType : - denv:TypedTreeOps.DisplayEnv -> - ilTyparSubst:Layout.layout list -> - ty:AbstractIL.IL.ILType -> Layout.layout - val layoutILCallingSignature : - denv:TypedTreeOps.DisplayEnv -> - ilTyparSubst:Layout.layout list -> - cons:string option -> - signature:AbstractIL.IL.ILCallingSignature -> Layout.layout - val layoutILFieldInit : - x:AbstractIL.IL.ILFieldInit option -> - Internal.Utilities.StructuredFormat.Layout - val layoutILEnumDefParts : - nm:string -> - litVal:AbstractIL.IL.ILFieldInit option -> - Internal.Utilities.StructuredFormat.Layout - end - module private PrintTypes = begin - val layoutConst : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> - c:TypedTree.Const -> Internal.Utilities.StructuredFormat.Layout - val layoutAccessibility : - denv:TypedTreeOps.DisplayEnv -> - accessibility:TypedTree.Accessibility -> - itemL:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val layoutTyconRef : - denv:TypedTreeOps.DisplayEnv -> - tycon:TypedTree.TyconRef -> Internal.Utilities.StructuredFormat.Layout - val layoutMemberFlags : - memFlags:SyntaxTree.MemberFlags -> - Internal.Utilities.StructuredFormat.Layout - val layoutAttribArg : - denv:TypedTreeOps.DisplayEnv -> - arg:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val layoutAttribArgs : - denv:TypedTreeOps.DisplayEnv -> - args:TypedTree.AttribExpr list -> - Internal.Utilities.StructuredFormat.Layout - val layoutAttrib : - denv:TypedTreeOps.DisplayEnv -> - TypedTree.Attrib -> Internal.Utilities.StructuredFormat.Layout - val layoutILAttribElement : - denv:TypedTreeOps.DisplayEnv -> - arg:AbstractIL.IL.ILAttribElem -> - Internal.Utilities.StructuredFormat.Layout - val layoutILAttrib : - denv:TypedTreeOps.DisplayEnv -> - ty:AbstractIL.IL.ILType * args:AbstractIL.IL.ILAttribElem list -> - Internal.Utilities.StructuredFormat.Layout - val layoutAttribs : - denv:TypedTreeOps.DisplayEnv -> - isValue:bool -> - ty:TypedTree.TType -> - kind:TypedTree.TyparKind -> - attrs:TypedTree.Attrib list -> - restL:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val layoutTyparAttribs : - denv:TypedTreeOps.DisplayEnv -> - kind:TypedTree.TyparKind -> - attrs:TypedTree.Attrib list -> - restL:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val layoutTyparRef : - denv:TypedTreeOps.DisplayEnv -> - typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val layoutTyparRefWithInfo : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - typar:TypedTree.Typar -> Internal.Utilities.StructuredFormat.Layout - val layoutConstraintsWithInfo : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - cxs:(TypedTree.Typar * TypedTree.TyparConstraint) list -> - Internal.Utilities.StructuredFormat.Layout - val layoutConstraintWithInfo : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - tp:TypedTree.Typar * tpc:TypedTree.TyparConstraint -> - Internal.Utilities.StructuredFormat.Layout list - val layoutTraitWithInfo : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - TypedTree.TraitConstraintInfo -> - Internal.Utilities.StructuredFormat.Layout - val layoutMeasure : - denv:TypedTreeOps.DisplayEnv -> - unt:TypedTree.Measure -> Internal.Utilities.StructuredFormat.Layout - val layoutTypeAppWithInfoAndPrec : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - tcL:Internal.Utilities.StructuredFormat.Layout -> - prec:int -> - prefix:bool -> - args:TypedTree.TType list -> - Internal.Utilities.StructuredFormat.Layout - val layoutTypeWithInfoAndPrec : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - prec:int -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val layoutTypesWithInfoAndPrec : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - prec:int -> - sep:Internal.Utilities.StructuredFormat.Layout -> - typl:TypedTree.TType list -> - Internal.Utilities.StructuredFormat.Layout - val layoutReturnType : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - rty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val layoutTypeWithInfo : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val layoutType : - denv:TypedTreeOps.DisplayEnv -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val layoutArgInfos : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> - Internal.Utilities.StructuredFormat.Layout list - val layoutGenericParameterTypes : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - _arg1:TypedTree.TType list -> - Internal.Utilities.StructuredFormat.Layout - val layoutTopType : - denv:TypedTreeOps.DisplayEnv -> - env:TypedTreeOps.SimplifyTypes.TypeSimplificationInfo -> - argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> - rty:TypedTree.TType -> - cxs:(TypedTree.Typar * TypedTree.TyparConstraint) list -> - Internal.Utilities.StructuredFormat.Layout - val layoutTyparDecls : - denv:TypedTreeOps.DisplayEnv -> - nmL:Internal.Utilities.StructuredFormat.Layout -> - prefix:bool -> - typars:TypedTree.Typars -> - Internal.Utilities.StructuredFormat.Layout - val layoutTyparConstraint : - denv:TypedTreeOps.DisplayEnv -> - tp:TypedTree.Typar * tpc:TypedTree.TyparConstraint -> - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfInstAndSig : - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst * tys:TypedTree.TTypes * - retTy:TypedTree.TType -> - TypedTreeOps.TyparInst * (TypedTree.TTypes * TypedTree.TType) * - (Internal.Utilities.StructuredFormat.Layout list * - Internal.Utilities.StructuredFormat.Layout) * - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfTopTypeInfoAux : - denv:TypedTreeOps.DisplayEnv -> - prettyArgInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> - prettyRetTy:TypedTree.TType -> - cxs:TypedTreeOps.TyparConstraintsWithTypars -> - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfUncurriedSig : - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst -> - argInfos:TypedTreeOps.UncurriedArgInfos -> - retTy:TypedTree.TType -> - TypedTreeOps.TyparInst * - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfCurriedMemberSig : - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst -> - argInfos:TypedTreeOps.CurriedArgInfos -> - retTy:TypedTree.TType -> - parentTyparTys:TypedTree.TTypes -> - TypedTreeOps.TyparInst * - Internal.Utilities.StructuredFormat.Layout - val prettyArgInfos : - denv:TypedTreeOps.DisplayEnv -> - allTyparInst:TypedTreeOps.TyparInst -> - _arg1:(TypedTree.TType * TypedTree.ArgReprInfo) list -> - (TypedTree.TType * TypedTree.ArgReprInfo) list - val prettyLayoutOfMemberSigCore : - denv:TypedTreeOps.DisplayEnv -> - memberToParentInst:(TypedTree.Typar * TypedTree.TType) list -> - typarInst:TypedTreeOps.TyparInst * methTypars:TypedTree.Typars * - argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list * - retTy:TypedTree.TType -> - TypedTreeOps.TyparInst * TypedTree.Typars * - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMemberType : - denv:TypedTreeOps.DisplayEnv -> - v:TypedTree.ValRef -> - typarInst:TypedTreeOps.TyparInst -> - argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> - retTy:TypedTree.TType -> - TypedTreeOps.TyparInst * TypedTree.Typars * - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMemberSig : - denv:TypedTreeOps.DisplayEnv -> - memberToParentInst:(TypedTree.Typar * TypedTree.TType) list * - nm:string * methTypars:TypedTree.Typars * - argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list * - retTy:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutsOfUnresolvedOverloading : - denv:TypedTreeOps.DisplayEnv -> - argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list -> - retTy:TypedTree.TType -> - genParamTys:seq -> - Internal.Utilities.StructuredFormat.Layout * - Internal.Utilities.StructuredFormat.Layout * - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfType : - denv:TypedTreeOps.DisplayEnv -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfTypeNoConstraints : - denv:TypedTreeOps.DisplayEnv -> - ty:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val layoutAssemblyName : _denv:'a -> ty:TypedTree.TType -> string - end - module private PrintTastMemberOrVals = begin - val prettyLayoutOfMemberShortOption : - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst -> - v:TypedTree.Val -> - short:bool -> - TypedTreeOps.TyparInst * - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMember : - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst -> - v:TypedTree.Val -> - TypedTreeOps.TyparInst * - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMemberNoInstShort : - denv:TypedTreeOps.DisplayEnv -> - v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val layoutOfLiteralValue : - literalValue:TypedTree.Const -> - Internal.Utilities.StructuredFormat.Layout - val layoutNonMemberVal : - denv:TypedTreeOps.DisplayEnv -> - tps:TypedTree.Typar list * v:TypedTree.Val * tau:TypedTree.TType * - cxs:TypedTreeOps.TyparConstraintsWithTypars -> - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfValOrMember : - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst -> - v:TypedTree.Val -> - TypedTreeOps.TyparInst * - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfValOrMemberNoInst : - denv:TypedTreeOps.DisplayEnv -> - v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - end - val layoutTyparConstraint : - denv:TypedTreeOps.DisplayEnv -> - TypedTree.Typar * TypedTree.TyparConstraint -> - Internal.Utilities.StructuredFormat.Layout - val outputType : - denv:TypedTreeOps.DisplayEnv -> - os:System.Text.StringBuilder -> x:TypedTree.TType -> unit - val layoutType : - denv:TypedTreeOps.DisplayEnv -> - x:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val outputTypars : - denv:TypedTreeOps.DisplayEnv -> - nm:Layout.TaggedText -> - os:System.Text.StringBuilder -> x:TypedTree.Typars -> unit - val outputTyconRef : - denv:TypedTreeOps.DisplayEnv -> - os:System.Text.StringBuilder -> x:TypedTree.TyconRef -> unit - val layoutTyconRef : - denv:TypedTreeOps.DisplayEnv -> - x:TypedTree.TyconRef -> Internal.Utilities.StructuredFormat.Layout - val layoutConst : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> - c:TypedTree.Const -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMemberSig : - denv:TypedTreeOps.DisplayEnv -> - (TypedTree.Typar * TypedTree.TType) list * string * TypedTree.Typars * - (TypedTree.TType * TypedTree.ArgReprInfo) list list * TypedTree.TType -> - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfUncurriedSig : - denv:TypedTreeOps.DisplayEnv -> - argInfos:TypedTreeOps.TyparInst -> - tau:TypedTreeOps.UncurriedArgInfos -> - (TypedTree.TType -> - TypedTreeOps.TyparInst * - Internal.Utilities.StructuredFormat.Layout) - val prettyLayoutsOfUnresolvedOverloading : - denv:TypedTreeOps.DisplayEnv -> - argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list -> - retTy:TypedTree.TType -> - genericParameters:seq -> - Internal.Utilities.StructuredFormat.Layout * - Internal.Utilities.StructuredFormat.Layout * - Internal.Utilities.StructuredFormat.Layout - module InfoMemberPrinting = begin - val layoutParamData : - denv:TypedTreeOps.DisplayEnv -> - Infos.ParamData -> Internal.Utilities.StructuredFormat.Layout - val formatParamDataToBuffer : - denv:TypedTreeOps.DisplayEnv -> - os:System.Text.StringBuilder -> pd:Infos.ParamData -> unit - val private layoutMethInfoFSharpStyleCore : - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - minfo:Infos.MethInfo -> - minst:TypedTree.TType list -> - Internal.Utilities.StructuredFormat.Layout - val private layoutMethInfoCSharpStyle : - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - minfo:Infos.MethInfo -> - minst:TypedTree.TType list -> - Internal.Utilities.StructuredFormat.Layout - val prettifyILMethInfo : - amap:Import.ImportMap -> - m:Range.range -> - minfo:Infos.MethInfo -> - typarInst:TypedTreeOps.TyparInst -> - ilMethInfo:Infos.ILMethInfo -> - TypedTreeOps.TyparInst * Infos.MethInfo * TypedTree.TType list - val prettyLayoutOfMethInfoFreeStyle : - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst -> - methInfo:Infos.MethInfo -> - TypedTreeOps.TyparInst * - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfPropInfoFreeStyle : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - pinfo:Infos.PropInfo -> - Internal.Utilities.StructuredFormat.Layout - val formatMethInfoToBufferFreeStyle : - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - os:System.Text.StringBuilder -> minfo:Infos.MethInfo -> unit - val layoutMethInfoFSharpStyle : - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - minfo:Infos.MethInfo -> Internal.Utilities.StructuredFormat.Layout - end - module private TastDefinitionPrinting = begin - val layoutExtensionMember : - denv:TypedTreeOps.DisplayEnv -> - v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val layoutExtensionMembers : - denv:TypedTreeOps.DisplayEnv -> - vs:TypedTree.Val list -> Internal.Utilities.StructuredFormat.Layout - val layoutRecdField : - addAccess:bool -> - denv:TypedTreeOps.DisplayEnv -> - fld:TypedTree.RecdField -> - Internal.Utilities.StructuredFormat.Layout - val layoutUnionOrExceptionField : - denv:TypedTreeOps.DisplayEnv -> - isGenerated:('a -> TypedTree.RecdField -> bool) -> - i:'a -> - fld:TypedTree.RecdField -> - Internal.Utilities.StructuredFormat.Layout - val isGeneratedUnionCaseField : pos:int -> f:TypedTree.RecdField -> bool - val isGeneratedExceptionField : pos:'a -> f:TypedTree.RecdField -> bool - val layoutUnionCaseFields : - denv:TypedTreeOps.DisplayEnv -> - isUnionCase:bool -> - fields:TypedTree.RecdField list -> - Internal.Utilities.StructuredFormat.Layout - val layoutUnionCase : - denv:TypedTreeOps.DisplayEnv -> - prefixL:Internal.Utilities.StructuredFormat.Layout -> - ucase:TypedTree.UnionCase -> - Internal.Utilities.StructuredFormat.Layout - val layoutUnionCases : - denv:TypedTreeOps.DisplayEnv -> - ucases:TypedTree.UnionCase list -> - Internal.Utilities.StructuredFormat.Layout list - val breakTypeDefnEqn : repr:TypedTree.TyconRepresentation -> bool - val layoutILFieldInfo : - denv:TypedTreeOps.DisplayEnv -> - amap:Import.ImportMap -> - m:Range.range -> - e:Infos.ILFieldInfo -> Internal.Utilities.StructuredFormat.Layout - val layoutEventInfo : - denv:TypedTreeOps.DisplayEnv -> - amap:Import.ImportMap -> - m:Range.range -> - e:Infos.EventInfo -> Internal.Utilities.StructuredFormat.Layout - val layoutPropInfo : - denv:TypedTreeOps.DisplayEnv -> - amap:Import.ImportMap -> - m:Range.range -> - p:Infos.PropInfo -> Internal.Utilities.StructuredFormat.Layout - val layoutTycon : - denv:TypedTreeOps.DisplayEnv -> - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - simplified:bool -> - typewordL:Internal.Utilities.StructuredFormat.Layout -> - tycon:TypedTree.Tycon -> - Internal.Utilities.StructuredFormat.Layout - val layoutExnDefn : - denv:TypedTreeOps.DisplayEnv -> - exnc:TypedTree.Entity -> Internal.Utilities.StructuredFormat.Layout - val layoutTyconDefns : - denv:TypedTreeOps.DisplayEnv -> - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - tycons:TypedTree.Tycon list -> - Internal.Utilities.StructuredFormat.Layout - end - module private InferredSigPrinting = begin - val layoutInferredSigOfModuleExpr : - showHeader:bool -> - denv:TypedTreeOps.DisplayEnv -> - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - expr:TypedTree.ModuleOrNamespaceExprWithSig -> - Internal.Utilities.StructuredFormat.Layout - end - module private PrintData = begin - val dataExprL : - denv:TypedTreeOps.DisplayEnv -> - expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val dataExprWrapL : - denv:TypedTreeOps.DisplayEnv -> - isAtomic:bool -> - expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val dataExprsL : - denv:TypedTreeOps.DisplayEnv -> - xs:TypedTree.Exprs -> Internal.Utilities.StructuredFormat.Layout list - end - val dataExprL : - denv:TypedTreeOps.DisplayEnv -> - expr:TypedTree.Expr -> Internal.Utilities.StructuredFormat.Layout - val outputValOrMember : - denv:TypedTreeOps.DisplayEnv -> - os:System.Text.StringBuilder -> x:TypedTree.Val -> unit - val stringValOrMember : - denv:TypedTreeOps.DisplayEnv -> x:TypedTree.Val -> string - val layoutQualifiedValOrMember : - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst -> - v:TypedTree.Val -> - TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout - val outputQualifiedValOrMember : - denv:TypedTreeOps.DisplayEnv -> - os:System.Text.StringBuilder -> v:TypedTree.Val -> unit - val outputQualifiedValSpec : - denv:TypedTreeOps.DisplayEnv -> - os:System.Text.StringBuilder -> v:TypedTree.Val -> unit - val stringOfQualifiedValOrMember : - denv:TypedTreeOps.DisplayEnv -> v:TypedTree.Val -> string - val formatMethInfoToBufferFreeStyle : - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - buf:System.Text.StringBuilder -> d:Infos.MethInfo -> unit - val prettyLayoutOfMethInfoFreeStyle : - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst -> - minfo:Infos.MethInfo -> - TypedTreeOps.TyparInst * - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfPropInfoFreeStyle : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - d:Infos.PropInfo -> Internal.Utilities.StructuredFormat.Layout - val stringOfMethInfo : - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> d:Infos.MethInfo -> string - val stringOfParamData : - denv:TypedTreeOps.DisplayEnv -> paramData:Infos.ParamData -> string - val layoutOfParamData : - denv:TypedTreeOps.DisplayEnv -> - paramData:Infos.ParamData -> Internal.Utilities.StructuredFormat.Layout - val layoutExnDef : - denv:TypedTreeOps.DisplayEnv -> - x:TypedTree.Entity -> Internal.Utilities.StructuredFormat.Layout - val stringOfTyparConstraints : - denv:TypedTreeOps.DisplayEnv -> - x:(TypedTree.Typar * TypedTree.TyparConstraint) list -> string - val layoutTycon : - denv:TypedTreeOps.DisplayEnv -> - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - x:TypedTree.Tycon -> Internal.Utilities.StructuredFormat.Layout - val layoutUnionCases : - denv:TypedTreeOps.DisplayEnv -> - x:TypedTree.RecdField list -> Internal.Utilities.StructuredFormat.Layout - val isGeneratedUnionCaseField : pos:int -> f:TypedTree.RecdField -> bool - val isGeneratedExceptionField : pos:'a -> f:TypedTree.RecdField -> bool - val stringOfTyparConstraint : - denv:TypedTreeOps.DisplayEnv -> - TypedTree.Typar * TypedTree.TyparConstraint -> string - val stringOfTy : denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> string - val prettyLayoutOfType : - denv:TypedTreeOps.DisplayEnv -> - x:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfTypeNoCx : - denv:TypedTreeOps.DisplayEnv -> - x:TypedTree.TType -> Internal.Utilities.StructuredFormat.Layout - val prettyStringOfTy : - denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> string - val prettyStringOfTyNoCx : - denv:TypedTreeOps.DisplayEnv -> x:TypedTree.TType -> string - val stringOfRecdField : - denv:TypedTreeOps.DisplayEnv -> x:TypedTree.RecdField -> string - val stringOfUnionCase : - denv:TypedTreeOps.DisplayEnv -> x:TypedTree.UnionCase -> string - val stringOfExnDef : - denv:TypedTreeOps.DisplayEnv -> x:TypedTree.Entity -> string - val stringOfFSAttrib : - denv:TypedTreeOps.DisplayEnv -> x:TypedTree.Attrib -> string - val stringOfILAttrib : - denv:TypedTreeOps.DisplayEnv -> - AbstractIL.IL.ILType * AbstractIL.IL.ILAttribElem list -> string - val layoutInferredSigOfModuleExpr : - showHeader:bool -> - denv:TypedTreeOps.DisplayEnv -> - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - expr:TypedTree.ModuleOrNamespaceExprWithSig -> - Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfValOrMember : - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst -> - v:TypedTree.Val -> - TypedTreeOps.TyparInst * Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfValOrMemberNoInst : - denv:TypedTreeOps.DisplayEnv -> - v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfMemberNoInstShort : - denv:TypedTreeOps.DisplayEnv -> - v:TypedTree.Val -> Internal.Utilities.StructuredFormat.Layout - val prettyLayoutOfInstAndSig : - denv:TypedTreeOps.DisplayEnv -> - TypedTreeOps.TyparInst * TypedTree.TTypes * TypedTree.TType -> - TypedTreeOps.TyparInst * (TypedTree.TTypes * TypedTree.TType) * - (Internal.Utilities.StructuredFormat.Layout list * - Internal.Utilities.StructuredFormat.Layout) * - Internal.Utilities.StructuredFormat.Layout - val minimalStringsOfTwoTypes : - denv:TypedTreeOps.DisplayEnv -> - t1:TypedTree.TType -> t2:TypedTree.TType -> string * string * string - val minimalStringsOfTwoValues : - denv:TypedTreeOps.DisplayEnv -> - v1:TypedTree.Val -> v2:TypedTree.Val -> string * string - val minimalStringOfType : - denv:TypedTreeOps.DisplayEnv -> ty:TypedTree.TType -> string - end - -namespace FSharp.Compiler - module internal AugmentWithHashCompare = begin - val mkIComparableCompareToSlotSig : - g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkGenericIComparableCompareToSlotSig : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.SlotSig - val mkIStructuralComparableCompareToSlotSig : - g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkGenericIEquatableEqualsSlotSig : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.SlotSig - val mkIStructuralEquatableEqualsSlotSig : - g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkIStructuralEquatableGetHashCodeSlotSig : - g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkGetHashCodeSlotSig : g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkEqualsSlotSig : g:TcGlobals.TcGlobals -> TypedTree.SlotSig - val mkThisTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkCompareObjTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkCompareTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkCompareWithComparerTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkEqualsObjTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkEqualsTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkEqualsWithComparerTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkHashTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkHashWithComparerTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TypedTree.TType - val mkRelBinOp : - g:TcGlobals.TcGlobals -> - op:AbstractIL.IL.ILInstr -> - m:Range.range -> - e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkClt : - g:TcGlobals.TcGlobals -> - m:Range.range -> - e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkCgt : - g:TcGlobals.TcGlobals -> - m:Range.range -> - e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkILLangPrimTy : g:TcGlobals.TcGlobals -> AbstractIL.IL.ILType - val mkILCallGetComparer : - g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.Expr - val mkILCallGetEqualityComparer : - g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.Expr - val mkThisVar : - g:TcGlobals.TcGlobals -> - m:Range.range -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val mkShl : - g:TcGlobals.TcGlobals -> - m:Range.range -> acce:TypedTree.Expr -> n:int -> TypedTree.Expr - val mkShr : - g:TcGlobals.TcGlobals -> - m:Range.range -> acce:TypedTree.Expr -> n:int -> TypedTree.Expr - val mkAdd : - g:TcGlobals.TcGlobals -> - m:Range.range -> - e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkAddToHashAcc : - g:TcGlobals.TcGlobals -> - m:Range.range -> - e:TypedTree.Expr -> - accv:TypedTree.ValRef -> acce:TypedTree.Expr -> TypedTree.Expr - val mkCombineHashGenerators : - g:TcGlobals.TcGlobals -> - m:Range.range -> - exprs:TypedTree.Expr list -> - accv:TypedTree.ValRef -> acce:TypedTree.Expr -> TypedTree.Expr - val mkThatAddrLocal : - g:TcGlobals.TcGlobals -> - m:Range.range -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val mkThatAddrLocalIfNeeded : - g:TcGlobals.TcGlobals -> - m:Range.range -> - tcve:TypedTree.Expr -> - ty:TypedTree.TType -> TypedTree.Val option * TypedTree.Expr - val mkThisVarThatVar : - g:TcGlobals.TcGlobals -> - m:Range.range -> - ty:TypedTree.TType -> - TypedTree.Val * TypedTree.Val * TypedTree.Expr * TypedTree.Expr - val mkThatVarBind : - g:TcGlobals.TcGlobals -> - m:Range.range -> - ty:TypedTree.TType -> - thataddrv:TypedTree.Val -> - expr:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr - val mkBindThatAddr : - g:TcGlobals.TcGlobals -> - m:Range.range -> - ty:TypedTree.TType -> - thataddrv:TypedTree.Val -> - thatv:TypedTree.Val -> - thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val mkBindThatAddrIfNeeded : - m:Range.range -> - thataddrvOpt:TypedTree.Val option -> - thatv:TypedTree.Val -> expr:TypedTree.Expr -> TypedTree.Expr - val mkDerefThis : - g:TcGlobals.TcGlobals -> - m:Range.range -> - thisv:TypedTree.Val -> thise:TypedTree.Expr -> TypedTree.Expr - val mkCompareTestConjuncts : - g:TcGlobals.TcGlobals -> - m:Range.range -> exprs:TypedTree.Expr list -> TypedTree.Expr - val mkEqualsTestConjuncts : - g:TcGlobals.TcGlobals -> - m:Range.range -> exprs:TypedTree.Expr list -> TypedTree.Expr - val mkMinimalTy : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> TypedTree.TType list * TypedTree.TType - val mkBindNullComparison : - g:TcGlobals.TcGlobals -> - m:Range.range -> - thise:TypedTree.Expr -> - thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val mkBindThisNullEquals : - g:TcGlobals.TcGlobals -> - m:Range.range -> - thise:TypedTree.Expr -> - thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val mkBindThatNullEquals : - g:TcGlobals.TcGlobals -> - m:Range.range -> - thise:TypedTree.Expr -> - thate:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val mkBindNullHash : - g:TcGlobals.TcGlobals -> - m:Range.range -> - thise:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val mkRecdCompare : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - tycon:TypedTree.Tycon -> - TypedTree.Val * TypedTree.Val * TypedTree.Expr - val mkRecdCompareWithComparer : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - tycon:TypedTree.Tycon -> - _thisv:'a * thise:TypedTree.Expr -> - 'b * thate:TypedTree.Expr -> - compe:TypedTree.Expr -> TypedTree.Expr - val mkRecdEquality : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - tycon:TypedTree.Tycon -> - TypedTree.Val * TypedTree.Val * TypedTree.Expr - val mkRecdEqualityWithComparer : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - tycon:TypedTree.Tycon -> - _thisv:'a * thise:TypedTree.Expr -> - thatobje:TypedTree.Expr -> - thatv:TypedTree.Val * thate:TypedTree.Expr -> - compe:TypedTree.Expr -> TypedTree.Expr - val mkExnEquality : - g:TcGlobals.TcGlobals -> - exnref:TypedTree.TyconRef -> - exnc:TypedTree.Tycon -> TypedTree.Val * TypedTree.Val * TypedTree.Expr - val mkExnEqualityWithComparer : - g:TcGlobals.TcGlobals -> - exnref:TypedTree.TyconRef -> - exnc:TypedTree.Tycon -> - _thisv:'a * thise:TypedTree.Expr -> - thatobje:TypedTree.Expr -> - thatv:TypedTree.Val * thate:TypedTree.Expr -> - compe:TypedTree.Expr -> TypedTree.Expr - val mkUnionCompare : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - tycon:TypedTree.Tycon -> - TypedTree.Val * TypedTree.Val * TypedTree.Expr - val mkUnionCompareWithComparer : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - tycon:TypedTree.Tycon -> - _thisv:'a * thise:TypedTree.Expr -> - _thatobjv:'b * thatcaste:TypedTree.Expr -> - compe:TypedTree.Expr -> TypedTree.Expr - val mkUnionEquality : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - tycon:TypedTree.Tycon -> - TypedTree.Val * TypedTree.Val * TypedTree.Expr - val mkUnionEqualityWithComparer : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - tycon:TypedTree.Tycon -> - _thisv:'a * thise:TypedTree.Expr -> - thatobje:TypedTree.Expr -> - thatv:TypedTree.Val * thate:TypedTree.Expr -> - compe:TypedTree.Expr -> TypedTree.Expr - val mkRecdHashWithComparer : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - tycon:TypedTree.Tycon -> - compe:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr - val mkExnHashWithComparer : - g:TcGlobals.TcGlobals -> - exnref:TypedTree.TyconRef -> - exnc:TypedTree.Tycon -> - compe:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr - val mkUnionHashWithComparer : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - tycon:TypedTree.Tycon -> - compe:TypedTree.Expr -> TypedTree.Val * TypedTree.Expr - val isNominalExnc : exnc:TypedTree.Tycon -> bool - val isTrueFSharpStructTycon : _g:'a -> tycon:TypedTree.Tycon -> bool - val canBeAugmentedWithEquals : g:'a -> tycon:TypedTree.Tycon -> bool - val canBeAugmentedWithCompare : g:'a -> tycon:TypedTree.Tycon -> bool - val getAugmentationAttribs : - g:TcGlobals.TcGlobals -> - tycon:TypedTree.Tycon -> - bool * bool * bool option * bool option * bool option * bool option * - bool option * bool option * bool option - val CheckAugmentationAttribs : - bool -> TcGlobals.TcGlobals -> Import.ImportMap -> TypedTree.Tycon -> unit - val TyconIsCandidateForAugmentationWithCompare : - TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val TyconIsCandidateForAugmentationWithEquals : - TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val TyconIsCandidateForAugmentationWithHash : - TcGlobals.TcGlobals -> TypedTree.Tycon -> bool - val slotImplMethod : - final:bool * c:TypedTree.TyconRef * slotsig:TypedTree.SlotSig -> - TypedTree.ValMemberInfo - val nonVirtualMethod : c:TypedTree.TyconRef -> TypedTree.ValMemberInfo - val unitArg : TypedTree.ArgReprInfo list list - val unaryArg : TypedTree.ArgReprInfo list list - val tupArg : TypedTree.ArgReprInfo list list - val mkValSpec : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - tmty:TypedTree.TType -> - vis:TypedTree.Accessibility -> - slotsig:TypedTree.SlotSig option -> - methn:string -> - ty:TypedTree.TType -> - argData:TypedTree.ArgReprInfo list list -> TypedTree.Val - val MakeValsForCompareAugmentation : - TcGlobals.TcGlobals -> TypedTree.TyconRef -> TypedTree.Val * TypedTree.Val - val MakeValsForCompareWithComparerAugmentation : - TcGlobals.TcGlobals -> TypedTree.TyconRef -> TypedTree.Val - val MakeValsForEqualsAugmentation : - TcGlobals.TcGlobals -> TypedTree.TyconRef -> TypedTree.Val * TypedTree.Val - val MakeValsForEqualityWithComparerAugmentation : - TcGlobals.TcGlobals -> - TypedTree.TyconRef -> TypedTree.Val * TypedTree.Val * TypedTree.Val - val MakeBindingsForCompareAugmentation : - TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list - val MakeBindingsForCompareWithComparerAugmentation : - TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list - val MakeBindingsForEqualityWithComparerAugmentation : - TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list - val MakeBindingsForEqualsAugmentation : - TcGlobals.TcGlobals -> TypedTree.Tycon -> TypedTree.Binding list - val TypeDefinitelyHasEquality : - TcGlobals.TcGlobals -> TypedTree.TType -> bool - end - -namespace FSharp.Compiler - module internal NameResolution = begin - type NameResolver = - class - new : g:TcGlobals.TcGlobals * amap:Import.ImportMap * - infoReader:InfoReader.InfoReader * - instantiationGenerator:(Range.range -> TypedTree.Typars -> - TypedTree.TypeInst) -> NameResolver - member InfoReader : InfoReader.InfoReader - member - InstantiationGenerator : (Range.range -> TypedTree.Typars -> - TypedTree.TypeInst) - member amap : Import.ImportMap - member g : TcGlobals.TcGlobals - member languageSupportsNameOf : bool - end - val UnionCaseRefsInTycon : - modref:TypedTree.ModuleOrNamespaceRef -> - tycon:TypedTree.Tycon -> TypedTree.UnionCaseRef list - val UnionCaseRefsInModuleOrNamespace : - modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.UnionCaseRef list - val TryFindTypeWithUnionCase : - modref:TypedTree.ModuleOrNamespaceRef -> - id:SyntaxTree.Ident -> TypedTree.Entity option - val TryFindTypeWithRecdField : - modref:TypedTree.ModuleOrNamespaceRef -> - id:SyntaxTree.Ident -> TypedTree.Entity option - val ActivePatternElemsOfValRef : - vref:TypedTree.ValRef -> TypedTree.ActivePatternElemRef list - val TryMkValRefInModRef : - modref:TypedTree.EntityRef -> - vspec:TypedTree.Val -> TypedTree.ValRef option - val ActivePatternElemsOfVal : - modref:TypedTree.EntityRef -> - vspec:TypedTree.Val -> TypedTree.ActivePatternElemRef list - val ActivePatternElemsOfModuleOrNamespace : - TypedTree.ModuleOrNamespaceRef -> - AbstractIL.Internal.Library.NameMap - val ( |AbbrevOrAppTy|_| ) : TypedTree.TType -> TypedTree.TyconRef option - [] - type ArgumentContainer = - | Method of Infos.MethInfo - | Type of TypedTree.TyconRef - val emptyTypeInst : TypedTree.TypeInst - type EnclosingTypeInst = TypedTree.TypeInst - val emptyEnclosingTypeInst : EnclosingTypeInst - [] - type Item = - | Value of TypedTree.ValRef - | UnionCase of Infos.UnionCaseInfo * hasRequireQualifiedAccessAttr: bool - | ActivePatternResult of - PrettyNaming.ActivePatternInfo * TypedTree.TType * int * Range.range - | ActivePatternCase of TypedTree.ActivePatternElemRef - | ExnCase of TypedTree.TyconRef - | RecdField of Infos.RecdFieldInfo - | UnionCaseField of Infos.UnionCaseInfo * fieldIndex: int - | AnonRecdField of - TypedTree.AnonRecdTypeInfo * TypedTree.TTypes * int * Range.range - | NewDef of SyntaxTree.Ident - | ILField of Infos.ILFieldInfo - | Event of Infos.EventInfo - | Property of string * Infos.PropInfo list - | MethodGroup of - displayName: string * methods: Infos.MethInfo list * - uninstantiatedMethodOpt: Infos.MethInfo option - | CtorGroup of string * Infos.MethInfo list - | FakeInterfaceCtor of TypedTree.TType - | DelegateCtor of TypedTree.TType - | Types of string * TypedTree.TType list - | CustomOperation of - string * (unit -> string option) * Infos.MethInfo option - | CustomBuilder of string * TypedTree.ValRef - | TypeVar of string * TypedTree.Typar - | ModuleOrNamespaces of TypedTree.ModuleOrNamespaceRef list - | ImplicitOp of SyntaxTree.Ident * TypedTree.TraitConstraintSln option ref - | ArgName of SyntaxTree.Ident * TypedTree.TType * ArgumentContainer option - | SetterArg of SyntaxTree.Ident * Item - | UnqualifiedType of TypedTree.TyconRef list - with - static member - MakeCtorGroup : nm:string * minfos:Infos.MethInfo list -> Item - static member - MakeMethGroup : nm:string * minfos:Infos.MethInfo list -> Item - member DisplayName : string - end - val valRefHash : vref:TypedTree.ValRef -> int - [] - type ItemWithInst = - { Item: Item - TyparInst: TypedTreeOps.TyparInst } - val ItemWithNoInst : Item -> ItemWithInst - val ( |ItemWithInst| ) : ItemWithInst -> Item * TypedTreeOps.TyparInst - type FieldResolution = | FieldResolution of Infos.RecdFieldInfo * bool - type ExtensionMember = - | FSExtMem of TypedTree.ValRef * Infos.ExtensionMethodPriority - | ILExtMem of - TypedTree.TyconRef * Infos.MethInfo * Infos.ExtensionMethodPriority - with - static member - Comparer : g:TcGlobals.TcGlobals -> - System.Collections.Generic.IEqualityComparer - static member - Equality : g:TcGlobals.TcGlobals -> - e1:ExtensionMember -> e2:ExtensionMember -> bool - static member Hash : e1:ExtensionMember -> int - member Priority : Infos.ExtensionMethodPriority - end - type FullyQualifiedFlag = - | FullyQualified - | OpenQualified - type UnqualifiedItems = AbstractIL.Internal.Library.LayeredMap - [] - type NameResolutionEnv = - { eDisplayEnv: TypedTreeOps.DisplayEnv - eUnqualifiedItems: UnqualifiedItems - eUnqualifiedEnclosingTypeInsts: - TypedTreeOps.TyconRefMap - ePatItems: AbstractIL.Internal.Library.NameMap - eModulesAndNamespaces: - AbstractIL.Internal.Library.NameMultiMap - eFullyQualifiedModulesAndNamespaces: - AbstractIL.Internal.Library.NameMultiMap - eFieldLabels: - AbstractIL.Internal.Library.NameMultiMap - eUnqualifiedRecordOrUnionTypeInsts: - TypedTreeOps.TyconRefMap - eTyconsByAccessNames: - AbstractIL.Internal.Library.LayeredMultiMap - eFullyQualifiedTyconsByAccessNames: - AbstractIL.Internal.Library.LayeredMultiMap - eTyconsByDemangledNameAndArity: - AbstractIL.Internal.Library.LayeredMap - eFullyQualifiedTyconsByDemangledNameAndArity: - AbstractIL.Internal.Library.LayeredMap - eIndexedExtensionMembers: TypedTreeOps.TyconRefMultiMap - eUnindexedExtensionMembers: ExtensionMember list - eTypars: AbstractIL.Internal.Library.NameMap } - with - static member Empty : g:TcGlobals.TcGlobals -> NameResolutionEnv - member FindUnqualifiedItem : string -> Item - member - ModulesAndNamespaces : fq:FullyQualifiedFlag -> - AbstractIL.Internal.Library.NameMultiMap - member - TyconsByAccessNames : fq:FullyQualifiedFlag -> - AbstractIL.Internal.Library.LayeredMultiMap - member - TyconsByDemangledNameAndArity : fq:FullyQualifiedFlag -> - AbstractIL.Internal.Library.LayeredMap - member DisplayEnv : TypedTreeOps.DisplayEnv - end - [] - type ResultCollectionSettings = - | AllResults - | AtMostOneResult - val NextExtensionMethodPriority : unit -> uint64 - val IsTyconRefUsedForCSharpStyleExtensionMembers : - g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool - val IsTypeUsedForCSharpStyleExtensionMembers : - g:TcGlobals.TcGlobals -> m:Range.range -> ty:TypedTree.TType -> bool - val IsMethInfoPlainCSharpStyleExtensionMember : - g:TcGlobals.TcGlobals -> - m:Range.range -> isEnclExtTy:bool -> minfo:Infos.MethInfo -> bool - val private GetCSharpStyleIndexedExtensionMembersForTyconRef : - amap:Import.ImportMap -> - m:Range.range -> - tcrefOfStaticClass:TypedTree.TyconRef -> - Choice<(TypedTree.TyconRef * ExtensionMember),ExtensionMember> list - val IntrinsicPropInfosOfTypeInScope : - infoReader:InfoReader.InfoReader -> - optFilter:string option -> - ad:AccessibilityLogic.AccessorDomain -> - findFlag:InfoReader.FindMemberFlag -> - m:Range.range -> ty:TypedTree.TType -> Infos.PropInfo list - val SelectPropInfosFromExtMembers : - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - optFilter:string option -> - declaringTy:TypedTree.TType -> - m:Range.range -> - extMemInfos:seq -> Infos.PropInfo list - val ExtensionPropInfosOfTypeInScope : - ResultCollectionSettings -> - InfoReader.InfoReader -> - NameResolutionEnv -> - string option -> - AccessibilityLogic.AccessorDomain -> - Range.range -> TypedTree.TType -> Infos.PropInfo list - val AllPropInfosOfTypeInScope : - ResultCollectionSettings -> - InfoReader.InfoReader -> - NameResolutionEnv -> - string option -> - AccessibilityLogic.AccessorDomain -> - InfoReader.FindMemberFlag -> - Range.range -> TypedTree.TType -> Infos.PropInfo list - val IntrinsicMethInfosOfType : - infoReader:InfoReader.InfoReader -> - optFilter:string option -> - ad:AccessibilityLogic.AccessorDomain -> - allowMultiIntfInst:Infos.AllowMultiIntfInstantiations -> - findFlag:InfoReader.FindMemberFlag -> - m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list - val TrySelectExtensionMethInfoOfILExtMem : - Range.range -> - Import.ImportMap -> - TypedTree.TType -> - TypedTree.TyconRef * Infos.MethInfo * Infos.ExtensionMethodPriority -> - Infos.MethInfo option - val SelectMethInfosFromExtMembers : - infoReader:InfoReader.InfoReader -> - optFilter:string option -> - apparentTy:TypedTree.TType -> - m:Range.range -> - extMemInfos:seq -> Infos.MethInfo list - val ExtensionMethInfosOfTypeInScope : - collectionSettings:ResultCollectionSettings -> - infoReader:InfoReader.InfoReader -> - nenv:NameResolutionEnv -> - optFilter:string option -> - m:Range.range -> ty:TypedTree.TType -> Infos.MethInfo list - val AllMethInfosOfTypeInScope : - ResultCollectionSettings -> - InfoReader.InfoReader -> - NameResolutionEnv -> - string option -> - AccessibilityLogic.AccessorDomain -> - InfoReader.FindMemberFlag -> - Range.range -> TypedTree.TType -> Infos.MethInfo list - [] - type BulkAdd = - | Yes - | No - val AddValRefsToItems : - bulkAddMode:BulkAdd -> - eUnqualifiedItems:UnqualifiedItems -> - vrefs:TypedTree.ValRef [] -> UnqualifiedItems - val AddValRefToExtensionMembers : - pri:Infos.ExtensionMethodPriority -> - eIndexedExtensionMembers:TypedTreeOps.TyconRefMultiMap -> - vref:TypedTree.ValRef -> - TypedTreeOps.TyconRefMultiMap - val AddFakeNamedValRefToNameEnv : - string -> NameResolutionEnv -> TypedTree.ValRef -> NameResolutionEnv - val AddFakeNameToNameEnv : - string -> NameResolutionEnv -> Item -> NameResolutionEnv - val AddValRefsToActivePatternsNameEnv : - ePatItems:Map -> vref:TypedTree.ValRef -> Map - val AddValRefsToNameEnvWithPriority : - bulkAddMode:BulkAdd -> - pri:Infos.ExtensionMethodPriority -> - nenv:NameResolutionEnv -> - vrefs:TypedTree.ValRef [] -> NameResolutionEnv - val AddValRefToNameEnv : - NameResolutionEnv -> TypedTree.ValRef -> NameResolutionEnv - val AddActivePatternResultTagsToNameEnv : - PrettyNaming.ActivePatternInfo -> - NameResolutionEnv -> TypedTree.TType -> Range.range -> NameResolutionEnv - val GeneralizeUnionCaseRef : - ucref:TypedTree.UnionCaseRef -> Infos.UnionCaseInfo - val AddTyconsByDemangledNameAndArity : - bulkAddMode:BulkAdd -> - tcrefs:TypedTree.TyconRef [] -> - tab:AbstractIL.Internal.Library.LayeredMap -> - AbstractIL.Internal.Library.LayeredMap - val AddTyconByAccessNames : - bulkAddMode:BulkAdd -> - tcrefs:TypedTree.TyconRef [] -> - tab:AbstractIL.Internal.Library.LayeredMultiMap -> - AbstractIL.Internal.Library.LayeredMultiMap - val AddRecdField : - rfref:TypedTree.RecdFieldRef -> - tab:AbstractIL.Internal.Library.NameMultiMap -> - Map - val AddUnionCases1 : - tab:Map -> - ucrefs:TypedTree.UnionCaseRef list -> Map - val AddUnionCases2 : - bulkAddMode:BulkAdd -> - eUnqualifiedItems:UnqualifiedItems -> - ucrefs:TypedTree.UnionCaseRef list -> Map - type TypeNameResolutionFlag = - | ResolveTypeNamesToCtors - | ResolveTypeNamesToTypeRefs - [] - type TypeNameResolutionStaticArgsInfo = - | Indefinite - | Definite of int - with - static member - FromTyArgs : numTyArgs:int -> TypeNameResolutionStaticArgsInfo - member MangledNameForType : nm:string -> string - member HasNoStaticArgsInfo : bool - member NumStaticArgs : int - static member DefiniteEmpty : TypeNameResolutionStaticArgsInfo - end - [] - type TypeNameResolutionInfo = - | TypeNameResolutionInfo of - TypeNameResolutionFlag * TypeNameResolutionStaticArgsInfo - with - static member - ResolveToTypeRefs : TypeNameResolutionStaticArgsInfo -> - TypeNameResolutionInfo - member DropStaticArgsInfo : TypeNameResolutionInfo - member ResolutionFlag : TypeNameResolutionFlag - member StaticArgsInfo : TypeNameResolutionStaticArgsInfo - static member Default : TypeNameResolutionInfo - end - [] - type PermitDirectReferenceToGeneratedType = - | Yes - | No - val CheckForDirectReferenceToGeneratedType : - tcref:TypedTree.TyconRef * genOk:PermitDirectReferenceToGeneratedType * - m:Range.range -> unit - val AddEntityForProvidedType : - amap:Import.ImportMap * modref:TypedTree.ModuleOrNamespaceRef * - resolutionEnvironment:ExtensionTyping.ResolutionEnvironment * - st:Tainted * m:Range.range -> - TypedTree.EntityRef - val ResolveProvidedTypeNameInEntity : - amap:Import.ImportMap * m:Range.range * typeName:string * - modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.EntityRef list - val LookupTypeNameInEntityHaveArity : - nm:string -> - staticResInfo:TypeNameResolutionStaticArgsInfo -> - mty:TypedTree.ModuleOrNamespaceType -> TypedTree.Tycon option - val LookupTypeNameNoArity : - nm:string -> - byDemangledNameAndArity:AbstractIL.Internal.Library.LayeredMap -> - byAccessNames:AbstractIL.Internal.Library.LayeredMultiMap -> - 'a list - val LookupTypeNameInEntityNoArity : - _m:'a -> - nm:string -> - mtyp:TypedTree.ModuleOrNamespaceType -> TypedTree.Tycon list - val LookupTypeNameInEntityMaybeHaveArity : - amap:Import.ImportMap * m:Range.range * - ad:AccessibilityLogic.AccessorDomain * nm:string * - staticResInfo:TypeNameResolutionStaticArgsInfo * - modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.EntityRef list - val GetNestedTyconRefsOfType : - infoReader:InfoReader.InfoReader -> - amap:Import.ImportMap -> - ad:AccessibilityLogic.AccessorDomain * optFilter:string option * - staticResInfo:TypeNameResolutionStaticArgsInfo * - checkForGenerated:bool * m:Range.range -> - ty:TypedTree.TType -> TypedTree.TypeInst * TypedTree.EntityRef list - val MakeNestedType : - ncenv:NameResolver -> - tinst:TypedTree.TType list -> - m:Range.range -> tcrefNested:TypedTree.TyconRef -> TypedTree.TType - val GetNestedTypesOfType : - ad:AccessibilityLogic.AccessorDomain * ncenv:NameResolver * - optFilter:string option * staticResInfo:TypeNameResolutionStaticArgsInfo * - checkForGenerated:bool * m:Range.range -> - ty:TypedTree.TType -> TypedTree.TType list - val ChooseMethInfosForNameEnv : - g:TcGlobals.TcGlobals -> - m:Range.range -> - ty:TypedTree.TType -> - minfos:Infos.MethInfo list -> - System.Collections.Generic.KeyValuePair list - val ChoosePropInfosForNameEnv : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> - pinfos:Infos.PropInfo list -> - System.Collections.Generic.KeyValuePair list - val ChooseFSharpFieldInfosForNameEnv : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> - rfinfos:Infos.RecdFieldInfo list -> - System.Collections.Generic.KeyValuePair list - val ChooseILFieldInfosForNameEnv : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> - finfos:Infos.ILFieldInfo list -> - System.Collections.Generic.KeyValuePair list - val ChooseEventInfosForNameEnv : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> - einfos:Infos.EventInfo list -> - System.Collections.Generic.KeyValuePair list - val AddStaticContentOfTypeToNameEnv : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - nenv:NameResolutionEnv -> ty:TypedTree.TType -> NameResolutionEnv - val private AddNestedTypesOfTypeToNameEnv : - infoReader:InfoReader.InfoReader -> - amap:Import.ImportMap -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - nenv:NameResolutionEnv -> ty:TypedTree.TType -> NameResolutionEnv - val private AddTyconRefsWithEnclosingTypeInstToNameEnv : - bulkAddMode:BulkAdd -> - ownDefinition:bool -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - root:bool -> - nenv:NameResolutionEnv -> - tinstEnclosing:TypedTree.TypeInst * - tcrefs:TypedTree.TyconRef list -> NameResolutionEnv - val private AddStaticPartsOfTypeToNameEnv : - amap:Import.ImportMap -> - m:Range.range -> - nenv:NameResolutionEnv -> ty:TypedTree.TType -> NameResolutionEnv - val private AddStaticPartsOfTyconRefToNameEnv : - bulkAddMode:BulkAdd -> - ownDefinition:bool -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - nenv:NameResolutionEnv -> - tinstOpt:TypedTree.TypeInst option -> - tcref:TypedTree.TyconRef -> NameResolutionEnv - val private CanAutoOpenTyconRef : - g:TcGlobals.TcGlobals -> m:Range.range -> tcref:TypedTree.TyconRef -> bool - val private AddPartsOfTyconRefToNameEnv : - bulkAddMode:BulkAdd -> - ownDefinition:bool -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - nenv:NameResolutionEnv -> - tcref:TypedTree.TyconRef -> NameResolutionEnv - val AddTyconRefsToNameEnv : - BulkAdd -> - bool -> - TcGlobals.TcGlobals -> - Import.ImportMap -> - AccessibilityLogic.AccessorDomain -> - Range.range -> - bool -> - NameResolutionEnv -> - TypedTree.TyconRef list -> NameResolutionEnv - val AddExceptionDeclsToNameEnv : - BulkAdd -> NameResolutionEnv -> TypedTree.TyconRef -> NameResolutionEnv - val AddModuleAbbrevToNameEnv : - SyntaxTree.Ident -> - NameResolutionEnv -> - TypedTree.ModuleOrNamespaceRef list -> NameResolutionEnv - val MakeNestedModuleRefs : - modref:TypedTree.ModuleOrNamespaceRef -> TypedTree.EntityRef list - val AddModuleOrNamespaceRefsToNameEnv : - TcGlobals.TcGlobals -> - Import.ImportMap -> - Range.range -> - bool -> - AccessibilityLogic.AccessorDomain -> - NameResolutionEnv -> - TypedTree.ModuleOrNamespaceRef list -> NameResolutionEnv - val AddModuleOrNamespaceContentsToNameEnv : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - root:bool -> - nenv:NameResolutionEnv -> - modref:TypedTree.ModuleOrNamespaceRef -> NameResolutionEnv - val AddModuleOrNamespaceRefsContentsToNameEnv : - TcGlobals.TcGlobals -> - Import.ImportMap -> - AccessibilityLogic.AccessorDomain -> - Range.range -> - bool -> - NameResolutionEnv -> - TypedTree.EntityRef list -> NameResolutionEnv - val AddTypeContentsToNameEnv : - TcGlobals.TcGlobals -> - Import.ImportMap -> - AccessibilityLogic.AccessorDomain -> - Range.range -> - NameResolutionEnv -> TypedTree.TType -> NameResolutionEnv - val AddModuleOrNamespaceRefContentsToNameEnv : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - root:bool -> - nenv:NameResolutionEnv -> - modref:TypedTree.EntityRef -> NameResolutionEnv - val AddModuleOrNamespaceRefToNameEnv : - TcGlobals.TcGlobals -> - Import.ImportMap -> - Range.range -> - bool -> - AccessibilityLogic.AccessorDomain -> - NameResolutionEnv -> TypedTree.EntityRef -> NameResolutionEnv - type CheckForDuplicateTyparFlag = - | CheckForDuplicateTypars - | NoCheckForDuplicateTypars - val AddDeclaredTyparsToNameEnv : - CheckForDuplicateTyparFlag -> - NameResolutionEnv -> TypedTree.Typar list -> NameResolutionEnv - val FreshenTycon : - ncenv:NameResolver -> - m:Range.range -> tcref:TypedTree.TyconRef -> TypedTree.TType - val FreshenTyconWithEnclosingTypeInst : - ncenv:NameResolver -> - m:Range.range -> - tinstEnclosing:TypedTree.TypeInst -> - tcref:TypedTree.TyconRef -> TypedTree.TType - val FreshenUnionCaseRef : - ncenv:NameResolver -> - m:Range.range -> ucref:TypedTree.UnionCaseRef -> Infos.UnionCaseInfo - val FreshenRecdFieldRef : - NameResolver -> - Range.range -> TypedTree.RecdFieldRef -> Infos.RecdFieldInfo - val ResolveUnqualifiedItem : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> m:Range.range -> res:Item -> Item - val OneResult : - res:AbstractIL.Internal.Library.ResultOrException<'a> -> - AbstractIL.Internal.Library.ResultOrException<'a list> - val OneSuccess : - x:'a -> AbstractIL.Internal.Library.ResultOrException<'a list> - val AddResults : - res1:AbstractIL.Internal.Library.ResultOrException<'a list> -> - res2:AbstractIL.Internal.Library.ResultOrException<'a list> -> - AbstractIL.Internal.Library.ResultOrException<'a list> - val NoResultsOrUsefulErrors : - AbstractIL.Internal.Library.ResultOrException<'a list> - val CollectResults : - f:('a -> AbstractIL.Internal.Library.ResultOrException<'b>) -> - _arg1:'a list -> AbstractIL.Internal.Library.ResultOrException<'b list> - val CollectAtMostOneResult : - f:('a -> AbstractIL.Internal.Library.ResultOrException<'b>) -> - inputs:'a list -> AbstractIL.Internal.Library.ResultOrException<'b list> - val CollectResults2 : - resultCollectionSettings:ResultCollectionSettings -> - f:('a -> AbstractIL.Internal.Library.ResultOrException<'b>) -> - ('a list -> AbstractIL.Internal.Library.ResultOrException<'b list>) - val MapResults : - f:('a -> 'b) -> - _arg1:AbstractIL.Internal.Library.ResultOrException<'a list> -> - AbstractIL.Internal.Library.ResultOrException<'b list> - val AtMostOneResult : - m:Range.range -> - res:AbstractIL.Internal.Library.ResultOrException<'a list> -> - AbstractIL.Internal.Library.ResultOrException<'a> - val AtMostOneResultQuery : - query2:(unit -> AbstractIL.Internal.Library.ResultOrException<'a list>) -> - res1:AbstractIL.Internal.Library.ResultOrException<'a list> -> - AbstractIL.Internal.Library.ResultOrException<'a list> - val inline ( +++ ) : - res1:AbstractIL.Internal.Library.ResultOrException<'a list> -> - query2:(unit -> AbstractIL.Internal.Library.ResultOrException<'a list>) -> - AbstractIL.Internal.Library.ResultOrException<'a list> - val LookupTypeNameInEnvHaveArity : - fq:FullyQualifiedFlag -> - nm:string -> - numTyArgs:int -> nenv:NameResolutionEnv -> TypedTree.TyconRef option - val LookupTypeNameInEnvNoArity : - FullyQualifiedFlag -> - string -> NameResolutionEnv -> TypedTree.TyconRef list - val LookupTypeNameInEnvMaybeHaveArity : - fq:FullyQualifiedFlag -> - nm:string -> - typeNameResInfo:TypeNameResolutionInfo -> - nenv:NameResolutionEnv -> TypedTree.TyconRef list - [] - type ItemOccurence = - | Binding - | Use - | UseInType - | UseInAttribute - | Pattern - | Implemented - | RelatedText - | Open - type OpenDeclaration = - { Target: SyntaxTree.SynOpenDeclTarget - Range: Range.range option - Modules: TypedTree.ModuleOrNamespaceRef list - Types: TypedTree.TType list - AppliedScope: Range.range - IsOwnNamespace: bool } - with - static member - Create : target:SyntaxTree.SynOpenDeclTarget * - modules:TypedTree.ModuleOrNamespaceRef list * - types:TypedTree.TType list * appliedScope:Range.range * - isOwnNamespace:bool -> OpenDeclaration - end - type FormatStringCheckContext = - { SourceText: Text.ISourceText - LineStartPositions: int [] } - type ITypecheckResultsSink = - interface - abstract member - NotifyEnvWithScope : Range.range * NameResolutionEnv * - AccessibilityLogic.AccessorDomain -> unit - abstract member - NotifyExprHasType : TypedTree.TType * NameResolutionEnv * - AccessibilityLogic.AccessorDomain * Range.range -> - unit - abstract member - NotifyFormatSpecifierLocation : Range.range * int -> unit - abstract member - NotifyMethodGroupNameResolution : Range.pos * Item * Item * - TypedTreeOps.TyparInst * - ItemOccurence * NameResolutionEnv * - AccessibilityLogic.AccessorDomain * - Range.range * bool -> unit - abstract member - NotifyNameResolution : Range.pos * Item * TypedTreeOps.TyparInst * - ItemOccurence * NameResolutionEnv * - AccessibilityLogic.AccessorDomain * Range.range * - bool -> unit - abstract member NotifyOpenDeclaration : OpenDeclaration -> unit - abstract member CurrentSourceText : Text.ISourceText option - abstract member - FormatStringCheckContext : FormatStringCheckContext option - end - val ( |ValRefOfProp|_| ) : pi:Infos.PropInfo -> TypedTree.ValRef option - val ( |ValRefOfMeth|_| ) : mi:Infos.MethInfo -> TypedTree.ValRef option - val ( |ValRefOfEvent|_| ) : evt:Infos.EventInfo -> TypedTree.ValRef option - val ( |RecordFieldUse|_| ) : - item:Item -> (string * TypedTree.TyconRef) option - val ( |UnionCaseFieldUse|_| ) : - item:Item -> (int * TypedTree.UnionCaseRef) option - val ( |ILFieldUse|_| ) : item:Item -> Infos.ILFieldInfo option - val ( |PropertyUse|_| ) : item:Item -> Infos.PropInfo option - val ( |FSharpPropertyUse|_| ) : item:Item -> TypedTree.ValRef option - val ( |MethodUse|_| ) : item:Item -> Infos.MethInfo option - val ( |FSharpMethodUse|_| ) : item:Item -> TypedTree.ValRef option - val ( |EntityUse|_| ) : item:Item -> TypedTree.TyconRef option - val ( |EventUse|_| ) : item:Item -> Infos.EventInfo option - val ( |FSharpEventUse|_| ) : item:Item -> TypedTree.ValRef option - val ( |UnionCaseUse|_| ) : item:Item -> TypedTree.UnionCaseRef option - val ( |ValUse|_| ) : item:Item -> TypedTree.ValRef option - val ( |ActivePatternCaseUse|_| ) : - item:Item -> (Range.range * Range.range * int) option - val tyconRefDefnHash : - _g:TcGlobals.TcGlobals -> eref1:TypedTree.EntityRef -> int - val tyconRefDefnEq : - g:TcGlobals.TcGlobals -> - eref1:TypedTree.EntityRef -> eref2:TypedTree.EntityRef -> bool - val valRefDefnHash : _g:TcGlobals.TcGlobals -> vref1:TypedTree.ValRef -> int - val valRefDefnEq : - g:TcGlobals.TcGlobals -> - vref1:TypedTree.ValRef -> vref2:TypedTree.ValRef -> bool - val unionCaseRefDefnEq : - g:TcGlobals.TcGlobals -> - uc1:TypedTree.UnionCaseRef -> uc2:TypedTree.UnionCaseRef -> bool - val ItemsAreEffectivelyEqual : TcGlobals.TcGlobals -> Item -> Item -> bool - val ItemsAreEffectivelyEqualHash : TcGlobals.TcGlobals -> Item -> int - [] - type CapturedNameResolution = - class - new : i:Item * tpinst:TypedTreeOps.TyparInst * io:ItemOccurence * - nre:NameResolutionEnv * ad:AccessibilityLogic.AccessorDomain * - m:Range.range -> CapturedNameResolution - member DebugToString : unit -> string - member AccessorDomain : AccessibilityLogic.AccessorDomain - member DisplayEnv : TypedTreeOps.DisplayEnv - member Item : Item - member ItemOccurence : ItemOccurence - member ItemWithInst : ItemWithInst - member NameResolutionEnv : NameResolutionEnv - member Pos : Range.pos - member Range : Range.range - end - [] - type TcResolutions = - class - new : capturedEnvs:ResizeArray * - capturedExprTypes:ResizeArray * - capturedNameResolutions:ResizeArray * - capturedMethodGroupResolutions:ResizeArray -> - TcResolutions - member - CapturedEnvs : ResizeArray - member - CapturedExpressionTypings : ResizeArray - member - CapturedMethodGroupResolutions : ResizeArray - member CapturedNameResolutions : ResizeArray - static member Empty : TcResolutions - end - [] - type TcSymbolUseData = - { Item: Item - ItemOccurence: ItemOccurence - DisplayEnv: TypedTreeOps.DisplayEnv - Range: Range.range } - [] - type TcSymbolUses = - class - new : g:TcGlobals.TcGlobals * - capturedNameResolutions:ResizeArray * - formatSpecifierLocations:(Range.range * int) [] -> TcSymbolUses - member - GetFormatSpecifierLocationsAndArity : unit -> (Range.range * int) [] - member GetUsesOfSymbol : Item -> TcSymbolUseData [] - member AllUsesOfSymbols : TcSymbolUseData [] [] - static member Empty : TcSymbolUses - end - type TcResultsSinkImpl = - class - interface ITypecheckResultsSink - new : tcGlobals:TcGlobals.TcGlobals * ?sourceText:Text.ISourceText -> - TcResultsSinkImpl - member GetFormatSpecifierLocations : unit -> (Range.range * int) [] - member GetOpenDeclarations : unit -> OpenDeclaration [] - member GetResolutions : unit -> TcResolutions - member GetSymbolUses : unit -> TcSymbolUses - end - type TcResultsSink = - { mutable CurrentSink: ITypecheckResultsSink option } - with - static member WithSink : ITypecheckResultsSink -> TcResultsSink - static member NoSink : TcResultsSink - end - val WithNewTypecheckResultsSink : - ITypecheckResultsSink * TcResultsSink -> System.IDisposable - val TemporarilySuspendReportingTypecheckResultsToSink : - TcResultsSink -> System.IDisposable - val CallEnvSink : - TcResultsSink -> - Range.range * NameResolutionEnv * AccessibilityLogic.AccessorDomain -> - unit - val CallNameResolutionSink : - TcResultsSink -> - Range.range * NameResolutionEnv * Item * TypedTreeOps.TyparInst * - ItemOccurence * AccessibilityLogic.AccessorDomain -> unit - val CallMethodGroupNameResolutionSink : - TcResultsSink -> - Range.range * NameResolutionEnv * Item * Item * TypedTreeOps.TyparInst * - ItemOccurence * AccessibilityLogic.AccessorDomain -> unit - val CallNameResolutionSinkReplacing : - TcResultsSink -> - Range.range * NameResolutionEnv * Item * TypedTreeOps.TyparInst * - ItemOccurence * AccessibilityLogic.AccessorDomain -> unit - val CallExprHasTypeSink : - TcResultsSink -> - Range.range * NameResolutionEnv * TypedTree.TType * - AccessibilityLogic.AccessorDomain -> unit - val CallOpenDeclarationSink : TcResultsSink -> OpenDeclaration -> unit - type ResultTyparChecker = | ResultTyparChecker of (unit -> bool) - val CheckAllTyparsInferrable : - amap:Import.ImportMap -> m:Range.range -> item:Item -> bool - type ResolutionInfo = - | ResolutionInfo of - (Range.range * TypedTree.EntityRef) list * (ResultTyparChecker -> unit) * - tinstEnclosing: EnclosingTypeInst - with - static member - SendEntityPathToSink : sink:TcResultsSink * ncenv:NameResolver * - nenv:NameResolutionEnv * occ:ItemOccurence * - ad:AccessibilityLogic.AccessorDomain * - ResolutionInfo * - typarChecker:ResultTyparChecker -> unit - member - AddEntity : info:(Range.range * TypedTree.EntityRef) -> ResolutionInfo - member AddWarning : f:(ResultTyparChecker -> unit) -> ResolutionInfo - member - WithEnclosingTypeInst : tinstEnclosing:EnclosingTypeInst -> - ResolutionInfo - member EnclosingTypeInst : EnclosingTypeInst - static member Empty : ResolutionInfo - end - val CheckForTypeLegitimacyAndMultipleGenericTypeAmbiguities : - tcrefs:(ResolutionInfo * TypedTree.TyconRef) list * - typeNameResInfo:TypeNameResolutionInfo * - genOk:PermitDirectReferenceToGeneratedType * m:Range.range -> - (ResolutionInfo * TypedTree.TyconRef) list - val ResolveLongIdentAsModuleOrNamespace : - TcResultsSink -> - ResultCollectionSettings -> - Import.ImportMap -> - Range.range -> - first:bool -> - FullyQualifiedFlag -> - NameResolutionEnv -> - AccessibilityLogic.AccessorDomain -> - SyntaxTree.Ident -> - SyntaxTree.Ident list -> - isOpenDecl:bool -> - AbstractIL.Internal.Library.ResultOrException<(int * - TypedTree.ModuleOrNamespaceRef * - TypedTree.ModuleOrNamespaceType) list> - val ResolveLongIdentAsModuleOrNamespaceThen : - sink:TcResultsSink -> - atMostOne:ResultCollectionSettings -> - amap:Import.ImportMap -> - m:Range.range -> - fullyQualified:FullyQualifiedFlag -> - nenv:NameResolutionEnv -> - ad:AccessibilityLogic.AccessorDomain -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - isOpenDecl:bool -> - f:(ResolutionInfo -> int -> Range.range -> - TypedTree.ModuleOrNamespaceRef -> - TypedTree.ModuleOrNamespaceType -> - SyntaxTree.Ident -> SyntaxTree.Ident list -> - AbstractIL.Internal.Library.ResultOrException<'a>) -> - AbstractIL.Internal.Library.ResultOrException<'a list> - val private ResolveObjectConstructorPrim : - ncenv:NameResolver -> - edenv:TypedTreeOps.DisplayEnv -> - resInfo:'a -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - ty:TypedTree.TType -> - AbstractIL.Internal.Library.ResultOrException<'a * Item> - val ResolveObjectConstructor : - NameResolver -> - TypedTreeOps.DisplayEnv -> - Range.range -> - AccessibilityLogic.AccessorDomain -> - TypedTree.TType -> - AbstractIL.Internal.Library.ResultOrException - exception IndeterminateType of Range.range - [] - type LookupKind = - | RecdField - | Pattern - | Expr - | Type - | Ctor - val TryFindUnionCaseOfType : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> nm:string -> Infos.UnionCaseInfo voption - val TryFindAnonRecdFieldOfType : - TcGlobals.TcGlobals -> TypedTree.TType -> string -> Item option - val CoreDisplayName : pinfo:Infos.PropInfo -> string - val DecodeFSharpEvent : - pinfos:Infos.PropInfo list -> - ad:AccessibilityLogic.AccessorDomain -> - g:TcGlobals.TcGlobals -> - ncenv:NameResolver -> m:Range.range -> Item option - val GetRecordLabelsForType : - g:TcGlobals.TcGlobals -> - nenv:NameResolutionEnv -> - ty:TypedTree.TType -> System.Collections.Generic.HashSet - val CheckNestedTypesOfType : - ncenv:NameResolver -> - resInfo:ResolutionInfo -> - ad:AccessibilityLogic.AccessorDomain -> - nm:string -> - typeNameResInfo:TypeNameResolutionInfo -> - m:Range.range -> ty:TypedTree.TType -> TypedTree.TType list - val ResolveLongIdentInTypePrim : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - lookupKind:LookupKind -> - resInfo:ResolutionInfo -> - depth:int -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - findFlag:InfoReader.FindMemberFlag -> - typeNameResInfo:TypeNameResolutionInfo -> - ty:TypedTree.TType -> - AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * - Item * - SyntaxTree.Ident list) list> - val ResolveLongIdentInNestedTypes : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - lookupKind:LookupKind -> - resInfo:ResolutionInfo -> - depth:int -> - id:SyntaxTree.Ident -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - id2:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - findFlag:InfoReader.FindMemberFlag -> - typeNameResInfo:TypeNameResolutionInfo -> - tys:TypedTree.TType list -> - AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * - Item * - SyntaxTree.Ident list) list> - val ResolveLongIdentInType : - TcResultsSink -> - NameResolver -> - NameResolutionEnv -> - LookupKind -> - Range.range -> - AccessibilityLogic.AccessorDomain -> - SyntaxTree.Ident -> - InfoReader.FindMemberFlag -> - TypeNameResolutionInfo -> - TypedTree.TType -> Item * SyntaxTree.Ident list - val private ResolveLongIdentInTyconRef : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - lookupKind:LookupKind -> - resInfo:ResolutionInfo -> - depth:int -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - typeNameResInfo:TypeNameResolutionInfo -> - tcref:TypedTree.TyconRef -> - AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * - Item * - SyntaxTree.Ident list) list> - val private ResolveLongIdentInTyconRefs : - atMostOne:ResultCollectionSettings -> - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - lookupKind:LookupKind -> - depth:int -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - typeNameResInfo:TypeNameResolutionInfo -> - idRange:Range.range -> - tcrefs:(ResolutionInfo * TypedTree.EntityRef) list -> - AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * - Item * - SyntaxTree.Ident list) list> - val ( |AccessibleEntityRef|_| ) : - amap:Import.ImportMap -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - modref:TypedTree.ModuleOrNamespaceRef -> - mspec:TypedTree.Entity -> TypedTree.EntityRef option - val ResolveExprLongIdentInModuleOrNamespace : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - typeNameResInfo:TypeNameResolutionInfo -> - ad:AccessibilityLogic.AccessorDomain -> - resInfo:ResolutionInfo -> - depth:int -> - m:Range.range -> - modref:TypedTree.EntityRef -> - mty:TypedTree.ModuleOrNamespaceType -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - AbstractIL.Internal.Library.ResultOrException - val ChooseTyconRefInExpr : - ncenv:NameResolver * m:Range.range * ad:AccessibilityLogic.AccessorDomain * - nenv:NameResolutionEnv * id:SyntaxTree.Ident * - typeNameResInfo:TypeNameResolutionInfo * - tcrefs:(ResolutionInfo * TypedTree.TyconRef) list -> - AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * Item) list> - val ResolveUnqualifiedTyconRefs : - nenv:NameResolutionEnv -> - tcrefs:TypedTree.TyconRef list -> - (ResolutionInfo * TypedTree.TyconRef) list - val ResolveExprLongIdentPrim : - sink:TcResultsSink -> - ncenv:NameResolver -> - first:bool -> - fullyQualified:FullyQualifiedFlag -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - nenv:NameResolutionEnv -> - typeNameResInfo:TypeNameResolutionInfo -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - isOpenDecl:bool -> - AbstractIL.Internal.Library.ResultOrException - val ResolveExprLongIdent : - TcResultsSink -> - NameResolver -> - Range.range -> - AccessibilityLogic.AccessorDomain -> - NameResolutionEnv -> - TypeNameResolutionInfo -> - SyntaxTree.Ident list -> - AbstractIL.Internal.Library.ResultOrException - val ResolvePatternLongIdentInModuleOrNamespace : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - numTyArgsOpt:TypeNameResolutionInfo -> - ad:AccessibilityLogic.AccessorDomain -> - resInfo:ResolutionInfo -> - depth:int -> - m:Range.range -> - modref:TypedTree.ModuleOrNamespaceRef -> - mty:TypedTree.ModuleOrNamespaceType -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - AbstractIL.Internal.Library.ResultOrException - exception UpperCaseIdentifierInPattern of Range.range - type WarnOnUpperFlag = - | WarnOnUpperCase - | AllIdsOK - val ResolvePatternLongIdentPrim : - sink:TcResultsSink -> - ncenv:NameResolver -> - fullyQualified:FullyQualifiedFlag -> - warnOnUpper:WarnOnUpperFlag -> - newDef:bool -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - nenv:NameResolutionEnv -> - numTyArgsOpt:TypeNameResolutionInfo -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> Item - val ResolvePatternLongIdent : - TcResultsSink -> - NameResolver -> - WarnOnUpperFlag -> - bool -> - Range.range -> - AccessibilityLogic.AccessorDomain -> - NameResolutionEnv -> - TypeNameResolutionInfo -> SyntaxTree.Ident list -> Item - val ResolveNestedTypeThroughAbbreviation : - ncenv:NameResolver -> - tcref:TypedTree.TyconRef -> m:Range.range -> TypedTree.TyconRef - val ResolveTypeLongIdentInTyconRefPrim : - ncenv:NameResolver -> - typeNameResInfo:TypeNameResolutionInfo -> - ad:AccessibilityLogic.AccessorDomain -> - resInfo:ResolutionInfo -> - genOk:PermitDirectReferenceToGeneratedType -> - depth:int -> - m:Range.range -> - tcref:TypedTree.TyconRef -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - AbstractIL.Internal.Library.ResultOrException - val ResolveTypeLongIdentInTyconRef : - TcResultsSink -> - NameResolver -> - NameResolutionEnv -> - TypeNameResolutionInfo -> - AccessibilityLogic.AccessorDomain -> - Range.range -> - TypedTree.TyconRef -> - SyntaxTree.Ident list -> TypedTree.TyconRef - val SuggestTypeLongIdentInModuleOrNamespace : - depth:int -> - modref:TypedTree.ModuleOrNamespaceRef -> - amap:Import.ImportMap -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> id:SyntaxTree.Ident -> exn - val private ResolveTypeLongIdentInModuleOrNamespace : - sink:TcResultsSink -> - nenv:NameResolutionEnv -> - ncenv:NameResolver -> - typeNameResInfo:TypeNameResolutionInfo -> - ad:AccessibilityLogic.AccessorDomain -> - genOk:PermitDirectReferenceToGeneratedType -> - resInfo:ResolutionInfo -> - depth:int -> - m:Range.range -> - modref:TypedTree.ModuleOrNamespaceRef -> - _mty:TypedTree.ModuleOrNamespaceType -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - AbstractIL.Internal.Library.ResultOrException<(ResolutionInfo * - TypedTree.EntityRef) list> - val ResolveTypeLongIdentPrim : - sink:TcResultsSink -> - ncenv:NameResolver -> - occurence:ItemOccurence -> - first:bool -> - fullyQualified:FullyQualifiedFlag -> - m:Range.range -> - nenv:NameResolutionEnv -> - ad:AccessibilityLogic.AccessorDomain -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - staticResInfo:TypeNameResolutionStaticArgsInfo -> - genOk:PermitDirectReferenceToGeneratedType -> - AbstractIL.Internal.Library.ResultOrException - val ResolveTypeLongIdentAux : - sink:TcResultsSink -> - ncenv:NameResolver -> - occurence:ItemOccurence -> - fullyQualified:FullyQualifiedFlag -> - nenv:NameResolutionEnv -> - ad:AccessibilityLogic.AccessorDomain -> - lid:SyntaxTree.Ident list -> - staticResInfo:TypeNameResolutionStaticArgsInfo -> - genOk:PermitDirectReferenceToGeneratedType -> - AbstractIL.Internal.Library.ResultOrException - val ResolveTypeLongIdent : - TcResultsSink -> - NameResolver -> - ItemOccurence -> - FullyQualifiedFlag -> - NameResolutionEnv -> - AccessibilityLogic.AccessorDomain -> - SyntaxTree.Ident list -> - TypeNameResolutionStaticArgsInfo -> - PermitDirectReferenceToGeneratedType -> - AbstractIL.Internal.Library.ResultOrException - val ResolveFieldInModuleOrNamespace : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - ad:AccessibilityLogic.AccessorDomain -> - resInfo:ResolutionInfo -> - depth:int -> - m:Range.range -> - modref:TypedTree.ModuleOrNamespaceRef -> - _mty:TypedTree.ModuleOrNamespaceType -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - AbstractIL.Internal.Library.ResultOrException - val SuggestOtherLabelsOfSameRecordType : - g:TcGlobals.TcGlobals -> - nenv:NameResolutionEnv -> - ty:TypedTree.TType -> - id:SyntaxTree.Ident -> - allFields:SyntaxTree.Ident list -> - System.Collections.Generic.HashSet - val SuggestLabelsOfRelatedRecords : - g:TcGlobals.TcGlobals -> - nenv:NameResolutionEnv -> - id:SyntaxTree.Ident -> allFields:SyntaxTree.Ident list -> exn - val ResolveFieldPrim : - sink:TcResultsSink -> - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - ad:AccessibilityLogic.AccessorDomain -> - ty:TypedTree.TType -> - mp:SyntaxTree.Ident list * id:SyntaxTree.Ident -> - allFields:SyntaxTree.Ident list -> - (ResolutionInfo * FieldResolution) list - val ResolveField : - TcResultsSink -> - NameResolver -> - NameResolutionEnv -> - AccessibilityLogic.AccessorDomain -> - TypedTree.TType -> - SyntaxTree.Ident list * SyntaxTree.Ident -> - SyntaxTree.Ident list -> FieldResolution list - val private ResolveExprDotLongIdent : - ncenv:NameResolver -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - nenv:NameResolutionEnv -> - ty:TypedTree.TType -> - id:SyntaxTree.Ident -> - rest:SyntaxTree.Ident list -> - typeNameResInfo:TypeNameResolutionInfo -> - findFlag:InfoReader.FindMemberFlag -> - ResolutionInfo * Item * SyntaxTree.Ident list - val ComputeItemRange : - wholem:Range.range -> - lid:SyntaxTree.Ident list -> rest:'a list -> Range.range - val FilterMethodGroups : - ncenv:NameResolver -> - itemRange:Range.range -> item:Item -> staticOnly:bool -> Item - val NeedsWorkAfterResolution : namedItem:Item -> bool - [] - type AfterResolution = - | DoNothing - | RecordResolution of - Item option * (TypedTreeOps.TyparInst -> unit) * - (Infos.MethInfo * Infos.PropInfo option * TypedTreeOps.TyparInst -> unit) * - (unit -> unit) - val ResolveLongIdentAsExprAndComputeRange : - TcResultsSink -> - NameResolver -> - Range.range -> - AccessibilityLogic.AccessorDomain -> - NameResolutionEnv -> - TypeNameResolutionInfo -> - SyntaxTree.Ident list -> - AbstractIL.Internal.Library.ResultOrException - val ( |NonOverridable|_| ) : namedItem:Item -> unit option - val ResolveExprDotLongIdentAndComputeRange : - TcResultsSink -> - NameResolver -> - Range.range -> - AccessibilityLogic.AccessorDomain -> - NameResolutionEnv -> - TypedTree.TType -> - SyntaxTree.Ident list -> - TypeNameResolutionInfo -> - InfoReader.FindMemberFlag -> - bool -> - Item * Range.range * SyntaxTree.Ident list * - AfterResolution - val FakeInstantiationGenerator : - Range.range -> TypedTree.Typar list -> TypedTree.TType list - val ItemForModuleOrNamespaceRef : v:TypedTree.ModuleOrNamespaceRef -> Item - val ItemForPropInfo : pinfo:Infos.PropInfo -> Item - val IsTyconUnseenObsoleteSpec : - ad:AccessibilityLogic.AccessorDomain -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> x:TypedTree.TyconRef -> allowObsolete:bool -> bool - val IsTyconUnseen : - ad:AccessibilityLogic.AccessorDomain -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> m:Range.range -> x:TypedTree.TyconRef -> bool - val IsValUnseen : - ad:AccessibilityLogic.AccessorDomain -> - g:TcGlobals.TcGlobals -> m:'a -> v:TypedTree.ValRef -> bool - val IsUnionCaseUnseen : - ad:AccessibilityLogic.AccessorDomain -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> ucref:TypedTree.UnionCaseRef -> bool - val ItemIsUnseen : - ad:AccessibilityLogic.AccessorDomain -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> m:Range.range -> item:Item -> bool - val ItemOfTyconRef : - ncenv:NameResolver -> m:Range.range -> x:TypedTree.TyconRef -> Item - val ItemOfTy : g:TcGlobals.TcGlobals -> x:TypedTree.TType -> Item - val IsInterestingModuleName : nm:string -> bool - val PartialResolveLookupInModuleOrNamespaceAsModuleOrNamespaceThen : - f:(TypedTree.ModuleOrNamespaceRef -> 'a list) -> - plid:string list -> modref:TypedTree.ModuleOrNamespaceRef -> 'a list - val PartialResolveLongIdentAsModuleOrNamespaceThen : - nenv:NameResolutionEnv -> - plid:string list -> - f:(TypedTree.ModuleOrNamespaceRef -> 'a list) -> 'a list - val ResolveRecordOrClassFieldsOfType : - NameResolver -> - Range.range -> - AccessibilityLogic.AccessorDomain -> - TypedTree.TType -> bool -> Item list - [] - type ResolveCompletionTargets = - | All of (Infos.MethInfo -> TypedTree.TType -> bool) - | SettablePropertiesAndFields - with - member ResolveAll : bool - end - val ResolveCompletionsInType : - NameResolver -> - NameResolutionEnv -> - ResolveCompletionTargets -> - Range.range -> - AccessibilityLogic.AccessorDomain -> - bool -> TypedTree.TType -> Item list - val ResolvePartialLongIdentInType : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - isApplicableMeth:ResolveCompletionTargets -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - statics:bool -> - plid:string list -> ty:TypedTree.TType -> Item list - val InfosForTyconConstructors : - ncenv:NameResolver -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - tcref:TypedTree.TyconRef -> Item list - val inline notFakeContainerModule : - tyconNames:System.Collections.Generic.HashSet<'a> -> nm:'a -> bool - val getFakeContainerModulesFromTycons : - tycons:#seq -> System.Collections.Generic.HashSet - val getFakeContainerModulesFromTyconRefs : - tyconRefs:#seq -> - System.Collections.Generic.HashSet - val private EntityRefContainsSomethingAccessible : - ncenv:NameResolver -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - modref:TypedTree.ModuleOrNamespaceRef -> bool - val ResolvePartialLongIdentInModuleOrNamespace : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - isApplicableMeth:ResolveCompletionTargets -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - modref:TypedTree.ModuleOrNamespaceRef -> - plid:string list -> allowObsolete:bool -> Item list - val TryToResolveLongIdentAsType : - NameResolver -> - NameResolutionEnv -> - Range.range -> string list -> TypedTree.TType option - val ResolvePartialLongIdentPrim : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - isApplicableMeth:ResolveCompletionTargets -> - fullyQualified:FullyQualifiedFlag -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - plid:string list -> allowObsolete:bool -> Item list - val ResolvePartialLongIdent : - NameResolver -> - NameResolutionEnv -> - (Infos.MethInfo -> TypedTree.TType -> bool) -> - Range.range -> - AccessibilityLogic.AccessorDomain -> - string list -> bool -> Item list - val ResolvePartialLongIdentInModuleOrNamespaceForRecordFields : - ncenv:NameResolver -> - nenv:'a -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - modref:TypedTree.ModuleOrNamespaceRef -> - plid:string list -> allowObsolete:bool -> Item list - val ResolvePartialLongIdentToClassOrRecdFields : - NameResolver -> - NameResolutionEnv -> - Range.range -> - AccessibilityLogic.AccessorDomain -> - string list -> bool -> Item list - val ResolvePartialLongIdentToClassOrRecdFieldsImpl : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - fullyQualified:FullyQualifiedFlag -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - plid:string list -> allowObsolete:bool -> Item list - val ResolveCompletionsInTypeForItem : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - statics:bool -> ty:TypedTree.TType -> item:Item -> seq - val ResolvePartialLongIdentInTypeForItem : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - statics:bool -> - plid:string list -> item:Item -> ty:TypedTree.TType -> seq - val ResolvePartialLongIdentInModuleOrNamespaceForItem : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - modref:TypedTree.ModuleOrNamespaceRef -> - plid:string list -> item:Item -> seq - val PartialResolveLookupInModuleOrNamespaceAsModuleOrNamespaceThenLazy : - f:(TypedTree.ModuleOrNamespaceRef -> seq<'a>) -> - plid:string list -> modref:TypedTree.ModuleOrNamespaceRef -> seq<'a> - val PartialResolveLongIdentAsModuleOrNamespaceThenLazy : - nenv:NameResolutionEnv -> - plid:string list -> - f:(TypedTree.ModuleOrNamespaceRef -> seq<'a>) -> seq<'a> - val GetCompletionForItem : - ncenv:NameResolver -> - nenv:NameResolutionEnv -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - plid:string list -> item:Item -> seq - val IsItemResolvable : - NameResolver -> - NameResolutionEnv -> - Range.range -> - AccessibilityLogic.AccessorDomain -> string list -> Item -> bool - val GetVisibleNamespacesAndModulesAtPoint : - NameResolver -> - NameResolutionEnv -> - Range.range -> - AccessibilityLogic.AccessorDomain -> - TypedTree.ModuleOrNamespaceRef list - end - -namespace FSharp.Compiler - module internal SignatureConformance = begin - exception RequiredButNotSpecified of - TypedTreeOps.DisplayEnv * - TypedTree.ModuleOrNamespaceRef * string * - (System.Text.StringBuilder -> unit) * - Range.range - exception ValueNotContained of - TypedTreeOps.DisplayEnv * - TypedTree.ModuleOrNamespaceRef * TypedTree.Val * - TypedTree.Val * - (string * string * string -> string) - exception ConstrNotContained of - TypedTreeOps.DisplayEnv * TypedTree.UnionCase * - TypedTree.UnionCase * - (string * string -> string) - exception ExnconstrNotContained of - TypedTreeOps.DisplayEnv * TypedTree.Tycon * - TypedTree.Tycon * - (string * string -> string) - exception FieldNotContained of - TypedTreeOps.DisplayEnv * TypedTree.RecdField * - TypedTree.RecdField * - (string * string -> string) - exception InterfaceNotRevealed of - TypedTreeOps.DisplayEnv * TypedTree.TType * - Range.range - type Checker = - class - new : g:TcGlobals.TcGlobals * amap:Import.ImportMap * - denv:TypedTreeOps.DisplayEnv * - remapInfo:TypedTreeOps.SignatureRepackageInfo * checkingSig:bool -> - Checker - member - CheckSignature : aenv:TypedTreeOps.TypeEquivEnv -> - implModRef:TypedTree.ModuleOrNamespaceRef -> - signModType:TypedTree.ModuleOrNamespaceType -> - bool - member - CheckTypars : m:Range.range -> - aenv:TypedTreeOps.TypeEquivEnv -> - implTypars:TypedTree.Typars -> - signTypars:TypedTree.Typars -> bool - end - val CheckNamesOfModuleOrNamespaceContents : - denv:TypedTreeOps.DisplayEnv -> - implModRef:TypedTree.ModuleOrNamespaceRef -> - signModType:TypedTree.ModuleOrNamespaceType -> bool - val CheckNamesOfModuleOrNamespace : - denv:TypedTreeOps.DisplayEnv -> - implModRef:TypedTree.ModuleOrNamespaceRef -> - signModType:TypedTree.ModuleOrNamespaceType -> bool - end - -namespace FSharp.Compiler - module internal MethodOverrides = begin - type OverrideCanImplement = - | CanImplementAnyInterfaceSlot - | CanImplementAnyClassHierarchySlot - | CanImplementAnySlot - | CanImplementNoSlots - type OverrideInfo = - | Override of - OverrideCanImplement * TypedTree.TyconRef * SyntaxTree.Ident * - (TypedTree.Typars * TypedTreeOps.TyparInst) * TypedTree.TType list list * - TypedTree.TType option * bool * bool - with - member ArgTypes : TypedTree.TType list list - member BoundingTyconRef : TypedTree.TyconRef - member CanImplement : OverrideCanImplement - member IsCompilerGenerated : bool - member IsFakeEventProperty : bool - member LogicalName : string - member Range : Range.range - member ReturnType : TypedTree.TType option - end - type RequiredSlot = - | RequiredSlot of Infos.MethInfo * isOptional: bool - | DefaultInterfaceImplementationSlot of - Infos.MethInfo * isOptional: bool * possiblyNoMostSpecific: bool - with - member HasDefaultInterfaceImplementation : bool - member IsOptional : bool - member MethodInfo : Infos.MethInfo - member PossiblyNoMostSpecificImplementation : bool - end - type SlotImplSet = - | SlotImplSet of - RequiredSlot list * - AbstractIL.Internal.Library.NameMultiMap * - OverrideInfo list * Infos.PropInfo list - exception TypeIsImplicitlyAbstract of Range.range - exception OverrideDoesntOverride of - TypedTreeOps.DisplayEnv * OverrideInfo * - Infos.MethInfo option * - TcGlobals.TcGlobals * Import.ImportMap * - Range.range - module DispatchSlotChecking = begin - val PrintOverrideToBuffer : - denv:TypedTreeOps.DisplayEnv -> - os:System.Text.StringBuilder -> OverrideInfo -> unit - val PrintMethInfoSigToBuffer : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - os:System.Text.StringBuilder -> minfo:Infos.MethInfo -> unit - val FormatOverride : - denv:TypedTreeOps.DisplayEnv -> d:OverrideInfo -> string - val FormatMethInfoSig : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> d:Infos.MethInfo -> string - val GetInheritedMemberOverrideInfo : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - parentType:OverrideCanImplement -> - minfo:Infos.MethInfo -> OverrideInfo - val GetTypeMemberOverrideInfo : - g:TcGlobals.TcGlobals -> - reqdTy:TypedTree.TType -> overrideBy:TypedTree.ValRef -> OverrideInfo - val GetObjectExprOverrideInfo : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - implty:TypedTree.TType * id:SyntaxTree.Ident * - memberFlags:SyntaxTree.MemberFlags * ty:TypedTree.TType * - arityInfo:TypedTree.ValReprInfo * bindingAttribs:TypedTree.Attribs * - rhsExpr:TypedTree.Expr -> - OverrideInfo * - (TypedTree.Val option * TypedTree.Val * TypedTree.Val list list * - TypedTree.Attribs * TypedTree.Expr) - val IsNameMatch : - dispatchSlot:Infos.MethInfo -> overrideBy:OverrideInfo -> bool - val IsImplMatch : - g:TcGlobals.TcGlobals -> - dispatchSlot:Infos.MethInfo -> overrideBy:OverrideInfo -> bool - val IsTyparKindMatch : Infos.CompiledSig -> OverrideInfo -> bool - val IsSigPartialMatch : - g:TcGlobals.TcGlobals -> - dispatchSlot:Infos.MethInfo -> - compiledSig:Infos.CompiledSig -> OverrideInfo -> bool - val IsPartialMatch : - g:TcGlobals.TcGlobals -> - dispatchSlot:Infos.MethInfo -> - compiledSig:Infos.CompiledSig -> overrideBy:OverrideInfo -> bool - val ReverseTyparRenaming : - g:TcGlobals.TcGlobals -> - tinst:(TypedTree.Typar * TypedTree.TType) list -> - (TypedTree.Typar * TypedTree.TType) list - val ComposeTyparInsts : - inst1:('a * TypedTree.TType) list -> - inst2:TypedTreeOps.TyparInst -> ('a * TypedTree.TType) list - val IsSigExactMatch : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> dispatchSlot:Infos.MethInfo -> OverrideInfo -> bool - val IsExactMatch : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - dispatchSlot:Infos.MethInfo -> overrideBy:OverrideInfo -> bool - val OverrideImplementsDispatchSlot : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - dispatchSlot:Infos.MethInfo -> - availPriorOverride:OverrideInfo -> bool - val DispatchSlotIsAlreadyImplemented : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - availPriorOverridesKeyed:AbstractIL.Internal.Library.NameMultiMap -> - dispatchSlot:Infos.MethInfo -> bool - val CheckDispatchSlotsAreImplemented : - denv:TypedTreeOps.DisplayEnv * infoReader:InfoReader.InfoReader * - m:Range.range * nenv:NameResolution.NameResolutionEnv * - sink:NameResolution.TcResultsSink * isOverallTyAbstract:bool * - reqdTy:TypedTree.TType * dispatchSlots:RequiredSlot list * - availPriorOverrides:OverrideInfo list * overrides:OverrideInfo list -> - bool - val GetMostSpecificOverrideInterfaceMethodSets : - infoReader:InfoReader.InfoReader -> - allReqdTys:(TypedTree.TType * Range.range) list -> - Map - val GetMostSpecificOverrideInterfaceMethodsByMethod : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - mostSpecificOverrides:AbstractIL.Internal.Library.NameMultiMap -> - minfo:Infos.MethInfo -> (TypedTree.TType * Infos.MethInfo) list - val GetInterfaceDispatchSlots : - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - availImpliedInterfaces:TypedTree.TType list -> - mostSpecificOverrides:AbstractIL.Internal.Library.NameMultiMap -> - interfaceTy:TypedTree.TType -> RequiredSlot list - val GetClassDispatchSlots : - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> reqdTy:TypedTree.TType -> RequiredSlot list - val GetDispatchSlotSet : - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> - availImpliedInterfaces:TypedTree.TType list -> - mostSpecificOverrides:AbstractIL.Internal.Library.NameMultiMap -> - reqdTy:TypedTree.TType -> - impliedTys:seq -> - (TypedTree.TType * RequiredSlot list) list - val CheckOverridesAreAllUsedOnce : - denv:TypedTreeOps.DisplayEnv * g:TcGlobals.TcGlobals * - amap:Import.ImportMap * isObjExpr:bool * reqdTy:TypedTree.TType * - dispatchSlotsKeyed:AbstractIL.Internal.Library.NameMultiMap * - availPriorOverrides:OverrideInfo list * overrides:OverrideInfo list -> - unit - val GetSlotImplSets : - infoReader:InfoReader.InfoReader -> - denv:TypedTreeOps.DisplayEnv -> - ad:AccessibilityLogic.AccessorDomain -> - isObjExpr:bool -> - allReqdTys:(TypedTree.TType * Range.range) list -> - SlotImplSet list - val CheckImplementationRelationAtEndOfInferenceScope : - infoReader:InfoReader.InfoReader * denv:TypedTreeOps.DisplayEnv * - nenv:NameResolution.NameResolutionEnv * - sink:NameResolution.TcResultsSink * tycon:TypedTree.Tycon * - isImplementation:bool -> unit - end - val FinalTypeDefinitionChecksAtEndOfInferenceScope : - infoReader:InfoReader.InfoReader * nenv:NameResolution.NameResolutionEnv * - sink:NameResolution.TcResultsSink * isImplementation:bool * - denv:TypedTreeOps.DisplayEnv -> tycon:TypedTree.Tycon -> unit - val GetAbstractMethInfosForSynMethodDecl : - infoReader:InfoReader.InfoReader * ad:AccessibilityLogic.AccessorDomain * - memberName:SyntaxTree.Ident * bindm:Range.range * - typToSearchForAbstractMembers:(TypedTree.TType * SlotImplSet option) * - valSynData:SyntaxTree.SynValInfo -> - Infos.MethInfo list * Infos.MethInfo list - val GetAbstractPropInfosForSynPropertyDecl : - infoReader:InfoReader.InfoReader * ad:AccessibilityLogic.AccessorDomain * - memberName:SyntaxTree.Ident * bindm:Range.range * - typToSearchForAbstractMembers:(TypedTree.TType * SlotImplSet option) * - _k:'a * _valSynData:'b -> Infos.PropInfo list - end - -namespace FSharp.Compiler - module internal MethodCalls = begin - type CallerArg<'T> = - | CallerArg of - ty: TypedTree.TType * range: Range.range * isOpt: bool * exprInfo: 'T - with - member CallerArgumentType : TypedTree.TType - member Expr : 'T - member IsExplicitOptional : bool - member Range : Range.range - end - type CalledArg = - { Position: struct (int * int) - IsParamArray: bool - OptArgInfo: Infos.OptionalArgInfo - CallerInfo: Infos.CallerInfo - IsInArg: bool - IsOutArg: bool - ReflArgInfo: Infos.ReflectedArgInfo - NameOpt: SyntaxTree.Ident option - CalledArgumentType: TypedTree.TType } - val CalledArg : - pos:struct (int * int) * isParamArray:bool * - optArgInfo:Infos.OptionalArgInfo * callerInfo:Infos.CallerInfo * - isInArg:bool * isOutArg:bool * nameOpt:SyntaxTree.Ident option * - reflArgInfo:Infos.ReflectedArgInfo * calledArgTy:TypedTree.TType -> - CalledArg - type AssignedCalledArg<'T> = - { NamedArgIdOpt: SyntaxTree.Ident option - CalledArg: CalledArg - CallerArg: CallerArg<'T> } - with - member Position : struct (int * int) - end - type AssignedItemSetterTarget = - | AssignedPropSetter of - Infos.PropInfo * Infos.MethInfo * TypedTree.TypeInst - | AssignedILFieldSetter of Infos.ILFieldInfo - | AssignedRecdFieldSetter of Infos.RecdFieldInfo - type AssignedItemSetter<'T> = - | AssignedItemSetter of - SyntaxTree.Ident * AssignedItemSetterTarget * CallerArg<'T> - type CallerNamedArg<'T> = - | CallerNamedArg of SyntaxTree.Ident * CallerArg<'T> - with - member CallerArg : CallerArg<'T> - member Ident : SyntaxTree.Ident - member Name : string - end - [] - type CallerArgs<'T> = - { Unnamed: CallerArg<'T> list list - Named: CallerNamedArg<'T> list list } - with - member ArgumentNamesAndTypes : (string option * TypedTree.TType) list - member CallerArgCounts : int * int - member - CurriedCallerArgs : (CallerArg<'T> list * CallerNamedArg<'T> list) list - static member Empty : CallerArgs<'T> - end - val AdjustCalledArgTypeForLinqExpressionsAndAutoQuote : - infoReader:InfoReader.InfoReader -> - callerArgTy:TypedTree.TType -> - calledArg:CalledArg -> m:Range.range -> TypedTree.TType - val AdjustCalledArgTypeForOptionals : - g:TcGlobals.TcGlobals -> - enforceNullableOptionalsKnownTypes:bool -> - calledArg:CalledArg -> - calledArgTy:TypedTree.TType -> - callerArg:CallerArg<'a> -> TypedTree.TType - val AdjustCalledArgType : - infoReader:InfoReader.InfoReader -> - isConstraint:bool -> - enforceNullableOptionalsKnownTypes:bool -> - calledArg:CalledArg -> callerArg:CallerArg<'a> -> TypedTree.TType - type CalledMethArgSet<'T> = - { UnnamedCalledArgs: CalledArg list - UnnamedCallerArgs: CallerArg<'T> list - ParamArrayCalledArgOpt: CalledArg option - ParamArrayCallerArgs: CallerArg<'T> list - AssignedNamedArgs: AssignedCalledArg<'T> list } - with - member NumAssignedNamedArgs : int - member NumUnnamedCalledArgs : int - member NumUnnamedCallerArgs : int - end - val MakeCalledArgs : - amap:Import.ImportMap -> - m:Range.range -> - minfo:Infos.MethInfo -> - minst:TypedTree.TType list -> CalledArg list list - type CalledMeth<'T> = - class - new : infoReader:InfoReader.InfoReader * - nameEnv:NameResolution.NameResolutionEnv option * - isCheckingAttributeCall:bool * - freshenMethInfo:(Range.range -> Infos.MethInfo -> - TypedTree.TypeInst) * m:Range.range * - ad:AccessibilityLogic.AccessorDomain * minfo:Infos.MethInfo * - calledTyArgs:TypedTree.TType list * - callerTyArgs:TypedTree.TType list * pinfoOpt:Infos.PropInfo option * - callerObjArgTys:TypedTree.TType list * callerArgs:CallerArgs<'T> * - allowParamArgs:bool * allowOutAndOptArgs:bool * - tyargsOpt:TypedTree.TType option -> CalledMeth<'T> - static member GetMethod : x:CalledMeth<'T> -> Infos.MethInfo - member CalledObjArgTys : m:Range.range -> TypedTree.TType list - member GetParamArrayElementType : unit -> TypedTree.TType - member HasCorrectObjArgs : m:Range.range -> bool - member - IsAccessible : m:Range.range * ad:AccessibilityLogic.AccessorDomain -> - bool - member - IsCandidate : m:Range.range * ad:AccessibilityLogic.AccessorDomain -> - bool - override ToString : unit -> string - member AllCalledArgs : CalledArg list list - member AllUnnamedCalledArgs : CalledArg list - member ArgSets : CalledMethArgSet<'T> list - member AssignedItemSetters : AssignedItemSetter<'T> list - member AssignedNamedArgs : AssignedCalledArg<'T> list list - member AssignedUnnamedArgs : AssignedCalledArg<'T> list list - member AssignsAllNamedArgs : bool - member AssociatedPropertyInfo : Infos.PropInfo option - member AttributeAssignedNamedArgs : CallerNamedArg<'T> list - member CalledReturnTypeAfterByrefDeref : TypedTree.TType - member CalledReturnTypeAfterOutArgTupling : TypedTree.TType - member CalledTyArgs : TypedTree.TType list - member CalledTyparInst : TypedTreeOps.TyparInst - member CallerObjArgTys : TypedTree.TType list - member CallerTyArgs : TypedTree.TType list - member HasCorrectArity : bool - member HasCorrectGenericArity : bool - member HasOptArgs : bool - member HasOutArgs : bool - member Method : Infos.MethInfo - member NumArgSets : int - member NumAssignedProps : int - member NumCalledTyArgs : int - member NumCallerTyArgs : int - member ParamArrayCalledArgOpt : CalledArg option - member ParamArrayCallerArgs : CallerArg<'T> list option - member TotalNumAssignedNamedArgs : int - member TotalNumUnnamedCalledArgs : int - member TotalNumUnnamedCallerArgs : int - member UnassignedNamedArgs : CallerNamedArg<'T> list - member UnnamedCalledOptArgs : CalledArg list - member UnnamedCalledOutArgs : CalledArg list - member UsesParamArrayConversion : bool - member amap : Import.ImportMap - member infoReader : InfoReader.InfoReader - end - val NamesOfCalledArgs : calledArgs:CalledArg list -> SyntaxTree.Ident list - type ArgumentAnalysis = - | NoInfo - | ArgDoesNotMatch - | CallerLambdaHasArgTypes of TypedTree.TType list - | CalledArgMatchesType of TypedTree.TType - val InferLambdaArgsForLambdaPropagation : - origRhsExpr:SyntaxTree.SynExpr -> int - val ExamineArgumentForLambdaPropagation : - infoReader:InfoReader.InfoReader -> - arg:AssignedCalledArg -> ArgumentAnalysis - val ExamineMethodForLambdaPropagation : - x:CalledMeth -> - (ArgumentAnalysis list list * - (SyntaxTree.Ident * ArgumentAnalysis) list list) option - val IsBaseCall : objArgs:TypedTree.Expr list -> bool - val ComputeConstrainedCallInfo : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - objArgs:TypedTree.Expr list * minfo:Infos.MethInfo -> - TypedTree.TType option - val TakeObjAddrForMethodCall : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - minfo:Infos.MethInfo -> - isMutable:TypedTreeOps.Mutates -> - m:Range.range -> - objArgs:TypedTree.Expr list -> - f:(TypedTree.TType option -> TypedTree.Expr list -> - TypedTree.Expr * 'a) -> TypedTree.Expr * 'a - val BuildILMethInfoCall : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - isProp:bool -> - minfo:Infos.ILMethInfo -> - valUseFlags:TypedTree.ValUseFlag -> - minst:TypedTree.TType list -> - direct:bool -> - args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType - val BuildFSharpMethodApp : - g:TcGlobals.TcGlobals -> - m:Range.range -> - vref:TypedTree.ValRef -> - vexp:TypedTree.Expr -> - vexprty:TypedTree.TType -> - args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType - val BuildFSharpMethodCall : - g:TcGlobals.TcGlobals -> - m:Range.range -> - ty:TypedTree.TType * vref:TypedTree.ValRef -> - valUseFlags:TypedTree.ValUseFlag -> - minst:TypedTree.TType list -> - args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType - val MakeMethInfoCall : - amap:Import.ImportMap -> - m:Range.range -> - minfo:Infos.MethInfo -> - minst:TypedTree.TType list -> args:TypedTree.Exprs -> TypedTree.Expr - val TryImportProvidedMethodBaseAsLibraryIntrinsic : - amap:Import.ImportMap * m:Range.range * - mbase:Tainted -> - TypedTree.ValRef option - val BuildMethodCall : - tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TType list -> - Range.range -> TypedTree.Expr * TypedTree.TType) -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - isMutable:TypedTreeOps.Mutates -> - m:Range.range -> - isProp:bool -> - minfo:Infos.MethInfo -> - valUseFlags:TypedTree.ValUseFlag -> - minst:TypedTree.TType list -> - objArgs:TypedTree.Expr list -> - args:TypedTree.Expr list -> - TypedTree.Expr * TypedTree.TType - val BuildObjCtorCall : - g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.Expr - val BuildNewDelegateExpr : - eventInfoOpt:Infos.EventInfo option * g:TcGlobals.TcGlobals * - amap:Import.ImportMap * delegateTy:TypedTree.TType * - invokeMethInfo:Infos.MethInfo * delArgTys:TypedTree.TType list * - f:TypedTree.Expr * fty:TypedTree.TType * m:Range.range -> TypedTree.Expr - val CoerceFromFSharpFuncToDelegate : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - callerArgTy:TypedTree.TType -> - m:Range.range -> - callerArgExpr:TypedTree.Expr -> - delegateTy:TypedTree.TType -> TypedTree.Expr - val AdjustCallerArgExprForCoercions : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - isOutArg:bool -> - calledArgTy:TypedTree.TType -> - reflArgInfo:Infos.ReflectedArgInfo -> - callerArgTy:TypedTree.TType -> - m:Range.range -> - callerArgExpr:TypedTree.Expr -> - 'a option * TypedTree.Expr - val emptyPreBinder : e:TypedTree.Expr -> TypedTree.Expr - val GetDefaultExpressionForCallerSideOptionalArg : - tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> - g:TcGlobals.TcGlobals -> - calledArg:CalledArg -> - currCalledArgTy:TypedTree.TType -> - currDfltVal:Infos.OptionalArgCallerSideValue -> - eCallerMemberName:string option -> - mMethExpr:Range.range -> - (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr - val GetDefaultExpressionForCalleeSideOptionalArg : - g:TcGlobals.TcGlobals -> - calledArg:CalledArg -> - eCallerMemberName:string option -> - mMethExpr:Range.range -> TypedTree.Expr - val GetDefaultExpressionForOptionalArg : - tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> - g:TcGlobals.TcGlobals -> - calledArg:CalledArg -> - eCallerMemberName:string option -> - mItem:Range.range -> - mMethExpr:Range.range -> - (TypedTree.Expr -> TypedTree.Expr) * - AssignedCalledArg - val MakeNullableExprIfNeeded : - infoReader:InfoReader.InfoReader -> - calledArgTy:TypedTree.TType -> - callerArgTy:TypedTree.TType -> - callerArgExpr:TypedTree.Expr -> m:Range.range -> TypedTree.Expr - val AdjustCallerArgForOptional : - tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> - eCallerMemberName:string option -> - infoReader:InfoReader.InfoReader -> - assignedArg:AssignedCalledArg -> - AssignedCalledArg - val AdjustCallerArgsForOptionals : - tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> - eCallerMemberName:string option -> - infoReader:InfoReader.InfoReader -> - calledMeth:CalledMeth -> - mItem:Range.range -> - mMethExpr:Range.range -> - AssignedCalledArg list * - (TypedTree.Expr -> TypedTree.Expr) * - AssignedCalledArg list * - AssignedCalledArg list - val AdjustOutCallerArgs : - g:TcGlobals.TcGlobals -> - calledMeth:CalledMeth<'a> -> - mMethExpr:Range.range -> - AssignedCalledArg list * TypedTree.Expr list * - TypedTree.Binding list - val AdjustParamArrayCallerArgs : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - calledMeth:CalledMeth -> - mMethExpr:Range.range -> - 'a option list * AssignedCalledArg list - val AdjustCallerArgs : - tcFieldInit:(Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const) -> - eCallerMemberName:string option -> - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - calledMeth:CalledMeth -> - objArgs:TypedTree.Expr list -> - lambdaVars:'a option -> - mItem:Range.range -> - mMethExpr:Range.range -> - (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr list * - 'b option list * AssignedCalledArg list * - TypedTree.Expr list * (TypedTree.Expr -> TypedTree.Expr) * - 'c option list * TypedTree.Expr list * - TypedTree.Binding list - module ProvidedMethodCalls = begin - val private convertConstExpr : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - constant:Tainted -> - TypedTree.Expr - val eraseSystemType : - amap:Import.ImportMap * m:Range.range * - inputType:Tainted -> - Tainted - val convertProvidedExpressionToExprAndWitness : - tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> - TypedTree.TType list -> Range.range -> - TypedTree.Expr * TypedTree.TType) -> - thisArg:TypedTree.Expr option * allArgs:TypedTree.Exprs * - paramVars:Tainted [] * - g:TcGlobals.TcGlobals * amap:Import.ImportMap * - mut:TypedTreeOps.Mutates * isProp:bool * - isSuperInit:TypedTree.ValUseFlag * m:Range.range * - expr:Tainted -> - Tainted option * - (TypedTree.Expr * TypedTree.TType) - val TranslateInvokerExpressionForProvidedMethodCall : - tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> - TypedTree.TType list -> Range.range -> - TypedTree.Expr * TypedTree.TType) -> - g:TcGlobals.TcGlobals * amap:Import.ImportMap * - mut:TypedTreeOps.Mutates * isProp:bool * - isSuperInit:TypedTree.ValUseFlag * - mi:Tainted * - objArgs:TypedTree.Expr list * allArgs:TypedTree.Exprs * m:Range.range -> - Tainted option * - (TypedTree.Expr * TypedTree.TType) - val BuildInvokerExpressionForProvidedMethodCall : - tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> - TypedTree.TType list -> Range.range -> - TypedTree.Expr * TypedTree.TType) -> - g:TcGlobals.TcGlobals * amap:Import.ImportMap * - mi:Tainted * - objArgs:TypedTree.Expr list * mut:TypedTreeOps.Mutates * isProp:bool * - isSuperInit:TypedTree.ValUseFlag * allArgs:TypedTree.Exprs * - m:Range.range -> - Tainted option * TypedTree.Expr * - TypedTree.TType - end - val RecdFieldInstanceChecks : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> rfinfo:Infos.RecdFieldInfo -> unit - val ILFieldStaticChecks : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - infoReader:InfoReader.InfoReader -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> finfo:Infos.ILFieldInfo -> unit - val ILFieldInstanceChecks : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> finfo:Infos.ILFieldInfo -> unit - val MethInfoChecks : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - isInstance:bool -> - tyargsOpt:'a option -> - objArgs:TypedTree.Expr list -> - ad:AccessibilityLogic.AccessorDomain -> - m:Range.range -> minfo:Infos.MethInfo -> unit - exception FieldNotMutable of - TypedTreeOps.DisplayEnv * TypedTree.RecdFieldRef * - Range.range - val CheckRecdFieldMutation : - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> rfinfo:Infos.RecdFieldInfo -> unit - val GenWitnessExpr : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - m:Range.range -> - traitInfo:TypedTree.TraitConstraintInfo -> - argExprs:TypedTree.Expr list -> TypedTree.Expr option - val GenWitnessExprLambda : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - m:Range.range -> - traitInfo:TypedTree.TraitConstraintInfo -> - Choice - val GenWitnessArgs : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - m:Range.range -> - traitInfos:TypedTree.TraitConstraintInfo list -> - Choice list - end - -namespace FSharp.Compiler - module internal PatternMatchCompilation = begin - exception MatchIncomplete of bool * (string * bool) option * Range.range - exception RuleNeverMatched of Range.range - exception EnumMatchIncomplete of bool * (string * bool) option * Range.range - type ActionOnFailure = - | ThrowIncompleteMatchException - | IgnoreWithWarning - | Throw - | Rethrow - | FailFilter - [] - type Pattern = - | TPat_const of TypedTree.Const * Range.range - | TPat_wild of Range.range - | TPat_as of Pattern * PatternValBinding * Range.range - | TPat_disjs of Pattern list * Range.range - | TPat_conjs of Pattern list * Range.range - | TPat_query of - (TypedTree.Expr * TypedTree.TType list * - (TypedTree.ValRef * TypedTree.TypeInst) option * int * - PrettyNaming.ActivePatternInfo) * Pattern * Range.range - | TPat_unioncase of - TypedTree.UnionCaseRef * TypedTree.TypeInst * Pattern list * Range.range - | TPat_exnconstr of TypedTree.TyconRef * Pattern list * Range.range - | TPat_tuple of - TypedTree.TupInfo * Pattern list * TypedTree.TType list * Range.range - | TPat_array of Pattern list * TypedTree.TType * Range.range - | TPat_recd of - TypedTree.TyconRef * TypedTree.TypeInst * Pattern list * Range.range - | TPat_range of char * char * Range.range - | TPat_null of Range.range - | TPat_isinst of - TypedTree.TType * TypedTree.TType * PatternValBinding option * - Range.range - | TPat_error of Range.range - with - member Range : Range.range - end - and PatternValBinding = | PBind of TypedTree.Val * TypedTreeOps.TypeScheme - and TypedMatchClause = - | TClause of - Pattern * TypedTree.Expr option * TypedTree.DecisionTreeTarget * - Range.range - with - member BoundVals : TypedTree.Val list - member GuardExpr : TypedTree.Expr option - member Pattern : Pattern - member Range : Range.range - member Target : TypedTree.DecisionTreeTarget - end - val debug : bool - type SubExprOfInput = - | SubExpr of - (TypedTreeOps.TyparInst -> TypedTree.Expr -> TypedTree.Expr) * - (TypedTree.Expr * TypedTree.Val) - val BindSubExprOfInput : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - gtps:TypedTree.Typar list -> - PatternValBinding -> - m:Range.range -> SubExprOfInput -> TypedTree.Val * TypedTree.Expr - val GetSubExprOfInput : - g:TcGlobals.TcGlobals -> - gtps:'a list * tyargs:TypedTree.TType list * - tinst:TypedTreeOps.TyparInst -> SubExprOfInput -> TypedTree.Expr - type Path = - | PathQuery of Path * CompilerGlobalState.Unique - | PathConj of Path * int - | PathTuple of Path * TypedTree.TypeInst * int - | PathRecd of Path * TypedTree.TyconRef * TypedTree.TypeInst * int - | PathUnionConstr of - Path * TypedTree.UnionCaseRef * TypedTree.TypeInst * int - | PathArray of Path * TypedTree.TType * int * int - | PathExnConstr of Path * TypedTree.TyconRef * int - | PathEmpty of TypedTree.TType - val pathEq : p1:Path -> p2:Path -> bool - type RefutedSet = - | RefutedInvestigation of Path * TypedTree.DecisionTreeTest list - | RefutedWhenClause - val notNullText : string - val otherSubtypeText : string - val ilFieldToTastConst : AbstractIL.IL.ILFieldInit -> TypedTree.Const - exception CannotRefute - val RefuteDiscrimSet : - g:TcGlobals.TcGlobals -> - m:Range.range -> - path:Path -> - discrims:TypedTree.DecisionTreeTest list -> TypedTree.Expr * bool - val CombineRefutations : - g:TcGlobals.TcGlobals -> - r1:TypedTree.Expr -> r2:TypedTree.Expr -> TypedTree.Expr - val ShowCounterExample : - g:TcGlobals.TcGlobals -> - denv:TypedTreeOps.DisplayEnv -> - m:Range.range -> - refuted:RefutedSet list -> (string * bool * bool) option - type RuleNumber = int - type Active = | Active of Path * SubExprOfInput * Pattern - type Actives = Active list - type Frontier = - | Frontier of RuleNumber * Actives * TypedTreeOps.ValMap - type InvestigationPoint = - | Investigation of RuleNumber * TypedTree.DecisionTreeTest * Path - val isMemOfActives : p1:Path -> actives:Active list -> bool - val lookupActive : x:Path -> l:Active list -> SubExprOfInput * Pattern - val removeActive : x:Path -> l:Active list -> Active list - val getDiscrimOfPattern : - g:TcGlobals.TcGlobals -> - tpinst:TypedTreeOps.TyparInst -> - t:Pattern -> TypedTree.DecisionTreeTest option - val constOfDiscrim : discrim:TypedTree.DecisionTreeTest -> TypedTree.Const - val constOfCase : c:TypedTree.DecisionTreeCase -> TypedTree.Const - val discrimsEq : - g:TcGlobals.TcGlobals -> - d1:TypedTree.DecisionTreeTest -> d2:TypedTree.DecisionTreeTest -> bool - val isDiscrimSubsumedBy : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - d1:TypedTree.DecisionTreeTest -> - d2:TypedTree.DecisionTreeTest -> bool - val chooseSimultaneousEdgeSet : - prevOpt:'a option -> - f:('a option -> 'b -> 'a option) -> l:'b list -> 'a list * 'b list - val canCompactConstantClass : c:TypedTree.Const -> bool - val discrimsHaveSameSimultaneousClass : - g:TcGlobals.TcGlobals -> - d1:TypedTree.DecisionTreeTest -> d2:TypedTree.DecisionTreeTest -> bool - val canInvestigate : pat:Pattern -> bool - val ChooseInvestigationPointLeftToRight : frontiers:Frontier list -> Active - val ( |ConstNeedsDefaultCase|_| ) : c:TypedTree.Const -> unit option - val BuildSwitch : - inpExprOpt:'a option -> - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> - edges:TypedTree.DecisionTreeCase list -> - dflt:TypedTree.DecisionTree option -> - m:Range.range -> TypedTree.DecisionTree - val layoutPat : pat:Pattern -> Internal.Utilities.StructuredFormat.Layout - val layoutPath : _p:'a -> Internal.Utilities.StructuredFormat.Layout - val layoutActive : Active -> Internal.Utilities.StructuredFormat.Layout - val layoutFrontier : Frontier -> Internal.Utilities.StructuredFormat.Layout - val mkFrontiers : - investigations:(Actives * TypedTreeOps.ValMap) list -> - i:RuleNumber -> Frontier list - val getRuleIndex : Frontier -> RuleNumber - val isPatternPartial : p:Pattern -> bool - val erasePartialPatterns : inpp:Pattern -> Pattern - val erasePartials : inps:Pattern list -> Pattern list - type EdgeDiscrim = - | EdgeDiscrim of int * TypedTree.DecisionTreeTest * Range.range - val getDiscrim : EdgeDiscrim -> TypedTree.DecisionTreeTest - val CompilePatternBasic : - g:TcGlobals.TcGlobals -> - denv:TypedTreeOps.DisplayEnv -> - amap:Import.ImportMap -> - tcVal:(TypedTree.ValRef -> TypedTree.ValUseFlag -> - TypedTree.TType list -> Range.range -> - TypedTree.Expr * TypedTree.TType) -> - infoReader:InfoReader.InfoReader -> - exprm:Range.range -> - matchm:Range.range -> - warnOnUnused:bool -> - warnOnIncomplete:bool -> - actionOnFailure:ActionOnFailure -> - origInputVal:TypedTree.Val * - origInputValTypars:TypedTree.Typar list * - _origInputExprOpt:TypedTree.Expr option -> - typedClauses:TypedMatchClause list -> - inputTy:TypedTree.TType -> - resultTy:TypedTree.TType -> - TypedTree.DecisionTree * - TypedTree.DecisionTreeTarget list - val isPartialOrWhenClause : c:TypedMatchClause -> bool - val CompilePattern : - TcGlobals.TcGlobals -> - TypedTreeOps.DisplayEnv -> - Import.ImportMap -> - (TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TType list -> - Range.range -> TypedTree.Expr * TypedTree.TType) -> - InfoReader.InfoReader -> - Range.range -> - Range.range -> - bool -> - ActionOnFailure -> - TypedTree.Val * TypedTree.Typar list * - TypedTree.Expr option -> - TypedMatchClause list -> - TypedTree.TType -> - TypedTree.TType -> - TypedTree.DecisionTree * - TypedTree.DecisionTreeTarget list - end - -namespace FSharp.Compiler - module internal ConstraintSolver = begin - val compgenId : SyntaxTree.Ident - val NewCompGenTypar : - kind:TypedTree.TyparKind * rigid:TypedTree.TyparRigidity * - staticReq:SyntaxTree.TyparStaticReq * dynamicReq:TypedTree.TyparDynamicReq * - error:bool -> TypedTree.Typar - val AnonTyparId : m:Range.range -> SyntaxTree.Ident - val NewAnonTypar : - TypedTree.TyparKind * Range.range * TypedTree.TyparRigidity * - SyntaxTree.TyparStaticReq * TypedTree.TyparDynamicReq -> TypedTree.Typar - val NewNamedInferenceMeasureVar : - _m:'a * rigid:TypedTree.TyparRigidity * var:SyntaxTree.TyparStaticReq * - id:SyntaxTree.Ident -> TypedTree.Typar - val NewInferenceMeasurePar : unit -> TypedTree.Typar - val NewErrorTypar : unit -> TypedTree.Typar - val NewErrorMeasureVar : unit -> TypedTree.Typar - val NewInferenceType : unit -> TypedTree.TType - val NewErrorType : unit -> TypedTree.TType - val NewErrorMeasure : unit -> TypedTree.Measure - val NewByRefKindInferenceType : - TcGlobals.TcGlobals -> Range.range -> TypedTree.TType - val NewInferenceTypes : 'a list -> TypedTree.TType list - val FreshenAndFixupTypars : - Range.range -> - TypedTree.TyparRigidity -> - TypedTree.Typars -> - TypedTree.TType list -> - TypedTree.Typar list -> - TypedTree.Typar list * TypedTreeOps.TyparInst * TypedTree.TTypes - val FreshenTypeInst : - Range.range -> - TypedTree.Typar list -> - TypedTree.Typar list * TypedTreeOps.TyparInst * TypedTree.TTypes - val FreshMethInst : - m:Range.range -> - fctps:TypedTree.Typars -> - tinst:TypedTree.TType list -> - tpsorig:TypedTree.Typar list -> - TypedTree.Typar list * TypedTreeOps.TyparInst * TypedTree.TTypes - val FreshenTypars : - Range.range -> TypedTree.Typar list -> TypedTree.TType list - val FreshenMethInfo : Range.range -> Infos.MethInfo -> TypedTree.TTypes - [] - type ContextInfo = - | NoContext - | IfExpression of Range.range - | OmittedElseBranch of Range.range - | ElseBranchResult of Range.range - | RecordFields - | TupleInRecordFields - | CollectionElement of bool * Range.range - | ReturnInComputationExpression - | YieldInComputationExpression - | RuntimeTypeTest of bool - | DowncastUsedInsteadOfUpcast of bool - | FollowingPatternMatchClause of Range.range - | PatternMatchGuard of Range.range - | SequenceExpression of TypedTree.TType - type OverloadInformation = - { methodSlot: MethodCalls.CalledMeth - amap: Import.ImportMap - error: exn } - type OverloadResolutionFailure = - | NoOverloadsFound of - methodName: string * candidates: OverloadInformation list * - cx: TypedTree.TraitConstraintInfo option - | PossibleCandidates of - methodName: string * candidates: OverloadInformation list * - cx: TypedTree.TraitConstraintInfo option - exception ConstraintSolverTupleDiffLengths of - displayEnv: - TypedTreeOps.DisplayEnv * - TypedTree.TType list * - TypedTree.TType list * - Range.range * Range.range - exception ConstraintSolverInfiniteTypes of - displayEnv: - TypedTreeOps.DisplayEnv * - contextInfo: ContextInfo * - TypedTree.TType * TypedTree.TType * - Range.range * Range.range - exception ConstraintSolverTypesNotInEqualityRelation of - displayEnv: - TypedTreeOps.DisplayEnv * - TypedTree.TType * - TypedTree.TType * - Range.range * - Range.range * - ContextInfo - exception ConstraintSolverTypesNotInSubsumptionRelation of - displayEnv: - TypedTreeOps.DisplayEnv * - argTy: - TypedTree.TType * - paramTy: - TypedTree.TType * - callRange: - Range.range * - parameterRange: - Range.range - exception ConstraintSolverMissingConstraint of - displayEnv: - TypedTreeOps.DisplayEnv * - TypedTree.Typar * - TypedTree.TyparConstraint * - Range.range * Range.range - exception ConstraintSolverError of string * Range.range * Range.range - exception ConstraintSolverRelatedInformation of - string option * Range.range * - exn - exception ErrorFromApplyingDefault of - tcGlobals: TcGlobals.TcGlobals * - displayEnv: TypedTreeOps.DisplayEnv * - TypedTree.Typar * TypedTree.TType * exn * - Range.range - exception ErrorFromAddingTypeEquation of - tcGlobals: TcGlobals.TcGlobals * - displayEnv: TypedTreeOps.DisplayEnv * - actualTy: TypedTree.TType * - expectedTy: TypedTree.TType * exn * - Range.range - exception ErrorsFromAddingSubsumptionConstraint of - tcGlobals: - TcGlobals.TcGlobals * - displayEnv: - TypedTreeOps.DisplayEnv * - actualTy: TypedTree.TType * - expectedTy: - TypedTree.TType * exn * - ContextInfo * - parameterRange: - Range.range - exception ErrorFromAddingConstraint of - displayEnv: TypedTreeOps.DisplayEnv * - exn * Range.range - exception UnresolvedOverloading of - displayEnv: TypedTreeOps.DisplayEnv * - callerArgs: - MethodCalls.CallerArgs * - failure: OverloadResolutionFailure * - Range.range - exception UnresolvedConversionOperator of - displayEnv: TypedTreeOps.DisplayEnv * - TypedTree.TType * TypedTree.TType * - Range.range - type TcValF = - TypedTree.ValRef -> TypedTree.ValUseFlag -> TypedTree.TType list -> - Range.range -> TypedTree.Expr * TypedTree.TType - [] - type ConstraintSolverState = - { g: TcGlobals.TcGlobals - amap: Import.ImportMap - InfoReader: InfoReader.InfoReader - TcVal: TcValF - mutable ExtraCxs: - Internal.Utilities.Collections.HashMultiMap } - with - static member - New : TcGlobals.TcGlobals * Import.ImportMap * InfoReader.InfoReader * - TcValF -> ConstraintSolverState - end - type ConstraintSolverEnv = - { SolverState: ConstraintSolverState - eContextInfo: ContextInfo - MatchingOnly: bool - m: Range.range - EquivEnv: TypedTreeOps.TypeEquivEnv - DisplayEnv: TypedTreeOps.DisplayEnv } - with - override ToString : unit -> string - member InfoReader : InfoReader.InfoReader - member amap : Import.ImportMap - member g : TcGlobals.TcGlobals - end - val MakeConstraintSolverEnv : - contextInfo:ContextInfo -> - css:ConstraintSolverState -> - m:Range.range -> denv:TypedTreeOps.DisplayEnv -> ConstraintSolverEnv - val occursCheck : - g:TcGlobals.TcGlobals -> un:TypedTree.Typar -> ty:TypedTree.TType -> bool - type PermitWeakResolution = - | Yes - | No - with - member Permit : bool - end - val isNativeIntegerTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isSignedIntegerTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isUnsignedIntegerTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsIntegerOrIntegerEnumTy : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isIntegerTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isStringTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isCharTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isBoolTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isFpTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val isDecimalTy : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsNonDecimalNumericOrIntegralEnumType : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsNumericOrIntegralEnumType : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsNonDecimalNumericType : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsNumericType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsRelationalType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsCharOrStringType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsAddSubModType : - nm:string -> g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsBitwiseOpType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val IsBinaryOpOtherArgType : - g:TcGlobals.TcGlobals -> - permitWeakResolution:PermitWeakResolution -> ty:TypedTree.TType -> bool - val IsSignType : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - type TraitConstraintSolution = - | TTraitUnsolved - | TTraitBuiltIn - | TTraitSolved of Infos.MethInfo * TypedTree.TypeInst - | TTraitSolvedRecdProp of Infos.RecdFieldInfo * bool - | TTraitSolvedAnonRecdProp of - TypedTree.AnonRecdTypeInfo * TypedTree.TypeInst * int - val BakedInTraitConstraintNames : Set - [] - type Trace = - { mutable actions: ((unit -> unit) * (unit -> unit)) list } - with - static member New : unit -> Trace - member Push : f:(unit -> unit) -> undo:(unit -> unit) -> unit - member Undo : unit -> unit - end - type OptionalTrace = - | NoTrace - | WithTrace of Trace - with - member AddFromReplay : source:Trace -> unit - member - CollectThenUndoOrCommit : predicate:('a -> bool) -> - f:(Trace -> 'a) -> 'a - member Exec : f:(unit -> unit) -> undo:(unit -> unit) -> unit - member HasTrace : bool - end - val CollectThenUndo : f:(Trace -> 'a) -> 'a - val FilterEachThenUndo : - f:(Trace -> 'a -> ErrorLogger.OperationResult<'b>) -> - meths:'a list -> ('a * exn list * Trace) list - val ShowAccessDomain : ad:AccessibilityLogic.AccessorDomain -> string - exception NonRigidTypar of - displayEnv: TypedTreeOps.DisplayEnv * - string option * Range.range * TypedTree.TType * - TypedTree.TType * Range.range - exception AbortForFailedOverloadResolution - val inline TryD_IgnoreAbortForFailedOverloadResolution : - f1:(unit -> ErrorLogger.OperationResult) -> - f2:(exn -> ErrorLogger.OperationResult) -> - ErrorLogger.OperationResult - exception ArgDoesNotMatchError of - error: - ErrorsFromAddingSubsumptionConstraint * - calledMeth: - MethodCalls.CalledMeth * - calledArg: MethodCalls.CalledArg * - callerArg: - MethodCalls.CallerArg - exception LocallyAbortOperationThatLosesAbbrevs - val localAbortD : ErrorLogger.OperationResult - val PreferUnifyTypar : v1:TypedTree.Typar -> v2:TypedTree.Typar -> bool - val FindPreferredTypar : - vs:(TypedTree.Typar * 'a) list -> (TypedTree.Typar * 'a) list - val SubstMeasure : r:TypedTree.Typar -> ms:TypedTree.Measure -> unit - val TransactStaticReq : - csenv:ConstraintSolverEnv -> - trace:OptionalTrace -> - tpr:TypedTree.Typar -> - req:SyntaxTree.TyparStaticReq -> ErrorLogger.OperationResult - val SolveTypStaticReqTypar : - csenv:ConstraintSolverEnv -> - trace:OptionalTrace -> - req:SyntaxTree.TyparStaticReq -> - tpr:TypedTree.Typar -> ErrorLogger.OperationResult - val SolveTypStaticReq : - csenv:ConstraintSolverEnv -> - trace:OptionalTrace -> - req:SyntaxTree.TyparStaticReq -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val TransactDynamicReq : - trace:OptionalTrace -> - tpr:TypedTree.Typar -> - req:TypedTree.TyparDynamicReq -> ErrorLogger.OperationResult - val SolveTypDynamicReq : - csenv:ConstraintSolverEnv -> - trace:OptionalTrace -> - req:TypedTree.TyparDynamicReq -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val TransactIsCompatFlex : - trace:OptionalTrace -> - tpr:TypedTree.Typar -> req:bool -> ErrorLogger.OperationResult - val SolveTypIsCompatFlex : - csenv:ConstraintSolverEnv -> - trace:OptionalTrace -> - req:bool -> ty:TypedTree.TType -> ErrorLogger.OperationResult - val SubstMeasureWarnIfRigid : - csenv:ConstraintSolverEnv -> - trace:OptionalTrace -> - v:TypedTree.Typar -> - ms:TypedTree.Measure -> ErrorLogger.OperationResult - val UnifyMeasureWithOne : - csenv:ConstraintSolverEnv -> - trace:OptionalTrace -> - ms:TypedTree.Measure -> ErrorLogger.OperationResult - val UnifyMeasures : - csenv:ConstraintSolverEnv -> - trace:OptionalTrace -> - ms1:TypedTree.Measure -> - ms2:TypedTree.Measure -> ErrorLogger.OperationResult - val SimplifyMeasure : - g:TcGlobals.TcGlobals -> - vars:TypedTree.Typar list -> - ms:TypedTree.Measure -> TypedTree.Typar list * TypedTree.Typar option - val SimplifyMeasuresInType : - g:TcGlobals.TcGlobals -> - resultFirst:bool -> - TypedTree.Typar list * TypedTree.Typar list -> - ty:TypedTree.TType -> TypedTree.Typar list * TypedTree.Typar list - val SimplifyMeasuresInTypes : - g:TcGlobals.TcGlobals -> - TypedTree.Typar list * TypedTree.Typar list -> - tys:TypedTree.TypeInst -> TypedTree.Typar list * TypedTree.Typar list - val SimplifyMeasuresInConstraint : - g:TcGlobals.TcGlobals -> - TypedTree.Typar list * TypedTree.Typar list -> - c:TypedTree.TyparConstraint -> - TypedTree.Typar list * TypedTree.Typar list - val SimplifyMeasuresInConstraints : - g:TcGlobals.TcGlobals -> - TypedTree.Typar list * TypedTree.Typar list -> - cs:TypedTree.TyparConstraint list -> - TypedTree.Typar list * TypedTree.Typar list - val GetMeasureVarGcdInType : - v:TypedTree.Typar -> ty:TypedTree.TType -> Rational.Rational - val GetMeasureVarGcdInTypes : - v:TypedTree.Typar -> tys:TypedTree.TypeInst -> Rational.Rational - val NormalizeExponentsInTypeScheme : - uvars:TypedTree.Typar list -> ty:TypedTree.TType -> TypedTree.Typar list - val SimplifyMeasuresInTypeScheme : - TcGlobals.TcGlobals -> - bool -> - TypedTree.Typar list -> - TypedTree.TType -> - TypedTree.TyparConstraint list -> TypedTree.Typar list - val freshMeasure : unit -> TypedTree.Measure - val CheckWarnIfRigid : - csenv:ConstraintSolverEnv -> - ty1:TypedTree.TType -> - r:TypedTree.Typar -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTyparEqualsTypePart1 : - csenv:ConstraintSolverEnv -> - m2:Range.range -> - trace:OptionalTrace -> - ty1:TypedTree.TType -> - r:TypedTree.Typar -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTyparEqualsTypePart2 : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - r:TypedTree.Typar -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val solveTypMeetsTyparConstraints : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty:TypedTree.TType -> - r:TypedTree.Typar -> ErrorLogger.OperationResult - val SolveTyparEqualsType : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty1:TypedTree.TType -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTyparsEqualTypes : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - tptys:TypedTree.TType list -> - tys:TypedTree.TType list -> ErrorLogger.OperationResult - val SolveAnonInfoEqualsAnonInfo : - csenv:ConstraintSolverEnv -> - m2:Range.range -> - anonInfo1:TypedTree.AnonRecdTypeInfo -> - anonInfo2:TypedTree.AnonRecdTypeInfo -> - ErrorLogger.OperationResult - val SolveTypeEqualsType : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * - TypedTree.TraitConstraintSln) option -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeEqualsTypeKeepAbbrevs : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> ErrorLogger.OperationResult - val private SolveTypeEqualsTypeKeepAbbrevsWithCxsln : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * - TypedTree.TraitConstraintSln) option -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeEqualsTypeEqns : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * - TypedTree.TraitConstraintSln) option -> - origl1:TypedTree.TypeInst -> - origl2:TypedTree.TypeInst -> ErrorLogger.OperationResult - val SolveFunTypeEqn : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * - TypedTree.TraitConstraintSln) option -> - d1:TypedTree.TType -> - d2:TypedTree.TType -> - r1:TypedTree.TType -> - r2:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeSubsumesType : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * - TypedTree.TraitConstraintSln) option -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeSubsumesTypeKeepAbbrevs : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * - TypedTree.TraitConstraintSln) option -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTyparSubtypeOfType : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - tp:TypedTree.Typar -> - ty1:TypedTree.TType -> ErrorLogger.OperationResult - val DepthCheck : - ndeep:int -> m:Range.range -> ErrorLogger.OperationResult - val SolveDimensionlessNumericType : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveMemberConstraint : - csenv:ConstraintSolverEnv -> - ignoreUnresolvedOverload:bool -> - permitWeakResolution:PermitWeakResolution -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - traitInfo:TypedTree.TraitConstraintInfo -> - ErrorLogger.OperationResult - val RecordMemberConstraintSolution : - css:ConstraintSolverState -> - m:Range.range -> - trace:OptionalTrace -> - traitInfo:TypedTree.TraitConstraintInfo -> - res:TraitConstraintSolution -> ErrorLogger.OperationResult - val MemberConstraintSolutionOfMethInfo : - css:ConstraintSolverState -> - m:Range.range -> - minfo:Infos.MethInfo -> - minst:TypedTree.TypeInst -> TypedTree.TraitConstraintSln - val TransactMemberConstraintSolution : - traitInfo:TypedTree.TraitConstraintInfo -> - trace:OptionalTrace -> sln:TypedTree.TraitConstraintSln -> unit - val GetRelevantMethodsForTrait : - csenv:ConstraintSolverEnv -> - permitWeakResolution:PermitWeakResolution -> - nm:string -> TypedTree.TraitConstraintInfo -> Infos.MethInfo list - val GetSupportOfMemberConstraint : - csenv:ConstraintSolverEnv -> - TypedTree.TraitConstraintInfo -> TypedTree.Typar list - val SupportOfMemberConstraintIsFullySolved : - csenv:ConstraintSolverEnv -> TypedTree.TraitConstraintInfo -> bool - val GetFreeTyparsOfMemberConstraint : - csenv:ConstraintSolverEnv -> - TypedTree.TraitConstraintInfo -> TypedTree.Typar list - val MemberConstraintIsReadyForWeakResolution : - csenv:ConstraintSolverEnv -> - traitInfo:TypedTree.TraitConstraintInfo -> bool - val MemberConstraintIsReadyForStrongResolution : - csenv:ConstraintSolverEnv -> - traitInfo:TypedTree.TraitConstraintInfo -> bool - val MemberConstraintSupportIsReadyForDeterminingOverloads : - csenv:ConstraintSolverEnv -> - traitInfo:TypedTree.TraitConstraintInfo -> bool - val SolveRelevantMemberConstraints : - csenv:ConstraintSolverEnv -> - ndeep:int -> - permitWeakResolution:PermitWeakResolution -> - trace:OptionalTrace -> - tps:TypedTree.Typar list -> ErrorLogger.OperationResult - val SolveRelevantMemberConstraintsForTypar : - csenv:ConstraintSolverEnv -> - ndeep:int -> - permitWeakResolution:PermitWeakResolution -> - trace:OptionalTrace -> - tp:TypedTree.Typar -> ErrorLogger.OperationResult - val CanonicalizeRelevantMemberConstraints : - csenv:ConstraintSolverEnv -> - ndeep:int -> - trace:OptionalTrace -> - tps:TypedTree.Typar list -> ErrorLogger.OperationResult - val AddMemberConstraint : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - traitInfo:TypedTree.TraitConstraintInfo -> - support:TypedTree.Typar list -> - frees:TypedTree.Typar list -> - ErrorLogger.OperationResult - val AddConstraint : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - tp:TypedTree.Typar -> - newConstraint:TypedTree.TyparConstraint -> - ErrorLogger.OperationResult - val SolveTypeSupportsNull : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeSupportsComparison : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeSupportsEquality : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeIsEnum : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty:TypedTree.TType -> - underlying:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeIsDelegate : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty:TypedTree.TType -> - aty:TypedTree.TType -> - bty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeIsNonNullableValueType : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeIsUnmanaged : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeChoice : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty:TypedTree.TType -> - tys:TypedTree.TTypes -> ErrorLogger.OperationResult - val SolveTypeIsReferenceType : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - ty:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeRequiresDefaultConstructor : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - origTy:TypedTree.TType -> ErrorLogger.OperationResult - val SolveTypeRequiresDefaultValue : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m2:Range.range -> - trace:OptionalTrace -> - origTy:TypedTree.TType -> ErrorLogger.OperationResult - val CanMemberSigsMatchUpToCheck : - csenv:ConstraintSolverEnv -> - permitOptArgs:bool -> - alwaysCheckReturn:bool -> - unifyTypes:(TypedTree.TType -> TypedTree.TType -> - ErrorLogger.OperationResult) -> - subsumeTypes:(TypedTree.TType -> TypedTree.TType -> - ErrorLogger.OperationResult) -> - subsumeArg:(MethodCalls.CalledArg -> - MethodCalls.CallerArg<'a> -> - ErrorLogger.OperationResult) -> - reqdRetTyOpt:TypedTree.TType option -> - calledMeth:MethodCalls.CalledMeth<'a> -> - ErrorLogger.ImperativeOperationResult - val private SolveTypeSubsumesTypeWithWrappedContextualReport : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m:Range.range -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * - TypedTree.TraitConstraintSln) option -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> - wrapper:(exn -> #exn) -> ErrorLogger.OperationResult - val private SolveTypeSubsumesTypeWithReport : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m:Range.range -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * - TypedTree.TraitConstraintSln) option -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> ErrorLogger.OperationResult - val private SolveTypeEqualsTypeWithReport : - csenv:ConstraintSolverEnv -> - ndeep:int -> - m:Range.range -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * - TypedTree.TraitConstraintSln) option -> - actual:TypedTree.TType -> - expected:TypedTree.TType -> ErrorLogger.OperationResult - val ArgsMustSubsumeOrConvert : - csenv:ConstraintSolverEnv -> - ndeep:int -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> - isConstraint:bool -> - enforceNullableOptionalsKnownTypes:bool -> - calledArg:MethodCalls.CalledArg -> - callerArg:MethodCalls.CallerArg<'T> -> - ErrorLogger.OperationResult - val MustUnify : - csenv:ConstraintSolverEnv -> - ndeep:int -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> ErrorLogger.OperationResult - val MustUnifyInsideUndo : - csenv:ConstraintSolverEnv -> - ndeep:int -> - trace:Trace -> - cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> - ty1:TypedTree.TType -> - ty2:TypedTree.TType -> ErrorLogger.OperationResult - val ArgsMustSubsumeOrConvertInsideUndo : - csenv:ConstraintSolverEnv -> - ndeep:int -> - trace:Trace -> - cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> - isConstraint:bool -> - calledMeth:MethodCalls.CalledMeth -> - calledArg:MethodCalls.CalledArg -> - MethodCalls.CallerArg -> - ErrorLogger.OperationResult - val TypesMustSubsumeOrConvertInsideUndo : - csenv:ConstraintSolverEnv -> - ndeep:int -> - trace:OptionalTrace -> - cxsln:(TypedTree.TraitConstraintInfo * TypedTree.TraitConstraintSln) option -> - m:Range.range -> - calledArgTy:TypedTree.TType -> - callerArgTy:TypedTree.TType -> - ErrorLogger.OperationResult - val ArgsEquivInsideUndo : - csenv:ConstraintSolverEnv -> - isConstraint:bool -> - calledArg:MethodCalls.CalledArg -> - MethodCalls.CallerArg<'c> -> ErrorLogger.OperationResult - val ReportNoCandidatesError : - csenv:ConstraintSolverEnv -> - nUnnamedCallerArgs:System.Int32 * nNamedCallerArgs:int -> - methodName:System.String -> - ad:AccessibilityLogic.AccessorDomain -> - calledMethGroup:MethodCalls.CalledMeth<'d> list -> - isSequential:('d -> bool) -> ErrorLogger.OperationResult<'e> - val ReportNoCandidatesErrorExpr : - csenv:ConstraintSolverEnv -> - System.Int32 * int -> - methodName:System.String -> - ad:AccessibilityLogic.AccessorDomain -> - calledMethGroup:MethodCalls.CalledMeth list -> - ErrorLogger.OperationResult<'f> - val ReportNoCandidatesErrorSynExpr : - csenv:ConstraintSolverEnv -> - System.Int32 * int -> - methodName:System.String -> - ad:AccessibilityLogic.AccessorDomain -> - calledMethGroup:MethodCalls.CalledMeth list -> - ErrorLogger.OperationResult<'g> - val ResolveOverloading : - csenv:ConstraintSolverEnv -> - trace:OptionalTrace -> - methodName:string -> - ndeep:int -> - cx:TypedTree.TraitConstraintInfo option -> - callerArgs:MethodCalls.CallerArgs -> - ad:AccessibilityLogic.AccessorDomain -> - calledMethGroup:MethodCalls.CalledMeth list -> - permitOptArgs:bool -> - reqdRetTyOpt:TypedTree.TType option -> - MethodCalls.CalledMeth option * - ErrorLogger.OperationResult - val ResolveOverloadingForCall : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> - methodName:string -> - ndeep:int -> - cx:TypedTree.TraitConstraintInfo option -> - callerArgs:MethodCalls.CallerArgs -> - AccessibilityLogic.AccessorDomain -> - calledMethGroup:MethodCalls.CalledMeth list -> - permitOptArgs:bool -> - reqdRetTyOpt:TypedTree.TType option -> - MethodCalls.CalledMeth option * - ErrorLogger.OperationResult - val UnifyUniqueOverloading : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> - System.Int32 * int -> - System.String -> - AccessibilityLogic.AccessorDomain -> - MethodCalls.CalledMeth list -> - TypedTree.TType -> ErrorLogger.OperationResult - val EliminateConstraintsForGeneralizedTypars : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> OptionalTrace -> TypedTree.Typars -> unit - val AddCxTypeEqualsType : - ContextInfo -> - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> TypedTree.TType -> TypedTree.TType -> unit - val UndoIfFailed : f:(Trace -> ErrorLogger.OperationResult<'a>) -> bool - val UndoIfFailedOrWarnings : - f:(Trace -> ErrorLogger.OperationResult<'a>) -> bool - val AddCxTypeEqualsTypeUndoIfFailed : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> TypedTree.TType -> TypedTree.TType -> bool - val AddCxTypeEqualsTypeUndoIfFailedOrWarnings : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> TypedTree.TType -> TypedTree.TType -> bool - val AddCxTypeEqualsTypeMatchingOnlyUndoIfFailed : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> TypedTree.TType -> TypedTree.TType -> bool - val AddCxTypeMustSubsumeTypeUndoIfFailed : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> TypedTree.TType -> TypedTree.TType -> bool - val AddCxTypeMustSubsumeTypeMatchingOnlyUndoIfFailed : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> TypedTree.TType -> TypedTree.TType -> bool - val AddCxTypeMustSubsumeType : - ContextInfo -> - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> - OptionalTrace -> TypedTree.TType -> TypedTree.TType -> unit - val AddCxMethodConstraint : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> OptionalTrace -> TypedTree.TraitConstraintInfo -> unit - val AddCxTypeMustSupportNull : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeMustSupportComparison : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeMustSupportEquality : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeMustSupportDefaultCtor : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeIsReferenceType : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeIsValueType : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeIsUnmanaged : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> OptionalTrace -> TypedTree.TType -> unit - val AddCxTypeIsEnum : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> - OptionalTrace -> TypedTree.TType -> TypedTree.TType -> unit - val AddCxTypeIsDelegate : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> - OptionalTrace -> - TypedTree.TType -> TypedTree.TType -> TypedTree.TType -> unit - val AddCxTyparDefaultsTo : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> - ContextInfo -> TypedTree.Typar -> int -> TypedTree.TType -> unit - val SolveTypeAsError : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> Range.range -> TypedTree.TType -> unit - val ApplyTyparDefaultAtPriority : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> priority:int -> TypedTree.Typar -> unit - val CreateCodegenState : - tcVal:TcValF -> - g:TcGlobals.TcGlobals -> amap:Import.ImportMap -> ConstraintSolverState - val CodegenWitnessExprForTraitConstraint : - TcValF -> - TcGlobals.TcGlobals -> - Import.ImportMap -> - Range.range -> - TypedTree.TraitConstraintInfo -> - TypedTree.Expr list -> - ErrorLogger.OperationResult - val CodegenWitnessesForTyparInst : - TcValF -> - TcGlobals.TcGlobals -> - Import.ImportMap -> - Range.range -> - TypedTree.Typar list -> - TypedTree.TType list -> - ErrorLogger.OperationResult list> - val CodegenWitnessArgForTraitConstraint : - TcValF -> - TcGlobals.TcGlobals -> - Import.ImportMap -> - Range.range -> - TypedTree.TraitConstraintInfo -> - ErrorLogger.OperationResult> - val ChooseTyparSolutionAndSolve : - ConstraintSolverState -> - TypedTreeOps.DisplayEnv -> TypedTree.Typar -> unit - val CheckDeclaredTypars : - TypedTreeOps.DisplayEnv -> - ConstraintSolverState -> - Range.range -> TypedTree.Typar list -> TypedTree.Typar list -> unit - val CanonicalizePartialInferenceProblem : - ConstraintSolverState -> - TypedTreeOps.DisplayEnv -> Range.range -> TypedTree.Typar list -> unit - val IsApplicableMethApprox : - TcGlobals.TcGlobals -> - Import.ImportMap -> - Range.range -> Infos.MethInfo -> TypedTree.TType -> bool - end - -namespace FSharp.Compiler - module internal CheckFormatStrings = begin - type FormatItem = - | Simple of TypedTree.TType - | FuncAndVal - val copyAndFixupFormatTypar : - m:Range.range -> tp:TypedTree.Typar -> TypedTree.TType - val lowestDefaultPriority : int - val mkFlexibleFormatTypar : - m:Range.range -> - tys:TypedTree.TTypes -> dflt:TypedTree.TType -> TypedTree.TType - val mkFlexibleIntFormatTypar : - g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.TType - val mkFlexibleDecimalFormatTypar : - g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.TType - val mkFlexibleFloatFormatTypar : - g:TcGlobals.TcGlobals -> m:Range.range -> TypedTree.TType - type FormatInfoRegister = - { mutable leftJustify: bool - mutable numPrefixIfPos: char option - mutable addZeros: bool - mutable precision: bool } - val newInfo : unit -> FormatInfoRegister - val parseFormatStringInternal : - m:Range.range -> - fragRanges:Range.range list -> - g:TcGlobals.TcGlobals -> - isInterpolated:bool -> - isFormattableString:bool -> - context:NameResolution.FormatStringCheckContext option -> - fmt:string -> - printerArgTy:TypedTree.TType -> - printerResidueTy:TypedTree.TType -> - TypedTree.TType list * (Range.range * int) list * string * - TypedTree.TType [] - val ParseFormatString : - m:Range.range -> - fragmentRanges:Range.range list -> - g:TcGlobals.TcGlobals -> - isInterpolated:bool -> - isFormattableString:bool -> - formatStringCheckContext:NameResolution.FormatStringCheckContext option -> - fmt:string -> - printerArgTy:TypedTree.TType -> - printerResidueTy:TypedTree.TType -> - printerResultTy:TypedTree.TType -> - TypedTree.TType list * TypedTree.TType * - TypedTree.TType * TypedTree.TType [] * - (Range.range * int) list * string - val TryCountFormatStringArguments : - m:Range.range -> - g:TcGlobals.TcGlobals -> - isInterpolated:bool -> - fmt:string -> - printerArgTy:TypedTree.TType -> - printerResidueTy:TypedTree.TType -> int option - end - -namespace FSharp.Compiler - module internal FindUnsolved = begin - type env = | Nix - type cenv = - { g: TcGlobals.TcGlobals - amap: Import.ImportMap - denv: TypedTreeOps.DisplayEnv - mutable unsolved: TypedTree.Typars } - with - override ToString : unit -> string - end - val accTy : cenv:cenv -> _env:'a -> ty:TypedTree.TType -> unit - val accTypeInst : cenv:cenv -> env:'a -> tyargs:TypedTree.TType list -> unit - val accExpr : cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit - val accMethods : - cenv:cenv -> - env:env -> - baseValOpt:TypedTree.Val option -> - l:TypedTree.ObjExprMethod list -> unit - val accMethod : - cenv:cenv -> - env:env -> - _baseValOpt:TypedTree.Val option -> TypedTree.ObjExprMethod -> unit - val accIntfImpls : - cenv:cenv -> - env:env -> - baseValOpt:TypedTree.Val option -> - l:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> unit - val accIntfImpl : - cenv:cenv -> - env:env -> - baseValOpt:TypedTree.Val option -> - ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> unit - val accOp : - cenv:cenv -> - env:env -> - op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * - _m:Range.range -> unit - val accTraitInfo : - cenv:cenv -> env:env -> TypedTree.TraitConstraintInfo -> unit - val accLambdas : - cenv:cenv -> - env:env -> - topValInfo:TypedTree.ValReprInfo -> - e:TypedTree.Expr -> ety:TypedTree.TType -> unit - val accExprs : cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> unit - val accTargets : - cenv:cenv -> - env:env -> - m:Range.range -> - ty:TypedTree.TType -> - targets:TypedTree.DecisionTreeTarget array -> unit - val accTarget : - cenv:cenv -> - env:env -> - _m:Range.range -> - _ty:TypedTree.TType -> TypedTree.DecisionTreeTarget -> unit - val accDTree : cenv:cenv -> env:env -> x:TypedTree.DecisionTree -> unit - val accSwitch : - cenv:cenv -> - env:env -> - e:TypedTree.Expr * cases:TypedTree.DecisionTreeCase list * - dflt:TypedTree.DecisionTree option * _m:Range.range -> unit - val accDiscrim : - cenv:cenv -> env:env -> d:TypedTree.DecisionTreeTest -> unit - val accAttrib : cenv:cenv -> env:env -> TypedTree.Attrib -> unit - val accAttribs : - cenv:cenv -> env:env -> attribs:TypedTree.Attrib list -> unit - val accValReprInfo : cenv:cenv -> env:env -> TypedTree.ValReprInfo -> unit - val accArgReprInfo : - cenv:cenv -> env:env -> argInfo:TypedTree.ArgReprInfo -> unit - val accVal : cenv:cenv -> env:env -> v:TypedTree.Val -> unit - val accBind : cenv:cenv -> env:env -> bind:TypedTree.Binding -> unit - val accBinds : cenv:cenv -> env:env -> xs:TypedTree.Bindings -> unit - val accTyconRecdField : - cenv:cenv -> env:env -> _tycon:'a -> rfield:TypedTree.RecdField -> unit - val accTycon : cenv:cenv -> env:env -> tycon:TypedTree.Tycon -> unit - val accTycons : cenv:cenv -> env:env -> tycons:TypedTree.Tycon list -> unit - val accModuleOrNamespaceExpr : - cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExprWithSig -> unit - val accModuleOrNamespaceDefs : - cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr list -> unit - val accModuleOrNamespaceDef : - cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr -> unit - val accModuleOrNamespaceBinds : - cenv:cenv -> env:env -> xs:TypedTree.ModuleOrNamespaceBinding list -> unit - val accModuleOrNamespaceBind : - cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceBinding -> unit - val UnsolvedTyparsOfModuleDef : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - denv:TypedTreeOps.DisplayEnv -> - mdef:TypedTree.ModuleOrNamespaceExpr * - extraAttribs:TypedTree.Attrib list -> TypedTree.Typar list - end - -namespace FSharp.Compiler - module internal QuotationTranslator = begin - val verboseCReflect : bool - [] - type IsReflectedDefinition = - | Yes - | No - [] - type QuotationSerializationFormat = - { SupportsWitnesses: bool - SupportsDeserializeEx: bool } - [] - type QuotationGenerationScope = - { g: TcGlobals.TcGlobals - amap: Import.ImportMap - scope: TypedTree.CcuThunk - tcVal: ConstraintSolver.TcValF - referencedTypeDefs: ResizeArray - referencedTypeDefsTable: - System.Collections.Generic.Dictionary - typeSplices: ResizeArray - exprSplices: ResizeArray - isReflectedDefinition: IsReflectedDefinition - quotationFormat: QuotationSerializationFormat - mutable emitDebugInfoInQuotations: bool } - with - static member - ComputeQuotationFormat : TcGlobals.TcGlobals -> - QuotationSerializationFormat - static member - Create : TcGlobals.TcGlobals * Import.ImportMap * TypedTree.CcuThunk * - ConstraintSolver.TcValF * IsReflectedDefinition -> - QuotationGenerationScope - member - Close : unit -> - AbstractIL.IL.ILTypeRef list * - (TypedTree.TType * Range.range) list * - (TypedTree.Expr * Range.range) list - end - type QuotationTranslationEnv = - { vs: TypedTreeOps.ValMap - numValsInScope: int - tyvs: TypedTree.StampMap - suppressWitnesses: bool - witnessesInScope: TypedTreeOps.TraitWitnessInfoHashMap - isinstVals: TypedTreeOps.ValMap - substVals: TypedTreeOps.ValMap } - with - static member - CreateEmpty : g:TcGlobals.TcGlobals -> QuotationTranslationEnv - member BindTypar : v:TypedTree.Typar -> QuotationTranslationEnv - member BindTypars : vs:TypedTree.Typar list -> QuotationTranslationEnv - member - BindWitnessInfo : witnessInfo:TypedTree.TraitWitnessInfo -> - QuotationTranslationEnv - member - BindWitnessInfos : witnessInfos:TypedTree.TraitWitnessInfo list -> - QuotationTranslationEnv - end - val BindFormalTypars : - env:QuotationTranslationEnv -> - vs:TypedTree.Typar list -> QuotationTranslationEnv - val BindVal : - env:QuotationTranslationEnv -> v:TypedTree.Val -> QuotationTranslationEnv - val BindIsInstVal : - env:QuotationTranslationEnv -> - v:TypedTree.Val -> - ty:TypedTree.TType * e:TypedTree.Expr -> QuotationTranslationEnv - val BindSubstVal : - env:QuotationTranslationEnv -> - v:TypedTree.Val -> e:TypedTree.Expr -> QuotationTranslationEnv - val BindVals : - env:QuotationTranslationEnv -> - vs:TypedTree.Val list -> QuotationTranslationEnv - val BindFlatVals : - env:QuotationTranslationEnv -> - vs:TypedTree.Val list -> QuotationTranslationEnv - exception InvalidQuotedTerm of exn - exception IgnoringPartOfQuotedTermWarning of string * Range.range - val wfail : e:exn -> 'a - val ( |ModuleValueOrMemberUse|_| ) : - TcGlobals.TcGlobals -> - TypedTree.Expr -> - (TypedTree.ValRef * TypedTree.ValUseFlag * TypedTree.Expr * - TypedTree.TType * TypedTree.TypeInst * TypedTree.Expr list) option - val ( |SimpleArrayLoopUpperBound|_| ) : TypedTree.Expr -> unit option - val ( |SimpleArrayLoopBody|_| ) : - TcGlobals.TcGlobals -> - TypedTree.Expr -> - (TypedTree.Expr * TypedTree.TType * TypedTree.Expr) option - val ( |ObjectInitializationCheck|_| ) : - TcGlobals.TcGlobals -> TypedTree.Expr -> unit option - val isSplice : TcGlobals.TcGlobals -> TypedTree.ValRef -> bool - val EmitDebugInfoIfNecessary : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - astExpr:QuotationPickler.ExprData -> QuotationPickler.ExprData - val ConvExpr : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - expr:TypedTree.Expr -> QuotationPickler.ExprData - val GetWitnessArgs : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - tps:TypedTree.Typars -> - tyargs:TypedTree.TType list -> QuotationPickler.ExprData list - val ConvWitnessInfo : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - traitInfo:TypedTree.TraitConstraintInfo -> QuotationPickler.ExprData - val private ConvExprCore : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - expr:TypedTree.Expr -> QuotationPickler.ExprData - val ConvLdfld : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - fspec:AbstractIL.IL.ILFieldSpec -> - enclTypeArgs:TypedTree.TypeInst -> - args:TypedTree.Exprs -> QuotationPickler.ExprData - val ConvUnionFieldGet : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - ucref:TypedTree.UnionCaseRef -> - n:int -> - tyargs:TypedTree.TypeInst -> - e:TypedTree.Expr -> QuotationPickler.ExprData - val ConvClassOrRecdFieldGet : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - rfref:TypedTree.RecdFieldRef -> - tyargs:TypedTree.TypeInst -> - args:TypedTree.Exprs -> QuotationPickler.ExprData - val private ConvClassOrRecdFieldGetCore : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - rfref:TypedTree.RecdFieldRef -> - tyargs:TypedTree.TypeInst -> - args:TypedTree.Exprs -> QuotationPickler.ExprData - val ConvLetBind : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - bind:TypedTree.Binding -> - (QuotationPickler.VarData * QuotationPickler.ExprData) option * - QuotationTranslationEnv - val ConvLValueArgs : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - args:TypedTree.Exprs -> QuotationPickler.ExprData list - val ConvLValueExpr : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - expr:TypedTree.Expr -> QuotationPickler.ExprData - val ConvLValueExprCore : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - expr:TypedTree.Expr -> QuotationPickler.ExprData - val ConvObjectModelCall : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - bool * bool * bool * QuotationPickler.NamedTypeData * - QuotationPickler.TypeData list * QuotationPickler.TypeData list * - QuotationPickler.TypeData * string * TypedTree.TypeInst * int * - TypedTree.Expr list * QuotationPickler.ExprData list * - TypedTree.Expr list list -> QuotationPickler.ExprData - val ConvObjectModelCallCore : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - isPropGet:bool * isPropSet:bool * isNewObj:bool * - parentTyconR:QuotationPickler.NamedTypeData * - witnessArgTypesR:QuotationPickler.TypeData list * - methArgTypesR:QuotationPickler.TypeData list * - methRetTypeR:QuotationPickler.TypeData * methName:string * - tyargs:TypedTree.TypeInst * numGenericArgs:int * - objArgs:TypedTree.Expr list * - witnessArgsR:QuotationPickler.ExprData list * - untupledCurriedArgs:TypedTree.Expr list list -> - QuotationPickler.ExprData - val ConvModuleValueApp : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - vref:TypedTree.ValRef -> - tyargs:TypedTree.TypeInst -> - witnessArgs:QuotationPickler.ExprData list -> - args:TypedTree.Expr list list -> QuotationPickler.ExprData - val ConvModuleValueAppCore : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - vref:TypedTree.ValRef -> - tyargs:TypedTree.TypeInst -> - witnessArgsR:QuotationPickler.ExprData list -> - curriedArgs:TypedTree.Expr list list -> - QuotationPickler.ExprData - val ConvExprs : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - args:TypedTree.Exprs -> QuotationPickler.ExprData list - val ConvValRef : - holeOk:bool -> - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - vref:TypedTree.ValRef -> - tyargs:TypedTree.TypeInst -> QuotationPickler.ExprData - val private ConvValRefCore : - holeOk:bool -> - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - vref:TypedTree.ValRef -> - tyargs:TypedTree.TypeInst -> QuotationPickler.ExprData - val ConvUnionCaseRef : - cenv:QuotationGenerationScope -> - ucref:TypedTree.UnionCaseRef -> - m:Range.range -> QuotationPickler.NamedTypeData * string - val ConvRecdFieldRef : - cenv:QuotationGenerationScope -> - rfref:TypedTree.RecdFieldRef -> - m:Range.range -> QuotationPickler.NamedTypeData * string - val ConvVal : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - v:TypedTree.Val -> QuotationPickler.VarData - val ConvTyparRef : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> tp:TypedTree.Typar -> int - val FilterMeasureTyargs : tys:TypedTree.TType list -> TypedTree.TType list - val ConvType : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> ty:TypedTree.TType -> QuotationPickler.TypeData - val ConvTypes : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - tys:TypedTree.TType list -> QuotationPickler.TypeData list - val ConvConst : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> - c:TypedTree.Const -> ty:TypedTree.TType -> QuotationPickler.ExprData - val ConvDecisionTree : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - tgs:TypedTree.DecisionTreeTarget array -> - typR:QuotationPickler.TypeData -> - x:TypedTree.DecisionTree -> QuotationPickler.ExprData - val IsILTypeRefStaticLinkLocal : - cenv:QuotationGenerationScope -> - m:Range.range -> tr:AbstractIL.IL.ILTypeRef -> bool - val ConvILTypeRefUnadjusted : - cenv:QuotationGenerationScope -> - m:Range.range -> - tr:AbstractIL.IL.ILTypeRef -> QuotationPickler.NamedTypeData - val ConvILTypeRef : - cenv:QuotationGenerationScope -> - tr:AbstractIL.IL.ILTypeRef -> QuotationPickler.NamedTypeData - val ConvVoidType : - cenv:QuotationGenerationScope -> - m:Range.range -> QuotationPickler.TypeData - val ConvILType : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - m:Range.range -> ty:AbstractIL.IL.ILType -> QuotationPickler.TypeData - val TryElimErasableTyconRef : - cenv:QuotationGenerationScope -> - m:Range.range -> tcref:TypedTree.TyconRef -> TypedTree.TType option - val ConvTyconRef : - cenv:QuotationGenerationScope -> - tcref:TypedTree.TyconRef -> - m:Range.range -> QuotationPickler.NamedTypeData - val ConvReturnType : - cenv:QuotationGenerationScope -> - envinner:QuotationTranslationEnv -> - m:Range.range -> - retTy:TypedTree.TType option -> QuotationPickler.TypeData - val ConvExprPublic : - QuotationGenerationScope -> - suppressWitnesses:bool -> TypedTree.Expr -> QuotationPickler.ExprData - val ConvMethodBase : - cenv:QuotationGenerationScope -> - env:QuotationTranslationEnv -> - methName:string * v:TypedTree.Val -> QuotationPickler.MethodBaseData - val ConvReflectedDefinition : - QuotationGenerationScope -> - string -> - TypedTree.Val -> - TypedTree.Expr -> - QuotationPickler.MethodBaseData * QuotationPickler.ExprData - end - -namespace FSharp.Compiler - module internal PostTypeCheckSemanticChecks = begin - type env = - { boundTyparNames: string list - boundTypars: TypedTreeOps.TyparMap - argVals: TypedTreeOps.ValMap - sigToImplRemapInfo: - (TypedTreeOps.Remap * TypedTreeOps.SignatureHidingInfo) list - ctorLimitedZone: bool - quote: bool - reflect: bool - external: bool - returnScope: int - isInAppExpr: bool } - with - override ToString : unit -> string - end - val BindTypar : env:env -> tp:TypedTree.Typar -> env - val BindTypars : - g:TcGlobals.TcGlobals -> env:env -> tps:TypedTree.Typar list -> env - val BindArgVals : env:env -> vs:TypedTree.Val list -> env - [] - type LimitFlags = - | None = 0 - | ByRef = 1 - | ByRefOfSpanLike = 3 - | ByRefOfStackReferringSpanLike = 5 - | SpanLike = 8 - | StackReferringSpanLike = 16 - [] - type Limit = - { scope: int - flags: LimitFlags } - with - member IsLocal : bool - end - val inline HasLimitFlag : targetLimit:LimitFlags -> limit:Limit -> bool - val NoLimit : Limit - val CombineTwoLimits : limit1:Limit -> limit2:Limit -> Limit - val CombineLimits : limits:Limit list -> Limit - type cenv = - { boundVals: System.Collections.Generic.Dictionary - limitVals: System.Collections.Generic.Dictionary - mutable potentialUnboundUsesOfVals: TypedTree.StampMap - mutable anonRecdTypes: TypedTree.StampMap - g: TcGlobals.TcGlobals - amap: Import.ImportMap - infoReader: InfoReader.InfoReader - internalsVisibleToPaths: TypedTree.CompilationPath list - denv: TypedTreeOps.DisplayEnv - viewCcu: TypedTree.CcuThunk - reportErrors: bool - isLastCompiland: bool * bool - isInternalTestSpanStackReferring: bool - mutable usesQuotations: bool - mutable entryPointGiven: bool - tcVal: ConstraintSolver.TcValF } - with - override ToString : unit -> string - end - val IsValArgument : env:env -> v:TypedTree.Val -> bool - val IsValLocal : env:env -> v:TypedTree.Val -> bool - val GetLimitVal : - cenv:cenv -> env:env -> m:Range.range -> v:TypedTree.Val -> Limit - val GetLimitValByRef : - cenv:cenv -> env:env -> m:Range.range -> v:TypedTree.Val -> Limit - val LimitVal : cenv:cenv -> v:TypedTree.Val -> limit:Limit -> unit - val BindVal : cenv:cenv -> env:env -> v:TypedTree.Val -> unit - val BindVals : cenv:cenv -> env:env -> vs:TypedTree.Val list -> unit - val RecordAnonRecdInfo : - cenv:cenv -> anonInfo:TypedTree.AnonRecdTypeInfo -> unit - val CheckTypeDeep : - cenv:cenv -> - (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * - (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * - (TypedTree.TraitConstraintSln -> unit) option * - (env * TypedTree.Typar -> unit) option -> - g:TcGlobals.TcGlobals -> - env:env -> isInner:bool -> ty:TypedTree.TType -> unit - val CheckTypesDeep : - cenv:cenv -> - (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * - (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * - (TypedTree.TraitConstraintSln -> unit) option * - (env * TypedTree.Typar -> unit) option -> - g:TcGlobals.TcGlobals -> env:env -> tys:TypedTree.TypeInst -> unit - val CheckTypesDeepNoInner : - cenv:cenv -> - (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * - (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * - (TypedTree.TraitConstraintSln -> unit) option * - (env * TypedTree.Typar -> unit) option -> - g:TcGlobals.TcGlobals -> env:env -> tys:TypedTree.TypeInst -> unit - val CheckTypeConstraintDeep : - cenv:cenv -> - (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * - (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * - (TypedTree.TraitConstraintSln -> unit) option * - (env * TypedTree.Typar -> unit) option -> - g:TcGlobals.TcGlobals -> - env:env -> x:TypedTree.TyparConstraint -> unit - val CheckTraitInfoDeep : - cenv:cenv -> - (TypedTree.TType -> unit) * (bool -> TypedTree.TyconRef -> unit) option * - (TypedTree.TyconRef * TypedTree.TypeInst -> unit) option * - (TypedTree.TraitConstraintSln -> unit) option * - (env * TypedTree.Typar -> unit) option -> - g:TcGlobals.TcGlobals -> - env:env -> TypedTree.TraitConstraintInfo -> unit - val CheckForByrefLikeType : - cenv:cenv -> - env:env -> - m:Range.range -> ty:TypedTree.TType -> check:(unit -> unit) -> unit - val CheckForByrefType : - cenv:cenv -> env:env -> ty:TypedTree.TType -> check:(unit -> unit) -> unit - val CheckEscapes : - cenv:cenv -> - allowProtected:bool -> - m:Range.range -> - syntacticArgs:TypedTree.Val list -> - body:TypedTree.Expr -> TypedTree.FreeVars option - val AccessInternalsVisibleToAsInternal : - thisCompPath:TypedTree.CompilationPath -> - internalsVisibleToPaths:TypedTree.CompilationPath list -> - access:TypedTree.Accessibility -> TypedTree.Accessibility - val CheckTypeForAccess : - cenv:cenv -> - env:env -> - objName:(unit -> System.String) -> - valAcc:TypedTree.Accessibility -> - m:Range.range -> ty:TypedTree.TType -> unit - val WarnOnWrongTypeForAccess : - cenv:cenv -> - env:env -> - objName:(unit -> System.String) -> - valAcc:TypedTree.Accessibility -> - m:Range.range -> ty:TypedTree.TType -> unit - [] - type PermitByRefType = - | None - | NoInnerByRefLike - | SpanLike - | All - [] - type PermitByRefExpr = - | YesTupleOfArgs of int - | Yes - | YesReturnable - | YesReturnableNonLocal - | No - with - member Disallow : bool - member PermitOnlyReturnable : bool - member PermitOnlyReturnableNonLocal : bool - end - val inline IsLimitEscapingScope : - env:env -> context:PermitByRefExpr -> limit:Limit -> bool - val mkArgsPermit : n:int -> PermitByRefExpr - val mkArgsForAppliedVal : - isBaseCall:bool -> - vref:TypedTree.ValRef -> argsl:'a list -> PermitByRefExpr list - val mkArgsForAppliedExpr : - isBaseCall:bool -> - argsl:'a list -> x:TypedTree.Expr -> PermitByRefExpr list - val CheckTypeAux : - permitByRefLike:PermitByRefType -> - cenv:cenv -> - env:env -> - m:Range.range -> - ty:TypedTree.TType -> onInnerByrefError:(unit -> unit) -> unit - val CheckType : - permitByRefLike:PermitByRefType -> - cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit - val CheckTypeNoByrefs : - cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit - val CheckTypePermitSpanLike : - cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit - val CheckTypePermitAllByrefs : - cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit - val CheckTypeNoInnerByrefs : - cenv:cenv -> env:env -> m:Range.range -> ty:TypedTree.TType -> unit - val CheckTypeInstNoByrefs : - cenv:cenv -> - env:env -> m:Range.range -> tyargs:TypedTree.TType list -> unit - val CheckTypeInstPermitAllByrefs : - cenv:cenv -> - env:env -> m:Range.range -> tyargs:TypedTree.TType list -> unit - val CheckTypeInstNoInnerByrefs : - cenv:cenv -> - env:env -> m:Range.range -> tyargs:TypedTree.TType list -> unit - val ( |OptionalCoerce| ) : _arg1:TypedTree.Expr -> TypedTree.Expr - val CheckNoReraise : - cenv:cenv -> - freesOpt:TypedTree.FreeVars option -> body:TypedTree.Expr -> unit - val isSpliceOperator : g:TcGlobals.TcGlobals -> v:TypedTree.ValRef -> bool - type TTypeEquality = - | ExactlyEqual - | FeasiblyEqual - | NotEqual - val compareTypesWithRegardToTypeVariablesAndMeasures : - g:TcGlobals.TcGlobals -> - amap:'a -> - m:Range.range -> - typ1:TypedTree.TType -> typ2:TypedTree.TType -> TTypeEquality - val CheckMultipleInterfaceInstantiations : - cenv:cenv -> - typ:TypedTree.TType -> - interfaces:TypedTree.TType list -> - isObjectExpression:bool -> m:Range.range -> unit - val CheckExprNoByrefs : cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit - val CheckValRef : - cenv:cenv -> - env:env -> - v:TypedTree.ValRef -> m:Range.range -> context:PermitByRefExpr -> unit - val CheckValUse : - cenv:cenv -> - env:env -> - vref:TypedTree.ValRef * vFlags:TypedTree.ValUseFlag * m:Range.range -> - context:PermitByRefExpr -> Limit - val CheckForOverAppliedExceptionRaisingPrimitive : - cenv:cenv -> expr:TypedTree.Expr -> unit - val CheckCallLimitArgs : - cenv:cenv -> - env:env -> - m:Range.range -> - returnTy:TypedTree.TType -> - limitArgs:Limit -> context:PermitByRefExpr -> Limit - val CheckCall : - cenv:cenv -> - env:env -> - m:Range.range -> - returnTy:TypedTree.TType -> - args:TypedTree.Expr list -> - contexts:PermitByRefExpr list -> - context:PermitByRefExpr -> Limit - val CheckCallWithReceiver : - cenv:cenv -> - env:env -> - m:Range.range -> - returnTy:TypedTree.TType -> - args:TypedTree.Expr list -> - contexts:PermitByRefExpr list -> - context:PermitByRefExpr -> Limit - val CheckExprLinear : - cenv:cenv -> - env:env -> - expr:TypedTree.Expr -> - context:PermitByRefExpr -> contf:(Limit -> Limit) -> Limit - val CheckExpr : - cenv:cenv -> - env:env -> origExpr:TypedTree.Expr -> context:PermitByRefExpr -> Limit - val CheckMethods : - cenv:cenv -> - env:env -> - baseValOpt:TypedTree.Val option -> - methods:TypedTree.ObjExprMethod list -> unit - val CheckMethod : - cenv:cenv -> - env:env -> - baseValOpt:TypedTree.Val option -> TypedTree.ObjExprMethod -> unit - val CheckInterfaceImpls : - cenv:cenv -> - env:env -> - baseValOpt:TypedTree.Val option -> - l:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> unit - val CheckInterfaceImpl : - cenv:cenv -> - env:env -> - baseValOpt:TypedTree.Val option -> - _ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> unit - val CheckExprOp : - cenv:cenv -> - env:env -> - op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * - m:Range.range -> - context:PermitByRefExpr -> expr:TypedTree.Expr -> Limit - val CheckLambdas : - isTop:bool -> - memInfo:TypedTree.ValMemberInfo option -> - cenv:cenv -> - env:env -> - inlined:bool -> - topValInfo:TypedTree.ValReprInfo -> - alwaysCheckNoReraise:bool -> - e:TypedTree.Expr -> - mOrig:Range.range -> - ety:TypedTree.TType -> context:PermitByRefExpr -> Limit - val CheckExprs : - cenv:cenv -> - env:env -> - exprs:TypedTree.Expr list -> contexts:PermitByRefExpr list -> Limit - val CheckExprsNoByRefLike : - cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> Limit - val CheckExprsPermitByRefLike : - cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> Limit - val CheckExprsPermitReturnableByRef : - cenv:cenv -> env:env -> exprs:TypedTree.Expr list -> Limit - val CheckExprPermitByRefLike : - cenv:cenv -> env:env -> expr:TypedTree.Expr -> Limit - val CheckExprPermitReturnableByRef : - cenv:cenv -> env:env -> expr:TypedTree.Expr -> Limit - val CheckDecisionTreeTargets : - cenv:cenv -> - env:env -> - targets:TypedTree.DecisionTreeTarget array -> - context:PermitByRefExpr -> Limit - val CheckDecisionTreeTarget : - cenv:cenv -> - env:env -> - context:PermitByRefExpr -> TypedTree.DecisionTreeTarget -> Limit - val CheckDecisionTree : - cenv:cenv -> env:env -> x:TypedTree.DecisionTree -> unit - val CheckDecisionTreeSwitch : - cenv:cenv -> - env:env -> - e:TypedTree.Expr * cases:TypedTree.DecisionTreeCase list * - dflt:TypedTree.DecisionTree option * m:Range.range -> unit - val CheckDecisionTreeTest : - cenv:cenv -> - env:env -> m:Range.range -> discrim:TypedTree.DecisionTreeTest -> unit - val CheckAttrib : cenv:cenv -> env:env -> TypedTree.Attrib -> unit - val CheckAttribExpr : cenv:cenv -> env:env -> TypedTree.AttribExpr -> unit - val CheckAttribArgExpr : cenv:cenv -> env:env -> expr:TypedTree.Expr -> unit - val CheckAttribs : cenv:cenv -> env:env -> attribs:TypedTree.Attribs -> unit - val CheckValInfo : cenv:cenv -> env:env -> TypedTree.ValReprInfo -> unit - val CheckArgInfo : - cenv:cenv -> env:env -> argInfo:TypedTree.ArgReprInfo -> unit - val CheckValSpecAux : - permitByRefLike:PermitByRefType -> - cenv:cenv -> - env:env -> v:TypedTree.Val -> onInnerByrefError:(unit -> unit) -> unit - val CheckValSpec : - permitByRefLike:PermitByRefType -> - cenv:cenv -> env:env -> v:TypedTree.Val -> unit - val AdjustAccess : - isHidden:bool -> - cpath:(unit -> TypedTree.CompilationPath) -> - access:TypedTree.Accessibility -> TypedTree.Accessibility - val CheckBinding : - cenv:cenv -> - env:env -> - alwaysCheckNoReraise:bool -> - context:PermitByRefExpr -> TypedTree.Binding -> Limit - val CheckBindings : cenv:cenv -> env:env -> xs:TypedTree.Bindings -> unit - val CheckModuleBinding : cenv:cenv -> env:env -> TypedTree.Binding -> unit - val CheckModuleBindings : - cenv:cenv -> env:env -> binds:TypedTree.Binding list -> unit - val CheckRecdField : - isUnion:bool -> - cenv:cenv -> - env:env -> tycon:TypedTree.Tycon -> rfield:TypedTree.RecdField -> unit - val CheckEntityDefn : cenv:cenv -> env:env -> tycon:TypedTree.Entity -> unit - val CheckEntityDefns : - cenv:cenv -> env:env -> tycons:TypedTree.Entity list -> unit - val CheckModuleExpr : - cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExprWithSig -> unit - val CheckDefnsInModule : - cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr list -> unit - val CheckNothingAfterEntryPoint : cenv:cenv -> m:Range.range -> unit - val CheckDefnInModule : - cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceExpr -> unit - val CheckModuleSpec : - cenv:cenv -> env:env -> x:TypedTree.ModuleOrNamespaceBinding -> unit - val CheckTopImpl : - g:TcGlobals.TcGlobals * amap:Import.ImportMap * reportErrors:bool * - infoReader:InfoReader.InfoReader * - internalsVisibleToPaths:TypedTree.CompilationPath list * - viewCcu:TypedTree.CcuThunk * tcValF:ConstraintSolver.TcValF * - denv:TypedTreeOps.DisplayEnv * - mexpr:TypedTree.ModuleOrNamespaceExprWithSig * - extraAttribs:TypedTree.Attribs * (bool * bool) * - isInternalTestSpanStackReferring:bool -> - bool * TypedTree.StampMap - end - -namespace FSharp.Compiler - module internal CheckExpressions = begin - val mkNilListPat : - g:TcGlobals.TcGlobals -> - m:Range.range -> ty:TypedTree.TType -> PatternMatchCompilation.Pattern - val mkConsListPat : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> - ph:PatternMatchCompilation.Pattern -> - pt:PatternMatchCompilation.Pattern -> - PatternMatchCompilation.Pattern - exception BakedInMemberConstraintName of string * Range.range - exception FunctionExpected of - TypedTreeOps.DisplayEnv * TypedTree.TType * - Range.range - exception NotAFunction of - TypedTreeOps.DisplayEnv * TypedTree.TType * - Range.range * Range.range - exception NotAFunctionButIndexer of - TypedTreeOps.DisplayEnv * TypedTree.TType * - string option * Range.range * Range.range - exception Recursion of - TypedTreeOps.DisplayEnv * SyntaxTree.Ident * - TypedTree.TType * TypedTree.TType * Range.range - exception RecursiveUseCheckedAtRuntime of - TypedTreeOps.DisplayEnv * - TypedTree.ValRef * Range.range - exception LetRecEvaluatedOutOfOrder of - TypedTreeOps.DisplayEnv * - TypedTree.ValRef * TypedTree.ValRef * - Range.range - exception LetRecCheckedAtRuntime of Range.range - exception LetRecUnsound of - TypedTreeOps.DisplayEnv * TypedTree.ValRef list * - Range.range - exception TyconBadArgs of - TypedTreeOps.DisplayEnv * TypedTree.TyconRef * int * - Range.range - exception UnionCaseWrongArguments of - TypedTreeOps.DisplayEnv * int * int * - Range.range - exception UnionCaseWrongNumberOfArgs of - TypedTreeOps.DisplayEnv * int * int * - Range.range - exception FieldsFromDifferentTypes of - TypedTreeOps.DisplayEnv * - TypedTree.RecdFieldRef * - TypedTree.RecdFieldRef * Range.range - exception FieldGivenTwice of - TypedTreeOps.DisplayEnv * TypedTree.RecdFieldRef * - Range.range - exception MissingFields of string list * Range.range - exception FunctionValueUnexpected of - TypedTreeOps.DisplayEnv * - TypedTree.TType * Range.range - exception UnitTypeExpected of - TypedTreeOps.DisplayEnv * TypedTree.TType * - Range.range - exception UnitTypeExpectedWithEquality of - TypedTreeOps.DisplayEnv * - TypedTree.TType * Range.range - exception UnitTypeExpectedWithPossibleAssignment of - TypedTreeOps.DisplayEnv * - TypedTree.TType * bool * - string * Range.range - exception UnitTypeExpectedWithPossiblePropertySetter of - TypedTreeOps.DisplayEnv * - TypedTree.TType * - string * string * - Range.range - exception UnionPatternsBindDifferentNames of Range.range - exception VarBoundTwice of SyntaxTree.Ident - exception ValueRestriction of - TypedTreeOps.DisplayEnv * bool * TypedTree.Val * - TypedTree.Typar * Range.range - exception ValNotMutable of - TypedTreeOps.DisplayEnv * TypedTree.ValRef * - Range.range - exception ValNotLocal of - TypedTreeOps.DisplayEnv * TypedTree.ValRef * - Range.range - exception InvalidRuntimeCoercion of - TypedTreeOps.DisplayEnv * TypedTree.TType * - TypedTree.TType * Range.range - exception IndeterminateRuntimeCoercion of - TypedTreeOps.DisplayEnv * - TypedTree.TType * TypedTree.TType * - Range.range - exception IndeterminateStaticCoercion of - TypedTreeOps.DisplayEnv * - TypedTree.TType * TypedTree.TType * - Range.range - exception RuntimeCoercionSourceSealed of - TypedTreeOps.DisplayEnv * - TypedTree.TType * Range.range - exception CoercionTargetSealed of - TypedTreeOps.DisplayEnv * TypedTree.TType * - Range.range - exception UpcastUnnecessary of Range.range - exception TypeTestUnnecessary of Range.range - exception StaticCoercionShouldUseBox of - TypedTreeOps.DisplayEnv * - TypedTree.TType * TypedTree.TType * - Range.range - exception SelfRefObjCtor of bool * Range.range - exception VirtualAugmentationOnNullValuedType of Range.range - exception NonVirtualAugmentationOnNullValuedType of Range.range - exception UseOfAddressOfOperator of Range.range - exception DeprecatedThreadStaticBindingWarning of Range.range - exception IntfImplInIntrinsicAugmentation of Range.range - exception IntfImplInExtrinsicAugmentation of Range.range - exception OverrideInIntrinsicAugmentation of Range.range - exception OverrideInExtrinsicAugmentation of Range.range - exception NonUniqueInferredAbstractSlot of - TcGlobals.TcGlobals * - TypedTreeOps.DisplayEnv * string * - Infos.MethInfo * Infos.MethInfo * - Range.range - exception StandardOperatorRedefinitionWarning of string * Range.range - exception InvalidInternalsVisibleToAssemblyName of string * string option - type SafeInitData = - | SafeInitField of TypedTree.RecdFieldRef * TypedTree.RecdField - | NoSafeInitInfo - [] - type CtorInfo = - { ctorShapeCounter: int - safeThisValOpt: TypedTree.Val option - safeInitInfo: SafeInitData - ctorIsImplicit: bool } - [] - type UngeneralizableItem = - class - new : computeFreeTyvars:(unit -> TypedTree.FreeTyvars) -> - UngeneralizableItem - member GetFreeTyvars : unit -> TypedTree.FreeTyvars - member CachedFreeLocalTycons : TypedTree.FreeTycons - member CachedFreeTraitSolutions : TypedTree.FreeLocals - member WillNeverHaveFreeTypars : bool - end - [] - type TcEnv = - { eNameResEnv: NameResolution.NameResolutionEnv - eUngeneralizableItems: UngeneralizableItem list - ePath: SyntaxTree.Ident list - eCompPath: TypedTree.CompilationPath - eAccessPath: TypedTree.CompilationPath - eAccessRights: AccessibilityLogic.AccessorDomain - eInternalsVisibleCompPaths: TypedTree.CompilationPath list - eModuleOrNamespaceTypeAccumulator: TypedTree.ModuleOrNamespaceType ref - eContextInfo: ConstraintSolver.ContextInfo - eFamilyType: TypedTree.TyconRef option - eCtorInfo: CtorInfo option - eCallerMemberName: string option } - with - override ToString : unit -> string - member AccessRights : AccessibilityLogic.AccessorDomain - member DisplayEnv : TypedTreeOps.DisplayEnv - member NameEnv : NameResolution.NameResolutionEnv - end - val ComputeAccessRights : - eAccessPath:TypedTree.CompilationPath -> - eInternalsVisibleCompPaths:TypedTree.CompilationPath list -> - eFamilyType:TypedTree.TyconRef option -> - AccessibilityLogic.AccessorDomain - val InitialExplicitCtorInfo : - safeThisValOpt:TypedTree.Val option * safeInitInfo:SafeInitData -> - CtorInfo - val InitialImplicitCtorInfo : unit -> CtorInfo - val EnterFamilyRegion : tcref:TypedTree.TyconRef -> env:TcEnv -> TcEnv - val ExitFamilyRegion : env:TcEnv -> TcEnv - val AreWithinCtorShape : env:TcEnv -> bool - val AreWithinImplicitCtor : env:TcEnv -> bool - val GetCtorShapeCounter : env:TcEnv -> int - val GetRecdInfo : env:TcEnv -> TypedTree.RecordConstructionInfo - val AdjustCtorShapeCounter : f:(int -> int) -> env:TcEnv -> TcEnv - val ExitCtorShapeRegion : env:TcEnv -> TcEnv - val addFreeItemOfTy : - ty:TypedTree.TType -> - eUngeneralizableItems:UngeneralizableItem list -> - UngeneralizableItem list - val addFreeItemOfModuleTy : - TypedTree.ModuleOrNamespaceType -> - UngeneralizableItem list -> UngeneralizableItem list - val AddValMapToNameEnv : - vs:AbstractIL.Internal.Library.NameMap -> - nenv:NameResolution.NameResolutionEnv -> - NameResolution.NameResolutionEnv - val AddValListToNameEnv : - vs:TypedTree.Val list -> - nenv:NameResolution.NameResolutionEnv -> - NameResolution.NameResolutionEnv - val AddLocalValPrimitive : v:TypedTree.Val -> TcEnv -> TcEnv - val AddLocalValMap : - tcSink:NameResolution.TcResultsSink -> - scopem:Range.range -> - vals:AbstractIL.Internal.Library.NameMap -> - env:TcEnv -> TcEnv - val AddLocalVals : - tcSink:NameResolution.TcResultsSink -> - scopem:Range.range -> vals:TypedTree.Val list -> env:TcEnv -> TcEnv - val AddLocalVal : - NameResolution.TcResultsSink -> - scopem:Range.range -> v:TypedTree.Val -> TcEnv -> TcEnv - val AddDeclaredTypars : - check:NameResolution.CheckForDuplicateTyparFlag -> - typars:TypedTree.Typar list -> env:TcEnv -> TcEnv - type UnscopedTyparEnv = - | UnscopedTyparEnv of AbstractIL.Internal.Library.NameMap - val emptyUnscopedTyparEnv : UnscopedTyparEnv - val AddUnscopedTypar : - n:string -> p:TypedTree.Typar -> UnscopedTyparEnv -> UnscopedTyparEnv - val TryFindUnscopedTypar : - n:string -> UnscopedTyparEnv -> TypedTree.Typar option - val HideUnscopedTypars : - typars:TypedTree.Typar list -> UnscopedTyparEnv -> UnscopedTyparEnv - [] - type TcFileState = - { g: TcGlobals.TcGlobals - mutable recUses: - TypedTreeOps.ValMultiMap - mutable postInferenceChecks: ResizeArray<(unit -> unit)> - mutable createsGeneratedProvidedTypes: bool - isScript: bool - amap: Import.ImportMap - synArgNameGenerator: SyntaxTreeOps.SynArgNameGenerator - tcSink: NameResolution.TcResultsSink - topCcu: TypedTree.CcuThunk - css: ConstraintSolver.ConstraintSolverState - compilingCanonicalFslibModuleType: bool - isSig: bool - haveSig: bool - niceNameGen: CompilerGlobalState.NiceNameGenerator - infoReader: InfoReader.InfoReader - nameResolver: NameResolution.NameResolver - conditionalDefines: string list option - isInternalTestSpanStackReferring: bool - TcSequenceExpressionEntry: - TcFileState -> TcEnv -> TypedTree.TType -> UnscopedTyparEnv -> - bool * bool ref * SyntaxTree.SynExpr -> Range.range -> - TypedTree.Expr * UnscopedTyparEnv - TcArrayOrListSequenceExpression: - TcFileState -> TcEnv -> TypedTree.TType -> UnscopedTyparEnv -> - bool * SyntaxTree.SynExpr -> Range.range -> - TypedTree.Expr * UnscopedTyparEnv - TcComputationExpression: - TcFileState -> TcEnv -> TypedTree.TType -> UnscopedTyparEnv -> - Range.range * TypedTree.Expr * TypedTree.TType * SyntaxTree.SynExpr -> - TypedTree.Expr * UnscopedTyparEnv } - with - static member - Create : g:TcGlobals.TcGlobals * isScript:bool * - niceNameGen:CompilerGlobalState.NiceNameGenerator * - amap:Import.ImportMap * topCcu:TypedTree.CcuThunk * - isSig:bool * haveSig:bool * - conditionalDefines:string list option * - tcSink:NameResolution.TcResultsSink * - tcVal:ConstraintSolver.TcValF * - isInternalTestSpanStackReferring:bool * - tcSequenceExpressionEntry:(TcFileState -> TcEnv -> - TypedTree.TType -> - UnscopedTyparEnv -> - bool * bool ref * - SyntaxTree.SynExpr -> - Range.range -> - TypedTree.Expr * - UnscopedTyparEnv) * - tcArrayOrListSequenceExpression:(TcFileState -> TcEnv -> - TypedTree.TType -> - UnscopedTyparEnv -> - bool * SyntaxTree.SynExpr -> - Range.range -> - TypedTree.Expr * - UnscopedTyparEnv) * - tcComputationExpression:(TcFileState -> TcEnv -> - TypedTree.TType -> - UnscopedTyparEnv -> - Range.range * TypedTree.Expr * - TypedTree.TType * - SyntaxTree.SynExpr -> - TypedTree.Expr * UnscopedTyparEnv) -> - TcFileState - override ToString : unit -> string - end - type cenv = TcFileState - val CopyAndFixupTypars : - m:Range.range -> - rigid:TypedTree.TyparRigidity -> - tpsorig:TypedTree.Typars -> - TypedTree.Typars * TypedTreeOps.TyparInst * TypedTree.TType list - val UnifyTypes : - cenv:TcFileState -> - env:TcEnv -> - m:Range.range -> - actualTy:TypedTree.TType -> expectedTy:TypedTree.TType -> unit - val MakeInnerEnvWithAcc : - addOpenToNameEnv:bool -> - env:TcEnv -> - nm:SyntaxTree.Ident -> - mtypeAcc:TypedTree.ModuleOrNamespaceType ref -> - modKind:TypedTree.ModuleOrNamespaceKind -> TcEnv - val MakeInnerEnv : - addOpenToNameEnv:bool -> - env:TcEnv -> - nm:SyntaxTree.Ident -> - modKind:TypedTree.ModuleOrNamespaceKind -> - TcEnv * TypedTree.ModuleOrNamespaceType ref - val MakeInnerEnvForTyconRef : - env:TcEnv -> - tcref:TypedTree.TyconRef -> isExtrinsicExtension:bool -> TcEnv - val MakeInnerEnvForMember : env:TcEnv -> v:TypedTree.Val -> TcEnv - val GetCurrAccumulatedModuleOrNamespaceType : - env:TcEnv -> TypedTree.ModuleOrNamespaceType - val SetCurrAccumulatedModuleOrNamespaceType : - env:TcEnv -> x:TypedTree.ModuleOrNamespaceType -> unit - val LocateEnv : - ccu:TypedTree.CcuThunk -> - env:TcEnv -> enclosingNamespacePath:SyntaxTree.Ident list -> TcEnv - val ShrinkContext : - env:TcEnv -> oldRange:Range.range -> newRange:Range.range -> TcEnv - val UnifyRefTupleType : - contextInfo:ConstraintSolver.ContextInfo -> - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - m:Range.range -> - ty:TypedTree.TType -> ps:'a list -> TypedTree.TTypes - val UnifyTupleTypeAndInferCharacteristics : - contextInfo:ConstraintSolver.ContextInfo -> - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - m:Range.range -> - knownTy:TypedTree.TType -> - isExplicitStruct:bool -> - ps:'a list -> TypedTree.TupInfo * TypedTree.TTypes - val UnifyAnonRecdTypeAndInferCharacteristics : - contextInfo:ConstraintSolver.ContextInfo -> - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - m:Range.range -> - ty:TypedTree.TType -> - isExplicitStruct:bool -> - unsortedNames:SyntaxTree.Ident [] -> - TypedTree.AnonRecdTypeInfo * TypedTree.TType list - val UnifyFunctionTypeUndoIfFailed : - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - m:Range.range -> - ty:TypedTree.TType -> (TypedTree.TType * TypedTree.TType) voption - val UnifyFunctionType : - extraInfo:Range.range option -> - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - mFunExpr:Range.range -> - ty:TypedTree.TType -> TypedTree.TType * TypedTree.TType - val ReportImplicitlyIgnoredBoolExpression : - denv:TypedTreeOps.DisplayEnv -> - m:Range.range -> ty:TypedTree.TType -> expr:TypedTree.Expr -> exn - val UnifyUnitType : - cenv:TcFileState -> - env:TcEnv -> - m:Range.range -> ty:TypedTree.TType -> expr:TypedTree.Expr -> bool - val TryUnifyUnitTypeWithoutWarning : - cenv:TcFileState -> - env:TcEnv -> m:Range.range -> ty:TypedTree.TType -> bool - module AttributeTargets = begin - val FieldDecl : System.AttributeTargets - val FieldDeclRestricted : System.AttributeTargets - val UnionCaseDecl : System.AttributeTargets - val TyconDecl : System.AttributeTargets - val ExnDecl : System.AttributeTargets - val ModuleDecl : System.AttributeTargets - val Top : System.AttributeTargets - end - val ForNewConstructors : - tcSink:NameResolution.TcResultsSink -> - env:TcEnv -> - mObjTy:Range.range -> - methodName:string -> - meths:Infos.MethInfo list -> NameResolution.AfterResolution - val TcSynRationalConst : c:SyntaxTree.SynRationalConst -> Rational.Rational - val TcConst : - cenv:TcFileState -> - ty:TypedTree.TType -> - m:Range.range -> env:TcEnv -> c:SyntaxTree.SynConst -> TypedTree.Const - val TcFieldInit : - Range.range -> AbstractIL.IL.ILFieldInit -> TypedTree.Const - val AdjustValSynInfoInSignature : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo - type PartialValReprInfo = - | PartialValReprInfo of - curriedArgInfos: TypedTree.ArgReprInfo list list * - returnInfo: TypedTree.ArgReprInfo - val TranslateTopArgSynInfo : - isArg:bool -> - m:Range.range -> - tcAttributes:(SyntaxTree.SynAttribute list -> TypedTree.Attribs) -> - SyntaxTree.SynArgInfo -> TypedTree.ArgReprInfo - val TranslateTopValSynInfo : - Range.range -> - tcAttributes:(System.AttributeTargets -> SyntaxTree.SynAttribute list -> - TypedTree.Attribs) -> - synValInfo:SyntaxTree.SynValInfo -> PartialValReprInfo - val TranslatePartialArity : - tps:TypedTree.Typar list -> PartialValReprInfo -> TypedTree.ValReprInfo - val ComputeLogicalName : - id:SyntaxTree.Ident -> memberFlags:SyntaxTree.MemberFlags -> string - type PreValMemberInfo = - | PreValMemberInfo of - memberInfo: TypedTree.ValMemberInfo * logicalName: string * - compiledName: string - val MakeMemberDataAndMangledNameForMemberVal : - g:TcGlobals.TcGlobals * tcref:TypedTree.TyconRef * isExtrinsic:bool * - attrs:TypedTree.Attribs * optImplSlotTys:TypedTree.TType list * - memberFlags:SyntaxTree.MemberFlags * valSynData:SyntaxTree.SynValInfo * - id:SyntaxTree.Ident * isCompGen:bool -> PreValMemberInfo - type OverridesOK = - | OverridesOK - | WarnOnOverrides - | ErrorOnOverrides - type ExplicitTyparInfo = - | ExplicitTyparInfo of - rigidCopyOfDeclaredTypars: TypedTree.Typars * - declaredTypars: TypedTree.Typars * infer: bool - val permitInferTypars : ExplicitTyparInfo - val dontInferTypars : ExplicitTyparInfo - type ArgAndRetAttribs = - | ArgAndRetAttribs of TypedTree.Attribs list list * TypedTree.Attribs - val noArgOrRetAttribs : ArgAndRetAttribs - type DeclKind = - | ModuleOrMemberBinding - | IntrinsicExtensionBinding - | ExtrinsicExtensionBinding - | ClassLetBinding of isStatic: bool - | ObjectExpressionOverrideBinding - | ExpressionBinding - with - static member - AllowedAttribTargets : SyntaxTree.MemberFlags option -> - DeclKind -> System.AttributeTargets - static member CanGeneralizeConstrainedTypars : DeclKind -> bool - static member CanOverrideOrImplement : DeclKind -> OverridesOK - static member ConvertToLinearBindings : DeclKind -> bool - static member ImplicitlyStatic : DeclKind -> bool - static member IsAccessModifierPermitted : DeclKind -> bool - static member IsModuleOrMemberOrExtensionBinding : DeclKind -> bool - static member MustHaveArity : DeclKind -> bool - member CanBeDllImport : bool - end - [] - type PrelimValScheme1 = - | PrelimValScheme1 of - id: SyntaxTree.Ident * explicitTyparInfo: ExplicitTyparInfo * - TypedTree.TType * PartialValReprInfo option * PreValMemberInfo option * - bool * TypedTree.ValInline * TypedTree.ValBaseOrThisInfo * - ArgAndRetAttribs * SyntaxTree.SynAccess option * bool - with - member Ident : SyntaxTree.Ident - member Type : TypedTree.TType - end - type PrelimValScheme2 = - | PrelimValScheme2 of - SyntaxTree.Ident * TypedTreeOps.TypeScheme * PartialValReprInfo option * - PreValMemberInfo option * bool * TypedTree.ValInline * - TypedTree.ValBaseOrThisInfo * ArgAndRetAttribs * - SyntaxTree.SynAccess option * bool * bool - type ValScheme = - | ValScheme of - id: SyntaxTree.Ident * typeScheme: TypedTreeOps.TypeScheme * - topValInfo: TypedTree.ValReprInfo option * - memberInfo: PreValMemberInfo option * isMutable: bool * - inlineInfo: TypedTree.ValInline * - baseOrThisInfo: TypedTree.ValBaseOrThisInfo * - visibility: SyntaxTree.SynAccess option * compgen: bool * - isIncrClass: bool * isTyFunc: bool * hasDeclaredTypars: bool - with - member GeneralizedTypars : TypedTree.Typars - member TypeScheme : TypedTreeOps.TypeScheme - member ValReprInfo : TypedTree.ValReprInfo option - end - type TcPatPhase2Input = - | TcPatPhase2Input of - AbstractIL.Internal.Library.NameMap * bool - with - member RightPath : TcPatPhase2Input - end - [] - type CheckedBindingInfo = - | CheckedBindingInfo of - inlineFlag: TypedTree.ValInline * valAttribs: TypedTree.Attribs * - xmlDoc: XmlDoc.XmlDoc * - tcPatPhase2: TcPatPhase2Input -> PatternMatchCompilation.Pattern * - exlicitTyparInfo: ExplicitTyparInfo * - nameToPrelimValSchemeMap: - AbstractIL.Internal.Library.NameMap * - rhsExprChecked: TypedTree.Expr * argAndRetAttribs: ArgAndRetAttribs * - overallPatTy: TypedTree.TType * mBinding: Range.range * - spBind: SyntaxTree.DebugPointForBinding * isCompilerGenerated: bool * - literalValue: TypedTree.Const option * isFixed: bool - with - member Expr : TypedTree.Expr - member SeqPoint : SyntaxTree.DebugPointForBinding - end - val GeneralizedTypeForTypeScheme : - typeScheme:TypedTreeOps.TypeScheme -> TypedTree.TType - val NonGenericTypeScheme : ty:TypedTree.TType -> TypedTreeOps.TypeScheme - val UpdateAccModuleOrNamespaceType : - cenv:TcFileState -> - env:TcEnv -> - f:(bool -> TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType) -> unit - val PublishModuleDefn : - cenv:TcFileState -> env:TcEnv -> mspec:TypedTree.Tycon -> unit - val PublishTypeDefn : - cenv:TcFileState -> env:TcEnv -> mspec:TypedTree.Tycon -> unit - val PublishValueDefnPrim : - cenv:TcFileState -> env:TcEnv -> vspec:TypedTree.Val -> unit - val PublishValueDefn : - cenv:TcFileState -> - env:TcEnv -> declKind:DeclKind -> vspec:TypedTree.Val -> unit - val CombineVisibilityAttribs : - vis1:'a option -> vis2:'a option -> m:Range.range -> 'a option - val ComputeAccessAndCompPath : - env:TcEnv -> - declKindOpt:DeclKind option -> - m:Range.range -> - vis:SyntaxTree.SynAccess option -> - overrideVis:TypedTree.Accessibility option -> - actualParent:TypedTree.ParentRef -> - TypedTree.Accessibility * TypedTree.CompilationPath option - val CheckForAbnormalOperatorNames : - cenv:TcFileState -> - idRange:Range.range -> - coreDisplayName:string -> - memberInfoOpt:TypedTree.ValMemberInfo option -> unit - val MakeAndPublishVal : - cenv:TcFileState -> - env:TcEnv -> - altActualParent:TypedTree.ParentRef * inSig:bool * declKind:DeclKind * - vrec:TypedTree.ValRecursiveScopeInfo * vscheme:ValScheme * - attrs:TypedTree.Attribs * doc:XmlDoc.XmlDoc * - konst:TypedTree.Const option * isGeneratedEventVal:bool -> - TypedTree.Val - val MakeAndPublishVals : - cenv:TcFileState -> - env:TcEnv -> - altActualParent:TypedTree.ParentRef * inSig:bool * declKind:DeclKind * - vrec:TypedTree.ValRecursiveScopeInfo * valSchemes:Map<'a,ValScheme> * - attrs:TypedTree.Attribs * doc:XmlDoc.XmlDoc * - literalValue:TypedTree.Const option -> - Map<'a,(TypedTree.Val * TypedTreeOps.TypeScheme)> - when 'a : comparison - val MakeAndPublishBaseVal : - cenv:TcFileState -> - env:TcEnv -> - SyntaxTree.Ident option -> TypedTree.TType -> TypedTree.Val option - val MakeAndPublishSafeThisVal : - cenv:TcFileState -> - env:TcEnv -> - thisIdOpt:SyntaxTree.Ident option -> - thisTy:TypedTree.TType -> TypedTree.Val option - val AdjustAndForgetUsesOfRecValue : - cenv:TcFileState -> - vrefTgt:TypedTree.ValRef -> valScheme:ValScheme -> unit - val AdjustRecType : vspec:TypedTree.Val -> vscheme:ValScheme -> unit - val RecordUseOfRecValue : - cenv:TcFileState -> - vrec:TypedTree.ValRecursiveScopeInfo -> - vrefTgt:TypedTree.ValRef -> - vexp:TypedTree.Expr -> m:Range.range -> TypedTree.Expr - [] - type RecursiveUseFixupPoints = - | RecursiveUseFixupPoints of (TypedTree.Expr ref * Range.range) list - val GetAllUsesOfRecValue : - cenv:TcFileState -> vrefTgt:TypedTree.Val -> RecursiveUseFixupPoints - val ChooseCanonicalDeclaredTyparsAfterInference : - g:TcGlobals.TcGlobals -> - denv:TypedTreeOps.DisplayEnv -> - declaredTypars:TypedTree.Typar list -> - m:Range.range -> TypedTree.Typars - val ChooseCanonicalValSchemeAfterInference : - g:TcGlobals.TcGlobals -> - denv:TypedTreeOps.DisplayEnv -> - vscheme:ValScheme -> m:Range.range -> ValScheme - val PlaceTyparsInDeclarationOrder : - declaredTypars:TypedTree.Typar list -> - generalizedTypars:TypedTree.Typar list -> TypedTree.Typar list - val SetTyparRigid : - TypedTreeOps.DisplayEnv -> Range.range -> TypedTree.Typar -> unit - val GeneralizeVal : - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - enclosingDeclaredTypars:TypedTree.Typar list -> - generalizedTyparsForThisBinding:TypedTree.Typar list -> - PrelimValScheme1 -> PrelimValScheme2 - val GeneralizeVals : - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - enclosingDeclaredTypars:TypedTree.Typar list -> - generalizedTypars:TypedTree.Typar list -> - types:AbstractIL.Internal.Library.NameMap -> - Map - val DontGeneralizeVals : - types:AbstractIL.Internal.Library.NameMap -> - Map - val InferGenericArityFromTyScheme : - TypedTreeOps.TypeScheme -> - partialValReprInfo:PartialValReprInfo -> TypedTree.ValReprInfo - val ComputeIsTyFunc : - id:SyntaxTree.Ident * hasDeclaredTypars:bool * - arityInfo:TypedTree.ValReprInfo option -> bool - val UseSyntacticArity : - declKind:DeclKind -> - typeScheme:TypedTreeOps.TypeScheme -> - partialValReprInfo:PartialValReprInfo -> TypedTree.ValReprInfo option - val CombineSyntacticAndInferredArities : - g:TcGlobals.TcGlobals -> - declKind:DeclKind -> - rhsExpr:TypedTree.Expr -> - prelimScheme:PrelimValScheme2 -> PartialValReprInfo option - val BuildValScheme : - declKind:DeclKind -> - partialArityInfoOpt:PartialValReprInfo option -> - prelimScheme:PrelimValScheme2 -> ValScheme - val UseCombinedArity : - g:TcGlobals.TcGlobals -> - declKind:DeclKind -> - rhsExpr:TypedTree.Expr -> prelimScheme:PrelimValScheme2 -> ValScheme - val UseNoArity : prelimScheme:PrelimValScheme2 -> ValScheme - val MakeAndPublishSimpleVals : - cenv:TcFileState -> - env:TcEnv -> - names:AbstractIL.Internal.Library.NameMap -> - Map * - Map - val MakeAndPublishSimpleValsForMergedScope : - cenv:TcFileState -> - env:TcEnv -> - m:Range.range -> - names:AbstractIL.Internal.Library.NameMap -> - TcEnv * Map * - Map - val FreshenTyconRef : - m:Range.range -> - rigid:TypedTree.TyparRigidity -> - tcref:TypedTree.TyconRef -> - declaredTyconTypars:TypedTree.Typar list -> - TypedTree.TType * TypedTree.Typar list * TypedTreeOps.TyparInst * - TypedTree.TType - val FreshenPossibleForallTy : - g:TcGlobals.TcGlobals -> - m:Range.range -> - rigid:TypedTree.TyparRigidity -> - ty:TypedTree.TType -> - TypedTree.Typar list * TypedTree.Typar list * TypedTree.TType list * - TypedTree.TType - val FreshenTyconRef2 : - m:Range.range -> - tcref:TypedTree.TyconRef -> - TypedTree.Typars * TypedTreeOps.TyparInst * TypedTree.TType list * - TypedTree.TType - val FreshenAbstractSlot : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - synTyparDecls:SyntaxTree.SynValTyparDecls -> - absMethInfo:Infos.MethInfo -> - bool * TypedTree.Typars * TypedTree.TType list list * - TypedTree.TType - val BuildFieldMap : - cenv:TcFileState -> - env:TcEnv -> - isPartial:bool -> - ty:TypedTree.TType -> - flds:((SyntaxTree.Ident list * SyntaxTree.Ident) * 'a) list -> - m:Range.range -> - TypedTree.TypeInst * TypedTree.TyconRef * Map * - (string * 'a) list - val ApplyUnionCaseOrExn : - makerForUnionCase:(TypedTree.UnionCaseRef * TypedTree.TypeInst -> 'a) * - makerForExnTag:(TypedTree.TyconRef -> 'a) -> - m:Range.range -> - cenv:TcFileState -> - env:TcEnv -> - overallTy:TypedTree.TType -> - item:NameResolution.Item -> - 'a * TypedTree.TType list * SyntaxTree.Ident list - val ApplyUnionCaseOrExnTypes : - m:Range.range -> - cenv:TcFileState -> - env:TcEnv -> - overallTy:TypedTree.TType -> - c:NameResolution.Item -> - (Range.range -> TypedTree.Exprs -> TypedTree.Expr) * - TypedTree.TType list * SyntaxTree.Ident list - val ApplyUnionCaseOrExnTypesForPat : - m:Range.range -> - cenv:TcFileState -> - env:TcEnv -> - overallTy:TypedTree.TType -> - c:NameResolution.Item -> - (Range.range -> PatternMatchCompilation.Pattern list -> - PatternMatchCompilation.Pattern) * TypedTree.TType list * - SyntaxTree.Ident list - val UnionCaseOrExnCheck : - env:TcEnv -> numArgTys:int -> numArgs:int -> m:Range.range -> unit - val TcUnionCaseOrExnField : - cenv:TcFileState -> - env:TcEnv -> - ty1:TypedTree.TType -> - m:Range.range -> - c:SyntaxTree.Ident list -> - n:int -> - (TypedTree.UnionCaseRef * TypedTree.TypeInst -> 'a) * - (TypedTree.TyconRef -> 'a) -> 'a * TypedTree.TType - type GeneralizeConstrainedTyparOptions = - | CanGeneralizeConstrainedTypars - | DoNotGeneralizeConstrainedTypars - module GeneralizationHelpers = begin - val ComputeUngeneralizableTypars : - env:TcEnv -> - Internal.Utilities.Collections.Tagged.Set> - val ComputeUnabstractableTycons : env:TcEnv -> TypedTree.FreeTycons - val ComputeUnabstractableTraitSolutions : - env:TcEnv -> TypedTree.FreeLocals - val IsGeneralizableValue : - g:TcGlobals.TcGlobals -> t:TypedTree.Expr -> bool - val CanGeneralizeConstrainedTyparsForDecl : - declKind:DeclKind -> GeneralizeConstrainedTyparOptions - val TrimUngeneralizableTypars : - genConstrainedTyparFlag:GeneralizeConstrainedTyparOptions -> - inlineFlag:TypedTree.ValInline -> - generalizedTypars:TypedTree.Typar list -> - freeInEnv:AbstractIL.Internal.Zset -> - TypedTree.Typar list * AbstractIL.Internal.Zset - val CondenseTypars : - cenv:TcFileState * denv:TypedTreeOps.DisplayEnv * - generalizedTypars:TypedTree.Typars * tauTy:TypedTree.TType * - m:Range.range -> TypedTree.Typar list - val ComputeAndGeneralizeGenericTypars : - cenv:TcFileState * denv:TypedTreeOps.DisplayEnv * m:Range.range * - freeInEnv:TypedTree.FreeTypars * canInferTypars:bool * - genConstrainedTyparFlag:GeneralizeConstrainedTyparOptions * - inlineFlag:TypedTree.ValInline * exprOpt:TypedTree.Expr option * - allDeclaredTypars:TypedTree.Typars * maxInferredTypars:TypedTree.Typars * - tauTy:TypedTree.TType * resultFirst:bool -> TypedTree.Typars - val CheckDeclaredTyparsPermitted : - memFlagsOpt:SyntaxTree.MemberFlags option * declaredTypars:'a list * - m:Range.range -> unit - val ComputeCanInferExtraGeneralizableTypars : - parentRef:TypedTree.ParentRef * canInferTypars:bool * - memFlagsOpt:SyntaxTree.MemberFlags option -> bool - end - val ComputeInlineFlag : - memFlagsOption:SyntaxTree.MemberFlags option -> - isInline:bool -> isMutable:bool -> m:Range.range -> TypedTree.ValInline - type NormalizedBindingRhs = - | NormalizedBindingRhs of - simplePats: SyntaxTree.SynSimplePats list * - returnTyOpt: SyntaxTree.SynBindingReturnInfo option * - rhsExpr: SyntaxTree.SynExpr - val PushOnePatternToRhs : - cenv:cenv -> - isMember:bool -> - p:SyntaxTree.SynPat -> NormalizedBindingRhs -> NormalizedBindingRhs - type NormalizedBindingPatternInfo = - | NormalizedBindingPat of - SyntaxTree.SynPat * NormalizedBindingRhs * SyntaxTree.SynValData * - SyntaxTree.SynValTyparDecls - type NormalizedBinding = - | NormalizedBinding of - visibility: SyntaxTree.SynAccess option * - kind: SyntaxTree.SynBindingKind * mustInline: bool * isMutable: bool * - attribs: SyntaxTree.SynAttribute list * xmlDoc: XmlDoc.XmlDoc * - typars: SyntaxTree.SynValTyparDecls * valSynData: SyntaxTree.SynValData * - pat: SyntaxTree.SynPat * rhsExpr: NormalizedBindingRhs * - mBinding: Range.range * spBinding: SyntaxTree.DebugPointForBinding - type IsObjExprBinding = - | ObjExprBinding - | ValOrMemberBinding - module BindingNormalization = begin - val private PushMultiplePatternsToRhs : - cenv:cenv -> - isMember:bool -> - ps:SyntaxTree.SynPat list -> - NormalizedBindingRhs -> NormalizedBindingRhs - val private MakeNormalizedStaticOrValBinding : - cenv:cenv -> - isObjExprBinding:IsObjExprBinding -> - id:SyntaxTree.Ident -> - vis:SyntaxTree.SynAccess option -> - typars:SyntaxTree.SynValTyparDecls -> - args:SyntaxTree.SynPat list -> - rhsExpr:NormalizedBindingRhs -> - valSynData:SyntaxTree.SynValData -> - NormalizedBindingPatternInfo - val private MakeNormalizedInstanceMemberBinding : - cenv:cenv -> - thisId:SyntaxTree.Ident -> - memberId:SyntaxTree.Ident -> - toolId:SyntaxTree.Ident option -> - vis:SyntaxTree.SynAccess option -> - m:Range.range -> - typars:SyntaxTree.SynValTyparDecls -> - args:SyntaxTree.SynPat list -> - rhsExpr:NormalizedBindingRhs -> - valSynData:SyntaxTree.SynValData -> - NormalizedBindingPatternInfo - val private NormalizeStaticMemberBinding : - cenv:cenv -> - memberFlags:SyntaxTree.MemberFlags -> - valSynData:SyntaxTree.SynValData -> - id:SyntaxTree.Ident -> - vis:SyntaxTree.SynAccess option -> - typars:SyntaxTree.SynValTyparDecls -> - args:SyntaxTree.SynPat list -> - m:Range.range -> - rhsExpr:NormalizedBindingRhs -> - NormalizedBindingPatternInfo - val private NormalizeInstanceMemberBinding : - cenv:cenv -> - memberFlags:SyntaxTree.MemberFlags -> - valSynData:SyntaxTree.SynValData -> - thisId:SyntaxTree.Ident -> - memberId:SyntaxTree.Ident -> - toolId:SyntaxTree.Ident option -> - vis:SyntaxTree.SynAccess option -> - typars:SyntaxTree.SynValTyparDecls -> - args:SyntaxTree.SynPat list -> - m:Range.range -> - rhsExpr:NormalizedBindingRhs -> - NormalizedBindingPatternInfo - val private NormalizeBindingPattern : - cenv:TcFileState -> - nameResolver:NameResolution.NameResolver -> - isObjExprBinding:IsObjExprBinding -> - env:TcEnv -> - valSynData:SyntaxTree.SynValData -> - pat:SyntaxTree.SynPat -> - rhsExpr:NormalizedBindingRhs -> NormalizedBindingPatternInfo - val NormalizeBinding : - isObjExprBinding:IsObjExprBinding -> - cenv:TcFileState -> - env:TcEnv -> binding:SyntaxTree.SynBinding -> NormalizedBinding - end - module EventDeclarationNormalization = begin - val ConvertSynInfo : - m:Range.range -> SyntaxTree.SynValInfo -> SyntaxTree.SynValInfo - val ConvertMemberFlags : - memberFlags:SyntaxTree.MemberFlags -> SyntaxTree.MemberFlags - val private ConvertMemberFlagsOpt : - m:Range.range -> - memberFlagsOpt:SyntaxTree.MemberFlags option -> - SyntaxTree.MemberFlags option - val private ConvertSynData : - m:Range.range -> - valSynData:SyntaxTree.SynValData -> SyntaxTree.SynValData - val private RenameBindingPattern : - f:(string -> string) -> - declPattern:SyntaxTree.SynPat -> SyntaxTree.SynPat - val GenerateExtraBindings : - cenv:TcFileState -> - bindingAttribs:TypedTree.Attribs * binding:NormalizedBinding -> - NormalizedBinding list - end - val FreshenObjectArgType : - cenv:TcFileState -> - m:Range.range -> - rigid:TypedTree.TyparRigidity -> - tcref:TypedTree.TyconRef -> - isExtrinsic:bool -> - declaredTyconTypars:TypedTree.Typar list -> - TypedTree.TType * TypedTree.Typar list * - TypedTreeOps.TyparInst * TypedTree.TType * TypedTree.TType - val TcValEarlyGeneralizationConsistencyCheck : - cenv:TcFileState -> - env:TcEnv -> - v:TypedTree.Val * vrec:TypedTree.ValRecursiveScopeInfo * - tinst:TypedTree.TType list * vty:TypedTree.TType * tau:TypedTree.TType * - m:Range.range -> unit - val TcVal : - checkAttributes:bool -> - cenv:TcFileState -> - env:TcEnv -> - tpenv:'a -> - vref:TypedTree.ValRef -> - optInst:(TypedTree.ValUseFlag * - ('a -> TypedTree.TyparKind list -> - TypedTree.TypeInst * 'a)) option -> - optAfterResolution:NameResolution.AfterResolution option -> - m:Range.range -> - TypedTree.Typar list * TypedTree.Expr * bool * - TypedTree.TType * TypedTree.TType list * 'a - val LightweightTcValForUsingInBuildMethodCall : - g:TcGlobals.TcGlobals -> - vref:TypedTree.ValRef -> - vrefFlags:TypedTree.ValUseFlag -> - vrefTypeInst:TypedTree.TTypes -> - m:Range.range -> TypedTree.Expr * TypedTree.TType - type ApplicableExpr = - | ApplicableExpr of cenv * TypedTree.Expr * bool - with - member - SupplyArgument : e2:TypedTree.Expr * m:Range.range -> ApplicableExpr - member Expr : TypedTree.Expr - member Range : Range.range - member Type : TypedTree.TType - end - val MakeApplicableExprNoFlex : - cenv:cenv -> expr:TypedTree.Expr -> ApplicableExpr - val MakeApplicableExprWithFlex : - cenv:TcFileState -> env:TcEnv -> expr:TypedTree.Expr -> ApplicableExpr - val TcRuntimeTypeTest : - isCast:bool -> - isOperator:bool -> - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - m:Range.range -> - tgtTy:TypedTree.TType -> srcTy:TypedTree.TType -> unit - val TcStaticUpcast : - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - m:Range.range -> - tgtTy:TypedTree.TType -> srcTy:TypedTree.TType -> unit - val BuildPossiblyConditionalMethodCall : - cenv:TcFileState -> - env:TcEnv -> - isMutable:TypedTreeOps.Mutates -> - m:Range.range -> - isProp:bool -> - minfo:Infos.MethInfo -> - valUseFlags:TypedTree.ValUseFlag -> - minst:TypedTree.TType list -> - objArgs:TypedTree.Expr list -> - args:TypedTree.Exprs -> TypedTree.Expr * TypedTree.TType - val TryFindIntrinsicOrExtensionMethInfo : - collectionSettings:NameResolution.ResultCollectionSettings -> - cenv:cenv -> - env:TcEnv -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - nm:string -> ty:TypedTree.TType -> Infos.MethInfo list - val TryFindFSharpSignatureInstanceGetterProperty : - cenv:cenv -> - env:TcEnv -> - m:Range.range -> - nm:string -> - ty:TypedTree.TType -> - sigTys:TypedTree.TType list -> Infos.PropInfo option - val BuildDisposableCleanup : - cenv:cenv -> - env:TcEnv -> m:Range.range -> v:TypedTree.Val -> TypedTree.Expr - val BuildOffsetToStringData : - cenv:cenv -> env:TcEnv -> m:Range.range -> TypedTree.Expr - val BuildILFieldGet : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - objExpr:TypedTree.Expr -> finfo:Infos.ILFieldInfo -> TypedTree.Expr - val private CheckFieldLiteralArg : - finfo:Infos.ILFieldInfo -> argExpr:TypedTree.Expr -> m:Range.range -> unit - val BuildILFieldSet : - g:TcGlobals.TcGlobals -> - m:Range.range -> - objExpr:TypedTree.Expr -> - finfo:Infos.ILFieldInfo -> argExpr:TypedTree.Expr -> TypedTree.Expr - val BuildILStaticFieldSet : - m:Range.range -> - finfo:Infos.ILFieldInfo -> argExpr:TypedTree.Expr -> TypedTree.Expr - val BuildRecdFieldSet : - g:TcGlobals.TcGlobals -> - m:Range.range -> - objExpr:TypedTree.Expr -> - rfinfo:Infos.RecdFieldInfo -> - argExpr:TypedTree.Expr -> TypedTree.Expr - val ( |BinOpExpr|_| ) : - SyntaxTree.SynExpr -> - (SyntaxTree.Ident * SyntaxTree.SynExpr * SyntaxTree.SynExpr) option - val ( |SimpleEqualsExpr|_| ) : - e:SyntaxTree.SynExpr -> (SyntaxTree.SynExpr * SyntaxTree.SynExpr) option - val TryGetNamedArg : - e:SyntaxTree.SynExpr -> - (bool * SyntaxTree.Ident * SyntaxTree.SynExpr) option - val inline IsNamedArg : e:SyntaxTree.SynExpr -> bool - val GetMethodArgs : - arg:SyntaxTree.SynExpr -> - SyntaxTree.SynExpr list * - (bool * SyntaxTree.Ident * SyntaxTree.SynExpr) list - val CompilePatternForMatch : - cenv:TcFileState -> - env:TcEnv -> - mExpr:Range.range -> - matchm:Range.range -> - warnOnUnused:bool -> - actionOnFailure:PatternMatchCompilation.ActionOnFailure -> - inputVal:TypedTree.Val * generalizedTypars:TypedTree.Typars * - inputExprOpt:TypedTree.Expr option -> - clauses:PatternMatchCompilation.TypedMatchClause list -> - inputTy:TypedTree.TType -> - resultTy:TypedTree.TType -> TypedTree.Expr - val CompilePatternForMatchClauses : - cenv:TcFileState -> - env:TcEnv -> - mExpr:Range.range -> - matchm:Range.range -> - warnOnUnused:bool -> - actionOnFailure:PatternMatchCompilation.ActionOnFailure -> - inputExprOpt:TypedTree.Expr option -> - inputTy:TypedTree.TType -> - resultTy:TypedTree.TType -> - tclauses:PatternMatchCompilation.TypedMatchClause list -> - TypedTree.Val * TypedTree.Expr - val AnalyzeArbitraryExprAsEnumerable : - cenv:cenv -> - env:TcEnv -> - localAlloc:bool -> - m:Range.range -> - exprty:TypedTree.TType -> - expr:TypedTree.Expr -> - TypedTree.Val * TypedTree.Expr * TypedTree.TType * - TypedTree.TType * TypedTree.Expr * TypedTree.TType * - TypedTree.Expr * TypedTree.TType * TypedTree.Expr - val ConvertArbitraryExprToEnumerable : - cenv:cenv -> - ty:TypedTree.TType -> - env:TcEnv -> expr:TypedTree.Expr -> TypedTree.Expr * TypedTree.TType - type InitializationGraphAnalysisState = - | Top - | InnerTop - | DefinitelyStrict - | MaybeLazy - | DefinitelyLazy - type PreInitializationGraphEliminationBinding = - { FixupPoints: RecursiveUseFixupPoints - Binding: TypedTree.Binding } - val EliminateInitializationGraphs : - g:TcGlobals.TcGlobals -> - mustHaveArity:bool -> - denv:TypedTreeOps.DisplayEnv -> - bindings:'Binding list -> - iterBindings:((PreInitializationGraphEliminationBinding list -> - unit) -> 'Binding list -> unit) -> - buildLets:(TypedTree.Binding list -> 'Result) -> - mapBindings:((PreInitializationGraphEliminationBinding list -> - TypedTree.Binding list) -> 'Binding list -> - 'Result list) -> - bindsm:Range.range -> 'Result list - val CheckAndRewriteObjectCtor : - g:TcGlobals.TcGlobals -> - env:TcEnv -> ctorLambdaExpr:TypedTree.Expr -> TypedTree.Expr - val buildApp : - cenv:TcFileState -> - expr:ApplicableExpr -> - resultTy:TypedTree.TType -> - arg:TypedTree.Expr -> - m:Range.range -> ApplicableExpr * TypedTree.TType - type DelayedItem = - | DelayedTypeApp of SyntaxTree.SynType list * Range.range * Range.range - | DelayedApp of - SyntaxTree.ExprAtomicFlag * SyntaxTree.SynExpr * Range.range - | DelayedDotLookup of SyntaxTree.Ident list * Range.range - | DelayedDot - | DelayedSet of SyntaxTree.SynExpr * Range.range - val MakeDelayedSet : e:SyntaxTree.SynExpr * m:Range.range -> DelayedItem - type NewSlotsOK = - | NewSlotsOK - | NoNewSlots - type ImplicitlyBoundTyparsAllowed = - | NewTyparsOKButWarnIfNotRigid - | NewTyparsOK - | NoNewTypars - type CheckConstraints = - | CheckCxs - | NoCheckCxs - type MemberOrValContainerInfo = - | MemberOrValContainerInfo of - tcref: TypedTree.TyconRef * - optIntfSlotTy: (TypedTree.TType * MethodOverrides.SlotImplSet) option * - baseValOpt: TypedTree.Val option * safeInitInfo: SafeInitData * - declaredTyconTypars: TypedTree.Typars - type ContainerInfo = - | ContainerInfo of TypedTree.ParentRef * MemberOrValContainerInfo option - with - member ParentRef : TypedTree.ParentRef - end - val ExprContainerInfo : ContainerInfo - type NormalizedRecBindingDefn = - | NormalizedRecBindingDefn of - containerInfo: ContainerInfo * newslotsOk: NewSlotsOK * - declKind: DeclKind * binding: NormalizedBinding - type ValSpecResult = - | ValSpecResult of - altActualParent: TypedTree.ParentRef * - memberInfoOpt: PreValMemberInfo option * id: SyntaxTree.Ident * - enclosingDeclaredTypars: TypedTree.Typars * - declaredTypars: TypedTree.Typars * ty: TypedTree.TType * - partialValReprInfo: PartialValReprInfo * declKind: DeclKind - type RecDefnBindingInfo = - | RecDefnBindingInfo of - containerInfo: ContainerInfo * newslotsOk: NewSlotsOK * - declKind: DeclKind * synBinding: SyntaxTree.SynBinding - type RecursiveBindingInfo = - | RecursiveBindingInfo of - recBindIndex: int * containerInfo: ContainerInfo * - enclosingDeclaredTypars: TypedTree.Typars * - inlineFlag: TypedTree.ValInline * vspec: TypedTree.Val * - explicitTyparInfo: ExplicitTyparInfo * - partialValReprInfo: PartialValReprInfo * - memberInfoOpt: PreValMemberInfo option * - baseValOpt: TypedTree.Val option * safeThisValOpt: TypedTree.Val option * - safeInitInfo: SafeInitData * visibility: SyntaxTree.SynAccess option * - ty: TypedTree.TType * declKind: DeclKind - with - member ContainerInfo : ContainerInfo - member DeclKind : DeclKind - member DeclaredTypars : TypedTree.Typars - member EnclosingDeclaredTypars : TypedTree.Typars - member ExplicitTyparInfo : ExplicitTyparInfo - member Index : int - member Val : TypedTree.Val - end - type PreCheckingRecursiveBinding = - { SyntacticBinding: NormalizedBinding - RecBindingInfo: RecursiveBindingInfo } - type PreGeneralizationRecursiveBinding = - { ExtraGeneralizableTypars: TypedTree.Typars - CheckedBinding: CheckedBindingInfo - RecBindingInfo: RecursiveBindingInfo } - type PostGeneralizationRecursiveBinding = - { ValScheme: ValScheme - CheckedBinding: CheckedBindingInfo - RecBindingInfo: RecursiveBindingInfo } - with - member GeneralizedTypars : TypedTree.Typars - end - type PostSpecialValsRecursiveBinding = - { ValScheme: ValScheme - Binding: TypedTree.Binding } - val CanInferExtraGeneralizedTyparsForRecBinding : - pgrbind:PreGeneralizationRecursiveBinding -> bool - val GetInstanceMemberThisVariable : - vspec:TypedTree.Val * expr:TypedTree.Expr -> TypedTree.Val option - val TcTyparConstraint : - ridx:int -> - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - c:SyntaxTree.SynTypeConstraint -> UnscopedTyparEnv - val TcPseudoMemberSpec : - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - env:TcEnv -> - synTypes:SyntaxTree.SynType list -> - tpenv:UnscopedTyparEnv -> - memSpfn:SyntaxTree.SynMemberSig -> - m:Range.range -> - TypedTree.TraitConstraintInfo * UnscopedTyparEnv - val TcValSpec : - cenv:TcFileState -> - TcEnv -> - DeclKind -> - ImplicitlyBoundTyparsAllowed -> - ContainerInfo -> - SyntaxTree.MemberFlags option -> - thisTyOpt:TypedTree.TType option -> - UnscopedTyparEnv -> - SyntaxTree.SynValSig -> - TypedTree.Attrib list -> - ValSpecResult list * UnscopedTyparEnv - val TcTyparOrMeasurePar : - optKind:TypedTree.TyparKind option -> - cenv:TcFileState -> - env:TcEnv -> - newOk:ImplicitlyBoundTyparsAllowed -> - tpenv:UnscopedTyparEnv -> - SyntaxTree.SynTypar -> TypedTree.Typar * UnscopedTyparEnv - val TcTypar : - cenv:TcFileState -> - env:TcEnv -> - newOk:ImplicitlyBoundTyparsAllowed -> - tpenv:UnscopedTyparEnv -> - tp:SyntaxTree.SynTypar -> TypedTree.Typar * UnscopedTyparEnv - val TcTyparDecl : - cenv:TcFileState -> - env:TcEnv -> SyntaxTree.SynTyparDecl -> TypedTree.Typar - val TcTyparDecls : - cenv:TcFileState -> - env:TcEnv -> - synTypars:SyntaxTree.SynTyparDecl list -> TypedTree.Typar list - val TcTypeOrMeasure : - optKind:TypedTree.TyparKind option -> - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv - val TcType : - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv - val TcMeasure : - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - SyntaxTree.SynType -> - m:Range.range -> TypedTree.Measure * UnscopedTyparEnv - val TcAnonTypeOrMeasure : - optKind:TypedTree.TyparKind option -> - _cenv:TcFileState -> - rigid:TypedTree.TyparRigidity -> - dyn:TypedTree.TyparDynamicReq -> - newOk:ImplicitlyBoundTyparsAllowed -> - m:Range.range -> TypedTree.Typar - val TcTypes : - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - args:SyntaxTree.SynType list -> - TypedTree.TType list * UnscopedTyparEnv - val TcTypesAsTuple : - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - args:(bool * SyntaxTree.SynType) list -> - m:Range.range -> TypedTree.TTypes * UnscopedTyparEnv - val TcMeasuresAsTuple : - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - args:(bool * SyntaxTree.SynType) list -> - m:Range.range -> TypedTree.Measure * UnscopedTyparEnv - val TcTypesOrMeasures : - optKinds:TypedTree.TyparKind list option -> - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - args:SyntaxTree.SynType list -> - m:Range.range -> TypedTree.TType list * UnscopedTyparEnv - val TcTyparConstraints : - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - synConstraints:SyntaxTree.SynTypeConstraint list -> - UnscopedTyparEnv - val TcStaticConstantParameter : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - kind:TypedTree.TType -> - SyntaxTree.SynType -> - idOpt:SyntaxTree.Ident option -> - container:NameResolution.ArgumentContainer -> - obj * UnscopedTyparEnv - val CrackStaticConstantArgs : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - staticParameters:Tainted [] * - args:SyntaxTree.SynType list * - container:NameResolution.ArgumentContainer * - containerName:System.String * m:Range.range -> obj [] - val TcProvidedTypeAppToStaticConstantArgs : - cenv:TcFileState -> - env:TcEnv -> - optGeneratedTypePath:string list option -> - tpenv:UnscopedTyparEnv -> - tcref:TypedTree.TyconRef -> - args:SyntaxTree.SynType list -> - m:Range.range -> - bool * Tainted * - (unit -> unit) - val TryTcMethodAppToStaticConstantArgs : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - minfos:Infos.MethInfo list * - argsOpt:(SyntaxTree.SynType list * 'a) option * - mExprAndArg:Range.range * mItem:Range.range -> Infos.MethInfo option - val TcProvidedMethodAppToStaticConstantArgs : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - minfo:Infos.MethInfo * - methBeforeArguments:Tainted * - staticParams:Tainted [] * - args:SyntaxTree.SynType list * m:Range.range -> - Tainted - val TcProvidedTypeApp : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - tcref:TypedTree.TyconRef -> - args:SyntaxTree.SynType list -> - m:Range.range -> TypedTree.TType * UnscopedTyparEnv - val TcTypeApp : - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - m:Range.range -> - tcref:TypedTree.TyconRef -> - pathTypeArgs:NameResolution.EnclosingTypeInst -> - synArgTys:SyntaxTree.SynType list -> - TypedTree.TType * UnscopedTyparEnv - val TcTypeOrMeasureAndRecover : - optKind:TypedTree.TyparKind option -> - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv - val TcTypeAndRecover : - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - ty:SyntaxTree.SynType -> TypedTree.TType * UnscopedTyparEnv - val TcNestedTypeApplication : - cenv:TcFileState -> - newOk:ImplicitlyBoundTyparsAllowed -> - checkCxs:CheckConstraints -> - occ:NameResolution.ItemOccurence -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - mWholeTypeApp:Range.range -> - ty:TypedTree.TType -> - pathTypeArgs:NameResolution.EnclosingTypeInst -> - tyargs:SyntaxTree.SynType list -> - TypedTree.TType * UnscopedTyparEnv - val TryAdjustHiddenVarNameToCompGenName : - cenv:TcFileState -> - env:TcEnv -> - id:SyntaxTree.Ident -> - altNameRefCellOpt:Ref option -> - SyntaxTree.Ident option - val TcSimplePat : - optArgsOK:bool -> - checkCxs:CheckConstraints -> - cenv:TcFileState -> - ty:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv * names:Map * - takenNames:Set -> - p:SyntaxTree.SynSimplePat -> - string * - (UnscopedTyparEnv * Map * - Set) - val ValidateOptArgOrder : spats:SyntaxTree.SynSimplePats -> unit - val TcSimplePats : - cenv:TcFileState -> - optArgsOK:bool -> - checkCxs:CheckConstraints -> - ty:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv * names:Map * - takenNames:Set -> - p:SyntaxTree.SynSimplePats -> - string list * - (UnscopedTyparEnv * Map * - Set) - val TcSimplePatsOfUnknownType : - cenv:TcFileState -> - optArgsOK:bool -> - checkCxs:CheckConstraints -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - spats:SyntaxTree.SynSimplePats -> - string list * - (UnscopedTyparEnv * Map * Set) - val TcPatBindingName : - cenv:TcFileState -> - env:TcEnv -> - id:SyntaxTree.Ident -> - ty:TypedTree.TType -> - isMemberThis:bool -> - vis1:SyntaxTree.SynAccess option -> - topValData:PartialValReprInfo option -> - inlineFlag:TypedTree.ValInline * - declaredTypars:ExplicitTyparInfo * - argAttribs:ArgAndRetAttribs * isMutable:bool * - vis2:SyntaxTree.SynAccess option * compgen:bool -> - names:Map * - takenNames:Set -> - (TcPatPhase2Input -> - PatternMatchCompilation.PatternValBinding) * - Map * Set - val TcPatAndRecover : - warnOnUpper:NameResolution.WarnOnUpperFlag -> - cenv:TcFileState -> - env:TcEnv -> - topValInfo:PartialValReprInfo option -> - TypedTree.ValInline * ExplicitTyparInfo * ArgAndRetAttribs * bool * - SyntaxTree.SynAccess option * bool -> - tpenv:UnscopedTyparEnv * names:Map * - takenNames:Set -> - ty:TypedTree.TType -> - pat:SyntaxTree.SynPat -> - (TcPatPhase2Input -> PatternMatchCompilation.Pattern) * - (UnscopedTyparEnv * Map * - Set) - val TcPat : - warnOnUpper:NameResolution.WarnOnUpperFlag -> - cenv:TcFileState -> - env:TcEnv -> - topValInfo:PartialValReprInfo option -> - TypedTree.ValInline * ExplicitTyparInfo * ArgAndRetAttribs * bool * - SyntaxTree.SynAccess option * bool -> - tpenv:UnscopedTyparEnv * names:Map * - takenNames:Set -> - ty:TypedTree.TType -> - pat:SyntaxTree.SynPat -> - (TcPatPhase2Input -> PatternMatchCompilation.Pattern) * - (UnscopedTyparEnv * Map * - Set) - val TcPatterns : - warnOnUpper:NameResolution.WarnOnUpperFlag -> - cenv:TcFileState -> - env:TcEnv -> - TypedTree.ValInline * ExplicitTyparInfo * ArgAndRetAttribs * bool * - SyntaxTree.SynAccess option * bool -> - UnscopedTyparEnv * Map * Set -> - argTys:TypedTree.TType list -> - args:SyntaxTree.SynPat list -> - (TcPatPhase2Input -> PatternMatchCompilation.Pattern) list * - (UnscopedTyparEnv * Map * - Set) - val solveTypAsError : - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - m:Range.range -> ty:TypedTree.TType -> unit - val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects : - cenv:TcFileState -> - env:TcEnv -> tpenv:UnscopedTyparEnv -> expr:SyntaxTree.SynExpr -> unit - val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects_Delayed : - cenv:TcFileState -> - env:TcEnv -> tpenv:UnscopedTyparEnv -> delayed:DelayedItem list -> unit - val UnifyTypesAndRecover : - cenv:TcFileState -> - env:TcEnv -> - m:Range.range -> - expectedTy:TypedTree.TType -> actualTy:TypedTree.TType -> unit - val TcExprOfUnknownType : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - expr:SyntaxTree.SynExpr -> - TypedTree.Expr * TypedTree.TType * UnscopedTyparEnv - val TcExprFlex : - cenv:TcFileState -> - flex:bool -> - compat:bool -> - ty:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - e:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcExpr : - cenv:TcFileState -> - ty:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcExprNoRecover : - cenv:TcFileState -> - ty:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcExprOfUnknownTypeThen : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - expr:SyntaxTree.SynExpr -> - delayed:DelayedItem list -> - TypedTree.Expr * TypedTree.TType * UnscopedTyparEnv - val TcExprThatIsCtorBody : - TypedTree.Val option * SafeInitData -> - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcExprThatCanBeCtorBody : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcExprThatCantBeCtorBody : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcStmtThatCantBeCtorBody : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - expr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcStmt : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - synExpr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TryTcStmt : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - synExpr:SyntaxTree.SynExpr -> - bool * TypedTree.Expr * UnscopedTyparEnv - val TcExprThen : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - synExpr:SyntaxTree.SynExpr -> - delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val TcExprs : - cenv:TcFileState -> - env:TcEnv -> - m:Range.range -> - tpenv:UnscopedTyparEnv -> - flexes:bool list -> - argTys:TypedTree.TType list -> - args:SyntaxTree.SynExpr list -> - TypedTree.Expr list * UnscopedTyparEnv - val CheckSuperInit : - cenv:TcFileState -> objTy:TypedTree.TType -> m:Range.range -> unit - val TcExprUndelayedNoType : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - synExpr:SyntaxTree.SynExpr -> - TypedTree.Expr * TypedTree.TType * UnscopedTyparEnv - val TcExprUndelayed : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - synExpr:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcIteratedLambdas : - cenv:TcFileState -> - isFirst:bool -> - env:TcEnv -> - overallTy:TypedTree.TType -> - takenNames:Set -> - tpenv:UnscopedTyparEnv -> - e:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcIndexerThen : - cenv:TcFileState -> - env:TcEnv -> - overallTy:TypedTree.TType -> - mWholeExpr:Range.range -> - mDot:Range.range -> - tpenv:UnscopedTyparEnv -> - wholeExpr:SyntaxTree.SynExpr -> - e1:SyntaxTree.SynExpr -> - indexArgs:SyntaxTree.SynIndexerArg list -> - delayed:DelayedItem list -> - TypedTree.Expr * UnscopedTyparEnv - val TcNewExpr : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - objTy:TypedTree.TType -> - mObjTyOpt:Range.range option -> - superInit:bool -> - arg:SyntaxTree.SynExpr -> - mWholeExprOrObjTy:Range.range -> - TypedTree.Expr * UnscopedTyparEnv - val TcCtorCall : - isNaked:bool -> - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - overallTy:TypedTree.TType -> - objTy:TypedTree.TType -> - mObjTyOpt:Range.range option -> - item:NameResolution.Item -> - superInit:bool -> - args:SyntaxTree.SynExpr list -> - mWholeCall:Range.range -> - delayed:DelayedItem list -> - afterTcOverloadResolutionOpt:NameResolution.AfterResolution option -> - TypedTree.Expr * UnscopedTyparEnv - val TcRecordConstruction : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - optOrigExprInfo:(TypedTree.Expr * TypedTree.Val * TypedTree.Expr) option -> - objTy:TypedTree.TType -> - fldsList:seq -> - m:Range.range -> TypedTree.Expr * UnscopedTyparEnv - val GetNameAndArityOfObjExprBinding : - _cenv:'b -> - _env:'c -> b:NormalizedBinding -> string * SyntaxTree.SynValInfo - val FreshenObjExprAbstractSlot : - cenv:TcFileState -> - env:TcEnv -> - implty:TypedTree.TType -> - virtNameAndArityPairs:((string * 'd) * Infos.MethInfo) list -> - bind:NormalizedBinding * bindAttribs:TypedTree.Attribs * - bindName:string * absSlots:('e * Infos.MethInfo) list -> - (bool * TypedTree.Typars * TypedTree.TType) option - val TcObjectExprBinding : - cenv:cenv -> - env:TcEnv -> - implty:TypedTree.TType -> - tpenv:UnscopedTyparEnv -> - absSlotInfo:(bool * TypedTree.Typars * TypedTree.TType) option * - bind:NormalizedBinding -> - (SyntaxTree.Ident * SyntaxTree.MemberFlags * TypedTree.TType * - TypedTree.Attribs * TypedTree.Expr) * UnscopedTyparEnv - val ComputeObjectExprOverrides : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - impls:(Range.range * TypedTree.TType * SyntaxTree.SynBinding list) list -> - (Range.range * TypedTree.TType * MethodOverrides.RequiredSlot list * - AbstractIL.Internal.Library.NameMultiMap * - MethodOverrides.OverrideInfo list * - (MethodOverrides.OverrideInfo * - (TypedTree.Val option * TypedTree.Val * TypedTree.Val list list * - TypedTree.Attribs * TypedTree.Expr)) list) list * - UnscopedTyparEnv - val CheckSuperType : - cenv:TcFileState -> ty:TypedTree.TType -> m:Range.range -> unit - val TcObjectExpr : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - synObjTy:SyntaxTree.SynType * - argopt:(SyntaxTree.SynExpr * SyntaxTree.Ident option) option * - binds:SyntaxTree.SynBinding list * - extraImpls:SyntaxTree.SynInterfaceImpl list * mNewExpr:Range.range * - mWholeExpr:Range.range -> TypedTree.Expr * UnscopedTyparEnv - val TcConstStringExpr : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - m:Range.range -> - tpenv:UnscopedTyparEnv -> - s:string -> TypedTree.Expr * UnscopedTyparEnv - val TcFormatStringExpr : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - m:Range.range -> - tpenv:UnscopedTyparEnv -> - fmtString:string -> TypedTree.Expr * UnscopedTyparEnv - val TcInterpolatedStringExpr : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - m:Range.range -> - tpenv:UnscopedTyparEnv -> - parts:SyntaxTree.SynInterpolatedStringPart list -> - TypedTree.Expr * UnscopedTyparEnv - val TcConstExpr : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - m:Range.range -> - tpenv:UnscopedTyparEnv -> - c:SyntaxTree.SynConst -> TypedTree.Expr * UnscopedTyparEnv - val TcAssertExpr : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - m:Range.range -> - tpenv:UnscopedTyparEnv -> - x:SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv - val TcRecdExpr : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - inherits:(SyntaxTree.SynType * SyntaxTree.SynExpr * Range.range * - SyntaxTree.BlockSeparator option * Range.range) option * - optOrigExpr:(SyntaxTree.SynExpr * SyntaxTree.BlockSeparator) option * - flds:(SyntaxTree.RecordFieldName * SyntaxTree.SynExpr option * - SyntaxTree.BlockSeparator option) list * - mWholeExpr:Range.range -> TypedTree.Expr * UnscopedTyparEnv - val TcAnonRecdExpr : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - isStruct:bool * - optOrigSynExpr:(SyntaxTree.SynExpr * SyntaxTree.BlockSeparator) option * - unsortedFieldIdsAndSynExprsGiven:(SyntaxTree.Ident * - SyntaxTree.SynExpr) list * - mWholeExpr:Range.range -> TypedTree.Expr * UnscopedTyparEnv - val TcForEachExpr : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - pat:SyntaxTree.SynPat * enumSynExpr:SyntaxTree.SynExpr * - bodySynExpr:SyntaxTree.SynExpr * mWholeExpr:Range.range * - spForLoop:SyntaxTree.DebugPointAtFor -> - TypedTree.Expr * UnscopedTyparEnv - val TcQuotationExpr : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - _oper:SyntaxTree.SynExpr * raw:bool * ast:SyntaxTree.SynExpr * - isFromQueryExpression:bool * m:Range.range -> - TypedTree.Expr * UnscopedTyparEnv - val Propagate : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - expr:ApplicableExpr -> - exprty:TypedTree.TType -> delayed:DelayedItem list -> unit - val PropagateThenTcDelayed : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - mExpr:Range.range -> - expr:ApplicableExpr -> - exprty:TypedTree.TType -> - atomicFlag:SyntaxTree.ExprAtomicFlag -> - delayed:DelayedItem list -> - TypedTree.Expr * UnscopedTyparEnv - val TcDelayed : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - mExpr:Range.range -> - expr:ApplicableExpr -> - exprty:TypedTree.TType -> - atomicFlag:SyntaxTree.ExprAtomicFlag -> - delayed:DelayedItem list -> - TypedTree.Expr * UnscopedTyparEnv - val delayRest : - rest:SyntaxTree.Ident list -> - mPrior:Range.range -> delayed:DelayedItem list -> DelayedItem list - val TcNameOfExpr : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> synArg:SyntaxTree.SynExpr -> TypedTree.Expr - val TcNameOfExprResult : - cenv:TcFileState -> - lastIdent:SyntaxTree.Ident -> m:Range.range -> TypedTree.Expr - val TcFunctionApplicationThen : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - mExprAndArg:Range.range -> - expr:ApplicableExpr -> - exprty:TypedTree.TType -> - synArg:SyntaxTree.SynExpr -> - atomicFlag:SyntaxTree.ExprAtomicFlag -> - delayed:DelayedItem list -> - TypedTree.Expr * UnscopedTyparEnv - val GetLongIdentTypeNameInfo : - delayed:DelayedItem list -> NameResolution.TypeNameResolutionInfo - val TcLongIdentThen : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - SyntaxTree.LongIdentWithDots -> - delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val TcItemThen : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - tinstEnclosing:NameResolution.EnclosingTypeInst * - item:NameResolution.Item * mItem:Range.range * - rest:SyntaxTree.Ident list * - afterResolution:NameResolution.AfterResolution -> - delayed:DelayedItem list -> TypedTree.Expr * UnscopedTyparEnv - val GetSynMemberApplicationArgs : - delayed:DelayedItem list -> - tpenv:'f -> - SyntaxTree.ExprAtomicFlag * - (SyntaxTree.SynType list * Range.range) option * - SyntaxTree.SynExpr list * DelayedItem list * 'f - val TcMemberTyArgsOpt : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - tyargsOpt:(SyntaxTree.SynType list * Range.range) option -> - TypedTree.TType list option * UnscopedTyparEnv - val GetMemberApplicationArgs : - delayed:DelayedItem list -> - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - SyntaxTree.ExprAtomicFlag * TypedTree.TType list option * - SyntaxTree.SynExpr list * DelayedItem list * UnscopedTyparEnv - val TcLookupThen : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - mObjExpr:Range.range -> - objExpr:TypedTree.Expr -> - objExprTy:TypedTree.TType -> - longId:SyntaxTree.Ident list -> - delayed:DelayedItem list -> - mExprAndLongId:Range.range -> - TypedTree.Expr * UnscopedTyparEnv - val TcEventValueThen : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - mItem:Range.range -> - mExprAndItem:Range.range -> - objDetails:(TypedTree.Expr * TypedTree.TType) option -> - einfo:Infos.EventInfo -> - delayed:DelayedItem list -> - TypedTree.Expr * UnscopedTyparEnv - val TcMethodApplicationThen : - cenv:TcFileState -> - env:TcEnv -> - overallTy:TypedTree.TType -> - objTyOpt:TypedTree.TType option -> - tpenv:UnscopedTyparEnv -> - callerTyArgs:TypedTree.TType list option -> - objArgs:TypedTree.Expr list -> - m:Range.range -> - mItem:Range.range -> - methodName:string -> - ad:AccessibilityLogic.AccessorDomain -> - mut:TypedTreeOps.Mutates -> - isProp:bool -> - meths:(Infos.MethInfo * Infos.PropInfo option) list -> - afterResolution:NameResolution.AfterResolution -> - isSuperInit:TypedTree.ValUseFlag -> - args:SyntaxTree.SynExpr list -> - atomicFlag:SyntaxTree.ExprAtomicFlag -> - delayed:DelayedItem list -> - TypedTree.Expr * UnscopedTyparEnv - val GetNewInferenceTypeForMethodArg : - cenv:TcFileState -> - env:'g -> tpenv:'h -> x:SyntaxTree.SynExpr -> TypedTree.TType - val TcMethodApplication : - isCheckingAttributeCall:bool -> - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - tyargsOpt:TypedTree.TType list option -> - objArgs:TypedTree.Expr list -> - mMethExpr:Range.range -> - mItem:Range.range -> - methodName:string -> - objTyOpt:TypedTree.TType option -> - ad:AccessibilityLogic.AccessorDomain -> - mut:TypedTreeOps.Mutates -> - isProp:bool -> - calledMethsAndProps:(Infos.MethInfo * - Infos.PropInfo option) list -> - afterResolution:NameResolution.AfterResolution -> - isSuperInit:TypedTree.ValUseFlag -> - curriedCallerArgs:SyntaxTree.SynExpr list -> - exprTy:TypedTree.TType -> - delayed:DelayedItem list -> - (TypedTree.Expr * - MethodCalls.CallerNamedArg list * - DelayedItem list) * - UnscopedTyparEnv - val TcSetterArgExpr : - cenv:TcFileState -> - env:TcEnv -> - denv:TypedTreeOps.DisplayEnv -> - objExpr:TypedTree.Expr -> - ad:AccessibilityLogic.AccessorDomain -> - MethodCalls.AssignedItemSetter -> - (TypedTree.Expr -> TypedTree.Expr) option * TypedTree.Expr * - Range.range - val TcUnnamedMethodArgs : - cenv:TcFileState -> - env:TcEnv -> - lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * - (SyntaxTree.Ident * - MethodCalls.ArgumentAnalysis) [] []) [] -> - tpenv:UnscopedTyparEnv -> - args:MethodCalls.CallerArg list list -> - MethodCalls.CallerArg list list * - ((MethodCalls.ArgumentAnalysis [] [] * - (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * - UnscopedTyparEnv) - val TcUnnamedMethodArg : - cenv:TcFileState -> - env:TcEnv -> - lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * - (SyntaxTree.Ident * - MethodCalls.ArgumentAnalysis) [] []) [] * - tpenv:UnscopedTyparEnv -> - i:int * j:int * MethodCalls.CallerArg -> - MethodCalls.CallerArg * - ((MethodCalls.ArgumentAnalysis [] [] * - (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * - UnscopedTyparEnv) - val TcMethodNamedArgs : - cenv:TcFileState -> - env:TcEnv -> - lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * - (SyntaxTree.Ident * - MethodCalls.ArgumentAnalysis) [] []) [] -> - tpenv:UnscopedTyparEnv -> - args:MethodCalls.CallerNamedArg list list -> - MethodCalls.CallerNamedArg list list * - ((MethodCalls.ArgumentAnalysis [] [] * - (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * - UnscopedTyparEnv) - val TcMethodNamedArg : - cenv:TcFileState -> - env:TcEnv -> - lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * - (SyntaxTree.Ident * - MethodCalls.ArgumentAnalysis) [] []) [] * - tpenv:UnscopedTyparEnv -> - MethodCalls.CallerNamedArg -> - MethodCalls.CallerNamedArg * - ((MethodCalls.ArgumentAnalysis [] [] * - (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * - UnscopedTyparEnv) - val TcMethodArg : - cenv:TcFileState -> - env:TcEnv -> - lambdaPropagationInfo:(MethodCalls.ArgumentAnalysis [] [] * - (SyntaxTree.Ident * - MethodCalls.ArgumentAnalysis) [] []) [] * - tpenv:UnscopedTyparEnv -> - lambdaPropagationInfoForArg:MethodCalls.ArgumentAnalysis [] * - MethodCalls.CallerArg -> - MethodCalls.CallerArg * - ((MethodCalls.ArgumentAnalysis [] [] * - (SyntaxTree.Ident * MethodCalls.ArgumentAnalysis) [] []) [] * - UnscopedTyparEnv) - val TcNewDelegateThen : - cenv:TcFileState -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - mDelTy:Range.range -> - mExprAndArg:Range.range -> - delegateTy:TypedTree.TType -> - arg:SyntaxTree.SynExpr -> - atomicFlag:SyntaxTree.ExprAtomicFlag -> - delayed:DelayedItem list -> - TypedTree.Expr * UnscopedTyparEnv - val bindLetRec : - binds:TypedTree.Bindings -> - m:Range.range -> e:TypedTree.Expr -> TypedTree.Expr - val CheckRecursiveBindingIds : binds:seq -> unit - val TcLinearExprs : - bodyChecker:(TypedTree.TType -> TcEnv -> UnscopedTyparEnv -> - SyntaxTree.SynExpr -> TypedTree.Expr * UnscopedTyparEnv) -> - cenv:TcFileState -> - env:TcEnv -> - overallTy:TypedTree.TType -> - tpenv:UnscopedTyparEnv -> - isCompExpr:bool -> - expr:SyntaxTree.SynExpr -> - cont:(TypedTree.Expr * UnscopedTyparEnv -> - TypedTree.Expr * UnscopedTyparEnv) -> - TypedTree.Expr * UnscopedTyparEnv - val TcAndPatternCompileMatchClauses : - mExpr:Range.range -> - matchm:Range.range -> - actionOnFailure:PatternMatchCompilation.ActionOnFailure -> - cenv:TcFileState -> - inputExprOpt:TypedTree.Expr option -> - inputTy:TypedTree.TType -> - resultTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - synClauses:SyntaxTree.SynMatchClause list -> - TypedTree.Val * TypedTree.Expr * UnscopedTyparEnv - val TcMatchPattern : - cenv:TcFileState -> - inputTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - pat:SyntaxTree.SynPat * optWhenExpr:SyntaxTree.SynExpr option -> - PatternMatchCompilation.Pattern * TypedTree.Expr option * - TypedTree.Val list * TcEnv * UnscopedTyparEnv - val TcMatchClauses : - cenv:TcFileState -> - inputTy:TypedTree.TType -> - resultTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - clauses:SyntaxTree.SynMatchClause list -> - PatternMatchCompilation.TypedMatchClause list * - UnscopedTyparEnv - val TcMatchClause : - cenv:TcFileState -> - inputTy:TypedTree.TType -> - resultTy:TypedTree.TType -> - env:TcEnv -> - isFirst:bool -> - tpenv:UnscopedTyparEnv -> - SyntaxTree.SynMatchClause -> - PatternMatchCompilation.TypedMatchClause * UnscopedTyparEnv - val TcStaticOptimizationConstraint : - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - c:SyntaxTree.SynStaticOptimizationConstraint -> - TypedTree.StaticOptimization * UnscopedTyparEnv - val mkConvToNativeInt : - g:TcGlobals.TcGlobals -> - e:TypedTree.Expr -> m:Range.range -> TypedTree.Expr - val TcAndBuildFixedExpr : - cenv:TcFileState -> - env:TcEnv -> - overallPatTy:TypedTree.TType * fixedExpr:TypedTree.Expr * - overallExprTy:TypedTree.TType * mBinding:Range.range -> TypedTree.Expr - val TcNormalizedBinding : - declKind:DeclKind -> - cenv:cenv -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - overallTy:TypedTree.TType -> - safeThisValOpt:TypedTree.Val option -> - safeInitInfo:SafeInitData -> - enclosingDeclaredTypars:TypedTree.Typar list * - ExplicitTyparInfo -> - bind:NormalizedBinding -> - CheckedBindingInfo * UnscopedTyparEnv - val TcLiteral : - cenv:cenv -> - overallTy:TypedTree.TType -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - attrs:TypedTree.Attribs * synLiteralValExpr:SyntaxTree.SynExpr -> - bool * TypedTree.Const option - val TcBindingTyparDecls : - alwaysRigid:bool -> - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - SyntaxTree.SynValTyparDecls -> - ExplicitTyparInfo * UnscopedTyparEnv - val TcNonrecBindingTyparDecls : - cenv:cenv -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - bind:NormalizedBinding -> ExplicitTyparInfo * UnscopedTyparEnv - val TcNonRecursiveBinding : - declKind:DeclKind -> - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - ty:TypedTree.TType -> - b:SyntaxTree.SynBinding -> CheckedBindingInfo * UnscopedTyparEnv - val TcAttribute : - canFail:bool -> - cenv:TcFileState -> - env:TcEnv -> - attrTgt:System.AttributeTargets -> - synAttr:SyntaxTree.SynAttribute -> - (System.AttributeTargets * TypedTree.Attrib) list * bool - val TcAttributesWithPossibleTargets : - canFail:bool -> - cenv:TcFileState -> - env:TcEnv -> - attrTgt:System.AttributeTargets -> - synAttribs:SyntaxTree.SynAttribute list -> - (System.AttributeTargets * TypedTree.Attrib) list * bool - val TcAttributesMaybeFail : - canFail:bool -> - cenv:TcFileState -> - env:TcEnv -> - attrTgt:System.AttributeTargets -> - synAttribs:SyntaxTree.SynAttribute list -> - TypedTree.Attrib list * bool - val TcAttributesCanFail : - cenv:TcFileState -> - env:TcEnv -> - attrTgt:System.AttributeTargets -> - synAttribs:SyntaxTree.SynAttribute list -> - TypedTree.Attrib list * (unit -> TypedTree.Attribs) - val TcAttributes : - cenv:TcFileState -> - env:TcEnv -> - attrTgt:System.AttributeTargets -> - synAttribs:SyntaxTree.SynAttribute list -> TypedTree.Attribs - val TcLetBinding : - cenv:TcFileState -> - isUse:bool -> - env:TcEnv -> - containerInfo:ContainerInfo -> - declKind:DeclKind -> - tpenv:UnscopedTyparEnv -> - synBinds:SyntaxTree.SynBinding list * - synBindsRange:Range.range * scopem:Range.range -> - (TypedTree.Expr * TypedTree.TType -> - TypedTree.Expr * TypedTree.TType) * TcEnv * - UnscopedTyparEnv - val TcLetBindings : - cenv:TcFileState -> - env:TcEnv -> - containerInfo:ContainerInfo -> - declKind:DeclKind -> - tpenv:UnscopedTyparEnv -> - binds:SyntaxTree.SynBinding list * bindsm:Range.range * - scopem:Range.range -> - TypedTree.ModuleOrNamespaceExpr list * TcEnv * - UnscopedTyparEnv - val CheckMemberFlags : - optIntfSlotTy:'a option -> - newslotsOK:NewSlotsOK -> - overridesOK:OverridesOK -> - memberFlags:SyntaxTree.MemberFlags -> m:Range.range -> unit - val ApplyTypesFromArgumentPatterns : - cenv:TcFileState * env:TcEnv * optArgsOK:bool * ty:TypedTree.TType * - m:Range.range * tpenv:UnscopedTyparEnv * NormalizedBindingRhs * - memberFlagsOpt:SyntaxTree.MemberFlags option -> unit - val ComputeIsComplete : - enclosingDeclaredTypars:TypedTree.Typar list -> - declaredTypars:TypedTree.Typar list -> ty:TypedTree.TType -> bool - val ApplyAbstractSlotInference : - cenv:cenv -> - envinner:TcEnv -> - bindingTy:TypedTree.TType * m:Range.range * - synTyparDecls:SyntaxTree.SynValTyparDecls * - declaredTypars:TypedTree.Typars * memberId:SyntaxTree.Ident * - tcrefObjTy:TypedTree.TType * renaming:TypedTreeOps.TyparInst * - _objTy:'i * - optIntfSlotTy:(TypedTree.TType * MethodOverrides.SlotImplSet) option * - valSynData:SyntaxTree.SynValInfo * memberFlags:SyntaxTree.MemberFlags * - attribs:TypedTree.Attribs -> TypedTree.TType list * TypedTree.Typars - val CheckForNonAbstractInterface : - declKind:DeclKind -> - tcref:TypedTree.TyconRef -> - memberFlags:SyntaxTree.MemberFlags -> m:Range.range -> unit - val AnalyzeRecursiveStaticMemberOrValDecl : - cenv:TcFileState * envinner:TcEnv * tpenv:'j * declKind:DeclKind * - newslotsOK:NewSlotsOK * overridesOK:OverridesOK * - tcrefContainerInfo:MemberOrValContainerInfo option * vis1:'k option * - id:SyntaxTree.Ident * vis2:'k option * declaredTypars:'l * - memberFlagsOpt:SyntaxTree.MemberFlags option * - thisIdOpt:SyntaxTree.Ident option * bindingAttribs:TypedTree.Attribs * - valSynInfo:SyntaxTree.SynValInfo * ty:TypedTree.TType * bindingRhs:'m * - mBinding:Range.range * explicitTyparInfo:'n -> - TcEnv * 'j * SyntaxTree.Ident * 'o option * PreValMemberInfo option * - 'k option * 'k option * TypedTree.Val option * TypedTree.Typar list * - TypedTree.Val option * 'n * 'm * 'l - val AnalyzeRecursiveInstanceMemberDecl : - cenv:cenv * envinner:TcEnv * tpenv:'p * declKind:DeclKind * - synTyparDecls:SyntaxTree.SynValTyparDecls * - valSynInfo:SyntaxTree.SynValInfo * explicitTyparInfo:ExplicitTyparInfo * - newslotsOK:NewSlotsOK * overridesOK:OverridesOK * vis1:'q option * - thisId:SyntaxTree.Ident * memberId:SyntaxTree.Ident * - toolId:SyntaxTree.Ident option * bindingAttribs:TypedTree.Attribs * - vis2:'q option * tcrefContainerInfo:MemberOrValContainerInfo option * - memberFlagsOpt:SyntaxTree.MemberFlags option * ty:TypedTree.TType * - bindingRhs:NormalizedBindingRhs * mBinding:Range.range -> - TcEnv * 'p * SyntaxTree.Ident * SyntaxTree.Ident option * - PreValMemberInfo option * 'q option * 'q option * 'r option * - TypedTree.Typar list * TypedTree.Val option * ExplicitTyparInfo * - NormalizedBindingRhs * TypedTree.Typars - val AnalyzeRecursiveDecl : - cenv:TcFileState * envinner:TcEnv * tpenv:UnscopedTyparEnv * - declKind:DeclKind * synTyparDecls:SyntaxTree.SynValTyparDecls * - declaredTypars:TypedTree.Typars * thisIdOpt:SyntaxTree.Ident option * - valSynInfo:SyntaxTree.SynValInfo * explicitTyparInfo:ExplicitTyparInfo * - newslotsOK:NewSlotsOK * overridesOK:OverridesOK * - vis1:SyntaxTree.SynAccess option * declPattern:SyntaxTree.SynPat * - bindingAttribs:TypedTree.Attribs * - tcrefContainerInfo:MemberOrValContainerInfo option * - memberFlagsOpt:SyntaxTree.MemberFlags option * ty:TypedTree.TType * - bindingRhs:NormalizedBindingRhs * mBinding:Range.range -> - TcEnv * UnscopedTyparEnv * SyntaxTree.Ident * SyntaxTree.Ident option * - PreValMemberInfo option * SyntaxTree.SynAccess option * - SyntaxTree.SynAccess option * TypedTree.Val option * - TypedTree.Typar list * TypedTree.Val option * ExplicitTyparInfo * - NormalizedBindingRhs * TypedTree.Typars - val AnalyzeAndMakeAndPublishRecursiveValue : - overridesOK:OverridesOK -> - isGeneratedEventVal:bool -> - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv * recBindIdx:int -> - NormalizedRecBindingDefn -> - (PreCheckingRecursiveBinding list * TypedTree.Val list) * - (UnscopedTyparEnv * int) - val AnalyzeAndMakeAndPublishRecursiveValues : - overridesOK:OverridesOK -> - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - binds:NormalizedRecBindingDefn list -> - PreCheckingRecursiveBinding list * TypedTree.Val list * - (UnscopedTyparEnv * int) - val TcLetrecBinding : - cenv:TcFileState * envRec:TcEnv * scopem:Range.range * - extraGeneralizableTypars:TypedTree.Typars * - reqdThisValTyOpt:TypedTree.TType option -> - envNonRec:TcEnv * - generalizedRecBinds:PostGeneralizationRecursiveBinding list * - preGeneralizationRecBinds:PreGeneralizationRecursiveBinding list * - tpenv:UnscopedTyparEnv * - uncheckedRecBindsTable:Map -> - rbind:PreCheckingRecursiveBinding -> - TcEnv * PostGeneralizationRecursiveBinding list * - PreGeneralizationRecursiveBinding list * UnscopedTyparEnv * - Map - val TcIncrementalLetRecGeneralization : - cenv:TcFileState -> - scopem:Range.range -> - envNonRec:TcEnv * - generalizedRecBinds:PostGeneralizationRecursiveBinding list * - preGeneralizationRecBinds:PreGeneralizationRecursiveBinding list * - tpenv:UnscopedTyparEnv * - uncheckedRecBindsTable:Map -> - TcEnv * PostGeneralizationRecursiveBinding list * - PreGeneralizationRecursiveBinding list * UnscopedTyparEnv * - Map - val TcLetrecComputeAndGeneralizeGenericTyparsForBinding : - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - freeInEnv:Internal.Utilities.Collections.Tagged.Set> -> - pgrbind:PreGeneralizationRecursiveBinding -> TypedTree.Typar list - val TcLetrecComputeSupportForBinding : - cenv:TcFileState -> - pgrbind:PreGeneralizationRecursiveBinding -> TypedTree.Typar list - val TcLetrecGeneralizeBinding : - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - generalizedTypars:TypedTree.Typar list -> - pgrbind:PreGeneralizationRecursiveBinding -> - PostGeneralizationRecursiveBinding - val TcLetrecComputeCtorSafeThisValBind : - cenv:TcFileState -> - safeThisValOpt:TypedTree.Val option -> TypedTree.Binding option - val MakeCheckSafeInitField : - g:TcGlobals.TcGlobals -> - tinst:TypedTree.TypeInst -> - thisValOpt:TypedTree.Val option -> - rfref:TypedTree.RecdFieldRef -> - reqExpr:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val MakeCheckSafeInit : - g:TcGlobals.TcGlobals -> - tinst:TypedTree.TypeInst -> - safeInitInfo:SafeInitData -> - reqExpr:TypedTree.Expr -> expr:TypedTree.Expr -> TypedTree.Expr - val TcLetrecAdjustMemberForSpecialVals : - cenv:TcFileState -> - pgrbind:PostGeneralizationRecursiveBinding -> - PostSpecialValsRecursiveBinding - val FixupLetrecBind : - cenv:TcFileState -> - denv:TypedTreeOps.DisplayEnv -> - generalizedTyparsForRecursiveBlock:TypedTree.Typars -> - bind:PostSpecialValsRecursiveBinding -> - PreInitializationGraphEliminationBinding - val unionGeneralizedTypars : - typarSets:TypedTree.Typar list list -> TypedTree.Typar list - val TcLetrec : - overridesOK:OverridesOK -> - cenv:TcFileState -> - env:TcEnv -> - tpenv:UnscopedTyparEnv -> - binds:RecDefnBindingInfo list * bindsm:Range.range * - scopem:Range.range -> - TypedTree.Bindings * TcEnv * UnscopedTyparEnv - val TcAndPublishValSpec : - cenv:TcFileState * env:TcEnv * containerInfo:ContainerInfo * - declKind:DeclKind * memFlagsOpt:SyntaxTree.MemberFlags option * - tpenv:UnscopedTyparEnv * valSpfn:SyntaxTree.SynValSig -> - TypedTree.Val list * UnscopedTyparEnv - end - -namespace FSharp.Compiler - module internal CheckComputationExpressions = begin - type cenv = CheckExpressions.TcFileState - type CompExprTranslationPass = - | Initial - | Subsequent - type CustomOperationsMode = - | Allowed - | Denied - val TryFindIntrinsicOrExtensionMethInfo : - collectionSettings:NameResolution.ResultCollectionSettings -> - cenv:cenv -> - env:CheckExpressions.TcEnv -> - m:Range.range -> - ad:AccessibilityLogic.AccessorDomain -> - nm:string -> ty:TypedTree.TType -> Infos.MethInfo list - val IgnoreAttribute : 'a -> 'b option - val ( |ExprAsPat|_| ) : f:SyntaxTree.SynExpr -> SyntaxTree.SynPat option - val ( |JoinRelation|_| ) : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - e:SyntaxTree.SynExpr -> - (SyntaxTree.SynExpr * SyntaxTree.SynExpr) option - val elimFastIntegerForLoop : - spBind:SyntaxTree.DebugPointAtFor * id:SyntaxTree.Ident * - start:SyntaxTree.SynExpr * dir:bool * finish:SyntaxTree.SynExpr * - innerExpr:SyntaxTree.SynExpr * m:Range.range -> SyntaxTree.SynExpr - val YieldFree : cenv:cenv -> expr:SyntaxTree.SynExpr -> bool - val ( |SimpleSemicolonSequence|_| ) : - cenv:cenv -> - acceptDeprecated:bool -> - cexpr:SyntaxTree.SynExpr -> SyntaxTree.SynExpr list option - val RecordNameAndTypeResolutions_IdeallyWithoutHavingOtherEffects : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - expr:SyntaxTree.SynExpr -> unit - val TcComputationExpression : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - overallTy:TypedTree.TType -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - mWhole:Range.range * interpExpr:TypedTree.Expr * - builderTy:TypedTree.TType * comp:SyntaxTree.SynExpr -> - TypedTree.Expr * CheckExpressions.UnscopedTyparEnv - val mkSeqEmpty : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - m:Range.range -> genTy:TypedTree.TType -> TypedTree.Expr - val mkSeqCollect : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - m:Range.range -> - enumElemTy:TypedTree.TType -> - genTy:TypedTree.TType -> - lam:TypedTree.Expr -> enumExpr:TypedTree.Expr -> TypedTree.Expr - val mkSeqUsing : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - m:Range.range -> - resourceTy:TypedTree.TType -> - genTy:TypedTree.TType -> - resourceExpr:TypedTree.Expr -> - lam:TypedTree.Expr -> TypedTree.Expr - val mkSeqDelay : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - m:Range.range -> - genTy:TypedTree.TType -> lam:TypedTree.Expr -> TypedTree.Expr - val mkSeqAppend : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - m:Range.range -> - genTy:TypedTree.TType -> - e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkSeqFromFunctions : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - m:Range.range -> - genTy:TypedTree.TType -> - e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkSeqFinally : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - m:Range.range -> - genTy:TypedTree.TType -> - e1:TypedTree.Expr -> e2:TypedTree.Expr -> TypedTree.Expr - val mkSeqExprMatchClauses : - pat':PatternMatchCompilation.Pattern * vspecs:TypedTree.Val list -> - innerExpr:TypedTree.Expr -> - PatternMatchCompilation.TypedMatchClause list - val compileSeqExprMatchClauses : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - inputExprMark:Range.range -> - pat:PatternMatchCompilation.Pattern * vspecs:TypedTree.Val list -> - innerExpr:TypedTree.Expr -> - inputExprOpt:TypedTree.Expr option -> - bindPatTy:TypedTree.TType -> - genInnerTy:TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val TcSequenceExpression : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - comp:SyntaxTree.SynExpr -> - overallTy:TypedTree.TType -> - m:Range.range -> - TypedTree.Expr * CheckExpressions.UnscopedTyparEnv - val TcSequenceExpressionEntry : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - overallTy:TypedTree.TType -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - isArrayOrList:bool * isNotNakedRefCell:bool ref * - comp:SyntaxTree.SynExpr -> - m:Range.range -> - TypedTree.Expr * CheckExpressions.UnscopedTyparEnv - val TcArrayOrListSequenceExpression : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - overallTy:TypedTree.TType -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - isArray:bool * comp:SyntaxTree.SynExpr -> - m:Range.range -> - TypedTree.Expr * CheckExpressions.UnscopedTyparEnv - end - -namespace FSharp.Compiler - module internal CheckDeclarations = begin - type cenv = CheckExpressions.TcFileState - type MutRecDataForOpen = - | MutRecDataForOpen of - SyntaxTree.SynOpenDeclTarget * Range.range * appliedScope: Range.range - type MutRecDataForModuleAbbrev = - | MutRecDataForModuleAbbrev of - SyntaxTree.Ident * SyntaxTree.LongIdent * Range.range - [] - type MutRecShape<'TypeData,'LetsData,'ModuleData> = - | Tycon of 'TypeData - | Lets of 'LetsData - | Module of 'ModuleData * MutRecShapes<'TypeData,'LetsData,'ModuleData> - | ModuleAbbrev of MutRecDataForModuleAbbrev - | Open of MutRecDataForOpen - and MutRecShapes<'TypeData,'LetsData,'ModuleData> = - MutRecShape<'TypeData,'LetsData,'ModuleData> list - module MutRecShapes = begin - val map : - f1:('a -> 'b) -> - f2:('c -> 'd) -> - f3:('e -> 'f) -> - x:MutRecShape<'a,'c,'e> list -> MutRecShape<'b,'d,'f> list - val mapTycons : - f1:('a -> 'b) -> - xs:MutRecShape<'a,'c,'d> list -> MutRecShape<'b,'c,'d> list - val mapTyconsAndLets : - f1:('a -> 'b) -> - f2:('c -> 'd) -> - xs:MutRecShape<'a,'c,'e> list -> MutRecShape<'b,'d,'e> list - val mapLets : - f2:('a -> 'b) -> - xs:MutRecShape<'c,'a,'d> list -> MutRecShape<'c,'b,'d> list - val mapModules : - f1:('a -> 'b) -> - xs:MutRecShape<'c,'d,'a> list -> MutRecShape<'c,'d,'b> list - val mapWithEnv : - fTycon:('Env -> 'a -> 'b) -> - fLets:('Env -> 'c -> 'd) -> - env:'Env -> - x:MutRecShape<'a,'c,('e * 'Env)> list -> - MutRecShape<'b,'d,('e * 'Env)> list - val mapTyconsWithEnv : - f1:('a -> 'b -> 'c) -> - env:'a -> - xs:MutRecShape<'b,'d,('e * 'a)> list -> - MutRecShape<'c,'d,('e * 'a)> list - val mapWithParent : - parent:'a -> - f1:('a -> 'b -> MutRecShapes<'c,'d,'b> -> 'e * 'a) -> - f2:('a -> 'c -> 'f) -> - f3:('a -> 'd -> 'g) -> - xs:MutRecShape<'c,'d,'b> list -> MutRecShape<'f,'g,'e> list - val computeEnvs : - f1:('a -> 'b -> 'Env) -> - f2:('Env -> MutRecShape<'c,'d,'b> list -> 'a) -> - env:'Env -> - xs:MutRecShape<'c,'d,'b> list -> - 'a * MutRecShape<'c,'d,('b * 'a)> list - val extendEnvs : - f1:('Env -> MutRecShape<'a,'b,('c * 'Env)> list -> 'Env) -> - env:'Env -> - xs:MutRecShape<'a,'b,('c * 'Env)> list -> - 'Env * MutRecShape<'a,'b,('c * 'Env)> list - val dropEnvs : - xs:MutRecShape<'a,'b,('c * 'd)> list -> MutRecShape<'a,'b,'c> list - val expandTyconsWithEnv : - f1:('a -> 'b -> 'c list * 'c list) -> - env:'a -> - xs:MutRecShape<'b,'c list,('d * 'a)> list -> - MutRecShape<'b,'c list,('d * 'a)> list - val mapFoldWithEnv : - f1:('a -> 'b -> MutRecShape<'c,'d,('e * 'b)> -> - MutRecShape<'f,'g,('e * 'b)> * 'a) -> - z:'a -> - env:'b -> - xs:MutRecShape<'c,'d,('e * 'b)> list -> - MutRecShape<'f,'g,('e * 'b)> list * 'a - val collectTycons : x:MutRecShape<'a,'b,'c> list -> 'a list - val topTycons : x:MutRecShape<'a,'b,'c> list -> 'a list - val iter : - f1:('a -> unit) -> - f2:('b -> unit) -> - f3:('c -> unit) -> - f4:(MutRecDataForOpen -> unit) -> - f5:(MutRecDataForModuleAbbrev -> unit) -> - x:MutRecShape<'a,'b,'c> list -> unit - val iterTycons : f1:('a -> unit) -> x:MutRecShape<'a,'b,'c> list -> unit - val iterTyconsAndLets : - f1:('a -> unit) -> - f2:('b -> unit) -> x:MutRecShape<'a,'b,'c> list -> unit - val iterModules : f1:('a -> unit) -> x:MutRecShape<'b,'c,'a> list -> unit - val iterWithEnv : - f1:('a -> 'b -> unit) -> - f2:('a -> 'c -> unit) -> - f3:('a -> MutRecDataForOpen -> unit) -> - f4:('a -> MutRecDataForModuleAbbrev -> unit) -> - env:'a -> x:MutRecShape<'b,'c,('d * 'a)> list -> unit - val iterTyconsWithEnv : - f1:('a -> 'b -> unit) -> - env:'a -> xs:MutRecShape<'b,'c,('d * 'a)> list -> unit - end - val ModuleOrNamespaceContainerInfo : - modref:TypedTree.EntityRef -> CheckExpressions.ContainerInfo - val TyconContainerInfo : - parent:TypedTree.ParentRef * tcref:TypedTree.TyconRef * - declaredTyconTypars:TypedTree.Typars * - safeInitInfo:CheckExpressions.SafeInitData -> - CheckExpressions.ContainerInfo - type TyconBindingDefn = - | TyconBindingDefn of - CheckExpressions.ContainerInfo * CheckExpressions.NewSlotsOK * - CheckExpressions.DeclKind * SyntaxTree.SynMemberDefn * Range.range - type MutRecSigsInitialData = - MutRecShape list - type MutRecDefnsInitialData = - MutRecShape list - type MutRecDefnsPhase1DataForTycon = - | MutRecDefnsPhase1DataForTycon of - SyntaxTree.SynComponentInfo * SyntaxTree.SynTypeDefnSimpleRepr * - (SyntaxTree.SynType * Range.range) list * - preEstablishedHasDefaultCtor: bool * hasSelfReferentialCtor: bool * - isAtOriginalTyconDefn: bool - type MutRecDefnsPhase1Data = - MutRecShape<(MutRecDefnsPhase1DataForTycon * SyntaxTree.SynMemberDefn list), - CheckExpressions.RecDefnBindingInfo list, - SyntaxTree.SynComponentInfo> list - type MutRecDefnsPhase2DataForTycon = - | MutRecDefnsPhase2DataForTycon of - TypedTree.Tycon option * TypedTree.ParentRef * CheckExpressions.DeclKind * - TypedTree.TyconRef * TypedTree.Val option * - CheckExpressions.SafeInitData * TypedTree.Typars * - SyntaxTree.SynMemberDefn list * Range.range * - CheckExpressions.NewSlotsOK * fixupFinalAttribs: unit -> unit - type MutRecDefnsPhase2DataForModule = - | MutRecDefnsPhase2DataForModule of - TypedTree.ModuleOrNamespaceType ref * TypedTree.ModuleOrNamespace - type MutRecDefnsPhase2Data = - MutRecShape list - type MutRecDefnsPhase2InfoForTycon = - | MutRecDefnsPhase2InfoForTycon of - TypedTree.Tycon option * TypedTree.TyconRef * TypedTree.Typars * - CheckExpressions.DeclKind * TyconBindingDefn list * - fixupFinalAttrs: unit -> unit - type MutRecDefnsPhase2Info = - MutRecShape list - val AddLocalExnDefnAndReport : - tcSink:NameResolution.TcResultsSink -> - scopem:Range.range -> - env:CheckExpressions.TcEnv -> - exnc:TypedTree.Tycon -> CheckExpressions.TcEnv - val AddLocalTyconRefs : - ownDefinition:bool -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - tcrefs:TypedTree.TyconRef list -> - env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv - val AddLocalTycons : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - tycons:TypedTree.Tycon list -> - env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv - val AddLocalTyconsAndReport : - tcSink:NameResolution.TcResultsSink -> - scopem:Range.range -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - tycons:TypedTree.Tycon list -> - env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv - val AddLocalSubModule : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - env:CheckExpressions.TcEnv -> - modul:TypedTree.ModuleOrNamespace -> CheckExpressions.TcEnv - val AddLocalSubModuleAndReport : - tcSink:NameResolution.TcResultsSink -> - scopem:Range.range -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - env:CheckExpressions.TcEnv -> - modul:TypedTree.ModuleOrNamespace -> CheckExpressions.TcEnv - val BuildRootModuleType : - enclosingNamespacePath:SyntaxTree.Ident list -> - cpath:TypedTree.CompilationPath -> - mtyp:TypedTree.ModuleOrNamespaceType -> - TypedTree.ModuleOrNamespaceType * TypedTree.ModuleOrNamespace list - val BuildRootModuleExpr : - enclosingNamespacePath:SyntaxTree.Ident list -> - cpath:TypedTree.CompilationPath -> - mexpr:TypedTree.ModuleOrNamespaceExpr -> - TypedTree.ModuleOrNamespaceExpr - val TryStripPrefixPath : - g:TcGlobals.TcGlobals -> - enclosingNamespacePath:SyntaxTree.Ident list -> - (SyntaxTree.Ident * SyntaxTree.Ident list) option - val AddModuleAbbreviationAndReport : - tcSink:NameResolution.TcResultsSink -> - scopem:Range.range -> - id:SyntaxTree.Ident -> - modrefs:TypedTree.ModuleOrNamespaceRef list -> - env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv - val OpenModuleOrNamespaceRefs : - tcSink:NameResolution.TcResultsSink -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - scopem:Range.range -> - root:bool -> - env:CheckExpressions.TcEnv -> - mvvs:TypedTree.ModuleOrNamespaceRef list -> - openDeclaration:NameResolution.OpenDeclaration -> - CheckExpressions.TcEnv - val OpenTypeContent : - tcSink:NameResolution.TcResultsSink -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - scopem:Range.range -> - env:CheckExpressions.TcEnv -> - typ:TypedTree.TType -> - openDeclaration:NameResolution.OpenDeclaration -> - CheckExpressions.TcEnv - val AddRootModuleOrNamespaceRefs : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - env:CheckExpressions.TcEnv -> - modrefs:TypedTree.ModuleOrNamespaceRef list -> - CheckExpressions.TcEnv - val addInternalsAccessibility : - env:CheckExpressions.TcEnv -> - ccu:TypedTree.CcuThunk -> CheckExpressions.TcEnv - val AddNonLocalCcu : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - scopem:Range.range -> - env:CheckExpressions.TcEnv -> - assemblyName:string -> - ccu:TypedTree.CcuThunk * - internalsVisibleToAttributes:string list -> - CheckExpressions.TcEnv - val AddLocalRootModuleOrNamespace : - NameResolution.TcResultsSink -> - TcGlobals.TcGlobals -> - Import.ImportMap -> - Range.range -> - CheckExpressions.TcEnv -> - TypedTree.ModuleOrNamespaceType -> CheckExpressions.TcEnv - val ImplicitlyOpenOwnNamespace : - tcSink:NameResolution.TcResultsSink -> - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - scopem:Range.range -> - enclosingNamespacePath:SyntaxTree.Ident list -> - env:CheckExpressions.TcEnv -> CheckExpressions.TcEnv - exception NotUpperCaseConstructor of Range.range - val CheckNamespaceModuleOrTypeName : - g:TcGlobals.TcGlobals -> id:SyntaxTree.Ident -> unit - val CheckDuplicates : - idf:('a -> SyntaxTree.Ident) -> k:string -> elems:'a list -> 'a list - module TcRecdUnionAndEnumDeclarations = begin - val CombineReprAccess : - parent:TypedTree.ParentRef -> - vis:TypedTree.Accessibility -> TypedTree.Accessibility - val MakeRecdFieldSpec : - _cenv:'a -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - isStatic:bool * konst:TypedTree.Const option * ty':TypedTree.TType * - attrsForProperty:TypedTree.Attribs * - attrsForField:TypedTree.Attribs * id:SyntaxTree.Ident * - nameGenerated:bool * isMutable:bool * vol:bool * - xmldoc:XmlDoc.XmlDoc * vis:SyntaxTree.SynAccess option * - m:Range.range -> TypedTree.RecdField - val TcFieldDecl : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - isIncrClass:bool -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - isStatic:bool * synAttrs:SyntaxTree.SynAttribute list * - id:SyntaxTree.Ident * nameGenerated:bool * - ty:SyntaxTree.SynType * isMutable:bool * xmldoc:XmlDoc.XmlDoc * - vis:SyntaxTree.SynAccess option * m:Range.range -> - TypedTree.RecdField - val TcAnonFieldDecl : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - nm:string -> SyntaxTree.SynField -> TypedTree.RecdField - val TcNamedFieldDecl : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - isIncrClass:bool -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - SyntaxTree.SynField -> TypedTree.RecdField - val TcNamedFieldDecls : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - isIncrClass:bool -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - fields:SyntaxTree.SynField list -> TypedTree.RecdField list - val CheckUnionCaseName : cenv:cenv -> id:SyntaxTree.Ident -> unit - val ValidateFieldNames : - synFields:SyntaxTree.SynField list * tastFields:TypedTree.RecdField list -> - unit - val TcUnionCaseDecl : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - thisTy:TypedTree.TType -> - thisTyInst:TypedTree.TypeInst -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - SyntaxTree.SynUnionCase -> TypedTree.UnionCase - val TcUnionCaseDecls : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - thisTy:TypedTree.TType -> - thisTyInst:TypedTree.TypeInst -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - unionCases:SyntaxTree.SynUnionCase list -> - TypedTree.UnionCase list - val TcEnumDecl : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - thisTy:TypedTree.TType -> - fieldTy:TypedTree.TType -> - SyntaxTree.SynEnumCase -> TypedTree.RecdField - val TcEnumDecls : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - thisTy:TypedTree.TType -> - enumCases:SyntaxTree.SynEnumCase list -> - TypedTree.TType * TypedTree.RecdField list - end - val PublishInterface : - cenv:cenv -> - denv:TypedTreeOps.DisplayEnv -> - tcref:TypedTree.TyconRef -> - m:Range.range -> compgen:bool -> ty':TypedTree.TType -> unit - val TcAndPublishMemberSpec : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - containerInfo:CheckExpressions.ContainerInfo -> - declKind:CheckExpressions.DeclKind -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - memb:SyntaxTree.SynMemberSig -> - TypedTree.Val list * CheckExpressions.UnscopedTyparEnv - val TcTyconMemberSpecs : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - containerInfo:CheckExpressions.ContainerInfo -> - declKind:CheckExpressions.DeclKind -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - augSpfn:SyntaxTree.SynMemberSig list -> - TypedTree.Val list * CheckExpressions.UnscopedTyparEnv - val TcOpenLidAndPermitAutoResolve : - tcSink:NameResolution.TcResultsSink -> - env:CheckExpressions.TcEnv -> - amap:Import.ImportMap -> - longId:SyntaxTree.Ident list -> - (int * TypedTree.ModuleOrNamespaceRef * - TypedTree.ModuleOrNamespaceType) list - val TcOpenModuleOrNamespaceDecl : - NameResolution.TcResultsSink -> - TcGlobals.TcGlobals -> - Import.ImportMap -> - Range.range -> - CheckExpressions.TcEnv -> - (SyntaxTree.Ident list * Range.range) -> CheckExpressions.TcEnv - val TcOpenTypeDecl : - cenv:cenv -> - mOpenDecl:Range.range -> - scopem:Range.range -> - env:CheckExpressions.TcEnv -> - synType:SyntaxTree.SynType * m:Range.range -> - CheckExpressions.TcEnv - val TcOpenDecl : - cenv:CheckExpressions.TcFileState -> - mOpenDecl:Range.range -> - scopem:Range.range -> - env:CheckExpressions.TcEnv -> - target:SyntaxTree.SynOpenDeclTarget -> CheckExpressions.TcEnv - exception ParameterlessStructCtor of Range.range - val MakeSafeInitField : - g:TcGlobals.TcGlobals -> - env:CheckExpressions.TcEnv -> - m:Range.range -> isStatic:bool -> TypedTree.RecdField - module IncrClassChecking = begin - type IncrClassBindingGroup = - | IncrClassBindingGroup of TypedTree.Binding list * bool * bool - | IncrClassDo of TypedTree.Expr * bool - type IncrClassCtorLhs = - { TyconRef: TypedTree.TyconRef - InstanceCtorDeclaredTypars: TypedTree.Typars - StaticCtorValInfo: - System.Lazy - InstanceCtorVal: TypedTree.Val - InstanceCtorValScheme: CheckExpressions.ValScheme - InstanceCtorArgs: TypedTree.Val list - InstanceCtorSafeThisValOpt: TypedTree.Val option - InstanceCtorSafeInitInfo: CheckExpressions.SafeInitData - InstanceCtorBaseValOpt: TypedTree.Val option - InstanceCtorThisVal: TypedTree.Val - NameGenerator: CompilerGlobalState.NiceNameGenerator } - with - member - GetNormalizedInstanceCtorDeclaredTypars : cenv:cenv -> - denv:TypedTreeOps.DisplayEnv -> - m:Range.range -> - TypedTree.Typar list - end - val TcImplicitCtorLhs_Phase2A : - cenv:cenv * env:CheckExpressions.TcEnv * - tpenv:CheckExpressions.UnscopedTyparEnv * tcref:TypedTree.TyconRef * - vis:SyntaxTree.SynAccess option * attrs:SyntaxTree.SynAttribute list * - spats:SyntaxTree.SynSimplePat list * thisIdOpt:SyntaxTree.Ident option * - baseValOpt:TypedTree.Val option * - safeInitInfo:CheckExpressions.SafeInitData * m:Range.range * - copyOfTyconTypars:TypedTree.Typar list * objTy:TypedTree.TType * - thisTy:TypedTree.TType * doc:XmlDoc.PreXmlDoc -> IncrClassCtorLhs - val private MakeIncrClassField : - g:TcGlobals.TcGlobals * cpath:TypedTree.CompilationPath * - formalTyparInst:TypedTreeOps.TyparInst * v:TypedTree.Val * isStatic:bool * - rfref:TypedTree.RecdFieldRef -> TypedTree.RecdField - type IncrClassValRepr = - | InVar of bool - | InField of bool * int * TypedTree.RecdFieldRef - | InMethod of bool * TypedTree.Val * TypedTree.ValReprInfo - type IncrClassReprInfo = - { TakenFieldNames: Set - RepInfoTcGlobals: TcGlobals.TcGlobals - ValReprs: AbstractIL.Internal.Zmap - ValsWithRepresentation: AbstractIL.Internal.Zset } - with - static member - Empty : g:TcGlobals.TcGlobals * names:string list -> - IncrClassReprInfo - static member - IsMethodRepr : cenv:cenv -> bind:TypedTree.Binding -> bool - member - ChooseAndAddRepresentation : cenv:cenv * env:CheckExpressions.TcEnv * - isStatic:bool * isCtorArg:bool * - ctorInfo:IncrClassCtorLhs * - staticForcedFieldVars:TypedTree.FreeLocals * - instanceForcedFieldVars:TypedTree.FreeLocals * - bind:TypedTree.Binding -> - IncrClassReprInfo - member - ChooseRepresentation : cenv:cenv * env:CheckExpressions.TcEnv * - isStatic:bool * isCtorArg:bool * - ctorInfo:IncrClassCtorLhs * - staticForcedFieldVars:TypedTree.FreeLocals * - instanceForcedFieldVars:TypedTree.FreeLocals * - takenFieldNames:Set * - bind:TypedTree.Binding -> - IncrClassValRepr * Set - member - FixupIncrClassExprPhase2C : cenv:CheckExpressions.TcFileState -> - thisValOpt:TypedTree.Val option -> - safeStaticInitInfo:CheckExpressions.SafeInitData -> - thisTyInst:TypedTree.TypeInst -> - expr:TypedTree.Expr -> - TypedTree.Expr - member IsValRepresentedAsLocalVar : v:TypedTree.Val -> bool - member IsValRepresentedAsMethod : v:TypedTree.Val -> bool - member IsValWithRepresentation : v:TypedTree.Val -> bool - member LookupRepr : v:TypedTree.Val -> IncrClassValRepr - member - MakeValueAssign : thisValOpt:TypedTree.Val option -> - tinst:TypedTree.TypeInst -> - safeStaticInitInfo:CheckExpressions.SafeInitData -> - v:TypedTree.Val -> - expr:TypedTree.Expr -> - m:Range.range -> TypedTree.Expr - member - MakeValueGetAddress : readonly:bool -> - thisValOpt:TypedTree.Val option -> - tinst:TypedTree.TypeInst -> - safeStaticInitInfo:CheckExpressions.SafeInitData -> - v:TypedTree.Val -> - m:Range.range -> TypedTree.Expr - member - MakeValueLookup : thisValOpt:TypedTree.Val option -> - tinst:TypedTree.TypeInst -> - safeStaticInitInfo:CheckExpressions.SafeInitData -> - v:TypedTree.Val -> - tyargs:TypedTree.TType list -> - m:Range.range -> TypedTree.Expr - member - PublishIncrClassFields : cenv:cenv * denv:TypedTreeOps.DisplayEnv * - cpath:TypedTree.CompilationPath * - ctorInfo:IncrClassCtorLhs * - safeStaticInitInfo:CheckExpressions.SafeInitData -> - unit - member ValNowWithRepresentation : v:TypedTree.Val -> IncrClassReprInfo - end - type IncrClassConstructionBindingsPhase2C = - | Phase2CBindings of IncrClassBindingGroup list - | Phase2CCtorJustAfterSuperInit - | Phase2CCtorJustAfterLastLet - val MakeCtorForIncrClassConstructionPhase2C : - cenv:cenv * env:CheckExpressions.TcEnv * ctorInfo:IncrClassCtorLhs * - inheritsExpr:TypedTree.Expr * inheritsIsVisible:bool * - decs:IncrClassConstructionBindingsPhase2C list * - memberBinds:TypedTree.Binding list * - generalizedTyparsForRecursiveBlock:TypedTree.Typar list * - safeStaticInitInfo:CheckExpressions.SafeInitData -> - TypedTree.Expr * TypedTree.Expr option * TypedTree.Binding list * - IncrClassReprInfo - end - module MutRecBindingChecking = begin - type TyconBindingPhase2A = - | Phase2AIncrClassCtor of IncrClassChecking.IncrClassCtorLhs - | Phase2AInherit of - SyntaxTree.SynType * SyntaxTree.SynExpr * TypedTree.Val option * - Range.range - | Phase2AIncrClassBindings of - TypedTree.TyconRef * SyntaxTree.SynBinding list * bool * bool * - Range.range - | Phase2AMember of CheckExpressions.PreCheckingRecursiveBinding - | Phase2AIncrClassCtorJustAfterSuperInit - | Phase2AIncrClassCtorJustAfterLastLet - type TyconBindingsPhase2A = - | TyconBindingsPhase2A of - TypedTree.Tycon option * CheckExpressions.DeclKind * - TypedTree.Val list * TypedTree.TyconRef * TypedTree.Typar list * - TypedTree.TType * TyconBindingPhase2A list - type MutRecDefnsPhase2AData = - MutRecShape list - type TyconBindingPhase2B = - | Phase2BIncrClassCtor of - IncrClassChecking.IncrClassCtorLhs * TypedTree.Binding option - | Phase2BInherit of TypedTree.Expr * TypedTree.Val option - | Phase2BIncrClassBindings of - IncrClassChecking.IncrClassBindingGroup list - | Phase2BMember of int - | Phase2BIncrClassCtorJustAfterSuperInit - | Phase2BIncrClassCtorJustAfterLastLet - type TyconBindingsPhase2B = - | TyconBindingsPhase2B of - TypedTree.Tycon option * TypedTree.TyconRef * TyconBindingPhase2B list - type MutRecDefnsPhase2BData = - MutRecShape list - type TyconBindingPhase2C = - | Phase2CIncrClassCtor of - IncrClassChecking.IncrClassCtorLhs * TypedTree.Binding option - | Phase2CInherit of TypedTree.Expr * TypedTree.Val option - | Phase2CIncrClassBindings of - IncrClassChecking.IncrClassBindingGroup list - | Phase2CMember of - CheckExpressions.PreInitializationGraphEliminationBinding - | Phase2CIncrClassCtorJustAfterSuperInit - | Phase2CIncrClassCtorJustAfterLastLet - type TyconBindingsPhase2C = - | TyconBindingsPhase2C of - TypedTree.Tycon option * TypedTree.TyconRef * TyconBindingPhase2C list - type MutRecDefnsPhase2CData = - MutRecShape list - val TcMutRecBindings_Phase2A_CreateRecursiveValuesAndCheckArgumentPatterns - : - cenv:cenv -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - envMutRec:CheckExpressions.TcEnv * mutRecDefns:MutRecDefnsPhase2Info -> - MutRecDefnsPhase2AData * - CheckExpressions.PreCheckingRecursiveBinding list * - CheckExpressions.UnscopedTyparEnv - val TcMutRecBindings_Phase2B_TypeCheckAndIncrementalGeneralization : - cenv:cenv -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - envInitial:CheckExpressions.TcEnv -> - envMutRec:CheckExpressions.TcEnv * defnsAs:MutRecDefnsPhase2AData * - uncheckedRecBinds:CheckExpressions.PreCheckingRecursiveBinding list * - scopem:Range.range -> - MutRecDefnsPhase2BData * - CheckExpressions.PostGeneralizationRecursiveBinding list * - CheckExpressions.UnscopedTyparEnv - val TcMutRecBindings_Phase2C_FixupRecursiveReferences : - cenv:cenv -> - denv:TypedTreeOps.DisplayEnv * defnsBs:MutRecDefnsPhase2BData * - generalizedTyparsForRecursiveBlock:TypedTree.Typar list * - generalizedRecBinds:CheckExpressions.PostGeneralizationRecursiveBinding list * - scopem:Range.range -> - MutRecShape list - val TcMutRecBindings_Phase2D_ExtractImplicitFieldAndMethodBindings : - cenv:cenv -> - envMutRec:CheckExpressions.TcEnv -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - denv:TypedTreeOps.DisplayEnv * - generalizedTyparsForRecursiveBlock:TypedTree.Typar list * - defnsCs:MutRecDefnsPhase2CData -> - MutRecShape<(TypedTree.Tycon option * - CheckExpressions.PreInitializationGraphEliminationBinding list * - TypedTree.Binding list), - CheckExpressions.PreInitializationGraphEliminationBinding list, - (MutRecDefnsPhase2DataForModule * - CheckExpressions.TcEnv)> list - val TcModuleAbbrevDecl : - cenv:cenv -> - scopem:Range.range -> - env:CheckExpressions.TcEnv -> - id:SyntaxTree.Ident * p:SyntaxTree.Ident list * m:Range.range -> - CheckExpressions.TcEnv - val TcMutRecDefns_UpdateNSContents : - mutRecNSInfo:(TypedTree.ModuleOrNamespace option * - TypedTree.ModuleOrNamespaceType ref) option -> unit - val TcMutRecDefns_UpdateModuleContents : - mutRecNSInfo:(TypedTree.ModuleOrNamespace option * - TypedTree.ModuleOrNamespaceType ref) option -> - defns:MutRecShape<'a,'b,(MutRecDefnsPhase2DataForModule * 'c)> list -> - unit - val TcMutRecDefns_ComputeEnvs : - getTyconOpt:('a -> TypedTree.Tycon option) -> - getVals:('b -> TypedTree.Val list) -> - cenv:cenv -> - report:bool -> - scopem:Range.range -> - m:Range.range -> - envInitial:CheckExpressions.TcEnv -> - mutRecShape:MutRecShape<'a,'b, - MutRecDefnsPhase2DataForModule> list -> - CheckExpressions.TcEnv * - MutRecShape<'a,'b, - (MutRecDefnsPhase2DataForModule * - CheckExpressions.TcEnv)> list - val TcMutRecDefns_Phase2_Bindings : - cenv:cenv -> - envInitial:CheckExpressions.TcEnv -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - bindsm:Range.range -> - scopem:Range.range -> - mutRecNSInfo:(TypedTree.ModuleOrNamespace option * - TypedTree.ModuleOrNamespaceType ref) option -> - envMutRecPrelimWithReprs:CheckExpressions.TcEnv -> - mutRecDefns:MutRecDefnsPhase2Info -> - MutRecShape<(TypedTree.Tycon option * - TypedTree.Binding list), - TypedTree.Binding list, - (MutRecDefnsPhase2DataForModule * - CheckExpressions.TcEnv)> list * - CheckExpressions.TcEnv - end - val TcMutRecDefns_Phase2 : - cenv:cenv -> - envInitial:CheckExpressions.TcEnv -> - bindsm:Range.range -> - scopem:Range.range -> - mutRecNSInfo:(TypedTree.ModuleOrNamespace option * - TypedTree.ModuleOrNamespaceType ref) option -> - envMutRec:CheckExpressions.TcEnv -> - mutRecDefns:MutRecDefnsPhase2Data -> - MutRecShape<(TypedTree.Tycon option * TypedTree.Binding list), - TypedTree.Binding list, - (MutRecDefnsPhase2DataForModule * - CheckExpressions.TcEnv)> list * - CheckExpressions.TcEnv - module AddAugmentationDeclarations = begin - val tcaugHasNominalInterface : - g:TcGlobals.TcGlobals -> - tcaug:TypedTree.TyconAugmentation -> tcref:TypedTree.TyconRef -> bool - val AddGenericCompareDeclarations : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - scSet:Set -> tycon:TypedTree.Tycon -> unit - val AddGenericEqualityWithComparerDeclarations : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - seSet:Set -> tycon:TypedTree.Tycon -> unit - val AddGenericCompareBindings : - cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list - val AddGenericCompareWithComparerBindings : - cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list - val AddGenericEqualityWithComparerBindings : - cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list - val AddGenericHashAndComparisonDeclarations : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - scSet:Set -> - seSet:Set -> tycon:TypedTree.Tycon -> unit - val AddGenericHashAndComparisonBindings : - cenv:cenv -> tycon:TypedTree.Tycon -> TypedTree.Binding list - val AddGenericEqualityBindings : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - tycon:TypedTree.Tycon -> TypedTree.Binding list - end - module TyconConstraintInference = begin - val InferSetOfTyconsSupportingComparable : - cenv:cenv -> - denv:TypedTreeOps.DisplayEnv -> - tyconsWithStructuralTypes:(TypedTree.Tycon * - (TypedTree.TType * 'a) list) list -> - Set - val InferSetOfTyconsSupportingEquatable : - cenv:cenv -> - denv:TypedTreeOps.DisplayEnv -> - tyconsWithStructuralTypes:(TypedTree.Tycon * - (TypedTree.TType * 'a) list) list -> - Set - end - val ComputeModuleName : longPath:SyntaxTree.Ident list -> SyntaxTree.Ident - val CheckForDuplicateConcreteType : - env:CheckExpressions.TcEnv -> nm:string -> m:Range.range -> unit - val CheckForDuplicateModule : - env:CheckExpressions.TcEnv -> nm:string -> m:Range.range -> unit - module TcExceptionDeclarations = begin - val TcExnDefnCore_Phase1A : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - SyntaxTree.SynExceptionDefnRepr -> TypedTree.Entity - val TcExnDefnCore_Phase1G_EstablishRepresentation : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - exnc:TypedTree.Entity -> - SyntaxTree.SynExceptionDefnRepr -> TypedTree.RecdField list - val private TcExnDefnCore : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - synExnDefnRepr:SyntaxTree.SynExceptionDefnRepr -> - TypedTree.Binding list * TypedTree.Entity - val TcExnDefn : - cenv:CheckExpressions.TcFileState -> - envInitial:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - SyntaxTree.SynExceptionDefn * scopem:Range.range -> - TypedTree.Binding list * TypedTree.Entity * - CheckExpressions.TcEnv - val TcExnSignature : - cenv:CheckExpressions.TcFileState -> - envInitial:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - SyntaxTree.SynExceptionSig * scopem:Range.range -> - TypedTree.Binding list * TypedTree.Val list * - TypedTree.EntityRef * CheckExpressions.TcEnv - end - module EstablishTypeDefinitionCores = begin - type TypeRealizationPass = - | FirstPass - | SecondPass - val private ComputeTyconName : - longPath:SyntaxTree.Ident list * doErase:bool * typars:TypedTree.Typars -> - SyntaxTree.Ident - val private GetTyconAttribs : - g:TcGlobals.TcGlobals -> - attrs:TypedTree.Attribs -> bool * bool * bool * bool * bool - val private InferTyconKind : - g:TcGlobals.TcGlobals -> - kind:SyntaxTree.SynTypeDefnKind * attrs:TypedTree.Attribs * - slotsigs:'a list * fields:'b list * inSig:bool * isConcrete:bool * - m:Range.range -> SyntaxTree.SynTypeDefnKind - val private ( |TyconCoreAbbrevThatIsReallyAUnion|_| ) : - hasMeasureAttr:bool * envinner:CheckExpressions.TcEnv * - id:SyntaxTree.Ident -> - synTyconRepr:SyntaxTree.SynTypeDefnSimpleRepr -> - (SyntaxTree.Ident * Range.range) option - val private GetStructuralElementsOfTyconDefn : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - MutRecDefnsPhase1DataForTycon -> - tycon:Lib.NonNullSlot -> - (TypedTree.TType * Range.range) list - val ComputeModuleOrNamespaceKind : - g:TcGlobals.TcGlobals -> - isModule:bool -> - typeNames:Set<'a> -> - attribs:TypedTree.Attribs -> - nm:'a -> TypedTree.ModuleOrNamespaceKind when 'a : comparison - val AdjustModuleName : - modKind:TypedTree.ModuleOrNamespaceKind -> nm:string -> string - val InstanceMembersNeedSafeInitCheck : - cenv:cenv -> m:Range.range -> thisTy:TypedTree.TType -> bool - val ComputeInstanceSafeInitInfo : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - m:Range.range -> - thisTy:TypedTree.TType -> CheckExpressions.SafeInitData - val TypeNamesInMutRecDecls : - cenv:CheckExpressions.TcFileState -> - env:CheckExpressions.TcEnv -> - compDecls:MutRecShapes<(MutRecDefnsPhase1DataForTycon * 'MemberInfo), - 'LetInfo,SyntaxTree.SynComponentInfo> -> - Set - val TypeNamesInNonMutRecDecls : - defs:seq -> Set - val TypeNamesInNonMutRecSigDecls : - defs:seq -> Set - val TcTyconDefnCore_Phase1A_BuildInitialModule : - cenv:CheckExpressions.TcFileState -> - envInitial:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - typeNames:Set -> - compInfo:SyntaxTree.SynComponentInfo -> - decls:MutRecShapes<(MutRecDefnsPhase1DataForTycon * 'a),'b, - SyntaxTree.SynComponentInfo> -> - MutRecDefnsPhase2DataForModule * - (TypedTree.ParentRef * Set * CheckExpressions.TcEnv) - val private TcTyconDefnCore_Phase1A_BuildInitialTycon : - cenv:cenv -> - env:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - MutRecDefnsPhase1DataForTycon -> TypedTree.Entity - val private TcTyconDefnCore_Phase1B_EstablishBasicKind : - cenv:cenv -> - inSig:bool -> - envinner:CheckExpressions.TcEnv -> - MutRecDefnsPhase1DataForTycon -> - tycon:TypedTree.Tycon -> - TypedTree.Attrib list * (unit -> TypedTree.Attribs) - val private TcTyconDefnCore_GetGenerateDeclaration_Rhs : - SyntaxTree.SynType -> - (SyntaxTree.LongIdent * SyntaxTree.SynType list * Range.range) option - val private TcTyconDefnCore_TryAsGenerateDeclaration : - cenv:cenv -> - envinner:CheckExpressions.TcEnv -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - tycon:TypedTree.Tycon * rhsType:SyntaxTree.SynType -> - (TypedTree.TyconRef * Tainted * - (unit -> unit) * SyntaxTree.SynType list * Range.range) option - val private - TcTyconDefnCore_Phase1C_EstablishDeclarationForGeneratedSetOfTypes : - cenv:cenv -> - inSig:bool -> - tycon:TypedTree.Tycon * rhsType:SyntaxTree.SynType * - tcrefForContainer:TypedTree.TyconRef * - theRootType:Tainted * - checkTypeName:(unit -> unit) * args:'a list * m:Range.range -> unit - val private TcTyconDefnCore_Phase1C_Phase1E_EstablishAbbreviations : - cenv:cenv -> - envinner:CheckExpressions.TcEnv -> - inSig:bool -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - pass:TypeRealizationPass -> - MutRecDefnsPhase1DataForTycon -> - tycon:TypedTree.Tycon -> attrs:TypedTree.Attribs -> unit - val private - TcTyconDefnCore_Phase1D_Phase1F_EstablishSuperTypesAndInterfaceTypes : - cenv:CheckExpressions.TcFileState -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - inSig:bool -> - pass:TypeRealizationPass -> - envMutRec:CheckExpressions.TcEnv * - mutRecDefns:MutRecShape<((MutRecDefnsPhase1DataForTycon * 'a * - 'b) * - (TypedTree.Tycon * - (TypedTree.Attribs * 'c)) option),'d, - ('e * CheckExpressions.TcEnv)> list -> - unit - val private TcTyconDefnCore_Phase1G_EstablishRepresentation : - cenv:cenv -> - envinner:CheckExpressions.TcEnv -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - inSig:bool -> - MutRecDefnsPhase1DataForTycon -> - tycon:TypedTree.Tycon -> - attrs:TypedTree.Attribs -> - TypedTree.Val option * CheckExpressions.SafeInitData - val private TcTyconDefnCore_CheckForCyclicAbbreviations : - tycons:TypedTree.Entity list -> unit - val TcTyconDefnCore_CheckForCyclicStructsAndInheritance : - cenv:cenv -> tycons:TypedTree.Entity list -> unit - val TcMutRecDefns_CheckExplicitConstraints : - cenv:CheckExpressions.TcFileState -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - m:Range.range -> - checkCxs:CheckExpressions.CheckConstraints -> - envMutRecPrelim:CheckExpressions.TcEnv -> - withEnvs:MutRecShape<((MutRecDefnsPhase1DataForTycon * 'a * 'b) * - TypedTree.Tycon option),'c, - ('d * CheckExpressions.TcEnv)> list -> - unit - val TcMutRecDefns_Phase1 : - mkLetInfo:(CheckExpressions.ContainerInfo -> 'LetInfo -> 'a) -> - cenv:cenv -> - envInitial:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - typeNames:Set -> - inSig:bool -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - m:Range.range -> - scopem:Range.range -> - mutRecNSInfo:(TypedTree.ModuleOrNamespace option * - TypedTree.ModuleOrNamespaceType ref) option -> - mutRecDefns:MutRecShapes<(MutRecDefnsPhase1DataForTycon * - 'MemberInfo),'LetInfo, - SyntaxTree.SynComponentInfo> -> - TypedTree.Entity list * CheckExpressions.TcEnv * - MutRecShape<((MutRecDefnsPhase1DataForTycon * - 'MemberInfo * TypedTree.ParentRef) * - TypedTree.Entity option * - (unit -> unit) * - (TypedTree.Val option * - CheckExpressions.SafeInitData)),'a, - (MutRecDefnsPhase2DataForModule * - CheckExpressions.TcEnv)> list - end - module TcDeclarations = begin - val private ComputeTyconDeclKind : - cenv:cenv -> - envForDecls:CheckExpressions.TcEnv -> - tyconOpt:Lib.NonNullSlot option -> - isAtOriginalTyconDefn:bool -> - inSig:bool -> - m:Range.range -> - synTypars:SyntaxTree.SynTyparDecl list -> - synTyparCxs:SyntaxTree.SynTypeConstraint list -> - longPath:SyntaxTree.Ident list -> - CheckExpressions.DeclKind * TypedTree.EntityRef * - TypedTree.Typars - val private isAugmentationTyconDefnRepr : - _arg1:SyntaxTree.SynTypeDefnSimpleRepr -> bool - val private isAutoProperty : _arg1:SyntaxTree.SynMemberDefn -> bool - val private isMember : _arg1:SyntaxTree.SynMemberDefn -> bool - val private isImplicitCtor : _arg1:SyntaxTree.SynMemberDefn -> bool - val private isImplicitInherit : _arg1:SyntaxTree.SynMemberDefn -> bool - val private isAbstractSlot : _arg1:SyntaxTree.SynMemberDefn -> bool - val private isInterface : _arg1:SyntaxTree.SynMemberDefn -> bool - val private isInherit : _arg1:SyntaxTree.SynMemberDefn -> bool - val private isField : _arg1:SyntaxTree.SynMemberDefn -> bool - val private isTycon : _arg1:SyntaxTree.SynMemberDefn -> bool - val private allFalse : ps:('a -> bool) list -> x:'a -> bool - val private CheckMembersForm : ds:SyntaxTree.SynMemberDefn list -> unit - val private SplitTyconDefn : - SyntaxTree.SynTypeDefn -> - MutRecDefnsPhase1DataForTycon * SyntaxTree.SynMemberDefn list - val TcMutRecDefinitions : - cenv:cenv -> - envInitial:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - typeNames:Set -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - m:Range.range -> - scopem:Range.range -> - mutRecNSInfo:(TypedTree.ModuleOrNamespace option * - TypedTree.ModuleOrNamespaceType ref) option -> - mutRecDefns:MutRecDefnsInitialData -> - MutRecShape<(TypedTree.Tycon option * - TypedTree.Binding list), - TypedTree.Binding list, - (MutRecDefnsPhase2DataForModule * - CheckExpressions.TcEnv)> list * - CheckExpressions.TcEnv - val private SplitTyconSignature : - SyntaxTree.SynTypeDefnSig -> - MutRecDefnsPhase1DataForTycon * - (SyntaxTree.SynComponentInfo * SyntaxTree.SynMemberSig list) - val private TcMutRecSignatureDecls_Phase2 : - cenv:cenv -> - scopem:Range.range -> - envMutRec:CheckExpressions.TcEnv -> - mutRecDefns:MutRecShape<((MutRecDefnsPhase1DataForTycon * - (SyntaxTree.SynComponentInfo * - SyntaxTree.SynMemberSig list) * - TypedTree.ParentRef) * - Lib.NonNullSlot option * - 'a * 'b), - (CheckExpressions.ContainerInfo * - SyntaxTree.SynValSig), - ('c * CheckExpressions.TcEnv)> list -> - MutRecShape<(TypedTree.Val list * - CheckExpressions.UnscopedTyparEnv), - CheckExpressions.TcEnv,('c * CheckExpressions.TcEnv)> list - val TcMutRecSignatureDecls : - cenv:cenv -> - envInitial:CheckExpressions.TcEnv -> - parent:TypedTree.ParentRef -> - typeNames:Set -> - tpenv:CheckExpressions.UnscopedTyparEnv -> - m:Range.range -> - scopem:Range.range -> - mutRecNSInfo:(TypedTree.ModuleOrNamespace option * - TypedTree.ModuleOrNamespaceType ref) option -> - mutRecSigs:MutRecSigsInitialData -> - CheckExpressions.TcEnv - end - val TcSignatureElementNonMutRec : - cenv:CheckExpressions.TcFileState -> - parent:TypedTree.ParentRef -> - typeNames:Set -> - endm:Range.range -> - env:CheckExpressions.TcEnv -> - synSigDecl:SyntaxTree.SynModuleSigDecl -> - AbstractIL.Internal.Library.Eventually - val TcSignatureElements : - cenv:CheckExpressions.TcFileState -> - parent:TypedTree.ParentRef -> - endm:Range.range -> - env:CheckExpressions.TcEnv -> - xml:XmlDoc.PreXmlDoc -> - mutRecNSInfo:(TypedTree.ModuleOrNamespace option * - TypedTree.ModuleOrNamespaceType ref) option -> - defs:SyntaxTree.SynModuleSigDecl list -> - AbstractIL.Internal.Library.Eventually - val TcSignatureElementsNonMutRec : - cenv:CheckExpressions.TcFileState -> - parent:TypedTree.ParentRef -> - typeNames:Set -> - endm:Range.range -> - env:CheckExpressions.TcEnv -> - defs:SyntaxTree.SynModuleSigDecl list -> - AbstractIL.Internal.Library.Eventually - val TcSignatureElementsMutRec : - cenv:CheckExpressions.TcFileState -> - parent:TypedTree.ParentRef -> - typeNames:Set -> - m:Range.range -> - mutRecNSInfo:(TypedTree.ModuleOrNamespace option * - TypedTree.ModuleOrNamespaceType ref) option -> - envInitial:CheckExpressions.TcEnv -> - defs:SyntaxTree.SynModuleSigDecl list -> - AbstractIL.Internal.Library.Eventually - val TcModuleOrNamespaceSignatureElementsNonMutRec : - cenv:CheckExpressions.TcFileState -> - parent:TypedTree.ParentRef -> - env:CheckExpressions.TcEnv -> - id:SyntaxTree.Ident * modKind:TypedTree.ModuleOrNamespaceKind * - defs:SyntaxTree.SynModuleSigDecl list * m:Range.range * - xml:XmlDoc.PreXmlDoc -> - AbstractIL.Internal.Library.Eventually - val ElimModuleDoBinding : - bind:SyntaxTree.SynModuleDecl -> SyntaxTree.SynModuleDecl - val TcMutRecDefnsEscapeCheck : - binds:MutRecShapes<(TypedTree.Tycon option * TypedTree.Binding list), - TypedTree.Binding list,'a> -> - env:CheckExpressions.TcEnv -> unit - val CheckLetOrDoInNamespace : - binds:SyntaxTree.SynBinding list -> m:Range.range -> unit - val TcModuleOrNamespaceElementNonMutRec : - cenv:cenv -> - parent:TypedTree.ParentRef -> - typeNames:Set -> - scopem:Range.range -> - env:CheckExpressions.TcEnv -> - synDecl:SyntaxTree.SynModuleDecl -> - AbstractIL.Internal.Library.Eventually<((TypedTree.ModuleOrNamespaceExpr list -> - TypedTree.ModuleOrNamespaceExpr list) * - (System.AttributeTargets * - TypedTree.Attrib) list) * - CheckExpressions.TcEnv * - CheckExpressions.TcEnv> - val TcModuleOrNamespaceElementsNonMutRec : - cenv:cenv -> - parent:TypedTree.ParentRef -> - typeNames:Set -> - endm:Range.range -> - defsSoFar:((TypedTree.ModuleOrNamespaceExpr list -> - TypedTree.ModuleOrNamespaceExpr list) * - (System.AttributeTargets * TypedTree.Attrib) list) list * - env:CheckExpressions.TcEnv * envAtEnd:CheckExpressions.TcEnv -> - moreDefs:SyntaxTree.SynModuleDecl list -> - AbstractIL.Internal.Library.Eventually<((TypedTree.ModuleOrNamespaceExpr list -> - TypedTree.ModuleOrNamespaceExpr list) * - (System.AttributeTargets * - TypedTree.Attrib) list) list * - CheckExpressions.TcEnv> - val TcModuleOrNamespaceElementsMutRec : - cenv:cenv -> - parent:TypedTree.ParentRef -> - typeNames:Set -> - m:Range.range -> - envInitial:CheckExpressions.TcEnv -> - mutRecNSInfo:(TypedTree.ModuleOrNamespace option * - TypedTree.ModuleOrNamespaceType ref) option -> - defs:SyntaxTree.SynModuleDecl list -> - AbstractIL.Internal.Library.Eventually<((TypedTree.ModuleOrNamespaceExpr list -> - TypedTree.ModuleOrNamespaceExpr list) * - (System.AttributeTargets * - TypedTree.Attrib) list) * - CheckExpressions.TcEnv * - CheckExpressions.TcEnv> - val TcMutRecDefsFinish : - cenv:cenv -> - defs:MutRecShape<(TypedTree.Tycon option * TypedTree.Binding list), - TypedTree.Binding list, - (MutRecDefnsPhase2DataForModule * - CheckExpressions.TcEnv)> list -> - m:Range.range -> TypedTree.ModuleOrNamespaceExpr - val TcModuleOrNamespaceElements : - cenv:cenv -> - parent:TypedTree.ParentRef -> - endm:Range.range -> - env:CheckExpressions.TcEnv -> - xml:XmlDoc.PreXmlDoc -> - mutRecNSInfo:(TypedTree.ModuleOrNamespace option * - TypedTree.ModuleOrNamespaceType ref) option -> - defs:SyntaxTree.SynModuleDecl list -> - AbstractIL.Internal.Library.Eventually - val ApplyAssemblyLevelAutoOpenAttributeToTcEnv : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - ccu:TypedTree.CcuThunk -> - scopem:Range.range -> - env:CheckExpressions.TcEnv -> - p:System.String * root:bool -> CheckExpressions.TcEnv - val AddCcuToTcEnv : - TcGlobals.TcGlobals * Import.ImportMap * Range.range * - CheckExpressions.TcEnv * assemblyName:string * ccu:TypedTree.CcuThunk * - autoOpens:string list * internalsVisibleToAttributes:string list -> - CheckExpressions.TcEnv - val emptyTcEnv : g:TcGlobals.TcGlobals -> CheckExpressions.TcEnv - val CreateInitialTcEnv : - TcGlobals.TcGlobals * Import.ImportMap * Range.range * assemblyName:string * - (TypedTree.CcuThunk * string list * string list) list -> - CheckExpressions.TcEnv - type ConditionalDefines = string list - type TopAttribs = - { mainMethodAttrs: TypedTree.Attribs - netModuleAttrs: TypedTree.Attribs - assemblyAttrs: TypedTree.Attribs } - val EmptyTopAttrs : TopAttribs - val CombineTopAttrs : TopAttribs -> TopAttribs -> TopAttribs - val IterTyconsOfModuleOrNamespaceType : - f:(TypedTree.Entity -> unit) -> - mty:TypedTree.ModuleOrNamespaceType -> unit - val ApplyDefaults : - cenv:cenv -> - g:TcGlobals.TcGlobals -> - denvAtEnd:TypedTreeOps.DisplayEnv -> - m:Range.range -> - mexpr:TypedTree.ModuleOrNamespaceExpr -> - extraAttribs:TypedTree.Attrib list -> unit - val CheckValueRestriction : - denvAtEnd:TypedTreeOps.DisplayEnv -> - rootSigOpt:'a option -> - implFileTypePriorToSig:TypedTree.ModuleOrNamespaceType -> - m:Range.range -> unit - val SolveInternalUnknowns : - g:TcGlobals.TcGlobals -> - cenv:cenv -> - denvAtEnd:TypedTreeOps.DisplayEnv -> - mexpr:TypedTree.ModuleOrNamespaceExpr -> - extraAttribs:TypedTree.Attrib list -> unit - val CheckModuleSignature : - g:TcGlobals.TcGlobals -> - cenv:cenv -> - m:Range.range -> - denvAtEnd:TypedTreeOps.DisplayEnv -> - rootSigOpt:TypedTree.ModuleOrNamespaceType option -> - implFileTypePriorToSig:TypedTree.ModuleOrNamespaceType -> - implFileSpecPriorToSig:Lib.NonNullSlot -> - mexpr:TypedTree.ModuleOrNamespaceExpr -> - TypedTree.ModuleOrNamespaceExprWithSig - val MakeInitialEnv : - env:CheckExpressions.TcEnv -> - CheckExpressions.TcEnv * TypedTree.ModuleOrNamespaceType ref - val TypeCheckOneImplFile : - TcGlobals.TcGlobals * CompilerGlobalState.NiceNameGenerator * - Import.ImportMap * TypedTree.CcuThunk * (unit -> bool) * - string list option * NameResolution.TcResultsSink * bool -> - CheckExpressions.TcEnv -> - TypedTree.ModuleOrNamespaceType option -> - SyntaxTree.ParsedImplFileInput -> - AbstractIL.Internal.Library.Eventually - val TypeCheckOneSigFile : - TcGlobals.TcGlobals * CompilerGlobalState.NiceNameGenerator * - Import.ImportMap * TypedTree.CcuThunk * (unit -> bool) * - string list option * NameResolution.TcResultsSink * bool -> - CheckExpressions.TcEnv -> - SyntaxTree.ParsedSigFileInput -> - AbstractIL.Internal.Library.Eventually - end - -namespace FSharp.Compiler - module internal Optimizer = begin - val verboseOptimizationInfo : bool - val verboseOptimizations : bool - val i_ldlen : AbstractIL.IL.ILInstr list - [] - val callSize : int = 1 - [] - val forAndWhileLoopSize : int = 5 - [] - val tryWithSize : int = 5 - [] - val tryFinallySize : int = 5 - [] - val closureTotalSize : int = 10 - [] - val methodDefnTotalSize : int = 1 - type TypeValueInfo = | UnknownTypeValue - type ExprValueInfo = - | UnknownValue - | SizeValue of size: int * ExprValueInfo - | ValValue of TypedTree.ValRef * ExprValueInfo - | TupleValue of ExprValueInfo [] - | RecdValue of TypedTree.TyconRef * ExprValueInfo [] - | UnionCaseValue of TypedTree.UnionCaseRef * ExprValueInfo [] - | ConstValue of TypedTree.Const * TypedTree.TType - | CurriedLambdaValue of - id: CompilerGlobalState.Unique * arity: int * size: int * - value: TypedTree.Expr * TypedTree.TType - | ConstExprValue of size: int * value: TypedTree.Expr - type ValInfo = - { ValMakesNoCriticalTailcalls: bool - ValExprInfo: ExprValueInfo } - type ValInfos = - class - new : entries:seq -> ValInfos - member Filter : f:(TypedTree.ValRef * ValInfo -> bool) -> ValInfos - member - Map : f:(TypedTree.ValRef * ValInfo -> TypedTree.ValRef * ValInfo) -> - ValInfos - member - TryFind : v:TypedTree.ValRef -> (TypedTree.ValRef * ValInfo) option - member - TryFindForFslib : g:TcGlobals.TcGlobals * vref:TypedTree.ValRef -> - bool * (TypedTree.ValRef * ValInfo) - member Entries : seq - end - type ModuleInfo = - { ValInfos: ValInfos - ModuleOrNamespaceInfos: - AbstractIL.Internal.Library.NameMap } - and LazyModuleInfo = Lazy - type ImplFileOptimizationInfo = LazyModuleInfo - type CcuOptimizationInfo = LazyModuleInfo - val braceL : - x:Internal.Utilities.StructuredFormat.Layout -> - Internal.Utilities.StructuredFormat.Layout - val seqL : - xL:('a -> Internal.Utilities.StructuredFormat.Layout) -> - xs:seq<'a> -> Internal.Utilities.StructuredFormat.Layout - val namemapL : - xL:(string -> 'a -> Internal.Utilities.StructuredFormat.Layout) -> - xmap:AbstractIL.Internal.Library.NameMap<'a> -> - Internal.Utilities.StructuredFormat.Layout - val exprValueInfoL : - g:TcGlobals.TcGlobals -> - exprVal:ExprValueInfo -> Internal.Utilities.StructuredFormat.Layout - val exprValueInfosL : - g:TcGlobals.TcGlobals -> - vinfos:ExprValueInfo [] -> Internal.Utilities.StructuredFormat.Layout - val moduleInfoL : - TcGlobals.TcGlobals -> - LazyModuleInfo -> Internal.Utilities.StructuredFormat.Layout - val valInfoL : - g:TcGlobals.TcGlobals -> - x:ValInfo -> Internal.Utilities.StructuredFormat.Layout - type Summary<'Info> = - { Info: 'Info - FunctionSize: int - TotalSize: int - HasEffect: bool - MightMakeCriticalTailcall: bool } - val SizeOfValueInfos : arr:ExprValueInfo [] -> int - val SizeOfValueInfo : x:ExprValueInfo -> int - [] - val minDepthForASizeNode : int = 5 - val MakeValueInfoWithCachedSize : - vdepth:int -> v:ExprValueInfo -> ExprValueInfo - val MakeSizedValueInfo : v:ExprValueInfo -> ExprValueInfo - val BoundValueInfoBySize : vinfo:ExprValueInfo -> ExprValueInfo - [] - val jitOptDefault : bool = true - [] - val localOptDefault : bool = true - [] - val crossModuleOptDefault : bool = true - type OptimizationSettings = - { abstractBigTargets: bool - jitOptUser: bool option - localOptUser: bool option - crossModuleOptUser: bool option - bigTargetSize: int - veryBigExprSize: int - lambdaInlineThreshold: int - reportingPhase: bool - reportNoNeedToTailcall: bool - reportFunctionSizes: bool - reportHasEffect: bool - reportTotalSizes: bool } - with - member EliminateImmediatelyConsumedLocals : unit -> bool - member EliminateRecdFieldGet : unit -> bool - member EliminateSequential : unit -> bool - member EliminateSwitch : unit -> bool - member EliminateTryWithAndTryFinally : unit -> bool - member EliminateTupleFieldGet : unit -> bool - member EliminateUnionCaseFieldGet : unit -> bool - member EliminateUnusedBindings : unit -> bool - member ExpandStructuralValues : unit -> bool - member InlineLambdas : unit -> bool - member KeepOptimizationValues : unit -> bool - member crossModuleOpt : unit -> bool - member jitOpt : unit -> bool - member localOpt : unit -> bool - static member Defaults : OptimizationSettings - end - type cenv = - { g: TcGlobals.TcGlobals - TcVal: ConstraintSolver.TcValF - amap: Import.ImportMap - optimizing: bool - scope: TypedTree.CcuThunk - localInternalVals: - System.Collections.Generic.Dictionary - settings: OptimizationSettings - emitTailcalls: bool - casApplied: System.Collections.Generic.Dictionary } - with - override ToString : unit -> string - end - [] - type IncrementalOptimizationEnv = - { latestBoundId: SyntaxTree.Ident option - dontInline: AbstractIL.Internal.Zset - dontSplitVars: TypedTreeOps.ValMap - disableMethodSplitting: bool - functionVal: (TypedTree.Val * TypedTree.ValReprInfo) option - typarInfos: (TypedTree.Typar * TypeValueInfo) list - localExternalVals: - AbstractIL.Internal.Library.LayeredMap - globalModuleInfos: - AbstractIL.Internal.Library.LayeredMap } - with - override ToString : unit -> string - static member Empty : IncrementalOptimizationEnv - end - val IsPartialExprVal : x:ExprValueInfo -> bool - val CheckInlineValueIsComplete : - v:TypedTree.Val -> res:ExprValueInfo -> unit - val check : - vref:TypedTree.ValRef -> res:ValInfo -> TypedTree.ValRef * ValInfo - val EmptyModuleInfo : System.Lazy - val UnionOptimizationInfos : seq -> System.Lazy - val FindOrCreateModuleInfo : - n:'a -> ss:Map<'a,System.Lazy> -> System.Lazy - when 'a : comparison - val FindOrCreateGlobalModuleInfo : - n:'a -> - ss:AbstractIL.Internal.Library.LayeredMap<'a,System.Lazy> -> - System.Lazy when 'a : comparison - val BindValueInSubModuleFSharpCore : - mp:string [] -> - i:int -> v:TypedTree.Val -> vval:ValInfo -> ss:ModuleInfo -> ModuleInfo - val BindValueInModuleForFslib : - n:string -> - mp:string [] -> - i:int -> - v:TypedTree.Val -> - vval:ValInfo -> - ss:AbstractIL.Internal.Library.NameMap -> - AbstractIL.Internal.Library.NameMap - val BindValueInGlobalModuleForFslib : - n:'a -> - mp:string [] -> - i:int -> - v:TypedTree.Val -> - vval:ValInfo -> - ss:AbstractIL.Internal.Library.LayeredMap<'a, - System.Lazy> -> - Map<'a,System.Lazy> when 'a : comparison - val BindValueForFslib : - nlvref:TypedTree.NonLocalValOrMemberRef -> - v:TypedTree.Val -> - vval:ValInfo -> - env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv - val UnknownValInfo : ValInfo - val mkValInfo : info:Summary -> v:TypedTree.Val -> ValInfo - val BindInternalLocalVal : - cenv:cenv -> v:TypedTree.Val -> vval:ValInfo -> env:'a -> 'a - val BindExternalLocalVal : - cenv:cenv -> - v:TypedTree.Val -> - vval:ValInfo -> - env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv - val BindValsInModuleOrNamespace : - cenv:cenv -> - mval:LazyModuleInfo -> - env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv - val inline BindInternalValToUnknown : cenv:'a -> v:'b -> env:'c -> 'c - val inline BindInternalValsToUnknown : cenv:'a -> vs:'b -> env:'c -> 'c - val BindTypeVar : - tyv:TypedTree.Typar -> - typeinfo:TypeValueInfo -> - env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv - val BindTypeVarsToUnknown : - tps:TypedTree.Typar list -> - env:IncrementalOptimizationEnv -> IncrementalOptimizationEnv - val BindCcu : - TypedTree.CcuThunk -> - LazyModuleInfo -> - IncrementalOptimizationEnv -> - TcGlobals.TcGlobals -> IncrementalOptimizationEnv - val GetInfoForLocalValue : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - v:TypedTree.Val -> m:Range.range -> ValInfo - val TryGetInfoForCcu : - env:IncrementalOptimizationEnv -> - ccu:TypedTree.CcuThunk -> LazyModuleInfo option - val TryGetInfoForEntity : sv:ModuleInfo -> n:string -> ModuleInfo option - val TryGetInfoForPath : - sv:ModuleInfo -> p:string [] -> i:int -> ModuleInfo option - val TryGetInfoForNonLocalEntityRef : - env:IncrementalOptimizationEnv -> - nleref:TypedTree.NonLocalEntityRef -> ModuleInfo option - val GetInfoForNonLocalVal : - cenv:cenv -> - env:IncrementalOptimizationEnv -> vref:TypedTree.ValRef -> ValInfo - val GetInfoForVal : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - m:Range.range -> vref:TypedTree.ValRef -> ValInfo - val stripValue : _arg1:ExprValueInfo -> ExprValueInfo - val ( |StripConstValue|_| ) : ev:ExprValueInfo -> TypedTree.Const option - val ( |StripLambdaValue|_| ) : - ev:ExprValueInfo -> - (CompilerGlobalState.Unique * int * int * TypedTree.Expr * - TypedTree.TType) option - val destTupleValue : ev:ExprValueInfo -> ExprValueInfo [] option - val destRecdValue : ev:ExprValueInfo -> ExprValueInfo [] option - val ( |StripUnionCaseValue|_| ) : - ev:ExprValueInfo -> (TypedTree.UnionCaseRef * ExprValueInfo []) option - val mkBoolVal : g:TcGlobals.TcGlobals -> n:bool -> ExprValueInfo - val mkInt8Val : g:TcGlobals.TcGlobals -> n:sbyte -> ExprValueInfo - val mkInt16Val : g:TcGlobals.TcGlobals -> n:int16 -> ExprValueInfo - val mkInt32Val : g:TcGlobals.TcGlobals -> n:int32 -> ExprValueInfo - val mkInt64Val : g:TcGlobals.TcGlobals -> n:int64 -> ExprValueInfo - val mkUInt8Val : g:TcGlobals.TcGlobals -> n:byte -> ExprValueInfo - val mkUInt16Val : g:TcGlobals.TcGlobals -> n:uint16 -> ExprValueInfo - val mkUInt32Val : g:TcGlobals.TcGlobals -> n:uint32 -> ExprValueInfo - val mkUInt64Val : g:TcGlobals.TcGlobals -> n:uint64 -> ExprValueInfo - val ( |StripInt32Value|_| ) : _arg1:ExprValueInfo -> int32 option - val MakeValueInfoForValue : - g:TcGlobals.TcGlobals -> - m:Range.range -> - vref:TypedTree.ValRef -> vinfo:ExprValueInfo -> ExprValueInfo - val MakeValueInfoForRecord : - tcref:TypedTree.TyconRef -> argvals:ExprValueInfo [] -> ExprValueInfo - val MakeValueInfoForTuple : argvals:ExprValueInfo [] -> ExprValueInfo - val MakeValueInfoForUnionCase : - cspec:TypedTree.UnionCaseRef -> argvals:ExprValueInfo [] -> ExprValueInfo - val MakeValueInfoForConst : - c:TypedTree.Const -> ty:TypedTree.TType -> ExprValueInfo - val inline IntegerUnaryOp : - g:TcGlobals.TcGlobals -> - f8:(sbyte -> sbyte) -> - f16:(int16 -> int16) -> - f32:(int -> int) -> - f64:(int64 -> int64) -> - fu8:(byte -> byte) -> - fu16:(uint16 -> uint16) -> - fu32:(uint32 -> uint32) -> - fu64:(uint64 -> uint64) -> - a:ExprValueInfo -> ExprValueInfo option - val inline SignedIntegerUnaryOp : - g:TcGlobals.TcGlobals -> - f8:(sbyte -> sbyte) -> - f16:(int16 -> int16) -> - f32:(int32 -> int32) -> - f64:(int64 -> int64) -> a:ExprValueInfo -> ExprValueInfo option - val inline IntegerBinaryOp : - g:TcGlobals.TcGlobals -> - f8:(sbyte -> sbyte -> sbyte) -> - f16:(int16 -> int16 -> int16) -> - f32:(int -> int -> int) -> - f64:(int64 -> int64 -> int64) -> - fu8:(byte -> byte -> byte) -> - fu16:(uint16 -> uint16 -> uint16) -> - fu32:(uint32 -> uint32 -> uint32) -> - fu64:(uint64 -> uint64 -> uint64) -> - a:ExprValueInfo -> - b:ExprValueInfo -> ExprValueInfo option - val mkAssemblyCodeValueInfo : - g:TcGlobals.TcGlobals -> - instrs:AbstractIL.IL.ILInstr list -> - argvals:ExprValueInfo list -> - tys:TypedTree.TType list -> ExprValueInfo - [] - val localVarSize : int = 1 - val AddTotalSizes : l:Summary<'a> list -> int - val AddFunctionSizes : l:Summary<'a> list -> int - val OrEffects : l:Summary<'a> list -> bool - val OrTailcalls : l:Summary<'a> list -> bool - val OptimizeList : f:('a -> 'b * 'c) -> l:'a list -> 'b list * 'c list - val NoExprs : TypedTree.Expr list * Summary list - val CombineValueInfos : einfos:Summary<'a> list -> res:'b -> Summary<'b> - val CombineValueInfosUnknown : - einfos:Summary<'a> list -> Summary - val AbstractLazyModulInfoByHiding : - isAssemblyBoundary:bool -> - mhi:TypedTreeOps.SignatureHidingInfo -> - (LazyModuleInfo -> LazyModuleInfo) - val AbstractOptimizationInfoToEssentials : - (System.Lazy -> System.Lazy) - val AbstractExprInfoByVars : - boundVars:TypedTree.Val list * boundTyVars:TypedTree.Typar list -> - ivalue:ExprValueInfo -> ExprValueInfo - val RemapOptimizationInfo : - TcGlobals.TcGlobals -> - TypedTreeOps.Remap -> (LazyModuleInfo -> LazyModuleInfo) - val AbstractAndRemapModulInfo : - msg:string -> - g:TcGlobals.TcGlobals -> - m:Range.range -> - repackage:TypedTreeOps.SignatureRepackageInfo * - hidden:TypedTreeOps.SignatureHidingInfo -> - info:LazyModuleInfo -> LazyModuleInfo - [] - val suffixForVariablesThatMayNotBeEliminated : string = "$cont" - val IsTyFuncValRefExpr : _arg1:TypedTree.Expr -> bool - val IsSmallConstExpr : x:TypedTree.Expr -> bool - val ValueOfExpr : expr:TypedTree.Expr -> ExprValueInfo - val IsDiscardableEffectExpr : expr:TypedTree.Expr -> bool - val ValueIsUsedOrHasEffect : - cenv:cenv -> - fvs:(unit -> AbstractIL.Internal.Zset) -> - b:TypedTree.Binding * binfo:Summary<'a> -> bool - val SplitValuesByIsUsedOrHasEffect : - cenv:cenv -> - fvs:(unit -> AbstractIL.Internal.Zset) -> - x:(TypedTree.Binding * Summary<'a>) list -> - TypedTree.Binding list * Summary<'a> list - val IlAssemblyCodeInstrHasEffect : i:AbstractIL.IL.ILInstr -> bool - val IlAssemblyCodeHasEffect : instrs:AbstractIL.IL.ILInstr list -> bool - val ExprHasEffect : TcGlobals.TcGlobals -> TypedTree.Expr -> bool - val ExprsHaveEffect : g:TcGlobals.TcGlobals -> exprs:TypedTree.Exprs -> bool - val BindingsHaveEffect : - g:TcGlobals.TcGlobals -> binds:TypedTree.Bindings -> bool - val BindingHasEffect : - g:TcGlobals.TcGlobals -> bind:TypedTree.Binding -> bool - val OpHasEffect : - g:TcGlobals.TcGlobals -> m:Range.range -> op:TypedTree.TOp -> bool - val TryEliminateBinding : - cenv:cenv -> - _env:'a -> - TypedTree.Binding -> - e2:TypedTree.Expr -> _m:'b -> TypedTree.Expr option - val TryEliminateLet : - cenv:cenv -> - env:'a -> - bind:TypedTree.Binding -> - e2:TypedTree.Expr -> m:Range.range -> TypedTree.Expr * int - val ( |KnownValApp|_| ) : - expr:TypedTree.Expr -> - (TypedTree.ValRef * TypedTree.TType list * TypedTree.Expr list) option - val ( |TDBoolSwitch|_| ) : - dtree:TypedTree.DecisionTree -> - (TypedTree.Expr * bool * TypedTree.DecisionTree * TypedTree.DecisionTree * - Range.range) option - val ( |ConstantBoolTarget|_| ) : - target:TypedTree.DecisionTreeTarget -> bool option - val CountBoolLogicTree : - TypedTree.DecisionTreeTarget [] * int * int * bool -> - tree:TypedTree.DecisionTree -> int * int - val RewriteBoolLogicTree : - TypedTree.DecisionTreeTarget [] * TypedTree.DecisionTree * - TypedTree.DecisionTree * bool -> - tree:TypedTree.DecisionTree -> TypedTree.DecisionTree - val RewriteBoolLogicCase : - TypedTree.DecisionTreeTarget [] * TypedTree.DecisionTree * - TypedTree.DecisionTree * bool -> - TypedTree.DecisionTreeCase -> TypedTree.DecisionTreeCase - val CombineBoolLogic : expr:TypedTree.Expr -> TypedTree.Expr - val CanExpandStructuralBinding : v:TypedTree.Val -> bool - val ExprIsValue : _arg1:TypedTree.Expr -> bool - val MakeStructuralBindingTemp : - v:TypedTree.Val -> - i:'a -> - arg:TypedTree.Expr -> - argTy:TypedTree.TType -> TypedTree.Expr * TypedTree.Binding - val ExpandStructuralBindingRaw : - cenv:cenv -> expr:TypedTree.Expr -> TypedTree.Expr - val RearrangeTupleBindings : - expr:TypedTree.Expr -> - fin:(TypedTree.Expr -> TypedTree.Expr) -> TypedTree.Expr option - val ExpandStructuralBinding : - cenv:cenv -> expr:TypedTree.Expr -> TypedTree.Expr - val ( |QueryRun|_| ) : - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.TType option) option - val ( |MaybeRefTupled| ) : e:TypedTree.Expr -> TypedTree.Exprs - val ( |AnyInstanceMethodApp|_| ) : - e:TypedTree.Expr -> - (TypedTree.ValRef * TypedTree.TypeInst * TypedTree.Expr * - TypedTree.Exprs) option - val ( |InstanceMethodApp|_| ) : - g:TcGlobals.TcGlobals -> - expectedValRef:TypedTree.ValRef -> - e:TypedTree.Expr -> - (TypedTree.TypeInst * TypedTree.Expr * TypedTree.Exprs) option - val ( |QuerySourceEnumerable|_| ) : - g:TcGlobals.TcGlobals -> - _arg1:TypedTree.Expr -> (TypedTree.TType * TypedTree.Expr) option - val ( |QueryFor|_| ) : - g:TcGlobals.TcGlobals -> - _arg1:TypedTree.Expr -> - (TypedTree.TType * TypedTree.TType * TypedTree.TType * TypedTree.Expr * - TypedTree.Expr) option - val ( |QueryYield|_| ) : - g:TcGlobals.TcGlobals -> - _arg1:TypedTree.Expr -> - (TypedTree.TType * TypedTree.TType * TypedTree.Expr) option - val ( |QueryYieldFrom|_| ) : - g:TcGlobals.TcGlobals -> - _arg1:TypedTree.Expr -> - (TypedTree.TType * TypedTree.TType * TypedTree.Expr) option - val ( |QuerySelect|_| ) : - g:TcGlobals.TcGlobals -> - _arg1:TypedTree.Expr -> - (TypedTree.TType * TypedTree.TType * TypedTree.TType * TypedTree.Expr * - TypedTree.Expr) option - val ( |QueryZero|_| ) : - g:TcGlobals.TcGlobals -> - _arg1:TypedTree.Expr -> (TypedTree.TType * TypedTree.TType) option - val ( |AnyRefTupleTrans| ) : - e:TypedTree.Expr -> TypedTree.Exprs * (TypedTree.Exprs -> TypedTree.Expr) - val ( |AnyQueryBuilderOpTrans|_| ) : - g:TcGlobals.TcGlobals -> - _arg1:TypedTree.Expr -> - (TypedTree.Expr * (TypedTree.Expr -> TypedTree.Expr)) option - val tryRewriteToSeqCombinators : - g:TcGlobals.TcGlobals -> e:TypedTree.Expr -> TypedTree.Expr option - val TryDetectQueryQuoteAndRun : - cenv:cenv -> expr:TypedTree.Expr -> TypedTree.Expr option - val IsILMethodRefSystemStringConcat : mref:AbstractIL.IL.ILMethodRef -> bool - val IsILMethodRefSystemStringConcatArray : - mref:AbstractIL.IL.ILMethodRef -> bool - val OptimizeExpr : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - expr:TypedTree.Expr -> TypedTree.Expr * Summary - val OptimizeObjectExpr : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - ty:TypedTree.TType * baseValOpt:TypedTree.Val option * - basecall:TypedTree.Expr * overrides:TypedTree.ObjExprMethod list * - iimpls:(TypedTree.TType * TypedTree.ObjExprMethod list) list * - m:Range.range -> TypedTree.Expr * Summary - val OptimizeMethods : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - baseValOpt:TypedTree.Val option -> - methods:TypedTree.ObjExprMethod list -> - TypedTree.ObjExprMethod list * Summary list - val OptimizeMethod : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - baseValOpt:TypedTree.Val option -> - TypedTree.ObjExprMethod -> - TypedTree.ObjExprMethod * Summary - val OptimizeInterfaceImpls : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - baseValOpt:TypedTree.Val option -> - iimpls:(TypedTree.TType * TypedTree.ObjExprMethod list) list -> - (TypedTree.TType * TypedTree.ObjExprMethod list) list * - Summary list - val OptimizeInterfaceImpl : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - baseValOpt:TypedTree.Val option -> - ty:TypedTree.TType * overrides:TypedTree.ObjExprMethod list -> - (TypedTree.TType * TypedTree.ObjExprMethod list) * - Summary - val MakeOptimizedSystemStringConcatCall : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - m:Range.range -> - args:TypedTree.Exprs -> TypedTree.Expr * Summary - val OptimizeExprOp : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * - m:Range.range -> TypedTree.Expr * Summary - val OptimizeExprOpReductions : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - op:TypedTree.TOp * tyargs:TypedTree.TypeInst * args:TypedTree.Exprs * - m:Range.range -> TypedTree.Expr * Summary - val OptimizeExprOpReductionsAfter : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - op:TypedTree.TOp * tyargs:TypedTree.TypeInst * argsR:TypedTree.Exprs * - arginfos:Summary list * m:Range.range -> - TypedTree.Expr * Summary - val OptimizeExprOpFallback : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - op:TypedTree.TOp * tyargs:TypedTree.TypeInst * argsR:TypedTree.Exprs * - m:Range.range -> - arginfos:Summary list -> - valu:ExprValueInfo -> TypedTree.Expr * Summary - val OptimizeConst : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - expr:TypedTree.Expr -> - c:TypedTree.Const * m:Range.range * ty:TypedTree.TType -> - TypedTree.Expr * Summary - val TryOptimizeRecordFieldGet : - cenv:cenv -> - _env:IncrementalOptimizationEnv -> - e1info:Summary * TypedTree.RecdFieldRef * - _tinst:TypedTree.TypeInst * m:Range.range -> ExprValueInfo option - val TryOptimizeTupleFieldGet : - cenv:cenv -> - _env:IncrementalOptimizationEnv -> - _tupInfo:TypedTree.TupInfo * e1info:Summary * - tys:TypedTree.TypeInst * n:int * m:Range.range -> ExprValueInfo option - val TryOptimizeUnionCaseGet : - cenv:cenv -> - _env:IncrementalOptimizationEnv -> - e1info:Summary * cspec:TypedTree.UnionCaseRef * - _tys:TypedTree.TypeInst * n:int * m:Range.range -> - ExprValueInfo option - val OptimizeFastIntegerForLoop : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - spStart:SyntaxTree.DebugPointAtFor * v:TypedTree.Val * - e1:TypedTree.Expr * dir:TypedTree.ForLoopStyle * e2:TypedTree.Expr * - e3:TypedTree.Expr * m:Range.range -> - TypedTree.Expr * Summary - val OptimizeLetRec : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - binds:TypedTree.Bindings * bodyExpr:TypedTree.Expr * m:Range.range -> - TypedTree.Expr * Summary - val OptimizeLinearExpr : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - expr:TypedTree.Expr -> - contf:(TypedTree.Expr * Summary -> - TypedTree.Expr * Summary) -> - TypedTree.Expr * Summary - val OptimizeTryFinally : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - spTry:SyntaxTree.DebugPointAtTry * - spFinally:SyntaxTree.DebugPointAtFinally * e1:TypedTree.Expr * - e2:TypedTree.Expr * m:Range.range * ty:TypedTree.TType -> - TypedTree.Expr * Summary - val OptimizeTryWith : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - e1:TypedTree.Expr * vf:TypedTree.Val * ef:TypedTree.Expr * - vh:TypedTree.Val * eh:TypedTree.Expr * m:Range.range * - ty:TypedTree.TType * spTry:SyntaxTree.DebugPointAtTry * - spWith:SyntaxTree.DebugPointAtWith -> - TypedTree.Expr * Summary - val OptimizeWhileLoop : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - spWhile:SyntaxTree.DebugPointAtWhile * - marker:TypedTree.SpecialWhileLoopMarker * e1:TypedTree.Expr * - e2:TypedTree.Expr * m:Range.range -> - TypedTree.Expr * Summary - val OptimizeTraitCall : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - traitInfo:TypedTree.TraitConstraintInfo * args:TypedTree.Exprs * - m:Range.range -> TypedTree.Expr * Summary - val TryOptimizeVal : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - mustInline:bool * valInfoForVal:ExprValueInfo * m:Range.range -> - TypedTree.Expr option - val TryOptimizeValInfo : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - m:Range.range -> vinfo:Summary -> TypedTree.Expr option - val AddValEqualityInfo : - g:TcGlobals.TcGlobals -> - m:Range.range -> - v:TypedTree.ValRef -> - info:Summary -> Summary - val OptimizeVal : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - expr:TypedTree.Expr -> - v:TypedTree.ValRef * m:Range.range -> - TypedTree.Expr * Summary - val StripToNominalTyconRef : - cenv:cenv -> ty:TypedTree.TType -> TypedTree.TyconRef * TypedTree.TypeInst - val CanDevirtualizeApplication : - cenv:cenv -> - v:TypedTree.ValRef -> - vref:TypedTree.ValRef -> ty:TypedTree.TType -> args:'a list -> bool - val TakeAddressOfStructArgumentIfNeeded : - cenv:cenv -> - vref:TypedTree.ValRef -> - ty:TypedTree.TType -> - args:TypedTree.Expr list -> - m:Range.range -> - (TypedTree.Expr -> TypedTree.Expr) * TypedTree.Expr list - val DevirtualizeApplication : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - vref:TypedTree.ValRef -> - ty:TypedTree.TType -> - tyargs:TypedTree.TType list -> - args:TypedTree.Expr list -> - m:Range.range -> TypedTree.Expr * Summary - val TryDevirtualizeApplication : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - f:TypedTree.Expr * tyargs:TypedTree.TType list * - args:TypedTree.Expr list * m:Range.range -> - (TypedTree.Expr * Summary) option - val TryInlineApplication : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - finfo:Summary -> - tyargs:TypedTree.TType list * args:TypedTree.Expr list * - m:Range.range -> (TypedTree.Expr * Summary) option - val OptimizeApplication : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - f0:TypedTree.Expr * f0ty:TypedTree.TType * tyargs:TypedTree.TypeInst * - args:TypedTree.Exprs * m:Range.range -> - TypedTree.Expr * Summary - val OptimizeLambdas : - vspec:TypedTree.Val option -> - cenv:cenv -> - env:IncrementalOptimizationEnv -> - topValInfo:TypedTree.ValReprInfo -> - e:TypedTree.Expr -> - ety:TypedTree.TType -> TypedTree.Expr * Summary - val OptimizeExprsThenReshapeAndConsiderSplits : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - exprs:(ExprValueInfo * TypedTree.Expr) list -> - TypedTree.Exprs * Summary list - val OptimizeExprsThenConsiderSplits : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - exprs:TypedTree.Exprs -> TypedTree.Exprs * Summary list - val OptimizeExprThenReshapeAndConsiderSplit : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - shape:ExprValueInfo * e:TypedTree.Expr -> - TypedTree.Expr * Summary - val OptimizeDecisionTreeTargets : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - m:Range.range -> - targets:TypedTree.DecisionTreeTarget [] -> - TypedTree.DecisionTreeTarget list * Summary list - val ReshapeExpr : - cenv:cenv -> shape:ExprValueInfo * e:TypedTree.Expr -> TypedTree.Expr - val OptimizeExprThenConsiderSplit : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - e:TypedTree.Expr -> TypedTree.Expr * Summary - val ComputeSplitToMethodCondition : - flag:bool -> - threshold:int -> - cenv:cenv -> - env:IncrementalOptimizationEnv -> - e:TypedTree.Expr * einfo:Summary<'b> -> bool - val ConsiderSplitToMethod : - flag:bool -> - threshold:int -> - cenv:cenv -> - env:IncrementalOptimizationEnv -> - e:TypedTree.Expr * einfo:Summary -> - TypedTree.Expr * Summary - val OptimizeMatch : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - spMatch:SyntaxTree.DebugPointForBinding * exprm:Range.range * - dtree:TypedTree.DecisionTree * - targets:TypedTree.DecisionTreeTarget array * m:Range.range * - ty:TypedTree.TType -> TypedTree.Expr * Summary - val OptimizeMatchPart2 : - cenv:cenv -> - spMatch:SyntaxTree.DebugPointForBinding * exprm:Range.range * - dtreeR:TypedTree.DecisionTree * - targetsR:TypedTree.DecisionTreeTarget list * - dinfo:Summary * tinfos:Summary list * - m:Range.range * ty:TypedTree.TType -> - TypedTree.Expr * Summary - val CombineMatchInfos : - dinfo:Summary<'c> -> tinfo:Summary<'d> -> Summary - val RebuildOptimizedMatch : - spMatch:SyntaxTree.DebugPointForBinding * exprm:Range.range * - m:Range.range * ty:TypedTree.TType * dtree:TypedTree.DecisionTree * - tgs:TypedTree.DecisionTreeTarget list * dinfo:Summary * - tinfos:Summary list -> - TypedTree.Expr * Summary - val OptimizeDecisionTreeTarget : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - _m:Range.range -> - TypedTree.DecisionTreeTarget -> - TypedTree.DecisionTreeTarget * Summary - val OptimizeDecisionTree : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - m:Range.range -> - x:TypedTree.DecisionTree -> - TypedTree.DecisionTree * Summary - val TryOptimizeDecisionTreeTest : - cenv:cenv -> - test:TypedTree.DecisionTreeTest -> vinfo:ExprValueInfo -> bool option - val OptimizeSwitch : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - e:TypedTree.Expr * cases:TypedTree.DecisionTreeCase list * - dflt:TypedTree.DecisionTree option * m:Range.range -> - TypedTree.DecisionTree * Summary - val OptimizeSwitchFallback : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - eR:TypedTree.Expr * einfo:Summary * - cases:TypedTree.DecisionTreeCase list * - dflt:TypedTree.DecisionTree option * m:Range.range -> - TypedTree.DecisionTree * Summary - val OptimizeBinding : - cenv:cenv -> - isRec:bool -> - env:IncrementalOptimizationEnv -> - TypedTree.Binding -> - (TypedTree.Binding * Summary) * - IncrementalOptimizationEnv - val OptimizeBindings : - cenv:cenv -> - isRec:bool -> - env:IncrementalOptimizationEnv -> - xs:TypedTree.Bindings -> - (TypedTree.Binding * Summary) list * - IncrementalOptimizationEnv - val OptimizeModuleExpr : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - x:TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig * LazyModuleInfo - val mkValBind : bind:TypedTree.Binding -> info:'e -> TypedTree.ValRef * 'e - val OptimizeModuleDef : - cenv:cenv -> - env:IncrementalOptimizationEnv * - bindInfosColl:(TypedTree.Binding * Summary) list list -> - x:TypedTree.ModuleOrNamespaceExpr -> - (TypedTree.ModuleOrNamespaceExpr * System.Lazy) * - (IncrementalOptimizationEnv * - (TypedTree.Binding * Summary) list list) - val OptimizeModuleBindings : - cenv:cenv -> - env:IncrementalOptimizationEnv * - bindInfosColl:(TypedTree.Binding * Summary) list list -> - xs:TypedTree.ModuleOrNamespaceBinding list -> - (TypedTree.ModuleOrNamespaceBinding * - Choice<(TypedTree.Binding * Summary), - (string * LazyModuleInfo)>) list * - (IncrementalOptimizationEnv * - (TypedTree.Binding * Summary) list list) - val OptimizeModuleBinding : - cenv:cenv -> - env:IncrementalOptimizationEnv * - bindInfosColl:(TypedTree.Binding * Summary) list list -> - x:TypedTree.ModuleOrNamespaceBinding -> - (TypedTree.ModuleOrNamespaceBinding * - Choice<(TypedTree.Binding * Summary), - (string * LazyModuleInfo)>) * - (IncrementalOptimizationEnv * - (TypedTree.Binding * Summary) list list) - val OptimizeModuleDefs : - cenv:cenv -> - env:IncrementalOptimizationEnv * - bindInfosColl:(TypedTree.Binding * Summary) list list -> - defs:TypedTree.ModuleOrNamespaceExpr list -> - (TypedTree.ModuleOrNamespaceExpr list * System.Lazy) * - (IncrementalOptimizationEnv * - (TypedTree.Binding * Summary) list list) - val OptimizeImplFileInternal : - cenv:cenv -> - env:IncrementalOptimizationEnv -> - isIncrementalFragment:bool -> - hidden:TypedTreeOps.SignatureHidingInfo -> - TypedTree.TypedImplFile -> - IncrementalOptimizationEnv * TypedTree.TypedImplFile * - LazyModuleInfo * TypedTreeOps.SignatureHidingInfo - val OptimizeImplFile : - OptimizationSettings * TypedTree.CcuThunk * TcGlobals.TcGlobals * - ConstraintSolver.TcValF * Import.ImportMap * IncrementalOptimizationEnv * - isIncrementalFragment:bool * emitTailcalls:bool * - TypedTreeOps.SignatureHidingInfo * TypedTree.TypedImplFile -> - (IncrementalOptimizationEnv * TypedTree.TypedImplFile * LazyModuleInfo * - TypedTreeOps.SignatureHidingInfo) * - (bool -> TypedTree.Expr -> TypedTree.Expr) - val p_ExprValueInfo : - x:ExprValueInfo -> st:TypedTreePickle.WriterState -> unit - val p_ValInfo : v:ValInfo -> st:TypedTreePickle.WriterState -> unit - val p_ModuleInfo : x:ModuleInfo -> st:TypedTreePickle.WriterState -> unit - val p_LazyModuleInfo : - x:LazyModuleInfo -> st:TypedTreePickle.WriterState -> unit - val p_CcuOptimizationInfo : - LazyModuleInfo -> TypedTreePickle.WriterState -> unit - val u_ExprInfo : st:TypedTreePickle.ReaderState -> ExprValueInfo - val u_ValInfo : st:TypedTreePickle.ReaderState -> ValInfo - val u_ModuleInfo : st:TypedTreePickle.ReaderState -> ModuleInfo - val u_LazyModuleInfo : st:TypedTreePickle.ReaderState -> LazyModuleInfo - val u_CcuOptimizationInfo : TypedTreePickle.ReaderState -> LazyModuleInfo - end - -namespace FSharp.Compiler - module internal Detuple = begin - val ( |TyappAndApp|_| ) : - e:TypedTree.Expr -> - (TypedTree.Expr * TypedTree.TType * TypedTree.TType list * - TypedTree.Exprs * Range.range) option - module GlobalUsageAnalysis = begin - val bindAccBounds : - vals:AbstractIL.Internal.Zset<'a> -> - _isInDTree:'b * v:'a -> AbstractIL.Internal.Zset<'a> - val GetValsBoundInExpr : - TypedTree.Expr -> AbstractIL.Internal.Zset - type accessor = | TupleGet of int * TypedTree.TType list - type Results = - { Uses: - AbstractIL.Internal.Zmap - Defns: AbstractIL.Internal.Zmap - DecisionTreeBindings: AbstractIL.Internal.Zset - RecursiveBindings: - AbstractIL.Internal.Zmap - TopLevelBindings: AbstractIL.Internal.Zset - IterationIsAtTopLevel: bool } - val z0 : Results - val logUse : - f:TypedTree.Val -> - accessor list * TypedTree.TType list * TypedTree.Expr list -> - z:Results -> Results - val logBinding : z:Results -> isInDTree:bool * v:TypedTree.Val -> Results - val logNonRecBinding : z:Results -> bind:TypedTree.Binding -> Results - val logRecBindings : z:Results -> binds:TypedTree.Bindings -> Results - val foldUnderLambda : - f:(Results -> 'a -> Results) -> z:Results -> x:'a -> Results - val UsageFolders : - g:TcGlobals.TcGlobals -> TypedTreeOps.ExprFolder - val GetUsageInfoOfImplFile : - TcGlobals.TcGlobals -> TypedTree.TypedImplFile -> Results - end - val internalError : str:string -> 'a - val mkLocalVal : - m:Range.range -> - name:string -> - ty:TypedTree.TType -> - topValInfo:TypedTree.ValReprInfo option -> TypedTree.Val - type TupleStructure = - | UnknownTS - | TupleTS of TupleStructure list - val ValReprInfoForTS : ts:TupleStructure -> TypedTree.ArgReprInfo list list - val andTS : ts:TupleStructure -> tsB:TupleStructure -> TupleStructure - val checkTS : _arg1:TupleStructure -> TupleStructure - val uncheckedExprTS : expr:TypedTree.Expr -> TupleStructure - val uncheckedTypeTS : - g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> TupleStructure - val exprTS : exprs:TypedTree.Expr -> TupleStructure - val typeTS : g:TcGlobals.TcGlobals -> tys:TypedTree.TType -> TupleStructure - val rebuildTS : - g:TcGlobals.TcGlobals -> - m:Range.range -> - ts:TupleStructure -> vs:TypedTree.Val list -> TypedTree.Expr - type CallPattern = TupleStructure list - val callPatternOrder : (CallPattern -> CallPattern -> int) - val argsCP : exprs:TypedTree.Expr list -> TupleStructure list - val noArgsCP : 'a list - val inline isTrivialCP : xs:'a list -> bool - val minimalCallPattern : - callPattern:TupleStructure list -> TupleStructure list - val commonCallPattern : - callPatterns:TupleStructure list list -> TupleStructure list - val siteCP : - _accessors:'a * _inst:'b * args:TypedTree.Expr list -> TupleStructure list - val sitesCPs : - sites:('a * 'b * TypedTree.Expr list) list -> TupleStructure list list - type TransformedFormal = - | SameArg - | NewArgs of TypedTree.Val list * TypedTree.Expr - type Transform = - { transformCallPattern: CallPattern - transformedFormals: TransformedFormal list - transformedVal: TypedTree.Val } - val mkTransform : - g:TcGlobals.TcGlobals -> - f:TypedTree.Val -> - m:Range.range -> - tps:TypedTree.Typar list -> - x1Ntys:TypedTree.TType list -> - rty:TypedTree.TType -> - callPattern:TupleStructure list * - tyfringes:(TypedTree.TType list * TypedTree.Val list) list -> - Transform - val zipTupleStructureAndType : - g:TcGlobals.TcGlobals -> - ts:TupleStructure -> - ty:TypedTree.TType -> TupleStructure * TypedTree.TType list - val zipTupleStructuresAndTypes : - g:TcGlobals.TcGlobals -> - tss:TupleStructure list -> - tys:TypedTree.TTypes -> TupleStructure list * TypedTree.TType list - val zipCallPatternArgTys : - m:Range.range -> - g:TcGlobals.TcGlobals -> - callPattern:TupleStructure list -> - vss:TypedTree.Val list list -> - TupleStructure list * - (TypedTree.TType list * TypedTree.Val list) list - val decideFormalSuggestedCP : - g:TcGlobals.TcGlobals -> - z:GlobalUsageAnalysis.Results -> - tys:TypedTree.TType list -> - vss:TypedTree.Val list list -> TupleStructure list - val decideTransform : - g:TcGlobals.TcGlobals -> - z:GlobalUsageAnalysis.Results -> - v:TypedTree.Val -> - callPatterns:TupleStructure list list -> - m:Range.range * tps:TypedTree.Typar list * - vss:TypedTree.Val list list * rty:TypedTree.TType -> - (TypedTree.Val * Transform) option - val eligibleVal : - g:TcGlobals.TcGlobals -> m:Range.range -> v:TypedTree.Val -> bool - val determineTransforms : - g:TcGlobals.TcGlobals -> - z:GlobalUsageAnalysis.Results -> - AbstractIL.Internal.Zmap - type penv = - { transforms: AbstractIL.Internal.Zmap - ccu: TypedTree.CcuThunk - g: TcGlobals.TcGlobals } - val hasTransfrom : penv:penv -> f:TypedTree.Val -> Transform option - type env = - { eg: TcGlobals.TcGlobals - prefix: string - m: Range.range } - with - override ToString : unit -> string - end - val suffixE : env:env -> s:string -> env - val rangeE : env:env -> m:Range.range -> env - val push : b:'a -> bs:'a list -> 'a list - val pushL : xs:'a list -> bs:'a list -> 'a list - val newLocal : - env:env -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val newLocalN : - env:env -> i:'a -> ty:TypedTree.TType -> TypedTree.Val * TypedTree.Expr - val noEffectExpr : - env:env -> - bindings:TypedTree.Binding list -> - x:TypedTree.Expr -> TypedTree.Binding list * TypedTree.Expr - val buildProjections : - env:env -> - bindings:TypedTree.Binding list -> - x:TypedTree.Expr -> - xtys:TypedTree.TType list -> - TypedTree.Binding list * TypedTree.Expr list - val collapseArg : - env:env -> - bindings:TypedTree.Binding list -> - ts:TupleStructure -> - x:TypedTree.Expr -> TypedTree.Binding list * TypedTree.Expr list - val collapseArgs : - env:env -> - bindings:TypedTree.Binding list -> - n:int -> - callPattern:TupleStructure list -> - args:TypedTree.Exprs -> - TypedTree.Binding list * TypedTree.Expr list - val mkLets : - binds:TypedTree.Binding list -> body:TypedTree.Expr -> TypedTree.Expr - val fixupApp : - penv:penv -> - fx:TypedTree.Expr * fty:TypedTree.TType * tys:TypedTree.TypeInst * - args:TypedTree.Exprs * m:Range.range -> TypedTree.Expr - val transFormal : - ybi:TransformedFormal -> xi:TypedTree.Val list -> TypedTree.Val list list - val transRebind : - ybi:TransformedFormal -> xi:TypedTree.Val list -> TypedTree.Binding list - val passBind : penv:penv -> TypedTree.Binding -> TypedTree.Binding - val passBinds : - penv:penv -> binds:TypedTree.Binding list -> TypedTree.Binding list - val passBindRhs : - conv:(TypedTree.Expr -> TypedTree.Expr) -> - TypedTree.Binding -> TypedTree.Binding - val preInterceptExpr : - penv:penv -> - conv:(TypedTree.Expr -> TypedTree.Expr) -> - expr:TypedTree.Expr -> TypedTree.Expr option - val postTransformExpr : - penv:penv -> expr:TypedTree.Expr -> TypedTree.Expr option - val passImplFile : - penv:penv -> assembly:TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val DetupleImplFile : - TypedTree.CcuThunk -> - TcGlobals.TcGlobals -> - TypedTree.TypedImplFile -> TypedTree.TypedImplFile - end - -namespace FSharp.Compiler - module internal InnerLambdasToTopLevelFuncs = begin - val verboseTLR : bool - val internalError : str:string -> 'a - module Zmap = begin - val force : - k:'a -> - mp:AbstractIL.Internal.Zmap<'a,'b> -> - str:string * soK:('a -> string) -> 'b - end - type Tree<'T> = - | TreeNode of Tree<'T> list - | LeafNode of 'T - val fringeTR : tr:Tree<'a> -> 'a list - val emptyTR : Tree<'a> - val destApp : - f:TypedTree.Expr * fty:TypedTree.TType * tys:TypedTree.TType list * - args:'a * m:'b -> - TypedTree.Expr * TypedTree.TType * TypedTree.TType list * 'a * 'b - val showTyparSet : tps:AbstractIL.Internal.Zset -> string - val isDelayedRepr : f:TypedTree.Val -> e:TypedTree.Expr -> bool - val mkLocalNameTypeArity : - compgen:bool -> - m:Range.range -> - name:string -> - ty:TypedTree.TType -> - topValInfo:TypedTree.ValReprInfo option -> TypedTree.Val - val GetValsBoundUnderMustInline : - xinfo:Detuple.GlobalUsageAnalysis.Results -> - AbstractIL.Internal.Zset - val IsRefusedTLR : g:TcGlobals.TcGlobals -> f:TypedTree.Val -> bool - val IsMandatoryTopLevel : f:TypedTree.Val -> bool - val IsMandatoryNonTopLevel : - g:TcGlobals.TcGlobals -> f:TypedTree.Val -> bool - module Pass1_DetermineTLRAndArities = begin - val GetMaxNumArgsAtUses : - xinfo:Detuple.GlobalUsageAnalysis.Results -> f:TypedTree.Val -> int - val SelectTLRVals : - g:TcGlobals.TcGlobals -> - xinfo:Detuple.GlobalUsageAnalysis.Results -> - f:TypedTree.Val -> e:TypedTree.Expr -> (TypedTree.Val * int) option - val IsValueRecursionFree : - xinfo:Detuple.GlobalUsageAnalysis.Results -> f:TypedTree.Val -> bool - val DumpArity : arityM:AbstractIL.Internal.Zmap -> unit - val DetermineTLRAndArities : - g:TcGlobals.TcGlobals -> - expr:TypedTree.TypedImplFile -> - AbstractIL.Internal.Zset * - AbstractIL.Internal.Zset * - AbstractIL.Internal.Zmap - end - type BindingGroupSharingSameReqdItems = - class - new : bindings:TypedTree.Bindings -> BindingGroupSharingSameReqdItems - member Contains : v:TypedTree.Val -> bool - override ToString : unit -> string - member IsEmpty : bool - member Pairs : (TypedTree.Val * BindingGroupSharingSameReqdItems) list - member Vals : TypedTree.Vals - end - val fclassOrder : - System.Collections.Generic.IComparer - type ReqdItem = - | ReqdSubEnv of TypedTree.Val - | ReqdVal of TypedTree.Val - with - override ToString : unit -> string - end - val reqdItemOrder : System.Collections.Generic.IComparer - type ReqdItemsForDefn = - { reqdTypars: AbstractIL.Internal.Zset - reqdItems: AbstractIL.Internal.Zset - m: Range.range } - with - static member - Initial : typars:TypedTree.Typar list -> - m:Range.range -> ReqdItemsForDefn - member - Extend : typars:TypedTree.Typar list * items:ReqdItem list -> - ReqdItemsForDefn - override ToString : unit -> string - member ReqdSubEnvs : TypedTree.Val list - member ReqdVals : TypedTree.Val list - end - type Generators = AbstractIL.Internal.Zset - val IsArityMet : - vref:TypedTree.ValRef -> - wf:int -> tys:TypedTree.TypeInst -> args:'a list -> bool - module Pass2_DetermineReqdItems = begin - type state = - { stack: - (BindingGroupSharingSameReqdItems * Generators * ReqdItemsForDefn) list - reqdItemsMap: - AbstractIL.Internal.Zmap - fclassM: - AbstractIL.Internal.Zmap - revDeclist: BindingGroupSharingSameReqdItems list - recShortCallS: AbstractIL.Internal.Zset } - val state0 : state - val PushFrame : - fclass:BindingGroupSharingSameReqdItems -> - reqdTypars0:TypedTree.Typar list * reqdVals0:Generators * - m:Range.range -> state:state -> state - val SaveFrame : - fclass:BindingGroupSharingSameReqdItems -> state:state -> state - val LogRequiredFrom : - gv:TypedTree.Val -> items:ReqdItem list -> state:state -> state - val LogShortCall : gv:TypedTree.Val -> state:state -> state - val FreeInBindings : bs:TypedTree.Binding list -> TypedTree.FreeVars - val ExprEnvIntercept : - tlrS:AbstractIL.Internal.Zset * - arityM:AbstractIL.Internal.Zmap -> - recurseF:(state -> TypedTree.Expr -> state) -> - noInterceptF:(state -> TypedTree.Expr -> state) -> - z:state -> expr:TypedTree.Expr -> state - val CloseReqdTypars : - fclassM:AbstractIL.Internal.Zmap -> - reqdItemsMap:AbstractIL.Internal.Zmap<'a,ReqdItemsForDefn> -> - AbstractIL.Internal.Zmap<'a,ReqdItemsForDefn> - val DumpReqdValMap : - reqdItemsMap:seq> -> unit - val DetermineReqdItems : - tlrS:AbstractIL.Internal.Zset * - arityM:AbstractIL.Internal.Zmap -> - expr:TypedTree.TypedImplFile -> - AbstractIL.Internal.Zmap * - AbstractIL.Internal.Zmap * - BindingGroupSharingSameReqdItems list * - AbstractIL.Internal.Zset - end - type PackedReqdItems = - { ep_etps: TypedTree.Typars - ep_aenvs: TypedTree.Val list - ep_pack: TypedTree.Bindings - ep_unpack: TypedTree.Bindings } - exception AbortTLR of Range.range - val FlatEnvPacks : - g:TcGlobals.TcGlobals -> - fclassM:AbstractIL.Internal.Zmap -> - topValS:AbstractIL.Internal.Zset -> - declist:#BindingGroupSharingSameReqdItems list -> - reqdItemsMap:AbstractIL.Internal.Zmap -> - AbstractIL.Internal.Zmap - val DumpEnvPackM : - g:TcGlobals.TcGlobals -> - envPackM:seq> -> - unit - val ChooseReqdItemPackings : - g:TcGlobals.TcGlobals -> - fclassM:AbstractIL.Internal.Zmap -> - topValS:AbstractIL.Internal.Zset -> - declist:#BindingGroupSharingSameReqdItems list -> - reqdItemsMap:AbstractIL.Internal.Zmap -> - AbstractIL.Internal.Zmap - val MakeSimpleArityInfo : - tps:TypedTree.Typar list -> n:int -> TypedTree.ValReprInfo - val CreateNewValuesForTLR : - g:TcGlobals.TcGlobals -> - tlrS:AbstractIL.Internal.Zset -> - arityM:AbstractIL.Internal.Zmap -> - fclassM:AbstractIL.Internal.Zmap -> - envPackM:AbstractIL.Internal.Zmap<'a,PackedReqdItems> -> - AbstractIL.Internal.Zmap - module Pass4_RewriteAssembly = begin - [] - type RewriteContext = - { ccu: TypedTree.CcuThunk - g: TcGlobals.TcGlobals - tlrS: AbstractIL.Internal.Zset - topValS: AbstractIL.Internal.Zset - arityM: AbstractIL.Internal.Zmap - fclassM: - AbstractIL.Internal.Zmap - recShortCallS: AbstractIL.Internal.Zset - envPackM: - AbstractIL.Internal.Zmap - fHatM: AbstractIL.Internal.Zmap } - type IsRecursive = - | IsRec - | NotRec - type LiftedDeclaration = IsRecursive * TypedTree.Bindings - type RewriteState = - { rws_mustinline: bool - rws_innerLevel: int - rws_preDecs: Tree } - val rewriteState0 : RewriteState - val EnterInner : z:RewriteState -> RewriteState - val ExitInner : z:RewriteState -> RewriteState - val EnterMustInline : - b:bool -> - z:RewriteState -> - f:(RewriteState -> 'a * RewriteState) -> RewriteState * 'a - val ExtractPreDecs : - z:RewriteState -> LiftedDeclaration list * RewriteState - val PopPreDecs : z:RewriteState -> RewriteState * Tree - val SetPreDecs : - z:RewriteState -> pdt:Tree -> RewriteState - val LiftTopBinds : _isRec:'a -> _penv:'b -> z:'c -> binds:'d -> 'c * 'd - val MakePreDec : - m:Range.range -> - isRec:IsRecursive * binds:TypedTree.Bindings -> - expr:TypedTree.Expr -> TypedTree.Expr - val MakePreDecs : - m:Range.range -> - preDecs:(IsRecursive * TypedTree.Bindings) list -> - expr:TypedTree.Expr -> TypedTree.Expr - val RecursivePreDecs : - pdsA:Tree<'a * 'b list> -> - pdsB:Tree<'a * 'b list> -> Tree - val ConvertBind : - g:TcGlobals.TcGlobals -> TypedTree.Binding -> TypedTree.Binding - val TransTLRBindings : - penv:RewriteContext -> - binds:TypedTree.Bindings -> - TypedTree.Binding list * TypedTree.Binding list - val GetAEnvBindings : - penv:RewriteContext -> - fc:BindingGroupSharingSameReqdItems -> TypedTree.Binding list - val TransBindings : - xisRec:IsRecursive -> - penv:RewriteContext -> - binds:TypedTree.Bindings -> - TypedTree.Binding list * TypedTree.Binding list - val TransApp : - penv:RewriteContext -> - fx:TypedTree.Expr * fty:TypedTree.TType * tys:TypedTree.TypeInst * - args:TypedTree.Expr list * m:Range.range -> TypedTree.Expr - val TransExpr : - penv:RewriteContext -> - z:RewriteState -> expr:TypedTree.Expr -> TypedTree.Expr * RewriteState - val TransLinearExpr : - penv:RewriteContext -> - z:RewriteState -> - expr:TypedTree.Expr -> - contf:(TypedTree.Expr * RewriteState -> - TypedTree.Expr * RewriteState) -> - TypedTree.Expr * RewriteState - val TransMethod : - penv:RewriteContext -> - z:RewriteState -> - TypedTree.ObjExprMethod -> TypedTree.ObjExprMethod * RewriteState - val TransBindingRhs : - penv:RewriteContext -> - z:RewriteState -> - TypedTree.Binding -> TypedTree.Binding * RewriteState - val TransDecisionTree : - penv:RewriteContext -> - z:RewriteState -> - x:TypedTree.DecisionTree -> TypedTree.DecisionTree * RewriteState - val TransDecisionTreeTarget : - penv:RewriteContext -> - z:RewriteState -> - TypedTree.DecisionTreeTarget -> - TypedTree.DecisionTreeTarget * RewriteState - val TransValBinding : - penv:RewriteContext -> - z:RewriteState -> - bind:TypedTree.Binding -> TypedTree.Binding * RewriteState - val TransValBindings : - penv:RewriteContext -> - z:RewriteState -> - binds:TypedTree.Binding list -> - TypedTree.Binding list * RewriteState - val TransModuleExpr : - penv:RewriteContext -> - z:RewriteState -> - x:TypedTree.ModuleOrNamespaceExprWithSig -> - TypedTree.ModuleOrNamespaceExprWithSig * RewriteState - val TransModuleDefs : - penv:RewriteContext -> - z:RewriteState -> - x:TypedTree.ModuleOrNamespaceExpr list -> - TypedTree.ModuleOrNamespaceExpr list * RewriteState - val TransModuleDef : - penv:RewriteContext -> - z:RewriteState -> - x:TypedTree.ModuleOrNamespaceExpr -> - TypedTree.ModuleOrNamespaceExpr * RewriteState - val TransModuleBindings : - penv:RewriteContext -> - z:RewriteState -> - binds:TypedTree.ModuleOrNamespaceBinding list -> - TypedTree.ModuleOrNamespaceBinding list * RewriteState - val TransModuleBinding : - penv:RewriteContext -> - z:RewriteState -> - x:TypedTree.ModuleOrNamespaceBinding -> - TypedTree.ModuleOrNamespaceBinding * RewriteState - val TransImplFile : - penv:RewriteContext -> - z:RewriteState -> - TypedTree.TypedImplFile -> TypedTree.TypedImplFile * RewriteState - end - val RecreateUniqueBounds : - g:TcGlobals.TcGlobals -> - expr:TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val MakeTLRDecisions : - TypedTree.CcuThunk -> - TcGlobals.TcGlobals -> - TypedTree.TypedImplFile -> TypedTree.TypedImplFile - end - -namespace FSharp.Compiler - module internal LowerCallsAndSeqs = begin - val InterceptExpr : - g:TcGlobals.TcGlobals -> - cont:(TypedTree.Expr -> TypedTree.Expr) -> - expr:TypedTree.Expr -> TypedTree.Expr option - val LowerImplFile : - g:TcGlobals.TcGlobals -> - assembly:TypedTree.TypedImplFile -> TypedTree.TypedImplFile - val mkLambdaNoType : - g:TcGlobals.TcGlobals -> - m:Range.range -> uv:TypedTree.Val -> e:TypedTree.Expr -> TypedTree.Expr - val callNonOverloadedMethod : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - m:Range.range -> - methName:string -> - ty:TypedTree.TType -> args:TypedTree.Exprs -> TypedTree.Expr - type LoweredSeqFirstPhaseResult = - { phase2: - TypedTree.ValRef * TypedTree.ValRef * TypedTree.ValRef * - Map -> - TypedTree.Expr * TypedTree.Expr * TypedTree.Expr - entryPoints: int list - significantClose: bool - stateVars: TypedTree.ValRef list - asyncVars: TypedTree.FreeVars } - val isVarFreeInExpr : v:TypedTree.Val -> e:TypedTree.Expr -> bool - val ( |Seq|_| ) : - g:TcGlobals.TcGlobals -> - expr:TypedTree.Expr -> (TypedTree.Expr * TypedTree.TType) option - val IsPossibleSequenceExpr : - g:TcGlobals.TcGlobals -> overallExpr:TypedTree.Expr -> bool - val ConvertSequenceExprToObject : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - overallExpr:TypedTree.Expr -> - (TypedTree.ValRef * TypedTree.ValRef * TypedTree.ValRef * - TypedTree.ValRef list * TypedTree.Expr * TypedTree.Expr * - TypedTree.Expr * TypedTree.TType * Range.range) option - end - -namespace FSharp.Compiler - module internal AutoBox = begin - type cenv = - { g: TcGlobals.TcGlobals - amap: Import.ImportMap } - with - override ToString : unit -> string - end - val DecideEscapes : - syntacticArgs:TypedTree.Val list -> - body:TypedTree.Expr -> AbstractIL.Internal.Zset - val DecideLambda : - exprF:(AbstractIL.Internal.Zset -> TypedTree.Expr -> - AbstractIL.Internal.Zset) option -> - cenv:cenv -> - topValInfo:TypedTree.ValReprInfo -> - expr:TypedTree.Expr -> - ety:TypedTree.TType -> - z:AbstractIL.Internal.Zset -> - AbstractIL.Internal.Zset - val DecideExprOp : - exprF:(AbstractIL.Internal.Zset -> TypedTree.Expr -> - AbstractIL.Internal.Zset) -> - noInterceptF:(AbstractIL.Internal.Zset -> - TypedTree.Expr -> - AbstractIL.Internal.Zset) -> - z:AbstractIL.Internal.Zset -> - expr:TypedTree.Expr -> - op:TypedTree.TOp * tyargs:'a list * args:TypedTree.Expr list -> - AbstractIL.Internal.Zset - val DecideExpr : - cenv:cenv -> - exprF:(AbstractIL.Internal.Zset -> TypedTree.Expr -> - AbstractIL.Internal.Zset) -> - noInterceptF:(AbstractIL.Internal.Zset -> - TypedTree.Expr -> - AbstractIL.Internal.Zset) -> - z:AbstractIL.Internal.Zset -> - expr:TypedTree.Expr -> AbstractIL.Internal.Zset - val DecideBinding : - cenv:cenv -> - z:AbstractIL.Internal.Zset -> - TypedTree.Binding -> AbstractIL.Internal.Zset - val DecideBindings : - cenv:cenv -> - z:AbstractIL.Internal.Zset -> - binds:TypedTree.Binding list -> - AbstractIL.Internal.Zset - val DecideImplFile : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - implFile:TypedTree.TypedImplFile -> - AbstractIL.Internal.Zset - val TransformExpr : - g:TcGlobals.TcGlobals -> - nvs:TypedTreeOps.ValMap<'a * TypedTree.Expr> -> - exprF:(TypedTree.Expr -> TypedTree.Expr) -> - expr:TypedTree.Expr -> TypedTree.Expr option - val TransformBinding : - g:TcGlobals.TcGlobals -> - nvs:TypedTreeOps.ValMap -> - exprF:(TypedTree.Expr -> TypedTree.Expr) -> - TypedTree.Binding -> TypedTree.Binding option - val TransformImplFile : - g:TcGlobals.TcGlobals -> - amap:Import.ImportMap -> - implFile:TypedTree.TypedImplFile -> TypedTree.TypedImplFile - end - -namespace FSharp.Compiler - module internal IlxGen = begin - val IsNonErasedTypar : tp:TypedTree.Typar -> bool - val DropErasedTypars : tps:TypedTree.Typar list -> TypedTree.Typar list - val DropErasedTyargs : tys:TypedTree.TType list -> TypedTree.TType list - val AddNonUserCompilerGeneratedAttribs : - g:TcGlobals.TcGlobals -> - mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef - val debugDisplayMethodName : string - val useHiddenInitCode : bool - val iLdcZero : AbstractIL.IL.ILInstr - val iLdcInt64 : i:int64 -> AbstractIL.IL.ILInstr - val iLdcDouble : i:double -> AbstractIL.IL.ILInstr - val iLdcSingle : i:single -> AbstractIL.IL.ILInstr - val mkLdfldMethodDef : - ilMethName:string * reprAccess:AbstractIL.IL.ILMemberAccess * - isStatic:bool * ilTy:AbstractIL.IL.ILType * ilFieldName:string * - ilPropType:AbstractIL.IL.ILType -> AbstractIL.IL.ILMethodDef - val ChooseParamNames : - fieldNamesAndTypes:(string * string * 'a) list -> - (string * string * 'a) list - val CheckCodeDoesSomething : code:AbstractIL.IL.ILCode -> bool - val ChooseFreeVarNames : - takenNames:string list -> ts:string list -> string list - val IsILTypeByref : _arg1:AbstractIL.IL.ILType -> bool - val mainMethName : string - type AttributeDecoder = - class - new : namedArgs:TypedTree.AttribNamedArg list -> AttributeDecoder - member FindBool : x:string -> dflt:bool -> bool - member FindInt16 : x:string -> dflt:int16 -> int16 - member FindInt32 : x:string -> dflt:int32 -> int32 - member FindString : x:string -> dflt:string -> string - member FindTypeName : x:string -> dflt:string -> string - end - val mutable reports : (System.IO.TextWriter -> unit) - val AddReport : f:(System.IO.TextWriter -> unit) -> unit - val ReportStatistics : System.IO.TextWriter -> unit - val NewCounter : nm:string -> (unit -> unit) - val CountClosure : (unit -> unit) - val CountMethodDef : (unit -> unit) - val CountStaticFieldDef : (unit -> unit) - val CountCallFuncInstructions : (unit -> unit) - type IlxGenIntraAssemblyInfo = - { StaticFieldInfo: - System.Collections.Generic.Dictionary } - type FakeUnit = | Fake - type IlxGenBackend = - | IlWriteBackend - | IlReflectBackend - [] - type IlxGenOptions = - { fragName: string - generateFilterBlocks: bool - workAroundReflectionEmitBugs: bool - emitConstantArraysUsingStaticDataBlobs: bool - mainMethodInfo: TypedTree.Attribs option - localOptimizationsAreOn: bool - generateDebugSymbols: bool - testFlagEmitFeeFeeAs100001: bool - ilxBackend: IlxGenBackend - isInteractive: bool - isInteractiveItExpr: bool - alwaysCallVirt: bool } - [] - type cenv = - { g: TcGlobals.TcGlobals - amap: Import.ImportMap - tcVal: ConstraintSolver.TcValF - viewCcu: TypedTree.CcuThunk - opts: IlxGenOptions - mutable ilUnitTy: AbstractIL.IL.ILType option - intraAssemblyInfo: IlxGenIntraAssemblyInfo - casApplied: System.Collections.Generic.Dictionary - mutable optimizeDuringCodeGen: bool -> TypedTree.Expr -> TypedTree.Expr - mutable exprRecursionDepth: int - delayedGenMethods: System.Collections.Generic.Queue<(cenv -> unit)> } - with - override ToString : unit -> string - end - val mkTypeOfExpr : - cenv:cenv -> m:Range.range -> ilty:AbstractIL.IL.ILType -> TypedTree.Expr - val mkGetNameExpr : - cenv:cenv -> ilt:AbstractIL.IL.ILType -> m:Range.range -> TypedTree.Expr - val useCallVirt : - cenv:cenv -> - boxity:AbstractIL.IL.ILBoxity -> - mspec:AbstractIL.IL.ILMethodSpec -> isBaseCall:bool -> bool - type CompileLocation = - { Scope: AbstractIL.IL.ILScopeRef - TopImplQualifiedName: string - Namespace: string option - Enclosing: string list - QualifiedNameOfFile: string } - val mkTopName : ns:string option -> n:string -> string - val CompLocForFragment : - fragName:string -> ccu:TypedTree.CcuThunk -> CompileLocation - val CompLocForCcu : ccu:TypedTree.CcuThunk -> CompileLocation - val CompLocForSubModuleOrNamespace : - cloc:CompileLocation -> - submod:TypedTree.ModuleOrNamespace -> CompileLocation - val CompLocForFixedPath : - fragName:string -> - qname:string -> TypedTree.CompilationPath -> CompileLocation - val CompLocForFixedModule : - fragName:string -> - qname:string -> mspec:TypedTree.ModuleOrNamespace -> CompileLocation - val NestedTypeRefForCompLoc : - cloc:CompileLocation -> n:string -> AbstractIL.IL.ILTypeRef - val CleanUpGeneratedTypeName : nm:string -> string - val TypeNameForInitClass : cloc:CompileLocation -> string - val TypeNameForImplicitMainMethod : cloc:CompileLocation -> string - val TypeNameForPrivateImplementationDetails : cloc:CompileLocation -> string - val CompLocForInitClass : cloc:CompileLocation -> CompileLocation - val CompLocForImplicitMainMethod : cloc:CompileLocation -> CompileLocation - val CompLocForPrivateImplementationDetails : - cloc:CompileLocation -> CompileLocation - val TypeRefForCompLoc : cloc:CompileLocation -> AbstractIL.IL.ILTypeRef - val mkILTyForCompLoc : cloc:CompileLocation -> AbstractIL.IL.ILType - val ComputeMemberAccess : hidden:bool -> AbstractIL.IL.ILMemberAccess - val ComputePublicTypeAccess : unit -> AbstractIL.IL.ILTypeDefAccess - val ComputeTypeAccess : - tref:AbstractIL.IL.ILTypeRef -> - hidden:bool -> AbstractIL.IL.ILTypeDefAccess - [] - type TypeReprEnv = - class - new : reprs:Map * count:int -> TypeReprEnv - static member ForTycon : tycon:TypedTree.Tycon -> TypeReprEnv - static member ForTyconRef : tycon:TypedTree.TyconRef -> TypeReprEnv - static member ForTypars : tps:TypedTree.Typar list -> TypeReprEnv - member Add : tps:TypedTree.Typar list -> TypeReprEnv - member AddOne : tp:TypedTree.Typar -> TypeReprEnv - member Item : tp:TypedTree.Typar * m:Range.range -> uint16 - member Count : int - static member Empty : TypeReprEnv - end - val GenTyconRef : tcref:TypedTree.TyconRef -> TypedTree.CompiledTypeRepr - type VoidNotOK = - | VoidNotOK - | VoidOK - val voidCheck : - m:Range.range -> - g:TcGlobals.TcGlobals -> permits:VoidNotOK -> ty:TypedTree.TType -> unit - type PtrsOK = - | PtrTypesOK - | PtrTypesNotOK - val GenReadOnlyAttributeIfNecessary : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> AbstractIL.IL.ILAttribute option - val GenReadOnlyModReqIfNecessary : - g:TcGlobals.TcGlobals -> - ty:TypedTree.TType -> ilTy:AbstractIL.IL.ILType -> AbstractIL.IL.ILType - val GenTypeArgAux : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> tyarg:TypedTree.TType -> AbstractIL.IL.ILType - val GenTypeArgsAux : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - tyargs:TypedTree.TType list -> AbstractIL.IL.ILType list - val GenTyAppAux : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - repr:TypedTree.CompiledTypeRepr -> - tinst:TypedTree.TType list -> AbstractIL.IL.ILType - val GenILTyAppAux : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - tref:AbstractIL.IL.ILTypeRef * boxity:AbstractIL.IL.ILBoxity * - ilTypeOpt:AbstractIL.IL.ILType option -> - tinst:TypedTree.TType list -> AbstractIL.IL.ILType - val GenNamedTyAppAux : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - ptrsOK:PtrsOK -> - tcref:TypedTree.TyconRef -> - tinst:TypedTree.TType list -> AbstractIL.IL.ILType - val GenTypeAux : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - voidOK:VoidNotOK -> - ptrsOK:PtrsOK -> ty:TypedTree.TType -> AbstractIL.IL.ILType - val GenUnionCaseRef : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - i:int -> - fspecs:TypedTree.RecdField [] -> - AbstractIL.Extensions.ILX.Types.IlxUnionField [] - val GenUnionRef : - amap:Import.ImportMap -> - m:Range.range -> - tcref:TypedTree.TyconRef -> - AbstractIL.Extensions.ILX.Types.IlxUnionRef - val ComputeUnionHasHelpers : - g:TcGlobals.TcGlobals -> - tcref:TypedTree.TyconRef -> - AbstractIL.Extensions.ILX.Types.IlxUnionHasHelpers - val GenUnionSpec : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - tcref:TypedTree.TyconRef -> - tyargs:TypedTree.TypeInst -> - AbstractIL.Extensions.ILX.Types.IlxUnionSpec - val GenUnionCaseSpec : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - ucref:TypedTree.UnionCaseRef -> - tyargs:TypedTree.TypeInst -> - AbstractIL.Extensions.ILX.Types.IlxUnionSpec * int - val GenType : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> ty:TypedTree.TType -> AbstractIL.IL.ILType - val GenTypes : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - tys:TypedTree.TType list -> AbstractIL.IL.ILType list - val GenTypePermitVoid : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> ty:TypedTree.TType -> AbstractIL.IL.ILType - val GenTypesPermitVoid : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - tys:TypedTree.TType list -> AbstractIL.IL.ILType list - val GenTyApp : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - repr:TypedTree.CompiledTypeRepr -> - tyargs:TypedTree.TType list -> AbstractIL.IL.ILType - val GenNamedTyApp : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - tcref:TypedTree.TyconRef -> - tinst:TypedTree.TType list -> AbstractIL.IL.ILType - val GenReturnType : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - returnTyOpt:TypedTree.TType option -> AbstractIL.IL.ILType - val GenParamType : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - isSlotSig:bool -> ty:TypedTree.TType -> AbstractIL.IL.ILType - val GenParamTypes : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - isSlotSig:bool -> - tys:TypedTree.TType list -> AbstractIL.IL.ILType list - val GenTypeArgs : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> - tyargs:TypedTree.TypeInst -> AbstractIL.IL.ILGenericArgs - val GenTypePermitVoidAux : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> ty:TypedTree.TType -> AbstractIL.IL.ILType - val GenFieldSpecForStaticField : - isInteractive:bool * g:TcGlobals.TcGlobals * - ilContainerTy:AbstractIL.IL.ILType * vspec:TypedTree.Val * nm:string * - m:Range.range * cloc:CompileLocation * ilTy:AbstractIL.IL.ILType -> - AbstractIL.IL.ILFieldSpec - val GenRecdFieldRef : - m:Range.range -> - cenv:cenv -> - tyenv:TypeReprEnv -> - rfref:TypedTree.RecdFieldRef -> - tyargs:TypedTree.TType list -> AbstractIL.IL.ILFieldSpec - val GenExnType : - amap:Import.ImportMap -> - m:Range.range -> - tyenv:TypeReprEnv -> ecref:TypedTree.TyconRef -> AbstractIL.IL.ILType - type ArityInfo = int list - [] - type IlxClosureInfo = - { cloExpr: TypedTree.Expr - cloName: string - cloArityInfo: ArityInfo - ilCloFormalReturnTy: AbstractIL.IL.ILType - ilCloAllFreeVars: AbstractIL.Extensions.ILX.Types.IlxClosureFreeVar [] - cloSpec: AbstractIL.Extensions.ILX.Types.IlxClosureSpec - cloAttribs: TypedTree.Attribs - cloILGenericParams: AbstractIL.IL.ILGenericParameterDefs - cloFreeVars: TypedTree.Val list - cloFreeTyvars: TypedTree.Typars - cloWitnessInfos: TypedTreeOps.TraitWitnessInfos - ilCloLambdas: AbstractIL.Extensions.ILX.Types.IlxClosureLambdas - localTypeFuncILGenericArgs: AbstractIL.IL.ILType list - localTypeFuncContractFreeTypars: TypedTree.Typar list - localTypeFuncDirectILGenericParams: AbstractIL.IL.ILGenericParameterDefs - localTypeFuncInternalFreeTypars: TypedTree.Typar list } - [] - type ValStorage = - | Null - | StaticField of - AbstractIL.IL.ILFieldSpec * TypedTree.ValRef * bool * - AbstractIL.IL.ILType * string * AbstractIL.IL.ILType * - AbstractIL.IL.ILMethodRef * AbstractIL.IL.ILMethodRef * - OptionalShadowLocal - | StaticProperty of AbstractIL.IL.ILMethodSpec * OptionalShadowLocal - | Method of - TypedTree.ValReprInfo * TypedTree.ValRef * AbstractIL.IL.ILMethodSpec * - AbstractIL.IL.ILMethodSpec * Range.range * TypedTree.Typars * - TypedTree.Typars * TypedTreeOps.CurriedArgInfos * - TypedTree.ArgReprInfo list * TypedTreeOps.TraitWitnessInfos * - TypedTree.TType list * TypedTree.ArgReprInfo - | Env of - AbstractIL.IL.ILType * AbstractIL.IL.ILFieldSpec * - NamedLocalIlxClosureInfo ref option - | Arg of int - | Local of idx: int * realloc: bool * NamedLocalIlxClosureInfo ref option - and OptionalShadowLocal = - | NoShadowLocal - | ShadowLocal of ValStorage - and NamedLocalIlxClosureInfo = - | NamedLocalIlxClosureInfoGenerator of (IlxGenEnv -> IlxClosureInfo) - | NamedLocalIlxClosureInfoGenerated of IlxClosureInfo - with - override ToString : unit -> string - end - and ModuleStorage = - { Vals: Lazy> - SubModules: Lazy> } - with - override ToString : unit -> string - end - and BranchCallItem = - | BranchCallClosure of ArityInfo - | BranchCallMethod of - ArityInfo * (TypedTree.TType * TypedTree.ArgReprInfo) list list * - TypedTree.Typars * int * int * int - with - override ToString : unit -> string - end - and Mark = - | Mark of AbstractIL.IL.ILCodeLabel - with - member CodeLabel : AbstractIL.IL.ILCodeLabel - end - and sequel = - | EndFilter - | LeaveHandler of (bool * int * Mark) - | Br of Mark - | CmpThenBrOrContinue of Pops * AbstractIL.IL.ILInstr list - | Continue - | DiscardThen of sequel - | Return - | EndLocalScope of sequel * Mark - | ReturnVoid - and Pushes = AbstractIL.IL.ILType list - and Pops = int - and IlxGenEnv = - { tyenv: TypeReprEnv - someTypeInThisAssembly: AbstractIL.IL.ILType - isFinalFile: bool - cloc: CompileLocation - sigToImplRemapInfo: - (TypedTreeOps.Remap * TypedTreeOps.SignatureHidingInfo) list - valsInScope: TypedTreeOps.ValMap> - witnessesInScope: TypedTreeOps.TraitWitnessInfoHashMap - suppressWitnesses: bool - innerVals: (TypedTree.ValRef * (BranchCallItem * Mark)) list - letBoundVars: TypedTree.ValRef list - liveLocals: Lib.IntMap - withinSEH: bool - isInLoop: bool } - with - override ToString : unit -> string - end - val discard : sequel - val discardAndReturnVoid : sequel - val SetIsInLoop : isInLoop:bool -> eenv:IlxGenEnv -> IlxGenEnv - val ReplaceTyenv : tyenv:TypeReprEnv -> eenv:IlxGenEnv -> IlxGenEnv - val EnvForTypars : tps:TypedTree.Typar list -> eenv:IlxGenEnv -> IlxGenEnv - val AddTyparsToEnv : - typars:TypedTree.Typar list -> eenv:IlxGenEnv -> IlxGenEnv - val AddSignatureRemapInfo : - _msg:'a -> - rpi:TypedTreeOps.SignatureRepackageInfo * - mhi:TypedTreeOps.SignatureHidingInfo -> eenv:IlxGenEnv -> IlxGenEnv - val OutputStorage : pps:System.IO.TextWriter -> s:ValStorage -> unit - val AddStorageForVal : - g:TcGlobals.TcGlobals -> - v:TypedTree.Val * s:Lazy -> eenv:IlxGenEnv -> IlxGenEnv - val AddStorageForLocalVals : - g:TcGlobals.TcGlobals -> - vals:(TypedTree.Val * ValStorage) list -> eenv:IlxGenEnv -> IlxGenEnv - val AddStorageForLocalWitness : - eenv:IlxGenEnv -> w:TypedTree.TraitWitnessInfo * s:ValStorage -> IlxGenEnv - val AddStorageForLocalWitnesses : - witnesses:(TypedTree.TraitWitnessInfo * ValStorage) list -> - eenv:IlxGenEnv -> IlxGenEnv - val StorageForVal : - g:TcGlobals.TcGlobals -> - m:Range.range -> v:TypedTree.Val -> eenv:IlxGenEnv -> ValStorage - val StorageForValRef : - g:TcGlobals.TcGlobals -> - m:Range.range -> v:TypedTree.ValRef -> eenv:IlxGenEnv -> ValStorage - val ComputeGenerateWitnesses : - g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> bool - val TryStorageForWitness : - _g:TcGlobals.TcGlobals -> - eenv:IlxGenEnv -> w:TypedTree.TraitWitnessInfo -> ValStorage option - val IsValRefIsDllImport : - g:TcGlobals.TcGlobals -> vref:TypedTree.ValRef -> bool - val GetMethodSpecForMemberVal : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - memberInfo:TypedTree.ValMemberInfo -> - vref:TypedTree.ValRef -> - AbstractIL.IL.ILMethodSpec * AbstractIL.IL.ILMethodSpec * - TypedTree.Typar list * TypedTree.Typar list * - TypedTreeOps.CurriedArgInfos * TypedTree.ArgReprInfo list * - TypedTree.ArgReprInfo * TypedTreeOps.TraitWitnessInfos * - TypedTree.TType list * TypedTree.TType option - val ComputeFieldSpecForVal : - optIntraAssemblyInfo:IlxGenIntraAssemblyInfo option * isInteractive:bool * - g:TcGlobals.TcGlobals * ilTyForProperty:AbstractIL.IL.ILType * - vspec:TypedTree.Val * nm:string * m:Range.range * cloc:CompileLocation * - ilTy:AbstractIL.IL.ILType * ilGetterMethRef:AbstractIL.IL.ILMethodRef -> - AbstractIL.IL.ILFieldSpec - val ComputeStorageForFSharpValue : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - cloc:CompileLocation -> - optIntraAssemblyInfo:IlxGenIntraAssemblyInfo option -> - optShadowLocal:OptionalShadowLocal -> - isInteractive:bool -> - returnTy:TypedTree.TType -> - vref:TypedTree.ValRef -> m:Range.range -> ValStorage - val ComputeStorageForFSharpMember : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - topValInfo:TypedTree.ValReprInfo -> - memberInfo:TypedTree.ValMemberInfo -> - vref:TypedTree.ValRef -> m:Range.range -> ValStorage - val ComputeStorageForFSharpFunctionOrFSharpExtensionMember : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - cloc:CompileLocation -> - topValInfo:TypedTree.ValReprInfo -> - vref:TypedTree.ValRef -> m:Range.range -> ValStorage - val IsFSharpValCompiledAsMethod : - TcGlobals.TcGlobals -> TypedTree.Val -> bool - val ComputeStorageForTopVal : - amap:Import.ImportMap * g:TcGlobals.TcGlobals * - optIntraAssemblyInfo:IlxGenIntraAssemblyInfo option * isInteractive:bool * - optShadowLocal:OptionalShadowLocal * vref:TypedTree.ValRef * - cloc:CompileLocation -> ValStorage - val ComputeAndAddStorageForLocalTopVal : - amap:Import.ImportMap * g:TcGlobals.TcGlobals * - intraAssemblyFieldTable:IlxGenIntraAssemblyInfo * isInteractive:bool * - optShadowLocal:OptionalShadowLocal -> - cloc:CompileLocation -> v:TypedTree.Val -> eenv:IlxGenEnv -> IlxGenEnv - val ComputeStorageForNonLocalTopVal : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - cloc:CompileLocation -> - modref:TypedTree.EntityRef -> v:TypedTree.Val -> ValStorage - val AddStorageForNonLocalModuleOrNamespaceRef : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - cloc:CompileLocation -> - acc:IlxGenEnv -> - modref:TypedTree.ModuleOrNamespaceRef -> - modul:TypedTree.ModuleOrNamespace -> IlxGenEnv - val AddStorageForExternalCcu : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - eenv:IlxGenEnv -> ccu:TypedTree.CcuThunk -> IlxGenEnv - val AddBindingsForLocalModuleType : - allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> - cloc:CompileLocation -> - eenv:'a -> mty:TypedTree.ModuleOrNamespaceType -> 'a - val AddExternalCcusToIlxGenEnv : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - eenv:IlxGenEnv -> ccus:TypedTree.CcuThunk list -> IlxGenEnv - val AddBindingsForTycon : - allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> - cloc:CompileLocation -> tycon:TypedTree.Tycon -> eenv:'a -> 'a - val AddBindingsForModuleDefs : - allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> - cloc:CompileLocation -> - eenv:'a -> mdefs:TypedTree.ModuleOrNamespaceExpr list -> 'a - val AddBindingsForModuleDef : - allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> - cloc:CompileLocation -> - eenv:'a -> x:TypedTree.ModuleOrNamespaceExpr -> 'a - val AddBindingsForModule : - allocVal:(CompileLocation -> TypedTree.Val -> 'a -> 'a) -> - cloc:CompileLocation -> - x:TypedTree.ModuleOrNamespaceBinding -> eenv:'a -> 'a - val AddBindingsForModuleTopVals : - _g:'a -> - allocVal:('b -> 'c -> 'c) -> _cloc:'d -> eenv:'c -> vs:'b list -> 'c - val AddIncrementalLocalAssemblyFragmentToIlxGenEnv : - amap:Import.ImportMap * isIncrementalFragment:bool * g:TcGlobals.TcGlobals * - ccu:TypedTree.CcuThunk * fragName:string * - intraAssemblyInfo:IlxGenIntraAssemblyInfo * eenv:IlxGenEnv * - typedImplFiles:TypedTree.TypedImplFile list -> IlxGenEnv - val GenILSourceMarker : - g:TcGlobals.TcGlobals -> m:Range.range -> AbstractIL.IL.ILSourceMarker - val GenPossibleILSourceMarker : - cenv:cenv -> m:Range.range -> AbstractIL.IL.ILSourceMarker option - val HashRangeSorted : - ht:System.Collections.Generic.IDictionary<'a,(int * 'b)> -> 'b list - val MergeOptions : - m:Range.range -> o1:'a option -> o2:'a option -> 'a option - val MergePropertyPair : - m:Range.range -> - pd:AbstractIL.IL.ILPropertyDef -> - pdef:AbstractIL.IL.ILPropertyDef -> AbstractIL.IL.ILPropertyDef - type PropKey = - | PropKey of - string * AbstractIL.IL.ILTypes * AbstractIL.IL.ILThisConvention - val AddPropertyDefToHash : - m:Range.range -> - ht:System.Collections.Generic.Dictionary -> - pdef:AbstractIL.IL.ILPropertyDef -> unit - val MergePropertyDefs : - m:Range.range -> - ilPropertyDefs:#AbstractIL.IL.ILPropertyDef list -> - AbstractIL.IL.ILPropertyDef list - type TypeDefBuilder = - class - new : tdef:AbstractIL.IL.ILTypeDef * - tdefDiscards:((AbstractIL.IL.ILMethodDef -> bool) * - (AbstractIL.IL.ILPropertyDef -> bool)) option -> - TypeDefBuilder - member AddEventDef : edef:AbstractIL.IL.ILEventDef -> unit - member AddFieldDef : ilFieldDef:AbstractIL.IL.ILFieldDef -> unit - member AddMethodDef : ilMethodDef:AbstractIL.IL.ILMethodDef -> unit - member - AddOrMergePropertyDef : pdef:AbstractIL.IL.ILPropertyDef * - m:Range.range -> unit - member Close : unit -> AbstractIL.IL.ILTypeDef - member GetCurrentFields : unit -> seq - member - PrependInstructionsToSpecificMethodDef : cond:(AbstractIL.IL.ILMethodDef -> - bool) * - instrs:AbstractIL.IL.ILInstr list * - tag:AbstractIL.IL.ILSourceMarker option -> - unit - member NestedTypeDefs : TypeDefsBuilder - end - and TypeDefsBuilder = - class - new : unit -> TypeDefsBuilder - member - AddTypeDef : tdef:AbstractIL.IL.ILTypeDef * eliminateIfEmpty:bool * - addAtEnd:bool * - tdefDiscards:((AbstractIL.IL.ILMethodDef -> bool) * - (AbstractIL.IL.ILPropertyDef -> bool)) option -> - unit - member Close : unit -> AbstractIL.IL.ILTypeDef list - member - FindNestedTypeDefBuilder : tref:AbstractIL.IL.ILTypeRef -> - TypeDefBuilder - member FindNestedTypeDefsBuilder : path:string list -> TypeDefsBuilder - member FindTypeDefBuilder : nm:string -> TypeDefBuilder - end - type AnonTypeGenerationTable = - class - new : unit -> AnonTypeGenerationTable - member - Table : System.Collections.Generic.Dictionary - end - type AssemblyBuilder = - class - new : cenv:cenv * anonTypeTable:AnonTypeGenerationTable -> - AssemblyBuilder - member - AddEventDef : tref:AbstractIL.IL.ILTypeRef * - edef:AbstractIL.IL.ILEventDef -> unit - member - AddExplicitInitToSpecificMethodDef : cond:(AbstractIL.IL.ILMethodDef -> - bool) * - tref:AbstractIL.IL.ILTypeRef * - fspec:AbstractIL.IL.ILFieldSpec * - sourceOpt:AbstractIL.IL.ILSourceMarker option * - feefee:AbstractIL.IL.ILInstr list * - seqpt:AbstractIL.IL.ILInstr list -> - unit - member - AddFieldDef : tref:AbstractIL.IL.ILTypeRef * - ilFieldDef:AbstractIL.IL.ILFieldDef -> unit - member AddInitializeScriptsInOrderToEntryPoint : unit -> unit - member - AddMethodDef : tref:AbstractIL.IL.ILTypeRef * - ilMethodDef:AbstractIL.IL.ILMethodDef -> unit - member - AddOrMergePropertyDef : tref:AbstractIL.IL.ILTypeRef * - pdef:AbstractIL.IL.ILPropertyDef * - m:Range.range -> unit - member - AddReflectedDefinition : vspec:TypedTree.Val * expr:TypedTree.Expr -> - unit - member - AddScriptInitFieldSpec : fieldSpec:AbstractIL.IL.ILFieldSpec * - range:Range.range -> unit - member - AddTypeDef : tref:AbstractIL.IL.ILTypeRef * - tdef:AbstractIL.IL.ILTypeDef * eliminateIfEmpty:bool * - addAtEnd:bool * - tdefDiscards:((AbstractIL.IL.ILMethodDef -> bool) * - (AbstractIL.IL.ILPropertyDef -> bool)) option -> - unit - member - Close : unit -> - AbstractIL.IL.ILTypeDef list * - ((string * TypedTree.Val) * TypedTree.Expr) list - member - GenerateAnonType : genToStringMethod:(AbstractIL.IL.ILType -> - #seq) * - anonInfo:TypedTree.AnonRecdTypeInfo -> unit - member - GenerateRawDataValueType : cloc:CompileLocation * size:int -> - AbstractIL.IL.ILTypeSpec - member - GetCurrentFields : tref:AbstractIL.IL.ILTypeRef -> - seq - member - GetExplicitEntryPointInfo : unit -> AbstractIL.IL.ILTypeRef option - member GrabExtraBindingsToGenerate : unit -> TypedTree.Binding list - member - LookupAnonType : genToStringMethod:(AbstractIL.IL.ILType -> - #seq) * - anonInfo:TypedTree.AnonRecdTypeInfo -> - AbstractIL.IL.ILMethodRef * - AbstractIL.IL.ILMethodRef [] * AbstractIL.IL.ILType - member - ReplaceNameOfReflectedDefinition : vspec:TypedTree.Val * - newName:string -> unit - member cenv : cenv - end - val pop : i:int -> Pops - val Push : tys:Pushes -> Pushes - val Push0 : Pushes - val FeeFee : cenv:cenv -> int - val FeeFeeInstr : - cenv:cenv -> doc:AbstractIL.IL.ILSourceDocument -> AbstractIL.IL.ILInstr - type CodeGenBuffer = - class - new : m:Range.range * mgbuf:AssemblyBuilder * methodName:string * - alreadyUsedArgs:int -> CodeGenBuffer - member - AllocLocal : ranges:(string * (Mark * Mark)) list * - ty:AbstractIL.IL.ILType * isFixed:bool -> int - member AssertEmptyStack : unit -> unit - member - Close : unit -> - ((string * (Mark * Mark)) list * AbstractIL.IL.ILType * bool) list * - int * - System.Collections.Generic.Dictionary * - AbstractIL.IL.ILInstr [] * - AbstractIL.IL.ILExceptionSpec list * bool - member DoPops : n:Pops -> unit - member DoPushes : pushes:Pushes -> unit - member - EmitExceptionClause : clause:AbstractIL.IL.ILExceptionSpec -> unit - member - EmitInstr : pops:Pops * pushes:Pushes * i:AbstractIL.IL.ILInstr -> - unit - member - EmitInstrs : pops:Pops * pushes:Pushes * is:AbstractIL.IL.ILInstr list -> - unit - member EmitSeqPoint : src:Range.range -> unit - member EmitStartOfHiddenCode : unit -> unit - member private EnsureNopBetweenDebugPoints : unit -> unit - member GenerateDelayMark : _nm:'b -> Mark - member GetCurrentStack : unit -> AbstractIL.IL.ILType list - member GetLastDebugPoint : unit -> Range.range option - member Mark : s:'a -> Mark - member - ReallocLocal : cond:(int -> - (string * (Mark * Mark)) list * - AbstractIL.IL.ILType * bool -> bool) * - ranges:(string * (Mark * Mark)) list * - ty:AbstractIL.IL.ILType * isFixed:bool -> int * bool - member - SetCodeLabelToCodeLabel : lab1:AbstractIL.IL.ILCodeLabel * - lab2:AbstractIL.IL.ILCodeLabel -> unit - member SetCodeLabelToPC : lab:AbstractIL.IL.ILCodeLabel * pc:int -> unit - member SetMark : mark1:Mark * mark2:Mark -> unit - member SetMarkToHere : Mark -> unit - member SetStack : s:AbstractIL.IL.ILType list -> unit - member MethodName : string - member PreallocatedArgCount : int - member mgbuf : AssemblyBuilder - end - module CG = begin - val EmitInstr : - cgbuf:CodeGenBuffer -> - pops:Pops -> pushes:Pushes -> i:AbstractIL.IL.ILInstr -> unit - val EmitInstrs : - cgbuf:CodeGenBuffer -> - pops:Pops -> pushes:Pushes -> is:AbstractIL.IL.ILInstr list -> unit - val EmitSeqPoint : cgbuf:CodeGenBuffer -> src:Range.range -> unit - val GenerateDelayMark : cgbuf:CodeGenBuffer -> nm:'a -> Mark - val SetMark : cgbuf:CodeGenBuffer -> m1:Mark -> m2:Mark -> unit - val SetMarkToHere : cgbuf:CodeGenBuffer -> m1:Mark -> unit - val SetStack : cgbuf:CodeGenBuffer -> s:AbstractIL.IL.ILType list -> unit - val GenerateMark : cgbuf:CodeGenBuffer -> s:'a -> Mark - end - val GenString : cenv:cenv -> cgbuf:CodeGenBuffer -> s:string -> unit - val GenConstArray : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - ilElementType:AbstractIL.IL.ILType -> - data:'a [] -> - write:(AbstractIL.Internal.ByteBuffer -> 'a -> unit) -> unit - val CodeGenThen : - cenv:cenv -> - mgbuf:AssemblyBuilder -> - entryPointInfo:(TypedTree.ValRef * BranchCallItem) list * - methodName:string * eenv:IlxGenEnv * alreadyUsedArgs:int * - codeGenFunction:(CodeGenBuffer -> IlxGenEnv -> unit) * m:Range.range -> - AbstractIL.IL.ILLocal list * int * - System.Collections.Generic.Dictionary * - AbstractIL.IL.ILInstr [] * AbstractIL.IL.ILExceptionSpec list * - AbstractIL.IL.ILLocalDebugInfo list * bool - val CodeGenMethod : - cenv:cenv -> - mgbuf:AssemblyBuilder -> - entryPointInfo:(TypedTree.ValRef * BranchCallItem) list * - methodName:string * eenv:IlxGenEnv * alreadyUsedArgs:int * - codeGenFunction:(CodeGenBuffer -> IlxGenEnv -> unit) * m:Range.range -> - AbstractIL.IL.ILInstr [] * AbstractIL.IL.ILMethodBody - val StartDelayedLocalScope : nm:string -> cgbuf:CodeGenBuffer -> Mark * Mark - val StartLocalScope : nm:string -> cgbuf:CodeGenBuffer -> Mark * Mark - val LocalScope : - nm:string -> cgbuf:CodeGenBuffer -> f:(Mark * Mark -> 'a) -> 'a - val compileSequenceExpressions : bool - type EmitDebugPointState = - | SPAlways - | SPSuppress - val BindingEmitsNoCode : - g:TcGlobals.TcGlobals -> b:TypedTree.Binding -> bool - val ComputeDebugPointForBinding : - g:TcGlobals.TcGlobals -> - TypedTree.Binding -> bool * Range.range option * EmitDebugPointState - val BindingEmitsDebugPoint : - g:TcGlobals.TcGlobals -> bind:TypedTree.Binding -> bool - val BindingIsInvisible : TypedTree.Binding -> bool - val BindingEmitsHiddenCode : TypedTree.Binding -> bool - val FirstEmittedCodeWillBeDebugPoint : - g:TcGlobals.TcGlobals -> - sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool - val EmitDebugPointForWholeExpr : - g:TcGlobals.TcGlobals -> - sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool - val EmitHiddenCodeMarkerForWholeExpr : - g:TcGlobals.TcGlobals -> - sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool - val RangeOfDebugPointForWholeExpr : - g:TcGlobals.TcGlobals -> expr:TypedTree.Expr -> Range.range - val DoesGenExprStartWithDebugPoint : - g:TcGlobals.TcGlobals -> - sp:EmitDebugPointState -> expr:TypedTree.Expr -> bool - val ProcessDebugPointForExpr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - sp:EmitDebugPointState -> expr:TypedTree.Expr -> unit - val GenExpr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - sp:EmitDebugPointState -> - expr:TypedTree.Expr -> sequel:sequel -> unit - val ProcessDelayedGenMethods : cenv:cenv -> unit - val GenExprWithStackGuard : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - sp:EmitDebugPointState -> - expr:TypedTree.Expr -> sequel:sequel -> unit - val GenExprPreSteps : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - sp:EmitDebugPointState -> - expr:TypedTree.Expr -> sequel:sequel -> bool - val GenExprAux : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - sp:EmitDebugPointState -> - expr:TypedTree.Expr -> sequel:sequel -> unit - val GenExprs : - cenv:cenv -> - cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> es:TypedTree.Expr list -> unit - val CodeGenMethodForExpr : - cenv:cenv -> - mgbuf:AssemblyBuilder -> - spReq:EmitDebugPointState * - entryPointInfo:(TypedTree.ValRef * BranchCallItem) list * - methodName:string * eenv:IlxGenEnv * alreadyUsedArgs:int * - expr0:TypedTree.Expr * sequel0:sequel -> AbstractIL.IL.ILMethodBody - val sequelAfterDiscard : sequel:sequel -> sequel option - val sequelIgnoringEndScopesAndDiscard : sequel:sequel -> sequel - val sequelIgnoreEndScopes : sequel:sequel -> sequel - val GenSequelEndScopes : cgbuf:CodeGenBuffer -> sequel:sequel -> unit - val StringOfSequel : sequel:sequel -> string - val GenSequel : - cenv:cenv -> - cloc:CompileLocation -> cgbuf:CodeGenBuffer -> sequel:sequel -> unit - val GenConstant : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - c:TypedTree.Const * m:Range.range * ty:TypedTree.TType -> - sequel:sequel -> unit - val GenUnitTy : - cenv:cenv -> eenv:IlxGenEnv -> m:Range.range -> AbstractIL.IL.ILType - val GenUnit : - cenv:cenv -> - eenv:IlxGenEnv -> m:Range.range -> cgbuf:CodeGenBuffer -> unit - val GenUnitThenSequel : - cenv:cenv -> - eenv:IlxGenEnv -> - m:Range.range -> - cloc:CompileLocation -> cgbuf:CodeGenBuffer -> sequel:sequel -> unit - val GenAllocTuple : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - tupInfo:TypedTree.TupInfo * args:TypedTree.Exprs * - argtys:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenGetTupleField : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - tupInfo:TypedTree.TupInfo * e:TypedTree.Expr * - tys:TypedTree.TypeInst * n:int * m:Range.range -> - sequel:sequel -> unit - val GenAllocExn : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - c:TypedTree.TyconRef * args:TypedTree.Exprs * m:Range.range -> - sequel:sequel -> unit - val GenAllocUnionCaseCore : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - c:TypedTree.UnionCaseRef * tyargs:TypedTree.TypeInst * n:int * - m:Range.range -> unit - val GenAllocUnionCase : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - c:TypedTree.UnionCaseRef * tyargs:TypedTree.TypeInst * - args:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit - val GenLinearExpr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - sp:EmitDebugPointState -> - expr:TypedTree.Expr -> - sequel:sequel -> - preSteps:bool -> contf:(FakeUnit -> FakeUnit) -> FakeUnit - val GenAllocRecd : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - ctorInfo:TypedTree.RecordConstructionInfo -> - tcref:TypedTree.TyconRef * argtys:TypedTree.TypeInst * - args:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit - val GenAllocAnonRecd : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - anonInfo:TypedTree.AnonRecdTypeInfo * tyargs:TypedTree.TypeInst * - args:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit - val GenGetAnonRecdField : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - anonInfo:TypedTree.AnonRecdTypeInfo * e:TypedTree.Expr * - tyargs:TypedTree.TypeInst * n:int * m:Range.range -> - sequel:sequel -> unit - val GenNewArraySimple : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - elems:TypedTree.Expr list * elemTy:TypedTree.TType * m:Range.range -> - sequel:sequel -> unit - val GenNewArray : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - elems:TypedTree.Expr list * elemTy:TypedTree.TType * m:Range.range -> - sequel:sequel -> unit - val GenCoerce : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e:TypedTree.Expr * tgty:TypedTree.TType * m:Range.range * - srcty:TypedTree.TType -> sequel:sequel -> unit - val GenReraise : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - rtnty:TypedTree.TType * m:Range.range -> sequel:sequel -> unit - val GenGetExnField : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e:TypedTree.Expr * ecref:TypedTree.TyconRef * fieldNum:int * - m:Range.range -> sequel:sequel -> unit - val GenSetExnField : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e:TypedTree.Expr * ecref:TypedTree.TyconRef * fieldNum:int * - e2:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val UnionCodeGen : - cgbuf:CodeGenBuffer -> - AbstractIL.Extensions.ILX.EraseUnions.ICodeGen - val GenUnionCaseProof : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * - tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenGetUnionCaseField : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * - tyargs:TypedTree.TypeInst * n:int * m:Range.range -> - sequel:sequel -> unit - val GenGetUnionCaseFieldAddr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * - tyargs:TypedTree.TypeInst * n:int * m:Range.range -> - sequel:sequel -> unit - val GenGetUnionCaseTag : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e:TypedTree.Expr * tcref:TypedTree.TyconRef * - tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenSetUnionCaseField : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e:TypedTree.Expr * ucref:TypedTree.UnionCaseRef * - tyargs:TypedTree.TypeInst * n:int * e2:TypedTree.Expr * - m:Range.range -> sequel:sequel -> unit - val GenGetRecdFieldAddr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e:TypedTree.Expr * f:TypedTree.RecdFieldRef * - tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenGetStaticFieldAddr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * m:Range.range -> - sequel:sequel -> unit - val GenGetRecdField : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e:TypedTree.Expr * f:TypedTree.RecdFieldRef * - tyargs:TypedTree.TypeInst * m:Range.range -> sequel:sequel -> unit - val GenSetRecdField : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e1:TypedTree.Expr * f:TypedTree.RecdFieldRef * - tyargs:TypedTree.TypeInst * e2:TypedTree.Expr * m:Range.range -> - sequel:sequel -> unit - val GenGetStaticField : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * m:Range.range -> - sequel:sequel -> unit - val GenSetStaticField : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - f:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * - e2:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val mk_field_pops : isStatic:bool -> n:int -> Pops - val GenFieldGet : - isStatic:bool -> - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - rfref:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * - m:Range.range -> unit - val GenFieldStore : - isStatic:bool -> - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - rfref:TypedTree.RecdFieldRef * tyargs:TypedTree.TypeInst * - m:Range.range -> sequel:sequel -> unit - val GenUntupledArgsDiscardingLoneUnit : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> - numObjArgs:int -> - curriedArgInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list list -> - args:TypedTree.Expr list -> unit - val GenUntupledArgExpr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> - argInfos:(TypedTree.TType * TypedTree.ArgReprInfo) list -> - expr:TypedTree.Expr -> unit - val GenWitnessArgFromTraitInfo : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> traitInfo:TypedTree.TraitConstraintInfo -> unit - val GenWitnessArgFromWitnessInfo : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> witnessInfo:TypedTree.TraitWitnessInfo -> unit - val GenWitnessArgsFromWitnessInfos : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> - witnessInfos:seq -> unit - val GenWitnessArgs : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> - tps:TypedTree.Typars -> tyargs:TypedTree.TType list -> unit - val GenApp : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - f:TypedTree.Expr * fty:TypedTree.TType * tyargs:TypedTree.TypeInst * - curriedArgs:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit - val CanTailcall : - hasStructObjArg:bool * ccallInfo:TypedTree.TType option * withinSEH:bool * - hasByrefArg:bool * mustGenerateUnitAfterCall:bool * isDllImport:bool * - isSelfInit:bool * makesNoCriticalTailcalls:bool * sequel:sequel -> - AbstractIL.IL.ILTailcall - val GenNamedLocalTyFuncCall : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - ty:TypedTree.TType -> - cloinfo:IlxClosureInfo -> - tyargs:TypedTree.TypeInst -> m:Range.range -> TypedTree.TType - val GenCurriedArgsAndIndirectCall : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - functy:TypedTree.TType * tyargs:TypedTree.TypeInst * - curriedArgs:TypedTree.Exprs * m:Range.range -> sequel:sequel -> unit - val GenIndirectCall : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - functy:TypedTree.TType * tyargs:TypedTree.TType list * - curriedArgs:TypedTree.Expr list * m:Range.range -> - sequel:sequel -> unit - val GenTry : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - Mark * Mark -> - e1:TypedTree.Expr * m:Range.range * resty:TypedTree.TType * - spTry:SyntaxTree.DebugPointAtTry -> - int * IlxGenEnv * (AbstractIL.IL.ILType list * int list) * - (AbstractIL.IL.ILCodeLabel * AbstractIL.IL.ILCodeLabel) * Mark * - AbstractIL.IL.ILType - val GenTryWith : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e1:TypedTree.Expr * vf:TypedTree.Val * ef:TypedTree.Expr * - vh:TypedTree.Val * eh:TypedTree.Expr * m:Range.range * - resty:TypedTree.TType * spTry:SyntaxTree.DebugPointAtTry * - spWith:SyntaxTree.DebugPointAtWith -> sequel:sequel -> unit - val GenTryFinally : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - bodyExpr:TypedTree.Expr * handlerExpr:TypedTree.Expr * m:Range.range * - resty:TypedTree.TType * spTry:SyntaxTree.DebugPointAtTry * - spFinally:SyntaxTree.DebugPointAtFinally -> sequel:sequel -> unit - val GenForLoop : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - spFor:SyntaxTree.DebugPointAtFor * v:TypedTree.Val * - e1:TypedTree.Expr * dir:TypedTree.ForLoopStyle * e2:TypedTree.Expr * - loopBody:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val GenWhileLoop : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - spWhile:SyntaxTree.DebugPointAtWhile * e1:TypedTree.Expr * - e2:TypedTree.Expr * m:Range.range -> sequel:sequel -> unit - val GenAsmCode : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - il:AbstractIL.IL.ILInstr list * tyargs:TypedTree.TypeInst * - args:TypedTree.Exprs * returnTys:TypedTree.TTypes * m:Range.range -> - sequel:sequel -> unit - val GenQuotation : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - ast:TypedTree.Expr * - qdataCell:((AbstractIL.IL.ILTypeRef list * TypedTree.TTypes * - TypedTree.Exprs * QuotationPickler.ExprData) * - (AbstractIL.IL.ILTypeRef list * TypedTree.TTypes * - TypedTree.Exprs * QuotationPickler.ExprData)) option ref * - m:Range.range * ety:TypedTree.TType -> sequel:sequel -> unit - val GenILCall : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - virt:bool * valu:bool * newobj:bool * - valUseFlags:TypedTree.ValUseFlag * isDllImport:bool * - ilMethRef:AbstractIL.IL.ILMethodRef * enclArgTys:TypedTree.TypeInst * - methArgTys:TypedTree.TypeInst * argExprs:TypedTree.Exprs * - returnTys:TypedTree.TTypes * m:Range.range -> sequel:sequel -> unit - val CommitCallSequel : - cenv:cenv -> - eenv:IlxGenEnv -> - m:Range.range -> - cloc:CompileLocation -> - cgbuf:CodeGenBuffer -> - mustGenerateUnitAfterCall:bool -> sequel:sequel -> unit - val MakeNotSupportedExnExpr : - cenv:cenv -> - eenv:IlxGenEnv -> - argExpr:TypedTree.Expr * m:Range.range -> TypedTree.Expr - val GenTraitCall : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - traitInfo:TypedTree.TraitConstraintInfo * argExprs:TypedTree.Exprs * - m:Range.range -> expr:TypedTree.Expr -> sequel:sequel -> unit - val GenGetAddrOfRefCellField : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - e:TypedTree.Expr * ty:TypedTree.TType * m:Range.range -> - sequel:sequel -> unit - val GenGetValAddr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - v:TypedTree.ValRef * m:Range.range -> sequel:sequel -> unit - val GenGetByref : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - v:TypedTree.ValRef * m:Range.range -> sequel:sequel -> unit - val GenSetByref : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - v:TypedTree.ValRef * e:TypedTree.Expr * m:Range.range -> - sequel:sequel -> unit - val GenDefaultValue : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> ty:TypedTree.TType * m:Range.range -> unit - val GenGenericParam : - cenv:cenv -> - eenv:IlxGenEnv -> - tp:TypedTree.Typar -> AbstractIL.IL.ILGenericParameterDef - val GenSlotParam : - m:Range.range -> - cenv:cenv -> - eenv:IlxGenEnv -> TypedTree.SlotParam -> AbstractIL.IL.ILParameter - val GenFormalSlotsig : - m:Range.range -> - cenv:cenv -> - eenv:IlxGenEnv -> - TypedTree.SlotSig -> - AbstractIL.IL.ILType * AbstractIL.IL.ILParameter list * - AbstractIL.IL.ILReturn - val instSlotParam : - inst:TypedTreeOps.TyparInst -> TypedTree.SlotParam -> TypedTree.SlotParam - val GenActualSlotsig : - m:Range.range -> - cenv:cenv -> - eenv:IlxGenEnv -> - TypedTree.SlotSig -> - methTyparsOfOverridingMethod:TypedTree.Typars -> - methodParams:TypedTree.Val list -> - AbstractIL.IL.ILParameter list * AbstractIL.IL.ILReturn - val GenNameOfOverridingMethod : - cenv:cenv -> useMethodImpl:bool * slotsig:TypedTree.SlotSig -> string - val GenMethodImpl : - cenv:cenv -> - eenv:IlxGenEnv -> - useMethodImpl:bool * TypedTree.SlotSig -> - m:Range.range -> - string * - (AbstractIL.IL.ILType * TypedTree.Typar list -> - AbstractIL.IL.ILMethodImplDef) - val bindBaseOrThisVarOpt : - cenv:cenv -> - eenv:IlxGenEnv -> baseValOpt:TypedTree.Val option -> IlxGenEnv - val fixupVirtualSlotFlags : - mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef - val renameMethodDef : - nameOfOverridingMethod:string -> - mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef - val fixupMethodImplFlags : - mdef:AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef - val GenObjectMethod : - cenv:cenv -> - eenvinner:IlxGenEnv -> - cgbuf:CodeGenBuffer -> - useMethodImpl:bool -> - tmethod:TypedTree.ObjExprMethod -> - ((bool * - (AbstractIL.IL.ILType * TypedTree.Typar list -> - AbstractIL.IL.ILMethodImplDef) * TypedTree.Typars) * - AbstractIL.IL.ILMethodDef) list - val GenObjectExpr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenvouter:IlxGenEnv -> - expr:TypedTree.Expr -> - baseType:TypedTree.TType * baseValOpt:TypedTree.Val option * - basecall:TypedTree.Expr * overrides:TypedTree.ObjExprMethod list * - interfaceImpls:(TypedTree.TType * TypedTree.ObjExprMethod list) list * - m:Range.range -> sequel:sequel -> unit - val GenSequenceExpr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenvouter:IlxGenEnv -> - nextEnumeratorValRef:TypedTree.ValRef * pcvref:TypedTree.ValRef * - currvref:TypedTree.ValRef * stateVars:TypedTree.ValRef list * - generateNextExpr:TypedTree.Expr * closeExpr:TypedTree.Expr * - checkCloseExpr:TypedTree.Expr * seqElemTy:TypedTree.TType * - m:Range.range -> sequel:sequel -> unit - val GenClosureTypeDefs : - cenv:cenv -> - tref:AbstractIL.IL.ILTypeRef * - ilGenParams:AbstractIL.IL.ILGenericParameterDefs * - attrs:AbstractIL.IL.ILAttribute list * - ilCloAllFreeVars:AbstractIL.Extensions.ILX.Types.IlxClosureFreeVar [] * - ilCloLambdas:AbstractIL.Extensions.ILX.Types.IlxClosureLambdas * - ilCtorBody:AbstractIL.IL.ILMethodBody * - mdefs:AbstractIL.IL.ILMethodDef list * - mimpls:AbstractIL.IL.ILMethodImplDef list * ext:AbstractIL.IL.ILType * - ilIntfTys:AbstractIL.IL.ILType list * - cloSpec:AbstractIL.Extensions.ILX.Types.IlxClosureSpec option -> - AbstractIL.IL.ILTypeDef list - val GenStaticDelegateClosureTypeDefs : - cenv:cenv -> - tref:AbstractIL.IL.ILTypeRef * - ilGenParams:AbstractIL.IL.ILGenericParameterDefs * - attrs:AbstractIL.IL.ILAttribute list * - ilCloAllFreeVars:AbstractIL.Extensions.ILX.Types.IlxClosureFreeVar [] * - ilCloLambdas:AbstractIL.Extensions.ILX.Types.IlxClosureLambdas * - ilCtorBody:AbstractIL.IL.ILMethodBody * - mdefs:AbstractIL.IL.ILMethodDef list * - mimpls:AbstractIL.IL.ILMethodImplDef list * ext:AbstractIL.IL.ILType * - ilIntfTys:AbstractIL.IL.ILType list * - staticCloInfo:AbstractIL.Extensions.ILX.Types.IlxClosureSpec option -> - AbstractIL.IL.ILTypeDef list - val GenGenericParams : - cenv:cenv -> - eenv:IlxGenEnv -> - tps:TypedTree.Typar list -> AbstractIL.IL.ILGenericParameterDefs - val GenGenericArgs : - m:Range.range -> - tyenv:TypeReprEnv -> - tps:TypedTree.Typar list -> AbstractIL.IL.ILGenericArgs - val GenLambdaClosure : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - isLocalTypeFunc:bool -> - thisVars:TypedTree.ValRef list -> - expr:TypedTree.Expr -> IlxClosureInfo * Range.range - val GenClosureAlloc : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> cloinfo:IlxClosureInfo * m:Range.range -> unit - val GenLambda : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - isLocalTypeFunc:bool -> - thisVars:TypedTree.ValRef list -> - expr:TypedTree.Expr -> sequel:sequel -> unit - val GenTypeOfVal : - cenv:cenv -> eenv:IlxGenEnv -> v:TypedTree.Val -> AbstractIL.IL.ILType - val GenFreevar : - cenv:cenv -> - m:Range.range -> - eenvouter:IlxGenEnv -> - tyenvinner:TypeReprEnv -> fv:TypedTree.Val -> AbstractIL.IL.ILType - val GetIlxClosureFreeVars : - cenv:cenv -> - m:Range.range -> - thisVars:TypedTree.ValRef list -> - eenvouter:IlxGenEnv -> - takenNames:string list -> - expr:TypedTree.Expr -> - TypedTree.Attribs * TypedTree.Typar list * - TypedTree.Typar list * TypedTree.Typar list * - TypedTreeOps.TraitWitnessInfos * TypedTree.Val list * - AbstractIL.IL.ILTypeRef * - AbstractIL.Extensions.ILX.Types.IlxClosureFreeVar [] * - IlxGenEnv - val GetIlxClosureInfo : - cenv:cenv -> - m:Range.range -> - isLocalTypeFunc:bool -> - canUseStaticField:bool -> - thisVars:TypedTree.ValRef list -> - eenvouter:IlxGenEnv -> - expr:TypedTree.Expr -> - IlxClosureInfo * TypedTree.Expr * IlxGenEnv - val IsNamedLocalTypeFuncVal : - g:TcGlobals.TcGlobals -> v:TypedTree.Val -> expr:TypedTree.Expr -> bool - val GenNamedLocalTypeFuncContractInfo : - cenv:cenv -> - eenv:IlxGenEnv -> - m:Range.range -> - cloinfo:IlxClosureInfo -> - AbstractIL.IL.ILGenericParameterDef list * - AbstractIL.IL.ILGenericParameterDefs * AbstractIL.IL.ILTypeSpec * - AbstractIL.IL.ILType - val GenDelegateExpr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenvouter:IlxGenEnv -> - expr:TypedTree.Expr -> - TypedTree.ObjExprMethod * m:Range.range -> sequel:sequel -> unit - val GenStaticOptimization : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - constraints:TypedTree.StaticOptimization list * e2:TypedTree.Expr * - e3:TypedTree.Expr * _m:Range.range -> sequel:sequel -> unit - val IsSequelImmediate : sequel:sequel -> bool - val GenJoinPoint : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - pos:string -> - eenv:IlxGenEnv -> - ty:TypedTree.TType -> - m:Range.range -> - sequel:sequel -> - sequel * Mark * AbstractIL.IL.ILType list * sequel - val GenDecisionTreeAndTargets : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - stackAtTargets:AbstractIL.IL.ILType list -> - eenv:IlxGenEnv -> - tree:TypedTree.DecisionTree -> - targets:TypedTree.DecisionTreeTarget array -> - repeatSP:(unit -> unit) -> - sequel:sequel -> contf:(FakeUnit -> FakeUnit) -> FakeUnit - val GenPostponedDecisionTreeTargets : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - targetInfos:System.Collections.Generic.KeyValuePair unit) * - TypedTree.Val list * - TypedTree.Bindings * - Mark * Mark) * - bool)> list -> - stackAtTargets:AbstractIL.IL.ILType list -> - sequel:sequel -> contf:(FakeUnit -> FakeUnit) -> FakeUnit - val TryFindTargetInfo : - targetInfos:Lib.IntMap<'a * 'b> -> n:int -> 'a option - val GenDecisionTreeAndTargetsInner : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - inplabOpt:Mark option -> - stackAtTargets:AbstractIL.IL.ILType list -> - eenv:IlxGenEnv -> - tree:TypedTree.DecisionTree -> - targets:TypedTree.DecisionTreeTarget array -> - repeatSP:(unit -> unit) -> - targetInfos:AbstractIL.Internal.Zmap unit) * - TypedTree.Val list * - TypedTree.Bindings * - Mark * Mark) * bool)> -> - sequel:sequel -> - contf:(AbstractIL.Internal.Zmap unit) * - TypedTree.Val list * - TypedTree.Bindings * - Mark * Mark) * bool)> -> - FakeUnit) -> FakeUnit - val GetTarget : targets:'c [] -> n:int -> 'c - val GenDecisionTreeSuccess : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - inplabOpt:Mark option -> - stackAtTargets:AbstractIL.IL.ILType list -> - eenv:IlxGenEnv -> - es:TypedTree.Exprs -> - targetIdx:int -> - targets:TypedTree.DecisionTreeTarget array -> - repeatSP:(unit -> unit) -> - targetInfos:AbstractIL.Internal.Zmap unit) * - TypedTree.Val list * - TypedTree.Bindings * - Mark * Mark) * - bool)> -> - sequel:sequel -> - AbstractIL.Internal.Zmap unit) * - TypedTree.Val list * - TypedTree.Bindings * Mark * - Mark) * bool)> * - (IlxGenEnv * EmitDebugPointState * TypedTree.Expr * - sequel) option - val GenDecisionTreeTarget : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - stackAtTargets:AbstractIL.IL.ILType list -> - targetMarkBeforeBinds:Mark * targetMarkAfterBinds:Mark * - eenvAtTarget:IlxGenEnv * successExpr:TypedTree.Expr * - spTarget:SyntaxTree.DebugPointForTarget * repeatSP:(unit -> unit) * - vs:TypedTree.Val list * binds:TypedTree.Bindings * startScope:Mark * - endScope:Mark -> - sequel:sequel -> - IlxGenEnv * EmitDebugPointState * TypedTree.Expr * sequel - val GenDecisionTreeSwitch : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - inplabOpt:Mark option -> - stackAtTargets:AbstractIL.IL.ILType list -> - eenv:IlxGenEnv -> - e:TypedTree.Expr -> - cases:TypedTree.DecisionTreeCase list -> - defaultTargetOpt:TypedTree.DecisionTree option -> - switchm:Range.range -> - targets:TypedTree.DecisionTreeTarget array -> - repeatSP:(unit -> unit) -> - targetInfos:AbstractIL.Internal.Zmap unit) * - TypedTree.Val list * - TypedTree.Bindings * - Mark * Mark) * - bool)> -> - sequel:sequel -> - contf:(AbstractIL.Internal.Zmap unit) * - TypedTree.Val list * - TypedTree.Bindings * - Mark * Mark) * - bool)> -> - FakeUnit) -> FakeUnit - val GenDecisionTreeCases : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - stackAtTargets:AbstractIL.IL.ILType list -> - eenv:IlxGenEnv -> - defaultTargetOpt:TypedTree.DecisionTree option -> - targets:TypedTree.DecisionTreeTarget array -> - repeatSP:(unit -> unit) -> - targetInfos:AbstractIL.Internal.Zmap unit) * - TypedTree.Val list * - TypedTree.Bindings * - Mark * Mark) * bool)> -> - sequel:sequel -> - caseLabels:Mark list -> - cases:TypedTree.DecisionTreeCase list -> - contf:(AbstractIL.Internal.Zmap unit) * - TypedTree.Val list * - TypedTree.Bindings * - Mark * Mark) * - bool)> -> FakeUnit) -> - FakeUnit - val ( |BoolExpr|_| ) : _arg42:TypedTree.Expr -> bool option - val GenDecisionTreeTest : - cenv:cenv -> - cloc:CompileLocation -> - cgbuf:CodeGenBuffer -> - stackAtTargets:AbstractIL.IL.ILType list -> - e:TypedTree.Expr -> - tester:(Pops * Pushes * - Choice<(bool * - AbstractIL.Extensions.ILX.Types.IlxUnionSpec * - int),AbstractIL.IL.ILInstr>) option -> - eenv:IlxGenEnv -> - successTree:TypedTree.DecisionTree -> - failureTree:TypedTree.DecisionTree -> - targets:TypedTree.DecisionTreeTarget array -> - repeatSP:(unit -> unit) -> - targetInfos:AbstractIL.Internal.Zmap unit) * - TypedTree.Val list * - TypedTree.Bindings * - Mark * Mark) * - bool)> -> - sequel:sequel -> - contf:(AbstractIL.Internal.Zmap unit) * - TypedTree.Val list * - TypedTree.Bindings * - Mark * Mark) * - bool)> -> - FakeUnit) -> FakeUnit - val GenLetRecFixup : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - ilxCloSpec:AbstractIL.Extensions.ILX.Types.IlxClosureSpec * - e:TypedTree.Expr * ilField:AbstractIL.IL.ILFieldSpec * - e2:TypedTree.Expr * _m:'d -> unit - val GenLetRecBindings : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> allBinds:TypedTree.Bindings * m:Range.range -> unit - val GenLetRec : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - binds:TypedTree.Bindings * body:TypedTree.Expr * m:Range.range -> - sequel:sequel -> unit - val GenDebugPointForBind : - cenv:cenv -> - cgbuf:CodeGenBuffer -> bind:TypedTree.Binding -> EmitDebugPointState - val GenBinding : - cenv:cenv -> - cgbuf:CodeGenBuffer -> eenv:IlxGenEnv -> bind:TypedTree.Binding -> unit - val ComputeMemberAccessRestrictedBySig : - eenv:IlxGenEnv -> vspec:TypedTree.Val -> AbstractIL.IL.ILMemberAccess - val ComputeMethodAccessRestrictedBySig : - eenv:IlxGenEnv -> vspec:TypedTree.Val -> AbstractIL.IL.ILMemberAccess - val GenBindingAfterDebugPoint : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - sp:EmitDebugPointState -> - TypedTree.Binding -> startScopeMarkOpt:Mark option -> unit - val GenMarshal : - cenv:cenv -> - attribs:TypedTree.Attrib list -> - AbstractIL.IL.ILNativeType option * TypedTree.Attrib list - val GenParamAttribs : - cenv:cenv -> - paramTy:TypedTree.TType -> - attribs:TypedTree.Attribs -> - bool * bool * bool * AbstractIL.IL.ILFieldInit option * - AbstractIL.IL.ILNativeType option * TypedTree.Attribs - val GenParams : - cenv:cenv -> - eenv:IlxGenEnv -> - m:Range.range -> - mspec:AbstractIL.IL.ILMethodSpec -> - witnessInfos:TypedTreeOps.TraitWitnessInfos -> - argInfos:TypedTree.ArgReprInfo list -> - methArgTys:TypedTree.TType list -> - implValsOpt:TypedTree.Val list option -> - AbstractIL.IL.ILParameter list - val GenReturnInfo : - cenv:cenv -> - eenv:IlxGenEnv -> - returnTy:TypedTree.TType option -> - ilRetTy:AbstractIL.IL.ILType -> - retInfo:TypedTree.ArgReprInfo -> AbstractIL.IL.ILReturn - val GenPropertyForMethodDef : - compileAsInstance:bool -> - tref:AbstractIL.IL.ILTypeRef -> - mdef:AbstractIL.IL.ILMethodDef -> - v:TypedTree.Val -> - memberInfo:TypedTree.ValMemberInfo -> - ilArgTys:AbstractIL.IL.ILTypes -> - ilPropTy:AbstractIL.IL.ILType -> - ilAttrs:AbstractIL.IL.ILAttributes -> - compiledName:string option -> AbstractIL.IL.ILPropertyDef - val GenEventForProperty : - cenv:cenv -> - eenvForMeth:IlxGenEnv -> - mspec:AbstractIL.IL.ILMethodSpec -> - v:TypedTree.Val -> - ilAttrsThatGoOnPrimaryItem:AbstractIL.IL.ILAttribute list -> - m:Range.range -> - returnTy:TypedTree.TType -> AbstractIL.IL.ILEventDef - val ComputeUseMethodImpl : - cenv:cenv -> v:TypedTree.Val * slotsig:TypedTree.SlotSig -> bool - val ComputeMethodImplNameFixupForMemberBinding : - cenv:cenv -> - v:TypedTree.Val * memberInfo:TypedTree.ValMemberInfo -> string option - val ComputeFlagFixupsForMemberBinding : - cenv:cenv -> - v:TypedTree.Val * memberInfo:TypedTree.ValMemberInfo -> - (#AbstractIL.IL.ILMethodDef -> AbstractIL.IL.ILMethodDef) list - val ComputeMethodImplAttribs : - cenv:cenv -> - _v:TypedTree.Val -> - attrs:TypedTree.Attribs -> - bool * bool * bool * bool * TypedTree.Attrib list - val DelayGenMethodForBinding : - cenv:cenv -> - mgbuf:AssemblyBuilder -> - eenv:IlxGenEnv -> - TypedTree.Val * AbstractIL.IL.ILMethodSpec * bool * bool * - AbstractIL.IL.ILMemberAccess * TypedTree.Typars * TypedTree.Typars * - TypedTree.TraitWitnessInfo list * TypedTreeOps.CurriedArgInfos * - TypedTree.ArgReprInfo list * TypedTree.TType list * - TypedTree.ArgReprInfo * TypedTree.ValReprInfo * TypedTree.Val option * - TypedTree.Val option * TypedTree.Typars * TypedTree.Val list * - TypedTree.Expr * TypedTree.TType -> unit - val GenMethodForBinding : - cenv:cenv -> - mgbuf:AssemblyBuilder -> - eenv:IlxGenEnv -> - v:TypedTree.Val * mspec:AbstractIL.IL.ILMethodSpec * - hasWitnessEntry:bool * generateWitnessArgs:bool * - access:AbstractIL.IL.ILMemberAccess * ctps:TypedTree.Typars * - mtps:TypedTree.Typars * witnessInfos:TypedTree.TraitWitnessInfo list * - curriedArgInfos:TypedTreeOps.CurriedArgInfos * - paramInfos:TypedTree.ArgReprInfo list * argTys:TypedTree.TType list * - retInfo:TypedTree.ArgReprInfo * topValInfo:TypedTree.ValReprInfo * - ctorThisValOpt:TypedTree.Val option * - baseValOpt:TypedTree.Val option * methLambdaTypars:TypedTree.Typars * - methLambdaVars:TypedTree.Val list * methLambdaBody:TypedTree.Expr * - returnTy:TypedTree.TType -> unit - val GenPInvokeMethod : - nm:string * dll:string * namedArgs:TypedTree.AttribNamedArg list -> - bool * AbstractIL.IL.MethodBody - val GenBindings : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> binds:TypedTree.Bindings -> unit - val GenSetVal : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - vref:TypedTree.ValRef * e:TypedTree.Expr * m:Range.range -> - sequel:sequel -> unit - val GenGetValRefAndSequel : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> - v:TypedTree.ValRef -> - storeSequel:(TypedTree.TypeInst * TypedTree.Exprs * Range.range * - sequel) option -> unit - val GenGetVal : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - v:TypedTree.ValRef * m:Range.range -> sequel:sequel -> unit - val GenBindingRhs : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - sp:EmitDebugPointState -> - vspec:TypedTree.Val -> e:TypedTree.Expr -> unit - val CommitStartScope : - cgbuf:CodeGenBuffer -> startScopeMarkOpt:Mark option -> unit - val EmitInitLocal : - cgbuf:CodeGenBuffer -> ty:AbstractIL.IL.ILType -> idx:int -> unit - val EmitSetLocal : cgbuf:CodeGenBuffer -> idx:int -> unit - val EmitGetLocal : - cgbuf:CodeGenBuffer -> ty:AbstractIL.IL.ILType -> idx:int -> unit - val EmitSetStaticField : - cgbuf:CodeGenBuffer -> fspec:AbstractIL.IL.ILFieldSpec -> unit - val EmitGetStaticFieldAddr : - cgbuf:CodeGenBuffer -> - ty:AbstractIL.IL.ILType -> fspec:AbstractIL.IL.ILFieldSpec -> unit - val EmitGetStaticField : - cgbuf:CodeGenBuffer -> - ty:AbstractIL.IL.ILType -> fspec:AbstractIL.IL.ILFieldSpec -> unit - val GenSetStorage : - m:Range.range -> cgbuf:CodeGenBuffer -> storage:ValStorage -> unit - val CommitGetStorageSequel : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> - ty:TypedTree.TType -> - localCloInfo:Ref option -> - storeSequel:(TypedTree.TType list * TypedTree.Expr list * - Range.range * sequel) option -> unit - val GenGetStorageAndSequel : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> - ty:TypedTree.TType * ilTy:AbstractIL.IL.ILType -> - storage:ValStorage -> - storeSequel:(TypedTree.TType list * TypedTree.Expr list * - Range.range * sequel) option -> unit - val GenGetLocalVals : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenvouter:IlxGenEnv -> m:Range.range -> fvs:TypedTree.Val list -> unit - val GenGetLocalVal : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> - vspec:TypedTree.Val -> - storeSequel:(TypedTree.TType list * TypedTree.Expr list * - Range.range * sequel) option -> unit - val GenGetLocalVRef : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> - vref:TypedTree.ValRef -> - storeSequel:(TypedTree.TType list * TypedTree.Expr list * - Range.range * sequel) option -> unit - val GenStoreVal : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> m:Range.range -> vspec:TypedTree.Val -> unit - val AllocLocal : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - compgen:bool -> - v:string * ty:AbstractIL.IL.ILType * isFixed:bool -> - Mark * Mark -> int * bool * IlxGenEnv - val AllocLocalVal : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - v:TypedTree.Val -> - eenv:IlxGenEnv -> - repr:TypedTree.Expr option -> - Mark * Mark -> ValStorage option * IlxGenEnv - val AllocStorageForBind : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - Mark * Mark -> eenv:IlxGenEnv -> bind:TypedTree.Binding -> IlxGenEnv - val AllocStorageForBinds : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - Mark * Mark -> eenv:IlxGenEnv -> binds:TypedTree.Bindings -> IlxGenEnv - val AllocValForBind : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - Mark * Mark -> - eenv:IlxGenEnv -> TypedTree.Binding -> ValStorage option * IlxGenEnv - val AllocTopValWithinExpr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - cloc:CompileLocation -> - Mark * Mark -> v:TypedTree.Val -> eenv:IlxGenEnv -> IlxGenEnv - val EmitSaveStack : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - eenv:IlxGenEnv -> - m:Range.range -> - Mark * Mark -> (AbstractIL.IL.ILType list * int list) * IlxGenEnv - val EmitRestoreStack : - cgbuf:CodeGenBuffer -> - savedStack:AbstractIL.IL.ILType list * savedStackLocals:int list -> unit - val GenAttribArg : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - eenv:IlxGenEnv -> - x:TypedTree.Expr -> - ilArgTy:AbstractIL.IL.ILType -> AbstractIL.IL.ILAttribElem - val GenAttr : - amap:Import.ImportMap -> - g:TcGlobals.TcGlobals -> - eenv:IlxGenEnv -> TypedTree.Attrib -> AbstractIL.IL.ILAttribute - val GenAttrs : - cenv:cenv -> - eenv:IlxGenEnv -> - attrs:TypedTree.Attribs -> AbstractIL.IL.ILAttribute list - val GenCompilationArgumentCountsAttr : - cenv:cenv -> v:TypedTree.Val -> AbstractIL.IL.ILAttribute list - val CreatePermissionSets : - cenv:cenv -> - eenv:IlxGenEnv -> - securityAttributes:TypedTree.Attrib list -> - AbstractIL.IL.ILSecurityDecl list - val GenTypeDefForCompLoc : - cenv:cenv * eenv:IlxGenEnv * mgbuf:AssemblyBuilder * cloc:CompileLocation * - hidden:bool * attribs:TypedTree.Attribs * - initTrigger:AbstractIL.IL.ILTypeInit * eliminateIfEmpty:bool * - addAtEnd:bool -> unit - val GenModuleExpr : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - qname:SyntaxTree.QualifiedNameOfFile -> - lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> - AbstractIL.IL.ILInstr list -> - AbstractIL.IL.ILInstr list -> unit)> -> - eenv:IlxGenEnv -> x:TypedTree.ModuleOrNamespaceExprWithSig -> unit - val GenModuleDefs : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - qname:SyntaxTree.QualifiedNameOfFile -> - lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> - AbstractIL.IL.ILInstr list -> - AbstractIL.IL.ILInstr list -> unit)> -> - eenv:IlxGenEnv -> - mdefs:TypedTree.ModuleOrNamespaceExpr list -> unit - val GenModuleDef : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - qname:SyntaxTree.QualifiedNameOfFile -> - lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> - AbstractIL.IL.ILInstr list -> - AbstractIL.IL.ILInstr list -> unit)> -> - eenv:IlxGenEnv -> x:TypedTree.ModuleOrNamespaceExpr -> unit - val GenModuleBinding : - cenv:cenv -> - cgbuf:CodeGenBuffer -> - qname:SyntaxTree.QualifiedNameOfFile -> - lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> - AbstractIL.IL.ILInstr list -> - AbstractIL.IL.ILInstr list -> unit)> -> - eenv:IlxGenEnv -> - m:Range.range -> x:TypedTree.ModuleOrNamespaceBinding -> unit - val GenImplFile : - cenv:cenv -> - mgbuf:AssemblyBuilder -> - mainInfoOpt:TypedTree.Attribs option -> - eenv:IlxGenEnv -> - implFile:TypedTree.TypedImplFileAfterOptimization -> IlxGenEnv - val GenForceWholeFileInitializationAsPartOfCCtor : - cenv:cenv -> - mgbuf:AssemblyBuilder -> - lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> - AbstractIL.IL.ILInstr list -> - AbstractIL.IL.ILInstr list -> unit)> -> - tref:AbstractIL.IL.ILTypeRef -> m:Range.range -> unit - val GenEqualsOverrideCallingIComparable : - cenv:cenv -> - tcref:TypedTree.TyconRef * ilThisTy:AbstractIL.IL.ILType * _ilThatTy:'f -> - AbstractIL.IL.ILMethodDef - val GenFieldInit : - m:Range.range -> c:TypedTree.Const -> AbstractIL.IL.ILFieldInit - val GenWitnessParams : - cenv:cenv -> - eenv:IlxGenEnv -> - m:Range.range -> - witnessInfos:TypedTreeOps.TraitWitnessInfos -> - AbstractIL.IL.ILParameter list - val GenAbstractBinding : - cenv:cenv -> - eenv:IlxGenEnv -> - tref:AbstractIL.IL.ILTypeRef -> - vref:TypedTree.ValRef -> - AbstractIL.IL.ILMethodDef list * AbstractIL.IL.ILPropertyDef list * - AbstractIL.IL.ILEventDef list - val GenToStringMethod : - cenv:cenv -> - eenv:IlxGenEnv -> - ilThisTy:AbstractIL.IL.ILType -> - m:Range.range -> AbstractIL.IL.ILMethodDef list - val GenTypeDef : - cenv:cenv -> - mgbuf:AssemblyBuilder -> - lazyInitInfo:ResizeArray<(AbstractIL.IL.ILFieldSpec -> - AbstractIL.IL.ILInstr list -> - AbstractIL.IL.ILInstr list -> unit)> -> - eenv:IlxGenEnv -> m:Range.range -> tycon:TypedTree.Tycon -> unit - val GenExnDef : - cenv:cenv -> - mgbuf:AssemblyBuilder -> - eenv:IlxGenEnv -> m:Range.range -> exnc:TypedTree.Tycon -> unit - val CodegenAssembly : - cenv:cenv -> - eenv:IlxGenEnv -> - mgbuf:AssemblyBuilder -> - implFiles:TypedTree.TypedImplFileAfterOptimization list -> unit - val GetEmptyIlxGenEnv : - g:TcGlobals.TcGlobals -> ccu:TypedTree.CcuThunk -> IlxGenEnv - type IlxGenResults = - { ilTypeDefs: AbstractIL.IL.ILTypeDef list - ilAssemAttrs: AbstractIL.IL.ILAttribute list - ilNetModuleAttrs: AbstractIL.IL.ILAttribute list - topAssemblyAttrs: TypedTree.Attribs - permissionSets: AbstractIL.IL.ILSecurityDecl list - quotationResourceInfo: (AbstractIL.IL.ILTypeRef list * byte []) list } - val GenerateCode : - cenv:cenv * anonTypeTable:AnonTypeGenerationTable * eenv:IlxGenEnv * - TypedTree.TypedAssemblyAfterOptimization * assemAttribs:TypedTree.Attribs * - moduleAttribs:TypedTree.Attribs -> IlxGenResults - type ExecutionContext = - { LookupFieldRef: AbstractIL.IL.ILFieldRef -> System.Reflection.FieldInfo - LookupMethodRef: - AbstractIL.IL.ILMethodRef -> System.Reflection.MethodInfo - LookupTypeRef: AbstractIL.IL.ILTypeRef -> System.Type - LookupType: AbstractIL.IL.ILType -> System.Type } - val defaultOf : (System.Type -> obj) - val LookupGeneratedValue : - amap:Import.ImportMap -> - ctxt:ExecutionContext -> - eenv:IlxGenEnv -> v:TypedTree.Val -> (obj * System.Type) option - val SetGeneratedValue : - ctxt:ExecutionContext -> - g:TcGlobals.TcGlobals -> - eenv:IlxGenEnv -> - isForced:bool -> v:TypedTree.Val -> value:obj -> unit - val ClearGeneratedValue : - ctxt:ExecutionContext -> - g:TcGlobals.TcGlobals -> eenv:IlxGenEnv -> v:TypedTree.Val -> unit - type IlxAssemblyGenerator = - class - new : Import.ImportMap * TcGlobals.TcGlobals * ConstraintSolver.TcValF * - TypedTree.CcuThunk -> IlxAssemblyGenerator - member AddExternalCcus : TypedTree.CcuThunk list -> unit - member - AddIncrementalLocalAssemblyFragment : isIncrementalFragment:bool * - fragName:string * - typedImplFiles:TypedTree.TypedImplFile list -> - unit - member ClearGeneratedValue : ExecutionContext * TypedTree.Val -> unit - member - ForceSetGeneratedValue : ExecutionContext * TypedTree.Val * obj -> - unit - member - GenerateCode : IlxGenOptions * - TypedTree.TypedAssemblyAfterOptimization * - TypedTree.Attribs * TypedTree.Attribs -> IlxGenResults - member - LookupGeneratedValue : ExecutionContext * TypedTree.Val -> - (obj * System.Type) option - end - end - -namespace FSharp.Compiler - module internal DotNetFrameworkDependencies = begin - type private TypeInThisAssembly - val fSharpCompilerLocation : string - val inline ifEmptyUse : alternative:string -> filename:string -> string - val getFSharpCoreLibraryName : string - val getFsiLibraryName : string - val getDefaultFSharpCoreLocation : string - val getDefaultFsiLibraryLocation : string - val implementationAssemblyDir : string - val getDefaultSystemValueTupleReference : unit -> string option - val zeroVersion : System.Version - val version : string option - val frameworkRefsPackDirectoryRoot : string option - val netcoreTfm : string option - val getWindowsDesktopTfm : unit -> string - val executionTfm : string - val executionRid : string - val isInReferenceAssemblyPackDirectory : filename:string -> bool - val frameworkRefsPackDirectory : string option - val getDependenciesOf : - assemblyReferences:string list -> - System.Collections.Generic.Dictionary - val getDesktopDefaultReferences : useFsiAuxLib:bool -> string list - val fetchPathsForDefaultReferencesForScriptsAndOutOfProjectSources : - useFsiAuxLib:bool -> - useSdkRefs:bool -> assumeDotNetFramework:bool -> string list - val defaultReferencesForScriptsAndOutOfProjectSources : - useFsiAuxLib:bool -> - assumeDotNetFramework:bool -> useSdkRefs:bool -> string list - val systemAssemblies : System.Collections.Generic.HashSet - val basicReferencesForScriptLoadClosure : - useFsiAuxLib:bool -> - useSdkRefs:bool -> assumeDotNetFramework:bool -> string list - end - -namespace Microsoft.DotNet.DependencyManager - type AssemblyResolutionProbe = - delegate of Unit -> seq - type AssemblyResolveHandlerCoreclr = - class - interface System.IDisposable - new : assemblyProbingPaths:AssemblyResolutionProbe -> - AssemblyResolveHandlerCoreclr - end - type AssemblyResolveHandlerDeskTop = - class - interface System.IDisposable - new : assemblyProbingPaths:AssemblyResolutionProbe -> - AssemblyResolveHandlerDeskTop - end - type AssemblyResolveHandler = - class - interface System.IDisposable - new : assemblyProbingPaths:AssemblyResolutionProbe -> - AssemblyResolveHandler - end - -namespace Microsoft.DotNet.DependencyManager - type NativeResolutionProbe = - delegate of Unit -> seq - type NativeAssemblyLoadContext = - class - inherit System.Runtime.Loader.AssemblyLoadContext - new : unit -> NativeAssemblyLoadContext - override - Load : _path:System.Reflection.AssemblyName -> - System.Reflection.Assembly - member LoadNativeLibrary : path:string -> System.IntPtr - static member NativeLoadContext : NativeAssemblyLoadContext - end - type NativeDllResolveHandlerCoreClr = - class - interface System.IDisposable - new : nativeProbingRoots:NativeResolutionProbe -> - NativeDllResolveHandlerCoreClr - end - type NativeDllResolveHandler = - class - interface System.IDisposable - new : _nativeProbingRoots:NativeResolutionProbe -> NativeDllResolveHandler - member internal RefreshPathsInEnvironment : seq -> unit - end - -namespace Microsoft.DotNet.DependencyManager - module Option = begin - val ofString : s:string -> string option - end - module ReflectionHelper = begin - val dependencyManagerPattern : string - val dependencyManagerAttributeName : string - val resolveDependenciesMethodName : string - val namePropertyName : string - val keyPropertyName : string - val helpMessagesPropertyName : string - val arrEmpty : string [] - val seqEmpty : seq - val assemblyHasAttribute : - theAssembly:System.Reflection.Assembly -> attributeName:string -> bool - val getAttributeNamed : - theType:System.Type -> attributeName:string -> obj option - val getInstanceProperty<'treturn> : - theType:System.Type -> - propertyName:string -> System.Reflection.PropertyInfo option - val getInstanceMethod<'treturn> : - theType:System.Type -> - parameterTypes:System.Type array -> - methodName:string -> System.Reflection.MethodInfo option - val stripTieWrapper : e:System.Exception -> exn - end - [] - type ErrorReportType = - | Warning - | Error - type ResolvingErrorReport = - delegate of ErrorReportType * int * string -> unit - type IResolveDependenciesResult = - interface - abstract member Resolutions : seq - abstract member Roots : seq - abstract member SourceFiles : seq - abstract member StdError : string [] - abstract member StdOut : string [] - abstract member Success : bool - end - [] - type IDependencyManagerProvider = - interface - abstract member - ResolveDependencies : scriptDir:string * mainScriptName:string * - scriptName:string * scriptExt:string * - packageManagerTextLines:seq * - tfm:string * rid:string -> - IResolveDependenciesResult - abstract member HelpMessages : string [] - abstract member Key : string - abstract member Name : string - end - type ReflectionDependencyManagerProvider = - class - interface IDependencyManagerProvider - new : theType:System.Type * nameProperty:System.Reflection.PropertyInfo * - keyProperty:System.Reflection.PropertyInfo * - helpMessagesProperty:System.Reflection.PropertyInfo option * - resolveDeps:System.Reflection.MethodInfo option * - resolveDepsEx:System.Reflection.MethodInfo option * - outputDir:string option -> ReflectionDependencyManagerProvider - static member - InstanceMaker : theType:System.Type * outputDir:string option -> - (unit -> IDependencyManagerProvider) option - static member - MakeResultFromFields : success:bool * stdOut:string array * - stdError:string array * resolutions:seq * - sourceFiles:seq * roots:seq -> - IResolveDependenciesResult - static member - MakeResultFromObject : result:obj -> IResolveDependenciesResult - end - type DependencyProvider = - class - interface System.IDisposable - new : unit -> DependencyProvider - new : nativeProbingRoots:NativeResolutionProbe -> DependencyProvider - new : assemblyProbingPaths:AssemblyResolutionProbe * - nativeProbingRoots:NativeResolutionProbe -> DependencyProvider - member - CreatePackageManagerUnknownError : seq * string * string * - ResolvingErrorReport -> int * string - member - GetRegisteredDependencyManagerHelpText : seq * string * - ResolvingErrorReport -> - string [] - member - Resolve : packageManager:IDependencyManagerProvider * scriptExt:string * - packageManagerTextLines:seq * - reportError:ResolvingErrorReport * executionTfm:string * - executionRid:string * implicitIncludeDir:string * - mainScriptName:string * fileName:string -> - IResolveDependenciesResult - member - TryFindDependencyManagerByKey : compilerTools:seq * - outputDir:string * - reportError:ResolvingErrorReport * - key:string -> IDependencyManagerProvider - member - TryFindDependencyManagerInPath : compilerTools:seq * - outputDir:string * - reportError:ResolvingErrorReport * - path:string -> - string * IDependencyManagerProvider - end - -namespace FSharp.Compiler - module internal CompilerConfig = begin - val ( ++ ) : x:'a list -> s:'a -> 'a list - val FSharpSigFileSuffixes : string list - val mlCompatSuffixes : string list - val FSharpImplFileSuffixes : string list - val FSharpScriptFileSuffixes : string list - val doNotRequireNamespaceOrModuleSuffixes : string list - val FSharpLightSyntaxFileSuffixes : string list - exception FileNameNotResolved of string * string * Range.range - exception LoadedSourceNotFoundIgnoring of string * Range.range - val TryResolveFileUsingPaths : - paths:string list * m:Range.range * name:string -> string option - val ResolveFileUsingPaths : - paths:string list * m:Range.range * name:string -> string - val GetWarningNumber : m:Range.range * warningNumber:string -> int32 option - val ComputeMakePathAbsolute : - implicitIncludeDir:string -> path:string -> string - [] - type CompilerTarget = - | WinExe - | ConsoleExe - | Dll - | Module - with - member IsExe : bool - end - [] - type ResolveAssemblyReferenceMode = - | Speculative - | ReportErrors - [] - type CopyFSharpCoreFlag = - | Yes - | No - type VersionFlag = - | VersionString of string - | VersionFile of string - | VersionNone - with - member - GetVersionInfo : implicitIncludeDir:string -> - AbstractIL.IL.ILVersionInfo - member GetVersionString : implicitIncludeDir:string -> string - end - type IRawFSharpAssemblyData = - interface - abstract member - GetAutoOpenAttributes : AbstractIL.IL.ILGlobals -> string list - abstract member - GetInternalsVisibleToAttributes : AbstractIL.IL.ILGlobals -> - string list - abstract member - GetRawFSharpOptimizationData : Range.range * ilShortAssemName:string * - fileName:string -> - (string * - (unit -> - AbstractIL.Internal.ReadOnlyByteMemory)) list - abstract member - GetRawFSharpSignatureData : Range.range * ilShortAssemName:string * - fileName:string -> - (string * - (unit -> - AbstractIL.Internal.ReadOnlyByteMemory)) list - abstract member - GetRawTypeForwarders : unit -> - AbstractIL.IL.ILExportedTypesAndForwarders - abstract member - HasMatchingFSharpSignatureDataAttribute : AbstractIL.IL.ILGlobals -> - bool - abstract member - TryGetILModuleDef : unit -> AbstractIL.IL.ILModuleDef option - abstract member HasAnyFSharpSignatureDataAttribute : bool - abstract member ILAssemblyRefs : AbstractIL.IL.ILAssemblyRef list - abstract member ILScopeRef : AbstractIL.IL.ILScopeRef - abstract member ShortAssemblyName : string - end - type TimeStampCache = - class - new : defaultTimeStamp:System.DateTime -> TimeStampCache - member GetFileTimeStamp : string -> System.DateTime - member - GetProjectReferenceTimeStamp : IProjectReference * - AbstractIL.Internal.Library.CompilationThreadToken -> - System.DateTime - end - and IProjectReference = - interface - abstract member - EvaluateRawContents : AbstractIL.Internal.Library.CompilationThreadToken -> - AbstractIL.Internal.Library.Cancellable - abstract member - TryGetLogicalTimeStamp : TimeStampCache * - AbstractIL.Internal.Library.CompilationThreadToken -> - System.DateTime option - abstract member FileName : string - end - type AssemblyReference = - | AssemblyReference of Range.range * string * IProjectReference option - with - member SimpleAssemblyNameIs : string -> bool - override ToString : unit -> string - member ProjectReference : IProjectReference option - member Range : Range.range - member Text : string - end - type UnresolvedAssemblyReference = - | UnresolvedAssemblyReference of string * AssemblyReference list - type ResolvedExtensionReference = - | ResolvedExtensionReference of - string * AssemblyReference list * - Tainted list - type ImportedAssembly = - { ILScopeRef: AbstractIL.IL.ILScopeRef - FSharpViewOfMetadata: TypedTree.CcuThunk - AssemblyAutoOpenAttributes: string list - AssemblyInternalsVisibleToAttributes: string list - IsProviderGenerated: bool - mutable TypeProviders: Tainted list - FSharpOptimizationData: Lazy> } - type AvailableImportedAssembly = - | ResolvedImportedAssembly of ImportedAssembly - | UnresolvedImportedAssembly of string - type CcuLoadFailureAction = - | RaiseError - | ReturnNone - type Directive = - | Resolution - | Include - type LStatus = - | Unprocessed - | Processed - type PackageManagerLine = - { Directive: Directive - LineStatus: LStatus - Line: string - Range: Range.range } - with - static member - AddLineWithKey : string -> - Directive -> - string -> - Range.range -> - Map -> - Map - static member - RemoveUnprocessedLines : string -> - Map -> - Map - static member - SetLinesAsProcessed : string -> - Map -> - Map - static member StripDependencyManagerKey : string -> string -> string - end - [] - type TcConfigBuilder = - { mutable primaryAssembly: AbstractIL.IL.PrimaryAssembly - mutable noFeedback: bool - mutable stackReserveSize: int32 option - mutable implicitIncludeDir: string - mutable openDebugInformationForLaterStaticLinking: bool - defaultFSharpBinariesDir: string - mutable compilingFslib: bool - mutable useIncrementalBuilder: bool - mutable includes: string list - mutable implicitOpens: string list - mutable useFsiAuxLib: bool - mutable framework: bool - mutable resolutionEnvironment: ReferenceResolver.ResolutionEnvironment - mutable implicitlyResolveAssemblies: bool - mutable light: bool option - mutable conditionalCompilationDefines: string list - mutable loadedSources: (Range.range * string * string) list - mutable compilerToolPaths: string list - mutable referencedDLLs: AssemblyReference list - mutable packageManagerLines: Map - mutable projectReferences: IProjectReference list - mutable knownUnresolvedReferences: UnresolvedAssemblyReference list - reduceMemoryUsage: AbstractIL.ILBinaryReader.ReduceMemoryFlag - mutable subsystemVersion: int * int - mutable useHighEntropyVA: bool - mutable inputCodePage: int option - mutable embedResources: string list - mutable errorSeverityOptions: ErrorLogger.FSharpErrorSeverityOptions - mutable mlCompatibility: bool - mutable checkOverflow: bool - mutable showReferenceResolutions: bool - mutable outputDir: string option - mutable outputFile: string option - mutable platform: AbstractIL.IL.ILPlatform option - mutable prefer32Bit: bool - mutable useSimpleResolution: bool - mutable target: CompilerTarget - mutable debuginfo: bool - mutable testFlagEmitFeeFeeAs100001: bool - mutable dumpDebugInfo: bool - mutable debugSymbolFile: string option - mutable typeCheckOnly: bool - mutable parseOnly: bool - mutable importAllReferencesOnly: bool - mutable simulateException: string option - mutable printAst: bool - mutable tokenizeOnly: bool - mutable testInteractionParser: bool - mutable reportNumDecls: bool - mutable printSignature: bool - mutable printSignatureFile: string - mutable xmlDocOutputFile: string option - mutable stats: bool - mutable generateFilterBlocks: bool - mutable signer: string option - mutable container: string option - mutable delaysign: bool - mutable publicsign: bool - mutable version: VersionFlag - mutable metadataVersion: string option - mutable standalone: bool - mutable extraStaticLinkRoots: string list - mutable noSignatureData: bool - mutable onlyEssentialOptimizationData: bool - mutable useOptimizationDataFile: bool - mutable jitTracking: bool - mutable portablePDB: bool - mutable embeddedPDB: bool - mutable embedAllSource: bool - mutable embedSourceList: string list - mutable sourceLink: string - mutable ignoreSymbolStoreSequencePoints: bool - mutable internConstantStrings: bool - mutable extraOptimizationIterations: int - mutable win32res: string - mutable win32manifest: string - mutable includewin32manifest: bool - mutable linkResources: string list - mutable legacyReferenceResolver: ReferenceResolver.Resolver - mutable showFullPaths: bool - mutable errorStyle: ErrorLogger.ErrorStyle - mutable utf8output: bool - mutable flatErrors: bool - mutable maxErrors: int - mutable abortOnError: bool - mutable baseAddress: int32 option - mutable checksumAlgorithm: AbstractIL.ILPdbWriter.HashAlgorithm - mutable showOptimizationData: bool - mutable showTerms: bool - mutable writeTermsToFiles: bool - mutable doDetuple: bool - mutable doTLR: bool - mutable doFinalSimplify: bool - mutable optsOn: bool - mutable optSettings: Optimizer.OptimizationSettings - mutable emitTailcalls: bool - mutable deterministic: bool - mutable preferredUiLang: string option - mutable lcid: int option - mutable productNameForBannerText: string - mutable showBanner: bool - mutable showTimes: bool - mutable showLoadedAssemblies: bool - mutable continueAfterParseFailure: bool - mutable showExtensionTypeMessages: bool - mutable pause: bool - mutable alwaysCallVirt: bool - mutable noDebugData: bool - isInteractive: bool - isInvalidationSupported: bool - mutable emitDebugInfoInQuotations: bool - mutable exename: string option - mutable copyFSharpCore: CopyFSharpCoreFlag - mutable shadowCopyReferences: bool - mutable useSdkRefs: bool - mutable tryGetMetadataSnapshot: - AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot - mutable internalTestSpanStackReferring: bool - mutable noConditionalErasure: bool - mutable pathMap: Internal.Utilities.PathMap - mutable langVersion: Features.LanguageVersion } - with - static member - CreateNew : legacyReferenceResolver:ReferenceResolver.Resolver * - defaultFSharpBinariesDir:string * - reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * - implicitIncludeDir:string * isInteractive:bool * - isInvalidationSupported:bool * - defaultCopyFSharpCore:CopyFSharpCoreFlag * - tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot -> - TcConfigBuilder - static member - SplitCommandLineResourceInfo : string -> - string * string * - AbstractIL.IL.ILResourceAccess - member AddCompilerToolsByPath : string -> unit - member - AddDependencyManagerText : packageManager:Microsoft.DotNet.DependencyManager.IDependencyManagerProvider * - lt:Directive * m:Range.range * path:string -> - unit - member AddEmbeddedResource : string -> unit - member AddEmbeddedSourceFile : string -> unit - member AddIncludePath : Range.range * string * string -> unit - member - AddLoadedSource : m:Range.range * originalPath:string * - pathLoadedFrom:string -> unit - member AddPathMapping : oldPrefix:string * newPrefix:string -> unit - member - AddReferenceDirective : dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider * - m:Range.range * path:string * - directive:Directive -> unit - member AddReferencedAssemblyByPath : Range.range * string -> unit - member DecideNames : string list -> string * string option * string - member GetNativeProbingRoots : unit -> seq - member RemoveReferencedAssemblyByPath : Range.range * string -> unit - member - ResolveSourceFile : m:Range.range * nm:string * pathLoadedFrom:string -> - string - member TurnWarningOff : Range.range * string -> unit - member TurnWarningOn : Range.range * string -> unit - static member Initial : TcConfigBuilder - end - [] - type TcConfig = - class - private new : data:TcConfigBuilder * validate:bool -> TcConfig - static member Create : TcConfigBuilder * validate:bool -> TcConfig - member CloneToBuilder : unit -> TcConfigBuilder - member - ComputeCanContainEntryPoint : sourceFiles:string list -> - bool list * bool - member ComputeLightSyntaxInitialStatus : string -> bool - member CoreLibraryDllReference : unit -> AssemblyReference - member GetAvailableLoadedSources : unit -> (Range.range * string) list - member GetNativeProbingRoots : unit -> seq - member GetSearchPathsForLibraryFiles : unit -> string list - member GetTargetFrameworkDirectories : unit -> string list - member IsSystemAssembly : string -> bool - member MakePathAbsolute : string -> string - member PrimaryAssemblyDllReference : unit -> AssemblyReference - member - ResolveSourceFile : Range.range * filename:string * - pathLoadedFrom:string -> string - member GenerateOptimizationData : bool - member GenerateSignatureData : bool - member alwaysCallVirt : bool - member baseAddress : int32 option - member checkOverflow : bool - member checksumAlgorithm : AbstractIL.ILPdbWriter.HashAlgorithm - member clrRoot : string option - member compilerToolPaths : string list - member compilingFslib : bool - member conditionalCompilationDefines : string list - member container : string option - member continueAfterParseFailure : bool - member copyFSharpCore : CopyFSharpCoreFlag - member debugSymbolFile : string option - member debuginfo : bool - member delaysign : bool - member deterministic : bool - member doDetuple : bool - member doFinalSimplify : bool - member doTLR : bool - member dumpDebugInfo : bool - member embedAllSource : bool - member embedResources : string list - member embedSourceList : string list - member embeddedPDB : bool - member emitDebugInfoInQuotations : bool - member emitTailcalls : bool - member errorSeverityOptions : ErrorLogger.FSharpErrorSeverityOptions - member errorStyle : ErrorLogger.ErrorStyle - member extraOptimizationIterations : int - member extraStaticLinkRoots : string list - member flatErrors : bool - member framework : bool - member fsharpBinariesDir : string - member generateFilterBlocks : bool - member ignoreSymbolStoreSequencePoints : bool - member implicitIncludeDir : string - member implicitOpens : string list - member implicitlyResolveAssemblies : bool - member importAllReferencesOnly : bool - member includes : string list - member includewin32manifest : bool - member inputCodePage : int option - member internConstantStrings : bool - member internalTestSpanStackReferring : bool - member isInteractive : bool - member isInvalidationSupported : bool - member jitTracking : bool - member knownUnresolvedReferences : UnresolvedAssemblyReference list - member langVersion : Features.LanguageVersion - member lcid : int option - member legacyReferenceResolver : ReferenceResolver.Resolver - member light : bool option - member linkResources : string list - member loadedSources : (Range.range * string * string) list - member maxErrors : int - member metadataVersion : string option - member mlCompatibility : bool - member noConditionalErasure : bool - member noDebugData : bool - member noFeedback : bool - member noSignatureData : bool - member onlyEssentialOptimizationData : bool - member openDebugInformationForLaterStaticLinking : bool - member optSettings : Optimizer.OptimizationSettings - member optsOn : bool - member outputDir : string option - member outputFile : string option - member packageManagerLines : Map - member parseOnly : bool - member pathMap : Internal.Utilities.PathMap - member pause : bool - member platform : AbstractIL.IL.ILPlatform option - member portablePDB : bool - member prefer32Bit : bool - member preferredUiLang : string option - member primaryAssembly : AbstractIL.IL.PrimaryAssembly - member printAst : bool - member printSignature : bool - member printSignatureFile : string - member productNameForBannerText : string - member publicsign : bool - member reduceMemoryUsage : AbstractIL.ILBinaryReader.ReduceMemoryFlag - member referencedDLLs : AssemblyReference list - member reportNumDecls : bool - member resolutionEnvironment : ReferenceResolver.ResolutionEnvironment - member shadowCopyReferences : bool - member showBanner : bool - member showExtensionTypeMessages : bool - member showFullPaths : bool - member showLoadedAssemblies : bool - member showOptimizationData : bool - member showReferenceResolutions : bool - member showTerms : bool - member showTimes : bool - member signer : string option - member simulateException : string option - member sourceLink : string - member stackReserveSize : int32 option - member standalone : bool - member stats : bool - member subsystemVersion : int * int - member target : CompilerTarget - member targetFrameworkVersion : string - member testFlagEmitFeeFeeAs100001 : bool - member testInteractionParser : bool - member tokenizeOnly : bool - member - tryGetMetadataSnapshot : AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot - member typeCheckOnly : bool - member useFsiAuxLib : bool - member useHighEntropyVA : bool - member useIncrementalBuilder : bool - member useOptimizationDataFile : bool - member useSdkRefs : bool - member useSimpleResolution : bool - member utf8output : bool - member version : VersionFlag - member win32manifest : string - member win32res : string - member writeTermsToFiles : bool - member xmlDocOutputFile : string option - end - [] - type TcConfigProvider = - | TcConfigProvider of - (AbstractIL.Internal.Library.CompilationThreadToken -> TcConfig) - with - static member - BasedOnMutableBuilder : TcConfigBuilder -> TcConfigProvider - static member Constant : TcConfig -> TcConfigProvider - member - Get : AbstractIL.Internal.Library.CompilationThreadToken -> TcConfig - end - val GetFSharpCoreLibraryName : unit -> string - end - -namespace FSharp.Compiler - module internal CompilerImports = begin - val ( ++ ) : x:'a list -> s:'a -> 'a list - val IsSignatureDataResource : AbstractIL.IL.ILResource -> bool - val IsOptimizationDataResource : AbstractIL.IL.ILResource -> bool - val GetSignatureDataResourceName : AbstractIL.IL.ILResource -> string - val GetOptimizationDataResourceName : r:AbstractIL.IL.ILResource -> string - val IsReflectedDefinitionsResource : AbstractIL.IL.ILResource -> bool - val MakeILResource : - rName:string -> bytes:byte [] -> AbstractIL.IL.ILResource - val PickleToResource : - inMem:bool -> - file:string -> - g:TcGlobals.TcGlobals -> - scope:TypedTree.CcuThunk -> - rName:string -> - p:TypedTreePickle.pickler<'a> -> - x:'a -> AbstractIL.IL.ILResource - val GetSignatureData : - file:string * ilScopeRef:AbstractIL.IL.ILScopeRef * - ilModule:AbstractIL.IL.ILModuleDef option * - byteReader:(unit -> AbstractIL.Internal.ReadOnlyByteMemory) -> - TypedTreePickle.PickledDataWithReferences - val WriteSignatureData : - CompilerConfig.TcConfig * TcGlobals.TcGlobals * TypedTreeOps.Remap * - TypedTree.CcuThunk * filename:string * inMem:bool -> - AbstractIL.IL.ILResource - val GetOptimizationData : - file:string * ilScopeRef:AbstractIL.IL.ILScopeRef * - ilModule:AbstractIL.IL.ILModuleDef option * - byteReader:(unit -> AbstractIL.Internal.ReadOnlyByteMemory) -> - TypedTreePickle.PickledDataWithReferences - val WriteOptimizationData : - TcGlobals.TcGlobals * filename:string * inMem:bool * TypedTree.CcuThunk * - Optimizer.CcuOptimizationInfo -> AbstractIL.IL.ILResource - exception AssemblyNotResolved of string * Range.range - exception MSBuildReferenceResolutionWarning of string * string * Range.range - exception MSBuildReferenceResolutionError of string * string * Range.range - val OpenILBinary : - filename:string * - reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * - pdbDirPath:string option * shadowCopyReferences:bool * - tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot -> - AbstractIL.ILBinaryReader.ILModuleReader - [] - type ResolveAssemblyReferenceMode = - | Speculative - | ReportErrors - type ResolvedExtensionReference = - | ResolvedExtensionReference of - string * CompilerConfig.AssemblyReference list * - Tainted list - [] - type AssemblyResolution = - { originalReference: CompilerConfig.AssemblyReference - resolvedPath: string - prepareToolTip: unit -> string - sysdir: bool - mutable ilAssemblyRef: AbstractIL.IL.ILAssemblyRef option } - with - member - GetILAssemblyRef : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * - tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot -> - AbstractIL.Internal.Library.Cancellable - override ToString : unit -> string - member ProjectReference : CompilerConfig.IProjectReference option - end - [] - type ImportedBinary = - { FileName: string - RawMetadata: CompilerConfig.IRawFSharpAssemblyData - ProviderGeneratedAssembly: System.Reflection.Assembly option - IsProviderGenerated: bool - ProviderGeneratedStaticLinkMap: - ExtensionTyping.ProvidedAssemblyStaticLinkingMap option - ILAssemblyRefs: AbstractIL.IL.ILAssemblyRef list - ILScopeRef: AbstractIL.IL.ILScopeRef } - [] - type ImportedAssembly = - { ILScopeRef: AbstractIL.IL.ILScopeRef - FSharpViewOfMetadata: TypedTree.CcuThunk - AssemblyAutoOpenAttributes: string list - AssemblyInternalsVisibleToAttributes: string list - IsProviderGenerated: bool - mutable TypeProviders: Tainted list - FSharpOptimizationData: Lazy> } - type AvailableImportedAssembly = - | ResolvedImportedAssembly of ImportedAssembly - | UnresolvedImportedAssembly of string - type CcuLoadFailureAction = - | RaiseError - | ReturnNone - type TcConfig with - member - TryResolveLibWithDirectories : r:CompilerConfig.AssemblyReference -> - AssemblyResolution option - type TcConfig with - member - ResolveLibWithDirectories : ccuLoadFailureAction:CcuLoadFailureAction * - r:CompilerConfig.AssemblyReference -> - AssemblyResolution option - type TcConfig with - member - MsBuildResolve : references:(string * string) [] * - mode:ResolveAssemblyReferenceMode * - errorAndWarningRange:Range.range * showMessages:bool -> - ReferenceResolver.ResolvedFile [] - type TcConfig with - static member - TryResolveLibsUsingMSBuildRules : tcConfig:CompilerConfig.TcConfig * - originalReferences:CompilerConfig.AssemblyReference list * - errorAndWarningRange:Range.range * - mode:ResolveAssemblyReferenceMode -> - AssemblyResolution list * - CompilerConfig.UnresolvedAssemblyReference list - [] - type TcAssemblyResolutions = - class - new : tcConfig:CompilerConfig.TcConfig * results:AssemblyResolution list * - unresolved:CompilerConfig.UnresolvedAssemblyReference list -> - TcAssemblyResolutions - static member - BuildFromPriorResolutions : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfig:CompilerConfig.TcConfig * - AssemblyResolution list * - CompilerConfig.UnresolvedAssemblyReference list -> - TcAssemblyResolutions - static member - GetAllDllReferences : tcConfig:CompilerConfig.TcConfig -> - CompilerConfig.AssemblyReference list - static member - GetAssemblyResolutionInformation : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfig:CompilerConfig.TcConfig -> - AssemblyResolution list * - CompilerConfig.UnresolvedAssemblyReference list - static member - ResolveAssemblyReferences : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfig:CompilerConfig.TcConfig * - assemblyList:CompilerConfig.AssemblyReference list * - knownUnresolved:CompilerConfig.UnresolvedAssemblyReference list -> - TcAssemblyResolutions - static member - SplitNonFoundationalResolutions : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfig:CompilerConfig.TcConfig -> - AssemblyResolution list * - AssemblyResolution list * - CompilerConfig.UnresolvedAssemblyReference list - member - AddResolutionResults : newResults:AssemblyResolution list -> - TcAssemblyResolutions - member - AddUnresolvedReferences : newUnresolved:CompilerConfig.UnresolvedAssemblyReference list -> - TcAssemblyResolutions - member GetAssemblyResolutions : unit -> AssemblyResolution list - member - GetUnresolvedReferences : unit -> - CompilerConfig.UnresolvedAssemblyReference list - member - TryFindByExactILAssemblyRef : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - assemblyRef:AbstractIL.IL.ILAssemblyRef -> - AssemblyResolution option - member - TryFindByOriginalReference : assemblyReference:CompilerConfig.AssemblyReference -> - AssemblyResolution option - member - TryFindByOriginalReferenceText : nm:string -> - AssemblyResolution option - member TryFindByResolvedPath : nm:string -> AssemblyResolution option - member - TryFindBySimpleAssemblyName : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - simpleAssemName:string -> - AssemblyResolution option - end - val GetNameOfILModule : m:AbstractIL.IL.ILModuleDef -> string - val MakeScopeRefForILModule : - ilModule:AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILScopeRef - val GetCustomAttributesOfILModule : - ilModule:AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILAttribute list - val GetAutoOpenAttributes : - ilg:AbstractIL.IL.ILGlobals -> - ilModule:AbstractIL.IL.ILModuleDef -> string list - val GetInternalsVisibleToAttributes : - ilg:AbstractIL.IL.ILGlobals -> - ilModule:AbstractIL.IL.ILModuleDef -> string list - type RawFSharpAssemblyDataBackedByFileOnDisk = - class - interface CompilerConfig.IRawFSharpAssemblyData - new : ilModule:AbstractIL.IL.ILModuleDef * - ilAssemblyRefs:AbstractIL.IL.ILAssemblyRef list -> - RawFSharpAssemblyDataBackedByFileOnDisk - end - [] - type TcImportsSafeDisposal = - class - interface System.IDisposable - new : disposeActions:ResizeArray<(unit -> unit)> * - disposeTypeProviderActions:ResizeArray<(unit -> unit)> -> - TcImportsSafeDisposal - override Finalize : unit -> unit - end - type TcImportsDllInfoHack = - { FileName: string } - and TcImportsWeakHack = - class - new : tcImports:System.WeakReference -> TcImportsWeakHack - member SetDllInfos : value:ImportedBinary list -> unit - member SystemRuntimeContainsType : typeName:string -> bool - member Base : TcImportsWeakHack option - end - [] - and TcImports = - class - interface System.IDisposable - new : tcConfigP:CompilerConfig.TcConfigProvider * - initialResolutions:TcAssemblyResolutions * - importsBase:TcImports option * - ilGlobalsOpt:AbstractIL.IL.ILGlobals option * - dependencyProviderOpt:Microsoft.DotNet.DependencyManager.DependencyProvider option -> - TcImports - static member - BuildFrameworkTcImports : AbstractIL.Internal.Library.CompilationThreadToken * - CompilerConfig.TcConfigProvider * - AssemblyResolution list * - AssemblyResolution list -> - AbstractIL.Internal.Library.Cancellable - static member - BuildNonFrameworkTcImports : AbstractIL.Internal.Library.CompilationThreadToken * - CompilerConfig.TcConfigProvider * - TcGlobals.TcGlobals * TcImports * - AssemblyResolution list * - CompilerConfig.UnresolvedAssemblyReference list * - Microsoft.DotNet.DependencyManager.DependencyProvider -> - AbstractIL.Internal.Library.Cancellable - static member - BuildTcImports : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfigP:CompilerConfig.TcConfigProvider * - dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> - AbstractIL.Internal.Library.Cancellable - member AllAssemblyResolutions : unit -> AssemblyResolution list - member private AttachDisposeAction : action:(unit -> unit) -> unit - member - private AttachDisposeTypeProviderAction : action:(unit -> unit) -> - unit - member - FindCcu : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - m:Range.range * assemblyName:string * lookupOnly:bool -> - TypedTree.CcuResolutionResult - member - FindCcuFromAssemblyRef : AbstractIL.Internal.Library.CompilationThreadToken * - Range.range * AbstractIL.IL.ILAssemblyRef -> - TypedTree.CcuResolutionResult - member - FindCcuInfo : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - m:Range.range * assemblyName:string * lookupOnly:bool -> - AvailableImportedAssembly - member - FindDllInfo : AbstractIL.Internal.Library.CompilationThreadToken * - Range.range * string -> ImportedBinary - member GetCcusExcludingBase : unit -> TypedTree.CcuThunk list - member GetCcusInDeclOrder : unit -> TypedTree.CcuThunk list - member GetDllInfos : unit -> ImportedBinary list - member GetImportMap : unit -> Import.ImportMap - member GetImportedAssemblies : unit -> ImportedAssembly list - member - GetProvidedAssemblyInfo : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - m:Range.range * - assembly:Tainted -> - bool * - ExtensionTyping.ProvidedAssemblyStaticLinkingMap option - member GetTcGlobals : unit -> TcGlobals.TcGlobals - member - ImplicitLoadIfAllowed : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - m:Range.range * assemblyName:string * - lookupOnly:bool -> unit - member - ImportTypeProviderExtensions : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfig:CompilerConfig.TcConfig * - fileNameOfRuntimeAssembly:string * - ilScopeRefOfRuntimeAssembly:AbstractIL.IL.ILScopeRef * - runtimeAssemblyAttributes:AbstractIL.IL.ILAttribute list * - entityToInjectInto:TypedTree.Entity * - invalidateCcu:Event * - m:Range.range -> - Tainted list - member - private InjectProvidedNamespaceOrTypeIntoEntity : typeProviderEnvironment:ExtensionTyping.ResolutionEnvironment * - tcConfig:CompilerConfig.TcConfig * - m:Range.range * - entity:TypedTree.Entity * - injectedNamespace:string list * - remainingNamespace:string list * - provider:Tainted * - st:Tainted option -> - unit - member IsAlreadyRegistered : nm:string -> bool - member - MkLoaderForMultiModuleILAssemblies : ctok:AbstractIL.Internal.Library.CompilationThreadToken -> - m:Range.range -> - (AbstractIL.IL.ILScopeRef -> - AbstractIL.IL.ILModuleDef) - member - OpenILBinaryModule : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - filename:string * m:Range.range -> - AbstractIL.IL.ILModuleDef * - AbstractIL.IL.ILAssemblyRef list - member - PrepareToImportReferencedFSharpAssembly : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - m:Range.range * - filename:string * - dllinfo:ImportedBinary -> - (unit -> - AvailableImportedAssembly list) - member - PrepareToImportReferencedILAssembly : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - m:Range.range * filename:string * - dllinfo:ImportedBinary -> - (unit -> - AvailableImportedAssembly list) - member - RecordGeneratedTypeRoot : root:ExtensionTyping.ProviderGeneratedType -> - unit - member - RegisterAndImportReferencedAssemblies : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - nms:AssemblyResolution list -> - AbstractIL.Internal.Library.Cancellable - member - RegisterAndPrepareToImportReferencedDll : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - r:AssemblyResolution -> - AbstractIL.Internal.Library.Cancellable - AvailableImportedAssembly list)> - member RegisterCcu : ccuInfo:ImportedAssembly -> unit - member RegisterDll : dllInfo:ImportedBinary -> unit - member - ReportUnresolvedAssemblyReferences : CompilerConfig.UnresolvedAssemblyReference list -> - unit - member - ResolveAssemblyReference : AbstractIL.Internal.Library.CompilationThreadToken * - CompilerConfig.AssemblyReference * - ResolveAssemblyReferenceMode -> - AssemblyResolution list - member private SetILGlobals : ilg:AbstractIL.IL.ILGlobals -> unit - member private SetTcGlobals : g:TcGlobals.TcGlobals -> unit - member SystemRuntimeContainsType : string -> bool - override ToString : unit -> string - member - TryFindDllInfo : AbstractIL.Internal.Library.CompilationThreadToken * - Range.range * string * lookupOnly:bool -> - ImportedBinary option - member - TryFindExistingFullyQualifiedPathByExactAssemblyRef : AbstractIL.Internal.Library.CompilationThreadToken * - AbstractIL.IL.ILAssemblyRef -> - string option - member - TryFindExistingFullyQualifiedPathBySimpleAssemblyName : AbstractIL.Internal.Library.CompilationThreadToken * - string -> - string option - member - TryFindProviderGeneratedAssemblyByName : AbstractIL.Internal.Library.CompilationThreadToken * - assemblyName:string -> - System.Reflection.Assembly option - member - TryResolveAssemblyReference : AbstractIL.Internal.Library.CompilationThreadToken * - CompilerConfig.AssemblyReference * - ResolveAssemblyReferenceMode -> - ErrorLogger.OperationResult - member Base : TcImports option - member CcuTable : AbstractIL.Internal.Library.NameMap - member - DependencyProvider : Microsoft.DotNet.DependencyManager.DependencyProvider - member DllTable : AbstractIL.Internal.Library.NameMap - member - ProviderGeneratedTypeRoots : ExtensionTyping.ProviderGeneratedType list - member Weak : TcImportsWeakHack - end - val RequireDLL : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcImports:TcImports * tcEnv:CheckExpressions.TcEnv * - thisAssemblyName:string * referenceRange:Range.range * file:string -> - CheckExpressions.TcEnv * (ImportedBinary list * ImportedAssembly list) - val DefaultReferencesForScriptsAndOutOfProjectSources : bool -> string list - end - -namespace FSharp.Compiler - module internal CompilerDiagnostics = begin - module CompilerService = begin - val showAssertForUnexpectedException : bool ref - end - exception HashIncludeNotAllowedInNonScript of Range.range - exception HashReferenceNotAllowedInNonScript of Range.range - exception HashLoadedSourceHasIssues of exn list * exn list * Range.range - exception HashLoadedScriptConsideredSource of Range.range - exception HashDirectiveNotAllowedInNonScript of Range.range - exception DeprecatedCommandLineOptionFull of string * Range.range - exception DeprecatedCommandLineOptionForHtmlDoc of string * Range.range - exception DeprecatedCommandLineOptionSuggestAlternative of - string * string * - Range.range - exception DeprecatedCommandLineOptionNoDescription of string * Range.range - exception InternalCommandLineOption of string * Range.range - val GetRangeOfDiagnostic : - ErrorLogger.PhasedDiagnostic -> Range.range option - val GetDiagnosticNumber : ErrorLogger.PhasedDiagnostic -> int - val GetWarningLevel : err:ErrorLogger.PhasedDiagnostic -> int - val warningOn : - err:ErrorLogger.PhasedDiagnostic -> - level:int -> specificWarnOn:int list -> bool - val SplitRelatedDiagnostics : - ErrorLogger.PhasedDiagnostic -> - ErrorLogger.PhasedDiagnostic * ErrorLogger.PhasedDiagnostic list - val DeclareMessage : - (string * Printf.StringFormat<'a> -> DiagnosticMessage.ResourceString<'a>) - val SeeAlsoE : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ConstraintSolverTupleDiffLengthsE : - unit -> DiagnosticMessage.ResourceString<(int -> int -> string)> - val ConstraintSolverInfiniteTypesE : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val ConstraintSolverMissingConstraintE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ConstraintSolverTypesNotInEqualityRelation1E : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val ConstraintSolverTypesNotInEqualityRelation2E : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val ConstraintSolverTypesNotInSubsumptionRelationE : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ErrorFromAddingTypeEquation1E : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ErrorFromAddingTypeEquation2E : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ErrorFromApplyingDefault1E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ErrorFromApplyingDefault2E : - unit -> DiagnosticMessage.ResourceString - val ErrorsFromAddingSubsumptionConstraintE : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val UpperCaseIdentifierInPatternE : - unit -> DiagnosticMessage.ResourceString - val NotUpperCaseConstructorE : - unit -> DiagnosticMessage.ResourceString - val FunctionExpectedE : unit -> DiagnosticMessage.ResourceString - val BakedInMemberConstraintNameE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val BadEventTransformationE : - unit -> DiagnosticMessage.ResourceString - val ParameterlessStructCtorE : - unit -> DiagnosticMessage.ResourceString - val InterfaceNotRevealedE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val TyconBadArgsE : - unit -> DiagnosticMessage.ResourceString<(string -> int -> int -> string)> - val IndeterminateTypeE : unit -> DiagnosticMessage.ResourceString - val NameClash1E : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val NameClash2E : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> - string -> string -> string)> - val Duplicate1E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val Duplicate2E : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val UndefinedName2E : unit -> DiagnosticMessage.ResourceString - val FieldNotMutableE : unit -> DiagnosticMessage.ResourceString - val FieldsFromDifferentTypesE : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val VarBoundTwiceE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val RecursionE : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> - string -> string)> - val InvalidRuntimeCoercionE : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val IndeterminateRuntimeCoercionE : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val IndeterminateStaticCoercionE : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val StaticCoercionShouldUseBoxE : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val TypeIsImplicitlyAbstractE : - unit -> DiagnosticMessage.ResourceString - val NonRigidTypar1E : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val NonRigidTypar2E : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val NonRigidTypar3E : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val OBlockEndSentenceE : unit -> DiagnosticMessage.ResourceString - val UnexpectedEndOfInputE : unit -> DiagnosticMessage.ResourceString - val UnexpectedE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val NONTERM_interactionE : unit -> DiagnosticMessage.ResourceString - val NONTERM_hashDirectiveE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_fieldDeclE : unit -> DiagnosticMessage.ResourceString - val NONTERM_unionCaseReprE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_localBindingE : unit -> DiagnosticMessage.ResourceString - val NONTERM_hardwhiteLetBindingsE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_classDefnMemberE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_defnBindingsE : unit -> DiagnosticMessage.ResourceString - val NONTERM_classMemberSpfnE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_valSpfnE : unit -> DiagnosticMessage.ResourceString - val NONTERM_tyconSpfnE : unit -> DiagnosticMessage.ResourceString - val NONTERM_anonLambdaExprE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_attrUnionCaseDeclE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_cPrototypeE : unit -> DiagnosticMessage.ResourceString - val NONTERM_objectImplementationMembersE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_ifExprCasesE : unit -> DiagnosticMessage.ResourceString - val NONTERM_openDeclE : unit -> DiagnosticMessage.ResourceString - val NONTERM_fileModuleSpecE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_patternClausesE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_beginEndExprE : unit -> DiagnosticMessage.ResourceString - val NONTERM_recdExprE : unit -> DiagnosticMessage.ResourceString - val NONTERM_tyconDefnE : unit -> DiagnosticMessage.ResourceString - val NONTERM_exconCoreE : unit -> DiagnosticMessage.ResourceString - val NONTERM_typeNameInfoE : unit -> DiagnosticMessage.ResourceString - val NONTERM_attributeListE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_quoteExprE : unit -> DiagnosticMessage.ResourceString - val NONTERM_typeConstraintE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_ImplementationFileE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_DefinitionE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_SignatureFileE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_PatternE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_ExprE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_Category_TypeE : - unit -> DiagnosticMessage.ResourceString - val NONTERM_typeArgsActualE : - unit -> DiagnosticMessage.ResourceString - val TokenName1E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val TokenName1TokenName2E : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val TokenName1TokenName2TokenName3E : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val RuntimeCoercionSourceSealed1E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val RuntimeCoercionSourceSealed2E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val CoercionTargetSealedE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UpcastUnnecessaryE : unit -> DiagnosticMessage.ResourceString - val TypeTestUnnecessaryE : unit -> DiagnosticMessage.ResourceString - val OverrideDoesntOverride1E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val OverrideDoesntOverride2E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val OverrideDoesntOverride3E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val OverrideDoesntOverride4E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UnionCaseWrongArgumentsE : - unit -> DiagnosticMessage.ResourceString<(int -> int -> string)> - val UnionPatternsBindDifferentNamesE : - unit -> DiagnosticMessage.ResourceString - val RequiredButNotSpecifiedE : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val UseOfAddressOfOperatorE : - unit -> DiagnosticMessage.ResourceString - val DefensiveCopyWarningE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val DeprecatedThreadStaticBindingWarningE : - unit -> DiagnosticMessage.ResourceString - val FunctionValueUnexpectedE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UnitTypeExpectedE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UnitTypeExpectedWithEqualityE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UnitTypeExpectedWithPossiblePropertySetterE : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val UnitTypeExpectedWithPossibleAssignmentE : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val UnitTypeExpectedWithPossibleAssignmentToMutableE : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val RecursiveUseCheckedAtRuntimeE : - unit -> DiagnosticMessage.ResourceString - val LetRecUnsound1E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val LetRecUnsound2E : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val LetRecUnsoundInnerE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val LetRecEvaluatedOutOfOrderE : - unit -> DiagnosticMessage.ResourceString - val LetRecCheckedAtRuntimeE : - unit -> DiagnosticMessage.ResourceString - val SelfRefObjCtor1E : unit -> DiagnosticMessage.ResourceString - val SelfRefObjCtor2E : unit -> DiagnosticMessage.ResourceString - val VirtualAugmentationOnNullValuedTypeE : - unit -> DiagnosticMessage.ResourceString - val NonVirtualAugmentationOnNullValuedTypeE : - unit -> DiagnosticMessage.ResourceString - val NonUniqueInferredAbstractSlot1E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val NonUniqueInferredAbstractSlot2E : - unit -> DiagnosticMessage.ResourceString - val NonUniqueInferredAbstractSlot3E : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val NonUniqueInferredAbstractSlot4E : - unit -> DiagnosticMessage.ResourceString - val Failure3E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val Failure4E : unit -> DiagnosticMessage.ResourceString<(string -> string)> - val MatchIncomplete1E : unit -> DiagnosticMessage.ResourceString - val MatchIncomplete2E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val MatchIncomplete3E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val MatchIncomplete4E : unit -> DiagnosticMessage.ResourceString - val RuleNeverMatchedE : unit -> DiagnosticMessage.ResourceString - val EnumMatchIncomplete1E : unit -> DiagnosticMessage.ResourceString - val ValNotMutableE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ValNotLocalE : unit -> DiagnosticMessage.ResourceString - val Obsolete1E : unit -> DiagnosticMessage.ResourceString - val Obsolete2E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ExperimentalE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val PossibleUnverifiableCodeE : - unit -> DiagnosticMessage.ResourceString - val DeprecatedE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val LibraryUseOnlyE : unit -> DiagnosticMessage.ResourceString - val MissingFieldsE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ValueRestriction1E : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ValueRestriction2E : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ValueRestriction3E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val ValueRestriction4E : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val ValueRestriction5E : - unit -> - DiagnosticMessage.ResourceString<(string -> string -> string -> string)> - val RecoverableParseErrorE : - unit -> DiagnosticMessage.ResourceString - val ReservedKeywordE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val IndentationProblemE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val OverrideInIntrinsicAugmentationE : - unit -> DiagnosticMessage.ResourceString - val OverrideInExtrinsicAugmentationE : - unit -> DiagnosticMessage.ResourceString - val IntfImplInIntrinsicAugmentationE : - unit -> DiagnosticMessage.ResourceString - val IntfImplInExtrinsicAugmentationE : - unit -> DiagnosticMessage.ResourceString - val UnresolvedReferenceNoRangeE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val UnresolvedPathReferenceNoRangeE : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val HashIncludeNotAllowedInNonScriptE : - unit -> DiagnosticMessage.ResourceString - val HashReferenceNotAllowedInNonScriptE : - unit -> DiagnosticMessage.ResourceString - val HashDirectiveNotAllowedInNonScriptE : - unit -> DiagnosticMessage.ResourceString - val FileNameNotResolvedE : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val AssemblyNotResolvedE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val HashLoadedSourceHasIssues1E : - unit -> DiagnosticMessage.ResourceString - val HashLoadedSourceHasIssues2E : - unit -> DiagnosticMessage.ResourceString - val HashLoadedScriptConsideredSourceE : - unit -> DiagnosticMessage.ResourceString - val InvalidInternalsVisibleToAssemblyName1E : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val InvalidInternalsVisibleToAssemblyName2E : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val LoadedSourceNotFoundIgnoringE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val MSBuildReferenceResolutionErrorE : - unit -> DiagnosticMessage.ResourceString<(string -> string -> string)> - val TargetInvocationExceptionWrapperE : - unit -> DiagnosticMessage.ResourceString<(string -> string)> - val getErrorString : key:string -> string - val ( |InvalidArgument|_| ) : exn:exn -> string option - val OutputPhasedErrorR : - os:System.Text.StringBuilder -> - err:ErrorLogger.PhasedDiagnostic -> canSuggestNames:bool -> unit - val OutputPhasedDiagnostic : - System.Text.StringBuilder -> - ErrorLogger.PhasedDiagnostic -> - flattenErrors:bool -> suggestNames:bool -> unit - val SanitizeFileName : - fileName:string -> implicitIncludeDir:string -> string - [] - type DiagnosticLocation = - { Range: Range.range - File: string - TextRepresentation: string - IsEmpty: bool } - [] - type DiagnosticCanonicalInformation = - { ErrorNumber: int - Subcategory: string - TextRepresentation: string } - [] - type DiagnosticDetailedInfo = - { Location: DiagnosticLocation option - Canonical: DiagnosticCanonicalInformation - Message: string } - [] - type Diagnostic = - | Short of bool * string - | Long of bool * DiagnosticDetailedInfo - val CollectDiagnostic : - implicitIncludeDir:string * showFullPaths:bool * flattenErrors:bool * - errorStyle:ErrorLogger.ErrorStyle * isError:bool * - ErrorLogger.PhasedDiagnostic * suggestNames:bool -> seq - val OutputDiagnostic : - implicitIncludeDir:string * showFullPaths:bool * flattenErrors:bool * - errorStyle:ErrorLogger.ErrorStyle * isError:bool -> - System.Text.StringBuilder -> ErrorLogger.PhasedDiagnostic -> unit - val OutputDiagnosticContext : - prefix:string -> - fileLineFunction:(string -> int -> string) -> - System.Text.StringBuilder -> ErrorLogger.PhasedDiagnostic -> unit - val ReportWarning : - ErrorLogger.FSharpErrorSeverityOptions -> - ErrorLogger.PhasedDiagnostic -> bool - val ReportWarningAsError : - ErrorLogger.FSharpErrorSeverityOptions -> - ErrorLogger.PhasedDiagnostic -> bool - type ErrorLoggerFilteringByScopedPragmas = - class - inherit ErrorLogger.ErrorLogger - new : checkFile:bool * scopedPragmas:SyntaxTree.ScopedPragma list * - errorLogger:ErrorLogger.ErrorLogger -> - ErrorLoggerFilteringByScopedPragmas - override - DiagnosticSink : phasedError:ErrorLogger.PhasedDiagnostic * - isError:bool -> unit - override ErrorCount : int - end - val GetErrorLoggerFilteringByScopedPragmas : - checkFile:bool * SyntaxTree.ScopedPragma list * ErrorLogger.ErrorLogger -> - ErrorLogger.ErrorLogger - end - -namespace FSharp.Compiler - module internal ParseAndCheckInputs = begin - val CanonicalizeFilename : filename:string -> string - val IsScript : string -> bool - val QualFileNameOfModuleName : - m:Range.range -> - filename:string -> - modname:SyntaxTree.Ident list -> SyntaxTree.QualifiedNameOfFile - val QualFileNameOfFilename : - m:Range.range -> filename:string -> SyntaxTree.QualifiedNameOfFile - val ComputeQualifiedNameOfFileFromUniquePath : - Range.range * string list -> SyntaxTree.QualifiedNameOfFile - val QualFileNameOfSpecs : - filename:string -> - specs:SyntaxTree.SynModuleOrNamespaceSig list -> - SyntaxTree.QualifiedNameOfFile - val QualFileNameOfImpls : - filename:string -> - specs:SyntaxTree.SynModuleOrNamespace list -> - SyntaxTree.QualifiedNameOfFile - val PrependPathToQualFileName : - x:SyntaxTree.Ident list -> - SyntaxTree.QualifiedNameOfFile -> SyntaxTree.QualifiedNameOfFile - val PrependPathToImpl : - x:SyntaxTree.Ident list -> - SyntaxTree.SynModuleOrNamespace -> SyntaxTree.SynModuleOrNamespace - val PrependPathToSpec : - x:SyntaxTree.Ident list -> - SyntaxTree.SynModuleOrNamespaceSig -> SyntaxTree.SynModuleOrNamespaceSig - val PrependPathToInput : - SyntaxTree.Ident list -> SyntaxTree.ParsedInput -> SyntaxTree.ParsedInput - val ComputeAnonModuleName : - check:bool -> - defaultNamespace:string option -> - filename:string -> m:Range.range -> SyntaxTree.Ident list - val PostParseModuleImpl : - _i:'a * defaultNamespace:string option * isLastCompiland:(bool * bool) * - filename:string * impl:SyntaxTree.ParsedImplFileFragment -> - SyntaxTree.SynModuleOrNamespace - val PostParseModuleSpec : - _i:'a * defaultNamespace:string option * isLastCompiland:(bool * bool) * - filename:string * intf:SyntaxTree.ParsedSigFileFragment -> - SyntaxTree.SynModuleOrNamespaceSig - val GetScopedPragmasForInput : - input:SyntaxTree.ParsedInput -> SyntaxTree.ScopedPragma list - val GetScopedPragmasForHashDirective : - hd:SyntaxTree.ParsedHashDirective -> SyntaxTree.ScopedPragma list - val PostParseModuleImpls : - defaultNamespace:string option * filename:string * - isLastCompiland:(bool * bool) * SyntaxTree.ParsedImplFile -> - SyntaxTree.ParsedInput - val PostParseModuleSpecs : - defaultNamespace:string option * filename:string * - isLastCompiland:(bool * bool) * SyntaxTree.ParsedSigFile -> - SyntaxTree.ParsedInput - type ModuleNamesDict = - Map> - val DeduplicateModuleName : - moduleNamesDict:ModuleNamesDict -> - fileName:string -> - qualNameOfFile:SyntaxTree.QualifiedNameOfFile -> - SyntaxTree.QualifiedNameOfFile * ModuleNamesDict - val DeduplicateParsedInputModuleName : - ModuleNamesDict -> - SyntaxTree.ParsedInput -> SyntaxTree.ParsedInput * ModuleNamesDict - val ParseInput : - (Internal.Utilities.Text.Lexing.LexBuffer -> Parser.token) * - ErrorLogger.ErrorLogger * UnicodeLexing.Lexbuf * string option * string * - isLastCompiland:(bool * bool) -> SyntaxTree.ParsedInput - val ShowAllTokensAndExit : - shortFilename:string * tokenizer:LexFilter.LexFilter * - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> unit - val TestInteractionParserAndExit : - tokenizer:LexFilter.LexFilter * - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> 'a - val ReportParsingStatistics : res:SyntaxTree.ParsedInput -> unit - val ParseOneInputLexbuf : - tcConfig:CompilerConfig.TcConfig * - lexResourceManager:Lexhelp.LexResourceManager * - conditionalCompilationDefines:string list * lexbuf:UnicodeLexing.Lexbuf * - filename:string * isLastCompiland:(bool * bool) * - errorLogger:ErrorLogger.ErrorLogger -> SyntaxTree.ParsedInput option - val ValidSuffixes : string list - val ParseOneInputFile : - CompilerConfig.TcConfig * Lexhelp.LexResourceManager * string list * - string * isLastCompiland:(bool * bool) * ErrorLogger.ErrorLogger * bool -> - SyntaxTree.ParsedInput option - val ProcessMetaCommandsFromInput : - (('T -> Range.range * string -> 'T) * - ('T -> Range.range * string * CompilerConfig.Directive -> 'T) * - ('T -> Range.range * string -> unit)) -> - CompilerConfig.TcConfigBuilder * SyntaxTree.ParsedInput * string * 'T -> - 'T - val ApplyNoWarnsToTcConfig : - CompilerConfig.TcConfig * SyntaxTree.ParsedInput * string -> - CompilerConfig.TcConfig - val ApplyMetaCommandsFromInputToTcConfig : - CompilerConfig.TcConfig * SyntaxTree.ParsedInput * string * - Microsoft.DotNet.DependencyManager.DependencyProvider -> - CompilerConfig.TcConfig - val GetInitialTcEnv : - assemblyName:string * Range.range * CompilerConfig.TcConfig * - CompilerImports.TcImports * TcGlobals.TcGlobals -> CheckExpressions.TcEnv - val CheckSimulateException : tcConfig:CompilerConfig.TcConfig -> unit - type RootSigs = - AbstractIL.Internal.Zmap - type RootImpls = AbstractIL.Internal.Zset - val qnameOrder : - System.Collections.Generic.IComparer - [] - type TcState = - { tcsCcu: TypedTree.CcuThunk - tcsCcuType: TypedTree.ModuleOrNamespace - tcsNiceNameGen: CompilerGlobalState.NiceNameGenerator - tcsTcSigEnv: CheckExpressions.TcEnv - tcsTcImplEnv: CheckExpressions.TcEnv - tcsCreatesGeneratedProvidedTypes: bool - tcsRootSigs: RootSigs - tcsRootImpls: RootImpls - tcsCcuSig: TypedTree.ModuleOrNamespaceType } - with - member - NextStateAfterIncrementalFragment : CheckExpressions.TcEnv -> TcState - member Ccu : TypedTree.CcuThunk - member CcuSig : TypedTree.ModuleOrNamespaceType - member CcuType : TypedTree.ModuleOrNamespace - member CreatesGeneratedProvidedTypes : bool - member NiceNameGenerator : CompilerGlobalState.NiceNameGenerator - member TcEnvFromImpls : CheckExpressions.TcEnv - member TcEnvFromSignatures : CheckExpressions.TcEnv - end - val GetInitialTcState : - Range.range * string * CompilerConfig.TcConfig * TcGlobals.TcGlobals * - CompilerImports.TcImports * CompilerGlobalState.NiceNameGenerator * - CheckExpressions.TcEnv -> TcState - val TypeCheckOneInputEventually : - checkForErrors:(unit -> bool) * CompilerConfig.TcConfig * - CompilerImports.TcImports * TcGlobals.TcGlobals * - SyntaxTree.LongIdent option * NameResolution.TcResultsSink * TcState * - SyntaxTree.ParsedInput * skipImplIfSigExists:bool -> - AbstractIL.Internal.Library.Eventually<(CheckExpressions.TcEnv * - CheckDeclarations.TopAttribs * - TypedTree.TypedImplFile option * - TypedTree.ModuleOrNamespaceType) * - TcState> - val TypeCheckOneInput : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - checkForErrors:(unit -> bool) * tcConfig:CompilerConfig.TcConfig * - tcImports:CompilerImports.TcImports * tcGlobals:TcGlobals.TcGlobals * - prefixPathOpt:SyntaxTree.LongIdent option -> - tcState:TcState -> - inp:SyntaxTree.ParsedInput -> - (CheckExpressions.TcEnv * CheckDeclarations.TopAttribs * - TypedTree.TypedImplFile option * TypedTree.ModuleOrNamespaceType) * - TcState - val TypeCheckMultipleInputsFinish : - (CheckExpressions.TcEnv * CheckDeclarations.TopAttribs * 'T option * 'U) list * - TcState -> - (CheckExpressions.TcEnv * CheckDeclarations.TopAttribs * 'T list * - 'U list) * TcState - val TypeCheckOneInputAndFinishEventually : - checkForErrors:(unit -> bool) * CompilerConfig.TcConfig * - CompilerImports.TcImports * TcGlobals.TcGlobals * - SyntaxTree.LongIdent option * NameResolution.TcResultsSink * TcState * - SyntaxTree.ParsedInput -> - AbstractIL.Internal.Library.Eventually<(CheckExpressions.TcEnv * - CheckDeclarations.TopAttribs * - TypedTree.TypedImplFile list * - TypedTree.ModuleOrNamespaceType list) * - TcState> - val TypeCheckClosedInputSetFinish : - TypedTree.TypedImplFile list * TcState -> - TcState * TypedTree.TypedImplFile list - val TypeCheckClosedInputSet : - AbstractIL.Internal.Library.CompilationThreadToken * - checkForErrors:(unit -> bool) * CompilerConfig.TcConfig * - CompilerImports.TcImports * TcGlobals.TcGlobals * - SyntaxTree.LongIdent option * TcState * SyntaxTree.ParsedInput list -> - TcState * CheckDeclarations.TopAttribs * TypedTree.TypedImplFile list * - CheckExpressions.TcEnv - end - -namespace FSharp.Compiler - module internal ScriptClosure = begin - [] - type LoadClosureInput = - { FileName: string - SyntaxTree: SyntaxTree.ParsedInput option - ParseDiagnostics: (ErrorLogger.PhasedDiagnostic * bool) list - MetaCommandDiagnostics: (ErrorLogger.PhasedDiagnostic * bool) list } - [] - type LoadClosure = - { SourceFiles: (string * Range.range list) list - References: (string * CompilerImports.AssemblyResolution list) list - PackageReferences: (Range.range * string list) [] - UnresolvedReferences: CompilerConfig.UnresolvedAssemblyReference list - Inputs: LoadClosureInput list - OriginalLoadReferences: (Range.range * string * string) list - NoWarns: (string * Range.range list) list - ResolutionDiagnostics: (ErrorLogger.PhasedDiagnostic * bool) list - AllRootFileDiagnostics: (ErrorLogger.PhasedDiagnostic * bool) list - LoadClosureRootFileDiagnostics: - (ErrorLogger.PhasedDiagnostic * bool) list } - with - static member - ComputeClosureOfScriptFiles : AbstractIL.Internal.Library.CompilationThreadToken * - tcConfig:CompilerConfig.TcConfig * - (string * Range.range) list * - implicitDefines:CodeContext * - lexResourceManager:Lexhelp.LexResourceManager * - dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> - LoadClosure - static member - ComputeClosureOfScriptText : AbstractIL.Internal.Library.CompilationThreadToken * - legacyReferenceResolver:ReferenceResolver.Resolver * - defaultFSharpBinariesDir:string * - filename:string * - sourceText:Text.ISourceText * - implicitDefines:CodeContext * - useSimpleResolution:bool * - useFsiAuxLib:bool * useSdkRefs:bool * - lexResourceManager:Lexhelp.LexResourceManager * - applyCompilerOptions:(CompilerConfig.TcConfigBuilder -> - unit) * - assumeDotNetFramework:bool * - tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * - reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * - dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> - LoadClosure - end - [] - type CodeContext = - | CompilationAndEvaluation - | Compilation - | Editing - module ScriptPreprocessClosure = begin - type ClosureSource = - | ClosureSource of - filename: string * referenceRange: Range.range * - sourceText: Text.ISourceText * parseRequired: bool - type ClosureFile = - | ClosureFile of - string * Range.range * SyntaxTree.ParsedInput option * - (ErrorLogger.PhasedDiagnostic * bool) list * - (ErrorLogger.PhasedDiagnostic * bool) list * - (string * Range.range) list - type Observed = - class - new : unit -> Observed - member HaveSeen : check:string -> bool - member SetSeen : check:string -> unit - end - val ParseScriptText : - filename:string * sourceText:Text.ISourceText * - tcConfig:CompilerConfig.TcConfig * codeContext:CodeContext * - lexResourceManager:Lexhelp.LexResourceManager * - errorLogger:ErrorLogger.ErrorLogger -> SyntaxTree.ParsedInput option - val CreateScriptTextTcConfig : - legacyReferenceResolver:ReferenceResolver.Resolver * - defaultFSharpBinariesDir:string * filename:string * - codeContext:CodeContext * useSimpleResolution:bool * useFsiAuxLib:bool * - basicReferences:#seq option * - applyCommandLineArgs:(CompilerConfig.TcConfigBuilder -> unit) * - assumeDotNetFramework:bool * useSdkRefs:bool * - tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * - reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag -> - CompilerConfig.TcConfig - val ClosureSourceOfFilename : - filename:string * m:Range.range * inputCodePage:int option * - parseRequired:bool -> ClosureSource list - val ApplyMetaCommandsFromInputToTcConfigAndGatherNoWarn : - tcConfig:CompilerConfig.TcConfig * inp:SyntaxTree.ParsedInput * - pathOfMetaCommandSource:string * - dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> - CompilerConfig.TcConfig * (string * Range.range) list - val FindClosureFiles : - mainFile:string * _m:'a * closureSources:ClosureSource list * - origTcConfig:CompilerConfig.TcConfig * codeContext:CodeContext * - lexResourceManager:Lexhelp.LexResourceManager * - dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> - ClosureFile list * CompilerConfig.TcConfig * - (Range.range * string list) [] - val GetLoadClosure : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - rootFilename:string * closureFiles:ClosureFile list * - tcConfig:CompilerConfig.TcConfig * codeContext:CodeContext * - packageReferences:(Range.range * string list) [] -> LoadClosure - val GetFullClosureOfScriptText : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - legacyReferenceResolver:ReferenceResolver.Resolver * - defaultFSharpBinariesDir:string * filename:string * - sourceText:Text.ISourceText * codeContext:CodeContext * - useSimpleResolution:bool * useFsiAuxLib:bool * useSdkRefs:bool * - lexResourceManager:Lexhelp.LexResourceManager * - applyCommandLineArgs:(CompilerConfig.TcConfigBuilder -> unit) * - assumeDotNetFramework:bool * - tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * - reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * - dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> - LoadClosure - val GetFullClosureOfScriptFiles : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfig:CompilerConfig.TcConfig * files:(string * Range.range) list * - codeContext:CodeContext * lexResourceManager:Lexhelp.LexResourceManager * - dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> - LoadClosure - end - end - -namespace FSharp.Compiler - module internal CompilerOptions = begin - module Attributes = begin - end - [] - type OptionSwitch = - | On - | Off - type OptionSpec = - | OptionClear of bool ref - | OptionFloat of (float -> unit) - | OptionInt of (int -> unit) - | OptionSwitch of (OptionSwitch -> unit) - | OptionIntList of (int -> unit) - | OptionIntListSwitch of (int -> OptionSwitch -> unit) - | OptionRest of (string -> unit) - | OptionSet of bool ref - | OptionString of (string -> unit) - | OptionStringList of (string -> unit) - | OptionStringListSwitch of (string -> OptionSwitch -> unit) - | OptionUnit of (unit -> unit) - | OptionHelp of (CompilerOptionBlock list -> unit) - | OptionGeneral of (string list -> bool) * (string list -> string list) - and CompilerOption = - | CompilerOption of - string * string * OptionSpec * Option * string option - and CompilerOptionBlock = - | PublicOptions of string * CompilerOption list - | PrivateOptions of CompilerOption list - val GetOptionsOfBlock : block:CompilerOptionBlock -> CompilerOption list - val FilterCompilerOptionBlock : - (CompilerOption -> bool) -> CompilerOptionBlock -> CompilerOptionBlock - val compilerOptionUsage : CompilerOption -> string - val PrintCompilerOption : CompilerOption -> unit - val PrintPublicOptions : heading:string * opts:CompilerOption list -> unit - val PrintCompilerOptionBlocks : CompilerOptionBlock list -> unit - val dumpCompilerOption : prefix:string -> CompilerOption -> unit - val dumpCompilerOptionBlock : _arg1:CompilerOptionBlock -> unit - val DumpCompilerOptionBlocks : CompilerOptionBlock list -> unit - val isSlashOpt : opt:string -> bool - module ResponseFile = begin - type ResponseFileData = ResponseFileLine list - and ResponseFileLine = - | CompilerOptionSpec of string - | Comment of string - val parseFile : path:string -> Choice - end - val ParseCompilerOptions : - (string -> unit) * CompilerOptionBlock list * string list -> unit - val lexFilterVerbose : bool - val mutable enableConsoleColoring : bool - val setFlag : r:(bool -> 'a) -> n:int -> 'a - val SetOptimizeOff : tcConfigB:CompilerConfig.TcConfigBuilder -> unit - val SetOptimizeOn : tcConfigB:CompilerConfig.TcConfigBuilder -> unit - val SetOptimizeSwitch : - CompilerConfig.TcConfigBuilder -> OptionSwitch -> unit - val SetTailcallSwitch : - CompilerConfig.TcConfigBuilder -> OptionSwitch -> unit - val SetDeterministicSwitch : - tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val AddPathMapping : - tcConfigB:CompilerConfig.TcConfigBuilder -> pathPair:string -> unit - val jitoptimizeSwitch : - tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val localoptimizeSwitch : - tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val crossOptimizeSwitch : - tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val splittingSwitch : - tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val callVirtSwitch : - tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val useHighEntropyVASwitch : - tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val subSystemVersionSwitch : - tcConfigB:CompilerConfig.TcConfigBuilder -> text:string -> unit - val SetUseSdkSwitch : - tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val ( ++ ) : x:'a list -> s:'a -> 'a list - val SetTarget : tcConfigB:CompilerConfig.TcConfigBuilder -> s:string -> unit - val SetDebugSwitch : - CompilerConfig.TcConfigBuilder -> string option -> OptionSwitch -> unit - val SetEmbedAllSourceSwitch : - tcConfigB:CompilerConfig.TcConfigBuilder -> switch:OptionSwitch -> unit - val setOutFileName : - tcConfigB:CompilerConfig.TcConfigBuilder -> path:string -> unit - val setSignatureFile : - tcConfigB:CompilerConfig.TcConfigBuilder -> s:string -> unit - val tagString : string - val tagExe : string - val tagWinExe : string - val tagLibrary : string - val tagModule : string - val tagFile : string - val tagFileList : string - val tagDirList : string - val tagPathList : string - val tagResInfo : string - val tagFullPDBOnlyPortable : string - val tagWarnList : string - val tagSymbolList : string - val tagAddress : string - val tagAlgorithm : string - val tagInt : string - val tagPathMap : string - val tagNone : string - val tagLangVersionValues : string - val PrintOptionInfo : CompilerConfig.TcConfigBuilder -> unit - val inputFileFlagsBoth : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val referenceFlagAbbrev : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val compilerToolFlagAbbrev : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val inputFileFlagsFsc : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val inputFileFlagsFsiBase : - _tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val inputFileFlagsFsi : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val errorsAndWarningsFlags : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val outputFileFlagsFsi : - _tcConfigB:CompilerConfig.TcConfigBuilder -> 'a list - val outputFileFlagsFsc : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val resourcesFlagsFsi : _tcConfigB:CompilerConfig.TcConfigBuilder -> 'a list - val resourcesFlagsFsc : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val codeGenerationFlags : - isFsi:bool -> - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val defineSymbol : - tcConfigB:CompilerConfig.TcConfigBuilder -> s:string -> unit - val mlCompatibilityFlag : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val setLanguageVersion : specifiedVersion:string -> Features.LanguageVersion - val languageFlags : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val libFlag : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val codePageFlag : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val preferredUiLang : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val utf8OutputFlag : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val fullPathsFlag : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val cliRootFlag : - _tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val SetTargetProfile : CompilerConfig.TcConfigBuilder -> string -> unit - val advancedFlagsBoth : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val noFrameworkFlag : - isFsc:bool -> tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val advancedFlagsFsi : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val advancedFlagsFsc : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val testFlag : tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val editorSpecificFlags : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val internalFlags : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val compilingFsLibFlag : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val compilingFsLib20Flag : CompilerOption - val compilingFsLib40Flag : CompilerOption - val compilingFsLibNoBigIntFlag : CompilerOption - val mlKeywordsFlag : CompilerOption - val gnuStyleErrorsFlag : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption - val deprecatedFlagsBoth : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val deprecatedFlagsFsi : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val deprecatedFlagsFsc : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val DisplayBannerText : CompilerConfig.TcConfigBuilder -> unit - val displayHelpFsc : - tcConfigB:CompilerConfig.TcConfigBuilder -> - blocks:CompilerOptionBlock list -> 'a - val displayVersion : tcConfigB:CompilerConfig.TcConfigBuilder -> 'a - val miscFlagsBoth : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val miscFlagsFsc : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val miscFlagsFsi : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val abbreviatedFlagsBoth : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val abbreviatedFlagsFsi : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val abbreviatedFlagsFsc : - tcConfigB:CompilerConfig.TcConfigBuilder -> CompilerOption list - val GetAbbrevFlagSet : CompilerConfig.TcConfigBuilder -> bool -> Set - val PostProcessCompilerArgs : Set -> string [] -> string list - val testingAndQAFlags : _tcConfigB:'a -> CompilerOption list - val GetCoreFscCompilerOptions : - CompilerConfig.TcConfigBuilder -> CompilerOptionBlock list - val GetCoreServiceCompilerOptions : - CompilerConfig.TcConfigBuilder -> CompilerOptionBlock list - val GetCoreFsiCompilerOptions : - CompilerConfig.TcConfigBuilder -> CompilerOptionBlock list - val ApplyCommandLineArgs : - tcConfigB:CompilerConfig.TcConfigBuilder * sourceFiles:string list * - argv:string list -> string list - val mutable showTermFileCount : int - val PrintWholeAssemblyImplementation : - g:TcGlobals.TcGlobals -> - tcConfig:CompilerConfig.TcConfig -> - outfile:string -> - header:string -> expr:TypedTree.TypedImplFile list -> unit - val mutable tPrev : (float * int []) option - val mutable nPrev : string option - val ReportTime : CompilerConfig.TcConfig -> string -> unit - val ignoreFailureOnMono1_1_16 : (unit -> unit) -> unit - val foreBackColor : - unit -> (System.ConsoleColor * System.ConsoleColor) option - val DoWithColor : System.ConsoleColor -> (unit -> 'a) -> 'a - val DoWithErrorColor : bool -> (unit -> 'a) -> 'a - end - -namespace FSharp.Compiler - module internal OptimizeInputs = begin - val mutable showTermFileCount : int - val PrintWholeAssemblyImplementation : - g:TcGlobals.TcGlobals -> - tcConfig:CompilerConfig.TcConfig -> - outfile:string -> - header:string -> expr:TypedTree.TypedImplFile list -> unit - val AddExternalCcuToOptimizationEnv : - TcGlobals.TcGlobals -> - Optimizer.IncrementalOptimizationEnv -> - CompilerImports.ImportedAssembly -> - Optimizer.IncrementalOptimizationEnv - val GetInitialOptimizationEnv : - CompilerImports.TcImports * TcGlobals.TcGlobals -> - Optimizer.IncrementalOptimizationEnv - val ApplyAllOptimizations : - CompilerConfig.TcConfig * TcGlobals.TcGlobals * ConstraintSolver.TcValF * - string * Import.ImportMap * bool * Optimizer.IncrementalOptimizationEnv * - TypedTree.CcuThunk * TypedTree.TypedImplFile list -> - TypedTree.TypedAssemblyAfterOptimization * Optimizer.CcuOptimizationInfo * - Optimizer.IncrementalOptimizationEnv - val CreateIlxAssemblyGenerator : - CompilerConfig.TcConfig * CompilerImports.TcImports * TcGlobals.TcGlobals * - ConstraintSolver.TcValF * TypedTree.CcuThunk -> - IlxGen.IlxAssemblyGenerator - val GenerateIlxCode : - IlxGen.IlxGenBackend * isInteractiveItExpr:bool * isInteractiveOnMono:bool * - CompilerConfig.TcConfig * CheckDeclarations.TopAttribs * - TypedTree.TypedAssemblyAfterOptimization * fragName:string * - IlxGen.IlxAssemblyGenerator -> IlxGen.IlxGenResults - val NormalizeAssemblyRefs : - AbstractIL.Internal.Library.CompilationThreadToken * - AbstractIL.IL.ILGlobals * CompilerImports.TcImports -> - (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILScopeRef) - val GetGeneratedILModuleName : - CompilerConfig.CompilerTarget -> string -> string - end - -namespace FSharp.Compiler - module internal XmlDocFileWriter = begin - module XmlDocWriter = begin - val hasDoc : doc:XmlDoc.XmlDoc -> bool - val ComputeXmlDocSigs : - tcGlobals:TcGlobals.TcGlobals * generatedCcu:TypedTree.CcuThunk -> unit - val WriteXmlDocFile : - assemblyName:string * generatedCcu:TypedTree.CcuThunk * xmlfile:string -> - unit - end - end - -namespace FSharp.Compiler - module internal BinaryResourceFormats = begin - module BinaryGenerationUtilities = begin - val b0 : n:int -> byte - val b1 : n:int -> byte - val b2 : n:int -> byte - val b3 : n:int -> byte - val i16 : i:int32 -> byte [] - val i32 : i:int32 -> byte [] - val Padded : initialAlignment:int -> v:byte [] -> byte [] - end - module ResFileFormat = begin - val ResFileNode : - dwTypeID:int32 * dwNameID:int32 * wMemFlags:int32 * wLangID:int32 * - data:byte [] -> byte [] - val ResFileHeader : unit -> byte [] - end - module VersionResourceFormat = begin - val VersionInfoNode : data:byte [] -> byte [] - val VersionInfoElement : - wType:int32 * szKey:byte [] * valueOpt:byte [] option * - children:byte [] [] * isString:bool -> byte [] - val Version : version:AbstractIL.IL.ILVersionInfo -> byte [] - val String : string:string * value:string -> byte [] - val StringTable : - language:string * strings:seq -> byte [] - val StringFileInfo : - stringTables:#seq -> byte [] - when 'b :> seq - val VarFileInfo : vars:#seq -> byte [] - val VS_FIXEDFILEINFO : - fileVersion:AbstractIL.IL.ILVersionInfo * - productVersion:AbstractIL.IL.ILVersionInfo * dwFileFlagsMask:int32 * - dwFileFlags:int32 * dwFileOS:int32 * dwFileType:int32 * - dwFileSubtype:int32 * lwFileDate:int64 -> byte [] - val VS_VERSION_INFO : - fixedFileInfo:(AbstractIL.IL.ILVersionInfo * AbstractIL.IL.ILVersionInfo * - int32 * int32 * int32 * int32 * int32 * int64) * - stringFileInfo:seq> * - varFileInfo:seq -> byte [] - val VS_VERSION_INFO_RESOURCE : - (AbstractIL.IL.ILVersionInfo * AbstractIL.IL.ILVersionInfo * int32 * - int32 * int32 * int32 * int32 * int64) * - seq> * seq -> byte [] - end - module ManifestResourceFormat = begin - val VS_MANIFEST_RESOURCE : data:byte [] * isLibrary:bool -> byte [] - end - end - -namespace FSharp.Compiler - module internal StaticLinking = begin - type TypeForwarding = - class - new : tcImports:CompilerImports.TcImports -> TypeForwarding - member - TypeForwardILTypeRef : tref:AbstractIL.IL.ILTypeRef -> - AbstractIL.IL.ILTypeRef - end - val debugStaticLinking : bool - val StaticLinkILModules : - tcConfig:CompilerConfig.TcConfig * ilGlobals:AbstractIL.IL.ILGlobals * - tcImports:CompilerImports.TcImports * - ilxMainModule:AbstractIL.IL.ILModuleDef * - dependentILModules:(TypedTree.CcuThunk option * AbstractIL.IL.ILModuleDef) list -> - AbstractIL.IL.ILModuleDef * - (AbstractIL.IL.ILScopeRef -> AbstractIL.IL.ILScopeRef) - [] - type Node = - { name: string - data: AbstractIL.IL.ILModuleDef - ccu: TypedTree.CcuThunk option - refs: AbstractIL.IL.ILReferences - mutable edges: Node list - mutable visited: bool } - val FindDependentILModulesForStaticLinking : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfig:CompilerConfig.TcConfig * tcImports:CompilerImports.TcImports * - ilGlobals:AbstractIL.IL.ILGlobals * - ilxMainModule:AbstractIL.IL.ILModuleDef -> - (TypedTree.CcuThunk option * AbstractIL.IL.ILModuleDef) list - val FindProviderGeneratedILModules : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcImports:CompilerImports.TcImports * - providerGeneratedAssemblies:(CompilerImports.ImportedBinary * 'a) list -> - ((TypedTree.CcuThunk option * AbstractIL.IL.ILScopeRef * - AbstractIL.IL.ILModuleDef) * (string * 'a)) list - val StaticLink : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfig:CompilerConfig.TcConfig * tcImports:CompilerImports.TcImports * - ilGlobals:AbstractIL.IL.ILGlobals -> - (AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILModuleDef) - end - -namespace FSharp.Compiler - module internal CreateILModule = begin - module AttributeHelpers = begin - val TryFindStringAttribute : - g:TcGlobals.TcGlobals -> - attrib:string -> attribs:TypedTree.Attribs -> string option - val TryFindIntAttribute : - g:TcGlobals.TcGlobals -> - attrib:string -> attribs:TypedTree.Attribs -> int32 option - val TryFindBoolAttribute : - g:TcGlobals.TcGlobals -> - attrib:string -> attribs:TypedTree.Attribs -> bool option - val ( |ILVersion|_| ) : - versionString:string -> AbstractIL.IL.ILVersionInfo option - end - type StrongNameSigningInfo = - | StrongNameSigningInfo of - delaysign: bool * publicsign: bool * signer: string option * - container: string option - val ValidateKeySigningAttributes : - tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * - CheckDeclarations.TopAttribs -> StrongNameSigningInfo - val GetStrongNameSigner : - signingInfo:StrongNameSigningInfo -> - AbstractIL.Internal.StrongNameSign.ILStrongNameSigner option - module MainModuleBuilder = begin - val injectedCompatTypes : Set - val typesForwardedToMscorlib : Set - val typesForwardedToSystemNumerics : Set - val createMscorlibExportList : - tcGlobals:TcGlobals.TcGlobals -> - AbstractIL.IL.ILExportedTypeOrForwarder list - val createSystemNumericsExportList : - tcConfig:CompilerConfig.TcConfig -> - tcImports:CompilerImports.TcImports -> - AbstractIL.IL.ILExportedTypeOrForwarder list - val fileVersion : - findStringAttr:(string -> string option) -> - assemblyVersion:AbstractIL.IL.ILVersionInfo -> - AbstractIL.IL.ILVersionInfo - val productVersion : - findStringAttr:(string -> string option) -> - fileVersion:AbstractIL.IL.ILVersionInfo -> string - val productVersionToILVersionInfo : string -> AbstractIL.IL.ILVersionInfo - val CreateMainModule : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * - tcImports:CompilerImports.TcImports * pdbfile:'t option * - assemblyName:string * outfile:string * - topAttrs:CheckDeclarations.TopAttribs * - sigDataAttributes:AbstractIL.IL.ILAttribute list * - sigDataResources:AbstractIL.IL.ILResource list * - optDataResources:AbstractIL.IL.ILResource list * - codegenResults:IlxGen.IlxGenResults * - assemVerFromAttrib:AbstractIL.IL.ILVersionInfo option * - metadataVersion:string * secDecls:AbstractIL.IL.ILSecurityDecls -> - AbstractIL.IL.ILModuleDef - end - end - -namespace FSharp.Compiler - module internal Driver = begin - [] - type ErrorLoggerUpToMaxErrors = - class - inherit ErrorLogger.ErrorLogger - new : tcConfigB:CompilerConfig.TcConfigBuilder * - exiter:ErrorLogger.Exiter * nameForDebugging:string -> - ErrorLoggerUpToMaxErrors - override - DiagnosticSink : err:ErrorLogger.PhasedDiagnostic * isError:bool -> - unit - abstract member - HandleIssue : tcConfigB:CompilerConfig.TcConfigBuilder * - error:ErrorLogger.PhasedDiagnostic * isError:bool -> - unit - abstract member HandleTooManyErrors : text:string -> unit - override ErrorCount : int - end - val ConsoleErrorLoggerUpToMaxErrors : - tcConfigB:CompilerConfig.TcConfigBuilder * exiter:ErrorLogger.Exiter -> - ErrorLogger.ErrorLogger - type DelayAndForwardErrorLogger = - class - inherit ErrorLogger.CapturingErrorLogger - new : exiter:ErrorLogger.Exiter * - errorLoggerProvider:ErrorLoggerProvider -> - DelayAndForwardErrorLogger - member - ForwardDelayedDiagnostics : tcConfigB:CompilerConfig.TcConfigBuilder -> - unit - end - [] - and ErrorLoggerProvider = - class - new : unit -> ErrorLoggerProvider - member - CreateDelayAndForwardLogger : exiter:ErrorLogger.Exiter -> - DelayAndForwardErrorLogger - abstract member - CreateErrorLoggerUpToMaxErrors : tcConfigBuilder:CompilerConfig.TcConfigBuilder * - exiter:ErrorLogger.Exiter -> - ErrorLogger.ErrorLogger - end - type InProcErrorLoggerProvider = - class - new : unit -> InProcErrorLoggerProvider - member CapturedErrors : CompilerDiagnostics.Diagnostic [] - member CapturedWarnings : CompilerDiagnostics.Diagnostic [] - member Provider : ErrorLoggerProvider - end - type ConsoleLoggerProvider = - class - inherit ErrorLoggerProvider - new : unit -> ConsoleLoggerProvider - override - CreateErrorLoggerUpToMaxErrors : tcConfigBuilder:CompilerConfig.TcConfigBuilder * - exiter:ErrorLogger.Exiter -> - ErrorLogger.ErrorLogger - end - val AbortOnError : - errorLogger:ErrorLogger.ErrorLogger * exiter:ErrorLogger.Exiter -> unit - val TypeCheck : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfig:CompilerConfig.TcConfig * tcImports:CompilerImports.TcImports * - tcGlobals:TcGlobals.TcGlobals * errorLogger:ErrorLogger.ErrorLogger * - assemblyName:string * niceNameGen:CompilerGlobalState.NiceNameGenerator * - tcEnv0:CheckExpressions.TcEnv * inputs:SyntaxTree.ParsedInput list * - exiter:ErrorLogger.Exiter -> - ParseAndCheckInputs.TcState * CheckDeclarations.TopAttribs * - TypedTree.TypedImplFile list * CheckExpressions.TcEnv - val AdjustForScriptCompile : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - tcConfigB:CompilerConfig.TcConfigBuilder * - commandLineSourceFiles:string list * - lexResourceManager:Lexhelp.LexResourceManager * - dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider -> - string list - val SetProcessThreadLocals : - tcConfigB:CompilerConfig.TcConfigBuilder -> unit - val ProcessCommandLineFlags : - tcConfigB:CompilerConfig.TcConfigBuilder * lcidFromCodePage:int option * - argv:string [] -> string list - val EncodeSignatureData : - tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * - exportRemapping:TypedTreeOps.Remap * generatedCcu:TypedTree.CcuThunk * - outfile:string * isIncrementalBuild:bool -> - AbstractIL.IL.ILAttribute list * AbstractIL.IL.ILResource list - val EncodeOptimizationData : - tcGlobals:TcGlobals.TcGlobals * tcConfig:CompilerConfig.TcConfig * - outfile:string * exportRemapping:TypedTreeOps.Remap * - data:(TypedTree.CcuThunk * #Optimizer.CcuOptimizationInfo) * - isIncrementalBuild:bool -> AbstractIL.IL.ILResource list - module InterfaceFileWriter = begin - val BuildInitialDisplayEnvForSigFileGeneration : - tcGlobals:TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv - val WriteInterfaceFile : - tcGlobals:TcGlobals.TcGlobals * tcConfig:CompilerConfig.TcConfig * - infoReader:InfoReader.InfoReader * - declaredImpls:seq -> unit - end - val CopyFSharpCore : - outFile:string * referencedDlls:CompilerConfig.AssemblyReference list -> - unit - val TryFindVersionAttribute : - g:TcGlobals.TcGlobals -> - attrib:string -> - attribName:System.String -> - attribs:TypedTree.Attribs -> - deterministic:bool -> AbstractIL.IL.ILVersionInfo option - [] - type Args<'T> = | Args of 'T - val main1 : - ctok:'a * argv:string [] * - legacyReferenceResolver:ReferenceResolver.Resolver * - bannerAlreadyPrinted:bool * - reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * - defaultCopyFSharpCore:CompilerConfig.CopyFSharpCoreFlag * - exiter:ErrorLogger.Exiter * errorLoggerProvider:ErrorLoggerProvider * - disposables:Lib.DisposablesTracker -> - Args<'a * TcGlobals.TcGlobals * CompilerImports.TcImports * - CompilerImports.TcImports * TypedTree.CcuThunk * - TypedTree.TypedImplFile list * CheckDeclarations.TopAttribs * - CompilerConfig.TcConfig * string * string option * string * - ErrorLogger.ErrorLogger * ErrorLogger.Exiter> - when 'a :> AbstractIL.Internal.Library.CompilationThreadToken - val main1OfAst : - ctok:'a * legacyReferenceResolver:ReferenceResolver.Resolver * - reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * - assemblyName:string * target:CompilerConfig.CompilerTarget * outfile:'b * - pdbFile:'c option * dllReferences:string list * noframework:bool * - exiter:ErrorLogger.Exiter * errorLoggerProvider:ErrorLoggerProvider * - disposables:Lib.DisposablesTracker * inputs:SyntaxTree.ParsedInput list -> - Args<'a * TcGlobals.TcGlobals * CompilerImports.TcImports * - CompilerImports.TcImports * TypedTree.CcuThunk * - TypedTree.TypedImplFile list * CheckDeclarations.TopAttribs * - CompilerConfig.TcConfig * 'b * 'c option * string * - ErrorLogger.ErrorLogger * ErrorLogger.Exiter> - when 'a :> AbstractIL.Internal.Library.CompilationThreadToken - val main2 : - Args<'a * 'b * CompilerImports.TcImports * 'c * TypedTree.CcuThunk * 'd * - CheckDeclarations.TopAttribs * CompilerConfig.TcConfig * 'e * 'f * - string * #ErrorLogger.ErrorLogger * ErrorLogger.Exiter> -> - Args<'a * CompilerConfig.TcConfig * CompilerImports.TcImports * 'c * 'b * - ErrorLogger.ErrorLogger * TypedTree.CcuThunk * 'e * 'd * - CheckDeclarations.TopAttribs * 'f * string * - AbstractIL.IL.ILVersionInfo option * - CreateILModule.StrongNameSigningInfo * ErrorLogger.Exiter> - when 'b :> TcGlobals.TcGlobals and 'd :> seq - val main3 : - Args<'a * CompilerConfig.TcConfig * CompilerImports.TcImports * - CompilerImports.TcImports * 'b * ErrorLogger.ErrorLogger * - TypedTree.CcuThunk * string * TypedTree.TypedImplFile list * 'c * 'd * - 'e * 'f * 'g * ErrorLogger.Exiter> -> - Args<'a * CompilerConfig.TcConfig * CompilerImports.TcImports * 'b * - ErrorLogger.ErrorLogger * TypedTree.CcuThunk * string * - TypedTree.TypedAssemblyAfterOptimization * 'c * 'd * 'e * - AbstractIL.IL.ILAttribute list * AbstractIL.IL.ILResource list * - AbstractIL.IL.ILResource list * 'f * 'g * string * - ErrorLogger.Exiter> when 'b :> TcGlobals.TcGlobals - val main4 : - tcImportsCapture:(CompilerImports.TcImports -> unit) option * - dynamicAssemblyCreator:'a option -> - Args<'b * CompilerConfig.TcConfig * CompilerImports.TcImports * - TcGlobals.TcGlobals * 'c * TypedTree.CcuThunk * string * - TypedTree.TypedAssemblyAfterOptimization * - CheckDeclarations.TopAttribs * 'd option * string * - AbstractIL.IL.ILAttribute list * AbstractIL.IL.ILResource list * - AbstractIL.IL.ILResource list * AbstractIL.IL.ILVersionInfo option * - 'e * string * ErrorLogger.Exiter> -> - Args<'b * CompilerConfig.TcConfig * CompilerImports.TcImports * - TcGlobals.TcGlobals * 'c * - (AbstractIL.IL.ILModuleDef -> AbstractIL.IL.ILModuleDef) * string * - 'd option * AbstractIL.IL.ILModuleDef * 'e * ErrorLogger.Exiter> - when 'b :> AbstractIL.Internal.Library.CompilationThreadToken and - 'c :> ErrorLogger.ErrorLogger - val main5 : - Args<'a * 'b * 'c * 'd * ErrorLogger.ErrorLogger * ('e -> 'f) * 'g * 'h * - 'e * 'i * ErrorLogger.Exiter> -> - Args<'a * 'b * 'c * 'd * ErrorLogger.ErrorLogger * 'f * 'g * 'h * 'i * - ErrorLogger.Exiter> - val main6 : - dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * - AbstractIL.IL.ILModuleDef -> unit) option -> - Args<#AbstractIL.Internal.Library.CompilationThreadToken * - CompilerConfig.TcConfig * CompilerImports.TcImports * - TcGlobals.TcGlobals * ErrorLogger.ErrorLogger * - AbstractIL.IL.ILModuleDef * string * string option * - CreateILModule.StrongNameSigningInfo * ErrorLogger.Exiter> -> unit - val mainCompile : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * argv:string [] * - legacyReferenceResolver:ReferenceResolver.Resolver * - bannerAlreadyPrinted:bool * - reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * - defaultCopyFSharpCore:CompilerConfig.CopyFSharpCoreFlag * - exiter:ErrorLogger.Exiter * loggerProvider:ErrorLoggerProvider * - tcImportsCapture:(CompilerImports.TcImports -> unit) option * - dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * - AbstractIL.IL.ILModuleDef -> unit) option -> unit - val compileOfAst : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - legacyReferenceResolver:ReferenceResolver.Resolver * - reduceMemoryUsage:AbstractIL.ILBinaryReader.ReduceMemoryFlag * - assemblyName:string * target:CompilerConfig.CompilerTarget * - targetDll:string * targetPdb:string option * dependencies:string list * - noframework:bool * exiter:ErrorLogger.Exiter * - loggerProvider:ErrorLoggerProvider * inputs:SyntaxTree.ParsedInput list * - tcImportsCapture:(CompilerImports.TcImports -> unit) option * - dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * - AbstractIL.IL.ILModuleDef -> unit) option -> unit - end - -namespace FSharp.Compiler.SourceCodeServices - module EnvMisc2 = begin - val maxMembers : int - end - [] - type FSharpErrorSeverity = - | Warning - | Error - module FSharpErrorInfo = begin - [] - val ObsoleteMessage : string - = "Use FSharpErrorInfo.Range. This API will be removed in a future update." - end - [] - type FSharpErrorInfo = - class - new : m:Range.range * severity:FSharpErrorSeverity * message:string * - subcategory:string * errorNum:int -> FSharpErrorInfo - static member - CreateFromException : ErrorLogger.PhasedDiagnostic * isError:bool * - Range.range * suggestNames:bool -> FSharpErrorInfo - static member - CreateFromExceptionAndAdjustEof : ErrorLogger.PhasedDiagnostic * - isError:bool * Range.range * - lastPosInFile:(int * int) * - suggestNames:bool -> FSharpErrorInfo - override ToString : unit -> string - member WithEnd : newEnd:Range.pos -> FSharpErrorInfo - member WithStart : newStart:Range.pos -> FSharpErrorInfo - [] - member End : Range.pos - [] - member EndColumn : int - [] - member EndLine : Range.Line0 - [] - member EndLineAlternate : int - member ErrorNumber : int - [] - member FileName : string - member Message : string - member Range : Range.range - member Severity : FSharpErrorSeverity - [] - member Start : Range.pos - [] - member StartColumn : int - [] - member StartLine : Range.Line0 - [] - member StartLineAlternate : int - member Subcategory : string - end - [] - type ErrorScope = - class - interface System.IDisposable - new : unit -> ErrorScope - static member - Protect : Range.range -> (unit -> 'a) -> (string -> 'a) -> 'a - member TryGetFirstErrorText : unit -> string option - member Diagnostics : FSharpErrorInfo list - member Errors : FSharpErrorInfo list - member FirstError : string option - member Warnings : FSharpErrorInfo list - end - type internal CompilationErrorLogger = - class - inherit ErrorLogger.ErrorLogger - new : debugName:string * options:ErrorLogger.FSharpErrorSeverityOptions -> - CompilationErrorLogger - override - DiagnosticSink : exn:ErrorLogger.PhasedDiagnostic * isError:bool -> unit - member - GetErrors : unit -> - (ErrorLogger.PhasedDiagnostic * FSharpErrorSeverity) [] - override ErrorCount : int - end - type CompilationGlobalsScope = - class - interface System.IDisposable - new : ErrorLogger.ErrorLogger * ErrorLogger.BuildPhase -> - CompilationGlobalsScope - end - module ErrorHelpers = begin - val ReportError : - ErrorLogger.FSharpErrorSeverityOptions * allErrors:bool * - mainInputFileName:string * fileInfo:(int * int) * - (ErrorLogger.PhasedDiagnostic * FSharpErrorSeverity) * suggestNames:bool -> - FSharpErrorInfo list - val CreateErrorInfos : - ErrorLogger.FSharpErrorSeverityOptions * allErrors:bool * - mainInputFileName:string * - seq * - suggestNames:bool -> FSharpErrorInfo [] - end - type Layout = Internal.Utilities.StructuredFormat.Layout - [] - type FSharpXmlDoc = - | None - | Text of unprocessedLines: string [] * elaboratedXmlLines: string [] - | XmlDocFileSignature of string * string - [] - type FSharpToolTipElementData<'T> = - { MainDescription: 'T - XmlDoc: FSharpXmlDoc - TypeMapping: 'T list - Remarks: 'T option - ParamName: string option } - with - static member - Create : layout:'T * xml:FSharpXmlDoc * ?typeMapping:'T list * - ?paramName:string * ?remarks:'T -> FSharpToolTipElementData<'T> - end - [] - type FSharpToolTipElement<'T> = - | None - | Group of FSharpToolTipElementData<'T> list - | CompositionError of string - with - static member - Single : 'T * FSharpXmlDoc * ?typeMapping:'T list * ?paramName:string * - ?remarks:'T -> FSharpToolTipElement<'T> - end - type FSharpToolTipElement = FSharpToolTipElement - type FSharpStructuredToolTipElement = FSharpToolTipElement - type FSharpToolTipText<'T> = - | FSharpToolTipText of FSharpToolTipElement<'T> list - type FSharpToolTipText = FSharpToolTipText - type FSharpStructuredToolTipText = FSharpToolTipText - module Tooltips = begin - val ToFSharpToolTipElement : - FSharpToolTipElement -> FSharpToolTipElement - val ToFSharpToolTipText : - FSharpToolTipText -> FSharpToolTipText - end - [] - type CompletionItemKind = - | Field - | Property - | Method of isExtension: bool - | Event - | Argument - | CustomOperation - | Other - type UnresolvedSymbol = - { FullName: string - DisplayName: string - Namespace: string [] } - type CompletionItem = - { ItemWithInst: NameResolution.ItemWithInst - Kind: CompletionItemKind - IsOwnMember: bool - MinorPriority: int - Type: TypedTree.TyconRef option - Unresolved: UnresolvedSymbol option } - with - member Item : NameResolution.Item - end - module internal SymbolHelpers = begin - val OutputFullName : - isListItem:bool -> - ppF:('a -> 'b option) -> - fnF:('a -> Internal.Utilities.StructuredFormat.Layout) -> - r:'a -> Internal.Utilities.StructuredFormat.Layout - val rangeOfValRef : - preferFlag:bool option -> vref:TypedTree.ValRef -> Range.range - val rangeOfEntityRef : - preferFlag:bool option -> eref:TypedTree.EntityRef -> Range.range - val rangeOfPropInfo : - preferFlag:bool option -> pinfo:Infos.PropInfo -> Range.range option - val rangeOfMethInfo : - g:TcGlobals.TcGlobals -> - preferFlag:bool option -> minfo:Infos.MethInfo -> Range.range option - val rangeOfEventInfo : - preferFlag:bool option -> einfo:Infos.EventInfo -> Range.range option - val rangeOfUnionCaseInfo : - preferFlag:bool option -> ucinfo:Infos.UnionCaseInfo -> Range.range - val rangeOfRecdField : - preferFlag:bool option -> rField:TypedTree.RecdField -> Range.range - val rangeOfRecdFieldInfo : - preferFlag:bool option -> rfinfo:Infos.RecdFieldInfo -> Range.range - val rangeOfItem : - TcGlobals.TcGlobals -> - bool option -> NameResolution.Item -> Range.range option - val computeCcuOfTyconRef : - tcref:TypedTree.TyconRef -> TypedTree.CcuThunk option - val ccuOfMethInfo : - g:TcGlobals.TcGlobals -> minfo:Infos.MethInfo -> TypedTree.CcuThunk option - val ccuOfItem : - TcGlobals.TcGlobals -> NameResolution.Item -> TypedTree.CcuThunk option - val fileNameOfItem : - TcGlobals.TcGlobals -> - string option -> Range.range -> NameResolution.Item -> string - val cutFileName : s:string -> string - val libFileOfEntityRef : x:TypedTree.EntityRef -> string option - val ParamNameAndTypesOfUnaryCustomOperation : - TcGlobals.TcGlobals -> Infos.MethInfo -> Infos.ParamNameAndType list - val metaInfoOfEntityRef : - infoReader:InfoReader.InfoReader -> - m:Range.range -> - tcref:TypedTree.EntityRef -> - (string option * TypedTree.Typars * Infos.ILTypeInfo) option - val mkXmlComment : thing:(string option * string) option -> FSharpXmlDoc - val GetXmlDocSigOfEntityRef : - InfoReader.InfoReader -> - Range.range -> TypedTree.EntityRef -> (string option * string) option - val GetXmlDocSigOfScopedValRef : - TcGlobals.TcGlobals -> - TypedTree.TyconRef -> - TypedTree.ValRef -> (string option * string) option - val GetXmlDocSigOfRecdFieldInfo : - Infos.RecdFieldInfo -> (string option * string) option - val GetXmlDocSigOfUnionCaseInfo : - Infos.UnionCaseInfo -> (string option * string) option - val GetXmlDocSigOfMethInfo : - InfoReader.InfoReader -> - Range.range -> Infos.MethInfo -> (string option * string) option - val GetXmlDocSigOfValRef : - TcGlobals.TcGlobals -> TypedTree.ValRef -> (string option * string) option - val GetXmlDocSigOfProp : - InfoReader.InfoReader -> - Range.range -> Infos.PropInfo -> (string option * string) option - val GetXmlDocSigOfEvent : - InfoReader.InfoReader -> - Range.range -> Infos.EventInfo -> (string option * string) option - val GetXmlDocSigOfILFieldInfo : - InfoReader.InfoReader -> - Range.range -> Infos.ILFieldInfo -> (string option * string) option - val GetXmlDocHelpSigOfItemForLookup : - infoReader:InfoReader.InfoReader -> - m:Range.range -> d:NameResolution.Item -> FSharpXmlDoc - val GetXmlCommentForItemAux : - xmlDoc:XmlDoc.XmlDoc option -> - infoReader:InfoReader.InfoReader -> - m:Range.range -> d:NameResolution.Item -> FSharpXmlDoc - val mutable ToolTipFault : string option - val GetXmlCommentForMethInfoItem : - infoReader:InfoReader.InfoReader -> - m:Range.range -> - d:NameResolution.Item -> minfo:Infos.MethInfo -> FSharpXmlDoc - val FormatTyparMapping : - denv:TypedTreeOps.DisplayEnv -> - prettyTyparInst:TypedTreeOps.TyparInst -> - Internal.Utilities.StructuredFormat.Layout list - val FormatOverloadsToList : - infoReader:InfoReader.InfoReader -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - item:NameResolution.ItemWithInst -> - minfos:seq -> FSharpStructuredToolTipElement - val pubpathOfValRef : v:TypedTree.ValRef -> TypedTree.ValPublicPath option - val pubpathOfTyconRef : x:TypedTree.TyconRef -> TypedTree.PublicPath option - val ( |ItemWhereTypIsPreferred|_| ) : - item:NameResolution.Item -> TypedTree.TType option - val ItemDisplayPartialEquality : - g:TcGlobals.TcGlobals -> - AbstractIL.Internal.Library.IPartialEqualityComparer - val CompletionItemDisplayPartialEquality : - g:TcGlobals.TcGlobals -> - AbstractIL.Internal.Library.IPartialEqualityComparer - val ItemWithTypeDisplayPartialEquality : - g:TcGlobals.TcGlobals -> - AbstractIL.Internal.Library.IPartialEqualityComparer - val RemoveDuplicateModuleRefs : - modrefs:TypedTree.ModuleOrNamespaceRef list -> - TypedTree.ModuleOrNamespaceRef list - val RemoveDuplicateItems : - TcGlobals.TcGlobals -> - NameResolution.ItemWithInst list -> NameResolution.ItemWithInst list - val RemoveDuplicateCompletionItems : - TcGlobals.TcGlobals -> CompletionItem list -> CompletionItem list - val IsExplicitlySuppressed : - TcGlobals.TcGlobals -> NameResolution.Item -> bool - val RemoveExplicitlySuppressed : - TcGlobals.TcGlobals -> - NameResolution.ItemWithInst list -> NameResolution.ItemWithInst list - val RemoveExplicitlySuppressedCompletionItems : - TcGlobals.TcGlobals -> CompletionItem list -> CompletionItem list - val SimplerDisplayEnv : TypedTreeOps.DisplayEnv -> TypedTreeOps.DisplayEnv - val FullNameOfItem : TcGlobals.TcGlobals -> NameResolution.Item -> string - val GetXmlCommentForItem : - InfoReader.InfoReader -> - Range.range -> NameResolution.Item -> FSharpXmlDoc - val IsAttribute : InfoReader.InfoReader -> NameResolution.Item -> bool - val FormatItemDescriptionToToolTipElement : - isListItem:bool -> - infoReader:InfoReader.InfoReader -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - item:NameResolution.ItemWithInst -> FSharpToolTipElement - val ( |ItemIsProvidedType|_| ) : - TcGlobals.TcGlobals -> NameResolution.Item -> TypedTree.TyconRef option - val ( |ItemIsProvidedTypeWithStaticArguments|_| ) : - Range.range -> - TcGlobals.TcGlobals -> - NameResolution.Item -> - Tainted [] option - val ( |ItemIsProvidedMethodWithStaticArguments|_| ) : - item:NameResolution.Item -> - Tainted [] option - val ( |ItemIsWithStaticArguments|_| ) : - Range.range -> - TcGlobals.TcGlobals -> - NameResolution.Item -> - Tainted [] option - val GetF1Keyword : - TcGlobals.TcGlobals -> NameResolution.Item -> string option - val FormatStructuredDescriptionOfItem : - isDecl:bool -> - InfoReader.InfoReader -> - Range.range -> - TypedTreeOps.DisplayEnv -> - NameResolution.ItemWithInst -> FSharpToolTipElement - val FlattenItems : - TcGlobals.TcGlobals -> - Range.range -> NameResolution.Item -> NameResolution.Item list - end - -namespace FSharp.Compiler.SourceCodeServices - type FSharpAccessibility = - class - new : TypedTree.Accessibility * ?isProtected:bool -> FSharpAccessibility - override ToString : unit -> string - member internal Contents : TypedTree.Accessibility - member IsInternal : bool - member IsPrivate : bool - member IsProtected : bool - member IsPublic : bool - end - and SymbolEnv = - class - new : TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * - thisCcuTyp:TypedTree.ModuleOrNamespaceType option * - tcImports:CompilerImports.TcImports -> SymbolEnv - new : TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * - thisCcuTyp:TypedTree.ModuleOrNamespaceType option * - tcImports:CompilerImports.TcImports * amap:Import.ImportMap * - infoReader:InfoReader.InfoReader -> SymbolEnv - member amap : Import.ImportMap - member g : TcGlobals.TcGlobals - member infoReader : InfoReader.InfoReader - member tcImports : CompilerImports.TcImports - member - tcValF : (TypedTree.ValRef -> TypedTree.ValUseFlag -> - TypedTree.TTypes -> Range.range -> - TypedTree.Expr * TypedTree.TType) - member thisCcu : TypedTree.CcuThunk - member thisCcuTy : TypedTree.ModuleOrNamespaceType option - end - and FSharpDisplayContext = - class - new : denv:(TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv) -> - FSharpDisplayContext - member Contents : g:TcGlobals.TcGlobals -> TypedTreeOps.DisplayEnv - member WithShortTypeNames : bool -> FSharpDisplayContext - static member Empty : FSharpDisplayContext - end - [] - and FSharpSymbol = - class - new : cenv:SymbolEnv * item:(unit -> NameResolution.Item) * - access:(FSharpSymbol -> TypedTree.CcuThunk -> - AccessibilityLogic.AccessorDomain -> bool) -> FSharpSymbol - static member - Create : cenv:SymbolEnv * item:NameResolution.Item -> FSharpSymbol - static member - Create : g:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * - thisCcuTyp:TypedTree.ModuleOrNamespaceType * - tcImports:CompilerImports.TcImports * item:NameResolution.Item -> - FSharpSymbol - static member - GetAccessibility : FSharpSymbol -> FSharpAccessibility option - override Equals : other:obj -> bool - member GetEffectivelySameAsHash : unit -> int - override GetHashCode : unit -> int - member IsAccessible : FSharpAccessibilityRights -> bool - member IsEffectivelySameAs : other:FSharpSymbol -> bool - override ToString : unit -> string - member Assembly : FSharpAssembly - member DeclarationLocation : Range.range option - member DisplayName : string - member FullName : string - member ImplementationLocation : Range.range option - member IsExplicitlySuppressed : bool - member internal Item : NameResolution.Item - member SignatureLocation : Range.range option - end - and FSharpEntity = - class - inherit FSharpSymbol - new : SymbolEnv * TypedTree.EntityRef -> FSharpEntity - override Equals : other:obj -> bool - override GetHashCode : unit -> int - override ToString : unit -> string - member AbbreviatedType : FSharpType - member AccessPath : string - member Accessibility : FSharpAccessibility - member ActivePatternCases : FSharpActivePatternCase list - member AllCompilationPaths : string list - member AllInterfaces : System.Collections.Generic.IList - member ArrayRank : int - member Attributes : System.Collections.Generic.IList - member BaseType : FSharpType option - member CompiledName : string - member DeclarationLocation : Range.range - member DeclaredInterfaces : System.Collections.Generic.IList - member DeclaringEntity : FSharpEntity option - member DisplayName : string - member ElaboratedXmlDoc : System.Collections.Generic.IList - member Entity : TypedTree.EntityRef - member FSharpDelegateSignature : FSharpDelegateSignature - member FSharpFields : System.Collections.Generic.IList - member FullName : string - member - GenericParameters : System.Collections.Generic.IList - member HasAssemblyCodeRepresentation : bool - member HasFSharpModuleSuffix : bool - member IsAbstractClass : bool - member IsArrayType : bool - member IsAttributeType : bool - member IsByRef : bool - member IsClass : bool - member IsDelegate : bool - member IsDisposableType : bool - member IsEnum : bool - member IsFSharp : bool - member IsFSharpAbbreviation : bool - member IsFSharpExceptionDeclaration : bool - member IsFSharpModule : bool - member IsFSharpRecord : bool - member IsFSharpUnion : bool - member IsInterface : bool - member IsMeasure : bool - member IsNamespace : bool - member IsOpaque : bool - member IsProvided : bool - member IsProvidedAndErased : bool - member IsProvidedAndGenerated : bool - member IsStaticInstantiation : bool - member IsUnresolved : bool - member IsValueType : bool - member LogicalName : string - member - MembersFunctionsAndValues : System.Collections.Generic.IList - [] - member - MembersOrValues : System.Collections.Generic.IList - member Namespace : string option - member NestedEntities : System.Collections.Generic.IList - member QualifiedName : string - [] - member RecordFields : System.Collections.Generic.IList - member RepresentationAccessibility : FSharpAccessibility - member - StaticParameters : System.Collections.Generic.IList - member TryFullName : string option - member UnionCases : System.Collections.Generic.IList - member UsesPrefixDisplay : bool - member XmlDoc : System.Collections.Generic.IList - member XmlDocSig : string - end - [] - and FSharpUnionCase = - class - inherit FSharpSymbol - new : SymbolEnv * TypedTree.UnionCaseRef -> FSharpUnionCase - override Equals : other:obj -> bool - override GetHashCode : unit -> int - override ToString : unit -> string - member Accessibility : FSharpAccessibility - member Attributes : System.Collections.Generic.IList - member CompiledName : string - member DeclarationLocation : Range.range - member ElaboratedXmlDoc : System.Collections.Generic.IList - member HasFields : bool - member IsUnresolved : bool - member Name : string - member ReturnType : FSharpType - member UnionCaseFields : System.Collections.Generic.IList - member private V : TypedTree.UnionCaseRef - member XmlDoc : System.Collections.Generic.IList - member XmlDocSig : string - end - and FSharpFieldData = - | AnonField of - TypedTree.AnonRecdTypeInfo * TypedTree.TTypes * int * Range.range - | ILField of Infos.ILFieldInfo - | RecdOrClass of TypedTree.RecdFieldRef - | Union of TypedTree.UnionCaseRef * int - with - member TryDeclaringTyconRef : TypedTree.TyconRef option - member - TryRecdField : Choice - end - [] - and FSharpAnonRecordTypeDetails = - class - new : cenv:SymbolEnv * anonInfo:TypedTree.AnonRecdTypeInfo -> - FSharpAnonRecordTypeDetails - member Assembly : FSharpAssembly - member CompiledName : string - member EnclosingCompiledTypeNames : string list - member SortedFieldNames : string [] - end - [] - and FSharpField = - class - inherit FSharpSymbol - new : SymbolEnv * TypedTree.RecdFieldRef -> FSharpField - new : SymbolEnv * TypedTree.UnionCaseRef * int -> FSharpField - new : cenv:SymbolEnv * d:FSharpFieldData -> FSharpField - override Equals : other:obj -> bool - override GetHashCode : unit -> int - override ToString : unit -> string - member Accessibility : FSharpAccessibility - member - AnonRecordFieldDetails : FSharpAnonRecordTypeDetails * FSharpType [] * - int - member DeclarationLocation : Range.range - member DeclaringEntity : FSharpEntity option - member DeclaringUnionCase : FSharpUnionCase option - member ElaboratedXmlDoc : System.Collections.Generic.IList - member FieldAttributes : System.Collections.Generic.IList - member FieldType : FSharpType - member IsAnonRecordField : bool - member IsCompilerGenerated : bool - member IsDefaultValue : bool - member IsLiteral : bool - member IsMutable : bool - member IsNameGenerated : bool - member IsStatic : bool - member IsUnionCaseField : bool - member IsUnresolved : bool - member IsVolatile : bool - member LiteralValue : obj option - member Name : string - member - PropertyAttributes : System.Collections.Generic.IList - member private V : FSharpFieldData - member XmlDoc : System.Collections.Generic.IList - member XmlDocSig : string - end - [] - and FSharpRecordField = FSharpField - [] - and FSharpAccessibilityRights = - class - new : TypedTree.CcuThunk * AccessibilityLogic.AccessorDomain -> - FSharpAccessibilityRights - member internal Contents : AccessibilityLogic.AccessorDomain - member internal ThisCcu : TypedTree.CcuThunk - end - [] - and FSharpActivePatternCase = - class - inherit FSharpSymbol - new : cenv:SymbolEnv * apinfo:PrettyNaming.ActivePatternInfo * - ty:TypedTree.TType * n:int * valOpt:TypedTree.ValRef option * - item:NameResolution.Item -> FSharpActivePatternCase - member DeclarationLocation : Range.range - member ElaboratedXmlDoc : System.Collections.Generic.IList - member Group : FSharpActivePatternGroup - member Index : int - member Name : string - member XmlDoc : System.Collections.Generic.IList - member XmlDocSig : string - end - [] - and FSharpActivePatternGroup = - class - new : cenv:SymbolEnv * apinfo:PrettyNaming.ActivePatternInfo * - ty:TypedTree.TType * valOpt:TypedTree.ValRef option -> - FSharpActivePatternGroup - member DeclaringEntity : FSharpEntity option - member IsTotal : bool - member Name : string option - member Names : System.Collections.Generic.IList - member OverallType : FSharpType - end - [] - and FSharpGenericParameter = - class - inherit FSharpSymbol - new : SymbolEnv * TypedTree.Typar -> FSharpGenericParameter - override Equals : other:obj -> bool - override GetHashCode : unit -> int - override ToString : unit -> string - member Attributes : System.Collections.Generic.IList - member - Constraints : System.Collections.Generic.IList - member DeclarationLocation : Range.range - member ElaboratedXmlDoc : System.Collections.Generic.IList - member IsCompilerGenerated : bool - member IsMeasure : bool - member IsSolveAtCompileTime : bool - member Name : string - member internal V : TypedTree.Typar - member XmlDoc : System.Collections.Generic.IList - end - [] - and FSharpDelegateSignature = - class - new : cenv:SymbolEnv * info:TypedTree.SlotSig -> FSharpDelegateSignature - override ToString : unit -> string - member - DelegateArguments : System.Collections.Generic.IList - member DelegateReturnType : FSharpType - end - [] - and FSharpAbstractParameter = - class - new : cenv:SymbolEnv * info:TypedTree.SlotParam -> FSharpAbstractParameter - member Attributes : System.Collections.Generic.IList - member IsInArg : bool - member IsOptionalArg : bool - member IsOutArg : bool - member Name : string option - member Type : FSharpType - end - [] - and FSharpAbstractSignature = - class - new : SymbolEnv * TypedTree.SlotSig -> FSharpAbstractSignature - member - AbstractArguments : System.Collections.Generic.IList> - member AbstractReturnType : FSharpType - member DeclaringType : FSharpType - member - DeclaringTypeGenericParameters : System.Collections.Generic.IList - member - MethodGenericParameters : System.Collections.Generic.IList - member Name : string - end - [] - and FSharpGenericParameterMemberConstraint = - class - new : cenv:SymbolEnv * info:TypedTree.TraitConstraintInfo -> - FSharpGenericParameterMemberConstraint - override ToString : unit -> string - member MemberArgumentTypes : System.Collections.Generic.IList - member MemberIsStatic : bool - member MemberName : string - member MemberReturnType : FSharpType - member MemberSources : System.Collections.Generic.IList - end - [] - and FSharpGenericParameterDelegateConstraint = - class - new : cenv:SymbolEnv * tupledArgTy:TypedTree.TType * rty:TypedTree.TType -> - FSharpGenericParameterDelegateConstraint - override ToString : unit -> string - member DelegateReturnType : FSharpType - member DelegateTupledArgumentType : FSharpType - end - [] - and FSharpGenericParameterDefaultsToConstraint = - class - new : cenv:SymbolEnv * pri:int * ty:TypedTree.TType -> - FSharpGenericParameterDefaultsToConstraint - override ToString : unit -> string - member DefaultsToPriority : int - member DefaultsToTarget : FSharpType - end - [] - and FSharpGenericParameterConstraint = - class - new : cenv:SymbolEnv * cx:TypedTree.TyparConstraint -> - FSharpGenericParameterConstraint - override ToString : unit -> string - member CoercesToTarget : FSharpType - member - DefaultsToConstraintData : FSharpGenericParameterDefaultsToConstraint - member DelegateConstraintData : FSharpGenericParameterDelegateConstraint - member EnumConstraintTarget : FSharpType - member IsCoercesToConstraint : bool - member IsComparisonConstraint : bool - member IsDefaultsToConstraint : bool - member IsDelegateConstraint : bool - member IsEnumConstraint : bool - member IsEqualityConstraint : bool - member IsMemberConstraint : bool - member IsNonNullableValueTypeConstraint : bool - member IsReferenceTypeConstraint : bool - member IsRequiresDefaultConstructorConstraint : bool - member IsSimpleChoiceConstraint : bool - member IsSupportsNullConstraint : bool - member IsUnmanagedConstraint : bool - member MemberConstraintData : FSharpGenericParameterMemberConstraint - member SimpleChoices : System.Collections.Generic.IList - end - [] - and FSharpInlineAnnotation = - | PseudoValue - | AlwaysInline - | OptionalInline - | NeverInline - | AggressiveInline - and FSharpMemberOrValData = - | E of Infos.EventInfo - | P of Infos.PropInfo - | M of Infos.MethInfo - | C of Infos.MethInfo - | V of TypedTree.ValRef - and FSharpMemberOrVal = FSharpMemberOrFunctionOrValue - and FSharpMemberFunctionOrValue = FSharpMemberOrFunctionOrValue - [] - and FSharpMemberOrFunctionOrValue = - class - inherit FSharpSymbol - new : SymbolEnv * Infos.MethInfo -> FSharpMemberOrFunctionOrValue - new : SymbolEnv * TypedTree.ValRef -> FSharpMemberOrFunctionOrValue - new : cenv:SymbolEnv * d:FSharpMemberOrValData * item:NameResolution.Item -> - FSharpMemberOrFunctionOrValue - override Equals : other:obj -> bool - member - FormatLayout : context:FSharpDisplayContext -> - Internal.Utilities.StructuredFormat.Layout - override GetHashCode : unit -> int - member - GetWitnessPassingInfo : unit -> - (string * - System.Collections.Generic.IList) option - member - Overloads : bool -> - System.Collections.Generic.IList option - override ToString : unit -> string - member Accessibility : FSharpAccessibility - member ApparentEnclosingEntity : FSharpEntity - member Attributes : System.Collections.Generic.IList - member CompiledName : string - member - CurriedParameterGroups : System.Collections.Generic.IList> - member Data : FSharpMemberOrValData - member DeclarationLocation : Range.range - member DeclarationLocationOpt : Range.range option - member DeclaringEntity : FSharpEntity option - member DisplayName : string - member ElaboratedXmlDoc : System.Collections.Generic.IList - member EventAddMethod : FSharpMemberOrFunctionOrValue - member EventDelegateType : FSharpType - member EventForFSharpProperty : FSharpMemberOrFunctionOrValue option - member EventIsStandard : bool - member EventRemoveMethod : FSharpMemberOrFunctionOrValue - member FullType : FSharpType - member - GenericParameters : System.Collections.Generic.IList - member GetterMethod : FSharpMemberOrFunctionOrValue - member HasGetterMethod : bool - member HasSetterMethod : bool - member - ImplementedAbstractSignatures : System.Collections.Generic.IList - member InlineAnnotation : FSharpInlineAnnotation - member IsActivePattern : bool - member IsBaseValue : bool - member IsCompilerGenerated : bool - member IsConstructor : bool - member IsConstructorThisValue : bool - member IsDispatchSlot : bool - member IsEvent : bool - member IsEventAddMethod : bool - member IsEventRemoveMethod : bool - member IsExplicitInterfaceImplementation : bool - member IsExtensionMember : bool - [] - member IsGetterMethod : bool - member IsImplicitConstructor : bool - member IsInstanceMember : bool - member IsInstanceMemberInCompiledCode : bool - member IsMember : bool - member IsMemberThisValue : bool - member IsModuleValueOrMember : bool - member IsMutable : bool - member IsOverrideOrExplicitInterfaceImplementation : bool - [] - member IsOverrideOrExplicitMember : bool - member IsProperty : bool - member IsPropertyGetterMethod : bool - member IsPropertySetterMethod : bool - [] - member IsSetterMethod : bool - member IsTypeFunction : bool - member IsUnresolved : bool - member IsValCompiledAsMethod : bool - member IsValue : bool - member LiteralValue : obj option - member LogicalName : string - member ReturnParameter : FSharpParameter - member SetterMethod : FSharpMemberOrFunctionOrValue - member XmlDoc : System.Collections.Generic.IList - member XmlDocSig : string - end - [] - and FSharpType = - class - new : g:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * - thisCcuTyp:TypedTree.ModuleOrNamespaceType * - tcImports:CompilerImports.TcImports * ty:TypedTree.TType -> - FSharpType - new : SymbolEnv * ty:TypedTree.TType -> FSharpType - static member - Prettify : parameters:System.Collections.Generic.IList> -> - System.Collections.Generic.IList> - static member - Prettify : parameters:System.Collections.Generic.IList -> - System.Collections.Generic.IList - static member Prettify : parameter:FSharpParameter -> FSharpParameter - static member - Prettify : types:System.Collections.Generic.IList -> - System.Collections.Generic.IList - static member Prettify : ty:FSharpType -> FSharpType - static member - Prettify : parameters:System.Collections.Generic.IList> * - returnParameter:FSharpParameter -> - System.Collections.Generic.IList> * - FSharpParameter - member private AdjustType : t:TypedTree.TType -> FSharpType - override Equals : other:obj -> bool - member Format : context:FSharpDisplayContext -> string - member - FormatLayout : context:FSharpDisplayContext -> - Internal.Utilities.StructuredFormat.Layout - override GetHashCode : unit -> int - member - Instantiate : (FSharpGenericParameter * FSharpType) list -> FSharpType - override ToString : unit -> string - member AbbreviatedType : FSharpType - member AllInterfaces : System.Collections.Generic.IList - member AnonRecordTypeDetails : FSharpAnonRecordTypeDetails - member BaseType : FSharpType option - member GenericArguments : System.Collections.Generic.IList - member GenericParameter : FSharpGenericParameter - member HasTypeDefinition : bool - member IsAbbreviation : bool - member IsAnonRecordType : bool - member IsFunctionType : bool - member IsGenericParameter : bool - [] - member IsNamedType : bool - member IsStructTupleType : bool - member IsTupleType : bool - member IsUnresolved : bool - [] - member NamedEntity : FSharpEntity - member TypeDefinition : FSharpEntity - member private V : TypedTree.TType - member private cenv : SymbolEnv - end - [] - and FSharpAttribute = - class - new : cenv:SymbolEnv * attrib:AttributeChecking.AttribInfo -> - FSharpAttribute - member Format : context:FSharpDisplayContext -> string - override ToString : unit -> string - member AttributeType : FSharpEntity - member - ConstructorArguments : System.Collections.Generic.IList - member IsUnresolved : bool - member - NamedArguments : System.Collections.Generic.IList - member Range : Range.range - end - [] - and FSharpStaticParameter = - class - inherit FSharpSymbol - new : cenv:SymbolEnv * sp:Tainted * - m:Range.range -> FSharpStaticParameter - override Equals : other:obj -> bool - override GetHashCode : unit -> int - override ToString : unit -> string - member DeclarationLocation : Range.range - member DefaultValue : obj - [] - member HasDefaultValue : bool - member IsOptional : bool - member Kind : FSharpType - member Name : string - member Range : Range.range - end - [] - and FSharpParameter = - class - inherit FSharpSymbol - new : cenv:SymbolEnv * ty:TypedTree.TType * argInfo:TypedTree.ArgReprInfo * - ownerRangeOpt:Range.range option -> FSharpParameter - new : cenv:SymbolEnv * id:SyntaxTree.Ident * ty:TypedTree.TType * - container:NameResolution.ArgumentContainer option -> FSharpParameter - new : cenv:SymbolEnv * paramTy:TypedTree.TType * - topArgInfo:TypedTree.ArgReprInfo * - ownerOpt:NameResolution.ArgumentContainer option * - ownerRangeOpt:Range.range option * isParamArrayArg:bool * - isInArg:bool * isOutArg:bool * isOptionalArg:bool * - isWitnessArg:bool -> FSharpParameter - member AdjustType : ty:TypedTree.TType -> FSharpParameter - override Equals : other:obj -> bool - override GetHashCode : unit -> int - override ToString : unit -> string - member Attributes : System.Collections.Generic.IList - member DeclarationLocation : Range.range - member IsInArg : bool - member IsOptionalArg : bool - member IsOutArg : bool - member IsParamArrayArg : bool - member IsWitnessArg : bool - member Name : string option - member Owner : FSharpSymbol option - member Type : FSharpType - member V : TypedTree.TType - member private ValReprInfo : TypedTree.ArgReprInfo - member cenv : SymbolEnv - end - and FSharpAssemblySignature = - class - new : tcGlobals:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * - thisCcuTyp:TypedTree.ModuleOrNamespaceType * - tcImports:CompilerImports.TcImports * - topAttribs:CheckDeclarations.TopAttribs option * - contents:TypedTree.ModuleOrNamespaceType -> FSharpAssemblySignature - new : cenv:SymbolEnv * ccu:TypedTree.CcuThunk -> FSharpAssemblySignature - new : cenv:SymbolEnv * topAttribs:CheckDeclarations.TopAttribs option * - optViewedCcu:TypedTree.CcuThunk option * - mtyp:TypedTree.ModuleOrNamespaceType -> FSharpAssemblySignature - member FindEntityByPath : string list -> FSharpEntity option - override ToString : unit -> string - member Attributes : System.Collections.Generic.IList - member Entities : System.Collections.Generic.IList - end - and FSharpAssembly = - class - new : tcGlobals:TcGlobals.TcGlobals * tcImports:CompilerImports.TcImports * - ccu:TypedTree.CcuThunk -> FSharpAssembly - internal new : cenv:SymbolEnv * ccu:TypedTree.CcuThunk -> FSharpAssembly - override ToString : unit -> string - [] - member CodeLocation : string - member Contents : FSharpAssemblySignature - member FileName : string option - member IsProviderGenerated : bool - member QualifiedName : string - member RawCcuThunk : TypedTree.CcuThunk - member SimpleName : string - end - [] - and FSharpOpenDeclaration = - class - new : target:SyntaxTree.SynOpenDeclTarget * range:Range.range option * - modules:FSharpEntity list * types:FSharpType list * - appliedScope:Range.range * isOwnNamespace:bool -> - FSharpOpenDeclaration - member AppliedScope : Range.range - member IsOwnNamespace : bool - member LongId : SyntaxTree.LongIdent - member Modules : FSharpEntity list - member Range : Range.range option - member Target : SyntaxTree.SynOpenDeclTarget - member Types : FSharpType list - end - [] - and FSharpSymbolUse = - class - new : g:TcGlobals.TcGlobals * denv:TypedTreeOps.DisplayEnv * - symbol:FSharpSymbol * itemOcc:NameResolution.ItemOccurence * - range:Range.range -> FSharpSymbolUse - override ToString : unit -> string - member DisplayContext : FSharpDisplayContext - member FileName : string - member IsDefinition : bool - member IsFromAttribute : bool - member IsFromComputationExpression : bool - member IsFromDefinition : bool - member IsFromDispatchSlotImplementation : bool - member IsFromOpenStatement : bool - member IsFromPattern : bool - member IsFromType : bool - member IsPrivateToFile : bool - member Range : Range.Range01 - member RangeAlternate : Range.range - member Symbol : FSharpSymbol - end - module Impl = begin - val protect : f:(unit -> 'a) -> 'a - val makeReadOnlyCollection : - arr:seq<'T> -> System.Collections.Generic.IList<'T> - val makeXmlDoc : - doc:XmlDoc.XmlDoc -> System.Collections.Generic.IList - val makeElaboratedXmlDoc : - doc:XmlDoc.XmlDoc -> System.Collections.Generic.IList - val rescopeEntity : - optViewedCcu:TypedTree.CcuThunk option -> - entity:TypedTree.Entity -> TypedTree.EntityRef - val entityIsUnresolved : entity:TypedTree.EntityRef -> bool - val checkEntityIsResolved : entity:TypedTree.EntityRef -> unit - val checkForCrossProjectAccessibility : - ilg:AbstractIL.IL.ILGlobals -> - thisCcu2:TypedTree.CcuThunk * ad2:AccessibilityLogic.AccessorDomain -> - thisCcu1:TypedTree.CcuThunk * taccess1:TypedTree.Accessibility -> bool - val getApproxFSharpAccessibilityOfMember : - declaringEntity:TypedTree.EntityRef -> - ilAccess:AbstractIL.IL.ILMemberAccess -> TypedTree.Accessibility - val getApproxFSharpAccessibilityOfEntity : - entity:TypedTree.EntityRef -> TypedTree.Accessibility - val getLiteralValue : _arg6:TypedTree.Const option -> obj option - val getXmlDocSigForEntity : - cenv:SymbolEnv -> ent:TypedTree.EntityRef -> string - end - -namespace FSharp.Compiler.SourceCodeServices - module ExprTranslationImpl = begin - val nonNil : x:'a list -> bool - type ExprTranslationEnv = - { vs: TypedTreeOps.ValMap - tyvs: TypedTree.StampMap - isinstVals: TypedTreeOps.ValMap - substVals: TypedTreeOps.ValMap - suppressWitnesses: bool - witnessesInScope: TypedTreeOps.TraitWitnessInfoHashMap } - with - static member Empty : g:TcGlobals.TcGlobals -> ExprTranslationEnv - member - BindCurriedVals : vsl:TypedTree.Val list list -> ExprTranslationEnv - member - BindIsInstVal : v:TypedTree.Val -> - ty:TypedTree.TType * e:TypedTree.Expr -> - ExprTranslationEnv - member - BindSubstVal : v:TypedTree.Val -> - e:TypedTree.Expr -> ExprTranslationEnv - member - BindTypar : v:TypedTree.Typar * gp:FSharpGenericParameter -> - ExprTranslationEnv - member - BindTypars : vs:(TypedTree.Typar * #FSharpGenericParameter) list -> - ExprTranslationEnv - member BindVal : v:TypedTree.Val -> ExprTranslationEnv - member BindVals : vs:TypedTree.Val list -> ExprTranslationEnv - end - exception IgnoringPartOfQuotedTermWarning of string * Range.range - val wfail : msg:string * m:Range.range -> 'a - end - type E = - | Value of FSharpMemberOrFunctionOrValue - | ThisValue of FSharpType - | BaseValue of FSharpType - | Application of FSharpExpr * FSharpType list * FSharpExpr list - | Lambda of FSharpMemberOrFunctionOrValue * FSharpExpr - | TypeLambda of FSharpGenericParameter list * FSharpExpr - | Quote of FSharpExpr - | IfThenElse of FSharpExpr * FSharpExpr * FSharpExpr - | DecisionTree of - FSharpExpr * (FSharpMemberOrFunctionOrValue list * FSharpExpr) list - | DecisionTreeSuccess of int * FSharpExpr list - | Call of - FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * - FSharpType list * FSharpExpr list * FSharpExpr list - | NewObject of - FSharpMemberOrFunctionOrValue * FSharpType list * FSharpExpr list - | LetRec of (FSharpMemberOrFunctionOrValue * FSharpExpr) list * FSharpExpr - | Let of (FSharpMemberOrFunctionOrValue * FSharpExpr) * FSharpExpr - | NewRecord of FSharpType * FSharpExpr list - | ObjectExpr of - FSharpType * FSharpExpr * FSharpObjectExprOverride list * - (FSharpType * FSharpObjectExprOverride list) list - | FSharpFieldGet of FSharpExpr option * FSharpType * FSharpField - | FSharpFieldSet of - FSharpExpr option * FSharpType * FSharpField * FSharpExpr - | NewUnionCase of FSharpType * FSharpUnionCase * FSharpExpr list - | NewAnonRecord of FSharpType * FSharpExpr list - | AnonRecordGet of FSharpExpr * FSharpType * int - | UnionCaseGet of FSharpExpr * FSharpType * FSharpUnionCase * FSharpField - | UnionCaseSet of - FSharpExpr * FSharpType * FSharpUnionCase * FSharpField * FSharpExpr - | UnionCaseTag of FSharpExpr * FSharpType - | UnionCaseTest of FSharpExpr * FSharpType * FSharpUnionCase - | TraitCall of - FSharpType list * string * SyntaxTree.MemberFlags * FSharpType list * - FSharpType list * FSharpExpr list - | NewTuple of FSharpType * FSharpExpr list - | TupleGet of FSharpType * int * FSharpExpr - | Coerce of FSharpType * FSharpExpr - | NewArray of FSharpType * FSharpExpr list - | TypeTest of FSharpType * FSharpExpr - | AddressSet of FSharpExpr * FSharpExpr - | ValueSet of FSharpMemberOrFunctionOrValue * FSharpExpr - | Unused - | DefaultValue of FSharpType - | Const of obj * FSharpType - | AddressOf of FSharpExpr - | Sequential of FSharpExpr * FSharpExpr - | FastIntegerForLoop of FSharpExpr * FSharpExpr * FSharpExpr * bool - | WhileLoop of FSharpExpr * FSharpExpr - | TryFinally of FSharpExpr * FSharpExpr - | TryWith of - FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr * - FSharpMemberOrFunctionOrValue * FSharpExpr - | NewDelegate of FSharpType * FSharpExpr - | ILFieldGet of FSharpExpr option * FSharpType * string - | ILFieldSet of FSharpExpr option * FSharpType * string * FSharpExpr - | ILAsm of string * FSharpType list * FSharpExpr list - | WitnessArg of int - [] - and FSharpObjectExprOverride = - class - new : sgn:FSharpAbstractSignature * gps:FSharpGenericParameter list * - args:FSharpMemberOrFunctionOrValue list list * body:FSharpExpr -> - FSharpObjectExprOverride - member Body : FSharpExpr - member CurriedParameterGroups : FSharpMemberOrFunctionOrValue list list - member GenericParameters : FSharpGenericParameter list - member Signature : FSharpAbstractSignature - end - [] - and FSharpExpr = - class - new : cenv:SymbolEnv * f:(unit -> FSharpExpr) option * e:E * m:Range.range * - ty:TypedTree.TType -> FSharpExpr - override ToString : unit -> string - member E : E - member ImmediateSubExpressions : FSharpExpr list - member Range : Range.range - member Type : FSharpType - member cenv : SymbolEnv - end - module FSharpExprConvert = begin - val IsStaticInitializationField : rfref:TypedTree.RecdFieldRef -> bool - val ( |StaticInitializationCheck|_| ) : e:TypedTree.Expr -> unit option - val ( |StaticInitializationCount|_| ) : e:TypedTree.Expr -> unit option - val ( |ILUnaryOp|_| ) : - e:AbstractIL.IL.ILInstr -> - (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr) option - val ( |ILMulDivOp|_| ) : - e:AbstractIL.IL.ILInstr -> - ((#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> - TypedTree.TType -> TypedTree.TType -> TypedTree.Expr -> - TypedTree.Expr -> TypedTree.Expr) * bool) option - val ( |ILBinaryOp|_| ) : - e:AbstractIL.IL.ILInstr -> - (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr -> TypedTree.Expr) option - val ( |ILConvertOp|_| ) : - e:AbstractIL.IL.ILInstr -> - (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr) option - val ( |TTypeConvOp|_| ) : - cenv:SymbolEnv -> - ty:TypedTree.TType -> - (#TcGlobals.TcGlobals -> Range.range -> TypedTree.TType -> - TypedTree.Expr -> TypedTree.Expr) option - val ConvType : cenv:SymbolEnv -> ty:TypedTree.TType -> FSharpType - val ConvTypes : - cenv:SymbolEnv -> tys:TypedTree.TType list -> FSharpType list - val ConvILTypeRefApp : - cenv:SymbolEnv -> - m:Range.range -> - tref:AbstractIL.IL.ILTypeRef -> - tyargs:TypedTree.TypeInst -> FSharpType - val ConvUnionCaseRef : - cenv:SymbolEnv -> ucref:TypedTree.UnionCaseRef -> FSharpUnionCase - val ConvRecdFieldRef : - cenv:SymbolEnv -> rfref:TypedTree.RecdFieldRef -> FSharpField - val exprOfExprAddr : cenv:SymbolEnv -> expr:TypedTree.Expr -> TypedTree.Expr - val Mk : - cenv:SymbolEnv -> m:Range.range -> ty:TypedTree.TType -> e:E -> FSharpExpr - val Mk2 : cenv:SymbolEnv -> orig:TypedTree.Expr -> e:E -> FSharpExpr - val ConvLValueExpr : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - expr:TypedTree.Expr -> FSharpExpr - val ConvExpr : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - expr:TypedTree.Expr -> FSharpExpr - val ConvExprLinear : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - expr:TypedTree.Expr -> contF:(FSharpExpr -> E) -> E - val ConvExprPrimLinear : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - expr:TypedTree.Expr -> contF:(E -> E) -> E - val ConvModuleValueOrMemberUseLinear : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - expr:TypedTree.Expr * vref:TypedTree.ValRef * - vFlags:TypedTree.ValUseFlag * tyargs:TypedTree.TypeInst * - curriedArgs:TypedTree.Expr list -> contF:(E -> E) -> E - val GetWitnessArgs : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - vref:TypedTree.ValRef -> - m:Range.range -> - tps:TypedTree.Typars -> - tyargs:TypedTree.TypeInst -> FSharpExpr list - val ConvExprPrim : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> expr:TypedTree.Expr -> E - val ConvWitnessInfoPrim : - _cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - traitInfo:TypedTree.TraitConstraintInfo -> E - val ConvWitnessInfo : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - m:Range.range -> traitInfo:TypedTree.TraitConstraintInfo -> FSharpExpr - val ConvLetBind : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - bind:TypedTree.Binding -> - (FSharpMemberOrFunctionOrValue * FSharpExpr) option * - ExprTranslationImpl.ExprTranslationEnv - val ConvILCall : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - isNewObj:bool * valUseFlags:TypedTree.ValUseFlag * - ilMethRef:AbstractIL.IL.ILMethodRef * enclTypeArgs:TypedTree.TypeInst * - methTypeArgs:TypedTree.TypeInst * callArgs:TypedTree.Exprs * - m:Range.range -> E - val ConvObjectModelCallLinear : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - isNewObj:bool * v:FSharpMemberOrFunctionOrValue * - enclTyArgs:TypedTree.TType list * methTyArgs:TypedTree.TType list * - witnessArgsR:FSharpExpr list * callArgs:TypedTree.Expr list -> - contF:(E -> E) -> E - val ConvExprs : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - args:TypedTree.Exprs -> FSharpExpr list - val ConvExprsLinear : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - args:TypedTree.Expr list -> contF:(FSharpExpr list -> E) -> E - val ConvTargetsLinear : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - tgs:TypedTree.DecisionTreeTarget list -> - contF:((FSharpMemberOrFunctionOrValue list * FSharpExpr) list -> E) -> - E - val ConvValRef : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - m:Range.range -> vref:TypedTree.ValRef -> E - val ConvVal : - cenv:SymbolEnv -> v:TypedTree.Val -> FSharpMemberOrFunctionOrValue - val ConvConst : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - m:Range.range -> c:TypedTree.Const -> ty:TypedTree.TType -> E - val ConvDecisionTree : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - dtreeRetTy:TypedTree.TType -> - x:TypedTree.DecisionTree -> m:Range.range -> FSharpExpr - val ConvDecisionTreePrim : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - dtreeRetTy:TypedTree.TType -> x:TypedTree.DecisionTree -> E - val ConvExprOnDemand : - cenv:SymbolEnv -> - env:ExprTranslationImpl.ExprTranslationEnv -> - expr:TypedTree.Expr -> FSharpExpr - end - type FSharpAssemblyContents = - class - new : tcGlobals:TcGlobals.TcGlobals * thisCcu:TypedTree.CcuThunk * - thisCcuType:TypedTree.ModuleOrNamespaceType option * - tcImports:CompilerImports.TcImports * - mimpls:TypedTree.TypedImplFile list -> FSharpAssemblyContents - new : cenv:SymbolEnv * mimpls:TypedTree.TypedImplFile list -> - FSharpAssemblyContents - member ImplementationFiles : FSharpImplementationFileContents list - end - and FSharpImplementationFileDeclaration = - | Entity of FSharpEntity * FSharpImplementationFileDeclaration list - | MemberOrFunctionOrValue of - FSharpMemberOrFunctionOrValue * FSharpMemberOrFunctionOrValue list list * - FSharpExpr - | InitAction of FSharpExpr - and FSharpImplementationFileContents = - class - new : cenv:SymbolEnv * mimpl:TypedTree.TypedImplFile -> - FSharpImplementationFileContents - member Declarations : FSharpImplementationFileDeclaration list - member FileName : string - member HasExplicitEntryPoint : bool - member IsScript : bool - member QualifiedName : string - end - module BasicPatterns = begin - val ( |Value|_| ) : FSharpExpr -> FSharpMemberOrFunctionOrValue option - val ( |Const|_| ) : FSharpExpr -> (obj * FSharpType) option - val ( |TypeLambda|_| ) : - FSharpExpr -> (FSharpGenericParameter list * FSharpExpr) option - val ( |Lambda|_| ) : - FSharpExpr -> (FSharpMemberOrFunctionOrValue * FSharpExpr) option - val ( |Application|_| ) : - FSharpExpr -> (FSharpExpr * FSharpType list * FSharpExpr list) option - val ( |IfThenElse|_| ) : - FSharpExpr -> (FSharpExpr * FSharpExpr * FSharpExpr) option - val ( |Let|_| ) : - FSharpExpr -> - ((FSharpMemberOrFunctionOrValue * FSharpExpr) * FSharpExpr) option - val ( |LetRec|_| ) : - FSharpExpr -> - ((FSharpMemberOrFunctionOrValue * FSharpExpr) list * FSharpExpr) option - val ( |NewRecord|_| ) : FSharpExpr -> (FSharpType * FSharpExpr list) option - val ( |NewAnonRecord|_| ) : - FSharpExpr -> (FSharpType * FSharpExpr list) option - val ( |NewUnionCase|_| ) : - FSharpExpr -> (FSharpType * FSharpUnionCase * FSharpExpr list) option - val ( |NewTuple|_| ) : FSharpExpr -> (FSharpType * FSharpExpr list) option - val ( |TupleGet|_| ) : FSharpExpr -> (FSharpType * int * FSharpExpr) option - val ( |Call|_| ) : - FSharpExpr -> - (FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * - FSharpType list * FSharpExpr list) option - val ( |CallWithWitnesses|_| ) : - FSharpExpr -> - (FSharpExpr option * FSharpMemberOrFunctionOrValue * FSharpType list * - FSharpType list * FSharpExpr list * FSharpExpr list) option - val ( |NewObject|_| ) : - FSharpExpr -> - (FSharpMemberOrFunctionOrValue * FSharpType list * FSharpExpr list) option - val ( |FSharpFieldGet|_| ) : - FSharpExpr -> (FSharpExpr option * FSharpType * FSharpField) option - val ( |AnonRecordGet|_| ) : - FSharpExpr -> (FSharpExpr * FSharpType * int) option - val ( |FSharpFieldSet|_| ) : - FSharpExpr -> - (FSharpExpr option * FSharpType * FSharpField * FSharpExpr) option - val ( |UnionCaseGet|_| ) : - FSharpExpr -> - (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField) option - val ( |UnionCaseTag|_| ) : FSharpExpr -> (FSharpExpr * FSharpType) option - val ( |UnionCaseTest|_| ) : - FSharpExpr -> (FSharpExpr * FSharpType * FSharpUnionCase) option - val ( |NewArray|_| ) : FSharpExpr -> (FSharpType * FSharpExpr list) option - val ( |Coerce|_| ) : FSharpExpr -> (FSharpType * FSharpExpr) option - val ( |Quote|_| ) : FSharpExpr -> FSharpExpr option - val ( |TypeTest|_| ) : FSharpExpr -> (FSharpType * FSharpExpr) option - val ( |Sequential|_| ) : FSharpExpr -> (FSharpExpr * FSharpExpr) option - val ( |FastIntegerForLoop|_| ) : - FSharpExpr -> (FSharpExpr * FSharpExpr * FSharpExpr * bool) option - val ( |WhileLoop|_| ) : FSharpExpr -> (FSharpExpr * FSharpExpr) option - val ( |TryFinally|_| ) : FSharpExpr -> (FSharpExpr * FSharpExpr) option - val ( |TryWith|_| ) : - FSharpExpr -> - (FSharpExpr * FSharpMemberOrFunctionOrValue * FSharpExpr * - FSharpMemberOrFunctionOrValue * FSharpExpr) option - val ( |NewDelegate|_| ) : FSharpExpr -> (FSharpType * FSharpExpr) option - val ( |DefaultValue|_| ) : FSharpExpr -> FSharpType option - val ( |AddressSet|_| ) : FSharpExpr -> (FSharpExpr * FSharpExpr) option - val ( |ValueSet|_| ) : - FSharpExpr -> (FSharpMemberOrFunctionOrValue * FSharpExpr) option - val ( |AddressOf|_| ) : FSharpExpr -> FSharpExpr option - val ( |ThisValue|_| ) : FSharpExpr -> FSharpType option - val ( |BaseValue|_| ) : FSharpExpr -> FSharpType option - val ( |ILAsm|_| ) : - FSharpExpr -> (string * FSharpType list * FSharpExpr list) option - val ( |ILFieldGet|_| ) : - FSharpExpr -> (FSharpExpr option * FSharpType * string) option - val ( |ILFieldSet|_| ) : - FSharpExpr -> - (FSharpExpr option * FSharpType * string * FSharpExpr) option - val ( |ObjectExpr|_| ) : - FSharpExpr -> - (FSharpType * FSharpExpr * FSharpObjectExprOverride list * - (FSharpType * FSharpObjectExprOverride list) list) option - val ( |DecisionTree|_| ) : - FSharpExpr -> - (FSharpExpr * (FSharpMemberOrFunctionOrValue list * FSharpExpr) list) option - val ( |DecisionTreeSuccess|_| ) : - FSharpExpr -> (int * FSharpExpr list) option - val ( |UnionCaseSet|_| ) : - FSharpExpr -> - (FSharpExpr * FSharpType * FSharpUnionCase * FSharpField * FSharpExpr) option - val ( |TraitCall|_| ) : - FSharpExpr -> - (FSharpType list * string * SyntaxTree.MemberFlags * FSharpType list * - FSharpType list * FSharpExpr list) option - val ( |WitnessArg|_| ) : FSharpExpr -> int option - end - -namespace FSharp.Compiler.SourceCodeServices - module Symbol = begin - val isAttribute<'T> : FSharpAttribute -> bool - val tryGetAttribute<'T> : seq -> FSharpAttribute option - module Option = begin - val attempt : f:(unit -> 'a) -> 'a option - end - val hasModuleSuffixAttribute : FSharpEntity -> bool - val isOperator : name:string -> bool - val UnnamedUnionFieldRegex : System.Text.RegularExpressions.Regex - val isUnnamedUnionCaseField : FSharpField -> bool - val ( |AbbreviatedType|_| ) : FSharpEntity -> FSharpType option - val ( |TypeWithDefinition|_| ) : FSharpType -> FSharpEntity option - val getEntityAbbreviatedType : - FSharpEntity -> FSharpEntity * FSharpType option - val getAbbreviatedType : FSharpType -> FSharpType - val ( |Attribute|_| ) : FSharpEntity -> unit option - val hasAttribute<'T> : seq -> bool - val ( |ValueType|_| ) : FSharpEntity -> unit option - val ( |Class|_| ) : - original:FSharpEntity * abbreviated:FSharpEntity * 'a -> unit option - val ( |Record|_| ) : FSharpEntity -> unit option - val ( |UnionType|_| ) : FSharpEntity -> unit option - val ( |Delegate|_| ) : FSharpEntity -> unit option - val ( |FSharpException|_| ) : FSharpEntity -> unit option - val ( |Interface|_| ) : FSharpEntity -> unit option - val ( |AbstractClass|_| ) : FSharpEntity -> unit option - val ( |FSharpType|_| ) : FSharpEntity -> unit option - val ( |ProvidedType|_| ) : FSharpEntity -> unit option - val ( |ByRef|_| ) : FSharpEntity -> unit option - val ( |Array|_| ) : FSharpEntity -> unit option - val ( |FSharpModule|_| ) : FSharpEntity -> unit option - val ( |Namespace|_| ) : FSharpEntity -> unit option - val ( |ProvidedAndErasedType|_| ) : FSharpEntity -> unit option - val ( |Enum|_| ) : FSharpEntity -> unit option - val ( |Tuple|_| ) : FSharpType -> unit option - val ( |RefCell|_| ) : FSharpType -> unit option - val ( |FunctionType|_| ) : FSharpType -> unit option - val ( |Pattern|_| ) : FSharpSymbol -> unit option - val ( |Field|_| ) : FSharpSymbol -> (FSharpField * FSharpType) option - val ( |MutableVar|_| ) : FSharpSymbol -> unit option - val ( |FSharpEntity|_| ) : - FSharpSymbol -> (FSharpEntity * FSharpEntity * FSharpType option) option - val ( |Parameter|_| ) : FSharpSymbol -> unit option - val ( |UnionCase|_| ) : FSharpSymbol -> FSharpUnionCase option - val ( |RecordField|_| ) : FSharpSymbol -> FSharpField option - val ( |ActivePatternCase|_| ) : - FSharpSymbol -> FSharpActivePatternCase option - val ( |MemberFunctionOrValue|_| ) : - FSharpSymbol -> FSharpMemberOrFunctionOrValue option - val ( |Constructor|_| ) : - FSharpMemberOrFunctionOrValue -> FSharpEntity option - val ( |Function|_| ) : - excluded:bool -> FSharpMemberOrFunctionOrValue -> unit option - val ( |ExtensionMember|_| ) : FSharpMemberOrFunctionOrValue -> unit option - val ( |Event|_| ) : FSharpMemberOrFunctionOrValue -> unit option - end - -namespace FSharp.Compiler.SourceCodeServices - type internal IReactorOperations = - interface - abstract member - EnqueueAndAwaitOpAsync : userOpName:string * opName:string * - opArg:string * - action:(AbstractIL.Internal.Library.CompilationThreadToken -> - AbstractIL.Internal.Library.Cancellable<'T>) -> - Async<'T> - abstract member - EnqueueOp : userOpName:string * opName:string * opArg:string * - action:(AbstractIL.Internal.Library.CompilationThreadToken -> - unit) -> unit - end - [] - type internal ReactorCommands = - | SetBackgroundOp of - (string * string * string * - (AbstractIL.Internal.Library.CompilationThreadToken -> - System.Threading.CancellationToken -> bool)) option - | Op of - userOpName: string * opName: string * opArg: string * - System.Threading.CancellationToken * - (AbstractIL.Internal.Library.CompilationThreadToken -> unit) * - (unit -> unit) - | WaitForBackgroundOpCompletion of AsyncReplyChannel - | CompleteAllQueuedOps of AsyncReplyChannel - [] - type Reactor = - class - new : unit -> Reactor - member CancelBackgroundOp : unit -> unit - member CompleteAllQueuedOps : unit -> unit - member - EnqueueAndAwaitOpAsync : userOpName:string * opName:string * - opArg:string * - (AbstractIL.Internal.Library.CompilationThreadToken -> - AbstractIL.Internal.Library.Cancellable<'T>) -> - Async<'T> - member - EnqueueOp : userOpName:string * opName:string * opArg:string * - op:(AbstractIL.Internal.Library.CompilationThreadToken -> - unit) -> unit - member - EnqueueOpPrim : userOpName:string * opName:string * opArg:string * - ct:System.Threading.CancellationToken * - op:(AbstractIL.Internal.Library.CompilationThreadToken -> - unit) * ccont:(unit -> unit) -> unit - member - SetBackgroundOp : (string * string * string * - (AbstractIL.Internal.Library.CompilationThreadToken -> - System.Threading.CancellationToken -> bool)) option -> - unit - member SetPreferredUILang : string option -> unit - member WaitForBackgroundOpCompletion : unit -> unit - member CurrentQueueLength : int - member PauseBeforeBackgroundWork : int - static member Singleton : Reactor - end - -namespace FSharp.Compiler.SourceCodeServices - [] - type SemanticClassificationType = - | ReferenceType - | ValueType - | UnionCase - | UnionCaseField - | Function - | Property - | MutableVar - | Module - | Namespace - | Printf - | ComputationExpression - | IntrinsicFunction - | Enumeration - | Interface - | TypeArgument - | Operator - | DisposableType - | DisposableTopLevelValue - | DisposableLocalValue - | Method - | ExtensionMethod - | ConstructorForReferenceType - | ConstructorForValueType - | Literal - | RecordField - | MutableRecordField - | RecordFieldAsFunction - | Exception - | Field - | Event - | Delegate - | NamedArgument - | Value - | LocalValue - | Type - | TypeDef - | Plaintext - module TcResolutionsExtensions = begin - val ( |CNR| ) : - cnr:NameResolution.CapturedNameResolution -> - NameResolution.Item * NameResolution.ItemOccurence * - TypedTreeOps.DisplayEnv * NameResolution.NameResolutionEnv * - AccessibilityLogic.AccessorDomain * Range.range - type internal TcResolutions with - member - GetSemanticClassification : g:TcGlobals.TcGlobals * - amap:Import.ImportMap * - formatSpecifierLocations:(Range.range * int) [] * - range:Range.range option -> - struct - (Range.range * - SemanticClassificationType) [] - end - -namespace FSharp.Compiler.SourceCodeServices - module ItemKeyTags = begin - [] - val entityRef : string = "#E#" - [] - val typeTuple : string = "#T#" - [] - val typeAnonymousRecord : string = "#N#" - [] - val typeFunction : string = "#F#" - [] - val typeMeasure : string = "#M#" - [] - val typeUnionCase : string = "#U#" - [] - val typeMeasureVar : string = "#p#" - [] - val typeMeasureCon : string = "#c#" - [] - val itemValueMember : string = "m$" - [] - val itemValue : string = "v$" - [] - val itemUnionCase : string = "u$" - [] - val itemActivePattern : string = "r$" - [] - val itemExnCase : string = "e$" - [] - val itemRecordField : string = "d$" - [] - val itemAnonymousRecordField : string = "a$" - [] - val itemNewDef : string = "n$" - [] - val itemILField : string = "l$" - [] - val itemEvent : string = "t$" - [] - val itemProperty : string = "p$" - [] - val itemTypeVar : string = "y$" - [] - val itemModuleOrNamespace : string = "o$" - [] - val itemDelegateCtor : string = "g$" - [] - val parameters : string = "p$p$" - end - [] - type ItemKeyStore = - class - interface System.IDisposable - new : mmf:System.IO.MemoryMappedFiles.MemoryMappedFile * length:int64 -> - ItemKeyStore - member FindAll : NameResolution.Item -> seq - member ReadFirstKeyString : unit -> System.ReadOnlySpan - member - ReadKeyString : reader:byref -> - System.ReadOnlySpan - member - ReadRange : reader:byref -> - Range.range - end - [] - and ItemKeyStoreBuilder = - class - new : unit -> ItemKeyStoreBuilder - member TryBuildAndReset : unit -> ItemKeyStore option - member Write : Range.range * NameResolution.Item -> unit - end - -namespace FSharp.Compiler - module internal IncrementalBuild = begin - val mutable injectCancellationFault : bool - val LocallyInjectCancellationFault : unit -> System.IDisposable - end - module IncrementalBuilderEventTesting = begin - type internal FixedLengthMRU<'T> = - class - new : unit -> FixedLengthMRU<'T> - member Add : filename:'T -> unit - member MostRecentList : n:int -> 'T list - member CurrentEventNum : int - end - type IBEvent = - | IBEParsed of string - | IBETypechecked of string - | IBECreated - val MRU : FixedLengthMRU - val GetMostRecentIncrementalBuildEvents : int -> IBEvent list - val GetCurrentIncrementalBuildEventNum : unit -> int - end - module IncrementalBuildSyntaxTree = begin - [] - type SyntaxTree = - class - new : tcConfig:CompilerConfig.TcConfig * fileParsed:Event * - lexResourceManager:Lexhelp.LexResourceManager * - sourceRange:Range.range * filename:string * - isLastCompiland:(bool * bool) -> SyntaxTree - member Invalidate : unit -> unit - member - Parse : sigNameOpt:SyntaxTree.QualifiedNameOfFile option -> - SyntaxTree.ParsedInput option * Range.range * string * - (ErrorLogger.PhasedDiagnostic * - SourceCodeServices.FSharpErrorSeverity) [] - member FileName : string - end - end - [] - type TcInfo = - { tcState: ParseAndCheckInputs.TcState - tcEnvAtEndOfFile: CheckExpressions.TcEnv - moduleNamesDict: ParseAndCheckInputs.ModuleNamesDict - topAttribs: CheckDeclarations.TopAttribs option - latestCcuSigForFile: TypedTree.ModuleOrNamespaceType option - tcErrorsRev: - (ErrorLogger.PhasedDiagnostic * SourceCodeServices.FSharpErrorSeverity) [] list - tcDependencyFiles: string list - sigNameOpt: (string * SyntaxTree.QualifiedNameOfFile) option } - with - member - TcErrors : (ErrorLogger.PhasedDiagnostic * - SourceCodeServices.FSharpErrorSeverity) [] - end - [] - type TcInfoOptional = - { tcResolutionsRev: NameResolution.TcResolutions list - tcSymbolUsesRev: NameResolution.TcSymbolUses list - tcOpenDeclarationsRev: NameResolution.OpenDeclaration [] list - latestImplFile: TypedTree.TypedImplFile option - itemKeyStore: SourceCodeServices.ItemKeyStore option - semanticClassification: - struct (Range.range * SourceCodeServices.SemanticClassificationType) [] } - with - member TcSymbolUses : NameResolution.TcSymbolUses list - end - [] - type TcInfoState = - | PartialState of TcInfo - | FullState of TcInfo * TcInfoOptional - with - member Partial : TcInfo - end - [] - type SemanticModel = - class - private new : tcConfig:CompilerConfig.TcConfig * - tcGlobals:TcGlobals.TcGlobals * - tcImports:CompilerImports.TcImports * - keepAssemblyContents:bool * - keepAllBackgroundResolutions:bool * - maxTimeShareMilliseconds:int64 * - keepAllBackgroundSymbolUses:bool * - enableBackgroundItemKeyStoreAndSemanticClassification:bool * - enablePartialTypeChecking:bool * - beforeFileChecked:Event * fileChecked:Event * - prevTcInfo:TcInfo * - prevTcInfoOptional:AbstractIL.Internal.Library.Eventually * - syntaxTreeOpt:IncrementalBuildSyntaxTree.SyntaxTree option * - lazyTcInfoState:TcInfoState option ref -> SemanticModel - static member - Create : tcConfig:CompilerConfig.TcConfig * - tcGlobals:TcGlobals.TcGlobals * - tcImports:CompilerImports.TcImports * keepAssemblyContents:bool * - keepAllBackgroundResolutions:bool * - maxTimeShareMilliseconds:int64 * - keepAllBackgroundSymbolUses:bool * - enableBackgroundItemKeyStoreAndSemanticClassification:bool * - enablePartialTypeChecking:bool * - beforeFileChecked:Event * fileChecked:Event * - prevTcInfo:TcInfo * - prevTcInfoOptional:AbstractIL.Internal.Library.Eventually * - syntaxTreeOpt:IncrementalBuildSyntaxTree.SyntaxTree option -> - SemanticModel - member - Finish : finalTcErrorsRev:(ErrorLogger.PhasedDiagnostic * - SourceCodeServices.FSharpErrorSeverity) [] list * - finalTopAttribs:CheckDeclarations.TopAttribs option -> - AbstractIL.Internal.Library.Eventually - member - GetState : partialCheck:bool -> - AbstractIL.Internal.Library.Eventually - member Invalidate : unit -> unit - member - Next : syntaxTree:IncrementalBuildSyntaxTree.SyntaxTree -> - AbstractIL.Internal.Library.Eventually - member - private TypeCheck : partialCheck:bool -> - AbstractIL.Internal.Library.Eventually - member BackingSignature : SyntaxTree.QualifiedNameOfFile option - member TcConfig : CompilerConfig.TcConfig - member TcGlobals : TcGlobals.TcGlobals - member TcImports : CompilerImports.TcImports - member TcInfo : AbstractIL.Internal.Library.Eventually - member - TcInfoWithOptional : AbstractIL.Internal.Library.Eventually - end - type FrameworkImportsCacheKey = - string list * string * string list * string * decimal - type FrameworkImportsCache = - class - new : size:int -> FrameworkImportsCache - member Clear : AbstractIL.Internal.Library.CompilationThreadToken -> unit - member - Downsize : AbstractIL.Internal.Library.CompilationThreadToken -> unit - member - Get : AbstractIL.Internal.Library.CompilationThreadToken * - CompilerConfig.TcConfig -> - AbstractIL.Internal.Library.Cancellable - end - [] - type PartialCheckResults = - class - private new : semanticModel:SemanticModel * timeStamp:System.DateTime -> - PartialCheckResults - static member - Create : semanticModel:SemanticModel * timestamp:System.DateTime -> - PartialCheckResults - member - GetSemanticClassification : AbstractIL.Internal.Library.CompilationThreadToken -> - struct - (Range.range * - SourceCodeServices.SemanticClassificationType) [] - member - TcInfo : AbstractIL.Internal.Library.CompilationThreadToken -> TcInfo - member - TcInfoWithOptional : AbstractIL.Internal.Library.CompilationThreadToken -> - TcInfo * TcInfoOptional - member - TryGetItemKeyStore : AbstractIL.Internal.Library.CompilationThreadToken -> - SourceCodeServices.ItemKeyStore option - member TcConfig : CompilerConfig.TcConfig - member TcGlobals : TcGlobals.TcGlobals - member TcImports : CompilerImports.TcImports - member TimeStamp : System.DateTime - end - module Utilities = begin - val TryFindFSharpStringAttribute : - tcGlobals:TcGlobals.TcGlobals -> - attribSpec:TcGlobals.BuiltinAttribInfo -> - attribs:TypedTree.Attribs -> string option - end - type RawFSharpAssemblyDataBackedByLanguageService = - class - interface CompilerConfig.IRawFSharpAssemblyData - new : tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * - tcState:ParseAndCheckInputs.TcState * outfile:string * - topAttrs:CheckDeclarations.TopAttribs * assemblyName:string * - ilAssemRef:AbstractIL.IL.ILAssemblyRef -> - RawFSharpAssemblyDataBackedByLanguageService - end - [] - type IncrementalBuilder = - class - new : tcGlobals:TcGlobals.TcGlobals * - frameworkTcImports:CompilerImports.TcImports * - nonFrameworkAssemblyInputs:(Choice * - (CompilerConfig.TimeStampCache -> - AbstractIL.Internal.Library.CompilationThreadToken -> - System.DateTime)) list * - nonFrameworkResolutions:CompilerImports.AssemblyResolution list * - unresolvedReferences:CompilerConfig.UnresolvedAssemblyReference list * - tcConfig:CompilerConfig.TcConfig * projectDirectory:string * - outfile:string * assemblyName:string * - niceNameGen:CompilerGlobalState.NiceNameGenerator * - lexResourceManager:Lexhelp.LexResourceManager * - sourceFiles:string list * - loadClosureOpt:ScriptClosure.LoadClosure option * - keepAssemblyContents:bool * keepAllBackgroundResolutions:bool * - maxTimeShareMilliseconds:int64 * keepAllBackgroundSymbolUses:bool * - enableBackgroundItemKeyStoreAndSemanticClassification:bool * - enablePartialTypeChecking:bool * - dependencyProviderOpt:Microsoft.DotNet.DependencyManager.DependencyProvider option -> - IncrementalBuilder - static member - TryCreateIncrementalBuilderForProjectOptions : AbstractIL.Internal.Library.CompilationThreadToken * - ReferenceResolver.Resolver * - defaultFSharpBinariesDir:string * - FrameworkImportsCache * - loadClosureOpt:ScriptClosure.LoadClosure option * - sourceFiles:string list * - commandLineArgs:string list * - projectReferences:CompilerConfig.IProjectReference list * - projectDirectory:string * - useScriptResolutionRules:bool * - keepAssemblyContents:bool * - keepAllBackgroundResolutions:bool * - maxTimeShareMilliseconds:int64 * - tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * - suggestNamesForErrors:bool * - keepAllBackgroundSymbolUses:bool * - enableBackgroundItemKeyStoreAndSemanticClassification:bool * - enablePartialTypeChecking:bool * - dependencyProvider:Microsoft.DotNet.DependencyManager.DependencyProvider option -> - AbstractIL.Internal.Library.Cancellable - member AreCheckResultsBeforeFileInProjectReady : filename:string -> bool - member ContainsFile : filename:string -> bool - member - GetCheckResultsAfterFileInProject : AbstractIL.Internal.Library.CompilationThreadToken * - filename:string -> - AbstractIL.Internal.Library.Cancellable - member - GetCheckResultsAfterLastFileInProject : AbstractIL.Internal.Library.CompilationThreadToken -> - AbstractIL.Internal.Library.Cancellable - member - GetCheckResultsAndImplementationsForProject : AbstractIL.Internal.Library.CompilationThreadToken -> - AbstractIL.Internal.Library.Cancellable - member - GetCheckResultsBeforeFileInProject : AbstractIL.Internal.Library.CompilationThreadToken * - filename:string -> - AbstractIL.Internal.Library.Cancellable - member - GetCheckResultsBeforeFileInProjectEvenIfStale : filename:string -> - PartialCheckResults option - member - GetCheckResultsBeforeSlotInProject : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - slotOfFile:int -> - AbstractIL.Internal.Library.Cancellable - member - GetFullCheckResultsAfterFileInProject : AbstractIL.Internal.Library.CompilationThreadToken * - filename:string -> - AbstractIL.Internal.Library.Cancellable - member - GetFullCheckResultsAndImplementationsForProject : AbstractIL.Internal.Library.CompilationThreadToken -> - AbstractIL.Internal.Library.Cancellable - member - GetLogicalTimeStampForProject : CompilerConfig.TimeStampCache * - AbstractIL.Internal.Library.CompilationThreadToken -> - System.DateTime - member - GetParseResultsForFile : AbstractIL.Internal.Library.CompilationThreadToken * - filename:string -> - AbstractIL.Internal.Library.Cancellable - member GetSlotOfFileName : filename:string -> int - member GetSlotsCount : unit -> int - member - Step : AbstractIL.Internal.Library.CompilationThreadToken -> - AbstractIL.Internal.Library.Cancellable - member TryGetCurrentTcImports : unit -> CompilerImports.TcImports option - member TryGetSlotOfFileName : filename:string -> int option - member AllDependenciesDeprecated : string [] - member BeforeFileChecked : IEvent - member FileChecked : IEvent - member FileParsed : IEvent - member ImportsInvalidatedByTypeProvider : IEvent - member ProjectChecked : IEvent - member SourceFiles : string list - member TcConfig : CompilerConfig.TcConfig - end - -namespace FSharp.Compiler.SourceCodeServices - type DiagnosticKind = - | AddIndexerDot - | ReplaceWithSuggestion of suggestion: string - module CompilerDiagnostics = begin - val getErrorMessage : diagnosticKind:DiagnosticKind -> string - end - -namespace FSharp.Compiler.SourceCodeServices - [] - type FSharpGlyph = - | Class - | Constant - | Delegate - | Enum - | EnumMember - | Event - | Exception - | Field - | Interface - | Method - | OverridenMethod - | Module - | NameSpace - | Property - | Struct - | Typedef - | Type - | Union - | Variable - | ExtensionMethod - | Error - -namespace FSharp.Compiler.SourceCodeServices - [] - type FSharpMethodGroupItemParameter = - class - new : name:string * canonicalTypeTextForSorting:string * - display:Layout.layout * isOptional:bool -> - FSharpMethodGroupItemParameter - member CanonicalTypeTextForSorting : string - member Display : string - member IsOptional : bool - member ParameterName : string - member StructuredDisplay : Layout.layout - end - module internal DescriptionListsImpl = begin - val isFunction : g:TcGlobals.TcGlobals -> ty:TypedTree.TType -> bool - val printCanonicalizedTypeName : - g:TcGlobals.TcGlobals -> - denv:TypedTreeOps.DisplayEnv -> tau:TypedTree.TType -> string - val PrettyParamOfRecdField : - g:TcGlobals.TcGlobals -> - denv:TypedTreeOps.DisplayEnv -> - f:TypedTree.RecdField -> FSharpMethodGroupItemParameter - val PrettyParamOfUnionCaseField : - g:TcGlobals.TcGlobals -> - denv:TypedTreeOps.DisplayEnv -> - isGenerated:(int -> TypedTree.RecdField -> bool) -> - i:int -> f:TypedTree.RecdField -> FSharpMethodGroupItemParameter - val ParamOfParamData : - g:TcGlobals.TcGlobals -> - denv:TypedTreeOps.DisplayEnv -> - Infos.ParamData -> FSharpMethodGroupItemParameter - val PrettyParamsOfParamDatas : - g:TcGlobals.TcGlobals -> - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst -> - paramDatas:Infos.ParamData list -> - rty:TypedTree.TType -> - TypedTreeOps.TyparInst * FSharpMethodGroupItemParameter list * - Internal.Utilities.StructuredFormat.Layout * - Internal.Utilities.StructuredFormat.Layout - val PrettyParamsOfTypes : - g:TcGlobals.TcGlobals -> - denv:TypedTreeOps.DisplayEnv -> - typarInst:TypedTreeOps.TyparInst -> - paramTys:TypedTree.TTypes -> - retTy:TypedTree.TType -> - TypedTreeOps.TyparInst * FSharpMethodGroupItemParameter list * - Internal.Utilities.StructuredFormat.Layout * - Internal.Utilities.StructuredFormat.Layout - val StaticParamsOfItem : - infoReader:InfoReader.InfoReader -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - item:NameResolution.Item -> FSharpMethodGroupItemParameter [] - val PrettyParamsAndReturnTypeOfItem : - infoReader:InfoReader.InfoReader -> - m:Range.range -> - denv:TypedTreeOps.DisplayEnv -> - item:NameResolution.ItemWithInst -> - FSharpMethodGroupItemParameter list * - Internal.Utilities.StructuredFormat.Layout - val GlyphOfItem : - denv:TypedTreeOps.DisplayEnv * item:NameResolution.Item -> FSharpGlyph - val AnotherFlattenItems : - g:TcGlobals.TcGlobals -> - m:Range.range -> item:NameResolution.Item -> NameResolution.Item list - end - [] - type FSharpDeclarationListItem = - class - new : name:string * nameInCode:string * fullName:string * - glyph:FSharpGlyph * - info:Choice<(CompletionItem list * InfoReader.InfoReader * - Range.range * TypedTreeOps.DisplayEnv), - FSharpToolTipText> * - accessibility:FSharpAccessibility option * kind:CompletionItemKind * - isOwnMember:bool * priority:int * isResolved:bool * - namespaceToOpen:string option -> FSharpDeclarationListItem - member Accessibility : FSharpAccessibility option - member DescriptionText : FSharpToolTipText - [] - member DescriptionTextAsync : Async - member FullName : string - member Glyph : FSharpGlyph - member IsOwnMember : bool - member IsResolved : bool - member Kind : CompletionItemKind - member MinorPriority : int - member Name : string - member NameInCode : string - member NamespaceToOpen : string option - member StructuredDescriptionText : FSharpToolTipText - [] - member StructuredDescriptionTextAsync : Async> - end - [] - type FSharpDeclarationListInfo = - class - new : declarations:FSharpDeclarationListItem [] * isForType:bool * - isError:bool -> FSharpDeclarationListInfo - static member - Create : infoReader:InfoReader.InfoReader * m:Range.range * - denv:TypedTreeOps.DisplayEnv * - getAccessibility:(NameResolution.Item -> - FSharpAccessibility option) * - items:CompletionItem list * currentNamespace:string [] option * - isAttributeApplicationContext:bool -> FSharpDeclarationListInfo - static member Error : message:string -> FSharpDeclarationListInfo - member IsError : bool - member IsForType : bool - member Items : FSharpDeclarationListItem [] - static member Empty : FSharpDeclarationListInfo - end - [] - type FSharpMethodGroupItem = - class - new : description:FSharpToolTipText * xmlDoc:FSharpXmlDoc * - returnType:Layout.layout * - parameters:FSharpMethodGroupItemParameter [] * hasParameters:bool * - hasParamArrayArg:bool * - staticParameters:FSharpMethodGroupItemParameter [] -> - FSharpMethodGroupItem - member Description : FSharpToolTipText - member HasParamArrayArg : bool - member HasParameters : bool - member Parameters : FSharpMethodGroupItemParameter [] - member ReturnTypeText : string - member StaticParameters : FSharpMethodGroupItemParameter [] - member StructuredDescription : FSharpToolTipText - member StructuredReturnTypeText : Layout.layout - member XmlDoc : FSharpXmlDoc - end - [] - type FSharpMethodGroup = - class - new : string * FSharpMethodGroupItem [] -> FSharpMethodGroup - static member - Create : InfoReader.InfoReader * Range.range * TypedTreeOps.DisplayEnv * - NameResolution.ItemWithInst list -> FSharpMethodGroup - member MethodName : string - member Methods : FSharpMethodGroupItem [] - end - -namespace FSharp.Compiler.SourceCodeServices - type Position = int * int - type Range = Position * Position - module FSharpTokenTag = begin - val Identifier : int - val String : int - val IDENT : int - val STRING : int - val INTERP_STRING_BEGIN_END : int - val INTERP_STRING_BEGIN_PART : int - val INTERP_STRING_PART : int - val INTERP_STRING_END : int - val LPAREN : int - val RPAREN : int - val LBRACK : int - val RBRACK : int - val LBRACE : int - val RBRACE : int - val LBRACK_LESS : int - val GREATER_RBRACK : int - val LESS : int - val GREATER : int - val LBRACK_BAR : int - val BAR_RBRACK : int - val PLUS_MINUS_OP : int - val MINUS : int - val STAR : int - val INFIX_STAR_DIV_MOD_OP : int - val PERCENT_OP : int - val INFIX_AT_HAT_OP : int - val QMARK : int - val COLON : int - val EQUALS : int - val SEMICOLON : int - val COMMA : int - val DOT : int - val DOT_DOT : int - val DOT_DOT_HAT : int - val INT32_DOT_DOT : int - val UNDERSCORE : int - val BAR : int - val COLON_GREATER : int - val COLON_QMARK_GREATER : int - val COLON_QMARK : int - val INFIX_BAR_OP : int - val INFIX_COMPARE_OP : int - val COLON_COLON : int - val AMP_AMP : int - val PREFIX_OP : int - val COLON_EQUALS : int - val BAR_BAR : int - val RARROW : int - val LARROW : int - val QUOTE : int - val WHITESPACE : int - val COMMENT : int - val LINE_COMMENT : int - val BEGIN : int - val DO : int - val FUNCTION : int - val THEN : int - val ELSE : int - val STRUCT : int - val CLASS : int - val TRY : int - val NEW : int - val WITH : int - val OWITH : int - end - type FSharpTokenColorKind = - | Default = 0 - | Text = 0 - | Keyword = 1 - | Comment = 2 - | Identifier = 3 - | String = 4 - | UpperIdentifier = 5 - | InactiveCode = 7 - | PreprocessorKeyword = 8 - | Number = 9 - | Operator = 10 - | Punctuation = 11 - type FSharpTokenTriggerClass = - | None = 0 - | MemberSelect = 1 - | MatchBraces = 2 - | ChoiceSelect = 4 - | MethodTip = 240 - | ParamStart = 16 - | ParamNext = 32 - | ParamEnd = 64 - type FSharpTokenCharKind = - | Default = 0 - | Text = 0 - | Keyword = 1 - | Identifier = 2 - | String = 3 - | Literal = 4 - | Operator = 5 - | Delimiter = 6 - | WhiteSpace = 8 - | LineComment = 9 - | Comment = 10 - type FSharpTokenInfo = - { LeftColumn: int - RightColumn: int - ColorClass: FSharpTokenColorKind - CharClass: FSharpTokenCharKind - FSharpTokenTriggerClass: FSharpTokenTriggerClass - Tag: int - TokenName: string - FullMatchedLength: int } - module internal TokenClassifications = begin - val tokenInfo : - token:Parser.token -> - FSharpTokenColorKind * FSharpTokenCharKind * FSharpTokenTriggerClass - end - module internal TestExpose = begin - val TokenInfo : - Parser.token -> - FSharpTokenColorKind * FSharpTokenCharKind * FSharpTokenTriggerClass - end - [] - type FSharpTokenizerLexState = - { PosBits: int64 - OtherBits: int64 } - with - override Equals : obj:obj -> bool - member Equals : FSharpTokenizerLexState -> bool - override GetHashCode : unit -> int - static member Initial : FSharpTokenizerLexState - end - type FSharpTokenizerColorState = - | Token = 1 - | IfDefSkip = 3 - | String = 4 - | Comment = 5 - | StringInComment = 6 - | VerbatimStringInComment = 7 - | CamlOnly = 8 - | VerbatimString = 9 - | SingleLineComment = 10 - | EndLineThenSkip = 11 - | EndLineThenToken = 12 - | TripleQuoteString = 13 - | TripleQuoteStringInComment = 14 - | InitialState = 0 - module internal LexerStateEncoding = begin - val computeNextLexState : - token:Parser.token -> - prevLexcont:ParseHelpers.LexerContinuation -> - ParseHelpers.LexerContinuation - val revertToDefaultLexCont : ParseHelpers.LexerContinuation - val lexstateNumBits : int - val ncommentsNumBits : int - val hardwhiteNumBits : int - val ifdefstackCountNumBits : int - val ifdefstackNumBits : int - val stringKindBits : int - val nestingBits : int - val lexstateStart : int - val ncommentsStart : int - val hardwhitePosStart : int - val ifdefstackCountStart : int - val ifdefstackStart : int - val stringKindStart : int - val nestingStart : int - val lexstateMask : int64 - val ncommentsMask : int64 - val hardwhitePosMask : int64 - val ifdefstackCountMask : int64 - val ifdefstackMask : int64 - val stringKindMask : int64 - val nestingMask : int64 - val bitOfBool : b:bool -> int - val boolOfBit : n:int64 -> bool - val colorStateOfLexState : - state:FSharpTokenizerLexState -> FSharpTokenizerColorState - val lexStateOfColorState : state:FSharpTokenizerColorState -> int64 - val encodeStringStyle : kind:ParseHelpers.LexerStringStyle -> int - val decodeStringStyle : kind:int -> ParseHelpers.LexerStringStyle - val encodeLexCont : - colorState:FSharpTokenizerColorState * numComments:int64 * b:Range.pos * - ifdefStack:seq * light:bool * - stringKind:ParseHelpers.LexerStringKind * - stringNest:(int * ParseHelpers.LexerStringStyle * 'b) list -> - FSharpTokenizerLexState - val decodeLexCont : - state:FSharpTokenizerLexState -> - FSharpTokenizerColorState * int32 * Range.pos * - (ParseHelpers.LexerIfdefStackEntry * Range.range) list * bool * - ParseHelpers.LexerStringKind * - ParseHelpers.LexerInterpolatedStringNesting - val encodeLexInt : - lightStatus:bool -> - lexcont:ParseHelpers.LexerContinuation -> FSharpTokenizerLexState - val decodeLexInt : - state:FSharpTokenizerLexState -> bool * ParseHelpers.LexerContinuation - end - type SingleLineTokenState = - | BeforeHash = 0 - | NoFurtherMatchPossible = 1 - [] - type FSharpLineTokenizer = - class - new : lexbuf:UnicodeLexing.Lexbuf * maxLength:int option * - filename:string option * lexargs:Lexhelp.LexArgs -> - FSharpLineTokenizer - static member - ColorStateOfLexState : FSharpTokenizerLexState -> - FSharpTokenizerColorState - static member - LexStateOfColorState : FSharpTokenizerColorState -> - FSharpTokenizerLexState - member - ScanToken : lexState:FSharpTokenizerLexState -> - FSharpTokenInfo option * FSharpTokenizerLexState - end - [] - type FSharpSourceTokenizer = - class - new : conditionalDefines:string list * filename:string option -> - FSharpSourceTokenizer - member - CreateBufferTokenizer : bufferFiller:(char [] * int * int -> int) -> - FSharpLineTokenizer - member CreateLineTokenizer : lineText:string -> FSharpLineTokenizer - end - module Keywords = begin - val DoesIdentifierNeedQuotation : string -> bool - val QuoteIdentifierIfNeeded : string -> string - val NormalizeIdentifierBackticks : string -> string - val KeywordsWithDescription : (string * string) list - end - module Lexer = begin - [] - type FSharpLexerFlags = - | Default = 69649 - | LightSyntaxOn = 1 - | Compiling = 16 - | CompilingFSharpCore = 272 - | SkipTrivia = 4096 - | UseLexFilter = 65536 - [] - type FSharpSyntaxTokenKind = - | None - | HashIf - | HashElse - | HashEndIf - | CommentTrivia - | WhitespaceTrivia - | HashLine - | HashLight - | InactiveCode - | LineCommentTrivia - | StringText - | Fixed - | OffsideInterfaceMember - | OffsideBlockEnd - | OffsideRightBlockEnd - | OffsideDeclEnd - | OffsideEnd - | OffsideBlockSep - | OffsideBlockBegin - | OffsideReset - | OffsideFun - | OffsideFunction - | OffsideWith - | OffsideElse - | OffsideThen - | OffsideDoBang - | OffsideDo - | OffsideBinder - | OffsideLet - | HighPrecedenceTypeApp - | HighPrecedenceParenthesisApp - | HighPrecedenceBracketApp - | Extern - | Void - | Public - | Private - | Internal - | Global - | Static - | Member - | Class - | Abstract - | Override - | Default - | Constructor - | Inherit - | GreaterRightBracket - | Struct - | Sig - | Bar - | RightBracket - | RightBrace - | Minus - | Dollar - | BarRightBracket - | BarRightBrace - | Underscore - | Semicolon - | SemicolonSemicolon - | LeftArrow - | Equals - | LeftBracket - | LeftBracketBar - | LeftBraceBar - | LeftBracketLess - | LeftBrace - | QuestionMark - | QuestionMarkQuestionMark - | Dot - | Colon - | ColonColon - | ColonGreater - | ColonQuestionMark - | ColonQuestionMarkGreater - | ColonEquals - | When - | While - | With - | Hash - | Ampersand - | AmpersandAmpersand - | Quote - | LeftParenthesis - | RightParenthesis - | Star - | Comma - | RightArrow - | GreaterBarRightBracket - | LeftParenthesisStarRightParenthesis - | Open - | Or - | Rec - | Then - | To - | True - | Try - | Type - | Val - | Inline - | Interface - | Instance - | Const - | Lazy - | OffsideLazy - | Match - | MatchBang - | Mutable - | New - | Of - | Exception - | False - | For - | Fun - | Function - | If - | In - | JoinIn - | Finally - | DoBang - | And - | As - | Assert - | OffsideAssert - | Begin - | Do - | Done - | DownTo - | Else - | Elif - | End - | DotDot - | DotDotHat - | BarBar - | Upcast - | Downcast - | Null - | Reserved - | Module - | Namespace - | Delegate - | Constraint - | Base - | LeftQuote - | RightQuote - | RightQuoteDot - | PercentOperator - | Binder - | Less - | Greater - | Let - | Yield - | YieldBang - | BigNumber - | Decimal - | Char - | Ieee64 - | Ieee32 - | NativeInt - | UNativeInt - | UInt64 - | UInt32 - | UInt16 - | UInt8 - | Int64 - | Int32 - | Int32DotDot - | Int16 - | Int8 - | FunkyOperatorName - | AdjacentPrefixOperator - | PlusMinusOperator - | InfixAmpersandOperator - | InfixStarDivideModuloOperator - | PrefixOperator - | InfixBarOperator - | InfixAtHatOperator - | InfixCompareOperator - | InfixStarStarOperator - | Identifier - | KeywordString - | String - | ByteArray - | Asr - | InfixAsr - | InfixLand - | InfixLor - | InfixLsl - | InfixLsr - | InfixLxor - | InfixMod - [] - type FSharpSyntaxToken = - struct - new : tok:Parser.token * tokRange:Range.range -> FSharpSyntaxToken - val private tok: Parser.token - val private tokRange: Range.range - member IsCommentTrivia : bool - member IsIdentifier : bool - member IsKeyword : bool - member IsNumericLiteral : bool - member IsStringLiteral : bool - member Kind : FSharpSyntaxTokenKind - member Range : Range.range - end - val lexWithErrorLogger : - text:Text.ISourceText -> - conditionalCompilationDefines:string list -> - flags:FSharpLexerFlags -> - supportsFeature:(Features.LanguageFeature -> bool) -> - errorLogger:ErrorLogger.ErrorLogger -> - onToken:(Parser.token -> Range.range -> unit) -> - pathMap:Internal.Utilities.PathMap -> - ct:System.Threading.CancellationToken -> unit - val lex : - text:Text.ISourceText -> - conditionalCompilationDefines:string list -> - flags:FSharpLexerFlags -> - supportsFeature:(Features.LanguageFeature -> bool) -> - lexCallback:(Parser.token -> Range.range -> unit) -> - pathMap:Internal.Utilities.PathMap -> - ct:System.Threading.CancellationToken -> unit - [] - type FSharpLexer = - class - [] - static member - Lex : text:Text.ISourceText * - tokenCallback:(FSharpSyntaxToken -> unit) * ?langVersion:string * - ?filePath:string * ?conditionalCompilationDefines:string list * - ?flags:FSharpLexerFlags * ?pathMap:Map * - ?ct:System.Threading.CancellationToken -> unit - end - end - -namespace FSharp.Compiler.SourceCodeServices - module AstTraversal = begin - val rangeContainsPosLeftEdgeInclusive : - m1:Range.range -> p:Range.pos -> bool - val rangeContainsPosEdgesExclusive : m1:Range.range -> p:Range.pos -> bool - val rangeContainsPosLeftEdgeExclusiveAndRightEdgeInclusive : - m1:Range.range -> p:Range.pos -> bool - [] - type TraverseStep = - | Expr of SyntaxTree.SynExpr - | Module of SyntaxTree.SynModuleDecl - | ModuleOrNamespace of SyntaxTree.SynModuleOrNamespace - | TypeDefn of SyntaxTree.SynTypeDefn - | MemberDefn of SyntaxTree.SynMemberDefn - | MatchClause of SyntaxTree.SynMatchClause - | Binding of SyntaxTree.SynBinding - type TraversePath = TraverseStep list - [] - type AstVisitorBase<'T> = - class - new : unit -> AstVisitorBase<'T> - override - VisitBinding : defaultTraverse:(SyntaxTree.SynBinding -> 'T option) * - binding:SyntaxTree.SynBinding -> 'T option - abstract member - VisitBinding : (SyntaxTree.SynBinding -> 'T option) * - SyntaxTree.SynBinding -> 'T option - override VisitComponentInfo : SyntaxTree.SynComponentInfo -> 'T option - abstract member - VisitComponentInfo : SyntaxTree.SynComponentInfo -> 'T option - abstract member - VisitExpr : TraversePath * (SyntaxTree.SynExpr -> 'T option) * - (SyntaxTree.SynExpr -> 'T option) * SyntaxTree.SynExpr -> - 'T option - override VisitHashDirective : Range.range -> 'T option - abstract member VisitHashDirective : Range.range -> 'T option - override - VisitImplicitInherit : defaultTraverse:(SyntaxTree.SynExpr -> - 'T option) * - _ty:SyntaxTree.SynType * - expr:SyntaxTree.SynExpr * _m:Range.range -> - 'T option - abstract member - VisitImplicitInherit : (SyntaxTree.SynExpr -> 'T option) * - SyntaxTree.SynType * SyntaxTree.SynExpr * - Range.range -> 'T option - override - VisitInheritSynMemberDefn : _componentInfo:SyntaxTree.SynComponentInfo * - _typeDefnKind:SyntaxTree.SynTypeDefnKind * - _synType:SyntaxTree.SynType * - _members:SyntaxTree.SynMemberDefns * - _range:Range.range -> 'T option - abstract member - VisitInheritSynMemberDefn : SyntaxTree.SynComponentInfo * - SyntaxTree.SynTypeDefnKind * - SyntaxTree.SynType * - SyntaxTree.SynMemberDefns * Range.range -> - 'T option - override - VisitInterfaceSynMemberDefnType : _synType:SyntaxTree.SynType -> - 'T option - abstract member - VisitInterfaceSynMemberDefnType : SyntaxTree.SynType -> 'T option - override - VisitLetOrUse : TraversePath * (SyntaxTree.SynBinding -> 'T option) * - SyntaxTree.SynBinding list * Range.range -> 'T option - abstract member - VisitLetOrUse : TraversePath * (SyntaxTree.SynBinding -> 'T option) * - SyntaxTree.SynBinding list * Range.range -> 'T option - override - VisitMatchClause : defaultTraverse:(SyntaxTree.SynMatchClause -> - 'T option) * - mc:SyntaxTree.SynMatchClause -> 'T option - abstract member - VisitMatchClause : (SyntaxTree.SynMatchClause -> 'T option) * - SyntaxTree.SynMatchClause -> 'T option - override - VisitModuleDecl : defaultTraverse:(SyntaxTree.SynModuleDecl -> - 'T option) * - decl:SyntaxTree.SynModuleDecl -> 'T option - abstract member - VisitModuleDecl : (SyntaxTree.SynModuleDecl -> 'T option) * - SyntaxTree.SynModuleDecl -> 'T option - override - VisitModuleOrNamespace : SyntaxTree.SynModuleOrNamespace -> 'T option - abstract member - VisitModuleOrNamespace : SyntaxTree.SynModuleOrNamespace -> 'T option - override - VisitPat : defaultTraverse:(SyntaxTree.SynPat -> 'T option) * - pat:SyntaxTree.SynPat -> 'T option - abstract member - VisitPat : (SyntaxTree.SynPat -> 'T option) * SyntaxTree.SynPat -> - 'T option - override - VisitRecordField : _path:TraversePath * - _copyOpt:SyntaxTree.SynExpr option * - _recordField:SyntaxTree.LongIdentWithDots option -> - 'T option - abstract member - VisitRecordField : TraversePath * SyntaxTree.SynExpr option * - SyntaxTree.LongIdentWithDots option -> 'T option - override VisitSimplePats : SyntaxTree.SynSimplePat list -> 'T option - abstract member - VisitSimplePats : SyntaxTree.SynSimplePat list -> 'T option - override - VisitType : defaultTraverse:(SyntaxTree.SynType -> 'T option) * - ty:SyntaxTree.SynType -> 'T option - abstract member - VisitType : (SyntaxTree.SynType -> 'T option) * SyntaxTree.SynType -> - 'T option - override - VisitTypeAbbrev : _ty:SyntaxTree.SynType * _m:Range.range -> 'T option - abstract member - VisitTypeAbbrev : SyntaxTree.SynType * Range.range -> 'T option - end - val dive : node:'a -> range:'b -> project:('a -> 'c) -> 'b * (unit -> 'c) - val pick : - pos:Range.pos -> - outerRange:Range.range -> - _debugObj:obj -> - diveResults:(Range.range * (unit -> 'a option)) list -> 'a option - val Traverse : - pos:Range.pos * parseTree:SyntaxTree.ParsedInput * - visitor:AstVisitorBase<'T> -> 'T option - end - -namespace FSharp.Compiler.SourceCodeServices - type FSharpNavigationDeclarationItemKind = - | NamespaceDecl - | ModuleFileDecl - | ExnDecl - | ModuleDecl - | TypeDecl - | MethodDecl - | PropertyDecl - | FieldDecl - | OtherDecl - [] - type FSharpEnclosingEntityKind = - | Namespace - | Module - | Class - | Exception - | Interface - | Record - | Enum - | DU - [] - type FSharpNavigationDeclarationItem = - class - new : uniqueName:string * name:string * - kind:FSharpNavigationDeclarationItemKind * glyph:FSharpGlyph * - range:Range.range * bodyRange:Range.range * singleTopLevel:bool * - enclosingEntityKind:FSharpEnclosingEntityKind * isAbstract:bool * - access:SyntaxTree.SynAccess option -> - FSharpNavigationDeclarationItem - static member - Create : name:string * kind:FSharpNavigationDeclarationItemKind * - glyph:FSharpGlyph * range:Range.range * bodyRange:Range.range * - singleTopLevel:bool * - enclosingEntityKind:FSharpEnclosingEntityKind * isAbstract:bool * - access:SyntaxTree.SynAccess option -> - FSharpNavigationDeclarationItem - member - WithUniqueName : uniqueName:string -> FSharpNavigationDeclarationItem - member Access : SyntaxTree.SynAccess option - member BodyRange : Range.range - member EnclosingEntityKind : FSharpEnclosingEntityKind - member Glyph : FSharpGlyph - member IsAbstract : bool - member IsSingleTopLevel : bool - member Kind : FSharpNavigationDeclarationItemKind - member Name : string - member Range : Range.range - member UniqueName : string - member bodyRange : Range.range - end - [] - type FSharpNavigationTopLevelDeclaration = - { Declaration: FSharpNavigationDeclarationItem - Nested: FSharpNavigationDeclarationItem [] } - [] - type FSharpNavigationItems = - class - new : declarations:FSharpNavigationTopLevelDeclaration [] -> - FSharpNavigationItems - member Declarations : FSharpNavigationTopLevelDeclaration [] - end - module NavigationImpl = begin - val unionRangesChecked : r1:Range.range -> r2:Range.range -> Range.range - val rangeOfDecls2 : - f:('a -> FSharpNavigationDeclarationItem) -> decls:'a list -> Range.range - val rangeOfDecls : - ((FSharpNavigationDeclarationItem * int) list -> Range.range) - val moduleRange : - idm:Range.range -> - others:(FSharpNavigationDeclarationItem * 'a * 'b) list -> Range.range - val fldspecRange : fldspec:SyntaxTree.SynUnionCaseType -> Range.range - val bodyRange : - mb:Range.range -> - decls:(FSharpNavigationDeclarationItem * int) list -> Range.range - val getNavigationFromImplFile : - modules:SyntaxTree.SynModuleOrNamespace list -> FSharpNavigationItems - val getNavigationFromSigFile : - modules:SyntaxTree.SynModuleOrNamespaceSig list -> FSharpNavigationItems - end - module FSharpNavigation = begin - val getNavigation : SyntaxTree.ParsedInput -> FSharpNavigationItems - val empty : FSharpNavigationItems - end - module NavigateTo = begin - [] - type NavigableItemKind = - | Module - | ModuleAbbreviation - | Exception - | Type - | ModuleValue - | Field - | Property - | Constructor - | Member - | EnumCase - | UnionCase - with - override ToString : unit -> string - end - [] - type ContainerType = - | File - | Namespace - | Module - | Type - | Exception - type Container = - { Type: ContainerType - Name: string } - type NavigableItem = - { Name: string - Range: Range.range - IsSignature: bool - Kind: NavigableItemKind - Container: Container } - val getNavigableItems : SyntaxTree.ParsedInput -> NavigableItem [] - end - -namespace FSharp.Compiler.SourceCodeServices - [] - type FSharpNoteworthyParamInfoLocations = - class - new : longId:string list * longIdRange:Range.range * - openParenLocation:Range.pos * tupleEndLocations:Range.pos list * - isThereACloseParen:bool * namedParamNames:string option list -> - FSharpNoteworthyParamInfoLocations - static member - Find : Range.pos * SyntaxTree.ParsedInput -> - FSharpNoteworthyParamInfoLocations option - member IsThereACloseParen : bool - member LongId : string list - member LongIdEndLocation : Range.pos - member LongIdStartLocation : Range.pos - member NamedParamNames : string option [] - member OpenParenLocation : Range.pos - member TupleEndLocations : Range.pos [] - end - module internal NoteworthyParamInfoLocationsImpl = begin - val isStaticArg : SyntaxTree.SynType -> bool - val digOutIdentFromFuncExpr : - synExpr:SyntaxTree.SynExpr -> (string list * Range.range) option - type FindResult = - | Found of - openParen: Range.pos * - commasAndCloseParen: (Range.pos * string option) list * - hasClosedParen: bool - | NotFound - val digOutIdentFromStaticArg : SyntaxTree.SynType -> string option - val getNamedParamName : e:SyntaxTree.SynExpr -> string option - val getTypeName : synType:SyntaxTree.SynType -> string list - val handleSingleArg : - traverseSynExpr:(SyntaxTree.SynExpr -> 'a option) -> - pos:Range.pos * synExpr:SyntaxTree.SynExpr * parenRange:Range.range * - rpRangeOpt:'b option -> FindResult * 'c option - val searchSynArgExpr : - traverseSynExpr:(SyntaxTree.SynExpr -> 'a option) -> - pos:Range.pos -> - expr:SyntaxTree.SynExpr -> FindResult * 'a option option - val ( |StaticParameters|_| ) : - pos:Range.pos -> - SyntaxTree.SynType -> FSharpNoteworthyParamInfoLocations option - val traverseInput : - pos:Range.pos * parseTree:SyntaxTree.ParsedInput -> - FSharpNoteworthyParamInfoLocations option - end - module internal SynExprAppLocationsImpl = begin - val private searchSynArgExpr : - traverseSynExpr:(SyntaxTree.SynExpr -> 'a option) -> - expr:SyntaxTree.SynExpr -> - ranges:Range.range list -> Range.range list option * 'a option option - val getAllCurriedArgsAtPosition : - pos:Range.pos -> - parseTree:SyntaxTree.ParsedInput -> Range.range list option - end - -namespace FSharp.Compiler.SourceCodeServices - module SourceFile = begin - val private compilableExtensions : string list - val private singleFileProjectExtensions : string list - val IsCompilable : string -> bool - val MustBeSingleFileProject : string -> bool - end - module SourceFileImpl = begin - val IsInterfaceFile : string -> bool - val AdditionalDefinesForUseInEditor : isInteractive:bool -> string list - end - type CompletionPath = string list * string option - [] - type InheritanceOrigin = - | Class - | Interface - | Unknown - [] - type InheritanceContext = - | Class - | Interface - | Unknown - [] - type RecordContext = - | CopyOnUpdate of Range.range * CompletionPath - | Constructor of string - | New of CompletionPath - [] - type CompletionContext = - | Invalid - | Inherit of InheritanceContext * CompletionPath - | RecordField of RecordContext - | RangeOperator - | ParameterList of Range.pos * System.Collections.Generic.HashSet - | AttributeApplication - | OpenDeclaration of isOpenType: bool - | PatternType - [] - type FSharpParseFileResults = - class - new : errors:FSharpErrorInfo [] * input:SyntaxTree.ParsedInput option * - parseHadErrors:bool * dependencyFiles:string [] -> - FSharpParseFileResults - member - FindNoteworthyParamInfoLocations : pos:Range.pos -> - FSharpNoteworthyParamInfoLocations option - member - GetAllArgumentsForFunctionApplicationAtPostion : pos:Range.pos -> - Range.range list option - member GetNavigationItems : unit -> FSharpNavigationItems - member private GetNavigationItemsImpl : unit -> FSharpNavigationItems - member IsPosContainedInApplication : pos:Range.pos -> bool - member IsPositionContainedInACurriedParameter : pos:Range.pos -> bool - member - TryIdentOfPipelineContainingPosAndNumArgsApplied : pos:Range.pos -> - (SyntaxTree.Ident * - int) option - member TryRangeOfExprInYieldOrReturn : pos:Range.pos -> Range.range option - member - TryRangeOfFunctionOrMethodBeingApplied : pos:Range.pos -> - Range.range option - member - TryRangeOfParenEnclosingOpEqualsGreaterUsage : opGreaterEqualPos:Range.pos -> - (Range.range * - Range.range * - Range.range) option - member - TryRangeOfRecordExpressionContainingPos : pos:Range.pos -> - Range.range option - member - TryRangeOfRefCellDereferenceContainingPos : expressionPos:Range.pos -> - Range.range option - member ValidateBreakpointLocation : pos:Range.pos -> Range.range option - member - private ValidateBreakpointLocationImpl : pos:Range.pos -> - Range.range option - member DependencyFiles : string [] - member Errors : FSharpErrorInfo [] - member FileName : string - member ParseHadErrors : bool - member ParseTree : SyntaxTree.ParsedInput option - end - type ModuleKind = - { IsAutoOpen: bool - HasModuleSuffix: bool } - [] - type EntityKind = - | Attribute - | Type - | FunctionOrValue of isActivePattern: bool - | Module of ModuleKind - with - override ToString : unit -> string - end - module UntypedParseImpl = begin - val emptyStringSet : System.Collections.Generic.HashSet - val GetRangeOfExprLeftOfDot : - Range.pos * SyntaxTree.ParsedInput option -> Range.range option - val TryFindExpressionIslandInPosition : - Range.pos * SyntaxTree.ParsedInput option -> string option - val TryFindExpressionASTLeftOfDotLeftOfCursor : - Range.pos * SyntaxTree.ParsedInput option -> (Range.pos * bool) option - val GetEntityKind : Range.pos * SyntaxTree.ParsedInput -> EntityKind option - type internal TS = AstTraversal.TraverseStep - val insideAttributeApplicationRegex : System.Text.RegularExpressions.Regex - val TryGetCompletionContext : - Range.pos * SyntaxTree.ParsedInput * lineStr:string -> - CompletionContext option - val GetFullNameOfSmallestModuleOrNamespaceAtPoint : - SyntaxTree.ParsedInput * Range.pos -> string [] - end - -namespace FSharp.Compiler.SourceCodeServices - type ShortIdent = string - type Idents = ShortIdent [] - type MaybeUnresolvedIdent = - { Ident: ShortIdent - Resolved: bool } - type MaybeUnresolvedIdents = MaybeUnresolvedIdent [] - type IsAutoOpen = bool - module Extensions = begin - type FSharpEntity with - member TryGetFullName : unit -> string option - type FSharpEntity with - member TryGetFullDisplayName : unit -> string option - type FSharpEntity with - member TryGetFullCompiledName : unit -> string option - type FSharpEntity with - member PublicNestedEntities : seq - type FSharpEntity with - member - TryGetMembersFunctionsAndValues : System.Collections.Generic.IList - type FSharpMemberOrFunctionOrValue with - member FullTypeSafe : FSharpType option - type FSharpMemberOrFunctionOrValue with - member TryGetFullDisplayName : unit -> string option - type FSharpMemberOrFunctionOrValue with - member TryGetFullCompiledOperatorNameIdents : unit -> Idents option - type FSharpAssemblySignature with - member TryGetEntities : unit -> seq - end - [] - type LookupType = - | Fuzzy - | Precise - [] - type AssemblySymbol = - { FullName: string - CleanedIdents: Idents - Namespace: Idents option - NearestRequireQualifiedAccessParent: Idents option - TopRequireQualifiedAccessParent: Idents option - AutoOpenParent: Idents option - Symbol: FSharpSymbol - Kind: LookupType -> EntityKind - UnresolvedSymbol: UnresolvedSymbol } - with - override ToString : unit -> string - end - type AssemblyPath = string - type AssemblyContentType = - | Public - | Full - type Parent = - { Namespace: Idents option - ThisRequiresQualifiedAccess: bool -> Idents option - TopRequiresQualifiedAccess: bool -> Idents option - AutoOpen: Idents option - WithModuleSuffix: Idents option - IsModule: bool } - with - static member - RewriteParentIdents : parentIdents:Idents option -> - idents:Idents -> Idents - member FixParentModuleSuffix : idents:Idents -> Idents - member - FormatEntityFullName : entity:FSharpEntity -> - (string * ShortIdent []) option - static member Empty : Parent - end - type AssemblyContentCacheEntry = - { FileWriteTime: System.DateTime - ContentType: AssemblyContentType - Symbols: AssemblySymbol list } - [] - type IAssemblyContentCache = - interface - abstract member Set : AssemblyPath -> AssemblyContentCacheEntry -> unit - abstract member TryGet : AssemblyPath -> AssemblyContentCacheEntry option - end - module AssemblyContentProvider = begin - val unresolvedSymbol : - topRequireQualifiedAccessParent:Idents option -> - cleanedIdents:Idents -> fullName:string -> UnresolvedSymbol - val createEntity : - ns:Idents option -> - parent:Parent -> entity:FSharpEntity -> AssemblySymbol option - val traverseMemberFunctionAndValues : - ns:Idents option -> - parent:Parent -> - membersFunctionsAndValues:seq -> - seq - val traverseEntity : - contentType:AssemblyContentType -> - parent:Parent -> entity:FSharpEntity -> seq - val getAssemblySignatureContent : - AssemblyContentType -> FSharpAssemblySignature -> AssemblySymbol list - val getAssemblySignaturesContent : - contentType:AssemblyContentType -> - assemblies:FSharpAssembly list -> AssemblySymbol list - val getAssemblyContent : - withCache:((IAssemblyContentCache -> AssemblySymbol list) -> - AssemblySymbol list) -> - contentType:AssemblyContentType -> - fileName:string option -> - assemblies:FSharpAssembly list -> AssemblySymbol list - end - type EntityCache = - class - interface IAssemblyContentCache - new : unit -> EntityCache - member Clear : unit -> unit - member Locking : (IAssemblyContentCache -> 'T) -> 'T - end - type StringLongIdent = string - type Entity = - { FullRelativeName: StringLongIdent - Qualifier: StringLongIdent - Namespace: StringLongIdent option - Name: StringLongIdent - LastIdent: string } - with - override ToString : unit -> string - end - module Entity = begin - val getRelativeNamespace : targetNs:Idents -> sourceNs:Idents -> Idents - val cutAutoOpenModules : - autoOpenParent:Idents option -> candidateNs:Idents -> ShortIdent [] - val tryCreate : - targetNamespace:Idents option * targetScope:Idents * - partiallyQualifiedName:MaybeUnresolvedIdents * - requiresQualifiedAccessParent:Idents option * autoOpenParent:Idents option * - candidateNamespace:Idents option * candidate:Idents -> Entity [] - end - type ScopeKind = - | Namespace - | TopModule - | NestedModule - | OpenDeclaration - | HashDirective - with - override ToString : unit -> string - end - type InsertContext = - { ScopeKind: ScopeKind - Pos: Range.pos } - type Module = - { Idents: Idents - Range: Range.range } - type OpenStatementInsertionPoint = - | TopLevel - | Nearest - module ParsedInput = begin - val ( |Sequentials|_| ) : - _arg1:SyntaxTree.SynExpr -> SyntaxTree.SynExpr list option - val ( |ConstructorPats| ) : - _arg1:SyntaxTree.SynArgPats -> SyntaxTree.SynPat list - val getLongIdents : - input:SyntaxTree.ParsedInput option -> - System.Collections.Generic.IDictionary - val getLongIdentAt : - ast:SyntaxTree.ParsedInput -> pos:Range.pos -> SyntaxTree.LongIdent option - type Scope = - { Idents: Idents - Kind: ScopeKind } - val tryFindNearestPointAndModules : - currentLine:int -> - ast:SyntaxTree.ParsedInput -> - insertionPoint:OpenStatementInsertionPoint -> - (Scope * string [] option * Range.pos) option * Module list - val findBestPositionToInsertOpenDeclaration : - modules:Module list -> - scope:Scope -> pos:Range.pos -> entity:Idents -> InsertContext - val tryFindInsertionContext : - currentLine:int -> - ast:SyntaxTree.ParsedInput -> - MaybeUnresolvedIdents -> - insertionPoint:OpenStatementInsertionPoint -> - (Idents option * Idents option * Idents option * Idents -> - (Entity * InsertContext) []) - val adjustInsertionPoint : - getLineStr:(int -> string) -> ctx:InsertContext -> Range.pos - val findNearestPointToInsertOpenDeclaration : - currentLine:int -> - ast:SyntaxTree.ParsedInput -> - entity:Idents -> - insertionPoint:OpenStatementInsertionPoint -> InsertContext - end - -namespace FSharp.Compiler.SourceCodeServices - type XmlDocable = - | XmlDocable of line: int * indent: int * paramNames: string list - module XmlDocParsing = begin - val ( |ConstructorPats| ) : - _arg1:SyntaxTree.SynArgPats -> SyntaxTree.SynPat list - val digNamesFrom : pat:SyntaxTree.SynPat -> string list - val getXmlDocablesImpl : - sourceText:Text.ISourceText * input:SyntaxTree.ParsedInput option -> - XmlDocable list - end - module XmlDocComment = begin - val private ws : s:string * pos:int -> (string * int) option - val private str : - prefix:string -> s:string * pos:int -> (string * int) option - val private eol : s:string * pos:'a -> (string * 'a) option - val inline private ( >=> ) : - f:('a -> 'b option) -> g:('b -> 'c option) -> ('a -> 'c option) - val isBlank : string -> int option - end - module XmlDocParser = begin - val getXmlDocables : - Text.ISourceText * input:SyntaxTree.ParsedInput option -> XmlDocable list - end - -namespace FSharp.Compiler.SourceCodeServices - module private Option = begin - val ofOptionList : xs:'a option list -> 'a list option - end - [] - type ExternalType = - | Type of fullName: string * genericArgs: ExternalType list - | Array of inner: ExternalType - | Pointer of inner: ExternalType - | TypeVar of typeName: string - with - override ToString : unit -> string - end - module ExternalType = begin - val internal tryOfILType : - string array -> AbstractIL.IL.ILType -> ExternalType option - end - [] - type ParamTypeSymbol = - | Param of ExternalType - | Byref of ExternalType - with - override ToString : unit -> string - end - module ParamTypeSymbol = begin - val internal tryOfILType : - string array -> AbstractIL.IL.ILType -> ParamTypeSymbol option - val internal tryOfILTypes : - string array -> AbstractIL.IL.ILType list -> ParamTypeSymbol list option - end - [] - type ExternalSymbol = - | Type of fullName: string - | Constructor of typeName: string * args: ParamTypeSymbol list - | Method of - typeName: string * name: string * paramSyms: ParamTypeSymbol list * - genericArity: int - | Field of typeName: string * name: string - | Event of typeName: string * name: string - | Property of typeName: string * name: string - with - member internal ToDebuggerDisplay : unit -> string - override ToString : unit -> string - end - -namespace FSharp.Compiler - type PartialLongName = - { QualifyingIdents: string list - PartialIdent: string - EndColumn: int - LastDotPos: int option } - with - static member Empty : endColumn:int -> PartialLongName - end - module QuickParse = begin - val MagicalAdjustmentConstant : int - val CorrectIdentifierToken : tokenText:string -> tokenTag:int -> int - val isValidStrippedName : name:System.ReadOnlySpan -> idx:int -> bool - val private isValidActivePatternName : name:string -> bool - val GetCompleteIdentifierIslandImpl : - lineStr:string -> index:int -> (string * int * bool) option - val GetCompleteIdentifierIsland : - tolerateJustAfter:bool -> - tokenText:string -> index:int -> (string * int * bool) option - val private defaultName : 'a list * string - val GetPartialLongName : lineStr:string * index:int -> string list * string - type private EatCommentCallContext = - | SkipWhiteSpaces of - ident: string * current: string list * throwAwayNext: bool - | StartIdentifier of current: string list * throwAway: bool - val GetPartialLongNameEx : lineStr:string * index:int -> PartialLongName - val TokenNameEquals : - tokenInfo:SourceCodeServices.FSharpTokenInfo -> token2:string -> bool - val private expected : string [] list - val TestMemberOrOverrideDeclaration : - tokens:SourceCodeServices.FSharpTokenInfo [] -> bool - end - -namespace FSharp.Compiler.SourceCodeServices - module internal FSharpCheckerResultsSettings = begin - val getToolTipTextSize : int - val maxTypeCheckErrorsOutOfProjectContext : int - val maxTimeShareMilliseconds : int64 - val defaultFSharpBinariesDir : string - end - [] - type FSharpFindDeclFailureReason = - | Unknown of message: string - | NoSourceCode - | ProvidedType of string - | ProvidedMember of string - [] - type FSharpFindDeclResult = - | DeclNotFound of FSharpFindDeclFailureReason - | DeclFound of Range.range - | ExternalDecl of assembly: string * externalSym: ExternalSymbol - [] - type internal NameResResult = - | Members of - (NameResolution.ItemWithInst list * TypedTreeOps.DisplayEnv * Range.range) - | Cancel of TypedTreeOps.DisplayEnv * Range.range - | Empty - [] - type ResolveOverloads = - | Yes - | No - [] - type GetPreciseCompletionListFromExprTypingsResult = - | NoneBecauseTypecheckIsStaleAndTextChanged - | NoneBecauseThereWereTypeErrors - | None - | Some of - (NameResolution.ItemWithInst list * TypedTreeOps.DisplayEnv * Range.range) * - TypedTree.TType - type Names = string list - [] - type internal TypeCheckInfo = - class - new : _sTcConfig:CompilerConfig.TcConfig * g:TcGlobals.TcGlobals * - ccuSigForFile:TypedTree.ModuleOrNamespaceType * - thisCcu:TypedTree.CcuThunk * tcImports:CompilerImports.TcImports * - tcAccessRights:AccessibilityLogic.AccessorDomain * - projectFileName:string * mainInputFileName:string * - sResolutions:NameResolution.TcResolutions * - sSymbolUses:NameResolution.TcSymbolUses * - sFallback:NameResolution.NameResolutionEnv * - loadClosure:ScriptClosure.LoadClosure option * - implFileOpt:TypedTree.TypedImplFile option * - openDeclarations:NameResolution.OpenDeclaration [] -> TypeCheckInfo - member - GetBestDisplayEnvForPos : cursorPos:Range.pos -> - (NameResolution.NameResolutionEnv * - AccessibilityLogic.AccessorDomain) * - Range.range - member - GetDeclarationListSymbols : parseResultsOpt:FSharpParseFileResults option * - line:int * lineStr:string * - partialName:PartialLongName * - getAllEntities:(unit -> AssemblySymbol list) -> - FSharpSymbolUse list list - member - GetDeclarationLocation : line:int * lineStr:string * colAtEndOfNames:int * - names:string list * preferFlag:bool option -> - FSharpFindDeclResult - member - GetDeclarations : parseResultsOpt:FSharpParseFileResults option * - line:int * lineStr:string * - partialName:PartialLongName * - getAllEntities:(unit -> AssemblySymbol list) -> - FSharpDeclarationListInfo - member - GetF1Keyword : line:int * lineStr:string * colAtEndOfNames:int * - names:string list -> string option - member - GetFormatSpecifierLocationsAndArity : unit -> (Range.range * int) [] - member - GetMethods : line:int * lineStr:string * colAtEndOfNames:int * - namesOpt:string list option -> FSharpMethodGroup - member - GetMethodsAsSymbols : line:int * lineStr:string * colAtEndOfNames:int * - names:string list -> - (FSharpSymbol list * TypedTreeOps.DisplayEnv * - Range.range) option - member - GetReferenceResolutionStructuredToolTipText : line:int * col:int -> - FSharpToolTipText - member GetReferencedAssemblies : unit -> FSharpAssembly list - member - GetSemanticClassification : range:Range.range option -> - struct - (Range.range * - SemanticClassificationType) [] - member - GetStructuredToolTipText : line:int * lineStr:string * - colAtEndOfNames:int * names:string list -> - FSharpToolTipText - member - GetSymbolUseAtLocation : line:int * lineStr:string * colAtEndOfNames:int * - names:string list -> - (FSharpSymbol * TypedTreeOps.DisplayEnv * - Range.range) option - member - GetVisibleNamespacesAndModulesAtPosition : cursorPos:Range.pos -> - TypedTree.ModuleOrNamespaceRef list - member - IsRelativeNameResolvable : cursorPos:Range.pos * plid:string list * - item:NameResolution.Item -> bool - member - IsRelativeNameResolvableFromSymbol : cursorPos:Range.pos * - plid:string list * - symbol:FSharpSymbol -> bool - override ToString : unit -> string - member AccessRights : AccessibilityLogic.AccessorDomain - member CcuSigForFile : TypedTree.ModuleOrNamespaceType - member ImplementationFile : TypedTree.TypedImplFile option - member OpenDeclarations : NameResolution.OpenDeclaration [] - member PartialAssemblySignatureForFile : FSharpAssemblySignature - member ScopeResolutions : NameResolution.TcResolutions - member ScopeSymbolUses : NameResolution.TcSymbolUses - member SymbolEnv : SymbolEnv - member TcGlobals : TcGlobals.TcGlobals - member TcImports : CompilerImports.TcImports - member ThisCcu : TypedTree.CcuThunk - end - type FSharpParsingOptions = - { SourceFiles: string [] - ConditionalCompilationDefines: string list - ErrorSeverityOptions: ErrorLogger.FSharpErrorSeverityOptions - IsInteractive: bool - LightSyntax: bool option - CompilingFsLib: bool - IsExe: bool } - with - static member - FromTcConfig : tcConfig:CompilerConfig.TcConfig * sourceFiles:string [] * - isInteractive:bool -> FSharpParsingOptions - static member - FromTcConfigBuilder : tcConfigB:CompilerConfig.TcConfigBuilder * - sourceFiles:string [] * isInteractive:bool -> - FSharpParsingOptions - member LastFileName : string - static member Default : FSharpParsingOptions - end - module internal ParseAndCheckFile = begin - type ErrorHandler = - class - new : reportErrors:bool * mainInputFileName:string * - errorSeverityOptions:ErrorLogger.FSharpErrorSeverityOptions * - sourceText:Text.ISourceText * suggestNamesForErrors:bool -> - ErrorHandler - member AnyErrors : bool - member CollectedDiagnostics : FSharpErrorInfo [] - member ErrorCount : int - member ErrorLogger : ErrorLogger.ErrorLogger - member - ErrorSeverityOptions : ErrorLogger.FSharpErrorSeverityOptions with set - end - val getLightSyntaxStatus : - fileName:string -> - options:FSharpParsingOptions -> Lexhelp.LightSyntaxStatus - val createLexerFunction : - fileName:string -> - options:FSharpParsingOptions -> - lexbuf:Internal.Utilities.Text.Lexing.LexBuffer -> - errHandler:ErrorHandler -> ('a -> Parser.token) - val isFeatureSupported : _featureId:Features.LanguageFeature -> bool - val createLexbuf : sourceText:Text.ISourceText -> UnicodeLexing.Lexbuf - val matchBraces : - sourceText:Text.ISourceText * fileName:string * - options:FSharpParsingOptions * userOpName:string * - suggestNamesForErrors:bool -> (Range.range * Range.range) [] - val parseFile : - sourceText:Text.ISourceText * fileName:string * - options:FSharpParsingOptions * userOpName:string * - suggestNamesForErrors:bool -> - FSharpErrorInfo [] * SyntaxTree.ParsedInput option * bool - val ApplyLoadClosure : - tcConfig:CompilerConfig.TcConfig * parsedMainInput:SyntaxTree.ParsedInput * - mainInputFileName:string * loadClosure:ScriptClosure.LoadClosure option * - tcImports:CompilerImports.TcImports * - backgroundDiagnostics:(ErrorLogger.PhasedDiagnostic * FSharpErrorSeverity) [] -> - unit - val CheckOneFile : - parseResults:FSharpParseFileResults * sourceText:Text.ISourceText * - mainInputFileName:string * projectFileName:string * - tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * - tcImports:CompilerImports.TcImports * tcState:ParseAndCheckInputs.TcState * - moduleNamesDict:ParseAndCheckInputs.ModuleNamesDict * - loadClosure:ScriptClosure.LoadClosure option * - backgroundDiagnostics:(ErrorLogger.PhasedDiagnostic * FSharpErrorSeverity) [] * - reactorOps:IReactorOperations * userOpName:string * - suggestNamesForErrors:bool -> - Async> - end - [] - type FSharpProjectContext = - class - new : thisCcu:TypedTree.CcuThunk * assemblies:FSharpAssembly list * - ad:AccessibilityLogic.AccessorDomain -> FSharpProjectContext - member GetReferencedAssemblies : unit -> FSharpAssembly list - member AccessibilityRights : FSharpAccessibilityRights - end - [] - type FSharpCheckFileResults = - class - new : filename:string * errors:FSharpErrorInfo [] * - scopeOptX:TypeCheckInfo option * dependencyFiles:string [] * - builderX:IncrementalBuilder option * keepAssemblyContents:bool -> - FSharpCheckFileResults - static member - CheckOneFile : parseResults:FSharpParseFileResults * - sourceText:Text.ISourceText * mainInputFileName:string * - projectFileName:string * tcConfig:CompilerConfig.TcConfig * - tcGlobals:TcGlobals.TcGlobals * - tcImports:CompilerImports.TcImports * - tcState:ParseAndCheckInputs.TcState * - moduleNamesDict:ParseAndCheckInputs.ModuleNamesDict * - loadClosure:ScriptClosure.LoadClosure option * - backgroundDiagnostics:(ErrorLogger.PhasedDiagnostic * - FSharpErrorSeverity) [] * - reactorOps:IReactorOperations * userOpName:string * - isIncompleteTypeCheckEnvironment:bool * - builder:IncrementalBuilder * dependencyFiles:string [] * - creationErrors:FSharpErrorInfo [] * - parseErrors:FSharpErrorInfo [] * - keepAssemblyContents:bool * suggestNamesForErrors:bool -> - Async - static member - JoinErrors : isIncompleteTypeCheckEnvironment:bool * - creationErrors:FSharpErrorInfo [] * - parseErrors:FSharpErrorInfo [] * - tcErrors:FSharpErrorInfo [] -> FSharpErrorInfo [] - static member - Make : mainInputFileName:string * projectFileName:string * - tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * - isIncompleteTypeCheckEnvironment:bool * - builder:IncrementalBuilder * dependencyFiles:string [] * - creationErrors:FSharpErrorInfo [] * - parseErrors:FSharpErrorInfo [] * tcErrors:FSharpErrorInfo [] * - keepAssemblyContents:bool * - ccuSigForFile:TypedTree.ModuleOrNamespaceType * - thisCcu:TypedTree.CcuThunk * tcImports:CompilerImports.TcImports * - tcAccessRights:AccessibilityLogic.AccessorDomain * - sResolutions:NameResolution.TcResolutions * - sSymbolUses:NameResolution.TcSymbolUses * - sFallback:NameResolution.NameResolutionEnv * - loadClosure:ScriptClosure.LoadClosure option * - implFileOpt:TypedTree.TypedImplFile option * - openDeclarations:NameResolution.OpenDeclaration [] -> - FSharpCheckFileResults - static member - MakeEmpty : filename:string * creationErrors:FSharpErrorInfo [] * - keepAssemblyContents:bool -> FSharpCheckFileResults - member - GetAllUsesOfAllSymbolsInFile : ?cancellationToken:System.Threading.CancellationToken -> - seq - member - GetDeclarationListInfo : parsedFileResults:FSharpParseFileResults option * - line:int * lineText:string * - partialName:PartialLongName * - ?getAllEntities:(unit -> AssemblySymbol list) -> - FSharpDeclarationListInfo - member - GetDeclarationListSymbols : parsedFileResults:FSharpParseFileResults option * - line:int * lineText:string * - partialName:PartialLongName * - ?getAllEntities:(unit -> AssemblySymbol list) -> - FSharpSymbolUse list list - member - GetDeclarationLocation : line:int * colAtEndOfNames:int * - lineText:string * names:string list * - ?preferFlag:bool -> FSharpFindDeclResult - member - GetDisplayContextForPos : cursorPos:Range.pos -> - FSharpDisplayContext option - member - GetF1Keyword : line:int * colAtEndOfNames:int * lineText:string * - names:string list -> string option - [] - member GetFormatSpecifierLocations : unit -> Range.range [] - member - GetFormatSpecifierLocationsAndArity : unit -> (Range.range * int) [] - member - GetMethods : line:int * colAtEndOfNames:int * lineText:string * - names:string list option -> FSharpMethodGroup - member - GetMethodsAsSymbols : line:int * colAtEndOfNames:int * lineText:string * - names:string list -> FSharpSymbolUse list option - member - GetSemanticClassification : Range.range option -> - struct - (Range.range * - SemanticClassificationType) [] - member - GetStructuredToolTipText : line:int * colAtEndOfNames:int * - lineText:string * names:string list * - tokenTag:int -> FSharpToolTipText - member - GetSymbolAtLocation : line:int * colAtEndOfNames:int * lineStr:string * - names:string list -> FSharpSymbol option - member - GetSymbolUseAtLocation : line:int * colAtEndOfNames:int * - lineText:string * names:string list -> - FSharpSymbolUse option - member - GetToolTipText : line:int * colAtEndOfNames:int * lineText:string * - names:string list * tokenTag:int -> FSharpToolTipText - member - GetUsesOfSymbolInFile : symbol:FSharpSymbol * - ?cancellationToken:System.Threading.CancellationToken -> - FSharpSymbolUse [] - member - GetVisibleNamespacesAndModulesAtPoint : Range.pos -> - TypedTree.ModuleOrNamespaceRef [] - member - IsRelativeNameResolvable : cursorPos:Range.pos * plid:string list * - item:NameResolution.Item -> bool - member - IsRelativeNameResolvableFromSymbol : cursorPos:Range.pos * - plid:string list * - symbol:FSharpSymbol -> bool - override ToString : unit -> string - member TryGetCurrentTcImports : unit -> CompilerImports.TcImports option - member DependencyFiles : string [] - member Errors : FSharpErrorInfo [] - member HasFullTypeCheckInfo : bool - member ImplementationFile : FSharpImplementationFileContents option - member OpenDeclarations : FSharpOpenDeclaration [] - member PartialAssemblySignature : FSharpAssemblySignature - member ProjectContext : FSharpProjectContext - end - [] - and FSharpCheckFileAnswer = - | Aborted - | Succeeded of FSharpCheckFileResults - [] - type FSharpCheckProjectResults = - class - new : projectFileName:string * - tcConfigOption:CompilerConfig.TcConfig option * - keepAssemblyContents:bool * errors:FSharpErrorInfo [] * - details:(TcGlobals.TcGlobals * CompilerImports.TcImports * - TypedTree.CcuThunk * TypedTree.ModuleOrNamespaceType * - NameResolution.TcSymbolUses list * - CheckDeclarations.TopAttribs option * - CompilerConfig.IRawFSharpAssemblyData option * - AbstractIL.IL.ILAssemblyRef * - AccessibilityLogic.AccessorDomain * - TypedTree.TypedImplFile list option * string []) option -> - FSharpCheckProjectResults - member - GetAllUsesOfAllSymbols : ?cancellationToken:System.Threading.CancellationToken -> - FSharpSymbolUse [] - member GetOptimizedAssemblyContents : unit -> FSharpAssemblyContents - member - GetUsesOfSymbol : symbol:FSharpSymbol * - ?cancellationToken:System.Threading.CancellationToken -> - FSharpSymbolUse [] - override ToString : unit -> string - member AssemblyContents : FSharpAssemblyContents - member AssemblyFullName : string - member AssemblySignature : FSharpAssemblySignature - member DependencyFiles : string [] - member Errors : FSharpErrorInfo [] - member HasCriticalErrors : bool - member ProjectContext : FSharpProjectContext - member - RawFSharpAssemblyData : CompilerConfig.IRawFSharpAssemblyData option - member - TypedImplementationFiles : TcGlobals.TcGlobals * TypedTree.CcuThunk * - CompilerImports.TcImports * - TypedTree.TypedImplFile list - end - type FsiInteractiveChecker = - class - new : ReferenceResolver.Resolver * ops:IReactorOperations * - tcConfig:CompilerConfig.TcConfig * tcGlobals:TcGlobals.TcGlobals * - tcImports:CompilerImports.TcImports * - tcState:ParseAndCheckInputs.TcState -> FsiInteractiveChecker - member - ParseAndCheckInteraction : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - sourceText:Text.ISourceText * - ?userOpName:string -> - Async - end - -namespace FSharp.Compiler.SourceCodeServices - type internal Layout = Internal.Utilities.StructuredFormat.Layout - module EnvMisc = begin - val braceMatchCacheSize : int - val parseFileCacheSize : int - val checkFileInProjectCacheSize : int - val projectCacheSizeDefault : int - val frameworkTcImportsCacheStrongSize : int - val maxMBDefault : int - end - type UnresolvedReferencesSet = - | UnresolvedReferencesSet of CompilerConfig.UnresolvedAssemblyReference list - type FSharpProjectOptions = - { ProjectFileName: string - ProjectId: string option - SourceFiles: string [] - OtherOptions: string [] - ReferencedProjects: (string * FSharpProjectOptions) [] - IsIncompleteTypeCheckEnvironment: bool - UseScriptResolutionRules: bool - LoadTime: System.DateTime - UnresolvedReferences: UnresolvedReferencesSet option - OriginalLoadReferences: (Range.range * string * string) list - ExtraProjectInfo: obj option - Stamp: int64 option } - with - static member - AreSameForChecking : options1:FSharpProjectOptions * - options2:FSharpProjectOptions -> bool - static member - UseSameProject : options1:FSharpProjectOptions * - options2:FSharpProjectOptions -> bool - override ToString : unit -> string - member ProjectDirectory : string - member ProjectOptions : string [] - end - [] - type IsResultObsolete = | IsResultObsolete of (unit -> bool) - module Helpers = begin - val AreSameForChecking2 : - (string * FSharpProjectOptions) * (string * FSharpProjectOptions) -> bool - val AreSubsumable2 : - (string * FSharpProjectOptions) * (string * FSharpProjectOptions) -> bool - val AreSameForParsing : - (string * int * 'a) * (string * int * 'a) -> bool when 'a : equality - val AreSimilarForParsing : - ('a * 'b * 'c) * ('a * 'd * 'e) -> bool when 'a : equality - val AreSameForChecking3 : - (string * int * FSharpProjectOptions) * - (string * int * FSharpProjectOptions) -> bool - val AreSubsumable3 : - (string * 'a * FSharpProjectOptions) * - (string * 'b * FSharpProjectOptions) -> bool - end - module CompileHelpers = begin - val mkCompilationErrorHandlers : - unit -> - ResizeArray * ErrorLogger.ErrorLogger * - Driver.ErrorLoggerProvider - val tryCompile : - errorLogger:ErrorLogger.ErrorLogger -> - f:(ErrorLogger.Exiter -> unit) -> int - val compileFromArgs : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * argv:string [] * - legacyReferenceResolver:ReferenceResolver.Resolver * - tcImportsCapture:(CompilerImports.TcImports -> unit) option * - dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * - AbstractIL.IL.ILModuleDef -> unit) option -> - FSharpErrorInfo [] * int - val compileFromAsts : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - legacyReferenceResolver:ReferenceResolver.Resolver * - asts:SyntaxTree.ParsedInput list * assemblyName:string * outFile:string * - dependencies:string list * noframework:bool * pdbFile:string option * - executable:bool option * - tcImportsCapture:(CompilerImports.TcImports -> unit) option * - dynamicAssemblyCreator:(TcGlobals.TcGlobals * string * - AbstractIL.IL.ILModuleDef -> unit) option -> - FSharpErrorInfo [] * int - val createDynamicAssembly : - ctok:AbstractIL.Internal.Library.CompilationThreadToken * debugInfo:bool * - tcImportsRef:CompilerImports.TcImports option ref * execute:bool * - assemblyBuilderRef:System.Reflection.Emit.AssemblyBuilder option ref -> - tcGlobals:TcGlobals.TcGlobals * outfile:string * - ilxMainModule:AbstractIL.IL.ILModuleDef -> unit - val setOutputStreams : - execute:(#System.IO.TextWriter * #System.IO.TextWriter) option -> unit - end - type SourceTextHash = int - type FileName = string - type FilePath = string - type ProjectPath = string - type FileVersion = int - type ParseCacheLockToken = - class - interface AbstractIL.Internal.Library.LockToken - new : unit -> ParseCacheLockToken - end - type ScriptClosureCacheToken = - class - interface AbstractIL.Internal.Library.LockToken - new : unit -> ScriptClosureCacheToken - end - type BackgroundCompiler = - class - new : legacyReferenceResolver:ReferenceResolver.Resolver * - projectCacheSize:int * keepAssemblyContents:bool * - keepAllBackgroundResolutions:bool * - tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * - suggestNamesForErrors:bool * keepAllBackgroundSymbolUses:bool * - enableBackgroundItemKeyStoreAndSemanticClassification:bool * - enablePartialTypeChecking:bool -> BackgroundCompiler - member - CheckFileInProject : parseResults:FSharpParseFileResults * - filename:string * fileVersion:int * - sourceText:Text.ISourceText * - options:FSharpProjectOptions * userOpName:string -> - Async - member - CheckFileInProjectAllowingStaleCachedResults : parseResults:FSharpParseFileResults * - filename:string * - fileVersion:int * - sourceText:Text.ISourceText * - options:FSharpProjectOptions * - userOpName:string -> - Async - member - private CheckOneFileImpl : parseResults:FSharpParseFileResults * - sourceText:Text.ISourceText * fileName:string * - options:FSharpProjectOptions * - fileVersion:int * builder:IncrementalBuilder * - tcConfig:CompilerConfig.TcConfig * - tcGlobals:TcGlobals.TcGlobals * - tcImports:CompilerImports.TcImports * - tcDependencyFiles:string list * - timeStamp:System.DateTime * - prevTcState:ParseAndCheckInputs.TcState * - prevModuleNamesDict:ParseAndCheckInputs.ModuleNamesDict * - prevTcErrors:(ErrorLogger.PhasedDiagnostic * - FSharpErrorSeverity) [] * - creationErrors:FSharpErrorInfo [] * - userOpName:string -> - Async - member - CheckProjectInBackground : options:FSharpProjectOptions * - userOpName:string -> unit - member - ClearCache : options:seq * userOpName:string -> - unit - member ClearCachesAsync : userOpName:string -> Async - member CompleteAllQueuedOps : unit -> unit - member DownsizeCaches : userOpName:string -> Async - member - FindReferencesInFile : filename:string * options:FSharpProjectOptions * - symbol:FSharpSymbol * canInvalidateProject:bool * - userOpName:string -> Async> - member - GetAssemblyData : options:FSharpProjectOptions * - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - userOpName:string -> - AbstractIL.Internal.Library.Cancellable - member - GetBackgroundCheckResultsForFileInProject : filename:string * - options:FSharpProjectOptions * - userOpName:string -> - Async - member - GetBackgroundParseResultsForFileInProject : filename:string * - options:FSharpProjectOptions * - userOpName:string -> - Async - member - GetCachedCheckFileResult : builder:IncrementalBuilder * - filename:FileName * - sourceText:Text.ISourceText * - options:FSharpProjectOptions -> - (FSharpParseFileResults * - FSharpCheckFileResults) option - member - GetProjectOptionsFromScript : filename:string * - sourceText:Text.ISourceText * - previewEnabled:bool option * - loadedTimeStamp:System.DateTime option * - otherFlags:string [] option * - useFsiAuxLib:bool option * - useSdkRefs:bool option * - assumeDotNetFramework:bool option * - extraProjectInfo:obj option * - optionsStamp:int64 option * - userOpName:string -> - Async - member - GetSemanticClassificationForFile : filename:string * - options:FSharpProjectOptions * - userOpName:string -> - Async - member - ImplicitlyStartCheckProjectInBackground : options:FSharpProjectOptions * - userOpName:string -> unit - member - InvalidateConfiguration : options:FSharpProjectOptions * - startBackgroundCompileIfAlreadySeen:bool option * - userOpName:string -> unit - member - NotifyProjectCleaned : options:FSharpProjectOptions * userOpName:string -> - Async - member - ParseAndCheckFileInProject : filename:string * fileVersion:int * - sourceText:Text.ISourceText * - options:FSharpProjectOptions * - userOpName:string -> - Async - member - ParseAndCheckProject : options:FSharpProjectOptions * userOpName:string -> - Async - member - private ParseAndCheckProjectImpl : options:FSharpProjectOptions * - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - userOpName:string -> - AbstractIL.Internal.Library.Cancellable - member - ParseFile : filename:string * sourceText:Text.ISourceText * - options:FSharpParsingOptions * userOpName:string -> - Async - member - ParseFileNoCache : filename:string * sourceText:Text.ISourceText * - options:FSharpParsingOptions * userOpName:string -> - Async - member - RecordTypeCheckFileInProjectResults : filename:string * - options:FSharpProjectOptions * - parsingOptions:FSharpParsingOptions * - parseResults:FSharpParseFileResults * - fileVersion:int * - priorTimeStamp:System.DateTime * - checkAnswer:FSharpCheckFileAnswer option * - sourceText:SourceTextHash -> unit - member StopBackgroundCompile : unit -> unit - member - private TryGetLogicalTimeStampForProject : cache:CompilerConfig.TimeStampCache * - ctok:AbstractIL.Internal.Library.CompilationThreadToken * - options:FSharpProjectOptions * - userOpName:string -> - System.DateTime option - member - TryGetRecentCheckResultsForFile : filename:string * - options:FSharpProjectOptions * - sourceText:Text.ISourceText option * - _userOpName:string -> - (FSharpParseFileResults * - FSharpCheckFileResults * - FileVersion) option - member WaitForBackgroundCompile : unit -> unit - member BeforeBackgroundFileCheck : IEvent - member CurrentQueueLength : int - member FileChecked : IEvent - member FileParsed : IEvent - member FrameworkImportsCache : FrameworkImportsCache - member ImplicitlyStartBackgroundWork : bool - member ProjectChecked : IEvent - member Reactor : Reactor - member ReactorOps : IReactorOperations - static member GlobalForegroundParseCountStatistic : int - static member GlobalForegroundTypeCheckCountStatistic : int - end - [] - type FSharpChecker = - class - new : legacyReferenceResolver:ReferenceResolver.Resolver * - projectCacheSize:int * keepAssemblyContents:bool * - keepAllBackgroundResolutions:bool * - tryGetMetadataSnapshot:AbstractIL.ILBinaryReader.ILReaderTryGetMetadataSnapshot * - suggestNamesForErrors:bool * keepAllBackgroundSymbolUses:bool * - enableBackgroundItemKeyStoreAndSemanticClassification:bool * - enablePartialTypeChecking:bool -> FSharpChecker - static member - Create : ?projectCacheSize:int * ?keepAssemblyContents:bool * - ?keepAllBackgroundResolutions:bool * - ?legacyReferenceResolver:ReferenceResolver.Resolver * - ?tryGetMetadataSnapshot:(string * System.DateTime -> - AbstractIL.ILBinaryReader.ILReaderMetadataSnapshot option) * - ?suggestNamesForErrors:bool * ?keepAllBackgroundSymbolUses:bool * - ?enableBackgroundItemKeyStoreAndSemanticClassification:bool * - ?enablePartialTypeChecking:bool -> FSharpChecker - member - CheckFileInProject : parseResults:FSharpParseFileResults * - filename:string * fileVersion:int * - sourceText:Text.ISourceText * - options:FSharpProjectOptions * ?userOpName:string -> - Async - [] - member - CheckFileInProjectAllowingStaleCachedResults : parseResults:FSharpParseFileResults * - filename:string * - fileVersion:int * - source:string * - options:FSharpProjectOptions * - ?userOpName:string -> - Async - member CheckMaxMemoryReached : unit -> unit - member - CheckProjectInBackground : options:FSharpProjectOptions * - ?userOpName:string -> unit - member - ClearCache : options:seq * ?userOpName:string -> - unit - member ClearCaches : ?userOpName:string -> unit - member ClearCachesAsync : ?userOpName:string -> Async - member - ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients : unit -> - unit - member - Compile : argv:string [] * ?userOpName:string -> - Async - member - Compile : ast:SyntaxTree.ParsedInput list * assemblyName:string * - outFile:string * dependencies:string list * ?pdbFile:string * - ?executable:bool * ?noframework:bool * ?userOpName:string -> - Async - member - CompileToDynamicAssembly : otherFlags:string [] * - execute:(System.IO.TextWriter * - System.IO.TextWriter) option * - ?userOpName:string -> - Async - member - CompileToDynamicAssembly : ast:SyntaxTree.ParsedInput list * - assemblyName:string * - dependencies:string list * - execute:(System.IO.TextWriter * - System.IO.TextWriter) option * - ?debug:bool * ?noframework:bool * - ?userOpName:string -> - Async - member - FindBackgroundReferencesInFile : filename:string * - options:FSharpProjectOptions * - symbol:FSharpSymbol * - ?canInvalidateProject:bool * - ?userOpName:string -> - Async> - member - GetBackgroundCheckResultsForFileInProject : filename:string * - options:FSharpProjectOptions * - ?userOpName:string -> - Async - member - GetBackgroundParseResultsForFileInProject : filename:string * - options:FSharpProjectOptions * - ?userOpName:string -> - Async - member - GetBackgroundSemanticClassificationForFile : filename:string * - options:FSharpProjectOptions * - ?userOpName:string -> - Async - member - GetParsingOptionsFromCommandLineArgs : argv:string list * - ?isInteractive:bool -> - FSharpParsingOptions * - FSharpErrorInfo list - member - GetParsingOptionsFromCommandLineArgs : sourceFiles:string list * - argv:string list * - ?isInteractive:bool -> - FSharpParsingOptions * - FSharpErrorInfo list - member - GetParsingOptionsFromProjectOptions : options:FSharpProjectOptions -> - FSharpParsingOptions * - FSharpErrorInfo list - member - GetProjectOptionsFromCommandLineArgs : projectFileName:string * - argv:string [] * - ?loadedTimeStamp:System.DateTime * - ?extraProjectInfo:obj -> - FSharpProjectOptions - member - GetProjectOptionsFromScript : filename:string * source:Text.ISourceText * - ?previewEnabled:bool * - ?loadedTimeStamp:System.DateTime * - ?otherFlags:string [] * ?useFsiAuxLib:bool * - ?useSdkRefs:bool * - ?assumeDotNetFramework:bool * - ?extraProjectInfo:obj * - ?optionsStamp:int64 * ?userOpName:string -> - Async - member InvalidateAll : unit -> unit - member - InvalidateConfiguration : options:FSharpProjectOptions * - ?startBackgroundCompile:bool * - ?userOpName:string -> unit - [] - member - MatchBraces : filename:string * source:string * - options:FSharpProjectOptions * ?userOpName:string -> - Async<(Range.range * Range.range) []> - member - MatchBraces : filename:string * sourceText:Text.ISourceText * - options:FSharpParsingOptions * ?userOpName:string -> - Async<(Range.range * Range.range) []> - member - NotifyProjectCleaned : options:FSharpProjectOptions * ?userOpName:string -> - Async - member - ParseAndCheckFileInProject : filename:string * fileVersion:int * - sourceText:Text.ISourceText * - options:FSharpProjectOptions * - ?userOpName:string -> - Async - member - ParseAndCheckProject : options:FSharpProjectOptions * ?userOpName:string -> - Async - member - ParseFile : filename:string * sourceText:Text.ISourceText * - options:FSharpParsingOptions * ?userOpName:string -> - Async - [] - member - ParseFileInProject : filename:string * source:string * - options:FSharpProjectOptions * ?userOpName:string -> - Async - member - ParseFileNoCache : filename:string * sourceText:Text.ISourceText * - options:FSharpParsingOptions * ?userOpName:string -> - Async - member - StartBackgroundCompile : options:FSharpProjectOptions * - ?userOpName:string -> unit - member StopBackgroundCompile : unit -> unit - member TokenizeFile : source:string -> FSharpTokenInfo [] [] - member - TokenizeLine : line:string * state:FSharpTokenizerLexState -> - FSharpTokenInfo [] * FSharpTokenizerLexState - member - TryGetRecentCheckResultsForFile : filename:string * - options:FSharpProjectOptions * - ?sourceText:Text.ISourceText * - ?userOpName:string -> - (FSharpParseFileResults * - FSharpCheckFileResults * - FileVersion) option - member WaitForBackgroundCompile : unit -> unit - member BeforeBackgroundFileCheck : IEvent - member CurrentQueueLength : int - member FileChecked : IEvent - member FileParsed : IEvent - member internal FrameworkImportsCache : FrameworkImportsCache - member ImplicitlyStartBackgroundWork : bool - member MaxMemory : int - member MaxMemoryReached : IEvent - member PauseBeforeBackgroundWork : int - member ProjectChecked : IEvent - member ReactorOps : IReactorOperations - member ReferenceResolver : ReferenceResolver.Resolver - static member GlobalForegroundParseCountStatistic : int - static member GlobalForegroundTypeCheckCountStatistic : int - [] - static member Instance : FSharpChecker - end - [] - type CompilerEnvironment = - class - static member - BinFolderOfDefaultFSharpCompiler : ?probePoint:string -> string option - end - module CompilerEnvironment = begin - val DefaultReferencesForOrphanSources : - assumeDotNetFramework:bool -> string list - val GetCompilationDefinesForEditing : - parsingOptions:FSharpParsingOptions -> string list - val IsCheckerSupportedSubcategory : string -> bool - end - module DebuggerEnvironment = begin - val GetLanguageID : unit -> System.Guid - end - module PrettyNaming = begin - val IsIdentifierPartCharacter : char -> bool - val IsLongIdentifierPartCharacter : char -> bool - val IsOperatorName : string -> bool - val GetLongNameFromString : string -> string list - val FormatAndOtherOverloadsString : System.Int32 -> string - val QuoteIdentifierIfNeeded : string -> string - val KeywordNames : string list - end - module FSharpFileUtilities = begin - val isScriptFile : string -> bool - end - -namespace FSharp.Compiler.SourceCodeServices - module ErrorResolutionHints = begin - val getSuggestedNames : - suggestionsF:ErrorLogger.Suggestions -> - unresolvedIdentifier:string -> seq - end - - - -namespace FSharp.Compiler.SourceCodeServices - module Structure = begin - module Range = begin - val endToEnd : r1:Range.range -> r2:Range.range -> Range.range - val endToStart : r1:Range.range -> r2:Range.range -> Range.range - val startToEnd : r1:Range.range -> r2:Range.range -> Range.range - val startToStart : r1:Range.range -> r2:Range.range -> Range.range - val modStart : m:int -> r:Range.range -> Range.range - val modEnd : m:int -> r:Range.range -> Range.range - val modBoth : modStart:int -> modEnd:int -> r:Range.range -> Range.range - end - val longIdentRange : longId:SyntaxTree.LongIdent -> Range.range - val rangeOfTypeArgsElse : - other:Range.range -> typeArgs:SyntaxTree.SynTyparDecl list -> Range.range - val rangeOfSynPatsElse : - other:Range.range -> synPats:SyntaxTree.SynSimplePat list -> Range.range - [] - type Collapse = - | Below - | Same - [] - type Scope = - | Open - | Namespace - | Module - | Type - | Member - | LetOrUse - | Val - | CompExpr - | IfThenElse - | ThenInIfThenElse - | ElseInIfThenElse - | TryWith - | TryInTryWith - | WithInTryWith - | TryFinally - | TryInTryFinally - | FinallyInTryFinally - | ArrayOrList - | ObjExpr - | For - | While - | Match - | MatchBang - | MatchLambda - | MatchClause - | Lambda - | CompExprInternal - | Quote - | Record - | SpecialFunc - | Do - | New - | Attribute - | Interface - | HashDirective - | LetOrUseBang - | TypeExtension - | YieldOrReturn - | YieldOrReturnBang - | Tuple - | UnionCase - | EnumCase - | RecordField - | RecordDefn - | UnionDefn - | Comment - | XmlDocComment - with - override ToString : unit -> string - end - [] - type ScopeRange = - { Scope: Scope - Collapse: Collapse - Range: Range.range - CollapseRange: Range.range } - type LineNumber = int - type LineStr = string - type CommentType = - | SingleLine - | XmlDoc - [] - type CommentList = - { Lines: ResizeArray - Type: CommentType } - with - static member - New : ty:CommentType -> lineStr:(LineNumber * LineStr) -> CommentList - end - val getOutliningRanges : - sourceLines:string [] -> - parsedInput:SyntaxTree.ParsedInput -> seq - end - -namespace FSharp.Compiler.SourceCodeServices - module UnusedOpens = begin - val symbolHash : System.Collections.Generic.IEqualityComparer - type OpenedModule = - class - new : entity:FSharpEntity * isNestedAutoOpen:bool -> OpenedModule - member RevealedSymbolsContains : symbol:FSharpSymbol -> bool - member Entity : FSharpEntity - member IsNestedAutoOpen : bool - end - type OpenedModuleGroup = - { OpenedModules: OpenedModule [] } - with - static member Create : modul:FSharpEntity -> OpenedModuleGroup - end - type OpenStatement = - { OpenedGroups: OpenedModuleGroup list - Range: Range.range - AppliedScope: Range.range } - val getOpenStatements : - openDeclarations:FSharpOpenDeclaration [] -> OpenStatement [] - val filterSymbolUses : - getSourceLineStr:(int -> string) -> - symbolUses:seq -> FSharpSymbolUse [] - val splitSymbolUses : - symbolUses:FSharpSymbolUse [] -> FSharpSymbolUse [] * FSharpSymbolUse [] - val isOpenStatementUsed : - symbolUses2:FSharpSymbolUse [] -> - symbolUsesRangesByDeclaringEntity:System.Collections.Generic.Dictionary -> - usedModules:System.Collections.Generic.Dictionary -> - openStatement:OpenStatement -> bool - val filterOpenStatementsIncremental : - symbolUses2:FSharpSymbolUse [] -> - symbolUsesRangesByDeclaringEntity:System.Collections.Generic.Dictionary -> - openStatements:OpenStatement list -> - usedModules:System.Collections.Generic.Dictionary -> - acc:OpenStatement list -> Async - val entityHash : System.Collections.Generic.IEqualityComparer - val filterOpenStatements : - symbolUses1:FSharpSymbolUse [] * symbolUses2:FSharpSymbolUse [] -> - openStatements:OpenStatement [] -> Async - val getUnusedOpens : - checkFileResults:FSharpCheckFileResults * getSourceLineStr:(int -> string) -> - Async - end - module SimplifyNames = begin - type SimplifiableRange = - { Range: Range.range - RelativeName: string } - val getPlidLength : plid:string list -> int - val getSimplifiableNames : - checkFileResults:FSharpCheckFileResults * getSourceLineStr:(int -> string) -> - Async> - end - module UnusedDeclarations = begin - val isPotentiallyUnusedDeclaration : symbol:FSharpSymbol -> bool - val getUnusedDeclarationRanges : - symbolsUses:seq -> isScript:bool -> seq - val getUnusedDeclarations : - checkFileResults:FSharpCheckFileResults * isScriptFile:bool -> - Async> - end - -namespace FSharp.Compiler.Interactive - module Shell = begin - [] - type FsiValue = - class - new : reflectionValue:obj * reflectionType:System.Type * - fsharpType:SourceCodeServices.FSharpType -> FsiValue - member FSharpType : SourceCodeServices.FSharpType - member ReflectionType : System.Type - member ReflectionValue : obj - end - [] - type FsiBoundValue = - class - new : name:string * value:FsiValue -> FsiBoundValue - member Name : string - member Value : FsiValue - end - module internal Utilities = begin - type IAnyToLayoutCall = - interface - abstract member - AnyToLayout : Internal.Utilities.StructuredFormat.FormatOptions * - obj * System.Type -> - Internal.Utilities.StructuredFormat.Layout - abstract member - FsiAnyToLayout : Internal.Utilities.StructuredFormat.FormatOptions * - obj * System.Type -> - Internal.Utilities.StructuredFormat.Layout - end - type private AnyToLayoutSpecialization<'T> = - class - interface IAnyToLayoutCall - new : unit -> AnyToLayoutSpecialization<'T> - end - val getAnyToLayoutCall : ty:System.Type -> IAnyToLayoutCall - val callStaticMethod : - ty:System.Type -> name:string -> args:obj list -> obj - val ignoreAllErrors : f:(unit -> unit) -> unit - val getMember : - name:string -> - memberType:System.Reflection.MemberTypes -> - attr:System.Reflection.BindingFlags -> - declaringType:System.Type -> System.Reflection.MemberInfo [] - val tryFindMember : - name:string -> - memberType:System.Reflection.MemberTypes -> - declaringType:System.Type -> System.Reflection.MemberInfo option - val getInstanceProperty : obj:obj -> nm:string -> 'a - val setInstanceProperty : obj:obj -> nm:string -> v:obj -> 'a - val callInstanceMethod0 : - obj:obj -> typeArgs:System.Type [] -> nm:string -> 'a - val callInstanceMethod1 : - obj:obj -> typeArgs:System.Type [] -> nm:string -> v:obj -> 'a - val callInstanceMethod3 : - obj:obj -> - typeArgs:System.Type [] -> - nm:string -> v1:obj -> v2:obj -> v3:obj -> 'a - val colorPrintL : - outWriter:System.IO.TextWriter -> - opts:Internal.Utilities.StructuredFormat.FormatOptions -> - layout:Internal.Utilities.StructuredFormat.Layout -> unit - val reportError : - m:Range.range -> Microsoft.DotNet.DependencyManager.ResolvingErrorReport - val getOutputDir : tcConfigB:CompilerConfig.TcConfigBuilder -> string - end - type internal FsiTimeReporter = - class - new : outWriter:System.IO.TextWriter -> FsiTimeReporter - member TimeOp : f:(unit -> 'b) -> 'b - member TimeOpIf : flag:bool -> f:(unit -> 'a) -> 'a - end - type internal FsiValuePrinterMode = - | PrintExpr - | PrintDecl - [] - type EvaluationEventArgs = - class - inherit System.EventArgs - new : fsivalue:FsiValue option * - symbolUse:SourceCodeServices.FSharpSymbolUse * - decl:SourceCodeServices.FSharpImplementationFileDeclaration -> - EvaluationEventArgs - member FsiValue : FsiValue option - member - ImplementationDeclaration : SourceCodeServices.FSharpImplementationFileDeclaration - member Name : string - member Symbol : SourceCodeServices.FSharpSymbol - member SymbolUse : SourceCodeServices.FSharpSymbolUse - end - [] - type FsiEvaluationSessionHostConfig = - class - new : unit -> FsiEvaluationSessionHostConfig - abstract member EventLoopInvoke : codeToRun:(unit -> 'T) -> 'T - abstract member EventLoopRun : unit -> bool - abstract member EventLoopScheduleRestart : unit -> unit - abstract member - GetOptionalConsoleReadLine : probeToSeeIfConsoleWorks:bool -> - (unit -> string) option - abstract member ReportUserCommandLineArgs : string [] -> unit - abstract member StartServer : fsiServerName:string -> unit - member - internal TriggerEvaluation : value:FsiValue option * - symbolUse:SourceCodeServices.FSharpSymbolUse * - decl:SourceCodeServices.FSharpImplementationFileDeclaration -> - unit - abstract member - AddedPrinters : Choice<(System.Type * (obj -> string)), - (System.Type * (obj -> obj))> list - abstract member FloatingPointFormat : string - abstract member FormatProvider : System.IFormatProvider - member OnEvaluation : IEvent - abstract member PrintDepth : int - abstract member PrintLength : int - abstract member PrintSize : int - abstract member PrintWidth : int - abstract member ShowDeclarationValues : bool - abstract member ShowIEnumerable : bool - abstract member ShowProperties : bool - abstract member UseFsiAuxLib : bool - end - type internal FsiValuePrinter = - class - new : fsi:FsiEvaluationSessionHostConfig * g:TcGlobals.TcGlobals * - generateDebugInfo:bool * - resolveAssemblyRef:(AbstractIL.IL.ILAssemblyRef -> - Choice option) * - outWriter:System.IO.TextWriter -> FsiValuePrinter - member FormatValue : obj:obj * objTy:System.Type -> string - member - GetEvaluationContext : emEnv:AbstractIL.ILRuntimeWriter.emEnv -> - IlxGen.ExecutionContext - member - GetFsiPrintOptions : unit -> - Internal.Utilities.StructuredFormat.FormatOptions - member - InvokeDeclLayout : emEnv:AbstractIL.ILRuntimeWriter.emEnv * - ilxGenerator:IlxGen.IlxAssemblyGenerator * - v:TypedTree.Val -> - Internal.Utilities.StructuredFormat.Layout option - member - InvokeExprPrinter : denv:TypedTreeOps.DisplayEnv * - emEnv:AbstractIL.ILRuntimeWriter.emEnv * - ilxGenerator:IlxGen.IlxAssemblyGenerator * - vref:TypedTree.Val -> unit - member - PrintValue : printMode:FsiValuePrinterMode * - opts:Internal.Utilities.StructuredFormat.FormatOptions * - x:obj * ty:System.Type -> - Internal.Utilities.StructuredFormat.Layout - end - type internal FsiStdinSyphon = - class - new : errorWriter:System.IO.TextWriter -> FsiStdinSyphon - member Add : str:string -> unit - member GetLine : filename:string -> i:int -> string - member - PrintError : tcConfig:CompilerConfig.TcConfigBuilder * - err:ErrorLogger.PhasedDiagnostic -> unit - member Reset : unit -> unit - end - type internal FsiConsoleOutput = - class - new : tcConfigB:CompilerConfig.TcConfigBuilder * - outWriter:System.IO.TextWriter * errorWriter:System.IO.TextWriter -> - FsiConsoleOutput - member uprintf : fmt:Printf.TextWriterFormat<'f> -> 'f - member uprintfn : fmt:Printf.TextWriterFormat<'e> -> 'e - member uprintfnn : fmt:Printf.TextWriterFormat<'d,unit> -> 'd - member uprintnf : fmt:Printf.TextWriterFormat<'c> -> 'c - member uprintnfn : fmt:Printf.TextWriterFormat<'b> -> 'b - member uprintnfnn : fmt:Printf.TextWriterFormat<'a,unit> -> 'a - member Error : System.IO.TextWriter - member Out : System.IO.TextWriter - end - type internal ErrorLoggerThatStopsOnFirstError = - class - inherit ErrorLogger.ErrorLogger - new : tcConfigB:CompilerConfig.TcConfigBuilder * - fsiStdinSyphon:FsiStdinSyphon * fsiConsoleOutput:FsiConsoleOutput -> - ErrorLoggerThatStopsOnFirstError - override - DiagnosticSink : err:ErrorLogger.PhasedDiagnostic * isError:bool -> - unit - member ResetErrorCount : unit -> unit - member SetError : unit -> unit - override ErrorCount : int - end - type ErrorLogger with - member CheckForErrors : unit -> bool - type ErrorLogger with - member AbortOnError : fsiConsoleOutput:FsiConsoleOutput -> unit - val internal directoryName : s:string -> string - type internal FsiCommandLineOptions = - class - new : fsi:FsiEvaluationSessionHostConfig * argv:string [] * - tcConfigB:CompilerConfig.TcConfigBuilder * - fsiConsoleOutput:FsiConsoleOutput -> FsiCommandLineOptions - member ShowBanner : unit -> unit - member ShowHelp : m:Range.range -> unit - member - DependencyProvider : Microsoft.DotNet.DependencyManager.DependencyProvider - member EnableConsoleKeyProcessing : bool - member FsiLCID : int option - member FsiServerInputCodePage : int option - member FsiServerName : string - member FsiServerOutputCodePage : int option - member Gui : bool - member Interact : bool - member IsInteractiveServer : bool - member PeekAheadOnConsoleToPermitTyping : bool - member ProbeToSeeIfConsoleWorks : bool - member ShowILCode : bool - member ShowTypes : bool - member SourceFiles : (string * bool) list - end - val internal SetCurrentUICultureForThread : - lcid:int option -> System.IDisposable - val internal InstallErrorLoggingOnThisThread : - errorLogger:ErrorLogger.ErrorLogger -> unit - val internal SetServerCodePages : fsiOptions:FsiCommandLineOptions -> unit - type internal FsiConsolePrompt = - class - new : fsiOptions:FsiCommandLineOptions * - fsiConsoleOutput:FsiConsoleOutput -> FsiConsolePrompt - member Print : unit -> unit - member PrintAhead : unit -> unit - member SkipNext : unit -> unit - member FsiOptions : FsiCommandLineOptions - end - type internal FsiConsoleInput = - class - new : fsi:FsiEvaluationSessionHostConfig * - fsiOptions:FsiCommandLineOptions * inReader:System.IO.TextReader * - outWriter:System.IO.TextWriter -> FsiConsoleInput - member TryGetConsole : unit -> (unit -> string) option - member TryGetFirstLine : unit -> string option - member WaitForInitialConsoleInput : unit -> unit - member In : System.IO.TextReader - end - type internal FsiInteractionStepStatus = - | CtrlC - | EndOfFile - | Completed of FsiValue option - | CompletedWithAlreadyReportedError - | CompletedWithReportedError of exn - [] - type internal FsiDynamicCompilerState = - { optEnv: Optimizer.IncrementalOptimizationEnv - emEnv: AbstractIL.ILRuntimeWriter.emEnv - tcGlobals: TcGlobals.TcGlobals - tcState: ParseAndCheckInputs.TcState - tcImports: CompilerImports.TcImports - ilxGenerator: IlxGen.IlxAssemblyGenerator - boundValues: AbstractIL.Internal.Library.NameMap - timing: bool - debugBreak: bool } - val internal WithImplicitHome : - tcConfigB:CompilerConfig.TcConfigBuilder * dir:string -> - f:(unit -> 'a) -> 'a - val internal convertReflectionTypeToILTypeRef : - reflectionTy:System.Type -> AbstractIL.IL.ILTypeRef - val internal convertReflectionTypeToILType : - reflectionTy:System.Type -> AbstractIL.IL.ILType - val internal mkBoundValueTypedImpl : - tcGlobals:TcGlobals.TcGlobals -> - m:Range.range -> - moduleName:string -> - name:string -> - ty:TypedTree.TType -> - TypedTree.ModuleOrNamespace * TypedTree.Val * - TypedTree.TypedImplFile - type internal FsiDynamicCompiler = - class - new : fsi:FsiEvaluationSessionHostConfig * timeReporter:FsiTimeReporter * - tcConfigB:CompilerConfig.TcConfigBuilder * tcLockObject:obj * - outWriter:System.IO.TextWriter * - tcImports:CompilerImports.TcImports * - tcGlobals:TcGlobals.TcGlobals * fsiOptions:FsiCommandLineOptions * - fsiConsoleOutput:FsiConsoleOutput * fsiCollectible:bool * - niceNameGen:CompilerGlobalState.NiceNameGenerator * - resolveAssemblyRef:(AbstractIL.IL.ILAssemblyRef -> - Choice option) -> - FsiDynamicCompiler - member - AddBoundValue : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - errorLogger:ErrorLogger.ErrorLogger * - istate:FsiDynamicCompilerState * name:string * - value:obj -> - FsiDynamicCompilerState * FsiInteractionStepStatus - member - BuildItBinding : expr:SyntaxTree.SynExpr -> - SyntaxTree.SynModuleDecl list - member - CommitDependencyManagerText : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - istate:FsiDynamicCompilerState * - lexResourceManager:Lexhelp.LexResourceManager * - errorLogger:ErrorLogger.ErrorLogger -> - FsiDynamicCompilerState - member CreateDebuggerBreak : m:Range.range -> SyntaxTree.SynModuleDecl - member - CurrentPartialAssemblySignature : istate:FsiDynamicCompilerState -> - SourceCodeServices.FSharpAssemblySignature - member - EvalDependencyManagerTextFragment : packageManager:Microsoft.DotNet.DependencyManager.IDependencyManagerProvider * - lt:CompilerConfig.Directive * - m:Range.range * path:string -> - unit - member - EvalParsedDefinitions : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - errorLogger:ErrorLogger.ErrorLogger * - istate:FsiDynamicCompilerState * - showTypes:bool * isInteractiveItExpr:bool * - defs:SyntaxTree.SynModuleDecl list -> - FsiDynamicCompilerState * - FsiInteractionStepStatus - member - EvalParsedExpression : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - errorLogger:ErrorLogger.ErrorLogger * - istate:FsiDynamicCompilerState * - expr:SyntaxTree.SynExpr -> - FsiDynamicCompilerState * - FsiInteractionStepStatus - member - EvalParsedSourceFiles : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - errorLogger:ErrorLogger.ErrorLogger * - istate:FsiDynamicCompilerState * - inputs:SyntaxTree.ParsedInput list -> - FsiDynamicCompilerState - member - EvalRequireReference : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - istate:FsiDynamicCompilerState * m:Range.range * - path:string -> - CompilerImports.AssemblyResolution list * - FsiDynamicCompilerState - member - EvalSourceFiles : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - istate:FsiDynamicCompilerState * m:Range.range * - sourceFiles:string list * - lexResourceManager:Lexhelp.LexResourceManager * - errorLogger:ErrorLogger.ErrorLogger -> - FsiDynamicCompilerState - member FormatValue : obj:obj * objTy:System.Type -> string - member - GetBoundValues : istate:FsiDynamicCompilerState -> FsiBoundValue list - member GetInitialInteractiveState : unit -> FsiDynamicCompilerState - member - ProcessMetaCommandsFromInputAsInteractiveCommands : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - istate:FsiDynamicCompilerState * - sourceFile:string * - inp:SyntaxTree.ParsedInput -> - FsiDynamicCompilerState - member - TryFindBoundValue : istate:FsiDynamicCompilerState * nm:string -> - FsiBoundValue option - member DynamicAssembly : System.Reflection.Assembly - member DynamicAssemblyName : string - member ValueBound : IEvent - end - type ControlEventHandler = - delegate of int -> bool - type internal FsiInterruptStdinState = - | StdinEOFPermittedBecauseCtrlCRecentlyPressed - | StdinNormal - type internal FsiInterruptControllerState = - | InterruptCanRaiseException - | InterruptIgnored - type internal FsiInterruptControllerKillerThreadRequest = - | ThreadAbortRequest - | NoRequest - | ExitRequest - | PrintInterruptRequest - type internal FsiInterruptController = - class - new : fsiOptions:FsiCommandLineOptions * - fsiConsoleOutput:FsiConsoleOutput -> FsiInterruptController - member ClearInterruptRequest : unit -> unit - member Exit : unit -> 'a - member - InstallKillThread : threadToKill:System.Threading.Thread * - pauseMilliseconds:int -> unit - member Interrupt : unit -> unit - member PosixInvoke : n:int -> unit - member EventHandlers : ControlEventHandler list - member FsiInterruptStdinState : FsiInterruptStdinState - member InterruptAllowed : FsiInterruptControllerState with set - end - module internal MagicAssemblyResolution = begin - val private assemblyLoadFrom : path:string -> System.Reflection.Assembly - val Install : - tcConfigB:CompilerConfig.TcConfigBuilder * - tcImports:CompilerImports.TcImports * - fsiDynamicCompiler:FsiDynamicCompiler * - fsiConsoleOutput:FsiConsoleOutput -> System.IDisposable - end - type internal FsiStdinLexerProvider = - class - new : tcConfigB:CompilerConfig.TcConfigBuilder * - fsiStdinSyphon:FsiStdinSyphon * fsiConsoleInput:FsiConsoleInput * - fsiConsoleOutput:FsiConsoleOutput * - fsiOptions:FsiCommandLineOptions * - lexResourceManager:Lexhelp.LexResourceManager -> - FsiStdinLexerProvider - member - CreateBufferLexer : sourceFileName:string * - lexbuf:UnicodeLexing.Lexbuf * - errorLogger:ErrorLogger.ErrorLogger -> - LexFilter.LexFilter - member - CreateIncludedScriptLexer : sourceFileName:string * - reader:System.IO.StreamReader * - errorLogger:ErrorLogger.ErrorLogger -> - LexFilter.LexFilter - member - CreateStdinLexer : errorLogger:ErrorLogger.ErrorLogger -> - LexFilter.LexFilter - member - CreateStringLexer : sourceFileName:string * source:string * - errorLogger:ErrorLogger.ErrorLogger -> - LexFilter.LexFilter - member ConsoleInput : FsiConsoleInput - end - type internal FsiInteractionProcessor = - class - new : fsi:FsiEvaluationSessionHostConfig * - tcConfigB:CompilerConfig.TcConfigBuilder * - fsiOptions:FsiCommandLineOptions * - fsiDynamicCompiler:FsiDynamicCompiler * - fsiConsolePrompt:FsiConsolePrompt * - fsiConsoleOutput:FsiConsoleOutput * - fsiInterruptController:FsiInterruptController * - fsiStdinLexerProvider:FsiStdinLexerProvider * - lexResourceManager:Lexhelp.LexResourceManager * - initialInteractiveState:FsiDynamicCompilerState -> - FsiInteractionProcessor - member - AddBoundValue : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - errorLogger:ErrorLogger.ErrorLogger * name:string * - value:obj -> Choice - member - CompletionsForPartialLID : istate:FsiDynamicCompilerState * - prefix:string -> string list - member - EvalExpression : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - sourceText:string * scriptFileName:string * - errorLogger:ErrorLogger.ErrorLogger -> - Choice - member - EvalIncludedScript : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - istate:FsiDynamicCompilerState * - sourceFile:string * m:Range.range * - errorLogger:ErrorLogger.ErrorLogger -> - FsiDynamicCompilerState * - FsiInteractionStepStatus - member - EvalIncludedScripts : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - istate:FsiDynamicCompilerState * - sourceFiles:string list * - errorLogger:ErrorLogger.ErrorLogger -> - FsiDynamicCompilerState - member - EvalInteraction : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - sourceText:string * scriptFileName:string * - errorLogger:ErrorLogger.ErrorLogger * - ?cancellationToken:System.Threading.CancellationToken -> - Choice - member - EvalScript : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - scriptPath:string * errorLogger:ErrorLogger.ErrorLogger -> - Choice - member - LoadDummyInteraction : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - errorLogger:ErrorLogger.ErrorLogger -> unit - member - LoadInitialFiles : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - errorLogger:ErrorLogger.ErrorLogger -> unit - member - ParseAndCheckInteraction : ctok:AbstractIL.Internal.Library.CompilationThreadToken * - legacyReferenceResolver:ReferenceResolver.Resolver * - checker:SourceCodeServices.IReactorOperations * - istate:FsiDynamicCompilerState * - text:string -> - Async - member - ParseAndExecOneSetOfInteractionsFromLexbuf : runCodeOnMainThread:((#AbstractIL.Internal.Library.CompilationThreadToken -> - FsiDynamicCompilerState -> - FsiDynamicCompilerState * - FsiInteractionStepStatus) -> - FsiDynamicCompilerState -> - FsiDynamicCompilerState * - FsiInteractionStepStatus) * - istate:FsiDynamicCompilerState * - tokenizer:LexFilter.LexFilter * - errorLogger:ErrorLogger.ErrorLogger * - ?cancellationToken:System.Threading.CancellationToken -> - FsiDynamicCompilerState * - FsiInteractionStepStatus - member - StartStdinReadAndProcessThread : errorLogger:ErrorLogger.ErrorLogger -> - unit - member CurrentState : FsiDynamicCompilerState - member PartialAssemblySignatureUpdated : IEvent - end - val internal SpawnThread : name:string -> f:(unit -> unit) -> unit - val internal SpawnInteractiveServer : - fsi:FsiEvaluationSessionHostConfig * fsiOptions:FsiCommandLineOptions * - fsiConsoleOutput:FsiConsoleOutput -> unit - val internal DriveFsiEventLoop : - fsi:FsiEvaluationSessionHostConfig * fsiConsoleOutput:FsiConsoleOutput -> - unit - [] - type FsiCompilationException = - class - inherit System.Exception - new : string * SourceCodeServices.FSharpErrorInfo [] option -> - FsiCompilationException - member ErrorInfos : SourceCodeServices.FSharpErrorInfo [] option - end - [] - type FsiEvaluationSession = - class - interface System.IDisposable - new : fsi:FsiEvaluationSessionHostConfig * argv:string [] * - inReader:System.IO.TextReader * outWriter:System.IO.TextWriter * - errorWriter:System.IO.TextWriter * fsiCollectible:bool * - legacyReferenceResolver:ReferenceResolver.Resolver option -> - FsiEvaluationSession - static member - Create : fsiConfig:FsiEvaluationSessionHostConfig * argv:string [] * - inReader:System.IO.TextReader * - outWriter:System.IO.TextWriter * - errorWriter:System.IO.TextWriter * ?collectible:bool * - ?legacyReferenceResolver:ReferenceResolver.Resolver -> - FsiEvaluationSession - static member - GetDefaultConfiguration : unit -> FsiEvaluationSessionHostConfig - static member - GetDefaultConfiguration : fsiObj:obj -> FsiEvaluationSessionHostConfig - static member - GetDefaultConfiguration : fsiObj:obj * useFsiAuxLib:bool -> - FsiEvaluationSessionHostConfig - member AddBoundValue : name:string * value:obj -> unit - member EvalExpression : code:string -> FsiValue option - member - EvalExpressionNonThrowing : code:string -> - Choice * - SourceCodeServices.FSharpErrorInfo [] - member - EvalInteraction : code:string * - ?cancellationToken:System.Threading.CancellationToken -> - unit - member - EvalInteractionNonThrowing : code:string * - ?cancellationToken:System.Threading.CancellationToken -> - Choice * - SourceCodeServices.FSharpErrorInfo [] - member EvalScript : filePath:string -> unit - member - EvalScriptNonThrowing : filePath:string -> - Choice * - SourceCodeServices.FSharpErrorInfo [] - member - FormatValue : reflectionValue:obj * reflectionType:System.Type -> - string - member GetBoundValues : unit -> FsiBoundValue list - member GetCompletions : longIdent:string -> seq - member Interrupt : unit -> unit - member - ParseAndCheckInteraction : code:string -> - Async - member ReportUnhandledException : exn:exn -> unit - member Run : unit -> unit - member TryFindBoundValue : name:string -> FsiBoundValue option - member - CurrentPartialAssemblySignature : SourceCodeServices.FSharpAssemblySignature - member DynamicAssembly : System.Reflection.Assembly - member InteractiveChecker : SourceCodeServices.FSharpChecker - member IsGui : bool - member LCID : int option - member PartialAssemblySignatureUpdated : IEvent - member ValueBound : IEvent - end - module Settings = begin - type IEventLoop = - interface - abstract member Invoke : (unit -> 'T) -> 'T - abstract member Run : unit -> bool - abstract member ScheduleRestart : unit -> unit - end - type internal SimpleEventLoop = - class - interface System.IDisposable - interface IEventLoop - new : unit -> SimpleEventLoop - end - [] - type InteractiveSettings = - class - new : unit -> InteractiveSettings - member AddPrintTransformer : ('T -> obj) -> unit - member AddPrinter : ('T -> string) -> unit - member - AddedPrinters : Choice<(System.Type * (obj -> string)), - (System.Type * (obj -> obj))> list - member CommandLineArgs : string [] - member EventLoop : IEventLoop - member FloatingPointFormat : string - member FormatProvider : System.IFormatProvider - member PrintDepth : int - member PrintLength : int - member PrintSize : int - member PrintWidth : int - member ShowDeclarationValues : bool - member ShowIDictionary : bool - member ShowIEnumerable : bool - member ShowProperties : bool - end - val fsi : InteractiveSettings - end - [] - type CompilerInputStream = - class - inherit System.IO.Stream - new : unit -> CompilerInputStream - member Add : str:string -> unit - override Flush : unit -> unit - override Read : buffer:byte [] * offset:int * count:int -> int - override Seek : _offset:int64 * _origin:System.IO.SeekOrigin -> int64 - override SetLength : _value:int64 -> unit - override Write : _buffer:byte [] * _offset:int * _count:int -> unit - override CanRead : bool - override CanSeek : bool - override CanWrite : bool - override Length : int64 - override Position : int64 - end - [] - type CompilerOutputStream = - class - inherit System.IO.Stream - new : unit -> CompilerOutputStream - override Flush : unit -> unit - member Read : unit -> string - override Read : _buffer:byte [] * _offset:int * _count:int -> int - override Seek : _offset:int64 * _origin:System.IO.SeekOrigin -> int64 - override SetLength : _value:int64 -> unit - override Write : buffer:byte [] * offset:int * count:int -> unit - override CanRead : bool - override CanSeek : bool - override CanWrite : bool - override Length : int64 - override Position : int64 - end - end - From e6f06e452cde3383ee718bb3f0c876b391616dfd Mon Sep 17 00:00:00 2001 From: Don Syme Date: Fri, 11 Dec 2020 23:40:46 +0000 Subject: [PATCH 8/8] fix test --- .../SurfaceArea.netstandard.fs | 271 ++++++++++-------- 1 file changed, 145 insertions(+), 126 deletions(-) diff --git a/tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs b/tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs index 4df1e4a2ac5..332d43328ab 100644 --- a/tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs +++ b/tests/FSharp.Compiler.Service.Tests/SurfaceArea.netstandard.fs @@ -2377,6 +2377,20 @@ FSharp.Compiler.AbstractIL.IL+ILFieldInit: Int32 GetHashCode(System.Collections. FSharp.Compiler.AbstractIL.IL+ILFieldInit: Int32 Tag FSharp.Compiler.AbstractIL.IL+ILFieldInit: Int32 get_Tag() FSharp.Compiler.AbstractIL.IL+ILFieldInit: System.String ToString() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+Bool: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+Char: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+Double: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int16: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int32: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int64: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+Int8: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+Single: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+String: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt16: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt32: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt64: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit+UInt8: System.Object AsObject() +FSharp.Compiler.AbstractIL.IL+ILFieldInit: System.Object AsObject() FSharp.Compiler.AbstractIL.IL+ILFieldRef: Boolean Equals(ILFieldRef) FSharp.Compiler.AbstractIL.IL+ILFieldRef: Boolean Equals(System.Object) FSharp.Compiler.AbstractIL.IL+ILFieldRef: Boolean Equals(System.Object, System.Collections.IEqualityComparer) @@ -18048,18 +18062,18 @@ FSharp.Compiler.AbstractIL.Internal.Library+CancellableBuilder: Cancellable`1 Us FSharp.Compiler.AbstractIL.Internal.Library+CancellableBuilder: Cancellable`1 Zero() FSharp.Compiler.AbstractIL.Internal.Library+CancellableBuilder: Void .ctor() FSharp.Compiler.AbstractIL.Internal.Library+CancellableBuilder: i ReturnFrom[i](i) -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: Cancellable`1 bind[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[b]], Cancellable`1) -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: Cancellable`1 canceled[a]() -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: Cancellable`1 delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[T]]) -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: Cancellable`1 each[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[b]], System.Collections.Generic.IEnumerable`1[a]) -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: Cancellable`1 fold[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[a]]], a, System.Collections.Generic.IEnumerable`1[b]) -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: Cancellable`1 map[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,b], Cancellable`1) -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: Cancellable`1 ret[a](a) -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: Cancellable`1 token() -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: Cancellable`1 tryFinally[a](Cancellable`1, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: Cancellable`1 tryWith[a](Cancellable`1, Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[a]]) -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: ValueOrCancelled`1 run[a](System.Threading.CancellationToken, Cancellable`1) -FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule: a runWithoutCancellation[a](Cancellable`1) +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: Cancellable`1 bind[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[b]], Cancellable`1) +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: Cancellable`1 canceled[a]() +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: Cancellable`1 delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[T]]) +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: Cancellable`1 each[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[b]], System.Collections.Generic.IEnumerable`1[a]) +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: Cancellable`1 fold[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[a]]], a, System.Collections.Generic.IEnumerable`1[b]) +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: Cancellable`1 map[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,b], Cancellable`1) +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: Cancellable`1 ret[a](a) +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: Cancellable`1 token() +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: Cancellable`1 tryFinally[a](Cancellable`1, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: Cancellable`1 tryWith[a](Cancellable`1, Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[a]]) +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: ValueOrCancelled`1 run[a](System.Threading.CancellationToken, Cancellable`1) +FSharp.Compiler.AbstractIL.Internal.Library+Cancellable: a runWithoutCancellation[a](Cancellable`1) FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[TResult]: Cancellable`1 NewCancellable(Microsoft.FSharp.Core.FSharpFunc`2[System.Threading.CancellationToken,FSharp.Compiler.AbstractIL.Internal.Library+ValueOrCancelled`1[TResult]]) FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[TResult]: Int32 Tag FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[TResult]: Int32 get_Tag() @@ -18069,7 +18083,6 @@ FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[TResult]: System.Strin FSharp.Compiler.AbstractIL.Internal.Library+CompilationThreadToken: Void .ctor() FSharp.Compiler.AbstractIL.Internal.Library+Dictionary: System.Collections.Generic.Dictionary`2[a,b] newWithSize[a,b](Int32) FSharp.Compiler.AbstractIL.Internal.Library+DictionaryExtensions: Boolean BagExistsValueForKey[key,value](System.Collections.Generic.Dictionary`2[key,Microsoft.FSharp.Collections.FSharpList`1[value]], key, Microsoft.FSharp.Core.FSharpFunc`2[value,System.Boolean]) -FSharp.Compiler.AbstractIL.Internal.Library+DictionaryExtensions: Void .ctor() FSharp.Compiler.AbstractIL.Internal.Library+DictionaryExtensions: Void BagAdd[key,value](System.Collections.Generic.Dictionary`2[key,Microsoft.FSharp.Collections.FSharpList`1[value]], key, value) FSharp.Compiler.AbstractIL.Internal.Library+EventuallyBuilder: Eventually`1 Bind[g,h](Eventually`1, Microsoft.FSharp.Core.FSharpFunc`2[g,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[h]]) FSharp.Compiler.AbstractIL.Internal.Library+EventuallyBuilder: Eventually`1 Combine[d](Eventually`1, Eventually`1) @@ -18078,21 +18091,20 @@ FSharp.Compiler.AbstractIL.Internal.Library+EventuallyBuilder: Eventually`1 Retu FSharp.Compiler.AbstractIL.Internal.Library+EventuallyBuilder: Eventually`1 TryFinally[b](Eventually`1, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) FSharp.Compiler.AbstractIL.Internal.Library+EventuallyBuilder: Eventually`1 TryWith[c](Eventually`1, Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[c]]) FSharp.Compiler.AbstractIL.Internal.Library+EventuallyBuilder: Eventually`1 Zero() -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyBuilder: Void .ctor() FSharp.Compiler.AbstractIL.Internal.Library+EventuallyBuilder: e ReturnFrom[e](e) -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Eventually`1 bind[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[b]], Eventually`1) -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Eventually`1 box[a](Eventually`1) -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Eventually`1 catch[a](Eventually`1) -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Eventually`1 delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[T]]) -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Eventually`1 fold[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[a]]], a, System.Collections.Generic.IEnumerable`1[b]) -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Eventually`1 get_token() -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Eventually`1 repeatedlyProgressUntilDoneOrTimeShareOverOrCanceled[a,b](Int64, System.Threading.CancellationToken, Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.AbstractIL.Internal.Library+CompilationThreadToken,Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[a,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[b]],FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[b]]], Eventually`1) -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Eventually`1 token -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Eventually`1 tryFinally[a](Eventually`1, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Eventually`1 tryWith[a](Eventually`1, Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[a]]) -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] forceAsync[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.AbstractIL.Internal.Library+CompilationThreadToken,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[T]],Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[T]]], Eventually`1) -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: Microsoft.FSharp.Core.FSharpOption`1[a] forceWhile[a](CompilationThreadToken, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Eventually`1) -FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule: a force[a](CompilationThreadToken, Eventually`1) +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Eventually`1 bind[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[b]], Eventually`1) +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Eventually`1 box[a](Eventually`1) +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Eventually`1 catch[a](Eventually`1) +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Eventually`1 delay[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[T]]) +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Eventually`1 fold[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[a]]], a, System.Collections.Generic.IEnumerable`1[b]) +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Eventually`1 get_token() +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Eventually`1 repeatedlyProgressUntilDoneOrTimeShareOverOrCanceled[?,b](Int64, System.Threading.CancellationToken, Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.AbstractIL.Internal.Library+CompilationThreadToken,Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[?,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[b]],FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[b]]], Eventually`1) +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Eventually`1 token +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Eventually`1 tryFinally[a](Eventually`1, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit]) +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Eventually`1 tryWith[a](Eventually`1, Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[a]]) +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Microsoft.FSharp.Control.FSharpAsync`1[Microsoft.FSharp.Core.FSharpOption`1[T]] forceAsync[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.AbstractIL.Internal.Library+CompilationThreadToken,FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[T]],Microsoft.FSharp.Control.FSharpAsync`1[FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[T]]], Eventually`1) +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: Microsoft.FSharp.Core.FSharpOption`1[a] forceWhile[a](CompilationThreadToken, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,System.Boolean], Eventually`1) +FSharp.Compiler.AbstractIL.Internal.Library+Eventually: a force[a](CompilationThreadToken, Eventually`1) FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1+Done[T]: Boolean IsDone FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1+Done[T]: Boolean IsNotYetDone FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1+Done[T]: Boolean get_IsDone() @@ -18162,20 +18174,9 @@ FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: Boolean g FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: Boolean get_IsForced() FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: LazyWithContext`2 Create(Microsoft.FSharp.Core.FSharpFunc`2[ctxt,T], Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,System.Exception]) FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: LazyWithContext`2 NotLazy(T) -FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,System.Exception] findOriginalException -FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,System.Exception] get_findOriginalException() -FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: System.Object funcOrException -FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: System.Object funcOrException@ -FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: System.Object get_funcOrException() FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: System.String ToString() FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: T Force(ctxt) FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: T UnsynchronizedForce(ctxt) -FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: T get_value() -FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: T value -FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: T value@ -FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: Void .ctor(T, System.Object, Microsoft.FSharp.Core.FSharpFunc`2[System.Exception,System.Exception]) -FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: Void set_funcOrException(System.Object) -FSharp.Compiler.AbstractIL.Internal.Library+LazyWithContext`2[T,ctxt]: Void set_value(T) FSharp.Compiler.AbstractIL.Internal.Library+List: Boolean checkq[a](Microsoft.FSharp.Collections.FSharpList`1[a], Microsoft.FSharp.Collections.FSharpList`1[a]) FSharp.Compiler.AbstractIL.Internal.Library+List: Boolean existsSquared[a](Microsoft.FSharp.Core.FSharpFunc`2[a,System.Boolean], Microsoft.FSharp.Collections.FSharpList`1[Microsoft.FSharp.Collections.FSharpList`1[a]]) FSharp.Compiler.AbstractIL.Internal.Library+List: Boolean existsi[a](Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[a,System.Boolean]], Microsoft.FSharp.Collections.FSharpList`1[a]) @@ -18216,50 +18217,50 @@ FSharp.Compiler.AbstractIL.Internal.Library+Lock`1[LockTokenType]: a AcquireLock FSharp.Compiler.AbstractIL.Internal.Library+Map: Microsoft.FSharp.Collections.FSharpList`1[b] tryFindMulti[a,b](a, Microsoft.FSharp.Collections.FSharpMap`2[a,Microsoft.FSharp.Collections.FSharpList`1[b]]) FSharp.Compiler.AbstractIL.Internal.Library+MemoizationTable`2[T,U]: U Apply(T) FSharp.Compiler.AbstractIL.Internal.Library+MemoizationTable`2[T,U]: Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[T,U], System.Collections.Generic.IEqualityComparer`1[T], Microsoft.FSharp.Core.FSharpOption`1[Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean]]) -FSharp.Compiler.AbstractIL.Internal.Library+MultiMapModule: Boolean existsInRange[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[b,Microsoft.FSharp.Collections.FSharpList`1[a]]) -FSharp.Compiler.AbstractIL.Internal.Library+MultiMapModule: Microsoft.FSharp.Collections.FSharpList`1[b] find[a,b](a, Microsoft.FSharp.Collections.FSharpMap`2[a,Microsoft.FSharp.Collections.FSharpList`1[b]]) -FSharp.Compiler.AbstractIL.Internal.Library+MultiMapModule: Microsoft.FSharp.Collections.FSharpList`1[b] range[a,b](Microsoft.FSharp.Collections.FSharpMap`2[a,Microsoft.FSharp.Collections.FSharpList`1[b]]) -FSharp.Compiler.AbstractIL.Internal.Library+MultiMapModule: Microsoft.FSharp.Collections.FSharpMap`2[a,Microsoft.FSharp.Collections.FSharpList`1[b]] add[a,b](a, b, Microsoft.FSharp.Collections.FSharpMap`2[a,Microsoft.FSharp.Collections.FSharpList`1[b]]) -FSharp.Compiler.AbstractIL.Internal.Library+MultiMapModule: Microsoft.FSharp.Collections.FSharpMap`2[a,Microsoft.FSharp.Collections.FSharpList`1[b]] empty[a,b]() -FSharp.Compiler.AbstractIL.Internal.Library+MultiMapModule: Microsoft.FSharp.Collections.FSharpMap`2[b,Microsoft.FSharp.Collections.FSharpList`1[a]] initBy[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,b], System.Collections.Generic.IEnumerable`1[a]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Boolean existsInRange[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[b,a]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Boolean exists[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[a,b]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Boolean forall[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[a,b]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Boolean isEmpty[T](Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Boolean mem[T](System.String, Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Boolean suball2[a,b,c](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[c,Microsoft.FSharp.Core.FSharpFunc`2[b,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[a,c], Microsoft.FSharp.Collections.FSharpMap`2[a,b]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,T]] toList[T](Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpList`1[b] range[a,b](Microsoft.FSharp.Collections.FSharpMap`2[a,b]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,T] add[T](System.String, T, Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,T] filterRange[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,T] layer[T](Microsoft.FSharp.Collections.FSharpMap`2[System.String,T], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,T] ofList[T](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,T]]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,T] ofSeq[T](System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.String,T]]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,a] mapFilter[T,a](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[a]], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,a] map[T,a](Microsoft.FSharp.Core.FSharpFunc`2[T,a], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,b] union[a,b](Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[a],b], System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpMap`2[System.String,a]]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpMap`2[a,b] empty[a,b]() -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpMap`2[b,a] ofKeyedList[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,b], Microsoft.FSharp.Collections.FSharpList`1[a]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Collections.FSharpMap`2[c,Microsoft.FSharp.Collections.FSharpList`1[a]] layerAdditive[a,b,c](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Collections.FSharpList`1[a],Microsoft.FSharp.Core.FSharpFunc`2[b,Microsoft.FSharp.Collections.FSharpList`1[a]]], Microsoft.FSharp.Collections.FSharpMap`2[c,b], Microsoft.FSharp.Collections.FSharpMap`2[c,Microsoft.FSharp.Collections.FSharpList`1[a]]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Core.FSharpOption`1[T] tryFind[T](System.String, Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Microsoft.FSharp.Core.FSharpOption`1[a] tryFindInRange[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[b,a]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[System.String,T],Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]] partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[System.String,b],a] mapFold[a,T,b](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[b,a]]]], a, Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: T find[T](System.String, Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: Void iter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: a foldBackRange[T,a](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[a,a]], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T], a) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: a foldBack[T,a](Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[a,a]]], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T], a) -FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule: c subfold2[a,b,c,d](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,c]], Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[d,Microsoft.FSharp.Core.FSharpFunc`2[b,Microsoft.FSharp.Core.FSharpFunc`2[c,c]]]], Microsoft.FSharp.Collections.FSharpMap`2[a,d], Microsoft.FSharp.Collections.FSharpMap`2[a,b], c) -FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMapModule: Boolean existsInRange[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMapModule: Microsoft.FSharp.Collections.FSharpList`1[T] find[T](System.String, Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMapModule: Microsoft.FSharp.Collections.FSharpList`1[T] rangeReversingEachBucket[T](Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMapModule: Microsoft.FSharp.Collections.FSharpList`1[T] range[T](Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMapModule: Microsoft.FSharp.Collections.FSharpList`1[a] chooseRange[T,a](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[a]], Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]] add[T](System.String, T, Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]] empty[T]() -FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]] initBy[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.String], System.Collections.Generic.IEnumerable`1[T]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]] ofList[T](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,T]]) -FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMapModule: Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[a]] map[T,a](Microsoft.FSharp.Core.FSharpFunc`2[T,a], Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) +FSharp.Compiler.AbstractIL.Internal.Library+MultiMap: Boolean existsInRange[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[b,Microsoft.FSharp.Collections.FSharpList`1[a]]) +FSharp.Compiler.AbstractIL.Internal.Library+MultiMap: Microsoft.FSharp.Collections.FSharpList`1[b] find[a,b](a, Microsoft.FSharp.Collections.FSharpMap`2[a,Microsoft.FSharp.Collections.FSharpList`1[b]]) +FSharp.Compiler.AbstractIL.Internal.Library+MultiMap: Microsoft.FSharp.Collections.FSharpList`1[b] range[a,b](Microsoft.FSharp.Collections.FSharpMap`2[a,Microsoft.FSharp.Collections.FSharpList`1[b]]) +FSharp.Compiler.AbstractIL.Internal.Library+MultiMap: Microsoft.FSharp.Collections.FSharpMap`2[a,Microsoft.FSharp.Collections.FSharpList`1[b]] add[a,b](a, b, Microsoft.FSharp.Collections.FSharpMap`2[a,Microsoft.FSharp.Collections.FSharpList`1[b]]) +FSharp.Compiler.AbstractIL.Internal.Library+MultiMap: Microsoft.FSharp.Collections.FSharpMap`2[a,Microsoft.FSharp.Collections.FSharpList`1[b]] empty[a,b]() +FSharp.Compiler.AbstractIL.Internal.Library+MultiMap: Microsoft.FSharp.Collections.FSharpMap`2[b,Microsoft.FSharp.Collections.FSharpList`1[a]] initBy[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,b], System.Collections.Generic.IEnumerable`1[a]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Boolean existsInRange[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[b,a]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Boolean exists[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[a,b]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Boolean forall[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[a,b]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Boolean isEmpty[T](Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Boolean mem[T](System.String, Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Boolean suball2[a,b,c](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,System.Boolean]], Microsoft.FSharp.Core.FSharpFunc`2[c,Microsoft.FSharp.Core.FSharpFunc`2[b,System.Boolean]], Microsoft.FSharp.Collections.FSharpMap`2[a,c], Microsoft.FSharp.Collections.FSharpMap`2[a,b]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,T]] toList[T](Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpList`1[b] range[a,b](Microsoft.FSharp.Collections.FSharpMap`2[a,b]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,T] add[T](System.String, T, Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,T] filterRange[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,T] layer[T](Microsoft.FSharp.Collections.FSharpMap`2[System.String,T], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,T] ofList[T](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,T]]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,T] ofSeq[T](System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.String,T]]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,a] mapFilter[T,a](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[a]], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,a] map[T,a](Microsoft.FSharp.Core.FSharpFunc`2[T,a], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,b] union[a,b](Microsoft.FSharp.Core.FSharpFunc`2[System.Collections.Generic.IEnumerable`1[a],b], System.Collections.Generic.IEnumerable`1[Microsoft.FSharp.Collections.FSharpMap`2[System.String,a]]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpMap`2[a,b] empty[a,b]() +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpMap`2[b,a] ofKeyedList[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,b], Microsoft.FSharp.Collections.FSharpList`1[a]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Collections.FSharpMap`2[c,Microsoft.FSharp.Collections.FSharpList`1[a]] layerAdditive[a,b,c](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Collections.FSharpList`1[a],Microsoft.FSharp.Core.FSharpFunc`2[b,Microsoft.FSharp.Collections.FSharpList`1[a]]], Microsoft.FSharp.Collections.FSharpMap`2[c,b], Microsoft.FSharp.Collections.FSharpMap`2[c,Microsoft.FSharp.Collections.FSharpList`1[a]]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Core.FSharpOption`1[T] tryFind[T](System.String, Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Microsoft.FSharp.Core.FSharpOption`1[a] tryFindInRange[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[b,a]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[System.String,T],Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]] partition[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: System.Tuple`2[Microsoft.FSharp.Collections.FSharpMap`2[System.String,b],a] mapFold[a,T,b](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpFunc`2[T,System.Tuple`2[b,a]]]], a, Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: T find[T](System.String, Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: Void iter[T](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: a foldBackRange[T,a](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[a,a]], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T], a) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: a foldBack[T,a](Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpFunc`2[a,a]]], Microsoft.FSharp.Collections.FSharpMap`2[System.String,T], a) +FSharp.Compiler.AbstractIL.Internal.Library+NameMap: c subfold2[a,b,c,d](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,c]], Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[d,Microsoft.FSharp.Core.FSharpFunc`2[b,Microsoft.FSharp.Core.FSharpFunc`2[c,c]]]], Microsoft.FSharp.Collections.FSharpMap`2[a,d], Microsoft.FSharp.Collections.FSharpMap`2[a,b], c) +FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMap: Boolean existsInRange[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.Boolean], Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMap: Microsoft.FSharp.Collections.FSharpList`1[T] find[T](System.String, Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMap: Microsoft.FSharp.Collections.FSharpList`1[T] rangeReversingEachBucket[T](Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMap: Microsoft.FSharp.Collections.FSharpList`1[T] range[T](Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMap: Microsoft.FSharp.Collections.FSharpList`1[a] chooseRange[T,a](Microsoft.FSharp.Core.FSharpFunc`2[T,Microsoft.FSharp.Core.FSharpOption`1[a]], Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]] add[T](System.String, T, Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]] empty[T]() +FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]] initBy[T](Microsoft.FSharp.Core.FSharpFunc`2[T,System.String], System.Collections.Generic.IEnumerable`1[T]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]] ofList[T](Microsoft.FSharp.Collections.FSharpList`1[System.Tuple`2[System.String,T]]) +FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMap: Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[a]] map[T,a](Microsoft.FSharp.Core.FSharpFunc`2[T,a], Microsoft.FSharp.Collections.FSharpMap`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[T]]) FSharp.Compiler.AbstractIL.Internal.Library+Option: Microsoft.FSharp.Core.FSharpOption`1[T] attempt[T](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,T]) FSharp.Compiler.AbstractIL.Internal.Library+Option: System.Tuple`2[Microsoft.FSharp.Core.FSharpOption`1[c],a] mapFold[a,b,c](Microsoft.FSharp.Core.FSharpFunc`2[a,Microsoft.FSharp.Core.FSharpFunc`2[b,System.Tuple`2[c,a]]], a, Microsoft.FSharp.Core.FSharpOption`1[b]) FSharp.Compiler.AbstractIL.Internal.Library+Order: Int32 toFunction[U](System.Collections.Generic.IComparer`1[U], U, U) @@ -18267,11 +18268,11 @@ FSharp.Compiler.AbstractIL.Internal.Library+Order: System.Collections.Generic.IC FSharp.Compiler.AbstractIL.Internal.Library+Order: System.Collections.Generic.IComparer`1[T] orderOn[T,U](Microsoft.FSharp.Core.FSharpFunc`2[T,U], System.Collections.Generic.IComparer`1[U]) FSharp.Compiler.AbstractIL.Internal.Library+ResizeArray: a[][] chunkBySize[t,a](Int32, Microsoft.FSharp.Core.FSharpFunc`2[t,a], System.Collections.Generic.List`1[t]) FSharp.Compiler.AbstractIL.Internal.Library+ResizeArray: a[][] mapToSmallArrayChunks[t,a](Microsoft.FSharp.Core.FSharpFunc`2[t,a], System.Collections.Generic.List`1[t]) -FSharp.Compiler.AbstractIL.Internal.Library+ResultOrExceptionModule: ResultOrException`1 op_BarQmarkGreater[a,b](ResultOrException`1, Microsoft.FSharp.Core.FSharpFunc`2[a,b]) -FSharp.Compiler.AbstractIL.Internal.Library+ResultOrExceptionModule: ResultOrException`1 otherwise[a](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException`1[a]], ResultOrException`1) -FSharp.Compiler.AbstractIL.Internal.Library+ResultOrExceptionModule: ResultOrException`1 raze[a](System.Exception) -FSharp.Compiler.AbstractIL.Internal.Library+ResultOrExceptionModule: ResultOrException`1 success[a](a) -FSharp.Compiler.AbstractIL.Internal.Library+ResultOrExceptionModule: a ForceRaise[a](ResultOrException`1) +FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException: ResultOrException`1 op_BarQmarkGreater[a,b](ResultOrException`1, Microsoft.FSharp.Core.FSharpFunc`2[a,b]) +FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException: ResultOrException`1 otherwise[a](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException`1[a]], ResultOrException`1) +FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException: ResultOrException`1 raze[a](System.Exception) +FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException: ResultOrException`1 success[a](a) +FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException: a ForceRaise[a](ResultOrException`1) FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException`1+Exception[TResult]: Boolean Equals(ResultOrException`1) FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException`1+Exception[TResult]: Boolean Equals(System.Object) FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException`1+Exception[TResult]: Boolean Equals(System.Object, System.Collections.IEqualityComparer) @@ -18319,7 +18320,6 @@ FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException`1[TResult]: Int32 FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException`1[TResult]: ResultOrException`1 NewException(System.Exception) FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException`1[TResult]: ResultOrException`1 NewResult(TResult) FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException`1[TResult]: System.String ToString() -FSharp.Compiler.AbstractIL.Internal.Library+Shim+DefaultFileSystem: Void .ctor() FSharp.Compiler.AbstractIL.Internal.Library+Shim+IFileSystem: Boolean IsInvalidPathShim(System.String) FSharp.Compiler.AbstractIL.Internal.Library+Shim+IFileSystem: Boolean IsPathRootedShim(System.String) FSharp.Compiler.AbstractIL.Internal.Library+Shim+IFileSystem: Boolean IsStableFileHeuristic(System.String) @@ -18335,7 +18335,6 @@ FSharp.Compiler.AbstractIL.Internal.Library+Shim+IFileSystem: System.String GetF FSharp.Compiler.AbstractIL.Internal.Library+Shim+IFileSystem: System.String GetTempPathShim() FSharp.Compiler.AbstractIL.Internal.Library+Shim+IFileSystem: Void FileDelete(System.String) FSharp.Compiler.AbstractIL.Internal.Library+Shim: Byte[] File.ReadBinaryChunk.Static(System.String, Int32, Int32) -FSharp.Compiler.AbstractIL.Internal.Library+Shim: FSharp.Compiler.AbstractIL.Internal.Library+Shim+DefaultFileSystem FSharp.Compiler.AbstractIL.Internal.Library+Shim: FSharp.Compiler.AbstractIL.Internal.Library+Shim+IFileSystem FSharp.Compiler.AbstractIL.Internal.Library+Shim: IFileSystem FileSystem FSharp.Compiler.AbstractIL.Internal.Library+Shim: IFileSystem get_FileSystem() @@ -18363,7 +18362,6 @@ FSharp.Compiler.AbstractIL.Internal.Library+String: System.String[] getLines(Sys FSharp.Compiler.AbstractIL.Internal.Library+String: System.String[] split(System.StringSplitOptions, System.String[], System.String) FSharp.Compiler.AbstractIL.Internal.Library+String: System.Tuple`2[System.String,Microsoft.FSharp.Core.FSharpOption`1[System.Int32]] extractTrailingIndex(System.String) FSharp.Compiler.AbstractIL.Internal.Library+Tables: Microsoft.FSharp.Core.FSharpFunc`2[a,b] memoize[a,b](Microsoft.FSharp.Core.FSharpFunc`2[a,b]) -FSharp.Compiler.AbstractIL.Internal.Library+UndefinedException: Boolean Equals(System.Exception) FSharp.Compiler.AbstractIL.Internal.Library+UndefinedException: Boolean Equals(System.Object) FSharp.Compiler.AbstractIL.Internal.Library+UndefinedException: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.AbstractIL.Internal.Library+UndefinedException: Int32 GetHashCode() @@ -18434,18 +18432,19 @@ FSharp.Compiler.AbstractIL.Internal.Library: Boolean op_EqualsEqualsEquals[a](a, FSharp.Compiler.AbstractIL.Internal.Library: CancellableBuilder cancellable FSharp.Compiler.AbstractIL.Internal.Library: CancellableBuilder get_cancellable() FSharp.Compiler.AbstractIL.Internal.Library: CompilationThreadToken AssumeCompilationThreadWithoutEvidence() +FSharp.Compiler.AbstractIL.Internal.Library: ? AssumeLockWithoutEvidence[?]() FSharp.Compiler.AbstractIL.Internal.Library: EventuallyBuilder eventually FSharp.Compiler.AbstractIL.Internal.Library: EventuallyBuilder get_eventually() FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+AnyCallerThreadToken FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+Array FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+CancellableBuilder -FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+CancellableModule +FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+Cancellable +FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+Eventually FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+Cancellable`1[TResult] FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+CompilationThreadToken FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+Dictionary FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+DictionaryExtensions FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+EventuallyBuilder -FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+EventuallyModule FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+Eventually`1[T] FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+ExecutionToken FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+IPartialEqualityComparer @@ -18460,13 +18459,13 @@ FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+Lock`1[LockTokenType] FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+Map FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+MemoizationTable`2[T,U] -FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+MultiMapModule -FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+NameMapModule -FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMapModule +FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+MultiMap +FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+NameMap +FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+NameMultiMap FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+Option FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+Order FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+ResizeArray -FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+ResultOrExceptionModule +FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+ResultOrException`1[TResult] FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+Shim FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal.Library+String @@ -18478,7 +18477,6 @@ FSharp.Compiler.AbstractIL.Internal.Library: FSharp.Compiler.AbstractIL.Internal FSharp.Compiler.AbstractIL.Internal.Library: Int32 LOH_SIZE_THRESHOLD_BYTES FSharp.Compiler.AbstractIL.Internal.Library: Int32 get_LOH_SIZE_THRESHOLD_BYTES() FSharp.Compiler.AbstractIL.Internal.Library: Int32 op_GreaterGreaterGreaterAmp(Int32, Int32) -FSharp.Compiler.AbstractIL.Internal.Library: LockTokenType AssumeLockWithoutEvidence[LockTokenType]() FSharp.Compiler.AbstractIL.Internal.Library: Microsoft.FSharp.Collections.FSharpList`1[Value] Map`2.get_Values[Key,Value](Microsoft.FSharp.Collections.FSharpMap`2[Key,Value]) FSharp.Compiler.AbstractIL.Internal.Library: Microsoft.FSharp.Collections.FSharpMap`2[Key,Value] Map`2.AddAndMarkAsCollapsible[Key,Value](Microsoft.FSharp.Collections.FSharpMap`2[Key,Value], System.Collections.Generic.KeyValuePair`2[Key,Value][]) FSharp.Compiler.AbstractIL.Internal.Library: Microsoft.FSharp.Collections.FSharpMap`2[Key,Value] Map`2.LinearTryModifyThenLaterFlatten[Key,Value](Microsoft.FSharp.Collections.FSharpMap`2[Key,Value], Key, Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpOption`1[Value],Value]) @@ -18594,7 +18592,6 @@ FSharp.Compiler.ErrorLogger+CapturingErrorLogger: System.String DebugDisplay() FSharp.Compiler.ErrorLogger+CapturingErrorLogger: Void .ctor(System.String) FSharp.Compiler.ErrorLogger+CapturingErrorLogger: Void CommitDelayedDiagnostics(ErrorLogger) FSharp.Compiler.ErrorLogger+CapturingErrorLogger: Void DiagnosticSink(PhasedDiagnostic, Boolean) -FSharp.Compiler.ErrorLogger+Deprecated: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+Deprecated: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+Deprecated: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+Deprecated: Int32 GetHashCode() @@ -18605,7 +18602,6 @@ FSharp.Compiler.ErrorLogger+Deprecated: Void .ctor() FSharp.Compiler.ErrorLogger+Deprecated: Void .ctor(System.String, range) FSharp.Compiler.ErrorLogger+Deprecated: range Data1 FSharp.Compiler.ErrorLogger+Deprecated: range get_Data1() -FSharp.Compiler.ErrorLogger+Error: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+Error: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+Error: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+Error: Int32 GetHashCode() @@ -18684,7 +18680,6 @@ FSharp.Compiler.ErrorLogger+ErrorWithSuggestions: Void .ctor(System.Tuple`2[Syst FSharp.Compiler.ErrorLogger+ErrorWithSuggestions: range Data1 FSharp.Compiler.ErrorLogger+ErrorWithSuggestions: range get_Data1() FSharp.Compiler.ErrorLogger+Exiter: T Exit[T](Int32) -FSharp.Compiler.ErrorLogger+Experimental: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+Experimental: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+Experimental: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+Experimental: Int32 GetHashCode() @@ -18719,7 +18714,6 @@ FSharp.Compiler.ErrorLogger+FSharpErrorSeverityOptions: Microsoft.FSharp.Collect FSharp.Compiler.ErrorLogger+FSharpErrorSeverityOptions: Microsoft.FSharp.Collections.FSharpList`1[System.Int32] get_WarnOn() FSharp.Compiler.ErrorLogger+FSharpErrorSeverityOptions: System.String ToString() FSharp.Compiler.ErrorLogger+FSharpErrorSeverityOptions: Void .ctor(Int32, Boolean, Microsoft.FSharp.Collections.FSharpList`1[System.Int32], Microsoft.FSharp.Collections.FSharpList`1[System.Int32], Microsoft.FSharp.Collections.FSharpList`1[System.Int32], Microsoft.FSharp.Collections.FSharpList`1[System.Int32]) -FSharp.Compiler.ErrorLogger+InternalError: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+InternalError: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+InternalError: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+InternalError: Int32 GetHashCode() @@ -18732,7 +18726,6 @@ FSharp.Compiler.ErrorLogger+InternalError: Void .ctor() FSharp.Compiler.ErrorLogger+InternalError: Void .ctor(System.String, range) FSharp.Compiler.ErrorLogger+InternalError: range Data1 FSharp.Compiler.ErrorLogger+InternalError: range get_Data1() -FSharp.Compiler.ErrorLogger+LibraryUseOnly: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+LibraryUseOnly: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+LibraryUseOnly: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+LibraryUseOnly: Int32 GetHashCode() @@ -18741,7 +18734,6 @@ FSharp.Compiler.ErrorLogger+LibraryUseOnly: Void .ctor() FSharp.Compiler.ErrorLogger+LibraryUseOnly: Void .ctor(range) FSharp.Compiler.ErrorLogger+LibraryUseOnly: range Data0 FSharp.Compiler.ErrorLogger+LibraryUseOnly: range get_Data0() -FSharp.Compiler.ErrorLogger+NumberedError: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+NumberedError: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+NumberedError: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+NumberedError: Int32 GetHashCode() @@ -18759,10 +18751,10 @@ FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: Boolean IsErrorRes FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: Boolean IsOkResult FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: Boolean get_IsErrorResult() FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: Boolean get_IsOkResult() +FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: Microsoft.FSharp.Collections.FSharpList`1[System.Exception] get_warnings() +FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: Microsoft.FSharp.Collections.FSharpList`1[System.Exception] warnings FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: Int32 Tag FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: Int32 get_Tag() -FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: Microsoft.FSharp.Collections.FSharpList`1[System.Exception] Item1 -FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: Microsoft.FSharp.Collections.FSharpList`1[System.Exception] get_Item1() FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: System.Exception Item2 FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: System.Exception get_Item2() FSharp.Compiler.ErrorLogger+OperationResult`1+ErrorResult[T]: System.String ToString() @@ -18772,11 +18764,11 @@ FSharp.Compiler.ErrorLogger+OperationResult`1+OkResult[T]: Boolean get_IsErrorRe FSharp.Compiler.ErrorLogger+OperationResult`1+OkResult[T]: Boolean get_IsOkResult() FSharp.Compiler.ErrorLogger+OperationResult`1+OkResult[T]: Int32 Tag FSharp.Compiler.ErrorLogger+OperationResult`1+OkResult[T]: Int32 get_Tag() -FSharp.Compiler.ErrorLogger+OperationResult`1+OkResult[T]: Microsoft.FSharp.Collections.FSharpList`1[System.Exception] Item1 -FSharp.Compiler.ErrorLogger+OperationResult`1+OkResult[T]: Microsoft.FSharp.Collections.FSharpList`1[System.Exception] get_Item1() FSharp.Compiler.ErrorLogger+OperationResult`1+OkResult[T]: System.String ToString() FSharp.Compiler.ErrorLogger+OperationResult`1+OkResult[T]: T Item2 FSharp.Compiler.ErrorLogger+OperationResult`1+OkResult[T]: T get_Item2() +FSharp.Compiler.ErrorLogger+OperationResult`1+OkResult[T]: Microsoft.FSharp.Collections.FSharpList`1[System.Exception] get_warnings() +FSharp.Compiler.ErrorLogger+OperationResult`1+OkResult[T]: Microsoft.FSharp.Collections.FSharpList`1[System.Exception] warnings FSharp.Compiler.ErrorLogger+OperationResult`1+Tags[T]: Int32 ErrorResult FSharp.Compiler.ErrorLogger+OperationResult`1+Tags[T]: Int32 OkResult FSharp.Compiler.ErrorLogger+OperationResult`1[T]: Boolean IsErrorResult @@ -18807,7 +18799,6 @@ FSharp.Compiler.ErrorLogger+PhasedDiagnostic: System.String DebugDisplay() FSharp.Compiler.ErrorLogger+PhasedDiagnostic: System.String Subcategory() FSharp.Compiler.ErrorLogger+PhasedDiagnostic: System.String ToString() FSharp.Compiler.ErrorLogger+PhasedDiagnostic: Void .ctor(System.Exception, BuildPhase) -FSharp.Compiler.ErrorLogger+PossibleUnverifiableCode: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+PossibleUnverifiableCode: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+PossibleUnverifiableCode: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+PossibleUnverifiableCode: Int32 GetHashCode() @@ -18816,7 +18807,6 @@ FSharp.Compiler.ErrorLogger+PossibleUnverifiableCode: Void .ctor() FSharp.Compiler.ErrorLogger+PossibleUnverifiableCode: Void .ctor(range) FSharp.Compiler.ErrorLogger+PossibleUnverifiableCode: range Data0 FSharp.Compiler.ErrorLogger+PossibleUnverifiableCode: range get_Data0() -FSharp.Compiler.ErrorLogger+ReportedError: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+ReportedError: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+ReportedError: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+ReportedError: Int32 GetHashCode() @@ -18827,7 +18817,6 @@ FSharp.Compiler.ErrorLogger+ReportedError: System.String Message FSharp.Compiler.ErrorLogger+ReportedError: System.String get_Message() FSharp.Compiler.ErrorLogger+ReportedError: Void .ctor() FSharp.Compiler.ErrorLogger+ReportedError: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[System.Exception]) -FSharp.Compiler.ErrorLogger+StopProcessingExn: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+StopProcessingExn: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+StopProcessingExn: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+StopProcessingExn: Int32 GetHashCode() @@ -18849,7 +18838,6 @@ FSharp.Compiler.ErrorLogger+TrackErrorsBuilder: OperationResult`1 Zero() FSharp.Compiler.ErrorLogger+TrackErrorsBuilder: Void .ctor() FSharp.Compiler.ErrorLogger+TrackErrorsBuilder: a Run[a](Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,a]) FSharp.Compiler.ErrorLogger+TrackErrorsBuilder: f ReturnFrom[f](f) -FSharp.Compiler.ErrorLogger+UnresolvedPathReference: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+UnresolvedPathReference: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+UnresolvedPathReference: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+UnresolvedPathReference: Int32 GetHashCode() @@ -18862,7 +18850,6 @@ FSharp.Compiler.ErrorLogger+UnresolvedPathReference: Void .ctor() FSharp.Compiler.ErrorLogger+UnresolvedPathReference: Void .ctor(System.String, System.String, range) FSharp.Compiler.ErrorLogger+UnresolvedPathReference: range Data2 FSharp.Compiler.ErrorLogger+UnresolvedPathReference: range get_Data2() -FSharp.Compiler.ErrorLogger+UnresolvedPathReferenceNoRange: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+UnresolvedPathReferenceNoRange: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+UnresolvedPathReferenceNoRange: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+UnresolvedPathReferenceNoRange: Int32 GetHashCode() @@ -18875,7 +18862,6 @@ FSharp.Compiler.ErrorLogger+UnresolvedPathReferenceNoRange: System.String get_Da FSharp.Compiler.ErrorLogger+UnresolvedPathReferenceNoRange: System.String get_Message() FSharp.Compiler.ErrorLogger+UnresolvedPathReferenceNoRange: Void .ctor() FSharp.Compiler.ErrorLogger+UnresolvedPathReferenceNoRange: Void .ctor(System.String, System.String) -FSharp.Compiler.ErrorLogger+UnresolvedReferenceError: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+UnresolvedReferenceError: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+UnresolvedReferenceError: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+UnresolvedReferenceError: Int32 GetHashCode() @@ -18886,7 +18872,6 @@ FSharp.Compiler.ErrorLogger+UnresolvedReferenceError: Void .ctor() FSharp.Compiler.ErrorLogger+UnresolvedReferenceError: Void .ctor(System.String, range) FSharp.Compiler.ErrorLogger+UnresolvedReferenceError: range Data1 FSharp.Compiler.ErrorLogger+UnresolvedReferenceError: range get_Data1() -FSharp.Compiler.ErrorLogger+UnresolvedReferenceNoRange: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+UnresolvedReferenceNoRange: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+UnresolvedReferenceNoRange: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+UnresolvedReferenceNoRange: Int32 GetHashCode() @@ -18895,7 +18880,6 @@ FSharp.Compiler.ErrorLogger+UnresolvedReferenceNoRange: System.String Data0 FSharp.Compiler.ErrorLogger+UnresolvedReferenceNoRange: System.String get_Data0() FSharp.Compiler.ErrorLogger+UnresolvedReferenceNoRange: Void .ctor() FSharp.Compiler.ErrorLogger+UnresolvedReferenceNoRange: Void .ctor(System.String) -FSharp.Compiler.ErrorLogger+UserCompilerMessage: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+UserCompilerMessage: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+UserCompilerMessage: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+UserCompilerMessage: Int32 Data1 @@ -18908,7 +18892,6 @@ FSharp.Compiler.ErrorLogger+UserCompilerMessage: Void .ctor() FSharp.Compiler.ErrorLogger+UserCompilerMessage: Void .ctor(System.String, Int32, range) FSharp.Compiler.ErrorLogger+UserCompilerMessage: range Data2 FSharp.Compiler.ErrorLogger+UserCompilerMessage: range get_Data2() -FSharp.Compiler.ErrorLogger+WrappedError: Boolean Equals(System.Exception) FSharp.Compiler.ErrorLogger+WrappedError: Boolean Equals(System.Object) FSharp.Compiler.ErrorLogger+WrappedError: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ErrorLogger+WrappedError: Int32 GetHashCode() @@ -18979,7 +18962,6 @@ FSharp.Compiler.ErrorLogger: OperationResult`1 op_PlusPlus[a,b](OperationResult` FSharp.Compiler.ErrorLogger: System.Exception AttachRange(range, System.Exception) FSharp.Compiler.ErrorLogger: System.Exception StopProcessing[T]() FSharp.Compiler.ErrorLogger: System.Exception findOriginalException(System.Exception) -FSharp.Compiler.ErrorLogger: System.IDisposable PushErrorLoggerPhaseUntilUnwind[a](Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.ErrorLogger+ErrorLogger,a]) FSharp.Compiler.ErrorLogger: System.IDisposable PushThreadBuildPhaseUntilUnwind(BuildPhase) FSharp.Compiler.ErrorLogger: System.String NewlineifyErrorString(System.String) FSharp.Compiler.ErrorLogger: System.String NormalizeErrorString(System.String) @@ -18988,7 +18970,6 @@ FSharp.Compiler.ErrorLogger: System.String stringThatIsAProxyForANewlineInFlatEr FSharp.Compiler.ErrorLogger: TrackErrorsBuilder get_trackErrors() FSharp.Compiler.ErrorLogger: TrackErrorsBuilder trackErrors FSharp.Compiler.ErrorLogger: Void RaiseOperationResult(OperationResult`1) -FSharp.Compiler.ErrorLogger: Void ReportWarnings[a](Microsoft.FSharp.Collections.FSharpList`1[a]) FSharp.Compiler.ErrorLogger: Void SetThreadBuildPhaseNoUnwind(BuildPhase) FSharp.Compiler.ErrorLogger: Void SetThreadErrorLoggerNoUnwind(ErrorLogger) FSharp.Compiler.ErrorLogger: Void deprecatedOperator(range) @@ -20022,7 +20003,6 @@ FSharp.Compiler.ParseHelpers: FSharp.Compiler.ParseHelpers+LexerStringKind FSharp.Compiler.ParseHelpers: FSharp.Compiler.ParseHelpers+LexerStringStyle FSharp.Compiler.ParseHelpers: FSharp.Compiler.ParseHelpers+SyntaxError FSharp.Compiler.ParseHelpers: ILType ParseAssemblyCodeType(System.String, range) -FSharp.Compiler.ParseHelpers+IndentationProblem: Boolean Equals(System.Exception) FSharp.Compiler.ParseHelpers+IndentationProblem: Boolean Equals(System.Object) FSharp.Compiler.ParseHelpers+IndentationProblem: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.ParseHelpers+IndentationProblem: Int32 GetHashCode() @@ -20087,7 +20067,6 @@ FSharp.Compiler.PrettyNaming+FSharpLib: System.String Core FSharp.Compiler.PrettyNaming+FSharpLib: System.String Root FSharp.Compiler.PrettyNaming+FSharpLib: System.String get_Core() FSharp.Compiler.PrettyNaming+FSharpLib: System.String get_Root() -FSharp.Compiler.PrettyNaming+InvalidMangledStaticArg: Boolean Equals(System.Exception) FSharp.Compiler.PrettyNaming+InvalidMangledStaticArg: Boolean Equals(System.Object) FSharp.Compiler.PrettyNaming+InvalidMangledStaticArg: Boolean Equals(System.Object, System.Collections.IEqualityComparer) FSharp.Compiler.PrettyNaming+InvalidMangledStaticArg: Int32 GetHashCode() @@ -20133,7 +20112,6 @@ FSharp.Compiler.PrettyNaming: FSharp.Compiler.PrettyNaming+CustomOperations FSharp.Compiler.PrettyNaming: FSharp.Compiler.PrettyNaming+FSharpLib FSharp.Compiler.PrettyNaming: FSharp.Compiler.PrettyNaming+InvalidMangledStaticArg FSharp.Compiler.PrettyNaming: FSharp.Compiler.PrettyNaming+NameArityPair -FSharp.Compiler.PrettyNaming: Internal.Utilities.StructuredFormat.Layout DemangleOperatorNameAsLayout[a](Microsoft.FSharp.Core.FSharpFunc`2[System.String,a], System.String) FSharp.Compiler.PrettyNaming: Microsoft.FSharp.Collections.FSharpList`1[System.String] SplitNamesForILPath(System.String) FSharp.Compiler.PrettyNaming: Microsoft.FSharp.Core.FSharpChoice`6[Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit,Microsoft.FSharp.Core.Unit] |Control|Equality|Relational|Indexer|FixedTypes|Other|(System.String) FSharp.Compiler.PrettyNaming: Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,Microsoft.FSharp.Core.FSharpFunc`2[System.Int32,System.String]] get_mkUnionCaseFieldName() @@ -41952,13 +41930,9 @@ FSharp.Compiler.XmlDoc+XmlDocCollector: System.Tuple`2[System.String,FSharp.Comp FSharp.Compiler.XmlDoc+XmlDocCollector: Void .ctor() FSharp.Compiler.XmlDoc+XmlDocCollector: Void AddGrabPoint(pos) FSharp.Compiler.XmlDoc+XmlDocCollector: Void AddXmlDocLine(System.String, range) -FSharp.Compiler.XmlDoc+XmlDocStatics: Void .ctor() -FSharp.Compiler.XmlDoc+XmlDocStatics: XmlDoc Empty -FSharp.Compiler.XmlDoc+XmlDocStatics: XmlDoc get_Empty() FSharp.Compiler.XmlDoc: FSharp.Compiler.XmlDoc+PreXmlDoc FSharp.Compiler.XmlDoc: FSharp.Compiler.XmlDoc+XmlDoc FSharp.Compiler.XmlDoc: FSharp.Compiler.XmlDoc+XmlDocCollector -FSharp.Compiler.XmlDoc: FSharp.Compiler.XmlDoc+XmlDocStatics Internal.Utilities.PathMap: Boolean Equals(Internal.Utilities.PathMap) Internal.Utilities.PathMap: Boolean Equals(System.Object) Internal.Utilities.PathMap: Boolean Equals(System.Object, System.Collections.IEqualityComparer) @@ -42497,5 +42471,50 @@ Microsoft.DotNet.DependencyManager.NativeResolutionProbe: Void .ctor(System.Obje Microsoft.DotNet.DependencyManager.ResolvingErrorReport: System.IAsyncResult BeginInvoke(Microsoft.DotNet.DependencyManager.ErrorReportType, Int32, System.String, System.AsyncCallback, System.Object) Microsoft.DotNet.DependencyManager.ResolvingErrorReport: Void .ctor(System.Object, IntPtr) Microsoft.DotNet.DependencyManager.ResolvingErrorReport: Void EndInvoke(System.IAsyncResult) -Microsoft.DotNet.DependencyManager.ResolvingErrorReport: Void Invoke(Microsoft.DotNet.DependencyManager.ErrorReportType, Int32, System.String)" +Microsoft.DotNet.DependencyManager.ResolvingErrorReport: Void Invoke(Microsoft.DotNet.DependencyManager.ErrorReportType, Int32, System.String) +FSharp.Compiler.ErrorLogger: System.IDisposable PushErrorLoggerPhaseUntilUnwind[?](Microsoft.FSharp.Core.FSharpFunc`2[FSharp.Compiler.ErrorLogger+ErrorLogger,?]) +FSharp.Compiler.ErrorLogger: Void ReportWarnings[?](Microsoft.FSharp.Collections.FSharpList`1[?]) +FSharp.Compiler.ParseHelpers: ILInstr[] ParseAssemblyCodeInstructions(System.String, range) +FSharp.Compiler.PrettyNaming: Internal.Utilities.StructuredFormat.Layout DemangleOperatorNameAsLayout[?](Microsoft.FSharp.Core.FSharpFunc`2[System.String,?], System.String) +FSharp.Compiler.SourceCodeServices.CompilerDiagnostics: System.String getErrorMessage(FSharp.Compiler.SourceCodeServices.DiagnosticKind) +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Boolean Equals(FSharp.Compiler.SourceCodeServices.DiagnosticKind) +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Boolean Equals(System.Object) +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Boolean IsAddIndexerDot +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Boolean IsReplaceWithSuggestion +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Boolean get_IsAddIndexerDot() +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Boolean get_IsReplaceWithSuggestion() +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Int32 CompareTo(FSharp.Compiler.SourceCodeServices.DiagnosticKind) +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Int32 CompareTo(System.Object) +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Int32 CompareTo(System.Object, System.Collections.IComparer) +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Int32 GetHashCode() +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Int32 GetHashCode(System.Collections.IEqualityComparer) +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Int32 Tag +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: Int32 get_Tag() +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: System.String ToString() +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: System.String get_suggestion() +FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion: System.String suggestion +FSharp.Compiler.SourceCodeServices.DiagnosticKind+Tags: Int32 AddIndexerDot +FSharp.Compiler.SourceCodeServices.DiagnosticKind+Tags: Int32 ReplaceWithSuggestion +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Boolean Equals(FSharp.Compiler.SourceCodeServices.DiagnosticKind) +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Boolean Equals(System.Object) +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Boolean Equals(System.Object, System.Collections.IEqualityComparer) +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Boolean IsAddIndexerDot +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Boolean IsReplaceWithSuggestion +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Boolean get_IsAddIndexerDot() +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Boolean get_IsReplaceWithSuggestion() +FSharp.Compiler.SourceCodeServices.DiagnosticKind: FSharp.Compiler.SourceCodeServices.DiagnosticKind AddIndexerDot +FSharp.Compiler.SourceCodeServices.DiagnosticKind: FSharp.Compiler.SourceCodeServices.DiagnosticKind NewReplaceWithSuggestion(System.String) +FSharp.Compiler.SourceCodeServices.DiagnosticKind: FSharp.Compiler.SourceCodeServices.DiagnosticKind get_AddIndexerDot() +FSharp.Compiler.SourceCodeServices.DiagnosticKind: FSharp.Compiler.SourceCodeServices.DiagnosticKind+ReplaceWithSuggestion +FSharp.Compiler.SourceCodeServices.DiagnosticKind: FSharp.Compiler.SourceCodeServices.DiagnosticKind+Tags +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Int32 CompareTo(FSharp.Compiler.SourceCodeServices.DiagnosticKind) +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Int32 CompareTo(System.Object) +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Int32 CompareTo(System.Object, System.Collections.IComparer) +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Int32 GetHashCode() +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Int32 GetHashCode(System.Collections.IEqualityComparer) +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Int32 Tag +FSharp.Compiler.SourceCodeServices.DiagnosticKind: Int32 get_Tag() +FSharp.Compiler.SourceCodeServices.DiagnosticKind: System.String ToString() +FSharp.Compiler.SourceCodeServices.ErrorResolutionHints: System.Collections.Generic.IEnumerable`1[System.String] getSuggestedNames(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.Unit], System.String)" SurfaceArea.verify expected "netstandard" (System.IO.Path.Combine(__SOURCE_DIRECTORY__,__SOURCE_FILE__))