[Home] Module FSharp.PowerPack.Metadata.Reader.Internal.Tast


Modules (as contributed by assembly 'FSharp.PowerPack.Metadata')

ModuleDescription
FSharp.PowerPack.Metadata.Reader.Internal.Tast.TopValInfo Metadata on values (names of arguments etc.
FSharp.PowerPack.Metadata.Reader.Internal.Tast.TyparFlags
FSharp.PowerPack.Metadata.Reader.Internal.Tast.ValFlags

Type Definitions

TypeDescription
type Accessibility
type ActivePatternElemRef
type ActivePatternInfo
type Attrib Attrib(kind,unnamedArgs,propVals)
type AttribExpr We keep both source expression and evaluated expression around to help intellisense and signature printing
type AttribKind
type AttribNamedArg AttribNamedArg(name,type,isField,value)
type Attribs Note: an abbreviation for Attrib list
type Binding
type Bindings Note: an abbreviation for FlatList<Binding>
type ccu Note: an abbreviation for CcuThunk
type CcuData
type CcuReference Note: an abbreviation for string
type CcuResolutionResult The result of attempting to resolve an assembly name to a full ccu. UnresolvedCcu will contain the name of the assembly that could not be resolved.
type CcuThunk A relinkable handle to the contents of a compilation unit. Relinking is performed by mutation.
type CcuTypeForwarderTable Note: an abbreviation for Lazy<Map<(string [] * string),EntityRef>>
type CompilationPath The information ILXGEN needs about the location of an item
type CompiledTypeRepr Specifies the compiled representations of type and exception definitions. Computed and cached by later phases (never computed type checking). Cached at type and exception definitions. Not pickled.
type Constant Constants in expressions
type DecisionTree Decision trees. Pattern matching has been compiled down to a decision tree by this point. The right-hand-sides (actions) of the decision tree are labelled by integers that are unique for that particular tree.
type DecisionTreeCase
type DecisionTreeDiscriminator
type DecisionTreeTarget A target of a decision tree. Can be thought of as a little function, though is compiled as a local block.
type Entity
type EntityData
type EntityRef
type ExceptionInfo
type expr The big type of expressions.
type ExprOpSpec
type Exprs Note: an abbreviation for expr list
type FlatExprs Note: an abbreviation for FlatList<expr>
type FlatVals Note: an abbreviation for FlatList<Val>
type ForLoopStyle
type LValueOperation
type measure
type ModuleOrNamespace Note: an abbreviation for Entity
type ModuleOrNamespaceBinding A named module-or-namespace-fragment definition
type ModuleOrNamespaceExpr The module_typ is a binder. However it is not used in the ModuleOrNamespaceExpr: it is only referenced from the 'outside' The contents of a module-or-namespace-fragment definition
type ModuleOrNamespaceExprWithSig A type for a module-or-namespace-fragment and the actual definition of the module-or-namespace-fragment
type ModuleOrNamespaceKind
type ModuleOrNamespaceRef note: ModuleOrNamespaceRef and TyconRef are type equivalent Note: an abbreviation for EntityRef
type ModuleOrNamespaceType
type NonLocalItemRef Non-local references indirect via a CCU The lookup into the CCU is a NonLocalPath, which is a series of strings We cache the result of dereferencing
type NonLocalPath Index into the namespace/module structure of a particular CCU
type ObjExprMethod A representation of a method in an object expression. Note: Methods associated with types are represented as val declarations Note: We should probably use val_specs for object expressions, as then the treatment of members in object expressions could be more unified with the treatment of members in types
type ParentRef
type PickledModuleInfo
type PublicPath A public path records where a construct lives within the global namespace of a CCU.
type RecdField
type RecdFieldRef
type RecordConstructionInfo This ModuleOrNamespace that represents the compilation of a module as a class. The same set of tycons etc. are bound in the ModuleOrNamespace as in the ModuleOrNamespaceExpr This is the body of the module/namespace
type SequentialOpKind
type SlotParam
type SlotSig
type stamp Note: an abbreviation for int64
type StaticOptimization
type TcGlobals
type tinst Note: an abbreviation for typ list
type TopArgInfo The extra metadata stored about typars for top-level definitions. Any information here is propagated from signature through to the compiled code.
type TopTyparInfo The extra metadata stored about typars for top-level definitions. Any information here is propagated from signature through to the compiled code.
type TraitConstraintInfo The specification of a member constraint that must be solved
type TraitConstraintSln
type Tycon Note: an abbreviation for Entity
type TyconAugmentation
type TyconObjModelData
type TyconObjModelKind
type TyconRecdFields
type TyconRef Note: an abbreviation for EntityRef
type TyconRepresentation
type TyconUnionCases
type TyconUnionData
type typ The algebra of types
type Typar
type TyparConstraint
type TyparData
type TyparDynamicReq
type TyparKind
type TyparRigidity
type typars Note: an abbreviation for Typar list
type UnionCase
type UnionCaseRef
type uniq Unique name generator for stamps attached to lambdas and object expressions Note: an abbreviation for int64
type Val
type ValBaseOrThisInfo
type ValData
type ValInlineInfo
type ValMemberInfo
type ValMutability
type ValRecursiveScopeInfo
type ValRef References are either local or nonlocal
type Vals Note: an abbreviation for Val list
type ValTopReprInfo
type ValUseFlag

Exceptions

ExceptionDescription
exception Duplicate
exception FullAbstraction
exception InternalUndefinedItemRef
exception InternalUndefinedTyconItem
exception NameClash
exception UndefinedName

Values

ValueDescription
val access_subst_paths :
  CompilationPath * CompilationPath -> Accessibility -> Accessibility
Given (newPath,oldPath) replace oldPath by newPath in the TAccess.
val AddTyconsByAccessNames :
  string -> 'a -> NameMultiMap<'a> -> Map<string,'a list>
val AddTyconsByDemangledNameAndArity :
  string ->
    Typar list ->
      'a -> Map<NameArityPair,'a> -> Map<NameArityPair,'a>
val arity_of_val : Val -> ValTopReprInfo
val array_path_eq : string [] -> string [] -> bool
val attribs_of_tycon : Tycon -> Attribs
val can_access_cpath_from : CompilationPath -> CompilationPath -> bool
val can_access_cpath_from_one_of :
  CompilationPath list -> CompilationPath -> bool
val can_access_from : Accessibility -> CompilationPath -> bool
val can_access_from_everywhere : Accessibility -> bool
val can_access_from_somewhere : Accessibility -> bool
val ccu_eq : ccu -> ccu -> bool
Equality on CCUs, implemented as reference equality
val ccu_of_nlpath : NonLocalPath -> ccu
val ccu_of_nlref : NonLocalItemRef -> ccu
val ccu_of_tcref : EntityRef -> ccu option
val ccu_of_vref : ValRef -> ccu option
val combine_mtyps :
  string list -> range -> ModuleOrNamespaceType list -> ModuleOrNamespaceType
val combineAccess : Accessibility -> Accessibility -> Accessibility
val CopyTypar : Typar -> Typar
val CopyTypars : Typar list -> Typar list
val cpath_of_ccu : ccu -> CompilationPath
val data_of_val : Val -> ValData
val demangled_name_of_entity_name : string -> ModuleOrNamespaceKind -> string
val demangled_name_of_modref : ModuleOrNamespaceRef -> string
val demangled_name_of_modul : ModuleOrNamespace -> string
val demangled_path_of_cpath : CompilationPath -> string list
val deref_modul : ModuleOrNamespaceRef -> Entity
Identical to tcref.Deref and deref_tycon, just used to help distinguish what kind of entity we expect here
val deref_tycon : TyconRef -> Entity
val deref_val : ValRef -> Val
val empty_mtype : ModuleOrNamespaceKind -> ModuleOrNamespaceType
val enclosing_nlpath_of_pubpath : ccu -> PublicPath -> NonLocalPath
val ERef_nonlocal : NonLocalItemRef -> EntityRef
val ERef_nonlocal_preresolved :
  Entity nonnull_slot -> NonLocalItemRef -> EntityRef
val ERef_private : Entity nonnull_slot -> EntityRef
val fixup_typar_constraints : Typar -> TyparConstraint list -> unit
val FSharpOptimizationDataResourceName : string
val FSharpSignatureDataResourceName : string
val fslib_nlpath_eq_pubpath : NonLocalItemRef -> PublicPath -> bool
Compiler-internal references to items in fslib are generated as Ref_nonlocal even when compiling fslib
val fslib_refs_eq :
  ('a -> PublicPath option) ->
    'b -> ('c -> Choice<'a,NonLocalItemRef>) -> ccu -> 'c -> 'c -> bool
val full_cpath_of_modul : ModuleOrNamespace -> CompilationPath
val id_of_tycon : Tycon -> ident
val id_of_val : Val -> ident
val IsLessAccessible : Accessibility -> Accessibility -> bool
val item_of_nlref : NonLocalItemRef -> string
val local_tcref_eq : Tycon -> Tycon -> bool
val MakeRecdFieldsTable : RecdField list -> TyconRecdFields
val MakeUnionCases : UnionCase list -> TyconUnionData
val MakeUnionCasesTable : UnionCase list -> TyconUnionCases
val MakeUnionRepr : UnionCase list -> TyconRepresentation
val mangled_path_of_cpath : CompilationPath -> string list
val mk_byref_typ : TcGlobals -> typ -> typ
val mk_cpath :
  CompilationPath -> string -> ModuleOrNamespaceKind -> CompilationPath
val mk_exnconstr_namemap : (Tycon list -> Map<string,Tycon>)
val mk_local_tcref : Entity nonnull_slot -> EntityRef
val mk_multi_dim_array_typ : TcGlobals -> int -> typ -> typ
val mk_namemap : string -> ('a -> ident) -> 'a list -> Map<string,'a>
val mk_nativeint_typ : TcGlobals -> typ
val mk_nativeptr_typ : TcGlobals -> typ -> typ
val mk_nlpath : NonLocalPath -> string -> NonLocalPath
val mk_nlr : NonLocalPath -> string -> NonLocalItemRef
val mk_nonlocal_tcref : NonLocalPath -> string -> EntityRef
val mk_nonlocal_tcref_preresolved :
  Entity nonnull_slot -> NonLocalPath -> string -> EntityRef
val mk_nonlocal_vref : NonLocalPath -> string -> ValRef
val mk_nonlocal_vref_preresolved :
  Val nonnull_slot -> NonLocalPath -> string -> ValRef
val mk_rfref : TyconRef -> string -> RecdFieldRef
val mk_rigid_typar : string -> range -> Typar
val mk_tycon_namemap : (Tycon list -> Map<string,Tycon>)
val mk_typar_ty : Typar -> typ
val mk_ucref : TyconRef -> string -> UnionCaseRef
val mk_unit_typ : TcGlobals -> typ
val mk_val_namemap : (Val list -> Map<string,Val>)
val mustinline : ValInlineInfo -> bool
val name_of_rfield : RecdField -> string
val name_of_val : Val -> string
val new_ccu : CcuReference -> CcuData -> ccu
val new_stamp : (unit -> int64)
Unique name generator for stamps attached to to val_specs, tycon_specs etc.
val new_tcaug : unit -> TyconAugmentation
val new_uniq : (unit -> int64)
val NewCcuContents :
  ILScopeRef -> range -> string -> ModuleOrNamespaceType -> Entity
val NewClonedModuleOrNamespace : Tycon -> Entity
val NewClonedTycon : Tycon -> Entity
val NewExn :
  CompilationPath option ->
    ident -> Accessibility -> ExceptionInfo -> Attribs -> XmlDoc -> Entity
val NewFreeVarsCache : unit -> cache<'a>
val NewILTycon :
  CompilationPath option ->
    string * range ->
      LazyWithContext<typars,range> ->
        ILScopeRef * ILTypeDef list * ILTypeDef ->
          Lazy<ModuleOrNamespaceType> -> Entity
val NewModifiedModuleOrNamespace :
  (ModuleOrNamespaceType -> ModuleOrNamespaceType) -> Tycon -> Entity
Create a module Tycon based on an existing one using the function 'f'. We require that we be given the parent for the new module. We pass the new module to 'f' in case it needs to reparent the contents of the module.
val NewModifiedTycon : (EntityData -> EntityData) -> Tycon -> Entity
Create a tycon based on an existing one using the function 'f'. We require that we be given the new parent for the new tycon. We pass the new tycon to 'f' in case it needs to reparent the contents of the tycon.
val NewModifiedVal : (ValData -> ValData) -> Val -> Val
Create a Val based on an existing one using the function 'f'. We require that we be given the parent for the new Val.
val NewModuleOrNamespace :
  CompilationPath option ->
    Accessibility ->
      ident -> XmlDoc -> Attribs -> Lazy<ModuleOrNamespaceType> -> Entity
val NewModuleOrNamespaceType :
  ModuleOrNamespaceKind -> Entity list -> Val list -> ModuleOrNamespaceType
val NewRecdField :
  bool ->
    Constant option ->
      ident ->
        typ ->
          bool ->
            Attribs -> Attribs -> XmlDoc -> Accessibility -> bool -> RecdField
val NewTycon :
  CompilationPath option ->
    string * range ->
      Accessibility ->
        Accessibility ->
          TyparKind ->
            LazyWithContext<typars,range> ->
              XmlDoc -> bool -> Lazy<ModuleOrNamespaceType> -> Entity
val NewTypar :
  TyparKind * TyparRigidity * SynTypar * bool * TyparDynamicReq * Attribs ->
    Typar
val NewUnionCase :
  ident ->
    string ->
      RecdField list -> typ -> Attribs -> XmlDoc -> Accessibility -> UnionCase
val NewVal :
  ident * typ * ValMutability * bool * ValTopReprInfo option *
  CompilationPath option * Accessibility * ValRecursiveScopeInfo *
  ValMemberInfo option * ValBaseOrThisInfo * Attribs * ValInlineInfo * XmlDoc *
  bool * bool * bool * bool * Constant option * ParentRef -> Val
val nlpath_definitely_not_eq : NonLocalPath -> NonLocalPath -> 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 nlpath_eq : NonLocalPath -> NonLocalPath -> bool
val nlpath_of_ccu : ccu -> NonLocalPath
val nlpath_of_modul : ccu -> ModuleOrNamespace -> NonLocalPath option
val nlpath_of_nlref : NonLocalItemRef -> NonLocalPath
val nlpath_of_pubpath : ccu -> PublicPath -> NonLocalPath
val nlref_definitely_not_eq : NonLocalItemRef -> NonLocalItemRef -> bool
See nlpath_definitely_not_eq
val nlref_eq : NonLocalItemRef -> NonLocalItemRef -> bool
val nlref_of_pubpath : ccu -> PublicPath -> 'a -> NonLocalItemRef
val parent_cpath : CompilationPath -> CompilationPath
val path_of_nlpath : NonLocalPath -> string []
val prim_tcref_eq : bool -> ccu -> TyconRef -> TyconRef -> bool
val prim_ucref_eq : bool -> ccu -> UnionCaseRef -> UnionCaseRef -> bool
val prim_vref_eq : bool -> ccu -> ValRef -> ValRef -> bool
val pubpath_of_cpath : ident -> CompilationPath -> PublicPath
val pubpath_of_tycon : Tycon -> PublicPath option
val pubpath_of_val : Val -> PublicPath option
val rescope_tycon_pubpath : ccu -> PublicPath -> 'a -> TyconRef
val rescope_val_pubpath : ccu -> PublicPath -> 'a -> ValRef
val rfref_of_rfield : TyconRef -> RecdField -> RecdFieldRef
val set_compgen_of_tpdata : TyparData -> bool -> unit
val set_dynamic_req_of_tpdata : TyparData -> TyparDynamicReq -> unit
val set_from_error_of_tpdata : TyparData -> bool -> unit
val set_is_topbind_of_vflags : ValData -> bool -> unit
val set_kind_of_tpdata : TyparData -> TyparKind -> unit
val set_notailcall_hint_of_vflags : ValData -> bool -> unit
val set_rigid_of_tpdata : TyparData -> TyparRigidity -> unit
val set_static_req_of_tpdata : TyparData -> TyparStaticReq -> unit
val set_tcaug_compare : TyconAugmentation -> ValRef * ValRef -> unit
val set_tcaug_compare_withc : TyconAugmentation -> ValRef -> unit
val set_tcaug_equals : TyconAugmentation -> ValRef * ValRef -> unit
val set_tcaug_hash_and_equals_withc :
  TyconAugmentation -> ValRef * ValRef -> unit
val set_tcaug_hasObjectGetHashCode : TyconAugmentation -> bool -> unit
val set_vrec_of_vflags : ValData -> ValRecursiveScopeInfo -> unit
val SkipCacheCompute : SkipFreeVarsCache -> (unit -> 'a) -> 'a
val SkipFreeVarsCache : unit -> unit
val stamp_of_tycon : Tycon -> stamp
val strip_tpeqns : typ -> typ
val strip_tpeqnsA : bool -> typ -> typ
val strip_upeqns : measure -> measure
val strip_upeqnsA : bool -> measure -> measure
val taccessPublic : Accessibility
val tcref_in_this_assembly : bool -> TyconRef -> bool
val tpref_is_solved : Typar -> bool
val tpspec_eq : Typar -> Typar -> bool
Equality on type varialbes, implemented as reference equality
val try_deref_val : ValRef -> Val option
val try_shortcut_solved_upref : bool -> Typar -> measure
val typar_ref_eq : Typar -> Typar -> bool
val type_of_val : Val -> typ
val types_of_vals : Val list -> typ list
val ucref_of_ucase : TyconRef -> UnionCase -> UnionCaseRef
val unassignedTyparName : string
val verboseStamps : bool ref
verboseStamps: print #stamp on each id -- very verbose - but sometimes useful. Turn on using '--stamps'
val vref_in_this_assembly : bool -> ValRef -> bool
val VRef_nonlocal : NonLocalItemRef -> ValRef
val VRef_nonlocal_preresolved : Val nonnull_slot -> NonLocalItemRef -> ValRef
val VRef_private : Val nonnull_slot -> ValRef
val vspec_eq : Val -> Val -> bool
Equality on value specs, implemented as reference equality

Active Patterns

Active PatternDescription
val ( |ERef_private|ERef_nonlocal| ) :
  EntityRef -> Choice<Entity nonnull_slot,NonLocalItemRef>
val ( |ValDeref| ) : ValRef -> Val
val ( |VRef_private|VRef_nonlocal| ) :
  ValRef -> Choice<Val nonnull_slot,NonLocalItemRef>

See Also

FSharp.PowerPack.Metadata.Reader.Internal


Documentation for assembly FSharp.PowerPack.Metadata, version 1.9.6.16, generated using F# Programming Language version 1.9.6.16