csharpfftfsharpintegrationinterpolationlinear-algebramathdifferentiationmatrixnumericsrandomregressionstatisticsmathnet
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
376 lines
13 KiB
376 lines
13 KiB
// (c) Microsoft Corporation 2005-2009
|
|
namespace FSharp.PowerPack.Metadata
|
|
|
|
open System.Collections.ObjectModel
|
|
|
|
type [<Sealed>] Range =
|
|
member Document : string
|
|
member StartLine : int
|
|
member StartColumn : int
|
|
member EndLine : int
|
|
member EndColumn : int
|
|
|
|
type [<Sealed>] FSharpAssembly =
|
|
|
|
/// Get the object representing the F# core library (FSharp.Core.dll) for the running program
|
|
static member FSharpLibrary : FSharpAssembly
|
|
|
|
/// This is one way of starting the loading process off. Dependencies are automatically
|
|
/// resolved by calling System.Reflection.Assembly.Load.
|
|
static member FromAssembly : System.Reflection.Assembly -> FSharpAssembly
|
|
|
|
/// This is one way of starting the loading process off.
|
|
static member FromFile : fileName: string (* * loader:System.Func<string,FSharpAssembly> *) -> FSharpAssembly
|
|
|
|
/// Holds the full qualified assembly name
|
|
member QualifiedName: string;
|
|
|
|
/// Return the System.Reflection.Assembly object for the assembly
|
|
member ReflectionAssembly: System.Reflection.Assembly
|
|
|
|
/// Return the System.Reflection.Assembly object for the assembly
|
|
member GetEntity : string -> FSharpEntity
|
|
|
|
/// A hint as to where does the code for the CCU live (e.g what was the tcConfig.implicitIncludeDir at compilation time for this DLL?)
|
|
member CodeLocation: string;
|
|
|
|
/// A handle to the full specification of the contents of the module contained in this Assembly
|
|
member Entities: ReadOnlyCollection<FSharpEntity>
|
|
|
|
and [<Sealed>] FSharpEntity =
|
|
|
|
/// Return the FSharpEntity corresponding to a .NET type
|
|
static member FromType : System.Type -> FSharpEntity
|
|
|
|
/// The name of the type, possibly with `n mangling
|
|
member Name: string;
|
|
|
|
/// Get the fully qualified name of the type or module
|
|
member QualifiedName: string;
|
|
|
|
|
|
/// The declaration location for the type constructor
|
|
member Range: Range;
|
|
|
|
/// Indicates the type is a measure, type or exception abbreviation
|
|
member IsAbbreviation : bool
|
|
|
|
/// Indicates the type is a struct
|
|
member IsStruct : bool
|
|
|
|
|
|
/// Indicates the entity is an F# module definition
|
|
member IsModule: bool;
|
|
|
|
/// Get the generic parameters, possibly including unit-of-measure parameters
|
|
member GenericParameters: ReadOnlyCollection<FSharpGenericParameter>
|
|
|
|
/// Indicates that a module is compiled to a class with the given mangled name. The mangling is reversed during lookup
|
|
member HasFSharpModuleSuffix : bool
|
|
|
|
/// Indicates the entity is a measure definition
|
|
member IsMeasure: bool;
|
|
|
|
/// Indicates an F# exception declaration
|
|
member IsExceptionDeclaration: bool;
|
|
|
|
/// If true, then this is a reference to something in some .NET assembly from another .NET language
|
|
member IsExternal : bool
|
|
|
|
/// Return the System.Type for the type
|
|
///
|
|
/// Raises InvalidOperationException if the type is an abbreviation or has an assembly code representation.
|
|
member GetReflectionType : unit -> System.Type
|
|
|
|
|
|
/// The declared documentation for the type or module
|
|
member XmlDoc: ReadOnlyCollection<string>;
|
|
|
|
/// Indicates the type is implemented through a mapping to IL assembly code. THis is only
|
|
/// true for types in FSharp.Core.dll
|
|
member HasAssemblyCodeRepresentation: bool
|
|
|
|
|
|
/// Indicates the type prefers the "tycon<a,b>" syntax for display etc.
|
|
member UsesPrefixDisplay: bool;
|
|
|
|
/// The declared attributes for the type
|
|
member Attributes: ReadOnlyCollection<FSharpAttribute>;
|
|
|
|
/// Interface implementations - boolean indicates compiler-generated
|
|
member Implements : ReadOnlyCollection<FSharpType>;
|
|
|
|
/// Base type, if any
|
|
member BaseType : FSharpType;
|
|
|
|
|
|
/// Properties, methods etc. with implementations, also values in a module
|
|
member MembersOrValues : ReadOnlyCollection<FSharpMemberOrVal>;
|
|
|
|
member NestedEntities : ReadOnlyCollection<FSharpEntity>
|
|
|
|
/// The fields of the class, struct or enum
|
|
member RecordFields : ReadOnlyCollection<FSharpRecordField>
|
|
|
|
member AbbreviatedType : FSharpType
|
|
|
|
/// The cases of a discriminated union
|
|
member UnionCases : ReadOnlyCollection<FSharpUnionCase>
|
|
|
|
|
|
#if TODO
|
|
/// Indicates the type is implemented as IL assembly code using a closed type in ILDASM syntax
|
|
// NOTE: consider returning a System.Type
|
|
member GetAssemblyCodeRepresentation : unit -> string
|
|
|
|
|
|
// /// Indicates the type is a delegate with the given Invoke signature
|
|
// member TyconDelegateSlotSig : SlotSig option
|
|
|
|
|
|
/// The declared accessibility of the type
|
|
member Accessibility: FSharpAccessibility;
|
|
|
|
/// The declared accessibility of the representation, not taking signatures into account
|
|
member RepresentationAccessibility: FSharpAccessibility;
|
|
#endif
|
|
|
|
|
|
and [<Sealed>] FSharpUnionCase =
|
|
/// Name of the case
|
|
member Name: string;
|
|
/// Range of the name of the case
|
|
member Range : Range
|
|
/// Data carried by the case.
|
|
member Fields: ReadOnlyCollection<FSharpRecordField>;
|
|
/// Return type constructed by the case. Normally exactly the type of the enclosing type, sometimes an abbreviation of it
|
|
member ReturnType: FSharpType;
|
|
/// Name of the case in generated IL code
|
|
member CompiledName: string;
|
|
/// Documentation for the case
|
|
member XmlDoc: ReadOnlyCollection<string>;
|
|
|
|
#if TODO
|
|
/// Indicates the declared visibility of the union constructor, not taking signatures into account
|
|
member Accessibility: FSharpAccessibility;
|
|
#endif
|
|
/// Attributes, attached to the generated static method to make instances of the case
|
|
member Attributes: ReadOnlyCollection<FSharpAttribute>;
|
|
|
|
and [<Sealed>] FSharpRecordField =
|
|
/// Is the field declared in F#?
|
|
member IsMutable: bool;
|
|
/// Documentation for the field
|
|
member XmlDoc: ReadOnlyCollection<string>;
|
|
/// The type of the field, w.r.t. the generic parameters of the enclosing type constructor
|
|
member Type: FSharpType;
|
|
/// Indicates a static field
|
|
member IsStatic: bool;
|
|
/// Indicates a compiler generated field, not visible to Intellisense or name resolution
|
|
member IsCompilerGenerated: bool;
|
|
/// Declaration-location of the field
|
|
member Range: Range;
|
|
/// Attributes attached to generated property
|
|
member PropertyAttributes: ReadOnlyCollection<FSharpAttribute>;
|
|
/// Attributes attached to generated field
|
|
member FieldAttributes: ReadOnlyCollection<FSharpAttribute>;
|
|
/// Name of the field
|
|
member Name : string
|
|
|
|
#if TODO
|
|
/// The default initialization info, for static literals
|
|
member LiteralValue: obj;
|
|
/// Indicates the declared visibility of the field, not taking signatures into account
|
|
member Accessibility: FSharpAccessibility;
|
|
#endif
|
|
|
|
and [<Sealed>] FSharpAccessibility =
|
|
#if TODO
|
|
member IsPublic : bool
|
|
member IsPrivate : bool
|
|
member IsInternal : bool
|
|
#endif
|
|
|
|
and [<Sealed>] FSharpGenericParameter =
|
|
member Name: string
|
|
member Range : Range;
|
|
|
|
/// Is this a measure variable
|
|
member IsMeasure : bool
|
|
|
|
/// The documentation for the type parameter.
|
|
member XmlDoc : ReadOnlyCollection<string>;
|
|
|
|
/// Is this a ^a type variable
|
|
member IsSolveAtCompileTime : bool
|
|
|
|
/// The declared attributes of the type parameter.
|
|
member Attributes: ReadOnlyCollection<FSharpAttribute>;
|
|
|
|
#if TODO
|
|
/// The declared or inferred constraints for the type parameter
|
|
member Constraints: ReadOnlyCollection<FSharpGenericParameterConstraint>;
|
|
#endif
|
|
|
|
|
|
/// An F# discriminated union, as an object model
|
|
and [<Sealed>] FSharpGenericParameterConstraint =
|
|
#if TODO
|
|
/// Indicates a constraint that a type is a subtype of the given type
|
|
member IsCoercesToType : bool
|
|
member GetCoercesToTypeTarget : unit -> FSharpType
|
|
|
|
/// Indicates a default value for an inference type variable should it be netiher generalized nor solved
|
|
member IsDefaultsToType : bool
|
|
member GetDefaultsToTypePriority : unit -> int
|
|
member GetDefaultsToTypeTarget : unit -> FSharpType
|
|
|
|
/// Indicates a constraint that a type has a 'null' value
|
|
member IsSupportsNull : bool
|
|
|
|
/// Indicates a constraint that a type has a member with the given signature
|
|
member IsMayResolveMemberConstraint : bool
|
|
member GetMayResolveMemberConstraintSources : unit -> ReadOnlyCollection<FSharpType>
|
|
member GetMayResolveMemberConstraintMemberName : string
|
|
member GetMayResolveMemberConstraintIsStatc : bool
|
|
member GetMayResolveMemberConstraintArgumentType : unit -> ReadOnlyCollection<FSharpType>
|
|
member GetMayResolveMemberConstraintReturnType : unit -> FSharpType
|
|
|
|
/// Indicates a constraint that a type is a non-Nullable value type
|
|
member IsIsNotNullableValueType : bool
|
|
|
|
/// Indicates a constraint that a type is a reference type
|
|
member IsIsReferenceType : bool
|
|
|
|
/// Indicates a constraint that a type is a simple choice between one of the given ground types. See format.ml
|
|
member IsSimpleChoice : bool
|
|
member GetSimpleChoiceChoices : unit -> ReadOnlyCollection<FSharpType>
|
|
|
|
/// Indicates a constraint that a type has a parameterless constructor
|
|
member IsRequiresDefaultConstructor : bool
|
|
|
|
/// Indicates a constraint that a type is an enum with the given underlying
|
|
member IsIsEnum : bool
|
|
member GetIsEnumUnderlying : unit -> FSharpType
|
|
|
|
/// Indicates a constraint that a type is a delegate from the given tuple of args to the given return type *)
|
|
member IsIsDelegate : bool
|
|
member GetIsDelegateArgumentType : unit -> FSharpType
|
|
member GetIsDelegateReturnType : unit -> FSharpType
|
|
#endif
|
|
|
|
and FSharpInlineAnnotation =
|
|
| PsuedoValue = 3
|
|
/// Indictes the value is inlined but the code for the function still exists, e.g. to satisfy interfaces on objects, but that it is also always inlined
|
|
| AlwaysInline = 2
|
|
| OptionalInline = 1
|
|
| NeverInline = 0
|
|
|
|
and [<Sealed>] FSharpMemberOrVal =
|
|
member Range: Range
|
|
|
|
/// The typars of the member or value
|
|
member GenericParameters: ReadOnlyCollection<FSharpGenericParameter>
|
|
|
|
/// The full type of the member or value when used as a first class value
|
|
member Type: FSharpType
|
|
|
|
/// Is this a compiler generated value
|
|
member IsCompilerGenerated : bool
|
|
|
|
/// Is this a must-inline value
|
|
|
|
member InlineAnnotation : FSharpInlineAnnotation
|
|
|
|
/// Is this a mutable value
|
|
member IsMutable : bool
|
|
|
|
/// Is this a module or member value
|
|
member IsModuleValueOrMember : bool
|
|
|
|
/// Is this an extension member?
|
|
member IsExtensionMember : bool
|
|
|
|
/// Is this an implicit constructor?
|
|
member IsImplicitConstructor : bool
|
|
|
|
/// Is this an F# type function
|
|
member IsTypeFunction : bool
|
|
|
|
/// The member name in compiled code
|
|
member CompiledName: string
|
|
|
|
member CurriedParameterGroups : ReadOnlyCollection<ReadOnlyCollection<FSharpParameter>>
|
|
|
|
member ReturnParameter : FSharpParameter
|
|
|
|
/// Custom attributes attached to the value. These contain references to other values (i.e. constructors in types). Mutable to fixup
|
|
/// these value references after copying a colelction of values.
|
|
member Attributes: ReadOnlyCollection<FSharpAttribute>
|
|
|
|
/// XML documentation attached to a value.
|
|
member XmlDoc: ReadOnlyCollection<string>;
|
|
|
|
|
|
#if TODO
|
|
/// Is this "base" in "base.M(...)"
|
|
member IsBaseValue : bool
|
|
|
|
/// Is this the "x" in "type C() as x = ..."
|
|
member IsConstructorThisValue : bool
|
|
|
|
/// Is this the "x" in "member x.M = ..."
|
|
member IsMemberThisValue : bool
|
|
|
|
/// Is this a [<Literal>] value, and if so what value?
|
|
member LiteralValue : obj // may be null
|
|
|
|
/// How visible is this?
|
|
member Accessibility : FSharpAccessibility
|
|
/// Get the module, type or namespace where this value appears. For
|
|
/// an extension member this is the type being extended
|
|
member ApparentParent: FSharpEntity
|
|
|
|
/// Get the module, type or namespace where this value is compiled
|
|
member ActualParent: FSharpEntity;
|
|
|
|
#endif
|
|
|
|
|
|
and [<Sealed>] FSharpParameter =
|
|
member Name: string
|
|
member Range : Range;
|
|
member Type : FSharpType;
|
|
member Attributes: ReadOnlyCollection<FSharpAttribute>
|
|
|
|
|
|
and [<Sealed>] FSharpType =
|
|
|
|
/// Indicates the type is constructed using a named entity
|
|
member IsNamed : bool
|
|
/// Get the named entity for a type constructed using a named entity
|
|
member NamedEntity : FSharpEntity
|
|
/// Get the generic arguments for a tuple type, a function type or a type constructed using a named entity
|
|
member GenericArguments : ReadOnlyCollection<FSharpType>
|
|
|
|
/// Indicates the type is a tuple type. The GenericArguments property returns the elements of the tuple type.
|
|
member IsTuple : bool
|
|
|
|
/// Indicates the type is a function type. The GenericArguments property returns the domain and range of the function type.
|
|
member IsFunction : bool
|
|
|
|
/// Indicates the type is a variable type, whether declared, generalized or an inference type parameter
|
|
member IsGenericParameter : bool
|
|
/// Get the generic parameter data for a generic parameter type
|
|
member GenericParameter : FSharpGenericParameter
|
|
/// Get the index for a generic parameter type
|
|
member GenericParameterIndex : int
|
|
|
|
|
|
and [<Sealed>] FSharpAttribute =
|
|
member Value : obj
|
|
|
|
member GetReflectionType: unit -> System.Type
|
|
|
|
|
|
|
|
|