open System.Collections.Generic

open Internal.Utilities.Text.Lexing

open Internal.Utilities.Text.Parsing

open FSharp.Compiler.AbstractIL

open FSharp.Compiler.AbstractIL.IL

open FSharp.Compiler.AbstractIL.Internal

open FSharp.Compiler.AbstractIL.Internal.Library

open FSharp.Compiler

open FSharp.Compiler.UnicodeLexing

open FSharp.Compiler.ErrorLogger

open FSharp.Compiler.PrettyNaming

open FSharp.Compiler.Range

let FsiDynamicModulePrefix = "FSI_"

let Root = "Microsoft.FSharp"

let RootPath = IL.splitNamespace Root

let Core = Root + ".Core"

let CorePath = IL.splitNamespace Core

[<Literal>]

let Into = "into"

type XmlDocCollector() =

let mutable savedLines = new ResizeArray<(string * pos)>()

let mutable savedGrabPoints = new ResizeArray<pos>()

let posCompare p1 p2 = if posGeq p1 p2 then 1 else if posEq p1 p2 then 0 else -1

let savedGrabPointsAsArray =

lazy (savedGrabPoints.ToArray() |> Array.sortWith posCompare)

let savedLinesAsArray =

lazy (savedLines.ToArray() |> Array.sortWith (fun (_, p1) (_, p2) -> posCompare p1 p2))

let check() =

assert (not savedLinesAsArray.IsValueCreated && "can't add more XmlDoc elements to XmlDocCollector after extracting first XmlDoc from the overall results" <> "")

member x.AddGrabPoint pos =

check()

savedGrabPoints.Add pos

member x.AddXmlDocLine(line, pos) =

check()

savedLines.Add(line, pos)

member x.LinesBefore grabPointPos =

try

let lines = savedLinesAsArray.Force()

let grabPoints = savedGrabPointsAsArray.Force()

let firstLineIndexAfterGrabPoint = Array.findFirstIndexWhereTrue lines (fun (_, pos) -> posGeq pos grabPointPos)

let grabPointIndex = Array.findFirstIndexWhereTrue grabPoints (fun pos -> posGeq pos grabPointPos)

assert (posEq grabPoints.[grabPointIndex] grabPointPos)

let firstLineIndexAfterPrevGrabPoint =

if grabPointIndex = 0 then

0

else

let prevGrabPointPos = grabPoints.[grabPointIndex-1]

Array.findFirstIndexWhereTrue lines (fun (_, pos) -> posGeq pos prevGrabPointPos)

//printfn "#lines = %d, firstLineIndexAfterPrevGrabPoint = %d, firstLineIndexAfterGrabPoint = %d" lines.Length firstLineIndexAfterPrevGrabPoint firstLineIndexAfterGrabPoint

let lines = lines.[firstLineIndexAfterPrevGrabPoint..firstLineIndexAfterGrabPoint-1] |> Array.rev

if lines.Length = 0 then

[| |]

else

let firstLineNumber = (snd lines.[0]).Line

lines

|> Array.mapi (fun i x -> firstLineNumber - i, x)

|> Array.takeWhile (fun (sequencedLineNumber, (_, pos)) -> sequencedLineNumber = pos.Line)

|> Array.map (fun (_, (lineStr, _)) -> lineStr)

|> Array.rev

with e ->

//printfn "unexpected error in LinesBefore:\n%s" (e.ToString())

[| |]

type XmlDoc =

| XmlDoc of string[]

static member Empty = XmlDocStatics.Empty

member x.NonEmpty = (let (XmlDoc lines) = x in lines.Length <> 0)

static member Merge (XmlDoc lines) (XmlDoc lines') = XmlDoc (Array.append lines lines')

/// This code runs for .XML generation and thus influences cross-project xmldoc tooltips; for within-project tooltips,

/// see XmlDocumentation.fs in the language service

static member Process (XmlDoc lines) =

let rec processLines (lines: string list) =

match lines with

| [] -> []

| (lineA :: rest) as lines ->

let lineAT = lineA.TrimStart([|' '|])

if lineAT = "" then processLines rest

else if lineAT.StartsWithOrdinal("<") then lines

else ["<summary>"] @

(lines |> List.map (fun line -> Microsoft.FSharp.Core.XmlAdapters.escape line)) @

["</summary>"]

let lines = processLines (Array.toList lines)

if isNil lines then XmlDoc.Empty

else XmlDoc (Array.ofList lines)

and XmlDocStatics() =

static let empty = XmlDoc[| |]

static member Empty = empty

type PreXmlDoc =

| PreXmlMerge of PreXmlDoc * PreXmlDoc

| PreXmlDoc of pos * XmlDocCollector

| PreXmlDocEmpty

member x.ToXmlDoc() =

match x with

| PreXmlMerge(a, b) -> XmlDoc.Merge (a.ToXmlDoc()) (b.ToXmlDoc())

| PreXmlDocEmpty -> XmlDoc.Empty

| PreXmlDoc (pos, collector) ->

let lines = collector.LinesBefore pos

if lines.Length = 0 then XmlDoc.Empty

else XmlDoc lines

static member CreateFromGrabPoint(collector: XmlDocCollector, grabPointPos) =

collector.AddGrabPoint grabPointPos

PreXmlDoc(grabPointPos, collector)

static member Empty = PreXmlDocEmpty

static member Merge a b = PreXmlMerge (a, b)

type ParserDetail =

| Ok

| ThereWereSignificantParseErrorsSoDoNotTypecheckThisNode // would cause spurious/misleading diagnostics

type Ident (text: string, range: range) =

member x.idText = text

member x.idRange = range

override x.ToString() = text

type LongIdent = Ident list

type LongIdentWithDots =

/// LongIdentWithDots(lid, dotms)

/// Typically dotms.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 dotms.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)

| LongIdentWithDots of id: LongIdent * dotms: range list

member this.Range =

match this with

| LongIdentWithDots([], _) -> failwith "rangeOfLidwd"

| LongIdentWithDots([id], []) -> id.idRange

| LongIdentWithDots([id], [m]) -> unionRanges id.idRange m

| LongIdentWithDots(h :: t, []) -> unionRanges h.idRange (List.last t).idRange

| LongIdentWithDots(h :: t, dotms) -> unionRanges h.idRange (List.last t).idRange |> unionRanges (List.last dotms)

member this.Lid = match this with LongIdentWithDots(lid, _) -> lid

member this.ThereIsAnExtraDotAtTheEnd = match this with LongIdentWithDots(lid, dots) -> lid.Length = dots.Length

member this.RangeSansAnyExtraDot =

match this with

| LongIdentWithDots([], _) -> failwith "rangeOfLidwd"

| LongIdentWithDots([id], _) -> id.idRange

| LongIdentWithDots(h :: t, dotms) ->

let nonExtraDots = if dotms.Length = t.Length then dotms else List.truncate t.Length dotms

unionRanges h.idRange (List.last t).idRange |> unionRanges (List.last nonExtraDots)

type TyparStaticReq =

| NoStaticReq

| HeadTypeStaticReq

type SynTypar =

| Typar of ident: Ident * staticReq: TyparStaticReq * isCompGen: bool

member this.Range =

match this with

| Typar(id, _, _) ->

id.idRange

[<NoEquality; NoComparison; RequireQualifiedAccess>]

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

SynConst =

/// F# syntax: ()

| Unit

/// F# syntax: true, false

| Bool of bool

/// F# syntax: 13y, 0xFFy, 0o077y, 0b0111101y

| SByte of sbyte

/// F# syntax: 13uy, 0x40uy, 0oFFuy, 0b0111101uy

| Byte of byte

/// F# syntax: 13s, 0x4000s, 0o0777s, 0b0111101s

| Int16 of int16

/// F# syntax: 13us, 0x4000us, 0o0777us, 0b0111101us

| UInt16 of uint16

/// F# syntax: 13, 0x4000, 0o0777

| Int32 of int32

/// F# syntax: 13u, 0x4000u, 0o0777u

| UInt32 of uint32

/// F# syntax: 13L

| Int64 of int64

/// F# syntax: 13UL

| UInt64 of uint64

/// F# syntax: 13n

| IntPtr of int64

/// F# syntax: 13un

| UIntPtr of uint64

/// F# syntax: 1.30f, 1.40e10f etc.

| Single of single

/// F# syntax: 1.30, 1.40e10 etc.

| Double of double

/// F# syntax: 'a'

| Char of char

/// F# syntax: 23.4M

| Decimal of System.Decimal

/// UserNum(value, suffix)

///

/// F# syntax: 1Q, 1Z, 1R, 1N, 1G

| UserNum of value: string * suffix: string

/// F# syntax: verbatim or regular string, e.g. "abc"

| String of text: string * range: range

/// F# syntax: verbatim or regular byte string, e.g. "abc"B.

///

/// Also used internally in the typechecker once an array of unit16 constants

/// is detected, to allow more efficient processing of large arrays of uint16 constants.

| Bytes of bytes: byte[] * range: range

/// Used internally in the typechecker once an array of unit16 constants

/// is detected, to allow more efficient processing of large arrays of uint16 constants.

| UInt16s of uint16[]

/// Old comment: "we never iterate, so the const here is not another SynConst.Measure"

| Measure of constant: SynConst * SynMeasure

member c.Range dflt =

match c with

| SynConst.String (_, m0) | SynConst.Bytes (_, m0) -> m0

| _ -> dflt

[<NoEquality; NoComparison; RequireQualifiedAccess>]

/// The unchecked abstract syntax tree of F# unit of measure annotations.

/// This should probably be merged with the representation of SynType.

SynMeasure =

| Named of longId: LongIdent * range: range

| Product of SynMeasure * SynMeasure * range: range

| Seq of SynMeasure list * range: range

| Divide of SynMeasure * SynMeasure * range: range

| Power of SynMeasure * SynRationalConst * range: range

| One

| Anon of range: range

| Var of SynTypar * range: range

[<NoEquality; NoComparison; RequireQualifiedAccess>]

/// The unchecked abstract syntax tree of F# unit of measure exponents.

SynRationalConst =

| Integer of int32

| Rational of int32 * int32 * range: range

| Negate of SynRationalConst

type SynAccess =

| Public

| Internal

| Private

type SequencePointInfoForTarget =

| SequencePointAtTarget

| SuppressSequencePointAtTarget

type SequencePointInfoForSeq =

| SequencePointsAtSeq

// This means "suppress a in 'a;b'" and "suppress b in 'a before b'"

| SuppressSequencePointOnExprOfSequential

// This means "suppress b in 'a;b'" and "suppress a in 'a before b'"

| SuppressSequencePointOnStmtOfSequential

type SequencePointInfoForTry =

| SequencePointAtTry of range: range

// Used for "use" and "for"

| SequencePointInBodyOfTry

| NoSequencePointAtTry

type SequencePointInfoForWith =

| SequencePointAtWith of range: range

| NoSequencePointAtWith

type SequencePointInfoForFinally =

| SequencePointAtFinally of range: range

| NoSequencePointAtFinally

type SequencePointInfoForForLoop =

| SequencePointAtForLoop of range: range

| NoSequencePointAtForLoop

type SequencePointInfoForWhileLoop =

| SequencePointAtWhileLoop of range: range

| NoSequencePointAtWhileLoop

type SequencePointInfoForBinding =

| SequencePointAtBinding of range: range

// Indicates the omission of a sequence point for a binding for a 'do expr'

| NoSequencePointAtDoBinding

// Indicates the omission of a sequence point for a binding for a 'let e = expr' where

// 'expr' has immediate control flow

| NoSequencePointAtLetBinding

// Indicates the omission of a sequence point for a compiler generated binding

// where we've done a local expansion of some construct into something that involves

// a 'let'. e.g. we've inlined a function and bound its arguments using 'let'

// The let bindings are 'sticky' in that the inversion of the inlining would involve

// replacing the entire expression with the original and not just the let bindings alone.

| NoSequencePointAtStickyBinding

// Given 'let v = e1 in e2', where this is a compiler generated binding,

// we are sometimes forced to generate a sequence point for the expression anyway based on its

// overall range. If the let binding is given the flag below then it is asserting that

// the binding has no interesting side effects and can be totally ignored and the range

// of the inner expression is used instead

| NoSequencePointAtInvisibleBinding

// Don't drop sequence points when combining sequence points

member x.Combine(y: SequencePointInfoForBinding) =

match x, y with

| SequencePointAtBinding _ as g, _ -> g

| _, (SequencePointAtBinding _ as g) -> g

| _ -> x

type SeqExprOnly =

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

| SeqExprOnly of bool

type BlockSeparator = range * pos option

type RecordFieldName = LongIdentWithDots * bool

type ExprAtomicFlag =

/// Says that the expression is an atomic expression, i.e. is of a form that 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.

| Atomic = 0

| NonAtomic = 1

type SynBindingKind =

/// A standalone expression in a module

| StandaloneExpression

/// A normal 'let' binding in a module

| NormalBinding

/// A 'do' binding in a module. Must have type 'unit'

| DoBinding

[<NoEquality; NoComparison>]

/// Represents the explicit declaration of a type parameter

SynTyparDecl =

| TyparDecl of attributes: SynAttributes * SynTypar

[<NoEquality; NoComparison>]

/// The unchecked abstract syntax tree of F# type constraints

SynTypeConstraint =

/// F# syntax: is 'typar: struct

| WhereTyparIsValueType of genericName: SynTypar * range: range

/// F# syntax: is 'typar: not struct

| WhereTyparIsReferenceType of genericName: SynTypar * range: range

/// F# syntax is 'typar: unmanaged

| WhereTyparIsUnmanaged of genericName: SynTypar * range: range

/// F# syntax is 'typar: null

| WhereTyparSupportsNull of genericName: SynTypar * range: range

/// F# syntax is 'typar: comparison

| WhereTyparIsComparable of genericName: SynTypar * range: range

/// F# syntax is 'typar: equality

| WhereTyparIsEquatable of genericName: SynTypar * range: range

/// F# syntax is default ^T: type

| WhereTyparDefaultsToType of genericName: SynTypar * typeName: SynType * range: range

/// F# syntax is 'typar :> type

| WhereTyparSubtypeOfType of genericName: SynTypar * typeName: SynType * range: range

/// F# syntax is ^T: (static member MemberName: ^T * int -> ^T)

| WhereTyparSupportsMember of genericNames: SynType list * memberSig: SynMemberSig * range: range

/// F# syntax is 'typar: enum<'UnderlyingType>

| WhereTyparIsEnum of genericName: SynTypar * SynType list * range: range

/// F# syntax is 'typar: delegate<'Args, unit>

| WhereTyparIsDelegate of genericName: SynTypar * SynType list * range: range

[<NoEquality; NoComparison;RequireQualifiedAccess>]

/// The unchecked abstract syntax tree of F# types

SynType =

/// F# syntax: A.B.C

| LongIdent of longDotId: LongIdentWithDots

/// App(typeName, LESSm, typeArgs, commasm, GREATERm, isPostfix, m)

///

/// F# syntax: type<type, ..., type> or type type or (type, ..., type) type

/// isPostfix: indicates a postfix type application e.g. "int list" or "(int, string) dict"

/// commasm: ranges for interstitial commas, these only matter for parsing/design-time tooling, the typechecker may munge/discard them

| App of typeName: SynType * LESSrange: range option * typeArgs: SynType list * commaRanges: range list * GREATERrange: range option * isPostfix: bool * range: range

/// LongIdentApp(typeName, longId, LESSm, tyArgs, commasm, GREATERm, wholem)

///

/// F# syntax: type.A.B.C<type, ..., type>

/// commasm: ranges for interstitial commas, these only matter for parsing/design-time tooling, the typechecker may munge/discard them

| LongIdentApp of typeName: SynType * longDotId: LongIdentWithDots * LESSRange: range option * typeArgs: SynType list * commaRanges: range list * GREATERrange: range option * range: range

/// F# syntax: type * ... * type

/// F# syntax: struct (type * ... * type)

// the bool is true if / rather than * follows the type

| Tuple of isStruct: bool * typeNames:(bool*SynType) list * range: range

/// F# syntax: {| id: type; ...; id: type |}

/// F# syntax: struct {| id: type; ...; id: type |}

| AnonRecd of isStruct: bool * typeNames:(Ident * SynType) list * range: range

/// F# syntax: type[]

| Array of int * elementType: SynType * range: range

/// F# syntax: type -> type

| Fun of argType: SynType * returnType: SynType * range: range

/// F# syntax: 'Var

| Var of genericName: SynTypar * range: range

/// F# syntax: _

| Anon of range: range

/// F# syntax: typ with constraints

| WithGlobalConstraints of typeName: SynType * constraints: SynTypeConstraint list * range: range

/// F# syntax: #type

| HashConstraint of SynType * range: range

/// F# syntax: for units of measure e.g. m / s

| MeasureDivide of dividendType: SynType * divisorType: SynType * range: range

/// F# syntax: for units of measure e.g. m^3, kg^1/2

| MeasurePower of measureType: SynType * SynRationalConst * range: range

/// F# syntax: 1, "abc" etc, used in parameters to type providers

/// For the dimensionless units i.e. 1, and static parameters to provided types

| StaticConstant of constant: SynConst * range: range

/// F# syntax: const expr, used in static parameters to type providers

| StaticConstantExpr of expr: SynExpr * range: range

/// F# syntax: ident=1 etc., used in static parameters to type providers

| StaticConstantNamed of expr: SynType * SynType * range: range

/// Get the syntactic range of source code covered by this construct.

member x.Range =

match x with

| SynType.App (range=m)

| SynType.LongIdentApp (range=m)

| SynType.Tuple (range=m)

| SynType.Array (range=m)

| SynType.AnonRecd (range=m)

| SynType.Fun (range=m)

| SynType.Var (range=m)

| SynType.Anon (range=m)

| SynType.WithGlobalConstraints (range=m)

| SynType.StaticConstant (range=m)

| SynType.StaticConstantExpr (range=m)

| SynType.StaticConstantNamed (range=m)

| SynType.HashConstraint (range=m)

| SynType.MeasureDivide (range=m)

| SynType.MeasurePower (range=m) -> m

| SynType.LongIdent lidwd -> lidwd.Range

[<NoEquality; NoComparison;RequireQualifiedAccess>]

SynExpr =

/// F# syntax: (expr)

///

/// Paren(expr, leftParenRange, rightParenRange, wholeRangeIncludingParentheses)

///

/// Parenthesized expressions. Kept in AST to distinguish A.M((x, y))

/// from A.M(x, y), among other things.

| Paren of expr: SynExpr * leftParenRange: range * rightParenRange: range option * range: range

/// F# syntax: <@ expr @>, <@@ expr @@>

///

/// Quote(operator, isRaw, quotedSynExpr, isFromQueryExpression, m)

| Quote of operator: SynExpr * isRaw: bool * quotedSynExpr: SynExpr * isFromQueryExpression: bool * range: range

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

| Const of constant: SynConst * range: range

/// F# syntax: expr: type

| Typed of expr: SynExpr * typeName: SynType * range: range

/// F# syntax: e1, ..., eN

| Tuple of isStruct: bool * exprs: SynExpr list * commaRanges: range list * range: range // "range list" is for interstitial commas, these only matter for parsing/design-time tooling, the typechecker may munge/discard them

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

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

| AnonRecd of isStruct: bool * copyInfo:(SynExpr * BlockSeparator) option * recordFields:(Ident * SynExpr) list * range: range

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

| ArrayOrList of isList: bool * exprs: SynExpr list * range: range

/// F# syntax: { f1=e1; ...; fn=en }

/// SynExpr.Record ((baseType, baseCtorArgs, mBaseCtor, sepAfterBase, mInherits), (copyExpr, sepAfterCopyExpr), (recordFieldName, fieldValue, sepAfterField), mWholeExpr)

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

| Record of baseInfo:(SynType * SynExpr * range * BlockSeparator option * range) option * copyInfo:(SynExpr * BlockSeparator) option * recordFields:(RecordFieldName * (SynExpr option) * BlockSeparator option) list * range: range

/// F# syntax: new C(...)

/// The flag is true if known to be 'family' ('protected') scope

| New of isProtected: bool * typeName: SynType * expr: SynExpr * range: range

/// SynExpr.ObjExpr (objTy, argOpt, binds, extraImpls, mNewExpr, mWholeExpr)

///

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

| ObjExpr of objType: SynType * argOptions:(SynExpr * Ident option) option * bindings: SynBinding list * extraImpls: SynInterfaceImpl list * newExprRange: range * range: range

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

| While of whileSeqPoint: SequencePointInfoForWhileLoop * whileExpr: SynExpr * doExpr: SynExpr * range: range

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

| For of forSeqPoint: SequencePointInfoForForLoop * ident: Ident * identBody: SynExpr * bool * toBody: SynExpr * doBody: SynExpr * range: range

/// SynExpr.ForEach (spBind, seqExprOnly, isFromSource, pat, enumExpr, bodyExpr, mWholeExpr).

///

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

| ForEach of forSeqPoint: SequencePointInfoForForLoop * seqExprOnly: SeqExprOnly * isFromSource: bool * pat: SynPat * enumExpr: SynExpr * bodyExpr: SynExpr * range: range

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

| ArrayOrListOfSeqExpr of isArray: bool * expr: SynExpr * range: range

/// CompExpr(isArrayOrList, isNotNakedRefCell, expr)

///

/// F# syntax: { expr }

| CompExpr of isArrayOrList: bool * isNotNakedRefCell: bool ref * expr: SynExpr * range: range

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

///

/// F# syntax: fun pat -> expr

| Lambda of fromMethod: bool * inLambdaSeq: bool * args: SynSimplePats * body: SynExpr * range: range

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

| MatchLambda of isExnMatch: bool * range * SynMatchClause list * matchSeqPoint: SequencePointInfoForBinding * range: range

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

| Match of matchSeqPoint: SequencePointInfoForBinding * expr: SynExpr * clauses: SynMatchClause list * range: range (* bool indicates if this is an exception match in a computation expression which throws unmatched exceptions *)

/// F# syntax: do expr

| Do of expr: SynExpr * range: range

/// F# syntax: assert expr

| Assert of expr: SynExpr * range: range

/// App(exprAtomicFlag, isInfix, funcExpr, argExpr, m)

/// - exprAtomicFlag: 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

/// (or more generally, for higher operator fixities, if App(x, y) is such that y comes before x in the source code, then the node is marked isInfix=true)

///

/// F# syntax: f x

| App of ExprAtomicFlag * isInfix: bool * funcExpr: SynExpr * argExpr: SynExpr * range: range

/// TypeApp(expr, mLessThan, types, mCommas, mGreaterThan, mTypeArgs, mWholeExpr)

/// "mCommas" are the ranges for interstitial commas, these only matter for parsing/design-time tooling, the typechecker may munge/discard them

///

/// F# syntax: expr<type1, ..., typeN>

| TypeApp of expr: SynExpr * LESSrange: range * typeNames: SynType list * commaRanges: range list * GREATERrange: range option * typeArgsRange: range * range: range

/// LetOrUse(isRecursive, isUse, bindings, body, wholeRange)

///

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

| LetOrUse of isRecursive: bool * isUse: bool * bindings: SynBinding list * body: SynExpr * range: range

/// F# syntax: try expr with pat -> expr

| TryWith of tryExpr: SynExpr * tryRange: range * withCases: SynMatchClause list * withRange: range * range: range * trySeqPoint: SequencePointInfoForTry * withSeqPoint: SequencePointInfoForWith

/// F# syntax: try expr finally expr

| TryFinally of tryExpr: SynExpr * finallyExpr: SynExpr * range: range * trySeqPoint: SequencePointInfoForTry * finallySeqPoint: SequencePointInfoForFinally

/// F# syntax: lazy expr

| Lazy of SynExpr * range: range

/// Seq(seqPoint, isTrueSeq, e1, e2, m)

/// isTrueSeq: false indicates "let v = a in b; v"

///

/// F# syntax: expr; expr

| Sequential of seqPoint: SequencePointInfoForSeq * isTrueSeq: bool * expr1: SynExpr * expr2: SynExpr * range: range

/// IfThenElse(exprGuard, exprThen, optionalExprElse, spIfToThen, isFromErrorRecovery, mIfToThen, mIfToEndOfLastBranch)

///

/// F# syntax: if expr then expr

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

| IfThenElse of ifExpr: SynExpr * thenExpr: SynExpr * elseExpr: SynExpr option * spIfToThen: SequencePointInfoForBinding * isFromErrorRecovery: bool * ifToThenRange: range * range: range

/// F# syntax: ident

/// Optimized representation, = SynExpr.LongIdent (false, [id], id.idRange)

| Ident of Ident

/// F# syntax: ident.ident...ident

/// LongIdent(isOptional, longIdent, altNameRefCell, m)

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

| LongIdent of isOptional: bool * longDotId: LongIdentWithDots * altNameRefCell: SynSimplePatAlternativeIdInfo ref option * range: range

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

| LongIdentSet of longDotId: LongIdentWithDots * expr: SynExpr * range: range

/// DotGet(expr, rangeOfDot, lid, wholeRange)

///

/// F# syntax: expr.ident.ident

| DotGet of expr: SynExpr * rangeOfDot: range * longDotId: LongIdentWithDots * range: range

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

| DotSet of SynExpr * longDotId: LongIdentWithDots * SynExpr * range: range

/// F# syntax: expr <- expr

| Set of SynExpr * SynExpr * range: range

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

| DotIndexedGet of SynExpr * SynIndexerArg list * range * range: range

/// DotIndexedSet (objectExpr, indexExprs, valueExpr, rangeOfLeftOfSet, rangeOfDot, rangeOfWholeExpr)

///

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

| DotIndexedSet of objectExpr: SynExpr * indexExprs: SynIndexerArg list * valueExpr: SynExpr * leftOfSetRange: range * dotRange: range * range: range

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

| NamedIndexedPropertySet of longDotId: LongIdentWithDots * SynExpr * SynExpr * range: range

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

| DotNamedIndexedPropertySet of SynExpr * longDotId: LongIdentWithDots * SynExpr * SynExpr * range: range

/// F# syntax: expr :? type

| TypeTest of expr: SynExpr * typeName: SynType * range: range

/// F# syntax: expr :> type

| Upcast of expr: SynExpr * typeName: SynType * range: range

/// F# syntax: expr :?> type

| Downcast of expr: SynExpr * typeName: SynType * range: range

/// F# syntax: upcast expr

| InferredUpcast of expr: SynExpr * range: range

/// F# syntax: downcast expr

| InferredDowncast of expr: SynExpr * range: range

/// F# syntax: null

| Null of range: range

/// F# syntax: &expr, &&expr

| AddressOf of isByref: bool * SynExpr * range * range: range

/// F# syntax: ((typar1 or ... or typarN): (member-dig) expr)

| TraitCall of SynTypar list * SynMemberSig * SynExpr * range: range

/// F# syntax: ... in ...

/// Computation expressions only, based on JOIN_IN token from lex filter

| JoinIn of SynExpr * range * SynExpr * range: range

/// F# syntax: <implicit>

/// Computation expressions only, implied by final "do" or "do!"

| ImplicitZero of range: range

/// F# syntax: yield expr

/// F# syntax: return expr

/// Computation expressions only

| YieldOrReturn of (bool * bool) * expr: SynExpr * range: range

/// F# syntax: yield! expr

/// F# syntax: return! expr

/// Computation expressions only

| YieldOrReturnFrom of (bool * bool) * expr: SynExpr * range: range

/// SynExpr.LetOrUseBang (spBind, isUse, isFromSource, pat, rhsExpr, bodyExpr, mWholeExpr).

///

/// F# syntax: let! pat = expr in expr

/// F# syntax: use! pat = expr in expr

/// Computation expressions only

| LetOrUseBang of bindSeqPoint: SequencePointInfoForBinding * isUse: bool * isFromSource: bool * SynPat * SynExpr * SynExpr * range: range

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

| MatchBang of matchSeqPoint: SequencePointInfoForBinding * expr: SynExpr * clauses: SynMatchClause list * range: range (* bool indicates if this is an exception match in a computation expression which throws unmatched exceptions *)

/// F# syntax: do! expr

/// Computation expressions only

| DoBang of expr: SynExpr * range: range

/// Only used in FSharp.Core

| LibraryOnlyILAssembly of ILInstr array * SynType list * SynExpr list * SynType list * range: range (* Embedded IL assembly code *)

/// Only used in FSharp.Core

| LibraryOnlyStaticOptimization of SynStaticOptimizationConstraint list * SynExpr * SynExpr * range: range

/// Only used in FSharp.Core

| LibraryOnlyUnionCaseFieldGet of expr: SynExpr * longId: LongIdent * int * range: range

/// Only used in FSharp.Core

| LibraryOnlyUnionCaseFieldSet of SynExpr * longId: LongIdent * int * SynExpr * range: range

/// Inserted for error recovery

| ArbitraryAfterError of debugStr: string * range: range

/// Inserted for error recovery

| FromParseError of expr: SynExpr * range: range

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

| DiscardAfterMissingQualificationAfterDot of SynExpr * range: range

/// 'use x = fixed expr'

| Fixed of expr: SynExpr * range: range

/// Get the syntactic range of source code covered by this construct.

member e.Range =

match e with

| SynExpr.Paren (_, leftParenRange, rightParenRange, r) ->

match rightParenRange with

| Some rightParenRange when leftParenRange.FileIndex <> rightParenRange.FileIndex -> leftParenRange

| _ -> r

| SynExpr.Quote (range=m)

| SynExpr.Const (range=m)

| SynExpr.Typed (range=m)

| SynExpr.Tuple (range=m)

| SynExpr.AnonRecd (range=m)

| SynExpr.ArrayOrList (range=m)

| SynExpr.Record (range=m)

| SynExpr.New (range=m)

| SynExpr.ObjExpr (range=m)

| SynExpr.While (range=m)

| SynExpr.For (range=m)

| SynExpr.ForEach (range=m)

| SynExpr.CompExpr (range=m)

| SynExpr.ArrayOrListOfSeqExpr (range=m)

| SynExpr.Lambda (range=m)

| SynExpr.Match (range=m)

| SynExpr.MatchLambda (range=m)

| SynExpr.Do (range=m)

| SynExpr.Assert (range=m)

| SynExpr.App (range=m)

| SynExpr.TypeApp (range=m)

| SynExpr.LetOrUse (range=m)

| SynExpr.TryWith (range=m)

| SynExpr.TryFinally (range=m)

| SynExpr.Sequential (range=m)

| SynExpr.ArbitraryAfterError (range=m)

| SynExpr.FromParseError (range=m)

| SynExpr.DiscardAfterMissingQualificationAfterDot (range=m)

| SynExpr.IfThenElse (range=m)

| SynExpr.LongIdent (range=m)

| SynExpr.LongIdentSet (range=m)

| SynExpr.NamedIndexedPropertySet (range=m)

| SynExpr.DotIndexedGet (range=m)

| SynExpr.DotIndexedSet (range=m)

| SynExpr.DotGet (range=m)

| SynExpr.DotSet (range=m)

| SynExpr.Set (range=m)

| SynExpr.DotNamedIndexedPropertySet (range=m)

| SynExpr.LibraryOnlyUnionCaseFieldGet (range=m)

| SynExpr.LibraryOnlyUnionCaseFieldSet (range=m)

| SynExpr.LibraryOnlyILAssembly (range=m)

| SynExpr.LibraryOnlyStaticOptimization (range=m)

| SynExpr.TypeTest (range=m)

| SynExpr.Upcast (range=m)

| SynExpr.AddressOf (range=m)

| SynExpr.Downcast (range=m)

| SynExpr.JoinIn (range=m)

| SynExpr.InferredUpcast (range=m)

| SynExpr.InferredDowncast (range=m)

| SynExpr.Null (range=m)

| SynExpr.Lazy (range=m)

| SynExpr.TraitCall (range=m)

| SynExpr.ImplicitZero (range=m)

| SynExpr.YieldOrReturn (range=m)

| SynExpr.YieldOrReturnFrom (range=m)

| SynExpr.LetOrUseBang (range=m)

| SynExpr.MatchBang (range=m)

| SynExpr.DoBang (range=m)

| SynExpr.Fixed (range=m) -> m

| SynExpr.Ident id -> id.idRange

/// range ignoring any (parse error) extra trailing dots

member e.RangeSansAnyExtraDot =

match e with

| SynExpr.Paren (range=m)

| SynExpr.Quote (range=m)

| SynExpr.Const (range=m)

| SynExpr.Typed (range=m)

| SynExpr.Tuple (range=m)

| SynExpr.ArrayOrList (range=m)

| SynExpr.AnonRecd (range=m)

| SynExpr.Record (range=m)

| SynExpr.New (range=m)

| SynExpr.ObjExpr (range=m)

| SynExpr.While (range=m)

| SynExpr.For (range=m)

| SynExpr.ForEach (range=m)

| SynExpr.CompExpr (range=m)

| SynExpr.ArrayOrListOfSeqExpr (range=m)

| SynExpr.Lambda (range=m)

| SynExpr.Match (range=m)

| SynExpr.MatchLambda (range=m)

| SynExpr.Do (range=m)

| SynExpr.Assert (range=m)

| SynExpr.App (range=m)

| SynExpr.TypeApp (range=m)

| SynExpr.LetOrUse (range=m)

| SynExpr.TryWith (range=m)

| SynExpr.TryFinally (range=m)

| SynExpr.Sequential (range=m)

| SynExpr.ArbitraryAfterError (range=m)

| SynExpr.FromParseError (range=m)

| SynExpr.IfThenElse (range=m)

| SynExpr.LongIdentSet (range=m)

| SynExpr.NamedIndexedPropertySet (range=m)

| SynExpr.DotIndexedGet (range=m)

| SynExpr.DotIndexedSet (range=m)

| SynExpr.DotSet (range=m)

| SynExpr.Set (range=m)

| SynExpr.DotNamedIndexedPropertySet (range=m)

| SynExpr.LibraryOnlyUnionCaseFieldGet (range=m)

| SynExpr.LibraryOnlyUnionCaseFieldSet (range=m)

| SynExpr.LibraryOnlyILAssembly (range=m)

| SynExpr.LibraryOnlyStaticOptimization (range=m)

| SynExpr.TypeTest (range=m)

| SynExpr.Upcast (range=m)

| SynExpr.AddressOf (range=m)

| SynExpr.Downcast (range=m)

| SynExpr.JoinIn (range=m)

| SynExpr.InferredUpcast (range=m)

| SynExpr.InferredDowncast (range=m)

| SynExpr.Null (range=m)

| SynExpr.Lazy (range=m)

| SynExpr.TraitCall (range=m)

| SynExpr.ImplicitZero (range=m)

| SynExpr.YieldOrReturn (range=m)

| SynExpr.YieldOrReturnFrom (range=m)

| SynExpr.LetOrUseBang (range=m)

| SynExpr.MatchBang (range=m)

| SynExpr.DoBang (range=m) -> m

| SynExpr.DotGet (expr, _, lidwd, m) -> if lidwd.ThereIsAnExtraDotAtTheEnd then unionRanges expr.Range lidwd.RangeSansAnyExtraDot else m

| SynExpr.LongIdent (_, lidwd, _, _) -> lidwd.RangeSansAnyExtraDot

| SynExpr.DiscardAfterMissingQualificationAfterDot (expr, _) -> expr.Range

| SynExpr.Fixed (_, m) -> m

| SynExpr.Ident id -> id.idRange

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

member e.RangeOfFirstPortion =

match e with

// haven't bothered making these cases better than just .Range

| SynExpr.Quote (range=m)

| SynExpr.Const (range=m)

| SynExpr.Typed (range=m)

| SynExpr.Tuple (range=m)

| SynExpr.ArrayOrList (range=m)

| SynExpr.AnonRecd (range=m)

| SynExpr.Record (range=m)

| SynExpr.New (range=m)

| SynExpr.ObjExpr (range=m)

| SynExpr.While (range=m)

| SynExpr.For (range=m)

| SynExpr.CompExpr (range=m)

| SynExpr.ArrayOrListOfSeqExpr (range=m)

| SynExpr.Lambda (range=m)

| SynExpr.Match (range=m)

| SynExpr.MatchLambda (range=m)

| SynExpr.Do (range=m)

| SynExpr.Assert (range=m)

| SynExpr.TypeApp (range=m)

| SynExpr.LetOrUse (range=m)

| SynExpr.TryWith (range=m)

| SynExpr.TryFinally (range=m)

| SynExpr.ArbitraryAfterError (range=m)

| SynExpr.FromParseError (range=m)

| SynExpr.DiscardAfterMissingQualificationAfterDot (range=m)

| SynExpr.IfThenElse (range=m)

| SynExpr.LongIdent (range=m)

| SynExpr.LongIdentSet (range=m)

| SynExpr.NamedIndexedPropertySet (range=m)

| SynExpr.DotIndexedGet (range=m)

| SynExpr.DotIndexedSet (range=m)

| SynExpr.DotGet (range=m)

| SynExpr.DotSet (range=m)

| SynExpr.Set (range=m)

| SynExpr.DotNamedIndexedPropertySet (range=m)

| SynExpr.LibraryOnlyUnionCaseFieldGet (range=m)

| SynExpr.LibraryOnlyUnionCaseFieldSet (range=m)

| SynExpr.LibraryOnlyILAssembly (range=m)

| SynExpr.LibraryOnlyStaticOptimization (range=m)

| SynExpr.TypeTest (range=m)

| SynExpr.Upcast (range=m)

| SynExpr.AddressOf (range=m)

| SynExpr.Downcast (range=m)

| SynExpr.JoinIn (range=m)

| SynExpr.InferredUpcast (range=m)

| SynExpr.InferredDowncast (range=m)

| SynExpr.Null (range=m)

| SynExpr.Lazy (range=m)

| SynExpr.TraitCall (range=m)

| SynExpr.ImplicitZero (range=m)

| SynExpr.YieldOrReturn (range=m)

| SynExpr.YieldOrReturnFrom (range=m)

| SynExpr.LetOrUseBang (range=m)

| SynExpr.MatchBang (range=m)

| SynExpr.DoBang (range=m) -> m

// these are better than just .Range, and also commonly applicable inside queries

| SynExpr.Paren (_, m, _, _) -> m

| SynExpr.Sequential (_, _, e1, _, _)

| SynExpr.App (_, _, e1, _, _) ->

e1.RangeOfFirstPortion