SyntaxTree.fs

// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.

namespace rec FSharp.Compiler.Syntax

open System
open System.Diagnostics
open FSharp.Compiler.Syntax
open FSharp.Compiler.Text
open FSharp.Compiler.Text.Range
open FSharp.Compiler.Xml
open FSharp.Compiler.SyntaxTrivia

[<Struct; NoEquality; NoComparison; DebuggerDisplay("{idText}")>]
type Ident(text: string, range: range) =
    member _.idText = text
    member _.idRange = range

    member x.MakeSynthetic() =
        if range.IsSynthetic then
            x
        else
            Ident(text, range.MakeSynthetic())

    override _.ToString() = text

type SynIdent =
    | SynIdent of ident: Ident * trivia: IdentTrivia option

    member this.Range =
        match this with
        | SynIdent(ident, trivia) ->
            match trivia with
            | Some value ->
                match value with
                | IdentTrivia.OriginalNotationWithParen(leftParen, _, rightParen)
                | IdentTrivia.HasParenthesis(leftParen, rightParen) -> unionRanges leftParen rightParen
                | _ -> ident.idRange
            | None -> ident.idRange

type LongIdent = Ident list

type SynLongIdent =
    | SynLongIdent of id: LongIdent * dotRanges: range list * trivia: IdentTrivia option list

    member this.Range =
        match this with
        | SynLongIdent([], _, _) -> failwith "rangeOfLid"
        | SynLongIdent([ id ], [], _) -> id.idRange
        | SynLongIdent([ id ], [ m ], _) -> unionRanges id.idRange m
        | SynLongIdent(h :: t, [], _) -> unionRanges h.idRange (List.last t).idRange
        | SynLongIdent(h :: t, dotRanges, _) -> unionRanges h.idRange (List.last t).idRange |> unionRanges (List.last dotRanges)

    member this.LongIdent =
        match this with
        | SynLongIdent(lid, _, _) -> lid

    member this.Dots =
        match this with
        | SynLongIdent(dotRanges = dots) -> dots

    member this.Trivia =
        match this with
        | SynLongIdent(trivia = trivia) -> List.choose id trivia

    member this.IdentsWithTrivia =
        let (SynLongIdent(lid, _, trivia)) = this

        if lid.Length = trivia.Length then
            List.zip lid trivia |> List.map SynIdent
        elif lid.Length > trivia.Length then
            let delta = lid.Length - trivia.Length
            let trivia = [ yield! trivia; yield! List.replicate delta None ]
            List.zip lid trivia |> List.map SynIdent
        else
            failwith "difference between idents and trivia"

    member this.ThereIsAnExtraDotAtTheEnd =
        match this with
        | SynLongIdent(lid, dots, _) -> lid.Length = dots.Length

    member this.RangeWithoutAnyExtraDot =
        match this with
        | SynLongIdent([], _, _) -> failwith "rangeOfLidwd"
        | SynLongIdent([ id ], _, _) -> id.idRange
        | SynLongIdent(h :: t, dotRanges, _) ->
            let nonExtraDots =
                if dotRanges.Length = t.Length then
                    dotRanges
                else
                    List.truncate t.Length dotRanges

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

[<AutoOpen>]
module SynLongIdentHelpers =
    [<Obsolete("Please use SynLongIdent or define a custom active pattern")>]
    let (|LongIdentWithDots|) =
        function
        | SynLongIdent(lid, dots, _) -> lid, dots

    [<Obsolete("Please use SynLongIdent")>]
    let LongIdentWithDots (lid, dots) =
        SynLongIdent(lid, dots, List.replicate lid.Length None)

[<RequireQualifiedAccess>]
type ParserDetail =
    | Ok

    | ErrorRecovery

[<RequireQualifiedAccess>]
type TyparStaticReq =
    | None

    | HeadType

[<NoEquality; NoComparison>]
type SynTypar =
    | SynTypar of ident: Ident * staticReq: TyparStaticReq * isCompGen: bool

    member this.Range =
        match this with
        | SynTypar(id, _, _) -> id.idRange

[<Struct; RequireQualifiedAccess>]
type SynStringKind =
    | Regular
    | Verbatim
    | TripleQuote

[<Struct; RequireQualifiedAccess>]
type SynByteStringKind =
    | Regular
    | Verbatim

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynConst =

    | Unit

    | Bool of bool

    | SByte of sbyte

    | Byte of byte

    | Int16 of int16

    | UInt16 of uint16

    | Int32 of int32

    | UInt32 of uint32

    | Int64 of int64

    | UInt64 of uint64

    | IntPtr of int64

    | UIntPtr of uint64

    | Single of single

    | Double of double

    | Char of char

    | Decimal of Decimal

    | UserNum of value: string * suffix: string

    | String of text: string * synStringKind: SynStringKind * range: range

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

    | UInt16s of uint16[]

    | Measure of constant: SynConst * constantRange: range * synMeasure: SynMeasure * trivia: SynMeasureConstantTrivia

    | SourceIdentifier of constant: string * value: string * range: range

    member c.Range dflt =
        match c with
        | SynConst.String(_, _, m0)
        | SynConst.Bytes(_, _, m0)
        | SynConst.SourceIdentifier(_, _, m0) -> m0
        | _ -> dflt

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynMeasure =

    | Named of longId: LongIdent * range: range

    | Product of measure1: SynMeasure * mAsterisk: range * measure2: SynMeasure * range: range

    | Seq of measures: SynMeasure list * range: range

    | Divide of measure1: SynMeasure option * mSlash: range * measure2: SynMeasure * range: range

    | Power of measure: SynMeasure * caretRange: range * power: SynRationalConst * range: range

    | One of range: range

    | Anon of range: range

    | Var of typar: SynTypar * range: range

    | Paren of measure: SynMeasure * range: range

    member x.Range =
        match x with
        | SynMeasure.Named(range = m)
        | SynMeasure.Product(range = m)
        | SynMeasure.Seq(range = m)
        | SynMeasure.Divide(range = m)
        | SynMeasure.Power(range = m)
        | SynMeasure.One(range = m)
        | SynMeasure.Anon(range = m)
        | SynMeasure.Var(range = m)
        | SynMeasure.Paren(range = m) -> m

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynRationalConst =

    | Integer of value: int32 * range: range

    | Rational of numerator: int32 * numeratorRange: range * divRange: range * denominator: int32 * denominatorRange: range * range: range

    | Negate of rationalConst: SynRationalConst * range: range

    | Paren of rationalConst: SynRationalConst * range: range

[<RequireQualifiedAccess>]
type SynAccess =
    | Public of range: range

    | Internal of range: range

    | Private of range: range

    override this.ToString() =
        match this with
        | Public _ -> "Public"
        | Internal _ -> "Internal"
        | Private _ -> "Private"

    member this.Range: range =
        match this with
        | Public m
        | Internal m
        | Private m -> m

[<RequireQualifiedAccess>]
type DebugPointAtTarget =
    | Yes
    | No

[<RequireQualifiedAccess>]
type DebugPointAtSequential =
    | SuppressNeither
    | SuppressStmt
    | SuppressBoth
    | SuppressExpr

[<RequireQualifiedAccess>]
type DebugPointAtTry =
    | Yes of range: range
    | No

[<RequireQualifiedAccess>]
type DebugPointAtLeafExpr = Yes of range

[<RequireQualifiedAccess>]
type DebugPointAtWith =
    | Yes of range: range
    | No

[<RequireQualifiedAccess>]
type DebugPointAtFinally =
    | Yes of range: range
    | No

[<RequireQualifiedAccess>]
type DebugPointAtFor =
    | Yes of range: range
    | No

[<RequireQualifiedAccess>]
type DebugPointAtInOrTo =
    | Yes of range: range
    | No

[<RequireQualifiedAccess>]
type DebugPointAtWhile =
    | Yes of range: range
    | No

[<RequireQualifiedAccess>]
type DebugPointAtBinding =
    | Yes of range: range
    | NoneAtDo
    | NoneAtLet
    | NoneAtSticky
    | NoneAtInvisible

    member x.Combine(y: DebugPointAtBinding) =
        match x, y with
        | DebugPointAtBinding.Yes _ as g, _ -> g
        | _, (DebugPointAtBinding.Yes _ as g) -> g
        | _ -> x

type SeqExprOnly = SeqExprOnly of bool

type BlockSeparator = range * pos option

type RecordFieldName = SynLongIdent * bool

type ExprAtomicFlag =
    | Atomic = 0
    | NonAtomic = 1

[<RequireQualifiedAccess>]
type SynBindingKind =

    // Indicates 'expr' in a module, via ElimSynModuleDeclExpr
    | StandaloneExpression

    | Normal

    // Covers 'do expr' in class or let-rec but not in a module.
    //
    // Note, in a module 'expr' corresponds to SynModuleDecl.Expr
    // Note, in a module 'do expr' corresponds to SynModuleDecl.Expr with expression SynExpr.Do
    // These are eliminated to bindings with 'StandaloneExpression' by ElimSynModuleDeclExpr
    | Do

[<NoEquality; NoComparison>]
type SynTyparDecl =
    | SynTyparDecl of attributes: SynAttributes * typar: SynTypar * intersectionConstraints: SynType list * trivia: SynTyparDeclTrivia

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynTypeConstraint =

    | WhereTyparIsValueType of typar: SynTypar * range: range

    | WhereTyparIsReferenceType of typar: SynTypar * range: range

    | WhereTyparIsUnmanaged of typar: SynTypar * range: range

    | WhereTyparSupportsNull of typar: SynTypar * range: range

    | WhereTyparNotSupportsNull of genericName: SynTypar * range: range * trivia: SynTypeConstraintWhereTyparNotSupportsNullTrivia

    | WhereTyparIsComparable of typar: SynTypar * range: range

    | WhereTyparIsEquatable of typar: SynTypar * range: range

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

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

    | WhereTyparSupportsMember of typars: SynType * memberSig: SynMemberSig * range: range

    | WhereTyparIsEnum of typar: SynTypar * typeArgs: SynType list * range: range

    | WhereTyparIsDelegate of typar: SynTypar * typeArgs: SynType list * range: range

    | WhereSelfConstrained of selfConstraint: SynType * range: range

    member x.Range =
        match x with
        | WhereTyparIsValueType(range = range)
        | WhereTyparIsReferenceType(range = range)
        | WhereTyparIsUnmanaged(range = range)
        | WhereTyparSupportsNull(range = range)
        | WhereTyparNotSupportsNull(range = range)
        | WhereTyparIsComparable(range = range)
        | WhereTyparIsEquatable(range = range)
        | WhereTyparDefaultsToType(range = range)
        | WhereTyparSubtypeOfType(range = range)
        | WhereTyparSupportsMember(range = range)
        | WhereTyparIsEnum(range = range)
        | WhereTyparIsDelegate(range = range) -> range
        | WhereSelfConstrained(range = range) -> range

[<RequireQualifiedAccess>]
type SynTyparDecls =
    | PostfixList of decls: SynTyparDecl list * constraints: SynTypeConstraint list * range: range
    | PrefixList of decls: SynTyparDecl list * range: range
    | SinglePrefix of decl: SynTyparDecl * range: range

    member x.TyparDecls =
        match x with
        | PostfixList(decls = decls)
        | PrefixList(decls = decls) -> decls
        | SinglePrefix(decl, _) -> [ decl ]

    member x.Constraints =
        match x with
        | PostfixList(decls = decls; constraints = constraints) ->
            // Synthesize SynTypeConstraints implied with any intersection constraints in SynTyparDecl
            // The parser makes sure we're only dealing with hash constraints here
            let intersectionConstraints =
                decls
                |> List.collect (fun (SynTyparDecl(typar = tp; intersectionConstraints = tys)) ->
                    tys
                    |> List.map (fun ty ->
                        let ty =
                            match ty with
                            | SynType.HashConstraint(ty, _) -> ty
                            | _ -> ty

                        SynTypeConstraint.WhereTyparSubtypeOfType(tp, ty, ty.Range)))

            List.append intersectionConstraints constraints
        | _ -> []

    member x.Range =
        match x with
        | PostfixList(range = range)
        | PrefixList(range = range)
        | SinglePrefix(range = range) -> range

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynTupleTypeSegment =
    | Type of typeName: SynType
    | Star of range: range
    | Slash of range: range

    member this.Range =
        match this with
        | SynTupleTypeSegment.Type t -> t.Range
        | SynTupleTypeSegment.Star(range = range)
        | SynTupleTypeSegment.Slash(range = range) -> range

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynType =

    | LongIdent of longDotId: SynLongIdent

    | App of
        typeName: SynType *
        lessRange: range option *
        typeArgs: SynType list *
        commaRanges: range list *  // interstitial commas
        greaterRange: range option *
        isPostfix: bool *
        range: range

    | LongIdentApp of
        typeName: SynType *
        longDotId: SynLongIdent *
        lessRange: range option *
        typeArgs: SynType list *
        commaRanges: range list *  // interstitial commas
        greaterRange: range option *
        range: range

    | Tuple of isStruct: bool * path: SynTupleTypeSegment list * range: range

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

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

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

    | Var of typar: SynTypar * range: range

    | Anon of range: range

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

    | HashConstraint of innerType: SynType * range: range

    | MeasurePower of baseMeasure: SynType * exponent: SynRationalConst * range: range

    | StaticConstant of constant: SynConst * range: range

    | StaticConstantNull of range: range

    | StaticConstantExpr of expr: SynExpr * range: range

    | StaticConstantNamed of ident: SynType * value: SynType * range: range

    | WithNull of innerType: SynType * ambivalent: bool * range: range * trivia: SynTypeWithNullTrivia

    | Paren of innerType: SynType * range: range

    | SignatureParameter of attributes: SynAttributes * optional: bool * id: Ident option * usedType: SynType * range: range

    | Or of lhsType: SynType * rhsType: SynType * range: range * trivia: SynTypeOrTrivia

    | FromParseError of range: range

    | Intersection of typar: SynTypar option * types: SynType list * range: range * trivia: SynTyparDeclTrivia

    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.StaticConstantNull(range = m)
        | SynType.StaticConstantExpr(range = m)
        | SynType.StaticConstantNamed(range = m)
        | SynType.HashConstraint(range = m)
        | SynType.WithNull(range = m)
        | SynType.MeasurePower(range = m)
        | SynType.Paren(range = m)
        | SynType.SignatureParameter(range = m)
        | SynType.Or(range = m)
        | SynType.Intersection(range = m)
        | SynType.FromParseError(range = m) -> m
        | SynType.LongIdent lidwd -> lidwd.Range

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynExpr =

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

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

    | Const of constant: SynConst * range: range

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

    | Tuple of
        isStruct: bool *
        exprs: SynExpr list *
        commaRanges: range list *  // interstitial commas
        range: range

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

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

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

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

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

    | While of whileDebugPoint: DebugPointAtWhile * whileExpr: SynExpr * doExpr: SynExpr * range: range

    | For of
        forDebugPoint: DebugPointAtFor *
        toDebugPoint: DebugPointAtInOrTo *
        ident: Ident *
        equalsRange: range option *
        identBody: SynExpr *
        direction: bool *
        toBody: SynExpr *
        doBody: SynExpr *
        range: range

    | ForEach of
        forDebugPoint: DebugPointAtFor *
        inDebugPoint: DebugPointAtInOrTo *
        seqExprOnly: SeqExprOnly *
        isFromSource: bool *
        pat: SynPat *
        enumExpr: SynExpr *
        bodyExpr: SynExpr *
        range: range

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

    | IndexRange of expr1: SynExpr option * opm: range * expr2: SynExpr option * range1: range * range2: range * range: range

    | IndexFromEnd of expr: SynExpr * range: range

    | ComputationExpr of hasSeqBuilder: bool * expr: SynExpr * range: range

    | Lambda of
        fromMethod: bool *
        inLambdaSeq: bool *
        args: SynSimplePats *
        body: SynExpr *
        parsedData: (SynPat list * SynExpr) option *
        range: range *
        trivia: SynExprLambdaTrivia

    | MatchLambda of
        isExnMatch: bool *
        keywordRange: range *
        matchClauses: SynMatchClause list *
        matchDebugPoint: DebugPointAtBinding *
        range: range

    | Match of
        matchDebugPoint: DebugPointAtBinding *
        expr: SynExpr *
        clauses: SynMatchClause list *
        range: range *
        trivia: SynExprMatchTrivia

    | Do of expr: SynExpr * range: range

    | Assert of expr: SynExpr * range: range

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

    | TypeApp of
        expr: SynExpr *
        lessRange: range *
        typeArgs: SynType list *
        commaRanges: range list *
        greaterRange: range option *
        typeArgsRange: range *
        range: range

    | TryWith of
        tryExpr: SynExpr *
        withCases: SynMatchClause list *
        range: range *
        tryDebugPoint: DebugPointAtTry *
        withDebugPoint: DebugPointAtWith *
        trivia: SynExprTryWithTrivia

    | TryFinally of
        tryExpr: SynExpr *
        finallyExpr: SynExpr *
        range: range *
        tryDebugPoint: DebugPointAtTry *
        finallyDebugPoint: DebugPointAtFinally *
        trivia: SynExprTryFinallyTrivia

    | Lazy of expr: SynExpr * range: range

    | Sequential of
        debugPoint: DebugPointAtSequential *
        isTrueSeq: bool *
        expr1: SynExpr *
        expr2: SynExpr *
        range: range *
        trivia: SynExprSequentialTrivia

    | IfThenElse of
        ifExpr: SynExpr *
        thenExpr: SynExpr *
        elseExpr: SynExpr option *
        spIfToThen: DebugPointAtBinding *
        isFromErrorRecovery: bool *
        range: range *
        trivia: SynExprIfThenElseTrivia

    | Typar of typar: SynTypar * range: range

    | Ident of ident: Ident

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

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

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

    | DotLambda of expr: SynExpr * range: range * trivia: SynExprDotLambdaTrivia

    | DotSet of targetExpr: SynExpr * longDotId: SynLongIdent * rhsExpr: SynExpr * range: range

    | Set of targetExpr: SynExpr * rhsExpr: SynExpr * range: range

    | DotIndexedGet of objectExpr: SynExpr * indexArgs: SynExpr * dotRange: range * range: range

    | DotIndexedSet of
        objectExpr: SynExpr *
        indexArgs: SynExpr *
        valueExpr: SynExpr *
        leftOfSetRange: range *
        dotRange: range *
        range: range

    | NamedIndexedPropertySet of longDotId: SynLongIdent * expr1: SynExpr * expr2: SynExpr * range: range

    | DotNamedIndexedPropertySet of targetExpr: SynExpr * longDotId: SynLongIdent * argExpr: SynExpr * rhsExpr: SynExpr * range: range

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

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

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

    | InferredUpcast of expr: SynExpr * range: range

    | InferredDowncast of expr: SynExpr * range: range

    | Null of range: range

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

    | TraitCall of supportTys: SynType * traitSig: SynMemberSig * argExpr: SynExpr * range: range

    | JoinIn of lhsExpr: SynExpr * lhsRange: range * rhsExpr: SynExpr * range: range

    | ImplicitZero of range: range

    | SequentialOrImplicitYield of debugPoint: DebugPointAtSequential * expr1: SynExpr * expr2: SynExpr * ifNotStmt: SynExpr * range: range

    | YieldOrReturn of flags: (bool * bool) * expr: SynExpr * range: range * trivia: SynExprYieldOrReturnTrivia

    | YieldOrReturnFrom of flags: (bool * bool) * expr: SynExpr * range: range * trivia: SynExprYieldOrReturnFromTrivia

    | LetOrUse of SynLetOrUse

    | MatchBang of
        matchDebugPoint: DebugPointAtBinding *
        expr: SynExpr *
        clauses: SynMatchClause list *
        range: range *
        trivia: SynExprMatchBangTrivia

    | DoBang of expr: SynExpr * range: range * trivia: SynExprDoBangTrivia

    | WhileBang of whileDebugPoint: DebugPointAtWhile * whileExpr: SynExpr * doExpr: SynExpr * range: range

    | LibraryOnlyILAssembly of
        ilCode: obj *  // this type is ILInstr[]  but is hidden to avoid the representation of AbstractIL being public
        typeArgs: SynType list *
        args: SynExpr list *
        retTy: SynType list *
        range: range

    | LibraryOnlyStaticOptimization of
        constraints: SynStaticOptimizationConstraint list *
        expr: SynExpr *
        optimizedExpr: SynExpr *
        range: range

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

    | LibraryOnlyUnionCaseFieldSet of expr: SynExpr * longId: LongIdent * fieldNum: int * rhsExpr: SynExpr * range: range

    | ArbitraryAfterError of debugStr: string * range: range

    | FromParseError of expr: SynExpr * range: range

    | DiscardAfterMissingQualificationAfterDot of expr: SynExpr * dotRange: range * range: range

    | Fixed of expr: SynExpr * range: range

    | InterpolatedString of contents: SynInterpolatedStringPart list * synStringKind: SynStringKind * range: range

    | DebugPoint of debugPoint: DebugPointAtLeafExpr * isControlFlow: bool * innerExpr: SynExpr

    | Dynamic of funcExpr: SynExpr * qmark: range * argExpr: SynExpr * range: range

    member e.Range =
        match e with
        | SynExpr.Paren(range = m)
        | 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.ComputationExpr(range = m)
        | SynExpr.ArrayOrListComputed(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.SequentialOrImplicitYield(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.DotLambda(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.IndexRange(range = m)
        | SynExpr.IndexFromEnd(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.MatchBang(range = m)
        | SynExpr.DoBang(range = m)
        | SynExpr.WhileBang(range = m)
        | SynExpr.Fixed(range = m)
        | SynExpr.InterpolatedString(range = m)
        | SynExpr.Dynamic(range = m) -> m
        | SynExpr.Ident id -> id.idRange
        | SynExpr.Typar(range = m) -> m
        | SynExpr.DebugPoint(_, _, innerExpr) -> innerExpr.Range

    member e.RangeWithoutAnyExtraDot =
        match e with
        | SynExpr.DiscardAfterMissingQualificationAfterDot(expr, _, _) -> expr.Range
        | _ -> e.Range

    member e.RangeOfFirstPortion =
        match e with
        // these are better than just .Range, and also commonly applicable inside queries
        | SynExpr.Paren(_, m, _, _) -> m
        | SynExpr.Sequential(expr1 = e1)
        | SynExpr.SequentialOrImplicitYield(expr1 = e1)
        | SynExpr.App(funcExpr = e1) -> e1.RangeOfFirstPortion
        | SynExpr.ForEach(pat = pat; range = r) ->
            let e = (pat.Range: range).Start
            withEnd e r
        | _ -> e.Range

    member this.IsArbExprAndThusAlreadyReportedError =
        match this with
        | SynExpr.ArbitraryAfterError _ -> true
        | _ -> false

[<NoEquality; NoComparison>]
type SynExprRecordField =
    | SynExprRecordField of
        fieldName: RecordFieldName *
        equalsRange: range option *
        expr: SynExpr option *
        range: range *
        blockSeparator: BlockSeparator option

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynInterpolatedStringPart =
    | String of value: string * range: range
    | FillExpr of fillExpr: SynExpr * qualifiers: Ident option

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynSimplePat =
    | Id of
        ident: Ident *
        altNameRefCell: SynSimplePatAlternativeIdInfo ref option *
        isCompilerGenerated: bool *
        isThisVal: bool *
        isOptional: bool *
        range: range

    | Typed of pat: SynSimplePat * targetType: SynType * range: range

    | Attrib of pat: SynSimplePat * attributes: SynAttributes * range: range

    member x.Range =
        match x with
        | SynSimplePat.Id(range = range)
        | SynSimplePat.Typed(range = range)
        | SynSimplePat.Attrib(range = range) -> range

[<RequireQualifiedAccess>]
type SynSimplePatAlternativeIdInfo =

    | Undecided of Ident

    | Decided of Ident

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynStaticOptimizationConstraint =

    | WhenTyparTyconEqualsTycon of typar: SynTypar * rhsType: SynType * range: range

    | WhenTyparIsStruct of typar: SynTypar * range: range

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynSimplePats =
    | SimplePats of pats: SynSimplePat list * commaRanges: range list * range: range

    member x.Range =
        match x with
        | SynSimplePats.SimplePats(range = range) -> range

[<NoEquality; NoComparison>]
type NamePatPairField =
    | NamePatPairField of
        fieldName: SynLongIdent *
        equalsRange: range option *
        range: range *
        pat: SynPat *
        blockSeparator: BlockSeparator option

    member this.FieldName =
        match this with
        | NamePatPairField(fieldName = n) -> n

    member this.Range =
        match this with
        | NamePatPairField(range = m) -> m

    member this.Pattern =
        match this with
        | NamePatPairField(pat = pat) -> pat

[<RequireQualifiedAccess>]
type SynArgPats =
    | Pats of pats: SynPat list

    | NamePatPairs of pats: NamePatPairField list * range: range * trivia: SynArgPatsNamePatPairsTrivia

    member x.Patterns =
        match x with
        | Pats pats -> pats
        | NamePatPairs(pats = pats) -> pats |> List.map _.Pattern

[<NoEquality; NoComparison; RequireQualifiedAccess>]
type SynPat =

    | Const of constant: SynConst * range: range

    | Wild of range: range

    | Named of ident: SynIdent * isThisVal: bool * accessibility: SynAccess option * range: range

    | Typed of pat: SynPat * targetType: SynType * range: range

    | Attrib of pat: SynPat * attributes: SynAttributes * range: range

    | Or of lhsPat: SynPat * rhsPat: SynPat * range: range * trivia: SynPatOrTrivia

    | ListCons of lhsPat: SynPat * rhsPat: SynPat * range: range * trivia: SynPatListConsTrivia

    | Ands of pats: SynPat list * range: range

    | As of lhsPat: SynPat * rhsPat: SynPat * range: range

    | LongIdent of
        longDotId: SynLongIdent *
        extraId: Ident option *  // holds additional ident for tooling
        typarDecls: SynValTyparDecls option *  // usually None: temporary used to parse "f<'a> x = x"
        argPats: SynArgPats *
        accessibility: SynAccess option *
        range: range

    | Tuple of isStruct: bool * elementPats: SynPat list * commaRanges: range list * range: range

    | Paren of pat: SynPat * range: range

    | ArrayOrList of isArray: bool * elementPats: SynPat list * range: range

    | Record of fieldPats: NamePatPairField list * range: range

    | Null of range: range

    | OptionalVal of ident: Ident * range: range

    | IsInst of pat: SynType * range: range

    | QuoteExpr of expr: SynExpr * range: range

    | InstanceMember of
        thisId: Ident *