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 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

Holds operations for working with the untyped abstract syntax tree (ParsedInput).

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 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

Holds operations for working with SyntaxNodes in the untyped abstract syntax tree (AST).

Represents a major syntax node in the untyped abstract syntax tree.

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 one or two access modifier(s) in a property signature

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)