Represents the location of the separator block + optional position of the semicolon (used for tooling support)

Represents whether a debug point should be present for a 'let' binding, that is whether the construct corresponds to a debug point in the original source.

Represents whether a debug point should be present for the 'finally' in a 'try .. finally', that is whether the construct corresponds to a debug point in the original source.

Represents whether a debug point should be present for the 'for' in a 'for...' loop, that is whether the construct corresponds to a debug point in the original source.

Represents whether a debug point should be present for the 'in' or 'to' of a 'for...' loop, that is whether the construct corresponds to a debug point in the original source.

Represents a debug point at a leaf expression (e.g. an application or constant).

Represents whether a debug point should be suppressed for either the first or second part of a sequential execution, that is whether the construct corresponds to a debug point in the original source.

Represents whether a debug point should be present for the target of a decision tree, that is whether the construct corresponds to a debug point in the original source.

Represents whether a debug point should be present for a 'try', that is whether the construct corresponds to a debug point in the original source.

Represents whether a debug point should be present for the 'while' in a 'while...' loop, that is whether the construct corresponds to a debug point in the original source.

Represents whether a debug point should be present for the 'with' in a 'try .. with', that is whether the construct corresponds to a debug point in the original source.

Indicates if an expression is an atomic expression. An atomic expression has no whitespace unless enclosed in parentheses, e.g. 1, "3", ident, ident.[expr] and (expr). If an atomic expression has type T, then the largest expression ending at the same range as the atomic expression also has type T.

Represents an identifier in F# code

Represents a long identifier e.g. 'A.B.C'

Represents a parsed hash directive

Represents a parsed hash directive argument

Represents a parsed implementation file made up of fragments

Represents the syntax tree for the contents of a parsed implementation file

Represents the full syntax tree, file name and other parsing information for an implementation file

Represents the syntax tree for a parsed implementation or signature file

Represents a parsed syntax tree for an F# Interactive interaction

Represents a parsed signature file made up of fragments

Represents the syntax tree for the contents of a parsed signature file

Represents the full syntax tree, file name and other parsing information for a signature file

Indicates if the construct arises from error recovery

Some general F# utilities for mangling / unmangling / manipulating names. Anything to do with special names of identifiers and other lexical rules

Represents a qualifying name for anonymous module specifications and implementations,

Represents a record field name plus a flag indicating if given record field name is syntactically correct and can be used in name resolution.

Represents a scoped pragma

Indicates if a for loop is 'for x in e1 -> e2', only valid in sequence expressions

Represents an accessibility modifier in F# syntax

Represents the argument names and other metadata for a parameter for a member or function

Represents a syntax tree for arguments patterns

Represents an attribute

List of attributes enclosed in [< ... >].

Represents a binding for a 'let' or 'member' declaration

The kind associated with a binding - "let", "do" or a standalone expression

Represents the return information in a binding for a 'let' or 'member' declaration

Indicate if the byte string had a special format

Represents the syntax tree associated with the name of a type definition or module in signature or implementation. This includes the name, attributes, type parameters, constraints, documentation and accessibility for a type definition or module. For modules, entries such as the type parameters are always empty.

The unchecked abstract syntax tree of constants in F# types and expressions.

Represents the syntax tree for one case in an enum definition.

Represents the right hand side of an exception declaration 'exception E = ... ' plus any member definitions for the exception

Represents the right hand side of an exception declaration 'exception E = ... '

Represents the right hand side of an exception definition in a signature file

Represents a syntax tree for F# expressions

Represents the syntax tree for a field declaration in a record or class

Represents an identifier with potentially additional trivia information.

Represents a set of bindings that implement an interface

Represents a long identifier with possible '.' at end. Typically dotRanges.Length = lid.Length-1, but they may be same if (incomplete) code ends in a dot, e.g. "Foo.Bar." The dots mostly matter for parsing, and are typically ignored by the typechecker, but if dotRanges.Length = lid.Length, then the parser must have reported an error, so the typechecker is allowed more freedom about typechecking these expressions. LongIdent can be empty list - it is used to denote that name of some AST element is absent (i.e. empty type name in inherit)

Represents a clause in a 'match' expression

Represents an unchecked syntax tree of F# unit of measure annotations.

Represents a definition element within a type definition, e.g. 'member ... '

Represents the flags for a 'member' declaration

Note the member kind is actually computed partially by a syntax tree transformation in tc.fs

Represents the syntax tree for a member signature (used in signature files, abstract member declarations and member constraints)

Represents a definition within a module

Represents the definition of a module or namespace

Represents the kind of a module or namespace definition

Represents the definition of a module or namespace in a signature file

Represents a definition within a module or namespace in a signature file

Represents the target of the open declaration

Represents a syntax tree for an F# pattern

Represents an unchecked syntax tree of F# unit of measure exponents.

Represents the syntactic elements associated with the "return" of a function or method.

Represents a syntax tree for simple F# patterns

Represents the alternative identifier for a simple pattern

Represents a simple set of variable bindings a, (a, b) or (a: Type, b: Type) at a lambda, function definition or other binding point, after the elimination of pattern matching from the construct, e.g. after changing a "function pat1 -> rule1 | ..." to a "fun v -> match v with ..."

Represents a syntax tree for a static optimization constraint in the F# core library

Indicate if the string had a special format

Represents a syntactic type parameter

Represents the explicit declaration of a type parameter

List of type parameter declarations with optional type constraints, enclosed in `< ... >` (postfix) or `( ... )` (prefix), or a single prefix parameter.

Represents a syntax tree for F# types

The unchecked abstract syntax tree of F# type constraints

Represents a type or exception declaration 'type C = ... ' plus any additional member definitions for the type

Represents the kind of a type definition whether explicit or inferred

Represents the right hand side of a type or exception declaration 'type C = ... ' plus any additional member definitions for the type

Represents the syntax tree for a type definition in a signature

Represents the syntax tree for the right-hand-side of a type definition in a signature. Note: in practice, using a discriminated union to make a distinction between "simple" types and "object oriented" types is not particularly useful.

Represents the syntax tree for the core of a simple type definition, in either signature or implementation.

Represents the syntax tree for one case in a union definition.

Represents the syntax tree for the right-hand-side of union definition, excluding members, in either a signature or implementation.

Represents extra information about the declaration of a value

The argument names and other metadata for a member or function

Represents the syntax tree for a 'val' definition in an abstract slot or a signature file

Represents the names and other metadata for the type parameters for a member or function

Represents whether a type parameter has a static requirement or not (^T or 'T)