F# syntax: &expr, &&expr

F# syntax: {| id1=e1; ...; idN=eN |} F# syntax: struct {| id1=e1; ...; idN=eN |}

F# syntax: f x flag: indicates if the application is syntactically atomic, e.g. f.[1] is atomic, but 'f x' is not isInfix is true for the first app of an infix operator, e.g. 1+2 becomes App(App(+, 1), 2), where the inner node is marked isInfix

Inserted for error recovery

F# syntax: [ e1; ...; en ], [| e1; ...; en |]

F# syntax: [ expr ], [| expr |]

F# syntax: assert expr

F# syntax: { expr }

F# syntax: 1, 1.3, () etc.

Debug points arising from computation expressions

Inserted for error recovery when there is "expr." and missing tokens or error recovery after the dot

F# syntax: do expr

F# syntax: do! expr Computation expressions only

F# syntax: expr.ident.ident

F# syntax: expr.[expr, ..., expr]

F# syntax: expr.[expr, ..., expr] <- expr

F# syntax: _.ident.ident

F# syntax: expr.Items (e1) <- e2, rarely used named-property-setter notation, e.g. (stringExpr).Chars(3) <- 'a'

F# syntax: expr.ident...ident <- expr

F# syntax: expr :?> type

F# syntax: f?x

'use x = fixed expr'

F# syntax: 'for i = ... to ... do ...'

F# syntax: 'for ... in ... do ...'

Inserted for error recovery

F# syntax: ident Optimized representation for SynExpr.LongIdent (false, [id], id.idRange)

F# syntax: if expr then expr F# syntax: if expr then expr else expr

Used in parser error recovery and internally during type checking for translating computation expressions.

F# syntax: ^expr, used for from-end-of-collection indexing and ^T.Operation

F# syntax: expr.. F# syntax: ..expr F# syntax: expr..expr F# syntax: * A two-element range indexer argument a..b, a.., ..b. Also used to represent a range in a list, array or sequence expression.

F# syntax: downcast expr

F# syntax: upcast expr

F# syntax: interpolated string, e.g. "abc{x}" or "abc{x,3}" or "abc{x:N4}" Note the string ranges include the quotes, verbatim markers, dollar sign and braces

F# syntax: ... in ... Computation expressions only, based on JOIN_IN token from lex filter

First bool indicates if lambda originates from a method. Patterns here are always "simple" Second bool indicates if this is a "later" part of an iterated sequence of lambdas parsedData keeps original parsed patterns and expression, prior to transforming to "simple" patterns and iterated lambdas F# syntax: fun pat -> expr

F# syntax: lazy expr

F# syntax: let pat = expr in expr F# syntax: let f pat1 .. patN = expr in expr F# syntax: let rec f pat1 .. patN = expr in expr F# syntax: use pat = expr in expr

F# syntax: let! pat = expr in expr F# syntax: use! pat = expr in expr F# syntax: let! pat = expr and! ... and! ... and! pat = expr in expr Computation expressions only

Only used in FSharp.Core

Only used in FSharp.Core

Only used in FSharp.Core

Only used in FSharp.Core

F# syntax: ident.ident...ident isOptional: true if preceded by a '?' for an optional named parameter altNameRefCell: Normally 'None' except for some compiler-generated variables in desugaring pattern matching. See SynSimplePat.Id

F# syntax: ident.ident...ident <- expr

F# syntax: match expr with pat1 -> expr | ... | patN -> exprN

F# syntax: match! expr with pat1 -> expr | ... | patN -> exprN

F# syntax: function pat1 -> expr | ... | patN -> exprN

F# syntax: Type.Items(e1) <- e2, rarely used named-property-setter notation, e.g. Foo.Bar.Chars(3) <- 'a'

F# syntax: new C(...) The flag is true if known to be 'family' ('protected') scope

F# syntax: null

F# syntax: { new ... with ... }

F# syntax: (expr) Parenthesized expressions. Kept in AST to distinguish A.M((x, y)) from A.M(x, y), among other things.

F# syntax: <@ expr @>, <@@ expr @@> Quote(operator, isRaw, quotedSynExpr, isFromQueryExpression, m)

F# syntax: { f1=e1; ...; fn=en } inherit includes location of separator (for tooling) copyOpt contains range of the following WITH part (for tooling) every field includes range of separator after the field (for tooling)

Used internally during type checking for translating computation expressions.

F# syntax: expr <- expr

F# syntax: ((type1 or ... or typeN): (member-dig) expr)

F# syntax: try expr finally expr

F# syntax: try expr with pat -> expr

F# syntax: e1, ..., eN

F# syntax: 'T (for 'T.ident).

F# syntax: expr

F# syntax: expr :? type

F# syntax: expr: type

F# syntax: expr :> type

F# syntax: 'while ... do ...'

F# syntax: 'while! ... do ...'

F# syntax: yield expr F# syntax: return expr Computation expressions only

F# syntax: yield! expr F# syntax: return! expr Computation expressions only

Indicates if this expression arises from error recovery

Gets the syntax range of this construct

Attempt to get the range of the first token or initial portion only - this is ad-hoc, just a cheap way to improve a certain 'query custom operation' error range