From 5988cb9ef472a2a635f09b9e83ce6c9a31389b7a Mon Sep 17 00:00:00 2001 From: nojaf Date: Sat, 27 Feb 2021 13:14:56 +0100 Subject: [PATCH 1/8] Return Node list from AstTransformer.fs. --- src/Fantomas/AstTransformer.fs | 1312 +++++++++++++++----------------- src/Fantomas/Trivia.fs | 19 +- 2 files changed, 622 insertions(+), 709 deletions(-) diff --git a/src/Fantomas/AstTransformer.fs b/src/Fantomas/AstTransformer.fs index d10ebcd571..6e840b5954 100644 --- a/src/Fantomas/AstTransformer.fs +++ b/src/Fantomas/AstTransformer.fs @@ -4,11 +4,11 @@ open FSharp.Compiler.Text open FSharp.Compiler.SyntaxTree open Fantomas.TriviaTypes -let rec (|Sequentials|_|) = - function - | SynExpr.Sequential (_, isTrueSeq, e, Sequentials es, range) -> Some((isTrueSeq, e, None, range) :: es) - | SynExpr.Sequential (_, isTrueSeq, e1, e2, range) -> Some [ isTrueSeq, e1, Some e2, range ] - | _ -> None +//let rec (|Sequentials|_|) = +// function +// | SynExpr.Sequential (_, isTrueSeq, e, Sequentials es, range) -> Some((isTrueSeq, e, None, range) :: es) +// | SynExpr.Sequential (_, isTrueSeq, e1, e2, range) -> Some [ isTrueSeq, e1, Some e2, range ] +// | _ -> None type Id = { Ident: string; Range: Range option } @@ -18,7 +18,7 @@ type Node = { Type: FsAstType Range: Range option Properties: Map - Childs: Node list + // Childs: Node list FsAstNode: FsAstNode } module Helpers = @@ -40,9 +40,9 @@ module Helpers = module private Ast = open Helpers - let rec visit (ast: SynModuleOrNamespace) : Node = visitSynModuleOrNamespace ast + let rec visit (ast: SynModuleOrNamespace) : Node list = visitSynModuleOrNamespace ast - and visitSynModuleOrNamespace (modOrNs: SynModuleOrNamespace) : Node = + and visitSynModuleOrNamespace (modOrNs: SynModuleOrNamespace) : Node list = match modOrNs with | SynModuleOrNamespace (longIdent, isRecursive, synModuleOrNamespaceKind, decls, _, attrs, access, range) -> let collectIdents (idents: LongIdent) = @@ -52,8 +52,7 @@ module private Ast = { Type = Ident_ Range = r ident.idRange Properties = Map.empty - FsAstNode = ident - Childs = [] }) + FsAstNode = ident }) let typeName = match synModuleOrNamespaceKind with @@ -62,7 +61,6 @@ module private Ast = | SynModuleOrNamespaceKind.DeclaredNamespace -> SynModuleOrNamespace_DeclaredNamespace | SynModuleOrNamespaceKind.GlobalNamespace -> SynModuleOrNamespace_GlobalNamespace - { Type = typeName Range = r range Properties = @@ -73,58 +71,55 @@ module private Ast = yield "longIdent" ==> li longIdent if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = modOrNs - Childs = - [ yield! - if synModuleOrNamespaceKind = SynModuleOrNamespaceKind.DeclaredNamespace then - collectIdents longIdent - else - [] - yield! (visitSynAttributeLists range attrs) - yield! (decls |> List.map visitSynModuleDecl) ] } - - and visitSynModuleDecl (ast: SynModuleDecl) : Node = + FsAstNode = modOrNs } + :: [ yield! + if synModuleOrNamespaceKind = SynModuleOrNamespaceKind.DeclaredNamespace then + collectIdents longIdent + else + [] + yield! (visitSynAttributeLists range attrs) + yield! (decls |> List.collect visitSynModuleDecl) ] + + and visitSynModuleDecl (ast: SynModuleDecl) : Node list = match ast with | SynModuleDecl.ModuleAbbrev (ident, longIdent, range) -> - { Type = SynModuleDecl_ModuleAbbrev - Range = r range - Properties = - p [ "ident" ==> i ident - "longIdent" ==> li longIdent ] - FsAstNode = ast - Childs = [] } + [ { Type = SynModuleDecl_ModuleAbbrev + Range = r range + Properties = + p [ "ident" ==> i ident + "longIdent" ==> li longIdent ] + FsAstNode = ast } ] | SynModuleDecl.NestedModule (sci, isRecursive, decls, _, range) -> { Type = SynModuleDecl_NestedModule Range = r range Properties = p [ "isRecursive" ==> isRecursive ] - FsAstNode = ast - Childs = - [ yield visitSynComponentInfo sci - yield! (decls |> List.map visitSynModuleDecl) ] } + FsAstNode = ast } + :: [ yield! visitSynComponentInfo sci + yield! (decls |> List.collect visitSynModuleDecl) ] | SynModuleDecl.Let (_, bindings, range) -> { Type = SynModuleDecl_Let Range = r range Properties = p [] - FsAstNode = ast - Childs = bindings |> List.map visitSynBinding } + FsAstNode = ast } + :: (bindings |> List.collect visitSynBinding) | SynModuleDecl.DoExpr (_, expr, range) -> { Type = SynModuleDecl_DoExpr Range = r range Properties = p [] - FsAstNode = ast - Childs = [ visitSynExpr expr ] } + FsAstNode = ast } + :: visitSynExpr expr | SynModuleDecl.Types (typeDefs, range) -> { Type = SynModuleDecl_Types Range = r range Properties = p [] - FsAstNode = ast - Childs = typeDefs |> List.map visitSynTypeDefn } + FsAstNode = ast } + :: (typeDefs |> List.collect visitSynTypeDefn) | SynModuleDecl.Exception (exceptionDef, range) -> { Type = SynModuleDecl_Exception Range = r range Properties = p [] - FsAstNode = ast - Childs = [ visitSynExceptionDefn exceptionDef ] } + FsAstNode = ast } + :: (visitSynExceptionDefn exceptionDef) | SynModuleDecl.Open (target, parentRange) -> // we use the parent ranges here to match up with the trivia parsed match target with @@ -132,34 +127,34 @@ module private Ast = { Type = SynModuleDecl_Open Range = r parentRange Properties = p [ "longIdent" ==> li longIdent ] - FsAstNode = ast - Childs = [] } + FsAstNode = ast } + |> List.singleton | SynOpenDeclTarget.Type (synType, _range) -> { Type = SynModuleDecl_OpenType Range = r parentRange Properties = p [] - FsAstNode = ast - Childs = [ visitSynType synType ] } + FsAstNode = ast } + :: (visitSynType synType) | SynModuleDecl.Attributes (attrs, range) -> { Type = SynModuleDecl_Attributes Range = r range Properties = p [] - FsAstNode = ast - Childs = visitSynAttributeLists range attrs } + FsAstNode = ast } + :: (visitSynAttributeLists range attrs) | SynModuleDecl.HashDirective (hash, range) -> - { Type = SynModuleDecl_HashDirective - Range = r range - Properties = p [] - FsAstNode = ast - Childs = [ visitParsedHashDirective hash ] } + [ { Type = SynModuleDecl_HashDirective + Range = r range + Properties = p [] + FsAstNode = ast } + visitParsedHashDirective hash ] | SynModuleDecl.NamespaceFragment (moduleOrNamespace) -> { Type = SynModuleDecl_NamespaceFragment Range = noRange Properties = p [] - FsAstNode = ast - Childs = [ visitSynModuleOrNamespace moduleOrNamespace ] } + FsAstNode = ast } + :: (visitSynModuleOrNamespace moduleOrNamespace) - and visitSynExpr (synExpr: SynExpr) : Node = + and visitSynExpr (synExpr: SynExpr) : Node list = match synExpr with | SynExpr.Paren (expr, leftParenRange, rightParenRange, range) -> { Type = SynExpr_Paren @@ -168,155 +163,146 @@ module private Ast = p [ yield "leftParenRange" ==> r leftParenRange if rightParenRange.IsSome then yield "rightParenRange" ==> r rightParenRange.Value ] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.Quote (operator, isRaw, quotedSynExpr, isFromQueryExpression, range) -> { Type = SynExpr_Quote Range = r range Properties = p [ "isRaw" ==> isRaw "isFromQueryExpression" ==> isFromQueryExpression ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr operator - yield visitSynExpr quotedSynExpr ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr operator + yield! visitSynExpr quotedSynExpr ] | SynExpr.Const (constant, range) -> - { Type = SynExpr_Const - Range = r range - Properties = p [] - FsAstNode = synExpr - Childs = [ visitSynConst range constant ] } + [ { Type = SynExpr_Const + Range = r range + Properties = p [] + FsAstNode = synExpr } + visitSynConst range constant ] | SynExpr.Typed (expr, typeName, range) -> { Type = SynExpr_Typed Range = r range Properties = p [] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr - yield visitSynType typeName ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr + yield! visitSynType typeName ] | SynExpr.Tuple (isStruct, exprs, commaRanges, range) -> { Type = SynExpr_Tuple Range = r range Properties = p [ "isStruct" ==> isStruct "commaRanges" ==> (commaRanges |> List.map r) ] - FsAstNode = synExpr - Childs = [ yield! exprs |> List.map visitSynExpr ] } + FsAstNode = synExpr } + :: (exprs |> List.collect visitSynExpr) | SynExpr.ArrayOrList (isList, exprs, range) -> { Type = SynExpr_ArrayOrList Range = r range Properties = p [ "isList" ==> isList ] - FsAstNode = synExpr - Childs = [ yield! exprs |> List.map visitSynExpr ] } + FsAstNode = synExpr } + :: (exprs |> List.collect visitSynExpr) | SynExpr.Record (_, _, recordFields, range) -> { Type = SynExpr_Record Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield! recordFields |> List.map visitRecordField ] } + FsAstNode = synExpr } + :: (List.collect visitRecordField recordFields) | SynExpr.AnonRecd (_, _, recordFields, range) -> { Type = SynExpr_AnonRecd Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield! recordFields |> List.map visitAnonRecordField ] } + FsAstNode = synExpr } + :: (List.collect visitAnonRecordField recordFields) | SynExpr.New (isProtected, typeName, expr, range) -> { Type = SynExpr_New Range = r range Properties = p [ "isProtected" ==> isProtected ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr - yield visitSynType typeName ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr + yield! visitSynType typeName ] | SynExpr.ObjExpr (objType, argOptions, bindings, extraImpls, newExprRange, range) -> { Type = SynExpr_ObjExpr Range = r range Properties = p [ "newExprRange" ==> r newExprRange ] - FsAstNode = synExpr - Childs = - [ yield visitSynType objType - if argOptions.IsSome then - yield visitArgsOption argOptions.Value - yield! extraImpls |> List.map visitSynInterfaceImpl - yield! bindings |> List.map visitSynBinding ] } + FsAstNode = synExpr } + :: [ yield! visitSynType objType + if argOptions.IsSome then + yield! visitArgsOption argOptions.Value + yield! extraImpls |> List.collect visitSynInterfaceImpl + yield! bindings |> List.collect visitSynBinding ] | SynExpr.While (_, whileExpr, doExpr, range) -> { Type = SynExpr_While Range = r range Properties = p [] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr whileExpr - yield visitSynExpr doExpr ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr whileExpr + yield! visitSynExpr doExpr ] | SynExpr.For (_, ident, identBody, _, toBody, doBody, range) -> { Type = SynExpr_For Range = r range Properties = p [ "ident" ==> i ident ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr identBody - yield visitSynExpr toBody - yield visitSynExpr doBody ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr identBody + yield! visitSynExpr toBody + yield! visitSynExpr doBody ] | SynExpr.ForEach (_, (SeqExprOnly seqExprOnly), isFromSource, pat, enumExpr, bodyExpr, range) -> { Type = SynExpr_ForEach Range = r range Properties = p [ "isFromSource" ==> isFromSource "seqExprOnly" ==> seqExprOnly ] - FsAstNode = synExpr - Childs = - [ yield visitSynPat pat - yield visitSynExpr enumExpr - yield visitSynExpr bodyExpr ] } + FsAstNode = synExpr } + :: [ yield! visitSynPat pat + yield! visitSynExpr enumExpr + yield! visitSynExpr bodyExpr ] | SynExpr.ArrayOrListOfSeqExpr (isArray, expr, range) -> { Type = SynExpr_ArrayOrListOfSeqExpr Range = r range Properties = p [ "isArray" ==> isArray ] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.CompExpr (isArrayOrList, isNotNakedRefCell, expr, range) -> { Type = SynExpr_CompExpr Range = r range Properties = p [ "isArrayOrList" ==> isArrayOrList "isNotNakedRefCell" ==> isNotNakedRefCell ] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.Lambda (fromMethod, inLambdaSeq, args, body, _parsedData, range) -> { Type = SynExpr_Lambda Range = r range Properties = p [ "fromMethod" ==> fromMethod "inLambdaSeq" ==> inLambdaSeq ] - FsAstNode = synExpr - Childs = - [ yield visitSynSimplePats args - yield visitSynExpr body ] } + FsAstNode = synExpr } + :: [ yield! visitSynSimplePats args + yield! visitSynExpr body ] | SynExpr.MatchLambda (isExnMatch, _, matchClauses, _, range) -> { Type = SynExpr_MatchLambda Range = r range Properties = p [ "isExnMatch" ==> isExnMatch ] - FsAstNode = synExpr - Childs = [ yield! matchClauses |> List.map visitSynMatchClause ] } + FsAstNode = synExpr } + :: (List.collect visitSynMatchClause matchClauses) | SynExpr.Match (_, expr, clauses, range) -> { Type = SynExpr_Match Range = r range Properties = p [] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr - yield! clauses |> List.map visitSynMatchClause ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr + yield! clauses |> List.collect visitSynMatchClause ] | SynExpr.Do (expr, range) -> { Type = SynExpr_Do Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.Assert (expr, range) -> { Type = SynExpr_Assert Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.App (atomicFlag, isInfix, funcExpr, argExpr, range) -> { Type = SynExpr_App Range = r range @@ -326,10 +312,9 @@ module private Ast = | ExprAtomicFlag.Atomic -> "Atomic" | _ -> "Not Atomic") "isInfix" ==> isInfix ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr funcExpr - yield visitSynExpr argExpr ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr funcExpr + yield! visitSynExpr argExpr ] | SynExpr.TypeApp (expr, lESSrange, typeNames, commaRanges, gREATERrange, typeArgsRange, range) -> { Type = SynExpr_TypeApp Range = r range @@ -339,112 +324,103 @@ module private Ast = if gREATERrange.IsSome then yield "gREATERrange" ==> r gREATERrange.Value yield "typeArgsRange" ==> r typeArgsRange ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr - yield! typeNames |> List.map visitSynType ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr + yield! typeNames |> List.collect visitSynType ] | SynExpr.LetOrUse (isRecursive, isUse, bindings, body, range) -> { Type = SynExpr_LetOrUse Range = r range Properties = p [ "isRecursive" ==> isRecursive "isUse" ==> isUse ] - FsAstNode = synExpr - Childs = - [ yield! bindings |> List.map visitSynBinding - yield visitSynExpr body ] } + FsAstNode = synExpr } + :: [ yield! bindings |> List.collect visitSynBinding + yield! visitSynExpr body ] | SynExpr.TryWith (tryExpr, tryRange, withCases, withRange, range, _, _) -> { Type = SynExpr_TryWith Range = r range Properties = p [ "tryRange" ==> r tryRange "withRange" ==> r withRange ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr tryExpr - yield! withCases |> List.map visitSynMatchClause ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr tryExpr + yield! withCases |> List.collect visitSynMatchClause ] | SynExpr.TryFinally (tryExpr, finallyExpr, range, _, _) -> { Type = SynExpr_TryFinally Range = r range Properties = p [] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr tryExpr - yield visitSynExpr finallyExpr ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr tryExpr + yield! visitSynExpr finallyExpr ] | SynExpr.Lazy (ex, range) -> { Type = SynExpr_Lazy Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield visitSynExpr ex ] } - | Sequentials xs -> - let rec cons xs = - match xs with - | [] -> failwith "should not happen" // expr2Opt is always Some in last item - | ((isTrueSeq, expr1, expr2Opt, range) :: rest) -> - { Type = SynExpr_Sequential - Range = r range - Properties = p [ "isTrueSeq" ==> isTrueSeq ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr1 - yield - expr2Opt - |> Option.map visitSynExpr - |> Option.defaultWith (fun () -> cons rest) ] } - - cons xs + FsAstNode = synExpr } + :: (visitSynExpr ex) + // | Sequentials xs -> +// let rec cons xs = +// match xs with +// | [] -> failwith "should not happen" // expr2Opt is always Some in last item +// | ((isTrueSeq, expr1, expr2Opt, range) :: rest) -> +// { Type = SynExpr_Sequential +// Range = r range +// Properties = p [ "isTrueSeq" ==> isTrueSeq ] +// FsAstNode = synExpr +// Childs = +// [ yield visitSynExpr expr1 +// yield +// expr2Opt +// |> Option.map visitSynExpr +// |> Option.defaultWith (fun () -> cons rest) ] } +// +// cons xs | SynExpr.Sequential (_, isTrueSeq, expr1, expr2, range) -> { Type = SynExpr_Sequential Range = r range Properties = p [ "isTrueSeq" ==> isTrueSeq ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr1 - yield visitSynExpr expr2 ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr1 + yield! visitSynExpr expr2 ] | SynExpr.SequentialOrImplicitYield (seqPoint, expr1, expr2, ifNotStmt, range) -> { Type = SynExpr_SequentialOrImplicitYield Range = r range FsAstNode = synExpr - Properties = p [ "seqPoint" ==> seqPoint ] - Childs = - [ yield visitSynExpr expr1 - yield visitSynExpr expr2 - yield visitSynExpr ifNotStmt ] } + Properties = p [ "seqPoint" ==> seqPoint ] } + :: [ yield! visitSynExpr expr1 + yield! visitSynExpr expr2 + yield! visitSynExpr ifNotStmt ] | SynExpr.IfThenElse (ifExpr, thenExpr, elseExpr, _, isFromErrorRecovery, ifToThenRange, range) -> { Type = SynExpr_IfThenElse Range = r range Properties = p [ "isFromErrorRecovery" ==> isFromErrorRecovery "ifToThenRange" ==> r ifToThenRange ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr ifExpr - yield visitSynExpr thenExpr - if elseExpr.IsSome then - yield visitSynExpr elseExpr.Value ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr ifExpr + yield! visitSynExpr thenExpr + if elseExpr.IsSome then + yield! visitSynExpr elseExpr.Value ] | SynExpr.Ident (id) -> { Type = SynExpr_Ident Range = (i id).Range Properties = p [ "ident" ==> i id ] - FsAstNode = synExpr - Childs = [] } + FsAstNode = synExpr } + |> List.singleton | SynExpr.LongIdent (isOptional, longDotId, _, range) -> - let ids = visitLongIdentWithDots longDotId - { Type = SynExpr_LongIdent Range = r range Properties = p [ "isOptional" ==> isOptional "longDotId" ==> lid longDotId ] - FsAstNode = synExpr - Childs = ids } + FsAstNode = synExpr } + :: (visitLongIdentWithDots longDotId) | SynExpr.LongIdentSet (longDotId, expr, range) -> { Type = SynExpr_LongIdentSet Range = r range Properties = p [ "longDotId" ==> lid longDotId ] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.DotGet (expr, rangeOfDot, longDotId, range) -> // Idents are collected as childs here to deal with unit test ``Fluent api with comments should remain on same lines`` let ids = visitLongIdentWithDots longDotId @@ -454,229 +430,215 @@ module private Ast = Properties = p [ "rangeOfDot" ==> r rangeOfDot "longDotId" ==> lid longDotId ] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr; yield! ids ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr; yield! ids ] | SynExpr.DotSet (expr, longDotId, e2, range) -> { Type = SynExpr_DotSet Range = r range Properties = p [ "longDotId" ==> lid longDotId ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr - yield visitSynExpr e2 ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr + yield! visitSynExpr e2 ] | SynExpr.Set (e1, e2, range) -> { Type = SynExpr_Set Range = r range Properties = p [] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr e1 - yield visitSynExpr e2 ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr e1 + yield! visitSynExpr e2 ] | SynExpr.DotIndexedGet (objectExpr, indexExprs, dotRange, range) -> { Type = SynExpr_DotIndexedGet Range = r range Properties = p [ "dotRange" ==> r dotRange ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr objectExpr - yield! indexExprs |> List.map visitSynIndexerArg ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr objectExpr + yield! indexExprs |> List.collect visitSynIndexerArg ] | SynExpr.DotIndexedSet (objectExpr, indexExprs, valueExpr, leftOfSetRange, dotRange, range) -> { Type = SynExpr_DotIndexedSet Range = r range Properties = p [ "leftOfSetRange" ==> r leftOfSetRange "dotRange" ==> r dotRange ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr objectExpr - yield! indexExprs |> List.map visitSynIndexerArg - yield visitSynExpr valueExpr ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr objectExpr + yield! indexExprs |> List.collect visitSynIndexerArg + yield! visitSynExpr valueExpr ] | SynExpr.NamedIndexedPropertySet (longDotId, e1, e2, range) -> { Type = SynExpr_NamedIndexedPropertySet Range = r range Properties = p [ "longDotId" ==> lid longDotId ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr e1 - yield visitSynExpr e2 ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr e1 + yield! visitSynExpr e2 ] | SynExpr.DotNamedIndexedPropertySet (expr, longDotId, e1, e2, range) -> { Type = SynExpr_DotNamedIndexedPropertySet Range = r range Properties = p [ "longDotId" ==> lid longDotId ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr - yield visitSynExpr e1 - yield visitSynExpr e2 ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr + yield! visitSynExpr e1 + yield! visitSynExpr e2 ] | SynExpr.TypeTest (expr, typeName, range) -> { Type = SynExpr_TypeTest Range = r range Properties = p [] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr - yield visitSynType typeName ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr + yield! visitSynType typeName ] | SynExpr.Upcast (expr, typeName, range) -> { Type = SynExpr_Upcast Range = r range Properties = p [] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr - yield visitSynType typeName ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr + yield! visitSynType typeName ] | SynExpr.Downcast (expr, typeName, range) -> { Type = SynExpr_Downcast Range = r range Properties = p [] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr - yield visitSynType typeName ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr + yield! visitSynType typeName ] | SynExpr.InferredUpcast (expr, range) -> { Type = SynExpr_InferredUpcast Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.InferredDowncast (expr, range) -> { Type = SynExpr_InferredDowncast Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.Null (range) -> { Type = SynExpr_Null Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [] } + FsAstNode = synExpr } + |> List.singleton | SynExpr.AddressOf (isByref, expr, refRange, range) -> { Type = SynExpr_AddressOf Range = r range Properties = p [ "isByref" ==> isByref "refRange" ==> r refRange ] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.TraitCall (typars, sign, expr, range) -> { Type = SynExpr_TraitCall Range = r range Properties = p [] - FsAstNode = synExpr - Childs = - [ yield! typars |> List.map visitSynTypar - yield visitSynMemberSig sign - yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: [ yield! typars |> List.collect visitSynTypar + yield! visitSynMemberSig sign + yield! visitSynExpr expr ] | SynExpr.JoinIn (expr, inrange, expr2, range) -> { Type = SynExpr_JoinIn Range = r range Properties = p [ "inRange" ==> r inrange ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr - yield visitSynExpr expr2 ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr + yield! visitSynExpr expr2 ] | SynExpr.ImplicitZero (range) -> { Type = SynExpr_ImplicitZero Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [] } + FsAstNode = synExpr } + |> List.singleton | SynExpr.YieldOrReturn (_, expr, range) -> { Type = SynExpr_YieldOrReturn Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.YieldOrReturnFrom (_, expr, range) -> { Type = SynExpr_YieldOrReturnFrom Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.LetOrUseBang (_, isUse, isFromSource, pat, rhsExpr, andBangs, body, range) -> { Type = SynExpr_LetOrUseBang Range = r range Properties = p [ "isUse" ==> isUse "isFromSource" ==> isFromSource ] - FsAstNode = synExpr - Childs = - [ yield visitSynPat pat - yield visitSynExpr rhsExpr - yield! - andBangs - |> List.collect (fun (_, _, _, pat, body, _) -> visitSynPat pat :: [ visitSynExpr body ]) - yield visitSynExpr body ] } + FsAstNode = synExpr } + :: [ yield! visitSynPat pat + yield! visitSynExpr rhsExpr + yield! + andBangs + |> List.collect (fun (_, _, _, pat, body, _) -> visitSynPat pat @ (visitSynExpr body)) + yield! visitSynExpr body ] | SynExpr.MatchBang (_, expr, clauses, range) -> { Type = SynExpr_MatchBang Range = r range Properties = p [] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr expr - yield! clauses |> List.map visitSynMatchClause ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr expr + yield! clauses |> List.collect visitSynMatchClause ] | SynExpr.DoBang (expr, range) -> { Type = SynExpr_DoBang Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.LibraryOnlyILAssembly (_, _, _, _, range) -> { Type = SynExpr_LibraryOnlyILAssembly Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [] } + FsAstNode = synExpr } + |> List.singleton | SynExpr.LibraryOnlyStaticOptimization (_, _, _, range) -> { Type = SynExpr_LibraryOnlyStaticOptimization Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [] } + FsAstNode = synExpr } + |> List.singleton | SynExpr.LibraryOnlyUnionCaseFieldGet (expr, longId, _, range) -> { Type = SynExpr_LibraryOnlyUnionCaseFieldGet Range = r range Properties = p [ "longId" ==> li longId ] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.LibraryOnlyUnionCaseFieldSet (e1, longId, _, e2, range) -> { Type = SynExpr_LibraryOnlyUnionCaseFieldSet Range = r range Properties = p [ "longId" ==> li longId ] - FsAstNode = synExpr - Childs = - [ yield visitSynExpr e1 - yield visitSynExpr e2 ] } + FsAstNode = synExpr } + :: [ yield! visitSynExpr e1 + yield! visitSynExpr e2 ] | SynExpr.ArbitraryAfterError (debugStr, range) -> { Type = SynExpr_ArbitraryAfterError Range = r range Properties = p [ "debugStr" ==> debugStr ] - FsAstNode = synExpr - Childs = [] } + FsAstNode = synExpr } + |> List.singleton | SynExpr.FromParseError (expr, range) -> { Type = SynExpr_FromParseError Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.DiscardAfterMissingQualificationAfterDot (expr, range) -> { Type = SynExpr_DiscardAfterMissingQualificationAfterDot Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.Fixed (expr, range) -> { Type = SynExpr_Fixed Range = r range Properties = p [] - FsAstNode = synExpr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = synExpr } + :: (visitSynExpr expr) | SynExpr.InterpolatedString (parts, range) -> { Type = SynExpr_InterpolatedString Range = r range Properties = p [] - FsAstNode = synExpr - Childs = List.map visitSynInterpolatedStringPart parts } + FsAstNode = synExpr } + :: (List.collect visitSynInterpolatedStringPart parts) and visitSynInterpolatedStringPart (synInterpolatedStringPart: SynInterpolatedStringPart) = match synInterpolatedStringPart with @@ -684,102 +646,99 @@ module private Ast = { Type = SynInterpolatedStringPart_String Range = r range Properties = p [ "value", box value ] - FsAstNode = synInterpolatedStringPart - Childs = [] } + FsAstNode = synInterpolatedStringPart } + |> List.singleton | SynInterpolatedStringPart.FillExpr (expr, ident) -> { Type = SynInterpolatedStringPart_FillExpr Range = None Properties = p [] - FsAstNode = synInterpolatedStringPart - Childs = - [ visitSynExpr expr - yield! (Option.toList ident |> List.map visitIdent) ] } + FsAstNode = synInterpolatedStringPart } + :: [ yield! visitSynExpr expr + yield! (Option.toList ident |> List.map visitIdent) ] and visitRecordField ((longId, _) as rfn: RecordFieldName, expr: SynExpr option, _: BlockSeparator option) = { Type = RecordField_ Range = r longId.Range Properties = p [ "ident" ==> lid longId ] - FsAstNode = rfn - Childs = - [ if expr.IsSome then - yield visitSynExpr expr.Value ] } + FsAstNode = rfn } + :: (match expr with + | Some e -> visitSynExpr e + | None -> []) and visitAnonRecordField (ident: Ident, expr: SynExpr) = { Type = AnonRecordField_ Range = noRange Properties = p [ "ident" ==> i ident ] - FsAstNode = expr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = expr } + :: (visitSynExpr expr) and visitAnonRecordTypeField (ident: Ident, t: SynType) = { Type = AnonRecordTypeField_ Range = noRange Properties = p [ "ident" ==> i ident ] - FsAstNode = t - Childs = [ yield visitSynType t ] } + FsAstNode = t } + :: (visitSynType t) - and visitSynMemberSig (ms: SynMemberSig) : Node = + and visitSynMemberSig (ms: SynMemberSig) : Node list = match ms with | SynMemberSig.Member (valSig, _, range) -> { Type = SynMemberSig_Member Range = r range Properties = p [] - FsAstNode = ms - Childs = [ yield visitSynValSig valSig ] } + FsAstNode = ms } + :: (visitSynValSig valSig) | SynMemberSig.Interface (typeName, range) -> { Type = SynMemberSig_Interface Range = r range Properties = p [] - FsAstNode = ms - Childs = [ yield visitSynType typeName ] } + FsAstNode = ms } + :: (visitSynType typeName) | SynMemberSig.Inherit (typeName, range) -> { Type = SynMemberSig_Inherit Range = r range Properties = p [] - FsAstNode = ms - Childs = [ yield visitSynType typeName ] } + FsAstNode = ms } + :: (visitSynType typeName) | SynMemberSig.ValField (f, range) -> { Type = SynMemberSig_ValField Range = r range Properties = p [] - FsAstNode = ms - Childs = [ yield visitSynField f ] } + FsAstNode = ms } + :: (visitSynField f) | SynMemberSig.NestedType (typedef, range) -> { Type = SynMemberSig_NestedType Range = r range Properties = p [] - FsAstNode = ms - Childs = [ yield visitSynTypeDefnSig typedef ] } + FsAstNode = ms } + :: (visitSynTypeDefnSig typedef) - and visitSynIndexerArg (ia: SynIndexerArg) : Node = + and visitSynIndexerArg (ia: SynIndexerArg) : Node list = match ia with | SynIndexerArg.One (e, _fromEnd, _) -> { Type = SynIndexerArg_One Range = noRange Properties = p [] - FsAstNode = ia - Childs = [ yield visitSynExpr e ] } + FsAstNode = ia } + :: (visitSynExpr e) | SynIndexerArg.Two (e1, _fromEnd1, e2, _fromEnd2, _, _) -> { Type = SynIndexerArg_Two Range = noRange Properties = p [] - FsAstNode = ia - Childs = - [ yield visitSynExpr e1 - yield visitSynExpr e2 ] } + FsAstNode = ia } + :: [ yield! visitSynExpr e1 + yield! visitSynExpr e2 ] - and visitSynMatchClause (mc: SynMatchClause) : Node = + and visitSynMatchClause (mc: SynMatchClause) : Node list = match mc with | SynMatchClause.Clause (pat, e1, e2, _range, _) -> { Type = SynMatchClause_Clause Range = r mc.Range // _range is the same range as pat, see https://github.com/dotnet/fsharp/issues/10877 Properties = p [] - FsAstNode = mc - Childs = - [ yield visitSynPat pat - if e1.IsSome then - yield visitSynExpr e1.Value - yield visitSynExpr e2 ] } + FsAstNode = mc } + :: [ yield! visitSynPat pat + if e1.IsSome then + yield! visitSynExpr e1.Value + yield! visitSynExpr e2 ] and visitArgsOption (expr: SynExpr, ident: Ident option) = { Type = ArgOptions_ @@ -787,19 +746,18 @@ module private Ast = Properties = p [ if ident.IsSome then yield "ident" ==> i ident.Value ] - FsAstNode = expr - Childs = [ yield visitSynExpr expr ] } + FsAstNode = expr } + :: (visitSynExpr expr) - and visitSynInterfaceImpl (ii: SynInterfaceImpl) : Node = + and visitSynInterfaceImpl (ii: SynInterfaceImpl) : Node list = match ii with | InterfaceImpl (typ, bindings, range) -> { Type = InterfaceImpl_ Range = r range Properties = p [] - FsAstNode = ii - Childs = - [ yield visitSynType typ - yield! (bindings |> List.map visitSynBinding) ] } + FsAstNode = ii } + :: [ yield! visitSynType typ + yield! (bindings |> List.collect visitSynBinding) ] and visitSynTypeDefn (td: SynTypeDefn) = match td with @@ -807,48 +765,45 @@ module private Ast = { Type = TypeDefn_ Range = r range Properties = p [] - FsAstNode = td - Childs = - [ yield visitSynComponentInfo sci - yield visitSynTypeDefnRepr stdr - yield! (members |> List.map visitSynMemberDefn) ] } + FsAstNode = td } + :: [ yield! visitSynComponentInfo sci + yield! visitSynTypeDefnRepr stdr + yield! (members |> List.collect visitSynMemberDefn) ] - and visitSynTypeDefnSig (typeDefSig: SynTypeDefnSig) : Node = + and visitSynTypeDefnSig (typeDefSig: SynTypeDefnSig) : Node list = match typeDefSig with | TypeDefnSig (sci, synTypeDefnSigReprs, memberSig, range) -> { Type = TypeDefnSig_ Range = r range Properties = p [] - FsAstNode = typeDefSig - Childs = - [ yield visitSynComponentInfo sci - yield visitSynTypeDefnSigRepr synTypeDefnSigReprs - yield! (memberSig |> List.map visitSynMemberSig) ] } + FsAstNode = typeDefSig } + :: [ yield! visitSynComponentInfo sci + yield! visitSynTypeDefnSigRepr synTypeDefnSigReprs + yield! (memberSig |> List.collect visitSynMemberSig) ] - and visitSynTypeDefnSigRepr (stdr: SynTypeDefnSigRepr) : Node = + and visitSynTypeDefnSigRepr (stdr: SynTypeDefnSigRepr) : Node list = match stdr with | SynTypeDefnSigRepr.ObjectModel (kind, members, range) -> { Type = SynTypeDefnSigRepr_ObjectModel Range = r range Properties = p [] - FsAstNode = stdr - Childs = - [ yield visitSynTypeDefnKind kind - yield! (members |> List.map visitSynMemberSig) ] } + FsAstNode = stdr } + :: [ yield! visitSynTypeDefnKind kind + yield! (members |> List.collect visitSynMemberSig) ] | SynTypeDefnSigRepr.Simple (simpleRepr, range) -> { Type = SynTypeDefnSigRepr_ObjectModel Range = r range Properties = p [] - FsAstNode = stdr - Childs = [ yield visitSynTypeDefnSimpleRepr simpleRepr ] } + FsAstNode = stdr } + :: (visitSynTypeDefnSimpleRepr simpleRepr) | SynTypeDefnSigRepr.Exception (exceptionRepr) -> { Type = SynTypeDefnSigRepr_Exception Range = noRange Properties = p [] - FsAstNode = stdr - Childs = [ yield visitSynExceptionDefnRepr exceptionRepr ] } + FsAstNode = stdr } + :: (visitSynExceptionDefnRepr exceptionRepr) - and visitSynMemberDefn (mbrDef: SynMemberDefn) : Node = + and visitSynMemberDefn (mbrDef: SynMemberDefn) : Node list = match mbrDef with | SynMemberDefn.Open (target, parentRange) -> // we use the parent ranges here to match up with the trivia parsed @@ -857,20 +812,20 @@ module private Ast = { Type = SynMemberDefn_Open Range = r parentRange Properties = p [ "longIdent" ==> li longIdent ] - FsAstNode = target - Childs = [] } + FsAstNode = target } + |> List.singleton | SynOpenDeclTarget.Type (synType, _range) -> { Type = SynMemberDefn_OpenType Range = r parentRange Properties = p [] - FsAstNode = target - Childs = [ visitSynType synType ] } + FsAstNode = target } + :: (visitSynType synType) | SynMemberDefn.Member (memberDefn, range) -> { Type = SynMemberDefn_Member Range = r range Properties = p [] - FsAstNode = mbrDef - Childs = [ yield visitSynBinding memberDefn ] } + FsAstNode = mbrDef } + :: (visitSynBinding memberDefn) | SynMemberDefn.ImplicitCtor (access, attrs, ctorArgs, selfIdentifier, _xmlDoc, range) -> { Type = SynMemberDefn_ImplicitCtor Range = r range @@ -879,65 +834,62 @@ module private Ast = yield "selfIdent" ==> i selfIdentifier.Value if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = mbrDef - Childs = - [ yield! (visitSynAttributeLists range attrs) - yield visitSynSimplePats ctorArgs ] } + FsAstNode = mbrDef } + :: [ yield! (visitSynAttributeLists range attrs) + yield! visitSynSimplePats ctorArgs ] | SynMemberDefn.ImplicitInherit (inheritType, inheritArgs, inheritAlias, range) -> { Type = SynMemberDefn_ImplicitInherit Range = r range Properties = p [ if inheritAlias.IsSome then yield "inheritAlias" ==> i inheritAlias.Value ] - FsAstNode = mbrDef - Childs = - [ yield visitSynType inheritType - yield visitSynExpr inheritArgs ] } + FsAstNode = mbrDef } + :: [ yield! visitSynType inheritType + yield! visitSynExpr inheritArgs ] | SynMemberDefn.LetBindings (bindings, isStatic, isRecursive, range) -> { Type = SynMemberDefn_LetBindings Range = r range Properties = p [ "isStatic" ==> isStatic "isRecursive" ==> isRecursive ] - FsAstNode = mbrDef - Childs = [ yield! bindings |> List.map visitSynBinding ] } + FsAstNode = mbrDef } + :: (List.collect visitSynBinding bindings) | SynMemberDefn.AbstractSlot (valSig, _, range) -> { Type = SynMemberDefn_AbstractSlot Range = r range Properties = p [] - FsAstNode = mbrDef - Childs = [ yield visitSynValSig valSig ] } + FsAstNode = mbrDef } + :: (visitSynValSig valSig) | SynMemberDefn.Interface (typ, members, range) -> { Type = SynMemberDefn_Interface Range = r range Properties = p [] - FsAstNode = mbrDef - Childs = - [ yield visitSynType typ - if members.IsSome then - yield! members.Value |> List.map visitSynMemberDefn ] } + FsAstNode = mbrDef } + :: [ yield! visitSynType typ + if members.IsSome then + yield! members.Value |> List.collect visitSynMemberDefn ] | SynMemberDefn.Inherit (typ, ident, range) -> { Type = SynMemberDefn_Inherit Range = r range Properties = p [ if ident.IsSome then yield "ident" ==> i ident.Value ] - FsAstNode = mbrDef - Childs = [ yield visitSynType typ ] } + FsAstNode = mbrDef } + :: (visitSynType typ) | SynMemberDefn.ValField (fld, range) -> { Type = SynMemberDefn_ValField Range = r range Properties = p [] - FsAstNode = mbrDef - Childs = [ yield visitSynField fld ] } + FsAstNode = mbrDef } + :: (visitSynField fld) | SynMemberDefn.NestedType (typeDefn, access, range) -> { Type = SynMemberDefn_NestedType Range = r range Properties = p [ if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = mbrDef - Childs = [ yield visitSynTypeDefn typeDefn ] } + FsAstNode = mbrDef } + :: (visitSynTypeDefn typeDefn) | SynMemberDefn.AutoProperty (attrs, isStatic, ident, @@ -959,14 +911,13 @@ module private Ast = yield "access" ==> (access.Value |> visitSynAccess) if getSetRange.IsSome then yield "getSetRange" ==> (getSetRange.Value |> r) ] - FsAstNode = mbrDef - Childs = - [ yield! (visitSynAttributeLists range attrs) - if typeOpt.IsSome then - yield visitSynType typeOpt.Value - yield visitSynExpr synExpr ] } - - and visitSynSimplePat (sp: SynSimplePat) : Node = + FsAstNode = mbrDef } + :: [ yield! (visitSynAttributeLists range attrs) + if typeOpt.IsSome then + yield! visitSynType typeOpt.Value + yield! visitSynExpr synExpr ] + + and visitSynSimplePat (sp: SynSimplePat) : Node list = match sp with | SynSimplePat.Id (ident, _, isCompilerGenerated, isThisVar, isOptArg, range) -> { Type = SynSimplePat_Id @@ -976,43 +927,40 @@ module private Ast = "isThisVar" ==> isThisVar "isOptArg" ==> isOptArg "ident" ==> i ident ] - FsAstNode = sp - Childs = [] } + FsAstNode = sp } + |> List.singleton | SynSimplePat.Typed (simplePat, typ, range) -> { Type = SynSimplePat_Typed Range = r range Properties = p [] - FsAstNode = sp - Childs = - [ yield visitSynSimplePat simplePat - yield visitSynType typ ] } + FsAstNode = sp } + :: [ yield! visitSynSimplePat simplePat + yield! visitSynType typ ] | SynSimplePat.Attrib (simplePat, attrs, range) -> { Type = SynSimplePat_Attrib Range = r range Properties = p [] - FsAstNode = sp - Childs = - [ yield visitSynSimplePat simplePat - yield! (visitSynAttributeLists range attrs) ] } + FsAstNode = sp } + :: [ yield! visitSynSimplePat simplePat + yield! (visitSynAttributeLists range attrs) ] - and visitSynSimplePats (sp: SynSimplePats) : Node = + and visitSynSimplePats (sp: SynSimplePats) : Node list = match sp with | SynSimplePats.SimplePats (pats, range) -> { Type = SynSimplePats_SimplePats Range = r range Properties = p [] - FsAstNode = sp - Childs = [ yield! pats |> List.map visitSynSimplePat ] } + FsAstNode = sp } + :: [ yield! pats |> List.collect visitSynSimplePat ] | SynSimplePats.Typed (pats, typ, range) -> { Type = SynSimplePat_Typed Range = r range Properties = p [] - FsAstNode = sp - Childs = - [ yield visitSynSimplePats pats - yield visitSynType typ ] } + FsAstNode = sp } + :: [ yield! visitSynSimplePats pats + yield! visitSynType typ ] - and visitSynBinding (binding: SynBinding) : Node = + and visitSynBinding (binding: SynBinding) : Node list = match binding with | Binding (access, kind, mustInline, isMutable, attrs, _, valData, headPat, returnInfo, expr, range, _) -> let t = @@ -1029,16 +977,15 @@ module private Ast = yield "kind" ==> visitSynBindingKind kind if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = binding - Childs = - [ yield! (visitSynAttributeLists range attrs) - yield visitSynValData valData - yield visitSynPat headPat - if returnInfo.IsSome then - yield visitSynBindingReturnInfo returnInfo.Value - yield visitSynExpr expr ] } - - and visitSynValData (svd: SynValData) : Node = + FsAstNode = binding } + :: [ yield! (visitSynAttributeLists range attrs) + yield! visitSynValData valData + yield! visitSynPat headPat + if returnInfo.IsSome then + yield! visitSynBindingReturnInfo returnInfo.Value + yield! visitSynExpr expr ] + + and visitSynValData (svd: SynValData) : Node list = match svd with | SynValData (_, svi, ident) -> { Type = SynValData_ @@ -1046,10 +993,10 @@ module private Ast = Properties = p [ if ident.IsSome then yield "ident" ==> (ident.Value |> i) ] - FsAstNode = svd - Childs = [ yield visitSynValInfo svi ] } + FsAstNode = svd } + :: (visitSynValInfo svi) - and visitSynValSig (svs: SynValSig) : Node = + and visitSynValSig (svs: SynValSig) : Node list = match svs with | ValSpfn (attrs, ident, explicitValDecls, synType, arity, isInline, isMutable, _, access, expr, range) -> { Type = ValSpfn_ @@ -1060,36 +1007,34 @@ module private Ast = yield "isInline" ==> isInline if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = svs - Childs = - [ yield! (visitSynAttributeLists range attrs) - yield visitSynValTyparDecls explicitValDecls - yield visitSynType synType - yield visitSynValInfo arity - if expr.IsSome then - yield visitSynExpr expr.Value ] } - - and visitSynValTyparDecls (valTypeDecl: SynValTyparDecls) : Node = + FsAstNode = svs } + :: [ yield! (visitSynAttributeLists range attrs) + yield! visitSynValTyparDecls explicitValDecls + yield! visitSynType synType + yield! visitSynValInfo arity + if expr.IsSome then + yield! visitSynExpr expr.Value ] + + and visitSynValTyparDecls (valTypeDecl: SynValTyparDecls) : Node list = match valTypeDecl with | SynValTyparDecls (typardecls, _, _) -> { Type = SynValTyparDecls_ Range = noRange Properties = p [] - FsAstNode = valTypeDecl - Childs = [ yield! typardecls |> List.map visitSynTyparDecl ] } + FsAstNode = valTypeDecl } + :: (List.collect visitSynTyparDecl typardecls) - and visitSynTyparDecl (std: SynTyparDecl) : Node = + and visitSynTyparDecl (std: SynTyparDecl) : Node list = match std with | TyparDecl (attrs, typar) -> { Type = TyparDecl_ Range = noRange Properties = p [] - FsAstNode = std - Childs = - [ yield! (visitSynAttributeLists typar.Range attrs) - yield visitSynTypar typar ] } + FsAstNode = std } + :: [ yield! (visitSynAttributeLists typar.Range attrs) + yield! visitSynTypar typar ] - and visitSynTypar (typar: SynTypar) : Node = + and visitSynTypar (typar: SynTypar) : Node list = match typar with | Typar (ident, staticReq, isComGen) -> { Type = Typar_ @@ -1098,39 +1043,39 @@ module private Ast = p [ "ident" ==> i ident "isComGen" ==> isComGen "staticReq" ==> visitTyparStaticReq staticReq ] - FsAstNode = typar - Childs = [] } + FsAstNode = typar } + |> List.singleton and visitTyparStaticReq (tsr: TyparStaticReq) = match tsr with | NoStaticReq -> "NoStaticReq" | HeadTypeStaticReq -> "HeadTypeStaticReq" - and visitSynBindingReturnInfo (returnInfo: SynBindingReturnInfo) : Node = + and visitSynBindingReturnInfo (returnInfo: SynBindingReturnInfo) : Node list = match returnInfo with | SynBindingReturnInfo (typeName, range, attrs) -> { Type = SynBindingReturnInfo_ Range = r range Properties = p [] - FsAstNode = returnInfo - Childs = - [ yield visitSynType typeName - yield! (visitSynAttributeLists range attrs) ] } + FsAstNode = returnInfo } + :: [ yield! visitSynType typeName + yield! (visitSynAttributeLists range attrs) ] - and visitSynPat (sp: SynPat) : Node = + // TODO: tail + and visitSynPat (sp: SynPat) : Node list = match sp with | SynPat.Const (sc, range) -> - { Type = SynPat_Const - Range = r range - Properties = p [] - FsAstNode = sp - Childs = [ visitSynConst range sc ] } + [ { Type = SynPat_Const + Range = r range + Properties = p [] + FsAstNode = sp } + visitSynConst range sc ] | SynPat.Wild (range) -> { Type = SynPat_Wild Range = r range Properties = p [] - FsAstNode = sp - Childs = [] } + FsAstNode = sp } + |> List.singleton | SynPat.Named (synPat, ident, isSelfIdentifier, access, range) -> { Type = SynPat_Named Range = r range @@ -1139,38 +1084,35 @@ module private Ast = yield "isSelfIdentifier" ==> isSelfIdentifier if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = sp - Childs = [ yield visitSynPat synPat ] } + FsAstNode = sp } + :: (visitSynPat synPat) | SynPat.Typed (synPat, synType, range) -> { Type = SynPat_Typed Range = r range Properties = p [] - FsAstNode = sp - Childs = - [ yield visitSynPat synPat - yield visitSynType synType ] } + FsAstNode = sp } + :: [ yield! visitSynPat synPat + yield! visitSynType synType ] | SynPat.Attrib (synPat, attrs, range) -> { Type = SynPat_Attrib Range = r range Properties = p [] - FsAstNode = sp - Childs = - [ yield visitSynPat synPat - yield! (visitSynAttributeLists range attrs) ] } + FsAstNode = sp } + :: [ yield! visitSynPat synPat + yield! (visitSynAttributeLists range attrs) ] | SynPat.Or (synPat, synPat2, range) -> { Type = SynPat_Or Range = r range Properties = p [] - FsAstNode = sp - Childs = - [ yield visitSynPat synPat - yield visitSynPat synPat2 ] } + FsAstNode = sp } + :: [ yield! visitSynPat synPat + yield! visitSynPat synPat2 ] | SynPat.Ands (pats, range) -> { Type = SynPat_Ands Range = r range Properties = p [] - FsAstNode = sp - Childs = [ yield! pats |> List.map visitSynPat ] } + FsAstNode = sp } + :: (List.collect visitSynPat pats) | SynPat.LongIdent (longDotId, ident, svtd, ctorArgs, access, range) -> { Type = SynPat_LongIdent Range = r range @@ -1180,65 +1122,64 @@ module private Ast = yield "longDotId" ==> lid longDotId if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = sp - Childs = - [ if svtd.IsSome then - yield visitSynValTyparDecls svtd.Value - yield visitSynConstructorArgs ctorArgs ] } + FsAstNode = sp } + :: [ if svtd.IsSome then + yield! visitSynValTyparDecls svtd.Value + yield! visitSynConstructorArgs ctorArgs ] | SynPat.Tuple (isStruct, pats, range) -> { Type = SynPat_Tuple Range = r range Properties = p [ "isStruct" ==> isStruct ] - FsAstNode = sp - Childs = [ yield! pats |> List.map visitSynPat ] } + FsAstNode = sp } + :: (List.collect visitSynPat pats) | SynPat.Paren (pat, range) -> { Type = SynPat_Paren Range = r range Properties = p [] - FsAstNode = sp - Childs = [ visitSynPat pat ] } + FsAstNode = sp } + :: visitSynPat pat | SynPat.ArrayOrList (_, pats, range) -> { Type = SynPat_ArrayOrList Range = r range Properties = p [] - FsAstNode = sp - Childs = [ yield! pats |> List.map visitSynPat ] } + FsAstNode = sp } + :: (List.collect visitSynPat pats) | SynPat.Record (pats, range) -> { Type = SynPat_Record Range = r range Properties = p [] - FsAstNode = sp - Childs = [ yield! pats |> List.map (snd >> visitSynPat) ] } + FsAstNode = sp } + :: (List.collect (snd >> visitSynPat) pats) | SynPat.Null (range) -> { Type = SynPat_Null Range = r range Properties = p [] - FsAstNode = sp - Childs = [] } + FsAstNode = sp } + |> List.singleton | SynPat.OptionalVal (ident, range) -> { Type = SynPat_OptionalVal Range = r range Properties = p [ "ident" ==> i ident ] - FsAstNode = sp - Childs = [] } + FsAstNode = sp } + |> List.singleton | SynPat.IsInst (typ, range) -> { Type = SynPat_IsInst Range = r range Properties = p [] - FsAstNode = sp - Childs = [ visitSynType typ ] } + FsAstNode = sp } + :: visitSynType typ | SynPat.QuoteExpr (expr, range) -> { Type = SynPat_QuoteExpr Range = r range Properties = p [] - FsAstNode = sp - Childs = [ visitSynExpr expr ] } + FsAstNode = sp } + :: visitSynExpr expr | SynPat.DeprecatedCharRange (c, c2, range) -> { Type = SynPat_DeprecatedCharRange Range = r range Properties = p [ "c" ==> c; "c2" ==> c2 ] - FsAstNode = sp - Childs = [] } + FsAstNode = sp } + |> List.singleton | SynPat.InstanceMember (ident, ident2, ident3, access, range) -> { Type = SynPat_InstanceMember Range = r range @@ -1249,31 +1190,31 @@ module private Ast = yield "ident3" ==> (ident3.Value |> i) if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = sp - Childs = [] } + FsAstNode = sp } + |> List.singleton | SynPat.FromParseError (pat, range) -> { Type = SynPat_FromParseError Range = r range Properties = p [] - FsAstNode = sp - Childs = [ visitSynPat pat ] } + FsAstNode = sp } + :: (visitSynPat pat) - and visitSynConstructorArgs (ctorArgs: SynArgPats) : Node = + and visitSynConstructorArgs (ctorArgs: SynArgPats) : Node list = match ctorArgs with | Pats (pats) -> { Type = Pats_ Range = noRange Properties = p [] - FsAstNode = ctorArgs - Childs = [ yield! pats |> List.map visitSynPat ] } + FsAstNode = ctorArgs } + :: (List.collect visitSynPat pats) | NamePatPairs (pats, range) -> { Type = NamePatPairs_ Range = r range Properties = p [] - FsAstNode = ctorArgs - Childs = [ yield! pats |> List.map (snd >> visitSynPat) ] } + FsAstNode = ctorArgs } + :: (List.collect (snd >> visitSynPat) pats) - and visitSynComponentInfo (sci: SynComponentInfo) : Node = + and visitSynComponentInfo (sci: SynComponentInfo) : Node list = match sci with | ComponentInfo (attribs, typeParams, _, longId, _, preferPostfix, access, range) -> { Type = ComponentInfo_ @@ -1283,104 +1224,101 @@ module private Ast = yield "preferPostfix" ==> preferPostfix if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = sci - Childs = - [ yield! (visitSynAttributeLists range attribs) - yield! (typeParams |> List.map (visitSynTyparDecl)) ] } + FsAstNode = sci } + :: [ yield! (visitSynAttributeLists range attribs) + yield! (typeParams |> List.collect (visitSynTyparDecl)) ] - and visitSynTypeDefnRepr (stdr: SynTypeDefnRepr) : Node = + and visitSynTypeDefnRepr (stdr: SynTypeDefnRepr) : Node list = match stdr with | SynTypeDefnRepr.ObjectModel (kind, members, range) -> { Type = SynTypeDefnRepr_ObjectModel Range = r range Properties = p [] - FsAstNode = stdr - Childs = - [ yield visitSynTypeDefnKind kind - yield! (members |> List.map visitSynMemberDefn) ] } + FsAstNode = stdr } + :: [ yield! visitSynTypeDefnKind kind + yield! (members |> List.collect visitSynMemberDefn) ] | SynTypeDefnRepr.Simple (simpleRepr, range) -> { Type = SynTypeDefnRepr_Simple Range = r range Properties = p [] - FsAstNode = stdr - Childs = [ yield visitSynTypeDefnSimpleRepr simpleRepr ] } + FsAstNode = stdr } + :: (visitSynTypeDefnSimpleRepr simpleRepr) | SynTypeDefnRepr.Exception (exceptionRepr) -> { Type = SynTypeDefnRepr_Exception Range = noRange Properties = p [] - FsAstNode = stdr - Childs = [ yield visitSynExceptionDefnRepr exceptionRepr ] } + FsAstNode = stdr } + :: (visitSynExceptionDefnRepr exceptionRepr) - and visitSynTypeDefnKind (kind: SynTypeDefnKind) = + and visitSynTypeDefnKind (kind: SynTypeDefnKind) : Node list = match kind with | TyconUnspecified -> { Type = SynTypeDefnKind_TyconUnspecified Range = noRange Properties = p [] - FsAstNode = kind - Childs = [] } + FsAstNode = kind } + |> List.singleton | TyconClass -> { Type = SynTypeDefnKind_TyconClass Range = noRange Properties = p [] - FsAstNode = kind - Childs = [] } + FsAstNode = kind } + |> List.singleton | TyconInterface -> { Type = SynTypeDefnKind_TyconInterface Range = noRange Properties = p [] - FsAstNode = kind - Childs = [] } + FsAstNode = kind } + |> List.singleton | TyconStruct -> { Type = SynTypeDefnKind_TyconStruct Range = noRange Properties = p [] - FsAstNode = kind - Childs = [] } + FsAstNode = kind } + |> List.singleton | TyconRecord -> { Type = SynTypeDefnKind_TyconRecord Range = noRange Properties = p [] - FsAstNode = kind - Childs = [] } + FsAstNode = kind } + |> List.singleton | TyconUnion -> { Type = SynTypeDefnKind_TyconUnion Range = noRange Properties = p [] - FsAstNode = kind - Childs = [] } + FsAstNode = kind } + |> List.singleton | TyconAbbrev -> { Type = SynTypeDefnKind_TyconAbbrev Range = noRange Properties = p [] - FsAstNode = kind - Childs = [] } + FsAstNode = kind } + |> List.singleton | TyconHiddenRepr -> { Type = SynTypeDefnKind_TyconHiddenRepr Range = noRange Properties = p [] - FsAstNode = kind - Childs = [] } + FsAstNode = kind } + |> List.singleton | TyconAugmentation -> { Type = SynTypeDefnKind_TyconAugmentation Range = noRange Properties = p [] - FsAstNode = kind - Childs = [] } + FsAstNode = kind } + |> List.singleton | TyconILAssemblyCode -> { Type = SynTypeDefnKind_TyconILAssemblyCode Range = noRange Properties = p [] - FsAstNode = kind - Childs = [] } + FsAstNode = kind } + |> List.singleton | TyconDelegate (typ, valinfo) -> { Type = SynTypeDefnKind_TyconDelegate Range = noRange Properties = p [] - FsAstNode = kind - Childs = - [ yield visitSynType typ - yield visitSynValInfo valinfo ] } + FsAstNode = kind } + :: [ yield! visitSynType typ + yield! visitSynValInfo valinfo ] and visitSynTypeDefnSimpleRepr (arg: SynTypeDefnSimpleRepr) = match arg with @@ -1388,67 +1326,66 @@ module private Ast = { Type = SynTypeDefnSimpleRepr_None Range = r range Properties = p [] - FsAstNode = arg - Childs = [] } + FsAstNode = arg } + |> List.singleton | SynTypeDefnSimpleRepr.Union (access, unionCases, range) -> { Type = SynTypeDefnSimpleRepr_Union Range = r range Properties = p [ if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = arg - Childs = [ yield! unionCases |> List.map visitSynUnionCase ] } + FsAstNode = arg } + :: (List.collect visitSynUnionCase unionCases) | SynTypeDefnSimpleRepr.Enum (enumCases, range) -> { Type = SynTypeDefnSimpleRepr_Enum Range = r range Properties = p [] - FsAstNode = arg - Childs = [ yield! enumCases |> List.map visitSynEnumCase ] } + FsAstNode = arg } + :: (List.collect visitSynEnumCase enumCases) | SynTypeDefnSimpleRepr.Record (access, recordFields, range) -> { Type = SynTypeDefnSimpleRepr_Record Range = r range Properties = p [ if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = arg - Childs = [ yield! recordFields |> List.map visitSynField ] } + FsAstNode = arg } + :: (List.collect visitSynField recordFields) | SynTypeDefnSimpleRepr.General (_, _, _, _, _, _, _, range) -> { Type = SynTypeDefnSimpleRepr_General Range = r range Properties = p [] - FsAstNode = arg - Childs = [] } + FsAstNode = arg } + |> List.singleton | SynTypeDefnSimpleRepr.LibraryOnlyILAssembly (_, range) -> { Type = SynTypeDefnSimpleRepr_LibraryOnlyILAssembly Range = r range Properties = p [] - FsAstNode = arg - Childs = [] } + FsAstNode = arg } + |> List.singleton | SynTypeDefnSimpleRepr.TypeAbbrev (_, typ, range) -> { Type = SynTypeDefnSimpleRepr_TypeAbbrev Range = r range Properties = p [] - FsAstNode = arg - Childs = [ visitSynType typ ] } + FsAstNode = arg } + :: (visitSynType typ) | SynTypeDefnSimpleRepr.Exception (edr) -> { Type = SynTypeDefnSimpleRepr_Exception Range = noRange Properties = p [] - FsAstNode = arg - Childs = [ visitSynExceptionDefnRepr edr ] } + FsAstNode = arg } + :: (visitSynExceptionDefnRepr edr) - and visitSynExceptionDefn (exceptionDef: SynExceptionDefn) : Node = + and visitSynExceptionDefn (exceptionDef: SynExceptionDefn) : Node list = match exceptionDef with | SynExceptionDefn (sedr, members, range) -> { Type = SynExceptionDefn_ Range = r range Properties = p [] - FsAstNode = exceptionDef - Childs = - [ yield visitSynExceptionDefnRepr sedr - yield! (members |> List.map visitSynMemberDefn) ] } + FsAstNode = exceptionDef } + :: [ yield! visitSynExceptionDefnRepr sedr + yield! (members |> List.collect visitSynMemberDefn) ] - and visitSynExceptionDefnRepr (sedr: SynExceptionDefnRepr) : Node = + and visitSynExceptionDefnRepr (sedr: SynExceptionDefnRepr) : Node list = match sedr with | SynExceptionDefnRepr (attrs, unionCase, longId, _, access, range) -> { Type = SynExceptionDefnRepr_ @@ -1458,12 +1395,11 @@ module private Ast = yield "longIdent" ==> (longId.Value |> li) if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = sedr - Childs = - [ yield! (visitSynAttributeLists range attrs) - yield visitSynUnionCase unionCase ] } + FsAstNode = sedr } + :: [ yield! (visitSynAttributeLists range attrs) + yield! visitSynUnionCase unionCase ] - and visitSynAttribute (attr: SynAttribute) : Node = + and visitSynAttribute (attr: SynAttribute) : Node list = { Type = SynAttribute_ Range = r attr.Range Properties = @@ -1474,14 +1410,12 @@ module private Ast = "appliesToGetterAndSetter" ==> attr.AppliesToGetterAndSetter yield "typeName" ==> lid attr.TypeName ] - FsAstNode = attr - Childs = [ visitSynExpr attr.ArgExpr ] } + FsAstNode = attr } + :: (visitSynExpr attr.ArgExpr) and visitSynAttributeLists (parentRange: Range) (attrs: SynAttributeList list) : Node list = match attrs with - | [ h ] -> - visitSynAttributeList parentRange h - |> List.singleton + | [ h ] -> visitSynAttributeList parentRange h | _ :: tail -> let aRanges = tail @@ -1489,17 +1423,17 @@ module private Ast = |> fun r -> r @ [ parentRange ] List.zip attrs aRanges - |> List.map (fun (a, r) -> visitSynAttributeList r a) + |> List.collect (fun (a, r) -> visitSynAttributeList r a) | [] -> [] - and visitSynAttributeList (parentRange: Range) (attrs: SynAttributeList) : Node = + and visitSynAttributeList (parentRange: Range) (attrs: SynAttributeList) : Node list = { Type = SynAttributeList_ Range = r attrs.Range Properties = p [ "linesBetweenParent", box (parentRange.StartLine - attrs.Range.EndLine - 1) ] - FsAstNode = attrs - Childs = attrs.Attributes |> List.map visitSynAttribute } + FsAstNode = attrs } + :: (List.collect visitSynAttribute attrs.Attributes) - and visitSynUnionCase (uc: SynUnionCase) : Node = + and visitSynUnionCase (uc: SynUnionCase) : Node list = match uc with | UnionCase (attrs, ident, uct, _, access, range) -> { Type = UnionCase_ @@ -1508,10 +1442,9 @@ module private Ast = p [ yield "ident" ==> i ident if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = uc - Childs = - [ yield visitSynUnionCaseType uct - yield! (visitSynAttributeLists range attrs) ] } + FsAstNode = uc } + :: [ yield! visitSynUnionCaseType uct + yield! (visitSynAttributeLists range attrs) ] and visitSynUnionCaseType (uct: SynUnionCaseType) = match uct with @@ -1519,29 +1452,27 @@ module private Ast = { Type = UnionCaseFields_ Range = noRange Properties = p [] - FsAstNode = uct - Childs = [ yield! cases |> List.map visitSynField ] } + FsAstNode = uct } + :: (List.collect visitSynField cases) | UnionCaseFullType (stype, valInfo) -> { Type = UnionCaseFullType_ Range = noRange Properties = p [] - FsAstNode = uct - Childs = - [ yield visitSynType stype - yield visitSynValInfo valInfo ] } + FsAstNode = uct } + :: [ yield! visitSynType stype + yield! visitSynValInfo valInfo ] - and visitSynEnumCase (sec: SynEnumCase) : Node = + and visitSynEnumCase (sec: SynEnumCase) : Node list = match sec with | EnumCase (attrs, ident, _, _, range) -> { Type = EnumCase_ Range = r range Properties = p [] - FsAstNode = sec - Childs = - [ yield! (visitSynAttributeLists range attrs) - yield visitIdent ident ] } + FsAstNode = sec } + :: [ yield! (visitSynAttributeLists range attrs) + yield visitIdent ident ] - and visitSynField (sfield: SynField) : Node = + and visitSynField (sfield: SynField) : Node list = match sfield with | Field (attrs, isStatic, ident, typ, _, _, access, range) -> let parentRange = @@ -1557,10 +1488,9 @@ module private Ast = yield "isStatic" ==> isStatic if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = sfield - Childs = - [ yield! (visitSynAttributeLists parentRange attrs) - yield visitSynType typ ] } + FsAstNode = sfield } + :: [ yield! (visitSynAttributeLists parentRange attrs) + yield! visitSynType typ ] and visitSynType (st: SynType) = match st with @@ -1568,8 +1498,8 @@ module private Ast = { Type = SynType_LongIdent Range = noRange Properties = p [] - FsAstNode = st - Childs = visitLongIdentWithDots li } + FsAstNode = st } + :: (visitLongIdentWithDots li) | SynType.App (typeName, lessRange, typeArgs, commaRanges, greaterRange, isPostfix, range) -> { Type = SynType_App Range = r range @@ -1580,10 +1510,9 @@ module private Ast = if greaterRange.IsSome then yield "greaterRange" ==> (greaterRange.Value |> r) yield "isPostfix" ==> isPostfix ] - FsAstNode = st - Childs = - [ yield! typeArgs |> List.map visitSynType - yield visitSynType typeName ] } + FsAstNode = st } + :: [ yield! typeArgs |> List.collect visitSynType + yield! visitSynType typeName ] | SynType.LongIdentApp (typeName, longDotId, lessRange, typeArgs, commaRanges, greaterRange, range) -> { Type = SynType_LongIdentApp Range = r range @@ -1594,102 +1523,98 @@ module private Ast = yield "commaRanges" ==> (commaRanges |> List.map r) if greaterRange.IsSome then yield "greaterRange" ==> (greaterRange.Value |> r) ] - FsAstNode = st - Childs = - [ yield! typeArgs |> List.map visitSynType - yield visitSynType typeName ] } + FsAstNode = st } + :: [ yield! typeArgs |> List.collect visitSynType + yield! visitSynType typeName ] | SynType.Tuple (isStruct, typeNames, range) -> { Type = SynType_Tuple Range = r range Properties = p [ "isStruct" ==> isStruct ] - FsAstNode = st - Childs = [ yield! typeNames |> List.map (snd >> visitSynType) ] } + FsAstNode = st } + :: (List.collect (snd >> visitSynType) typeNames) | SynType.Array (_, elementType, range) -> { Type = SynType_Array Range = r range Properties = p [] - FsAstNode = st - Childs = [ yield visitSynType elementType ] } + FsAstNode = st } + :: (visitSynType elementType) | SynType.Fun (argType, returnType, range) -> { Type = SynType_Fun Range = r range Properties = p [] - FsAstNode = st - Childs = - [ yield visitSynType argType - yield visitSynType returnType ] } + FsAstNode = st } + :: [ yield! visitSynType argType + yield! visitSynType returnType ] | SynType.Var (genericName, range) -> { Type = SynType_Var Range = r range Properties = p [] - FsAstNode = st - Childs = [ yield visitSynTypar genericName ] } + FsAstNode = st } + :: (visitSynTypar genericName) | SynType.Anon (range) -> { Type = SynType_Anon Range = r range Properties = p [] - FsAstNode = st - Childs = [] } + FsAstNode = st } + |> List.singleton | SynType.WithGlobalConstraints (typeName, _, range) -> { Type = SynType_WithGlobalConstraints Range = r range Properties = p [] - FsAstNode = st - Childs = [ yield visitSynType typeName ] } + FsAstNode = st } + :: (visitSynType typeName) | SynType.HashConstraint (synType, range) -> { Type = SynType_HashConstraint Range = r range Properties = p [] - FsAstNode = st - Childs = [ yield visitSynType synType ] } + FsAstNode = st } + :: (visitSynType synType) | SynType.MeasureDivide (dividendType, divisorType, range) -> { Type = SynType_MeasureDivide Range = r range Properties = p [] - FsAstNode = st - Childs = - [ yield visitSynType dividendType - yield visitSynType divisorType ] } + FsAstNode = st } + :: [ yield! visitSynType dividendType + yield! visitSynType divisorType ] | SynType.MeasurePower (measureType, _, range) -> { Type = SynType_MeasurePower Range = r range Properties = p [] - FsAstNode = st - Childs = [ yield visitSynType measureType ] } + FsAstNode = st } + :: (visitSynType measureType) | SynType.StaticConstant (constant, range) -> { Type = SynType_StaticConstant Range = r range Properties = p [] - FsAstNode = st - Childs = [ visitSynConst range constant ] } + FsAstNode = st } + :: [ (visitSynConst range constant) ] | SynType.StaticConstantExpr (expr, range) -> { Type = SynType_StaticConstantExpr Range = r range Properties = p [] - FsAstNode = st - Childs = [ yield visitSynExpr expr ] } + FsAstNode = st } + :: (visitSynExpr expr) | SynType.StaticConstantNamed (expr, typ, range) -> { Type = SynType_StaticConstantNamed Range = r range Properties = p [] - FsAstNode = st - Childs = - [ yield visitSynType expr - yield visitSynType typ ] } + FsAstNode = st } + :: [ yield! visitSynType expr + yield! visitSynType typ ] | SynType.AnonRecd (isStruct, typeNames, range) -> { Type = SynType_AnonRecd Range = r range Properties = p [ "isStruct" ==> isStruct ] - FsAstNode = st - Childs = List.map visitAnonRecordTypeField typeNames } + FsAstNode = st } + :: (List.collect visitAnonRecordTypeField typeNames) | SynType.Paren (innerType, range) -> { Type = SynType_Paren Range = r range Properties = p [] - FsAstNode = st - Childs = [ yield visitSynType innerType ] } + FsAstNode = st } + :: (visitSynType innerType) - and visitSynConst (parentRange: Range) (sc: SynConst) = + and visitSynConst (parentRange: Range) (sc: SynConst) : Node = let t = match sc with | SynConst.Bool _ -> SynConst_Bool @@ -1717,8 +1642,7 @@ module private Ast = { Type = t Range = r (sc.Range parentRange) Properties = p [] - FsAstNode = sc - Childs = [] } + FsAstNode = sc } and visitSynValInfo (svi: SynValInfo) = match svi with @@ -1726,12 +1650,13 @@ module private Ast = { Type = SynValInfo_ Range = noRange Properties = p [] - FsAstNode = svi - Childs = - [ yield! args |> List.collect (List.map visitSynArgInfo) - yield visitSynArgInfo arg ] } + FsAstNode = svi } + :: [ yield! + args + |> List.collect (List.collect visitSynArgInfo) + yield! visitSynArgInfo arg ] - and visitSynArgInfo (sai: SynArgInfo) = + and visitSynArgInfo (sai: SynArgInfo) : Node list = match sai with | SynArgInfo (attrs, optional, ident) -> let parentRange = @@ -1745,8 +1670,8 @@ module private Ast = p [ if ident.IsSome then yield "ident" ==> i ident.Value yield "optional" ==> optional ] - FsAstNode = sai - Childs = [ yield! (visitSynAttributeLists parentRange attrs) ] } + FsAstNode = sai } + :: (visitSynAttributeLists parentRange attrs) and visitSynAccess (a: SynAccess) = match a with @@ -1777,10 +1702,9 @@ module private Ast = Properties = p [ "ident" ==> ident "longIdent" ==> longIdent ] - FsAstNode = hash - Childs = [] } + FsAstNode = hash } - and visitSynModuleOrNamespaceSig (modOrNs: SynModuleOrNamespaceSig) : Node = + and visitSynModuleOrNamespaceSig (modOrNs: SynModuleOrNamespaceSig) : Node list = match modOrNs with | SynModuleOrNamespaceSig (longIdent, isRecursive, synModuleOrNamespaceKind, decls, _, attrs, access, range) -> let typeName = @@ -1799,17 +1723,16 @@ module private Ast = yield "longIdent" ==> li longIdent if access.IsSome then yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = modOrNs - Childs = - [ yield! - if synModuleOrNamespaceKind = SynModuleOrNamespaceKind.DeclaredNamespace then - visitLongIdent longIdent - else - [] - yield! (visitSynAttributeLists range attrs) - yield! (decls |> List.map visitSynModuleSigDecl) ] } - - and visitSynModuleSigDecl (ast: SynModuleSigDecl) : Node = + FsAstNode = modOrNs } + :: [ yield! + if synModuleOrNamespaceKind = SynModuleOrNamespaceKind.DeclaredNamespace then + visitLongIdent longIdent + else + [] + yield! (visitSynAttributeLists range attrs) + yield! (decls |> List.collect visitSynModuleSigDecl) ] + + and visitSynModuleSigDecl (ast: SynModuleSigDecl) : Node list = match ast with | SynModuleSigDecl.ModuleAbbrev (ident, longIdent, range) -> { Type = SynModuleSigDecl_ModuleAbbrev @@ -1817,23 +1740,22 @@ module private Ast = Properties = p [ "ident" ==> i ident "longIdent" ==> li longIdent ] - FsAstNode = ast - Childs = [] } + FsAstNode = ast } + |> List.singleton | SynModuleSigDecl.NestedModule (sci, isRecursive, decls, range) -> { Type = SynModuleSigDecl_NestedModule Range = r range Properties = p [ "isRecursive" ==> isRecursive ] - FsAstNode = ast - Childs = - [ yield visitSynComponentInfo sci - yield! (decls |> List.map visitSynModuleSigDecl) ] } + FsAstNode = ast } + :: [ yield! visitSynComponentInfo sci + yield! (decls |> List.collect visitSynModuleSigDecl) ] | SynModuleSigDecl.Val (SynValSig.ValSpfn _ as node, _) -> visitSynValSig node | SynModuleSigDecl.Types (typeDefs, range) -> { Type = SynModuleSigDecl_Types Range = r range Properties = p [] - FsAstNode = ast - Childs = typeDefs |> List.map visitSynTypeDefnSig } + FsAstNode = ast } + :: (List.collect visitSynTypeDefnSig typeDefs) | SynModuleSigDecl.Open (target, parentRange) -> // we use the parent ranges here to match up with the trivia parsed match target with @@ -1841,43 +1763,42 @@ module private Ast = { Type = SynModuleSigDecl_Open Range = r parentRange Properties = p [ "longIdent" ==> li longIdent ] - FsAstNode = target - Childs = [] } + FsAstNode = target } + |> List.singleton | SynOpenDeclTarget.Type (synType, _range) -> { Type = SynModuleSigDecl_OpenType Range = r parentRange Properties = p [] - FsAstNode = target - Childs = [ visitSynType synType ] } + FsAstNode = target } + :: (visitSynType synType) | SynModuleSigDecl.HashDirective (hash, range) -> - { Type = SynModuleSigDecl_HashDirective - Range = r range - Properties = p [] - FsAstNode = ast - Childs = [ visitParsedHashDirective hash ] } + [ { Type = SynModuleSigDecl_HashDirective + Range = r range + Properties = p [] + FsAstNode = ast } + (visitParsedHashDirective hash) ] | SynModuleSigDecl.NamespaceFragment (moduleOrNamespace) -> { Type = SynModuleSigDecl_NamespaceFragment Range = noRange Properties = p [] - FsAstNode = ast - Childs = [ visitSynModuleOrNamespaceSig moduleOrNamespace ] } + FsAstNode = ast } + :: (visitSynModuleOrNamespaceSig moduleOrNamespace) | SynModuleSigDecl.Exception (synExceptionSig, range) -> { Type = SynModuleSigDecl_Exception Range = r range Properties = p [] - FsAstNode = ast - Childs = [ visitSynExceptionSig synExceptionSig ] } + FsAstNode = ast } + :: (visitSynExceptionSig synExceptionSig) - and visitSynExceptionSig (exceptionDef: SynExceptionSig) : Node = + and visitSynExceptionSig (exceptionDef: SynExceptionSig) : Node list = match exceptionDef with | SynExceptionSig (sedr, members, range) -> { Type = SynExceptionSig_ Range = r range Properties = p [] - FsAstNode = exceptionDef - Childs = - [ yield visitSynExceptionDefnRepr sedr - yield! (members |> List.map visitSynMemberSig) ] } + FsAstNode = exceptionDef } + :: [ yield! visitSynExceptionDefnRepr sedr + yield! (members |> List.collect visitSynMemberSig) ] and visitLongIdentWithDots (lid: LongIdentWithDots) : Node list = match lid with @@ -1889,26 +1810,25 @@ module private Ast = { Type = Ident_ Range = r ident.idRange Properties = Map.empty - FsAstNode = ident - Childs = [] } + FsAstNode = ident } -let astToNode (hds: ParsedHashDirective list) (mdls: SynModuleOrNamespace list) : Node = +let astToNode (hds: ParsedHashDirective list) (mdls: SynModuleOrNamespace list) : Node list = let children = - [ yield! List.map Ast.visit mdls + [ yield! List.collect Ast.visit mdls yield! List.map Ast.visitParsedHashDirective hds ] { Type = File_ Range = None Properties = Map.empty - FsAstNode = mdls - Childs = children } + FsAstNode = mdls } + :: children -let sigAstToNode (ast: SynModuleOrNamespaceSig list) : Node = +let sigAstToNode (ast: SynModuleOrNamespaceSig list) : Node list = let children = - List.map Ast.visitSynModuleOrNamespaceSig ast + List.collect Ast.visitSynModuleOrNamespaceSig ast { Type = SigFile_ Range = None Properties = Map.empty - FsAstNode = ast - Childs = children } + FsAstNode = ast } + :: children diff --git a/src/Fantomas/Trivia.fs b/src/Fantomas/Trivia.fs index 0274f19ba9..a2f4420513 100644 --- a/src/Fantomas/Trivia.fs +++ b/src/Fantomas/Trivia.fs @@ -33,13 +33,6 @@ let isToken (node: TriviaNode) = | Token _ -> true | _ -> false -let rec private flattenNodeToList (node: Node) = - [ yield node - yield! - (node.Childs - |> List.map flattenNodeToList - |> List.collect id) ] - let filterNodes nodes = let filterOutNodeTypes = set [ SynExpr_Sequential // some Sequential nodes are not visited in CodePrinter @@ -536,20 +529,20 @@ let private triviaNodeIsNotEmpty (triviaNode: TriviaNodeAssigner) = 4. genTrivia should use ranges to identify what extra content should be added from what triviaNode *) let collectTrivia (mkRange: MkRange) tokens (ast: ParsedInput) = - let node = + let nodes = match ast with | ParsedInput.ImplFile (ParsedImplFileInput.ParsedImplFileInput (_, _, _, _, hds, mns, _)) -> astToNode hds mns | ParsedInput.SigFile (ParsedSigFileInput.ParsedSigFileInput (_, _, _, _, mns)) -> sigAstToNode mns let startOfSourceCode = - match node.Range with - | Some r -> r.StartLine - | None -> 1 + match nodes with + | { Range = Some r } :: _ -> r.StartLine + | _ -> 1 let triviaNodesFromAST = - flattenNodeToList node - |> filterNodes + nodes + |> filterNodes // TODO: perhaps not capture in the first place? |> List.choose mapNodeToTriviaNode let hasAnyAttributesWithLinesBetweenParent = From 69939af75c2cf9fe7cae8cbcaaab9dcb66328734 Mon Sep 17 00:00:00 2001 From: nojaf Date: Sat, 27 Feb 2021 15:04:13 +0100 Subject: [PATCH 2/8] Add Continuation.sequence to AstTransformer.fs. --- src/Fantomas/AstTransformer.fs | 1706 +++++++++++++++++++------------- src/Fantomas/Fantomas.fsproj | 4 +- src/Fantomas/Utils.fs | 7 + 3 files changed, 1023 insertions(+), 694 deletions(-) diff --git a/src/Fantomas/AstTransformer.fs b/src/Fantomas/AstTransformer.fs index 6e840b5954..b05b4df21d 100644 --- a/src/Fantomas/AstTransformer.fs +++ b/src/Fantomas/AstTransformer.fs @@ -3,6 +3,7 @@ module Fantomas.AstTransformer open FSharp.Compiler.Text open FSharp.Compiler.SyntaxTree open Fantomas.TriviaTypes +open Fantomas //let rec (|Sequentials|_|) = // function @@ -40,9 +41,7 @@ module Helpers = module private Ast = open Helpers - let rec visit (ast: SynModuleOrNamespace) : Node list = visitSynModuleOrNamespace ast - - and visitSynModuleOrNamespace (modOrNs: SynModuleOrNamespace) : Node list = + let rec visitSynModuleOrNamespace (modOrNs: SynModuleOrNamespace) : Node list = match modOrNs with | SynModuleOrNamespace (longIdent, isRecursive, synModuleOrNamespaceKind, decls, _, attrs, access, range) -> let collectIdents (idents: LongIdent) = @@ -81,564 +80,827 @@ module private Ast = yield! (decls |> List.collect visitSynModuleDecl) ] and visitSynModuleDecl (ast: SynModuleDecl) : Node list = - match ast with - | SynModuleDecl.ModuleAbbrev (ident, longIdent, range) -> - [ { Type = SynModuleDecl_ModuleAbbrev - Range = r range - Properties = - p [ "ident" ==> i ident - "longIdent" ==> li longIdent ] - FsAstNode = ast } ] - | SynModuleDecl.NestedModule (sci, isRecursive, decls, _, range) -> - { Type = SynModuleDecl_NestedModule - Range = r range - Properties = p [ "isRecursive" ==> isRecursive ] - FsAstNode = ast } - :: [ yield! visitSynComponentInfo sci - yield! (decls |> List.collect visitSynModuleDecl) ] - | SynModuleDecl.Let (_, bindings, range) -> - { Type = SynModuleDecl_Let - Range = r range - Properties = p [] - FsAstNode = ast } - :: (bindings |> List.collect visitSynBinding) - | SynModuleDecl.DoExpr (_, expr, range) -> - { Type = SynModuleDecl_DoExpr - Range = r range - Properties = p [] - FsAstNode = ast } - :: visitSynExpr expr - | SynModuleDecl.Types (typeDefs, range) -> - { Type = SynModuleDecl_Types - Range = r range - Properties = p [] - FsAstNode = ast } - :: (typeDefs |> List.collect visitSynTypeDefn) - | SynModuleDecl.Exception (exceptionDef, range) -> - { Type = SynModuleDecl_Exception - Range = r range - Properties = p [] - FsAstNode = ast } - :: (visitSynExceptionDefn exceptionDef) - | SynModuleDecl.Open (target, parentRange) -> - // we use the parent ranges here to match up with the trivia parsed - match target with - | SynOpenDeclTarget.ModuleOrNamespace (longIdent, _range) -> - { Type = SynModuleDecl_Open - Range = r parentRange - Properties = p [ "longIdent" ==> li longIdent ] + let rec visit (ast: SynModuleDecl) (finalContinuation: Node list -> Node list) : Node list = + match ast with + | SynModuleDecl.ModuleAbbrev (ident, longIdent, range) -> + [ { Type = SynModuleDecl_ModuleAbbrev + Range = r range + Properties = + p [ "ident" ==> i ident + "longIdent" ==> li longIdent ] + FsAstNode = ast } ] + |> finalContinuation + | SynModuleDecl.NestedModule (sci, isRecursive, decls, _, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = decls |> List.map visit + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynModuleDecl_NestedModule + Range = r range + Properties = p [ "isRecursive" ==> isRecursive ] + FsAstNode = ast } + yield! visitSynComponentInfo sci + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynModuleDecl.Let (_, bindings, range) -> + { Type = SynModuleDecl_Let + Range = r range + Properties = p [] FsAstNode = ast } - |> List.singleton - | SynOpenDeclTarget.Type (synType, _range) -> - { Type = SynModuleDecl_OpenType - Range = r parentRange + :: (bindings |> List.collect visitSynBinding) + |> finalContinuation + | SynModuleDecl.DoExpr (_, expr, range) -> + { Type = SynModuleDecl_DoExpr + Range = r range Properties = p [] FsAstNode = ast } - :: (visitSynType synType) - | SynModuleDecl.Attributes (attrs, range) -> - { Type = SynModuleDecl_Attributes - Range = r range - Properties = p [] - FsAstNode = ast } - :: (visitSynAttributeLists range attrs) - | SynModuleDecl.HashDirective (hash, range) -> - [ { Type = SynModuleDecl_HashDirective - Range = r range - Properties = p [] - FsAstNode = ast } - visitParsedHashDirective hash ] - | SynModuleDecl.NamespaceFragment (moduleOrNamespace) -> - { Type = SynModuleDecl_NamespaceFragment - Range = noRange - Properties = p [] - FsAstNode = ast } - :: (visitSynModuleOrNamespace moduleOrNamespace) + :: visitSynExpr expr + |> finalContinuation + | SynModuleDecl.Types (typeDefs, range) -> + { Type = SynModuleDecl_Types + Range = r range + Properties = p [] + FsAstNode = ast } + :: (typeDefs |> List.collect visitSynTypeDefn) + |> finalContinuation + | SynModuleDecl.Exception (exceptionDef, range) -> + { Type = SynModuleDecl_Exception + Range = r range + Properties = p [] + FsAstNode = ast } + :: (visitSynExceptionDefn exceptionDef) + |> finalContinuation + | SynModuleDecl.Open (target, parentRange) -> + // we use the parent ranges here to match up with the trivia parsed + match target with + | SynOpenDeclTarget.ModuleOrNamespace (longIdent, _range) -> + { Type = SynModuleDecl_Open + Range = r parentRange + Properties = p [ "longIdent" ==> li longIdent ] + FsAstNode = ast } + |> List.singleton + |> finalContinuation + | SynOpenDeclTarget.Type (synType, _range) -> + { Type = SynModuleDecl_OpenType + Range = r parentRange + Properties = p [] + FsAstNode = ast } + :: (visitSynType synType) + |> finalContinuation + | SynModuleDecl.Attributes (attrs, range) -> + { Type = SynModuleDecl_Attributes + Range = r range + Properties = p [] + FsAstNode = ast } + :: (visitSynAttributeLists range attrs) + |> finalContinuation + | SynModuleDecl.HashDirective (hash, range) -> + [ { Type = SynModuleDecl_HashDirective + Range = r range + Properties = p [] + FsAstNode = ast } + visitParsedHashDirective hash ] + |> finalContinuation + | SynModuleDecl.NamespaceFragment (moduleOrNamespace) -> + { Type = SynModuleDecl_NamespaceFragment + Range = noRange + Properties = p [] + FsAstNode = ast } + :: (visitSynModuleOrNamespace moduleOrNamespace) + |> finalContinuation + + visit ast id and visitSynExpr (synExpr: SynExpr) : Node list = - match synExpr with - | SynExpr.Paren (expr, leftParenRange, rightParenRange, range) -> - { Type = SynExpr_Paren - Range = r range - Properties = - p [ yield "leftParenRange" ==> r leftParenRange - if rightParenRange.IsSome then - yield "rightParenRange" ==> r rightParenRange.Value ] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.Quote (operator, isRaw, quotedSynExpr, isFromQueryExpression, range) -> - { Type = SynExpr_Quote - Range = r range - Properties = - p [ "isRaw" ==> isRaw - "isFromQueryExpression" ==> isFromQueryExpression ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr operator - yield! visitSynExpr quotedSynExpr ] - | SynExpr.Const (constant, range) -> - [ { Type = SynExpr_Const - Range = r range - Properties = p [] - FsAstNode = synExpr } - visitSynConst range constant ] - | SynExpr.Typed (expr, typeName, range) -> - { Type = SynExpr_Typed - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr - yield! visitSynType typeName ] - | SynExpr.Tuple (isStruct, exprs, commaRanges, range) -> - { Type = SynExpr_Tuple - Range = r range - Properties = - p [ "isStruct" ==> isStruct - "commaRanges" ==> (commaRanges |> List.map r) ] - FsAstNode = synExpr } - :: (exprs |> List.collect visitSynExpr) - | SynExpr.ArrayOrList (isList, exprs, range) -> - { Type = SynExpr_ArrayOrList - Range = r range - Properties = p [ "isList" ==> isList ] - FsAstNode = synExpr } - :: (exprs |> List.collect visitSynExpr) - | SynExpr.Record (_, _, recordFields, range) -> - { Type = SynExpr_Record - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (List.collect visitRecordField recordFields) - | SynExpr.AnonRecd (_, _, recordFields, range) -> - { Type = SynExpr_AnonRecd - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (List.collect visitAnonRecordField recordFields) - | SynExpr.New (isProtected, typeName, expr, range) -> - { Type = SynExpr_New - Range = r range - Properties = p [ "isProtected" ==> isProtected ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr - yield! visitSynType typeName ] - | SynExpr.ObjExpr (objType, argOptions, bindings, extraImpls, newExprRange, range) -> - { Type = SynExpr_ObjExpr - Range = r range - Properties = p [ "newExprRange" ==> r newExprRange ] - FsAstNode = synExpr } - :: [ yield! visitSynType objType - if argOptions.IsSome then - yield! visitArgsOption argOptions.Value - yield! extraImpls |> List.collect visitSynInterfaceImpl - yield! bindings |> List.collect visitSynBinding ] - | SynExpr.While (_, whileExpr, doExpr, range) -> - { Type = SynExpr_While - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: [ yield! visitSynExpr whileExpr - yield! visitSynExpr doExpr ] - | SynExpr.For (_, ident, identBody, _, toBody, doBody, range) -> - { Type = SynExpr_For - Range = r range - Properties = p [ "ident" ==> i ident ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr identBody - yield! visitSynExpr toBody - yield! visitSynExpr doBody ] - | SynExpr.ForEach (_, (SeqExprOnly seqExprOnly), isFromSource, pat, enumExpr, bodyExpr, range) -> - { Type = SynExpr_ForEach - Range = r range - Properties = - p [ "isFromSource" ==> isFromSource - "seqExprOnly" ==> seqExprOnly ] - FsAstNode = synExpr } - :: [ yield! visitSynPat pat - yield! visitSynExpr enumExpr - yield! visitSynExpr bodyExpr ] - | SynExpr.ArrayOrListOfSeqExpr (isArray, expr, range) -> - { Type = SynExpr_ArrayOrListOfSeqExpr - Range = r range - Properties = p [ "isArray" ==> isArray ] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.CompExpr (isArrayOrList, isNotNakedRefCell, expr, range) -> - { Type = SynExpr_CompExpr - Range = r range - Properties = - p [ "isArrayOrList" ==> isArrayOrList - "isNotNakedRefCell" ==> isNotNakedRefCell ] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.Lambda (fromMethod, inLambdaSeq, args, body, _parsedData, range) -> - { Type = SynExpr_Lambda - Range = r range - Properties = - p [ "fromMethod" ==> fromMethod - "inLambdaSeq" ==> inLambdaSeq ] - FsAstNode = synExpr } - :: [ yield! visitSynSimplePats args - yield! visitSynExpr body ] - | SynExpr.MatchLambda (isExnMatch, _, matchClauses, _, range) -> - { Type = SynExpr_MatchLambda - Range = r range - Properties = p [ "isExnMatch" ==> isExnMatch ] - FsAstNode = synExpr } - :: (List.collect visitSynMatchClause matchClauses) - | SynExpr.Match (_, expr, clauses, range) -> - { Type = SynExpr_Match - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr - yield! clauses |> List.collect visitSynMatchClause ] - | SynExpr.Do (expr, range) -> - { Type = SynExpr_Do - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.Assert (expr, range) -> - { Type = SynExpr_Assert - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.App (atomicFlag, isInfix, funcExpr, argExpr, range) -> - { Type = SynExpr_App - Range = r range - Properties = - p [ "atomicFlag" - ==> (match atomicFlag with - | ExprAtomicFlag.Atomic -> "Atomic" - | _ -> "Not Atomic") - "isInfix" ==> isInfix ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr funcExpr - yield! visitSynExpr argExpr ] - | SynExpr.TypeApp (expr, lESSrange, typeNames, commaRanges, gREATERrange, typeArgsRange, range) -> - { Type = SynExpr_TypeApp - Range = r range - Properties = - p [ yield "lESSrange" ==> r lESSrange - yield "commaRanges" ==> (commaRanges |> List.map r) - if gREATERrange.IsSome then - yield "gREATERrange" ==> r gREATERrange.Value - yield "typeArgsRange" ==> r typeArgsRange ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr - yield! typeNames |> List.collect visitSynType ] - | SynExpr.LetOrUse (isRecursive, isUse, bindings, body, range) -> - { Type = SynExpr_LetOrUse - Range = r range - Properties = - p [ "isRecursive" ==> isRecursive - "isUse" ==> isUse ] - FsAstNode = synExpr } - :: [ yield! bindings |> List.collect visitSynBinding - yield! visitSynExpr body ] - | SynExpr.TryWith (tryExpr, tryRange, withCases, withRange, range, _, _) -> - { Type = SynExpr_TryWith - Range = r range - Properties = - p [ "tryRange" ==> r tryRange - "withRange" ==> r withRange ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr tryExpr - yield! withCases |> List.collect visitSynMatchClause ] - | SynExpr.TryFinally (tryExpr, finallyExpr, range, _, _) -> - { Type = SynExpr_TryFinally - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: [ yield! visitSynExpr tryExpr - yield! visitSynExpr finallyExpr ] - | SynExpr.Lazy (ex, range) -> - { Type = SynExpr_Lazy - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (visitSynExpr ex) - // | Sequentials xs -> -// let rec cons xs = -// match xs with -// | [] -> failwith "should not happen" // expr2Opt is always Some in last item -// | ((isTrueSeq, expr1, expr2Opt, range) :: rest) -> -// { Type = SynExpr_Sequential -// Range = r range -// Properties = p [ "isTrueSeq" ==> isTrueSeq ] -// FsAstNode = synExpr -// Childs = -// [ yield visitSynExpr expr1 -// yield -// expr2Opt -// |> Option.map visitSynExpr -// |> Option.defaultWith (fun () -> cons rest) ] } -// -// cons xs - | SynExpr.Sequential (_, isTrueSeq, expr1, expr2, range) -> - { Type = SynExpr_Sequential - Range = r range - Properties = p [ "isTrueSeq" ==> isTrueSeq ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr1 - yield! visitSynExpr expr2 ] - | SynExpr.SequentialOrImplicitYield (seqPoint, expr1, expr2, ifNotStmt, range) -> - { Type = SynExpr_SequentialOrImplicitYield - Range = r range - FsAstNode = synExpr - Properties = p [ "seqPoint" ==> seqPoint ] } - :: [ yield! visitSynExpr expr1 - yield! visitSynExpr expr2 - yield! visitSynExpr ifNotStmt ] - | SynExpr.IfThenElse (ifExpr, thenExpr, elseExpr, _, isFromErrorRecovery, ifToThenRange, range) -> - { Type = SynExpr_IfThenElse - Range = r range - Properties = - p [ "isFromErrorRecovery" ==> isFromErrorRecovery - "ifToThenRange" ==> r ifToThenRange ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr ifExpr - yield! visitSynExpr thenExpr - if elseExpr.IsSome then - yield! visitSynExpr elseExpr.Value ] - | SynExpr.Ident (id) -> - { Type = SynExpr_Ident - Range = (i id).Range - Properties = p [ "ident" ==> i id ] - FsAstNode = synExpr } - |> List.singleton - | SynExpr.LongIdent (isOptional, longDotId, _, range) -> - { Type = SynExpr_LongIdent - Range = r range - Properties = - p [ "isOptional" ==> isOptional - "longDotId" ==> lid longDotId ] - FsAstNode = synExpr } - :: (visitLongIdentWithDots longDotId) - | SynExpr.LongIdentSet (longDotId, expr, range) -> - { Type = SynExpr_LongIdentSet - Range = r range - Properties = p [ "longDotId" ==> lid longDotId ] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.DotGet (expr, rangeOfDot, longDotId, range) -> - // Idents are collected as childs here to deal with unit test ``Fluent api with comments should remain on same lines`` - let ids = visitLongIdentWithDots longDotId + let rec visit (synExpr: SynExpr) (finalContinuation: Node list -> Node list) : Node list = + match synExpr with + | SynExpr.Paren (expr, leftParenRange, rightParenRange, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_Paren + Range = r range + Properties = + p [ yield "leftParenRange" ==> r leftParenRange + if rightParenRange.IsSome then + yield "rightParenRange" ==> r rightParenRange.Value ] + FsAstNode = synExpr } + yield! nodes ] + |> finalContinuation) + | SynExpr.Quote (operator, isRaw, quotedSynExpr, isFromQueryExpression, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = + [ visit operator; visit quotedSynExpr ] + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynExpr_Quote + Range = r range + Properties = + p [ "isRaw" ==> isRaw + "isFromQueryExpression" ==> isFromQueryExpression ] + FsAstNode = synExpr } + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.Const (constant, range) -> + [ { Type = SynExpr_Const + Range = r range + Properties = p [] + FsAstNode = synExpr } + visitSynConst range constant ] + |> finalContinuation + | SynExpr.Typed (expr, typeName, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_Typed + Range = r range + Properties = p [] + FsAstNode = synExpr } + yield! nodes + yield! visitSynType typeName ] + |> finalContinuation) + | SynExpr.Tuple (isStruct, exprs, commaRanges, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = exprs |> List.map visit + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynExpr_Tuple + Range = r range + Properties = + p [ "isStruct" ==> isStruct + "commaRanges" ==> (commaRanges |> List.map r) ] + FsAstNode = synExpr } + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.ArrayOrList (isList, exprs, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = exprs |> List.map visit + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynExpr_ArrayOrList + Range = r range + Properties = p [ "isList" ==> isList ] + FsAstNode = synExpr } + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.Record (_, _, recordFields, range) -> + { Type = SynExpr_Record + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: (List.collect visitRecordField recordFields) + |> finalContinuation + | SynExpr.AnonRecd (_, _, recordFields, range) -> + { Type = SynExpr_AnonRecd + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: (List.collect visitAnonRecordField recordFields) + |> finalContinuation + | SynExpr.New (isProtected, typeName, expr, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_New + Range = r range + Properties = p [ "isProtected" ==> isProtected ] + FsAstNode = synExpr } + yield! nodes + yield! visitSynType typeName ] + |> finalContinuation) + | SynExpr.ObjExpr (objType, argOptions, bindings, extraImpls, newExprRange, range) -> + { Type = SynExpr_ObjExpr + Range = r range + Properties = p [ "newExprRange" ==> r newExprRange ] + FsAstNode = synExpr } + :: [ yield! visitSynType objType + if argOptions.IsSome then + yield! visitArgsOption argOptions.Value + yield! extraImpls |> List.collect visitSynInterfaceImpl + yield! bindings |> List.collect visitSynBinding ] + |> finalContinuation + | SynExpr.While (_, whileExpr, doExpr, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit whileExpr; visit doExpr ] + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynExpr_While + Range = r range + Properties = p [] + FsAstNode = synExpr } + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.For (_, ident, identBody, _, toBody, doBody, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = + [ visit identBody + visit toBody + visit doBody ] + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynExpr_For + Range = r range + Properties = p [ "ident" ==> i ident ] + FsAstNode = synExpr } + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.ForEach (_, (SeqExprOnly seqExprOnly), isFromSource, pat, enumExpr, bodyExpr, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit enumExpr; visit bodyExpr ] + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynExpr_ForEach + Range = r range + Properties = + p [ "isFromSource" ==> isFromSource + "seqExprOnly" ==> seqExprOnly ] + FsAstNode = synExpr } + yield! visitSynPat pat + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.ArrayOrListOfSeqExpr (isArray, expr, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_ArrayOrListOfSeqExpr + Range = r range + Properties = p [ "isArray" ==> isArray ] + FsAstNode = synExpr } + yield! nodes ] + |> finalContinuation) + | SynExpr.CompExpr (isArrayOrList, isNotNakedRefCell, expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_CompExpr + Range = r range + Properties = + p [ "isArrayOrList" ==> isArrayOrList + "isNotNakedRefCell" ==> isNotNakedRefCell ] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.Lambda (fromMethod, inLambdaSeq, args, body, _parsedData, range) -> + visit + body + (fun nodes -> + [ { Type = SynExpr_Lambda + Range = r range + Properties = + p [ "fromMethod" ==> fromMethod + "inLambdaSeq" ==> inLambdaSeq ] + FsAstNode = synExpr } + yield! visitSynSimplePats args + yield! nodes ] + |> finalContinuation) + | SynExpr.MatchLambda (isExnMatch, _, matchClauses, _, range) -> + { Type = SynExpr_MatchLambda + Range = r range + Properties = p [ "isExnMatch" ==> isExnMatch ] + FsAstNode = synExpr } + :: (List.collect visitSynMatchClause matchClauses) + |> finalContinuation + | SynExpr.Match (_, expr, clauses, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_Match + Range = r range + Properties = p [] + FsAstNode = synExpr } + yield! nodes + yield! (List.collect visitSynMatchClause clauses) ] + |> finalContinuation) + | SynExpr.Do (expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_Do + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.Assert (expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_Assert + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.App (atomicFlag, isInfix, funcExpr, argExpr, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit funcExpr; visit argExpr ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynExpr_App + Range = r range + Properties = + p [ "atomicFlag" + ==> (match atomicFlag with + | ExprAtomicFlag.Atomic -> "Atomic" + | _ -> "Not Atomic") + "isInfix" ==> isInfix ] + FsAstNode = synExpr } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.TypeApp (expr, lESSrange, typeNames, commaRanges, gREATERrange, typeArgsRange, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_TypeApp + Range = r range + Properties = + p [ yield "lESSrange" ==> r lESSrange + yield "commaRanges" ==> (commaRanges |> List.map r) + if gREATERrange.IsSome then + yield "gREATERrange" ==> r gREATERrange.Value + yield "typeArgsRange" ==> r typeArgsRange ] + FsAstNode = synExpr } + yield! nodes + yield! (List.collect visitSynType typeNames) ] + |> finalContinuation) + | SynExpr.LetOrUse (isRecursive, isUse, bindings, body, range) -> + visit + body + (fun nodes -> + [ { Type = SynExpr_LetOrUse + Range = r range + Properties = + p [ "isRecursive" ==> isRecursive + "isUse" ==> isUse ] + FsAstNode = synExpr } + yield! bindings |> List.collect visitSynBinding + yield! nodes ] + |> finalContinuation) + | SynExpr.TryWith (tryExpr, tryRange, withCases, withRange, range, _, _) -> + visit + tryExpr + (fun nodes -> + [ { Type = SynExpr_TryWith + Range = r range + Properties = + p [ "tryRange" ==> r tryRange + "withRange" ==> r withRange ] + FsAstNode = synExpr } + yield! nodes + yield! withCases |> List.collect visitSynMatchClause ] + |> finalContinuation) + | SynExpr.TryFinally (tryExpr, finallyExpr, range, _, _) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit tryExpr; visit finallyExpr ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynExpr_TryFinally + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.Lazy (ex, range) -> + visit + ex + (fun nodes -> + { Type = SynExpr_Lazy + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + // | Sequentials xs -> + // let rec cons xs = + // match xs with + // | [] -> failwith "should not happen" // expr2Opt is always Some in last item + // | ((isTrueSeq, expr1, expr2Opt, range) :: rest) -> + // { Type = SynExpr_Sequential + // Range = r range + // Properties = p [ "isTrueSeq" ==> isTrueSeq ] + // FsAstNode = synExpr + // Childs = + // [ yield visitSynExpr expr1 + // yield + // expr2Opt + // |> Option.map visitSynExpr + // |> Option.defaultWith (fun () -> cons rest) ] } + // + // cons xs + | SynExpr.Sequential (_, isTrueSeq, expr1, expr2, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr1; visit expr2 ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynExpr_Sequential + Range = r range + Properties = p [ "isTrueSeq" ==> isTrueSeq ] + FsAstNode = synExpr } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.SequentialOrImplicitYield (seqPoint, expr1, expr2, ifNotStmt, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = + [ visit expr1 + visit expr2 + visit ifNotStmt ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynExpr_SequentialOrImplicitYield + Range = r range + FsAstNode = synExpr + Properties = p [ "seqPoint" ==> seqPoint ] } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.IfThenElse (ifExpr, thenExpr, elseExpr, _, isFromErrorRecovery, ifToThenRange, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = + [ visit ifExpr + visit thenExpr + yield! (Option.toList elseExpr |> List.map visit) ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynExpr_IfThenElse + Range = r range + Properties = + p [ "isFromErrorRecovery" ==> isFromErrorRecovery + "ifToThenRange" ==> r ifToThenRange ] + FsAstNode = synExpr } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.Ident (id) -> + { Type = SynExpr_Ident + Range = (i id).Range + Properties = p [ "ident" ==> i id ] + FsAstNode = synExpr } + |> List.singleton + |> finalContinuation + | SynExpr.LongIdent (isOptional, longDotId, _, range) -> + { Type = SynExpr_LongIdent + Range = r range + Properties = + p [ "isOptional" ==> isOptional + "longDotId" ==> lid longDotId ] + FsAstNode = synExpr } + :: (visitLongIdentWithDots longDotId) + |> finalContinuation + | SynExpr.LongIdentSet (longDotId, expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_LongIdentSet + Range = r range + Properties = p [ "longDotId" ==> lid longDotId ] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.DotGet (expr, rangeOfDot, longDotId, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_DotGet + Range = r range + Properties = + p [ "rangeOfDot" ==> r rangeOfDot + "longDotId" ==> lid longDotId ] + FsAstNode = synExpr } + yield! nodes + // Idents are collected as childs here to deal with unit test ``Fluent api with comments should remain on same lines`` + yield! (visitLongIdentWithDots longDotId) ] + |> finalContinuation) + | SynExpr.DotSet (expr, longDotId, e2, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr; visit e2 ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynExpr_DotSet + Range = r range + Properties = p [ "longDotId" ==> lid longDotId ] + FsAstNode = synExpr } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.Set (e1, e2, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit e1; visit e2 ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynExpr_Set + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.DotIndexedGet (objectExpr, indexExprs, dotRange, range) -> + visit + objectExpr + (fun nodes -> + [ { Type = SynExpr_DotIndexedGet + Range = r range + Properties = p [ "dotRange" ==> r dotRange ] + FsAstNode = synExpr } + yield! nodes + yield! indexExprs |> List.collect visitSynIndexerArg ] + |> finalContinuation) + | SynExpr.DotIndexedSet (objectExpr, indexExprs, valueExpr, leftOfSetRange, dotRange, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit objectExpr; visit valueExpr ] + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynExpr_DotIndexedSet + Range = r range + Properties = + p [ "leftOfSetRange" ==> r leftOfSetRange + "dotRange" ==> r dotRange ] + FsAstNode = synExpr } + yield! (List.collect id nodes) + yield! indexExprs |> List.collect visitSynIndexerArg ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.NamedIndexedPropertySet (longDotId, e1, e2, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit e1; visit e2 ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynExpr_NamedIndexedPropertySet + Range = r range + Properties = p [ "longDotId" ==> lid longDotId ] + FsAstNode = synExpr } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.DotNamedIndexedPropertySet (expr, longDotId, e1, e2, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr; visit e1; visit e2 ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynExpr_DotNamedIndexedPropertySet + Range = r range + Properties = p [ "longDotId" ==> lid longDotId ] + FsAstNode = synExpr } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.TypeTest (expr, typeName, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_TypeTest + Range = r range + Properties = p [] + FsAstNode = synExpr } + yield! nodes + yield! visitSynType typeName ] + |> finalContinuation) + | SynExpr.Upcast (expr, typeName, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_Upcast + Range = r range + Properties = p [] + FsAstNode = synExpr } + yield! nodes + yield! visitSynType typeName ] + |> finalContinuation) + | SynExpr.Downcast (expr, typeName, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_Downcast + Range = r range + Properties = p [] + FsAstNode = synExpr } + yield! nodes + yield! visitSynType typeName ] + |> finalContinuation) + | SynExpr.InferredUpcast (expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_InferredUpcast + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.InferredDowncast (expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_InferredDowncast + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.Null (range) -> + { Type = SynExpr_Null + Range = r range + Properties = p [] + FsAstNode = synExpr } + |> List.singleton + |> finalContinuation + | SynExpr.AddressOf (isByref, expr, refRange, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_AddressOf + Range = r range + Properties = + p [ "isByref" ==> isByref + "refRange" ==> r refRange ] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.TraitCall (typars, sign, expr, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_TraitCall + Range = r range + Properties = p [] + FsAstNode = synExpr } + yield! typars |> List.collect visitSynTypar + yield! visitSynMemberSig sign + yield! nodes ] + |> finalContinuation) + | SynExpr.JoinIn (expr, inrange, expr2, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr; visit expr2 ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynExpr_JoinIn + Range = r range + Properties = p [ "inRange" ==> r inrange ] + FsAstNode = synExpr } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.ImplicitZero (range) -> + { Type = SynExpr_ImplicitZero + Range = r range + Properties = p [] + FsAstNode = synExpr } + |> List.singleton + |> finalContinuation + | SynExpr.YieldOrReturn (_, expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_YieldOrReturn + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.YieldOrReturnFrom (_, expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_YieldOrReturnFrom + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.LetOrUseBang (_, isUse, isFromSource, pat, rhsExpr, andBangs, body, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = + [ visit rhsExpr + visit body + yield! (List.map (fun (_, _, _, _, body, _) -> visit body) andBangs) ] + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynExpr_LetOrUseBang + Range = r range + Properties = + p [ "isUse" ==> isUse + "isFromSource" ==> isFromSource ] + FsAstNode = synExpr } + yield! visitSynPat pat + yield! (List.collect id nodes) + yield! + andBangs + |> List.collect (fun (_, _, _, pat, _, _) -> visitSynPat pat) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.MatchBang (_, expr, clauses, range) -> + visit + expr + (fun nodes -> + [ { Type = SynExpr_MatchBang + Range = r range + Properties = p [] + FsAstNode = synExpr } + yield! nodes + yield! clauses |> List.collect visitSynMatchClause ] + |> finalContinuation) + | SynExpr.DoBang (expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_DoBang + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.LibraryOnlyILAssembly (_, _, _, _, range) -> + { Type = SynExpr_LibraryOnlyILAssembly + Range = r range + Properties = p [] + FsAstNode = synExpr } + |> List.singleton + |> finalContinuation + | SynExpr.LibraryOnlyStaticOptimization (_, _, _, range) -> + { Type = SynExpr_LibraryOnlyStaticOptimization + Range = r range + Properties = p [] + FsAstNode = synExpr } + |> List.singleton + |> finalContinuation + | SynExpr.LibraryOnlyUnionCaseFieldGet (expr, longId, _, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_LibraryOnlyUnionCaseFieldGet + Range = r range + Properties = p [ "longId" ==> li longId ] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.LibraryOnlyUnionCaseFieldSet (e1, longId, _, e2, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit e1; visit e2 ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynExpr_LibraryOnlyUnionCaseFieldSet + Range = r range + Properties = p [ "longId" ==> li longId ] + FsAstNode = synExpr } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynExpr.ArbitraryAfterError (debugStr, range) -> + { Type = SynExpr_ArbitraryAfterError + Range = r range + Properties = p [ "debugStr" ==> debugStr ] + FsAstNode = synExpr } + |> List.singleton + |> finalContinuation + | SynExpr.FromParseError (expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_FromParseError + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.DiscardAfterMissingQualificationAfterDot (expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_DiscardAfterMissingQualificationAfterDot + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.Fixed (expr, range) -> + visit + expr + (fun nodes -> + { Type = SynExpr_Fixed + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: nodes + |> finalContinuation) + | SynExpr.InterpolatedString (parts, range) -> + { Type = SynExpr_InterpolatedString + Range = r range + Properties = p [] + FsAstNode = synExpr } + :: (List.collect visitSynInterpolatedStringPart parts) + |> finalContinuation - { Type = SynExpr_DotGet - Range = r range - Properties = - p [ "rangeOfDot" ==> r rangeOfDot - "longDotId" ==> lid longDotId ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr; yield! ids ] - | SynExpr.DotSet (expr, longDotId, e2, range) -> - { Type = SynExpr_DotSet - Range = r range - Properties = p [ "longDotId" ==> lid longDotId ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr - yield! visitSynExpr e2 ] - | SynExpr.Set (e1, e2, range) -> - { Type = SynExpr_Set - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: [ yield! visitSynExpr e1 - yield! visitSynExpr e2 ] - | SynExpr.DotIndexedGet (objectExpr, indexExprs, dotRange, range) -> - { Type = SynExpr_DotIndexedGet - Range = r range - Properties = p [ "dotRange" ==> r dotRange ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr objectExpr - yield! indexExprs |> List.collect visitSynIndexerArg ] - | SynExpr.DotIndexedSet (objectExpr, indexExprs, valueExpr, leftOfSetRange, dotRange, range) -> - { Type = SynExpr_DotIndexedSet - Range = r range - Properties = - p [ "leftOfSetRange" ==> r leftOfSetRange - "dotRange" ==> r dotRange ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr objectExpr - yield! indexExprs |> List.collect visitSynIndexerArg - yield! visitSynExpr valueExpr ] - | SynExpr.NamedIndexedPropertySet (longDotId, e1, e2, range) -> - { Type = SynExpr_NamedIndexedPropertySet - Range = r range - Properties = p [ "longDotId" ==> lid longDotId ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr e1 - yield! visitSynExpr e2 ] - | SynExpr.DotNamedIndexedPropertySet (expr, longDotId, e1, e2, range) -> - { Type = SynExpr_DotNamedIndexedPropertySet - Range = r range - Properties = p [ "longDotId" ==> lid longDotId ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr - yield! visitSynExpr e1 - yield! visitSynExpr e2 ] - | SynExpr.TypeTest (expr, typeName, range) -> - { Type = SynExpr_TypeTest - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr - yield! visitSynType typeName ] - | SynExpr.Upcast (expr, typeName, range) -> - { Type = SynExpr_Upcast - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr - yield! visitSynType typeName ] - | SynExpr.Downcast (expr, typeName, range) -> - { Type = SynExpr_Downcast - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr - yield! visitSynType typeName ] - | SynExpr.InferredUpcast (expr, range) -> - { Type = SynExpr_InferredUpcast - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.InferredDowncast (expr, range) -> - { Type = SynExpr_InferredDowncast - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.Null (range) -> - { Type = SynExpr_Null - Range = r range - Properties = p [] - FsAstNode = synExpr } - |> List.singleton - | SynExpr.AddressOf (isByref, expr, refRange, range) -> - { Type = SynExpr_AddressOf - Range = r range - Properties = - p [ "isByref" ==> isByref - "refRange" ==> r refRange ] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.TraitCall (typars, sign, expr, range) -> - { Type = SynExpr_TraitCall - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: [ yield! typars |> List.collect visitSynTypar - yield! visitSynMemberSig sign - yield! visitSynExpr expr ] - | SynExpr.JoinIn (expr, inrange, expr2, range) -> - { Type = SynExpr_JoinIn - Range = r range - Properties = p [ "inRange" ==> r inrange ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr - yield! visitSynExpr expr2 ] - | SynExpr.ImplicitZero (range) -> - { Type = SynExpr_ImplicitZero - Range = r range - Properties = p [] - FsAstNode = synExpr } - |> List.singleton - | SynExpr.YieldOrReturn (_, expr, range) -> - { Type = SynExpr_YieldOrReturn - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.YieldOrReturnFrom (_, expr, range) -> - { Type = SynExpr_YieldOrReturnFrom - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.LetOrUseBang (_, isUse, isFromSource, pat, rhsExpr, andBangs, body, range) -> - { Type = SynExpr_LetOrUseBang - Range = r range - Properties = - p [ "isUse" ==> isUse - "isFromSource" ==> isFromSource ] - FsAstNode = synExpr } - :: [ yield! visitSynPat pat - yield! visitSynExpr rhsExpr - yield! - andBangs - |> List.collect (fun (_, _, _, pat, body, _) -> visitSynPat pat @ (visitSynExpr body)) - yield! visitSynExpr body ] - | SynExpr.MatchBang (_, expr, clauses, range) -> - { Type = SynExpr_MatchBang - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: [ yield! visitSynExpr expr - yield! clauses |> List.collect visitSynMatchClause ] - | SynExpr.DoBang (expr, range) -> - { Type = SynExpr_DoBang - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.LibraryOnlyILAssembly (_, _, _, _, range) -> - { Type = SynExpr_LibraryOnlyILAssembly - Range = r range - Properties = p [] - FsAstNode = synExpr } - |> List.singleton - | SynExpr.LibraryOnlyStaticOptimization (_, _, _, range) -> - { Type = SynExpr_LibraryOnlyStaticOptimization - Range = r range - Properties = p [] - FsAstNode = synExpr } - |> List.singleton - | SynExpr.LibraryOnlyUnionCaseFieldGet (expr, longId, _, range) -> - { Type = SynExpr_LibraryOnlyUnionCaseFieldGet - Range = r range - Properties = p [ "longId" ==> li longId ] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.LibraryOnlyUnionCaseFieldSet (e1, longId, _, e2, range) -> - { Type = SynExpr_LibraryOnlyUnionCaseFieldSet - Range = r range - Properties = p [ "longId" ==> li longId ] - FsAstNode = synExpr } - :: [ yield! visitSynExpr e1 - yield! visitSynExpr e2 ] - | SynExpr.ArbitraryAfterError (debugStr, range) -> - { Type = SynExpr_ArbitraryAfterError - Range = r range - Properties = p [ "debugStr" ==> debugStr ] - FsAstNode = synExpr } - |> List.singleton - | SynExpr.FromParseError (expr, range) -> - { Type = SynExpr_FromParseError - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.DiscardAfterMissingQualificationAfterDot (expr, range) -> - { Type = SynExpr_DiscardAfterMissingQualificationAfterDot - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.Fixed (expr, range) -> - { Type = SynExpr_Fixed - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (visitSynExpr expr) - | SynExpr.InterpolatedString (parts, range) -> - { Type = SynExpr_InterpolatedString - Range = r range - Properties = p [] - FsAstNode = synExpr } - :: (List.collect visitSynInterpolatedStringPart parts) + visit synExpr id and visitSynInterpolatedStringPart (synInterpolatedStringPart: SynInterpolatedStringPart) = match synInterpolatedStringPart with @@ -1061,143 +1323,203 @@ module private Ast = :: [ yield! visitSynType typeName yield! (visitSynAttributeLists range attrs) ] - // TODO: tail and visitSynPat (sp: SynPat) : Node list = - match sp with - | SynPat.Const (sc, range) -> - [ { Type = SynPat_Const - Range = r range - Properties = p [] - FsAstNode = sp } - visitSynConst range sc ] - | SynPat.Wild (range) -> - { Type = SynPat_Wild - Range = r range - Properties = p [] - FsAstNode = sp } - |> List.singleton - | SynPat.Named (synPat, ident, isSelfIdentifier, access, range) -> - { Type = SynPat_Named - Range = r range - Properties = - p [ yield "ident" ==> i ident - yield "isSelfIdentifier" ==> isSelfIdentifier - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = sp } - :: (visitSynPat synPat) - | SynPat.Typed (synPat, synType, range) -> - { Type = SynPat_Typed - Range = r range - Properties = p [] - FsAstNode = sp } - :: [ yield! visitSynPat synPat - yield! visitSynType synType ] - | SynPat.Attrib (synPat, attrs, range) -> - { Type = SynPat_Attrib - Range = r range - Properties = p [] - FsAstNode = sp } - :: [ yield! visitSynPat synPat - yield! (visitSynAttributeLists range attrs) ] - | SynPat.Or (synPat, synPat2, range) -> - { Type = SynPat_Or - Range = r range - Properties = p [] - FsAstNode = sp } - :: [ yield! visitSynPat synPat - yield! visitSynPat synPat2 ] - | SynPat.Ands (pats, range) -> - { Type = SynPat_Ands - Range = r range - Properties = p [] - FsAstNode = sp } - :: (List.collect visitSynPat pats) - | SynPat.LongIdent (longDotId, ident, svtd, ctorArgs, access, range) -> - { Type = SynPat_LongIdent - Range = r range - Properties = - p [ if ident.IsSome then - yield "ident" ==> (ident.Value |> i) - yield "longDotId" ==> lid longDotId - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = sp } - :: [ if svtd.IsSome then - yield! visitSynValTyparDecls svtd.Value - yield! visitSynConstructorArgs ctorArgs ] - | SynPat.Tuple (isStruct, pats, range) -> - { Type = SynPat_Tuple - Range = r range - Properties = p [ "isStruct" ==> isStruct ] - FsAstNode = sp } - :: (List.collect visitSynPat pats) - | SynPat.Paren (pat, range) -> - { Type = SynPat_Paren - Range = r range - Properties = p [] - FsAstNode = sp } - :: visitSynPat pat - | SynPat.ArrayOrList (_, pats, range) -> - { Type = SynPat_ArrayOrList - Range = r range - Properties = p [] - FsAstNode = sp } - :: (List.collect visitSynPat pats) - | SynPat.Record (pats, range) -> - { Type = SynPat_Record - Range = r range - Properties = p [] - FsAstNode = sp } - :: (List.collect (snd >> visitSynPat) pats) - | SynPat.Null (range) -> - { Type = SynPat_Null - Range = r range - Properties = p [] - FsAstNode = sp } - |> List.singleton - | SynPat.OptionalVal (ident, range) -> - { Type = SynPat_OptionalVal - Range = r range - Properties = p [ "ident" ==> i ident ] - FsAstNode = sp } - |> List.singleton - | SynPat.IsInst (typ, range) -> - { Type = SynPat_IsInst - Range = r range - Properties = p [] - FsAstNode = sp } - :: visitSynType typ - | SynPat.QuoteExpr (expr, range) -> - { Type = SynPat_QuoteExpr - Range = r range - Properties = p [] - FsAstNode = sp } - :: visitSynExpr expr - | SynPat.DeprecatedCharRange (c, c2, range) -> - { Type = SynPat_DeprecatedCharRange - Range = r range - Properties = p [ "c" ==> c; "c2" ==> c2 ] - FsAstNode = sp } - |> List.singleton - | SynPat.InstanceMember (ident, ident2, ident3, access, range) -> - { Type = SynPat_InstanceMember - Range = r range - Properties = - p [ yield "ident" ==> i ident - yield "ident2" ==> i ident2 - if ident3.IsSome then - yield "ident3" ==> (ident3.Value |> i) - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = sp } - |> List.singleton - | SynPat.FromParseError (pat, range) -> - { Type = SynPat_FromParseError - Range = r range - Properties = p [] - FsAstNode = sp } - :: (visitSynPat pat) + let rec visit (sp: SynPat) (finalContinuation: Node list -> Node list) : Node list = + match sp with + | SynPat.Const (sc, range) -> + [ { Type = SynPat_Const + Range = r range + Properties = p [] + FsAstNode = sp } + visitSynConst range sc ] + |> finalContinuation + | SynPat.Wild (range) -> + { Type = SynPat_Wild + Range = r range + Properties = p [] + FsAstNode = sp } + |> List.singleton + |> finalContinuation + | SynPat.Named (synPat, ident, isSelfIdentifier, access, range) -> + visit + synPat + (fun nodes -> + { Type = SynPat_Named + Range = r range + Properties = + p [ yield "ident" ==> i ident + yield "isSelfIdentifier" ==> isSelfIdentifier + if access.IsSome then + yield "access" ==> (access.Value |> visitSynAccess) ] + FsAstNode = sp } + :: nodes + |> finalContinuation) + | SynPat.Typed (synPat, synType, range) -> + visit + synPat + (fun nodes -> + [ { Type = SynPat_Typed + Range = r range + Properties = p [] + FsAstNode = sp } + yield! nodes + yield! (visitSynType synType) ] + |> finalContinuation) + | SynPat.Attrib (synPat, attrs, range) -> + visit + synPat + (fun nodes -> + [ { Type = SynPat_Attrib + Range = r range + Properties = p [] + FsAstNode = sp } + yield! nodes + yield! (visitSynAttributeLists range attrs) ] + |> finalContinuation) + | SynPat.Or (synPat, synPat2, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit synPat; visit synPat2 ] + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynPat_Or + Range = r range + Properties = p [] + FsAstNode = sp } + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynPat.Ands (pats, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = pats |> List.map visit + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynPat_Ands + Range = r range + Properties = p [] + FsAstNode = sp } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynPat.LongIdent (longDotId, ident, svtd, ctorArgs, access, range) -> + { Type = SynPat_LongIdent + Range = r range + Properties = + p [ if ident.IsSome then + yield "ident" ==> (ident.Value |> i) + yield "longDotId" ==> lid longDotId + if access.IsSome then + yield "access" ==> (access.Value |> visitSynAccess) ] + FsAstNode = sp } + :: [ if svtd.IsSome then + yield! visitSynValTyparDecls svtd.Value + yield! visitSynConstructorArgs ctorArgs ] + |> finalContinuation + | SynPat.Tuple (isStruct, pats, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = pats |> List.map visit + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynPat_Tuple + Range = r range + Properties = p [ "isStruct" ==> isStruct ] + FsAstNode = sp } + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynPat.Paren (pat, range) -> + visit + pat + (fun nodes -> + { Type = SynPat_Paren + Range = r range + Properties = p [] + FsAstNode = sp } + :: nodes + |> finalContinuation) + | SynPat.ArrayOrList (_, pats, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = pats |> List.map visit + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynPat_ArrayOrList + Range = r range + Properties = p [] + FsAstNode = sp } + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynPat.Record (pats, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = pats |> List.map (snd >> visit) + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynPat_Record + Range = r range + Properties = p [] + FsAstNode = sp } + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynPat.Null (range) -> + { Type = SynPat_Null + Range = r range + Properties = p [] + FsAstNode = sp } + |> List.singleton + |> finalContinuation + | SynPat.OptionalVal (ident, range) -> + { Type = SynPat_OptionalVal + Range = r range + Properties = p [ "ident" ==> i ident ] + FsAstNode = sp } + |> List.singleton + |> finalContinuation + | SynPat.IsInst (typ, range) -> + { Type = SynPat_IsInst + Range = r range + Properties = p [] + FsAstNode = sp } + :: visitSynType typ + |> finalContinuation + | SynPat.QuoteExpr (expr, range) -> + { Type = SynPat_QuoteExpr + Range = r range + Properties = p [] + FsAstNode = sp } + :: visitSynExpr expr + |> finalContinuation + | SynPat.DeprecatedCharRange (c, c2, range) -> + { Type = SynPat_DeprecatedCharRange + Range = r range + Properties = p [ "c" ==> c; "c2" ==> c2 ] + FsAstNode = sp } + |> List.singleton + |> finalContinuation + | SynPat.InstanceMember (ident, ident2, ident3, access, range) -> + { Type = SynPat_InstanceMember + Range = r range + Properties = + p [ yield "ident" ==> i ident + yield "ident2" ==> i ident2 + if ident3.IsSome then + yield "ident3" ==> (ident3.Value |> i) + if access.IsSome then + yield "access" ==> (access.Value |> visitSynAccess) ] + FsAstNode = sp } + |> List.singleton + |> finalContinuation + | SynPat.FromParseError (pat, range) -> + visit + pat + (fun nodes -> + { Type = SynPat_FromParseError + Range = r range + Properties = p [] + FsAstNode = sp } + :: nodes + |> finalContinuation) + + visit sp id and visitSynConstructorArgs (ctorArgs: SynArgPats) : Node list = match ctorArgs with @@ -1814,7 +2136,7 @@ module private Ast = let astToNode (hds: ParsedHashDirective list) (mdls: SynModuleOrNamespace list) : Node list = let children = - [ yield! List.collect Ast.visit mdls + [ yield! List.collect Ast.visitSynModuleOrNamespace mdls yield! List.map Ast.visitParsedHashDirective hds ] { Type = File_ diff --git a/src/Fantomas/Fantomas.fsproj b/src/Fantomas/Fantomas.fsproj index 44df75e5fa..a823a2a12d 100644 --- a/src/Fantomas/Fantomas.fsproj +++ b/src/Fantomas/Fantomas.fsproj @@ -11,11 +11,11 @@ + + - - diff --git a/src/Fantomas/Utils.fs b/src/Fantomas/Utils.fs index de4bb12e73..49d28e428f 100644 --- a/src/Fantomas/Utils.fs +++ b/src/Fantomas/Utils.fs @@ -155,3 +155,10 @@ module Map = module Async = let map f computation = async.Bind(computation, f >> async.Return) + +[] +module Continuation = + let rec sequence<'a, 'ret> (recursions: (('a -> 'ret) -> 'ret) list) (finalContinuation: 'a list -> 'ret) : 'ret = + match recursions with + | [] -> [] |> finalContinuation + | recurse :: recurses -> recurse (fun ret -> sequence recurses (fun rets -> ret :: rets |> finalContinuation)) From 88ca56e3eab439764409748d54097efd95ff37b3 Mon Sep 17 00:00:00 2001 From: nojaf Date: Sat, 27 Feb 2021 15:42:44 +0100 Subject: [PATCH 3/8] Add Continuation.sequence to AstTransformer.fs, part 2 --- src/Fantomas/AstTransformer.fs | 553 +++++++++++++++++++-------------- 1 file changed, 315 insertions(+), 238 deletions(-) diff --git a/src/Fantomas/AstTransformer.fs b/src/Fantomas/AstTransformer.fs index b05b4df21d..8b55431ee1 100644 --- a/src/Fantomas/AstTransformer.fs +++ b/src/Fantomas/AstTransformer.fs @@ -5,12 +5,6 @@ open FSharp.Compiler.SyntaxTree open Fantomas.TriviaTypes open Fantomas -//let rec (|Sequentials|_|) = -// function -// | SynExpr.Sequential (_, isTrueSeq, e, Sequentials es, range) -> Some((isTrueSeq, e, None, range) :: es) -// | SynExpr.Sequential (_, isTrueSeq, e1, e2, range) -> Some [ isTrueSeq, e1, Some e2, range ] -// | _ -> None - type Id = { Ident: string; Range: Range option } type FsAstNode = obj @@ -19,7 +13,6 @@ type Node = { Type: FsAstType Range: Range option Properties: Map - // Childs: Node list FsAstNode: FsAstNode } module Helpers = @@ -479,23 +472,6 @@ module private Ast = FsAstNode = synExpr } :: nodes |> finalContinuation) - // | Sequentials xs -> - // let rec cons xs = - // match xs with - // | [] -> failwith "should not happen" // expr2Opt is always Some in last item - // | ((isTrueSeq, expr1, expr2Opt, range) :: rest) -> - // { Type = SynExpr_Sequential - // Range = r range - // Properties = p [ "isTrueSeq" ==> isTrueSeq ] - // FsAstNode = synExpr - // Childs = - // [ yield visitSynExpr expr1 - // yield - // expr2Opt - // |> Option.map visitSynExpr - // |> Option.defaultWith (fun () -> cons rest) ] } - // - // cons xs | SynExpr.Sequential (_, isTrueSeq, expr1, expr2, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr1; visit expr2 ] @@ -1180,47 +1156,67 @@ module private Ast = yield! visitSynExpr synExpr ] and visitSynSimplePat (sp: SynSimplePat) : Node list = - match sp with - | SynSimplePat.Id (ident, _, isCompilerGenerated, isThisVar, isOptArg, range) -> - { Type = SynSimplePat_Id - Range = r range - Properties = - p [ "isCompilerGenerated" ==> isCompilerGenerated - "isThisVar" ==> isThisVar - "isOptArg" ==> isOptArg - "ident" ==> i ident ] - FsAstNode = sp } - |> List.singleton - | SynSimplePat.Typed (simplePat, typ, range) -> - { Type = SynSimplePat_Typed - Range = r range - Properties = p [] - FsAstNode = sp } - :: [ yield! visitSynSimplePat simplePat - yield! visitSynType typ ] - | SynSimplePat.Attrib (simplePat, attrs, range) -> - { Type = SynSimplePat_Attrib - Range = r range - Properties = p [] - FsAstNode = sp } - :: [ yield! visitSynSimplePat simplePat - yield! (visitSynAttributeLists range attrs) ] + let rec visit (sp: SynSimplePat) (continuation: Node list -> Node list) : Node list = + match sp with + | SynSimplePat.Id (ident, _, isCompilerGenerated, isThisVar, isOptArg, range) -> + { Type = SynSimplePat_Id + Range = r range + Properties = + p [ "isCompilerGenerated" ==> isCompilerGenerated + "isThisVar" ==> isThisVar + "isOptArg" ==> isOptArg + "ident" ==> i ident ] + FsAstNode = sp } + |> List.singleton + |> continuation + | SynSimplePat.Typed (simplePat, typ, range) -> + visit + simplePat + (fun nodes -> + [ { Type = SynSimplePat_Typed + Range = r range + Properties = p [] + FsAstNode = sp } + yield! nodes + yield! visitSynType typ ] + |> continuation) + | SynSimplePat.Attrib (simplePat, attrs, range) -> + visit + simplePat + (fun nodes -> + [ { Type = SynSimplePat_Attrib + Range = r range + Properties = p [] + FsAstNode = sp } + yield! nodes + yield! (visitSynAttributeLists range attrs) ] + |> continuation) + + visit sp id and visitSynSimplePats (sp: SynSimplePats) : Node list = - match sp with - | SynSimplePats.SimplePats (pats, range) -> - { Type = SynSimplePats_SimplePats - Range = r range - Properties = p [] - FsAstNode = sp } - :: [ yield! pats |> List.collect visitSynSimplePat ] - | SynSimplePats.Typed (pats, typ, range) -> - { Type = SynSimplePat_Typed - Range = r range - Properties = p [] - FsAstNode = sp } - :: [ yield! visitSynSimplePats pats - yield! visitSynType typ ] + let rec visit (sp: SynSimplePats) (continuation: Node list -> Node list) = + match sp with + | SynSimplePats.SimplePats (pats, range) -> + { Type = SynSimplePats_SimplePats + Range = r range + Properties = p [] + FsAstNode = sp } + :: (List.collect visitSynSimplePat pats) + |> continuation + | SynSimplePats.Typed (pats, typ, range) -> + visit + pats + (fun nodes -> + [ { Type = SynSimplePat_Typed + Range = r range + Properties = p [] + FsAstNode = sp } + yield! nodes + yield! visitSynType typ ] + |> continuation) + + visit sp id and visitSynBinding (binding: SynBinding) : Node list = match binding with @@ -1815,126 +1811,192 @@ module private Ast = yield! visitSynType typ ] and visitSynType (st: SynType) = - match st with - | SynType.LongIdent (li) -> - { Type = SynType_LongIdent - Range = noRange - Properties = p [] - FsAstNode = st } - :: (visitLongIdentWithDots li) - | SynType.App (typeName, lessRange, typeArgs, commaRanges, greaterRange, isPostfix, range) -> - { Type = SynType_App - Range = r range - Properties = - p [ if lessRange.IsSome then - yield "lessRange" ==> (lessRange.Value |> r) - yield "commaRanges" ==> (commaRanges |> List.map r) - if greaterRange.IsSome then - yield "greaterRange" ==> (greaterRange.Value |> r) - yield "isPostfix" ==> isPostfix ] - FsAstNode = st } - :: [ yield! typeArgs |> List.collect visitSynType - yield! visitSynType typeName ] - | SynType.LongIdentApp (typeName, longDotId, lessRange, typeArgs, commaRanges, greaterRange, range) -> - { Type = SynType_LongIdentApp - Range = r range - Properties = - p [ yield "ident" ==> lid longDotId - if lessRange.IsSome then - yield "lessRange" ==> (lessRange.Value |> r) - yield "commaRanges" ==> (commaRanges |> List.map r) - if greaterRange.IsSome then - yield "greaterRange" ==> (greaterRange.Value |> r) ] - FsAstNode = st } - :: [ yield! typeArgs |> List.collect visitSynType - yield! visitSynType typeName ] - | SynType.Tuple (isStruct, typeNames, range) -> - { Type = SynType_Tuple - Range = r range - Properties = p [ "isStruct" ==> isStruct ] - FsAstNode = st } - :: (List.collect (snd >> visitSynType) typeNames) - | SynType.Array (_, elementType, range) -> - { Type = SynType_Array - Range = r range - Properties = p [] - FsAstNode = st } - :: (visitSynType elementType) - | SynType.Fun (argType, returnType, range) -> - { Type = SynType_Fun - Range = r range - Properties = p [] - FsAstNode = st } - :: [ yield! visitSynType argType - yield! visitSynType returnType ] - | SynType.Var (genericName, range) -> - { Type = SynType_Var - Range = r range - Properties = p [] - FsAstNode = st } - :: (visitSynTypar genericName) - | SynType.Anon (range) -> - { Type = SynType_Anon - Range = r range - Properties = p [] - FsAstNode = st } - |> List.singleton - | SynType.WithGlobalConstraints (typeName, _, range) -> - { Type = SynType_WithGlobalConstraints - Range = r range - Properties = p [] - FsAstNode = st } - :: (visitSynType typeName) - | SynType.HashConstraint (synType, range) -> - { Type = SynType_HashConstraint - Range = r range - Properties = p [] - FsAstNode = st } - :: (visitSynType synType) - | SynType.MeasureDivide (dividendType, divisorType, range) -> - { Type = SynType_MeasureDivide - Range = r range - Properties = p [] - FsAstNode = st } - :: [ yield! visitSynType dividendType - yield! visitSynType divisorType ] - | SynType.MeasurePower (measureType, _, range) -> - { Type = SynType_MeasurePower - Range = r range - Properties = p [] - FsAstNode = st } - :: (visitSynType measureType) - | SynType.StaticConstant (constant, range) -> - { Type = SynType_StaticConstant - Range = r range - Properties = p [] - FsAstNode = st } - :: [ (visitSynConst range constant) ] - | SynType.StaticConstantExpr (expr, range) -> - { Type = SynType_StaticConstantExpr - Range = r range - Properties = p [] - FsAstNode = st } - :: (visitSynExpr expr) - | SynType.StaticConstantNamed (expr, typ, range) -> - { Type = SynType_StaticConstantNamed - Range = r range - Properties = p [] - FsAstNode = st } - :: [ yield! visitSynType expr - yield! visitSynType typ ] - | SynType.AnonRecd (isStruct, typeNames, range) -> - { Type = SynType_AnonRecd - Range = r range - Properties = p [ "isStruct" ==> isStruct ] - FsAstNode = st } - :: (List.collect visitAnonRecordTypeField typeNames) - | SynType.Paren (innerType, range) -> - { Type = SynType_Paren - Range = r range - Properties = p [] - FsAstNode = st } - :: (visitSynType innerType) + let rec visit (st: SynType) (finalContinuation: Node list -> Node list) : Node list = + match st with + | SynType.LongIdent (li) -> + { Type = SynType_LongIdent + Range = noRange + Properties = p [] + FsAstNode = st } + :: (visitLongIdentWithDots li) + |> finalContinuation + | SynType.App (typeName, lessRange, typeArgs, commaRanges, greaterRange, isPostfix, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = + [ yield! (List.map visit typeArgs) + visit typeName ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynType_App + Range = r range + Properties = + p [ if lessRange.IsSome then + yield "lessRange" ==> (lessRange.Value |> r) + yield "commaRanges" ==> (commaRanges |> List.map r) + if greaterRange.IsSome then + yield "greaterRange" ==> (greaterRange.Value |> r) + yield "isPostfix" ==> isPostfix ] + FsAstNode = st } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynType.LongIdentApp (typeName, longDotId, lessRange, typeArgs, commaRanges, greaterRange, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = + [ yield! (List.map visit typeArgs) + visit typeName ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynType_LongIdentApp + Range = r range + Properties = + p [ yield "ident" ==> lid longDotId + if lessRange.IsSome then + yield "lessRange" ==> (lessRange.Value |> r) + yield "commaRanges" ==> (commaRanges |> List.map r) + if greaterRange.IsSome then + yield "greaterRange" ==> (greaterRange.Value |> r) ] + FsAstNode = st } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynType.Tuple (isStruct, typeNames, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = List.map (snd >> visit) typeNames + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynType_Tuple + Range = r range + Properties = p [ "isStruct" ==> isStruct ] + FsAstNode = st } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynType.Array (_, elementType, range) -> + visit + elementType + (fun nodes -> + { Type = SynType_Array + Range = r range + Properties = p [] + FsAstNode = st } + :: nodes + |> finalContinuation) + | SynType.Fun (argType, returnType, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit argType; visit returnType ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynType_Fun + Range = r range + Properties = p [] + FsAstNode = st } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynType.Var (genericName, range) -> + { Type = SynType_Var + Range = r range + Properties = p [] + FsAstNode = st } + :: (visitSynTypar genericName) + |> finalContinuation + | SynType.Anon (range) -> + { Type = SynType_Anon + Range = r range + Properties = p [] + FsAstNode = st } + |> List.singleton + |> finalContinuation + | SynType.WithGlobalConstraints (typeName, _, range) -> + visit + typeName + (fun nodes -> + { Type = SynType_WithGlobalConstraints + Range = r range + Properties = p [] + FsAstNode = st } + :: nodes + |> finalContinuation) + | SynType.HashConstraint (synType, range) -> + visit + synType + (fun nodes -> + { Type = SynType_HashConstraint + Range = r range + Properties = p [] + FsAstNode = st } + :: nodes + |> finalContinuation) + | SynType.MeasureDivide (dividendType, divisorType, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = + [ visit dividendType + visit divisorType ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynType_MeasureDivide + Range = r range + Properties = p [] + FsAstNode = st } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynType.MeasurePower (measureType, _, range) -> + visit + measureType + (fun nodes -> + { Type = SynType_MeasurePower + Range = r range + Properties = p [] + FsAstNode = st } + :: nodes + |> finalContinuation) + | SynType.StaticConstant (constant, range) -> + [ { Type = SynType_StaticConstant + Range = r range + Properties = p [] + FsAstNode = st } + visitSynConst range constant ] + |> finalContinuation + | SynType.StaticConstantExpr (expr, range) -> + { Type = SynType_StaticConstantExpr + Range = r range + Properties = p [] + FsAstNode = st } + :: (visitSynExpr expr) + |> finalContinuation + | SynType.StaticConstantNamed (expr, typ, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr; visit typ ] + + let finalContinuation (nodes: Node list list) : Node list = + { Type = SynType_StaticConstantNamed + Range = r range + Properties = p [] + FsAstNode = st } + :: (List.collect id nodes) + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynType.AnonRecd (isStruct, typeNames, range) -> + { Type = SynType_AnonRecd + Range = r range + Properties = p [ "isStruct" ==> isStruct ] + FsAstNode = st } + :: (List.collect visitAnonRecordTypeField typeNames) + |> finalContinuation + | SynType.Paren (innerType, range) -> + visit + innerType + (fun nodes -> + { Type = SynType_Paren + Range = r range + Properties = p [] + FsAstNode = st } + :: nodes + |> finalContinuation) + + visit st id and visitSynConst (parentRange: Range) (sc: SynConst) : Node = let t = @@ -2036,7 +2098,6 @@ module private Ast = | SynModuleOrNamespaceKind.DeclaredNamespace -> SynModuleOrNamespaceSig_DeclaredNamespace | SynModuleOrNamespaceKind.GlobalNamespace -> SynModuleOrNamespaceSig_GlobalNamespace - { Type = typeName Range = r range Properties = @@ -2055,62 +2116,78 @@ module private Ast = yield! (decls |> List.collect visitSynModuleSigDecl) ] and visitSynModuleSigDecl (ast: SynModuleSigDecl) : Node list = - match ast with - | SynModuleSigDecl.ModuleAbbrev (ident, longIdent, range) -> - { Type = SynModuleSigDecl_ModuleAbbrev - Range = r range - Properties = - p [ "ident" ==> i ident - "longIdent" ==> li longIdent ] - FsAstNode = ast } - |> List.singleton - | SynModuleSigDecl.NestedModule (sci, isRecursive, decls, range) -> - { Type = SynModuleSigDecl_NestedModule - Range = r range - Properties = p [ "isRecursive" ==> isRecursive ] - FsAstNode = ast } - :: [ yield! visitSynComponentInfo sci - yield! (decls |> List.collect visitSynModuleSigDecl) ] - | SynModuleSigDecl.Val (SynValSig.ValSpfn _ as node, _) -> visitSynValSig node - | SynModuleSigDecl.Types (typeDefs, range) -> - { Type = SynModuleSigDecl_Types - Range = r range - Properties = p [] - FsAstNode = ast } - :: (List.collect visitSynTypeDefnSig typeDefs) - | SynModuleSigDecl.Open (target, parentRange) -> - // we use the parent ranges here to match up with the trivia parsed - match target with - | SynOpenDeclTarget.ModuleOrNamespace (longIdent, _range) -> - { Type = SynModuleSigDecl_Open - Range = r parentRange - Properties = p [ "longIdent" ==> li longIdent ] - FsAstNode = target } + let rec visit (ast: SynModuleSigDecl) (finalContinuation: Node list -> Node list) : Node list = + match ast with + | SynModuleSigDecl.ModuleAbbrev (ident, longIdent, range) -> + { Type = SynModuleSigDecl_ModuleAbbrev + Range = r range + Properties = + p [ "ident" ==> i ident + "longIdent" ==> li longIdent ] + FsAstNode = ast } |> List.singleton - | SynOpenDeclTarget.Type (synType, _range) -> - { Type = SynModuleSigDecl_OpenType - Range = r parentRange + |> finalContinuation + | SynModuleSigDecl.NestedModule (sci, isRecursive, decls, range) -> + let continuations : ((Node list -> Node list) -> Node list) list = List.map visit decls + + let finalContinuation (nodes: Node list list) : Node list = + [ { Type = SynModuleSigDecl_NestedModule + Range = r range + Properties = p [ "isRecursive" ==> isRecursive ] + FsAstNode = ast } + yield! visitSynComponentInfo sci + yield! (List.collect id nodes) ] + |> finalContinuation + + Continuation.sequence continuations finalContinuation + | SynModuleSigDecl.Val (SynValSig.ValSpfn _ as node, _) -> visitSynValSig node |> finalContinuation + | SynModuleSigDecl.Types (typeDefs, range) -> + { Type = SynModuleSigDecl_Types + Range = r range Properties = p [] - FsAstNode = target } - :: (visitSynType synType) - | SynModuleSigDecl.HashDirective (hash, range) -> - [ { Type = SynModuleSigDecl_HashDirective - Range = r range - Properties = p [] - FsAstNode = ast } - (visitParsedHashDirective hash) ] - | SynModuleSigDecl.NamespaceFragment (moduleOrNamespace) -> - { Type = SynModuleSigDecl_NamespaceFragment - Range = noRange - Properties = p [] - FsAstNode = ast } - :: (visitSynModuleOrNamespaceSig moduleOrNamespace) - | SynModuleSigDecl.Exception (synExceptionSig, range) -> - { Type = SynModuleSigDecl_Exception - Range = r range - Properties = p [] - FsAstNode = ast } - :: (visitSynExceptionSig synExceptionSig) + FsAstNode = ast } + :: (List.collect visitSynTypeDefnSig typeDefs) + |> finalContinuation + | SynModuleSigDecl.Open (target, parentRange) -> + // we use the parent ranges here to match up with the trivia parsed + match target with + | SynOpenDeclTarget.ModuleOrNamespace (longIdent, _range) -> + { Type = SynModuleSigDecl_Open + Range = r parentRange + Properties = p [ "longIdent" ==> li longIdent ] + FsAstNode = target } + |> List.singleton + |> finalContinuation + | SynOpenDeclTarget.Type (synType, _range) -> + { Type = SynModuleSigDecl_OpenType + Range = r parentRange + Properties = p [] + FsAstNode = target } + :: (visitSynType synType) + |> finalContinuation + | SynModuleSigDecl.HashDirective (hash, range) -> + [ { Type = SynModuleSigDecl_HashDirective + Range = r range + Properties = p [] + FsAstNode = ast } + (visitParsedHashDirective hash) ] + |> finalContinuation + | SynModuleSigDecl.NamespaceFragment (moduleOrNamespace) -> + { Type = SynModuleSigDecl_NamespaceFragment + Range = noRange + Properties = p [] + FsAstNode = ast } + :: (visitSynModuleOrNamespaceSig moduleOrNamespace) + |> finalContinuation + | SynModuleSigDecl.Exception (synExceptionSig, range) -> + { Type = SynModuleSigDecl_Exception + Range = r range + Properties = p [] + FsAstNode = ast } + :: (visitSynExceptionSig synExceptionSig) + |> finalContinuation + + visit ast id and visitSynExceptionSig (exceptionDef: SynExceptionSig) : Node list = match exceptionDef with From 7ec9aa80d40eb982058c9bcdd15decd687007e04 Mon Sep 17 00:00:00 2001 From: nojaf Date: Sat, 27 Feb 2021 16:44:29 +0100 Subject: [PATCH 4/8] Remove unused properties and filter out unused nodes in AstTransformer. --- src/Fantomas/AstTransformer.fs | 818 ++++++++++++++------------------- src/Fantomas/Trivia.fs | 23 +- 2 files changed, 338 insertions(+), 503 deletions(-) diff --git a/src/Fantomas/AstTransformer.fs b/src/Fantomas/AstTransformer.fs index 8b55431ee1..79f91f34f9 100644 --- a/src/Fantomas/AstTransformer.fs +++ b/src/Fantomas/AstTransformer.fs @@ -36,7 +36,7 @@ module private Ast = let rec visitSynModuleOrNamespace (modOrNs: SynModuleOrNamespace) : Node list = match modOrNs with - | SynModuleOrNamespace (longIdent, isRecursive, synModuleOrNamespaceKind, decls, _, attrs, access, range) -> + | SynModuleOrNamespace (longIdent, _, synModuleOrNamespaceKind, decls, _, attrs, _, range) -> let collectIdents (idents: LongIdent) = idents |> List.map @@ -53,43 +53,37 @@ module private Ast = | SynModuleOrNamespaceKind.DeclaredNamespace -> SynModuleOrNamespace_DeclaredNamespace | SynModuleOrNamespaceKind.GlobalNamespace -> SynModuleOrNamespace_GlobalNamespace - { Type = typeName - Range = r range - Properties = - p [ yield "isRecursive" ==> isRecursive - yield - "synModuleOrNamespaceKind" - ==> synModuleOrNamespaceKind - yield "longIdent" ==> li longIdent - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = modOrNs } - :: [ yield! - if synModuleOrNamespaceKind = SynModuleOrNamespaceKind.DeclaredNamespace then - collectIdents longIdent - else - [] - yield! (visitSynAttributeLists range attrs) - yield! (decls |> List.collect visitSynModuleDecl) ] + [ + // LongIdent inside Namespace is being processed as children. + if typeName <> SynModuleOrNamespace_DeclaredNamespace then + { Type = typeName + Range = r range + Properties = Map.empty + FsAstNode = modOrNs } + yield! + if synModuleOrNamespaceKind = SynModuleOrNamespaceKind.DeclaredNamespace then + collectIdents longIdent + else + [] + yield! (visitSynAttributeLists range attrs) + yield! (decls |> List.collect visitSynModuleDecl) ] and visitSynModuleDecl (ast: SynModuleDecl) : Node list = let rec visit (ast: SynModuleDecl) (finalContinuation: Node list -> Node list) : Node list = match ast with - | SynModuleDecl.ModuleAbbrev (ident, longIdent, range) -> + | SynModuleDecl.ModuleAbbrev (_, _, range) -> [ { Type = SynModuleDecl_ModuleAbbrev Range = r range - Properties = - p [ "ident" ==> i ident - "longIdent" ==> li longIdent ] + Properties = Map.empty FsAstNode = ast } ] |> finalContinuation - | SynModuleDecl.NestedModule (sci, isRecursive, decls, _, range) -> + | SynModuleDecl.NestedModule (sci, _, decls, _, range) -> let continuations : ((Node list -> Node list) -> Node list) list = decls |> List.map visit let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynModuleDecl_NestedModule Range = r range - Properties = p [ "isRecursive" ==> isRecursive ] + Properties = Map.empty FsAstNode = ast } yield! visitSynComponentInfo sci yield! (List.collect id nodes) ] @@ -99,66 +93,66 @@ module private Ast = | SynModuleDecl.Let (_, bindings, range) -> { Type = SynModuleDecl_Let Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ast } :: (bindings |> List.collect visitSynBinding) |> finalContinuation | SynModuleDecl.DoExpr (_, expr, range) -> { Type = SynModuleDecl_DoExpr Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ast } :: visitSynExpr expr |> finalContinuation | SynModuleDecl.Types (typeDefs, range) -> { Type = SynModuleDecl_Types Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ast } :: (typeDefs |> List.collect visitSynTypeDefn) |> finalContinuation | SynModuleDecl.Exception (exceptionDef, range) -> { Type = SynModuleDecl_Exception Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ast } :: (visitSynExceptionDefn exceptionDef) |> finalContinuation | SynModuleDecl.Open (target, parentRange) -> // we use the parent ranges here to match up with the trivia parsed match target with - | SynOpenDeclTarget.ModuleOrNamespace (longIdent, _range) -> + | SynOpenDeclTarget.ModuleOrNamespace (_, _range) -> { Type = SynModuleDecl_Open Range = r parentRange - Properties = p [ "longIdent" ==> li longIdent ] + Properties = Map.empty FsAstNode = ast } |> List.singleton |> finalContinuation | SynOpenDeclTarget.Type (synType, _range) -> { Type = SynModuleDecl_OpenType Range = r parentRange - Properties = p [] + Properties = Map.empty FsAstNode = ast } :: (visitSynType synType) |> finalContinuation | SynModuleDecl.Attributes (attrs, range) -> { Type = SynModuleDecl_Attributes Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ast } :: (visitSynAttributeLists range attrs) |> finalContinuation | SynModuleDecl.HashDirective (hash, range) -> [ { Type = SynModuleDecl_HashDirective Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ast } visitParsedHashDirective hash ] |> finalContinuation | SynModuleDecl.NamespaceFragment (moduleOrNamespace) -> { Type = SynModuleDecl_NamespaceFragment Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = ast } :: (visitSynModuleOrNamespace moduleOrNamespace) |> finalContinuation @@ -199,42 +193,38 @@ module private Ast = | SynExpr.Const (constant, range) -> [ { Type = SynExpr_Const Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } visitSynConst range constant ] |> finalContinuation - | SynExpr.Typed (expr, typeName, range) -> + | SynExpr.Typed (expr, typeName, _) -> visit expr (fun nodes -> - [ { Type = SynExpr_Typed - Range = r range - Properties = p [] - FsAstNode = synExpr } - yield! nodes - yield! visitSynType typeName ] - |> finalContinuation) - | SynExpr.Tuple (isStruct, exprs, commaRanges, range) -> + // { Type = SynExpr_Typed +// Range = r range +// Properties = Map.empty +// FsAstNode = synExpr } + nodes @ visitSynType typeName |> finalContinuation) + | SynExpr.Tuple (_, exprs, _, range) -> let continuations : ((Node list -> Node list) -> Node list) list = exprs |> List.map visit let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynExpr_Tuple Range = r range - Properties = - p [ "isStruct" ==> isStruct - "commaRanges" ==> (commaRanges |> List.map r) ] + Properties = Map.empty FsAstNode = synExpr } yield! (List.collect id nodes) ] |> finalContinuation Continuation.sequence continuations finalContinuation - | SynExpr.ArrayOrList (isList, exprs, range) -> + | SynExpr.ArrayOrList (_, exprs, range) -> let continuations : ((Node list -> Node list) -> Node list) list = exprs |> List.map visit let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynExpr_ArrayOrList Range = r range - Properties = p [ "isList" ==> isList ] + Properties = Map.empty FsAstNode = synExpr } yield! (List.collect id nodes) ] |> finalContinuation @@ -243,32 +233,32 @@ module private Ast = | SynExpr.Record (_, _, recordFields, range) -> { Type = SynExpr_Record Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: (List.collect visitRecordField recordFields) |> finalContinuation | SynExpr.AnonRecd (_, _, recordFields, range) -> { Type = SynExpr_AnonRecd Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: (List.collect visitAnonRecordField recordFields) |> finalContinuation - | SynExpr.New (isProtected, typeName, expr, range) -> + | SynExpr.New (_, typeName, expr, range) -> visit expr (fun nodes -> [ { Type = SynExpr_New Range = r range - Properties = p [ "isProtected" ==> isProtected ] + Properties = Map.empty FsAstNode = synExpr } yield! nodes yield! visitSynType typeName ] |> finalContinuation) - | SynExpr.ObjExpr (objType, argOptions, bindings, extraImpls, newExprRange, range) -> + | SynExpr.ObjExpr (objType, argOptions, bindings, extraImpls, _, range) -> { Type = SynExpr_ObjExpr Range = r range - Properties = p [ "newExprRange" ==> r newExprRange ] + Properties = Map.empty FsAstNode = synExpr } :: [ yield! visitSynType objType if argOptions.IsSome then @@ -282,13 +272,13 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynExpr_While Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } yield! (List.collect id nodes) ] |> finalContinuation Continuation.sequence continuations finalContinuation - | SynExpr.For (_, ident, identBody, _, toBody, doBody, range) -> + | SynExpr.For (_, _, identBody, _, toBody, doBody, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ visit identBody visit toBody @@ -297,7 +287,7 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynExpr_For Range = r range - Properties = p [ "ident" ==> i ident ] + Properties = Map.empty FsAstNode = synExpr } yield! (List.collect id nodes) ] |> finalContinuation @@ -318,28 +308,23 @@ module private Ast = |> finalContinuation Continuation.sequence continuations finalContinuation - | SynExpr.ArrayOrListOfSeqExpr (isArray, expr, range) -> + | SynExpr.ArrayOrListOfSeqExpr (_, expr, range) -> visit expr (fun nodes -> [ { Type = SynExpr_ArrayOrListOfSeqExpr Range = r range - Properties = p [ "isArray" ==> isArray ] + Properties = Map.empty FsAstNode = synExpr } yield! nodes ] |> finalContinuation) - | SynExpr.CompExpr (isArrayOrList, isNotNakedRefCell, expr, range) -> - visit - expr - (fun nodes -> - { Type = SynExpr_CompExpr - Range = r range - Properties = - p [ "isArrayOrList" ==> isArrayOrList - "isNotNakedRefCell" ==> isNotNakedRefCell ] - FsAstNode = synExpr } - :: nodes - |> finalContinuation) + | SynExpr.CompExpr (_, _, expr, _) -> visit expr finalContinuation + // { Type = SynExpr_CompExpr +// Range = r range +// Properties = +// p [ "isArrayOrList" ==> isArrayOrList +// "isNotNakedRefCell" ==> isNotNakedRefCell ] +// FsAstNode = synExpr } | SynExpr.Lambda (fromMethod, inLambdaSeq, args, body, _parsedData, range) -> visit body @@ -353,10 +338,10 @@ module private Ast = yield! visitSynSimplePats args yield! nodes ] |> finalContinuation) - | SynExpr.MatchLambda (isExnMatch, _, matchClauses, _, range) -> + | SynExpr.MatchLambda (_, _, matchClauses, _, range) -> { Type = SynExpr_MatchLambda Range = r range - Properties = p [ "isExnMatch" ==> isExnMatch ] + Properties = Map.empty FsAstNode = synExpr } :: (List.collect visitSynMatchClause matchClauses) |> finalContinuation @@ -366,7 +351,7 @@ module private Ast = (fun nodes -> [ { Type = SynExpr_Match Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } yield! nodes yield! (List.collect visitSynMatchClause clauses) ] @@ -377,7 +362,7 @@ module private Ast = (fun nodes -> { Type = SynExpr_Do Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) @@ -387,7 +372,7 @@ module private Ast = (fun nodes -> { Type = SynExpr_Assert Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) @@ -408,34 +393,28 @@ module private Ast = |> finalContinuation Continuation.sequence continuations finalContinuation - | SynExpr.TypeApp (expr, lESSrange, typeNames, commaRanges, gREATERrange, typeArgsRange, range) -> + | SynExpr.TypeApp (expr, _, typeNames, _, _, _, range) -> visit expr (fun nodes -> [ { Type = SynExpr_TypeApp Range = r range - Properties = - p [ yield "lESSrange" ==> r lESSrange - yield "commaRanges" ==> (commaRanges |> List.map r) - if gREATERrange.IsSome then - yield "gREATERrange" ==> r gREATERrange.Value - yield "typeArgsRange" ==> r typeArgsRange ] + Properties = Map.empty FsAstNode = synExpr } yield! nodes yield! (List.collect visitSynType typeNames) ] |> finalContinuation) - | SynExpr.LetOrUse (isRecursive, isUse, bindings, body, range) -> + | SynExpr.LetOrUse (_, _, bindings, body, _) -> visit body (fun nodes -> - [ { Type = SynExpr_LetOrUse - Range = r range - Properties = - p [ "isRecursive" ==> isRecursive - "isUse" ==> isUse ] - FsAstNode = synExpr } - yield! bindings |> List.collect visitSynBinding - yield! nodes ] + // { Type = SynExpr_LetOrUse +// Range = r range +// Properties = +// p [ "isRecursive" ==> isRecursive +// "isUse" ==> isUse ] +// FsAstNode = synExpr } + (List.collect visitSynBinding bindings) @ nodes |> finalContinuation) | SynExpr.TryWith (tryExpr, tryRange, withCases, withRange, range, _, _) -> visit @@ -456,7 +435,7 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = { Type = SynExpr_TryFinally Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: (List.collect id nodes) |> finalContinuation @@ -468,23 +447,22 @@ module private Ast = (fun nodes -> { Type = SynExpr_Lazy Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) - | SynExpr.Sequential (_, isTrueSeq, expr1, expr2, range) -> + | SynExpr.Sequential (_, _, expr1, expr2, _) -> let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr1; visit expr2 ] let finalContinuation (nodes: Node list list) : Node list = - { Type = SynExpr_Sequential - Range = r range - Properties = p [ "isTrueSeq" ==> isTrueSeq ] - FsAstNode = synExpr } - :: (List.collect id nodes) - |> finalContinuation + // { Type = SynExpr_Sequential +// Range = r range +// Properties = Map.empty +// FsAstNode = synExpr } + (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation - | SynExpr.SequentialOrImplicitYield (seqPoint, expr1, expr2, ifNotStmt, range) -> + | SynExpr.SequentialOrImplicitYield (_, expr1, expr2, ifNotStmt, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr1 visit expr2 @@ -494,7 +472,7 @@ module private Ast = { Type = SynExpr_SequentialOrImplicitYield Range = r range FsAstNode = synExpr - Properties = p [ "seqPoint" ==> seqPoint ] } + Properties = Map.empty } :: (List.collect id nodes) |> finalContinuation @@ -519,7 +497,7 @@ module private Ast = | SynExpr.Ident (id) -> { Type = SynExpr_Ident Range = (i id).Range - Properties = p [ "ident" ==> i id ] + Properties = Map.empty FsAstNode = synExpr } |> List.singleton |> finalContinuation @@ -532,37 +510,35 @@ module private Ast = FsAstNode = synExpr } :: (visitLongIdentWithDots longDotId) |> finalContinuation - | SynExpr.LongIdentSet (longDotId, expr, range) -> + | SynExpr.LongIdentSet (_, expr, range) -> visit expr (fun nodes -> { Type = SynExpr_LongIdentSet Range = r range - Properties = p [ "longDotId" ==> lid longDotId ] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) - | SynExpr.DotGet (expr, rangeOfDot, longDotId, range) -> + | SynExpr.DotGet (expr, _, longDotId, range) -> visit expr (fun nodes -> [ { Type = SynExpr_DotGet Range = r range - Properties = - p [ "rangeOfDot" ==> r rangeOfDot - "longDotId" ==> lid longDotId ] + Properties = Map.empty FsAstNode = synExpr } yield! nodes - // Idents are collected as childs here to deal with unit test ``Fluent api with comments should remain on same lines`` + // Idents are collected as children here to deal with unit test ``Fluent api with comments should remain on same lines`` yield! (visitLongIdentWithDots longDotId) ] |> finalContinuation) - | SynExpr.DotSet (expr, longDotId, e2, range) -> + | SynExpr.DotSet (expr, _, e2, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr; visit e2 ] let finalContinuation (nodes: Node list list) : Node list = { Type = SynExpr_DotSet Range = r range - Properties = p [ "longDotId" ==> lid longDotId ] + Properties = Map.empty FsAstNode = synExpr } :: (List.collect id nodes) |> finalContinuation @@ -574,57 +550,55 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = { Type = SynExpr_Set Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation - | SynExpr.DotIndexedGet (objectExpr, indexExprs, dotRange, range) -> + | SynExpr.DotIndexedGet (objectExpr, indexExprs, _, range) -> visit objectExpr (fun nodes -> [ { Type = SynExpr_DotIndexedGet Range = r range - Properties = p [ "dotRange" ==> r dotRange ] + Properties = Map.empty FsAstNode = synExpr } yield! nodes yield! indexExprs |> List.collect visitSynIndexerArg ] |> finalContinuation) - | SynExpr.DotIndexedSet (objectExpr, indexExprs, valueExpr, leftOfSetRange, dotRange, range) -> + | SynExpr.DotIndexedSet (objectExpr, indexExprs, valueExpr, _, _, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ visit objectExpr; visit valueExpr ] let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynExpr_DotIndexedSet Range = r range - Properties = - p [ "leftOfSetRange" ==> r leftOfSetRange - "dotRange" ==> r dotRange ] + Properties = Map.empty FsAstNode = synExpr } yield! (List.collect id nodes) yield! indexExprs |> List.collect visitSynIndexerArg ] |> finalContinuation Continuation.sequence continuations finalContinuation - | SynExpr.NamedIndexedPropertySet (longDotId, e1, e2, range) -> + | SynExpr.NamedIndexedPropertySet (_, e1, e2, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ visit e1; visit e2 ] let finalContinuation (nodes: Node list list) : Node list = { Type = SynExpr_NamedIndexedPropertySet Range = r range - Properties = p [ "longDotId" ==> lid longDotId ] + Properties = Map.empty FsAstNode = synExpr } :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation - | SynExpr.DotNamedIndexedPropertySet (expr, longDotId, e1, e2, range) -> + | SynExpr.DotNamedIndexedPropertySet (expr, _, e1, e2, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr; visit e1; visit e2 ] let finalContinuation (nodes: Node list list) : Node list = { Type = SynExpr_DotNamedIndexedPropertySet Range = r range - Properties = p [ "longDotId" ==> lid longDotId ] + Properties = Map.empty FsAstNode = synExpr } :: (List.collect id nodes) |> finalContinuation @@ -636,7 +610,7 @@ module private Ast = (fun nodes -> [ { Type = SynExpr_TypeTest Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } yield! nodes yield! visitSynType typeName ] @@ -647,7 +621,7 @@ module private Ast = (fun nodes -> [ { Type = SynExpr_Upcast Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } yield! nodes yield! visitSynType typeName ] @@ -658,7 +632,7 @@ module private Ast = (fun nodes -> [ { Type = SynExpr_Downcast Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } yield! nodes yield! visitSynType typeName ] @@ -669,7 +643,7 @@ module private Ast = (fun nodes -> { Type = SynExpr_InferredUpcast Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) @@ -679,26 +653,24 @@ module private Ast = (fun nodes -> { Type = SynExpr_InferredDowncast Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) | SynExpr.Null (range) -> { Type = SynExpr_Null Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } |> List.singleton |> finalContinuation - | SynExpr.AddressOf (isByref, expr, refRange, range) -> + | SynExpr.AddressOf (_, expr, _, range) -> visit expr (fun nodes -> { Type = SynExpr_AddressOf Range = r range - Properties = - p [ "isByref" ==> isByref - "refRange" ==> r refRange ] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) @@ -708,19 +680,19 @@ module private Ast = (fun nodes -> [ { Type = SynExpr_TraitCall Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } yield! typars |> List.collect visitSynTypar yield! visitSynMemberSig sign yield! nodes ] |> finalContinuation) - | SynExpr.JoinIn (expr, inrange, expr2, range) -> + | SynExpr.JoinIn (expr, _, expr2, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr; visit expr2 ] let finalContinuation (nodes: Node list list) : Node list = { Type = SynExpr_JoinIn Range = r range - Properties = p [ "inRange" ==> r inrange ] + Properties = Map.empty FsAstNode = synExpr } :: (List.collect id nodes) |> finalContinuation @@ -729,7 +701,7 @@ module private Ast = | SynExpr.ImplicitZero (range) -> { Type = SynExpr_ImplicitZero Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } |> List.singleton |> finalContinuation @@ -739,7 +711,7 @@ module private Ast = (fun nodes -> { Type = SynExpr_YieldOrReturn Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) @@ -749,11 +721,11 @@ module private Ast = (fun nodes -> { Type = SynExpr_YieldOrReturnFrom Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) - | SynExpr.LetOrUseBang (_, isUse, isFromSource, pat, rhsExpr, andBangs, body, range) -> + | SynExpr.LetOrUseBang (_, _, _, pat, rhsExpr, andBangs, body, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ visit rhsExpr visit body @@ -762,9 +734,7 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynExpr_LetOrUseBang Range = r range - Properties = - p [ "isUse" ==> isUse - "isFromSource" ==> isFromSource ] + Properties = Map.empty FsAstNode = synExpr } yield! visitSynPat pat yield! (List.collect id nodes) @@ -780,7 +750,7 @@ module private Ast = (fun nodes -> [ { Type = SynExpr_MatchBang Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } yield! nodes yield! clauses |> List.collect visitSynMatchClause ] @@ -791,50 +761,50 @@ module private Ast = (fun nodes -> { Type = SynExpr_DoBang Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) | SynExpr.LibraryOnlyILAssembly (_, _, _, _, range) -> { Type = SynExpr_LibraryOnlyILAssembly Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } |> List.singleton |> finalContinuation | SynExpr.LibraryOnlyStaticOptimization (_, _, _, range) -> { Type = SynExpr_LibraryOnlyStaticOptimization Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } |> List.singleton |> finalContinuation - | SynExpr.LibraryOnlyUnionCaseFieldGet (expr, longId, _, range) -> + | SynExpr.LibraryOnlyUnionCaseFieldGet (expr, _, _, range) -> visit expr (fun nodes -> { Type = SynExpr_LibraryOnlyUnionCaseFieldGet Range = r range - Properties = p [ "longId" ==> li longId ] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) - | SynExpr.LibraryOnlyUnionCaseFieldSet (e1, longId, _, e2, range) -> + | SynExpr.LibraryOnlyUnionCaseFieldSet (e1, _, _, e2, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ visit e1; visit e2 ] let finalContinuation (nodes: Node list list) : Node list = { Type = SynExpr_LibraryOnlyUnionCaseFieldSet Range = r range - Properties = p [ "longId" ==> li longId ] + Properties = Map.empty FsAstNode = synExpr } :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation - | SynExpr.ArbitraryAfterError (debugStr, range) -> + | SynExpr.ArbitraryAfterError (_, range) -> { Type = SynExpr_ArbitraryAfterError Range = r range - Properties = p [ "debugStr" ==> debugStr ] + Properties = Map.empty FsAstNode = synExpr } |> List.singleton |> finalContinuation @@ -844,7 +814,7 @@ module private Ast = (fun nodes -> { Type = SynExpr_FromParseError Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) @@ -854,7 +824,7 @@ module private Ast = (fun nodes -> { Type = SynExpr_DiscardAfterMissingQualificationAfterDot Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) @@ -864,14 +834,14 @@ module private Ast = (fun nodes -> { Type = SynExpr_Fixed Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: nodes |> finalContinuation) | SynExpr.InterpolatedString (parts, range) -> { Type = SynExpr_InterpolatedString Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = synExpr } :: (List.collect visitSynInterpolatedStringPart parts) |> finalContinuation @@ -880,16 +850,16 @@ module private Ast = and visitSynInterpolatedStringPart (synInterpolatedStringPart: SynInterpolatedStringPart) = match synInterpolatedStringPart with - | SynInterpolatedStringPart.String (value, range) -> + | SynInterpolatedStringPart.String (_, range) -> { Type = SynInterpolatedStringPart_String Range = r range - Properties = p [ "value", box value ] + Properties = Map.empty FsAstNode = synInterpolatedStringPart } |> List.singleton | SynInterpolatedStringPart.FillExpr (expr, ident) -> { Type = SynInterpolatedStringPart_FillExpr Range = None - Properties = p [] + Properties = Map.empty FsAstNode = synInterpolatedStringPart } :: [ yield! visitSynExpr expr yield! (Option.toList ident |> List.map visitIdent) ] @@ -897,23 +867,23 @@ module private Ast = and visitRecordField ((longId, _) as rfn: RecordFieldName, expr: SynExpr option, _: BlockSeparator option) = { Type = RecordField_ Range = r longId.Range - Properties = p [ "ident" ==> lid longId ] + Properties = Map.empty FsAstNode = rfn } :: (match expr with | Some e -> visitSynExpr e | None -> []) - and visitAnonRecordField (ident: Ident, expr: SynExpr) = + and visitAnonRecordField (_: Ident, expr: SynExpr) = { Type = AnonRecordField_ Range = noRange - Properties = p [ "ident" ==> i ident ] + Properties = Map.empty FsAstNode = expr } :: (visitSynExpr expr) - and visitAnonRecordTypeField (ident: Ident, t: SynType) = + and visitAnonRecordTypeField (_: Ident, t: SynType) = { Type = AnonRecordTypeField_ Range = noRange - Properties = p [ "ident" ==> i ident ] + Properties = Map.empty FsAstNode = t } :: (visitSynType t) @@ -922,31 +892,31 @@ module private Ast = | SynMemberSig.Member (valSig, _, range) -> { Type = SynMemberSig_Member Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ms } :: (visitSynValSig valSig) | SynMemberSig.Interface (typeName, range) -> { Type = SynMemberSig_Interface Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ms } :: (visitSynType typeName) | SynMemberSig.Inherit (typeName, range) -> { Type = SynMemberSig_Inherit Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ms } :: (visitSynType typeName) | SynMemberSig.ValField (f, range) -> { Type = SynMemberSig_ValField Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ms } :: (visitSynField f) | SynMemberSig.NestedType (typedef, range) -> { Type = SynMemberSig_NestedType Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ms } :: (visitSynTypeDefnSig typedef) @@ -955,13 +925,13 @@ module private Ast = | SynIndexerArg.One (e, _fromEnd, _) -> { Type = SynIndexerArg_One Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = ia } :: (visitSynExpr e) | SynIndexerArg.Two (e1, _fromEnd1, e2, _fromEnd2, _, _) -> { Type = SynIndexerArg_Two Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = ia } :: [ yield! visitSynExpr e1 yield! visitSynExpr e2 ] @@ -971,19 +941,17 @@ module private Ast = | SynMatchClause.Clause (pat, e1, e2, _range, _) -> { Type = SynMatchClause_Clause Range = r mc.Range // _range is the same range as pat, see https://github.com/dotnet/fsharp/issues/10877 - Properties = p [] + Properties = Map.empty FsAstNode = mc } :: [ yield! visitSynPat pat if e1.IsSome then yield! visitSynExpr e1.Value yield! visitSynExpr e2 ] - and visitArgsOption (expr: SynExpr, ident: Ident option) = + and visitArgsOption (expr: SynExpr, _: Ident option) = { Type = ArgOptions_ Range = noRange - Properties = - p [ if ident.IsSome then - yield "ident" ==> i ident.Value ] + Properties = Map.empty FsAstNode = expr } :: (visitSynExpr expr) @@ -992,7 +960,7 @@ module private Ast = | InterfaceImpl (typ, bindings, range) -> { Type = InterfaceImpl_ Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ii } :: [ yield! visitSynType typ yield! (bindings |> List.collect visitSynBinding) ] @@ -1002,7 +970,7 @@ module private Ast = | TypeDefn (sci, stdr, members, range) -> { Type = TypeDefn_ Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = td } :: [ yield! visitSynComponentInfo sci yield! visitSynTypeDefnRepr stdr @@ -1010,34 +978,34 @@ module private Ast = and visitSynTypeDefnSig (typeDefSig: SynTypeDefnSig) : Node list = match typeDefSig with - | TypeDefnSig (sci, synTypeDefnSigReprs, memberSig, range) -> - { Type = TypeDefnSig_ - Range = r range - Properties = p [] - FsAstNode = typeDefSig } - :: [ yield! visitSynComponentInfo sci - yield! visitSynTypeDefnSigRepr synTypeDefnSigReprs - yield! (memberSig |> List.collect visitSynMemberSig) ] + | TypeDefnSig (sci, synTypeDefnSigReprs, memberSig, _) -> + // { Type = TypeDefnSig_ +// Range = r range +// Properties = Map.empty +// FsAstNode = typeDefSig } + [ yield! visitSynComponentInfo sci + yield! visitSynTypeDefnSigRepr synTypeDefnSigReprs + yield! (memberSig |> List.collect visitSynMemberSig) ] and visitSynTypeDefnSigRepr (stdr: SynTypeDefnSigRepr) : Node list = match stdr with - | SynTypeDefnSigRepr.ObjectModel (kind, members, range) -> - { Type = SynTypeDefnSigRepr_ObjectModel - Range = r range - Properties = p [] - FsAstNode = stdr } - :: [ yield! visitSynTypeDefnKind kind - yield! (members |> List.collect visitSynMemberSig) ] - | SynTypeDefnSigRepr.Simple (simpleRepr, range) -> - { Type = SynTypeDefnSigRepr_ObjectModel - Range = r range - Properties = p [] - FsAstNode = stdr } - :: (visitSynTypeDefnSimpleRepr simpleRepr) + | SynTypeDefnSigRepr.ObjectModel (kind, members, _) -> + // { Type = SynTypeDefnSigRepr_ObjectModel +// Range = r range +// Properties = Map.empty +// FsAstNode = stdr } + visitSynTypeDefnKind kind + @ (members |> List.collect visitSynMemberSig) + | SynTypeDefnSigRepr.Simple (simpleRepr, _) -> + // { Type = SynTypeDefnSigRepr_ObjectModel +// Range = r range +// Properties = Map.empty +// FsAstNode = stdr } + (visitSynTypeDefnSimpleRepr simpleRepr) | SynTypeDefnSigRepr.Exception (exceptionRepr) -> { Type = SynTypeDefnSigRepr_Exception Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = stdr } :: (visitSynExceptionDefnRepr exceptionRepr) @@ -1046,109 +1014,80 @@ module private Ast = | SynMemberDefn.Open (target, parentRange) -> // we use the parent ranges here to match up with the trivia parsed match target with - | SynOpenDeclTarget.ModuleOrNamespace (longIdent, _range) -> + | SynOpenDeclTarget.ModuleOrNamespace (_, _range) -> { Type = SynMemberDefn_Open Range = r parentRange - Properties = p [ "longIdent" ==> li longIdent ] + Properties = Map.empty FsAstNode = target } |> List.singleton | SynOpenDeclTarget.Type (synType, _range) -> { Type = SynMemberDefn_OpenType Range = r parentRange - Properties = p [] + Properties = Map.empty FsAstNode = target } :: (visitSynType synType) | SynMemberDefn.Member (memberDefn, range) -> { Type = SynMemberDefn_Member Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = mbrDef } :: (visitSynBinding memberDefn) - | SynMemberDefn.ImplicitCtor (access, attrs, ctorArgs, selfIdentifier, _xmlDoc, range) -> + | SynMemberDefn.ImplicitCtor (_, attrs, ctorArgs, _, _xmlDoc, range) -> { Type = SynMemberDefn_ImplicitCtor Range = r range - Properties = - p [ if selfIdentifier.IsSome then - yield "selfIdent" ==> i selfIdentifier.Value - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = mbrDef } :: [ yield! (visitSynAttributeLists range attrs) yield! visitSynSimplePats ctorArgs ] - | SynMemberDefn.ImplicitInherit (inheritType, inheritArgs, inheritAlias, range) -> + | SynMemberDefn.ImplicitInherit (inheritType, inheritArgs, _, range) -> { Type = SynMemberDefn_ImplicitInherit Range = r range - Properties = - p [ if inheritAlias.IsSome then - yield "inheritAlias" ==> i inheritAlias.Value ] + Properties = Map.empty FsAstNode = mbrDef } :: [ yield! visitSynType inheritType yield! visitSynExpr inheritArgs ] - | SynMemberDefn.LetBindings (bindings, isStatic, isRecursive, range) -> + | SynMemberDefn.LetBindings (bindings, _, _, range) -> { Type = SynMemberDefn_LetBindings Range = r range - Properties = - p [ "isStatic" ==> isStatic - "isRecursive" ==> isRecursive ] + Properties = Map.empty FsAstNode = mbrDef } :: (List.collect visitSynBinding bindings) | SynMemberDefn.AbstractSlot (valSig, _, range) -> { Type = SynMemberDefn_AbstractSlot Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = mbrDef } :: (visitSynValSig valSig) | SynMemberDefn.Interface (typ, members, range) -> { Type = SynMemberDefn_Interface Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = mbrDef } :: [ yield! visitSynType typ if members.IsSome then yield! members.Value |> List.collect visitSynMemberDefn ] - | SynMemberDefn.Inherit (typ, ident, range) -> + | SynMemberDefn.Inherit (typ, _, range) -> { Type = SynMemberDefn_Inherit Range = r range - Properties = - p [ if ident.IsSome then - yield "ident" ==> i ident.Value ] + Properties = Map.empty FsAstNode = mbrDef } :: (visitSynType typ) | SynMemberDefn.ValField (fld, range) -> { Type = SynMemberDefn_ValField Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = mbrDef } :: (visitSynField fld) - | SynMemberDefn.NestedType (typeDefn, access, range) -> + | SynMemberDefn.NestedType (typeDefn, _, range) -> { Type = SynMemberDefn_NestedType Range = r range - Properties = - p [ if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = mbrDef } :: (visitSynTypeDefn typeDefn) - | SynMemberDefn.AutoProperty (attrs, - isStatic, - ident, - typeOpt, - propKind, - _, - _, - access, - synExpr, - getSetRange, - range) -> + | SynMemberDefn.AutoProperty (attrs, _, _, typeOpt, _, _, _, _, synExpr, _, range) -> { Type = SynMemberDefn_AutoProperty Range = r range - Properties = - p [ yield "isStatic" ==> isStatic - yield "ident" ==> i ident - yield "propKind" ==> visitMemberKind propKind - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) - if getSetRange.IsSome then - yield "getSetRange" ==> (getSetRange.Value |> r) ] + Properties = Map.empty FsAstNode = mbrDef } :: [ yield! (visitSynAttributeLists range attrs) if typeOpt.IsSome then @@ -1158,14 +1097,10 @@ module private Ast = and visitSynSimplePat (sp: SynSimplePat) : Node list = let rec visit (sp: SynSimplePat) (continuation: Node list -> Node list) : Node list = match sp with - | SynSimplePat.Id (ident, _, isCompilerGenerated, isThisVar, isOptArg, range) -> + | SynSimplePat.Id (_, _, _, _, _, range) -> { Type = SynSimplePat_Id Range = r range - Properties = - p [ "isCompilerGenerated" ==> isCompilerGenerated - "isThisVar" ==> isThisVar - "isOptArg" ==> isOptArg - "ident" ==> i ident ] + Properties = Map.empty FsAstNode = sp } |> List.singleton |> continuation @@ -1175,7 +1110,7 @@ module private Ast = (fun nodes -> [ { Type = SynSimplePat_Typed Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } yield! nodes yield! visitSynType typ ] @@ -1186,7 +1121,7 @@ module private Ast = (fun nodes -> [ { Type = SynSimplePat_Attrib Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } yield! nodes yield! (visitSynAttributeLists range attrs) ] @@ -1200,7 +1135,7 @@ module private Ast = | SynSimplePats.SimplePats (pats, range) -> { Type = SynSimplePats_SimplePats Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } :: (List.collect visitSynSimplePat pats) |> continuation @@ -1210,7 +1145,7 @@ module private Ast = (fun nodes -> [ { Type = SynSimplePat_Typed Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } yield! nodes yield! visitSynType typ ] @@ -1220,7 +1155,7 @@ module private Ast = and visitSynBinding (binding: SynBinding) : Node list = match binding with - | Binding (access, kind, mustInline, isMutable, attrs, _, valData, headPat, returnInfo, expr, range, _) -> + | Binding (_, kind, _, _, attrs, _, valData, headPat, returnInfo, expr, range, _) -> let t = match kind with | SynBindingKind.StandaloneExpression -> StandaloneExpression_ @@ -1229,12 +1164,7 @@ module private Ast = { Type = t Range = r binding.RangeOfBindingAndRhs - Properties = - p [ yield "mustInline" ==> mustInline - yield "isMutable" ==> isMutable - yield "kind" ==> visitSynBindingKind kind - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = binding } :: [ yield! (visitSynAttributeLists range attrs) yield! visitSynValData valData @@ -1245,26 +1175,19 @@ module private Ast = and visitSynValData (svd: SynValData) : Node list = match svd with - | SynValData (_, svi, ident) -> + | SynValData (_, svi, _) -> { Type = SynValData_ Range = noRange - Properties = - p [ if ident.IsSome then - yield "ident" ==> (ident.Value |> i) ] + Properties = Map.empty FsAstNode = svd } :: (visitSynValInfo svi) and visitSynValSig (svs: SynValSig) : Node list = match svs with - | ValSpfn (attrs, ident, explicitValDecls, synType, arity, isInline, isMutable, _, access, expr, range) -> + | ValSpfn (attrs, _, explicitValDecls, synType, arity, _, _, _, _, expr, range) -> { Type = ValSpfn_ Range = r range - Properties = - p [ yield "ident" ==> i ident - yield "isMutable" ==> isMutable - yield "isInline" ==> isInline - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = svs } :: [ yield! (visitSynAttributeLists range attrs) yield! visitSynValTyparDecls explicitValDecls @@ -1278,7 +1201,7 @@ module private Ast = | SynValTyparDecls (typardecls, _, _) -> { Type = SynValTyparDecls_ Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = valTypeDecl } :: (List.collect visitSynTyparDecl typardecls) @@ -1287,20 +1210,17 @@ module private Ast = | TyparDecl (attrs, typar) -> { Type = TyparDecl_ Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = std } :: [ yield! (visitSynAttributeLists typar.Range attrs) yield! visitSynTypar typar ] and visitSynTypar (typar: SynTypar) : Node list = match typar with - | Typar (ident, staticReq, isComGen) -> + | Typar _ -> { Type = Typar_ Range = noRange - Properties = - p [ "ident" ==> i ident - "isComGen" ==> isComGen - "staticReq" ==> visitTyparStaticReq staticReq ] + Properties = Map.empty FsAstNode = typar } |> List.singleton @@ -1314,7 +1234,7 @@ module private Ast = | SynBindingReturnInfo (typeName, range, attrs) -> { Type = SynBindingReturnInfo_ Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = returnInfo } :: [ yield! visitSynType typeName yield! (visitSynAttributeLists range attrs) ] @@ -1325,28 +1245,24 @@ module private Ast = | SynPat.Const (sc, range) -> [ { Type = SynPat_Const Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } visitSynConst range sc ] |> finalContinuation | SynPat.Wild (range) -> { Type = SynPat_Wild Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } |> List.singleton |> finalContinuation - | SynPat.Named (synPat, ident, isSelfIdentifier, access, range) -> + | SynPat.Named (synPat, _, _, _, range) -> visit synPat (fun nodes -> { Type = SynPat_Named Range = r range - Properties = - p [ yield "ident" ==> i ident - yield "isSelfIdentifier" ==> isSelfIdentifier - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = sp } :: nodes |> finalContinuation) @@ -1356,7 +1272,7 @@ module private Ast = (fun nodes -> [ { Type = SynPat_Typed Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } yield! nodes yield! (visitSynType synType) ] @@ -1367,7 +1283,7 @@ module private Ast = (fun nodes -> [ { Type = SynPat_Attrib Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } yield! nodes yield! (visitSynAttributeLists range attrs) ] @@ -1378,7 +1294,7 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynPat_Or Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } yield! (List.collect id nodes) ] |> finalContinuation @@ -1390,33 +1306,28 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = { Type = SynPat_Ands Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation - | SynPat.LongIdent (longDotId, ident, svtd, ctorArgs, access, range) -> + | SynPat.LongIdent (_, _, svtd, ctorArgs, _, range) -> { Type = SynPat_LongIdent Range = r range - Properties = - p [ if ident.IsSome then - yield "ident" ==> (ident.Value |> i) - yield "longDotId" ==> lid longDotId - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = sp } :: [ if svtd.IsSome then yield! visitSynValTyparDecls svtd.Value yield! visitSynConstructorArgs ctorArgs ] |> finalContinuation - | SynPat.Tuple (isStruct, pats, range) -> + | SynPat.Tuple (_, pats, range) -> let continuations : ((Node list -> Node list) -> Node list) list = pats |> List.map visit let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynPat_Tuple Range = r range - Properties = p [ "isStruct" ==> isStruct ] + Properties = Map.empty FsAstNode = sp } yield! (List.collect id nodes) ] |> finalContinuation @@ -1428,7 +1339,7 @@ module private Ast = (fun nodes -> { Type = SynPat_Paren Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } :: nodes |> finalContinuation) @@ -1438,7 +1349,7 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynPat_ArrayOrList Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } yield! (List.collect id nodes) ] |> finalContinuation @@ -1450,7 +1361,7 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynPat_Record Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } yield! (List.collect id nodes) ] |> finalContinuation @@ -1459,48 +1370,42 @@ module private Ast = | SynPat.Null (range) -> { Type = SynPat_Null Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } |> List.singleton |> finalContinuation - | SynPat.OptionalVal (ident, range) -> + | SynPat.OptionalVal (_, range) -> { Type = SynPat_OptionalVal Range = r range - Properties = p [ "ident" ==> i ident ] + Properties = Map.empty FsAstNode = sp } |> List.singleton |> finalContinuation | SynPat.IsInst (typ, range) -> { Type = SynPat_IsInst Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } :: visitSynType typ |> finalContinuation | SynPat.QuoteExpr (expr, range) -> { Type = SynPat_QuoteExpr Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } :: visitSynExpr expr |> finalContinuation - | SynPat.DeprecatedCharRange (c, c2, range) -> + | SynPat.DeprecatedCharRange (_, _, range) -> { Type = SynPat_DeprecatedCharRange Range = r range - Properties = p [ "c" ==> c; "c2" ==> c2 ] + Properties = Map.empty FsAstNode = sp } |> List.singleton |> finalContinuation - | SynPat.InstanceMember (ident, ident2, ident3, access, range) -> + | SynPat.InstanceMember (_, _, _, _, range) -> { Type = SynPat_InstanceMember Range = r range - Properties = - p [ yield "ident" ==> i ident - yield "ident2" ==> i ident2 - if ident3.IsSome then - yield "ident3" ==> (ident3.Value |> i) - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = sp } |> List.singleton |> finalContinuation @@ -1510,7 +1415,7 @@ module private Ast = (fun nodes -> { Type = SynPat_FromParseError Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sp } :: nodes |> finalContinuation) @@ -1522,49 +1427,45 @@ module private Ast = | Pats (pats) -> { Type = Pats_ Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = ctorArgs } :: (List.collect visitSynPat pats) | NamePatPairs (pats, range) -> { Type = NamePatPairs_ Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ctorArgs } :: (List.collect (snd >> visitSynPat) pats) and visitSynComponentInfo (sci: SynComponentInfo) : Node list = match sci with - | ComponentInfo (attribs, typeParams, _, longId, _, preferPostfix, access, range) -> + | ComponentInfo (attribs, typeParams, _, _, _, _, _, range) -> { Type = ComponentInfo_ Range = r range - Properties = - p [ yield "longIdent" ==> li longId - yield "preferPostfix" ==> preferPostfix - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = sci } :: [ yield! (visitSynAttributeLists range attribs) yield! (typeParams |> List.collect (visitSynTyparDecl)) ] and visitSynTypeDefnRepr (stdr: SynTypeDefnRepr) : Node list = match stdr with - | SynTypeDefnRepr.ObjectModel (kind, members, range) -> - { Type = SynTypeDefnRepr_ObjectModel - Range = r range - Properties = p [] - FsAstNode = stdr } - :: [ yield! visitSynTypeDefnKind kind - yield! (members |> List.collect visitSynMemberDefn) ] - | SynTypeDefnRepr.Simple (simpleRepr, range) -> - { Type = SynTypeDefnRepr_Simple - Range = r range - Properties = p [] - FsAstNode = stdr } - :: (visitSynTypeDefnSimpleRepr simpleRepr) + | SynTypeDefnRepr.ObjectModel (kind, members, _) -> + // { Type = SynTypeDefnRepr_ObjectModel +// Range = r range +// Properties = Map.empty +// FsAstNode = stdr } + visitSynTypeDefnKind kind + @ (members |> List.collect visitSynMemberDefn) + | SynTypeDefnRepr.Simple (simpleRepr, _) -> + // { Type = SynTypeDefnRepr_Simple +// Range = r range +// Properties = Map.empty +// FsAstNode = stdr } + visitSynTypeDefnSimpleRepr simpleRepr | SynTypeDefnRepr.Exception (exceptionRepr) -> { Type = SynTypeDefnRepr_Exception Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = stdr } :: (visitSynExceptionDefnRepr exceptionRepr) @@ -1573,67 +1474,67 @@ module private Ast = | TyconUnspecified -> { Type = SynTypeDefnKind_TyconUnspecified Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = kind } |> List.singleton | TyconClass -> { Type = SynTypeDefnKind_TyconClass Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = kind } |> List.singleton | TyconInterface -> { Type = SynTypeDefnKind_TyconInterface Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = kind } |> List.singleton | TyconStruct -> { Type = SynTypeDefnKind_TyconStruct Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = kind } |> List.singleton | TyconRecord -> { Type = SynTypeDefnKind_TyconRecord Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = kind } |> List.singleton | TyconUnion -> { Type = SynTypeDefnKind_TyconUnion Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = kind } |> List.singleton | TyconAbbrev -> { Type = SynTypeDefnKind_TyconAbbrev Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = kind } |> List.singleton | TyconHiddenRepr -> { Type = SynTypeDefnKind_TyconHiddenRepr Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = kind } |> List.singleton | TyconAugmentation -> { Type = SynTypeDefnKind_TyconAugmentation Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = kind } |> List.singleton | TyconILAssemblyCode -> { Type = SynTypeDefnKind_TyconILAssemblyCode Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = kind } |> List.singleton | TyconDelegate (typ, valinfo) -> { Type = SynTypeDefnKind_TyconDelegate Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = kind } :: [ yield! visitSynType typ yield! visitSynValInfo valinfo ] @@ -1643,53 +1544,49 @@ module private Ast = | SynTypeDefnSimpleRepr.None (range) -> { Type = SynTypeDefnSimpleRepr_None Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = arg } |> List.singleton - | SynTypeDefnSimpleRepr.Union (access, unionCases, range) -> + | SynTypeDefnSimpleRepr.Union (_, unionCases, range) -> { Type = SynTypeDefnSimpleRepr_Union Range = r range - Properties = - p [ if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = arg } :: (List.collect visitSynUnionCase unionCases) | SynTypeDefnSimpleRepr.Enum (enumCases, range) -> { Type = SynTypeDefnSimpleRepr_Enum Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = arg } :: (List.collect visitSynEnumCase enumCases) - | SynTypeDefnSimpleRepr.Record (access, recordFields, range) -> + | SynTypeDefnSimpleRepr.Record (_, recordFields, range) -> { Type = SynTypeDefnSimpleRepr_Record Range = r range - Properties = - p [ if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = arg } :: (List.collect visitSynField recordFields) | SynTypeDefnSimpleRepr.General (_, _, _, _, _, _, _, range) -> { Type = SynTypeDefnSimpleRepr_General Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = arg } |> List.singleton | SynTypeDefnSimpleRepr.LibraryOnlyILAssembly (_, range) -> { Type = SynTypeDefnSimpleRepr_LibraryOnlyILAssembly Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = arg } |> List.singleton | SynTypeDefnSimpleRepr.TypeAbbrev (_, typ, range) -> { Type = SynTypeDefnSimpleRepr_TypeAbbrev Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = arg } :: (visitSynType typ) | SynTypeDefnSimpleRepr.Exception (edr) -> { Type = SynTypeDefnSimpleRepr_Exception Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = arg } :: (visitSynExceptionDefnRepr edr) @@ -1698,21 +1595,17 @@ module private Ast = | SynExceptionDefn (sedr, members, range) -> { Type = SynExceptionDefn_ Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = exceptionDef } :: [ yield! visitSynExceptionDefnRepr sedr yield! (members |> List.collect visitSynMemberDefn) ] and visitSynExceptionDefnRepr (sedr: SynExceptionDefnRepr) : Node list = match sedr with - | SynExceptionDefnRepr (attrs, unionCase, longId, _, access, range) -> + | SynExceptionDefnRepr (attrs, unionCase, _, _, _, range) -> { Type = SynExceptionDefnRepr_ Range = r range - Properties = - p [ if longId.IsSome then - yield "longIdent" ==> (longId.Value |> li) - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = sedr } :: [ yield! (visitSynAttributeLists range attrs) yield! visitSynUnionCase unionCase ] @@ -1720,14 +1613,7 @@ module private Ast = and visitSynAttribute (attr: SynAttribute) : Node list = { Type = SynAttribute_ Range = r attr.Range - Properties = - p [ if attr.Target.IsSome then - yield "target" ==> i attr.Target.Value - yield "typeName" ==> lid attr.TypeName - yield - "appliesToGetterAndSetter" - ==> attr.AppliesToGetterAndSetter - yield "typeName" ==> lid attr.TypeName ] + Properties = Map.empty FsAstNode = attr } :: (visitSynExpr attr.ArgExpr) @@ -1753,13 +1639,10 @@ module private Ast = and visitSynUnionCase (uc: SynUnionCase) : Node list = match uc with - | UnionCase (attrs, ident, uct, _, access, range) -> + | UnionCase (attrs, _, uct, _, _, range) -> { Type = UnionCase_ Range = r range - Properties = - p [ yield "ident" ==> i ident - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = uc } :: [ yield! visitSynUnionCaseType uct yield! (visitSynAttributeLists range attrs) ] @@ -1769,13 +1652,13 @@ module private Ast = | UnionCaseFields (cases) -> { Type = UnionCaseFields_ Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = uct } :: (List.collect visitSynField cases) | UnionCaseFullType (stype, valInfo) -> { Type = UnionCaseFullType_ Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = uct } :: [ yield! visitSynType stype yield! visitSynValInfo valInfo ] @@ -1785,27 +1668,21 @@ module private Ast = | EnumCase (attrs, ident, _, _, range) -> { Type = EnumCase_ Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = sec } :: [ yield! (visitSynAttributeLists range attrs) yield visitIdent ident ] and visitSynField (sfield: SynField) : Node list = match sfield with - | Field (attrs, isStatic, ident, typ, _, _, access, range) -> + | Field (attrs, _, ident, typ, _, _, _, range) -> let parentRange = Option.map (fun (i: Ident) -> i.idRange) ident |> Option.defaultValue range - { Type = Field_ Range = r range - Properties = - p [ if ident.IsSome then - yield "ident" ==> (ident.Value |> i) - yield "isStatic" ==> isStatic - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] + Properties = Map.empty FsAstNode = sfield } :: [ yield! (visitSynAttributeLists parentRange attrs) yield! visitSynType typ ] @@ -1816,11 +1693,11 @@ module private Ast = | SynType.LongIdent (li) -> { Type = SynType_LongIdent Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = st } :: (visitLongIdentWithDots li) |> finalContinuation - | SynType.App (typeName, lessRange, typeArgs, commaRanges, greaterRange, isPostfix, range) -> + | SynType.App (typeName, _, typeArgs, _, _, _, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ yield! (List.map visit typeArgs) visit typeName ] @@ -1828,19 +1705,13 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = { Type = SynType_App Range = r range - Properties = - p [ if lessRange.IsSome then - yield "lessRange" ==> (lessRange.Value |> r) - yield "commaRanges" ==> (commaRanges |> List.map r) - if greaterRange.IsSome then - yield "greaterRange" ==> (greaterRange.Value |> r) - yield "isPostfix" ==> isPostfix ] + Properties = Map.empty FsAstNode = st } :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation - | SynType.LongIdentApp (typeName, longDotId, lessRange, typeArgs, commaRanges, greaterRange, range) -> + | SynType.LongIdentApp (typeName, _, _, typeArgs, _, _, range) -> let continuations : ((Node list -> Node list) -> Node list) list = [ yield! (List.map visit typeArgs) visit typeName ] @@ -1848,25 +1719,19 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = { Type = SynType_LongIdentApp Range = r range - Properties = - p [ yield "ident" ==> lid longDotId - if lessRange.IsSome then - yield "lessRange" ==> (lessRange.Value |> r) - yield "commaRanges" ==> (commaRanges |> List.map r) - if greaterRange.IsSome then - yield "greaterRange" ==> (greaterRange.Value |> r) ] + Properties = Map.empty FsAstNode = st } :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation - | SynType.Tuple (isStruct, typeNames, range) -> + | SynType.Tuple (_, typeNames, range) -> let continuations : ((Node list -> Node list) -> Node list) list = List.map (snd >> visit) typeNames let finalContinuation (nodes: Node list list) : Node list = { Type = SynType_Tuple Range = r range - Properties = p [ "isStruct" ==> isStruct ] + Properties = Map.empty FsAstNode = st } :: (List.collect id nodes) |> finalContinuation @@ -1878,7 +1743,7 @@ module private Ast = (fun nodes -> { Type = SynType_Array Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } :: nodes |> finalContinuation) @@ -1888,7 +1753,7 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = { Type = SynType_Fun Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } :: (List.collect id nodes) |> finalContinuation @@ -1897,14 +1762,14 @@ module private Ast = | SynType.Var (genericName, range) -> { Type = SynType_Var Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } :: (visitSynTypar genericName) |> finalContinuation | SynType.Anon (range) -> { Type = SynType_Anon Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } |> List.singleton |> finalContinuation @@ -1914,7 +1779,7 @@ module private Ast = (fun nodes -> { Type = SynType_WithGlobalConstraints Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } :: nodes |> finalContinuation) @@ -1924,7 +1789,7 @@ module private Ast = (fun nodes -> { Type = SynType_HashConstraint Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } :: nodes |> finalContinuation) @@ -1936,7 +1801,7 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = { Type = SynType_MeasureDivide Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } :: (List.collect id nodes) |> finalContinuation @@ -1948,21 +1813,21 @@ module private Ast = (fun nodes -> { Type = SynType_MeasurePower Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } :: nodes |> finalContinuation) | SynType.StaticConstant (constant, range) -> [ { Type = SynType_StaticConstant Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } visitSynConst range constant ] |> finalContinuation | SynType.StaticConstantExpr (expr, range) -> { Type = SynType_StaticConstantExpr Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } :: (visitSynExpr expr) |> finalContinuation @@ -1972,16 +1837,16 @@ module private Ast = let finalContinuation (nodes: Node list list) : Node list = { Type = SynType_StaticConstantNamed Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation - | SynType.AnonRecd (isStruct, typeNames, range) -> + | SynType.AnonRecd (_, typeNames, range) -> { Type = SynType_AnonRecd Range = r range - Properties = p [ "isStruct" ==> isStruct ] + Properties = Map.empty FsAstNode = st } :: (List.collect visitAnonRecordTypeField typeNames) |> finalContinuation @@ -1991,7 +1856,7 @@ module private Ast = (fun nodes -> { Type = SynType_Paren Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = st } :: nodes |> finalContinuation) @@ -2025,7 +1890,7 @@ module private Ast = { Type = t Range = r (sc.Range parentRange) - Properties = p [] + Properties = Map.empty FsAstNode = sc } and visitSynValInfo (svi: SynValInfo) = @@ -2033,7 +1898,7 @@ module private Ast = | SynValInfo (args, arg) -> { Type = SynValInfo_ Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = svi } :: [ yield! args @@ -2042,7 +1907,7 @@ module private Ast = and visitSynArgInfo (sai: SynArgInfo) : Node list = match sai with - | SynArgInfo (attrs, optional, ident) -> + | SynArgInfo (attrs, _, ident) -> let parentRange = ident |> Option.map (fun i -> i.idRange) @@ -2050,10 +1915,7 @@ module private Ast = { Type = SynArgInfo_ Range = noRange - Properties = - p [ if ident.IsSome then - yield "ident" ==> i ident.Value - yield "optional" ==> optional ] + Properties = Map.empty FsAstNode = sai } :: (visitSynAttributeLists parentRange attrs) @@ -2080,17 +1942,15 @@ module private Ast = and visitParsedHashDirective (hash: ParsedHashDirective) : Node = match hash with - | ParsedHashDirective (ident, longIdent, range) -> + | ParsedHashDirective (_, _, range) -> { Type = ParsedHashDirective_ Range = r range - Properties = - p [ "ident" ==> ident - "longIdent" ==> longIdent ] + Properties = Map.empty FsAstNode = hash } and visitSynModuleOrNamespaceSig (modOrNs: SynModuleOrNamespaceSig) : Node list = match modOrNs with - | SynModuleOrNamespaceSig (longIdent, isRecursive, synModuleOrNamespaceKind, decls, _, attrs, access, range) -> + | SynModuleOrNamespaceSig (longIdent, _, synModuleOrNamespaceKind, decls, _, attrs, _, range) -> let typeName = match synModuleOrNamespaceKind with | SynModuleOrNamespaceKind.AnonModule -> SynModuleOrNamespaceSig_AnonModule @@ -2098,42 +1958,38 @@ module private Ast = | SynModuleOrNamespaceKind.DeclaredNamespace -> SynModuleOrNamespaceSig_DeclaredNamespace | SynModuleOrNamespaceKind.GlobalNamespace -> SynModuleOrNamespaceSig_GlobalNamespace - { Type = typeName - Range = r range - Properties = - p [ yield "isRecursive" ==> isRecursive - yield "isModule" ==> synModuleOrNamespaceKind - yield "longIdent" ==> li longIdent - if access.IsSome then - yield "access" ==> (access.Value |> visitSynAccess) ] - FsAstNode = modOrNs } - :: [ yield! - if synModuleOrNamespaceKind = SynModuleOrNamespaceKind.DeclaredNamespace then - visitLongIdent longIdent - else - [] - yield! (visitSynAttributeLists range attrs) - yield! (decls |> List.collect visitSynModuleSigDecl) ] + [ // LongIdent inside Namespace is being processed as children. + if typeName + <> SynModuleOrNamespaceSig_DeclaredNamespace then + { Type = typeName + Range = r range + Properties = Map.empty + FsAstNode = modOrNs } + yield! + if synModuleOrNamespaceKind = SynModuleOrNamespaceKind.DeclaredNamespace then + visitLongIdent longIdent + else + [] + yield! (visitSynAttributeLists range attrs) + yield! (decls |> List.collect visitSynModuleSigDecl) ] and visitSynModuleSigDecl (ast: SynModuleSigDecl) : Node list = let rec visit (ast: SynModuleSigDecl) (finalContinuation: Node list -> Node list) : Node list = match ast with - | SynModuleSigDecl.ModuleAbbrev (ident, longIdent, range) -> + | SynModuleSigDecl.ModuleAbbrev (_, _, range) -> { Type = SynModuleSigDecl_ModuleAbbrev Range = r range - Properties = - p [ "ident" ==> i ident - "longIdent" ==> li longIdent ] + Properties = Map.empty FsAstNode = ast } |> List.singleton |> finalContinuation - | SynModuleSigDecl.NestedModule (sci, isRecursive, decls, range) -> + | SynModuleSigDecl.NestedModule (sci, _, decls, range) -> let continuations : ((Node list -> Node list) -> Node list) list = List.map visit decls let finalContinuation (nodes: Node list list) : Node list = [ { Type = SynModuleSigDecl_NestedModule Range = r range - Properties = p [ "isRecursive" ==> isRecursive ] + Properties = Map.empty FsAstNode = ast } yield! visitSynComponentInfo sci yield! (List.collect id nodes) ] @@ -2144,45 +2000,45 @@ module private Ast = | SynModuleSigDecl.Types (typeDefs, range) -> { Type = SynModuleSigDecl_Types Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ast } :: (List.collect visitSynTypeDefnSig typeDefs) |> finalContinuation | SynModuleSigDecl.Open (target, parentRange) -> // we use the parent ranges here to match up with the trivia parsed match target with - | SynOpenDeclTarget.ModuleOrNamespace (longIdent, _range) -> + | SynOpenDeclTarget.ModuleOrNamespace (_, _range) -> { Type = SynModuleSigDecl_Open Range = r parentRange - Properties = p [ "longIdent" ==> li longIdent ] + Properties = Map.empty FsAstNode = target } |> List.singleton |> finalContinuation | SynOpenDeclTarget.Type (synType, _range) -> { Type = SynModuleSigDecl_OpenType Range = r parentRange - Properties = p [] + Properties = Map.empty FsAstNode = target } :: (visitSynType synType) |> finalContinuation | SynModuleSigDecl.HashDirective (hash, range) -> [ { Type = SynModuleSigDecl_HashDirective Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ast } (visitParsedHashDirective hash) ] |> finalContinuation | SynModuleSigDecl.NamespaceFragment (moduleOrNamespace) -> { Type = SynModuleSigDecl_NamespaceFragment Range = noRange - Properties = p [] + Properties = Map.empty FsAstNode = ast } :: (visitSynModuleOrNamespaceSig moduleOrNamespace) |> finalContinuation | SynModuleSigDecl.Exception (synExceptionSig, range) -> { Type = SynModuleSigDecl_Exception Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = ast } :: (visitSynExceptionSig synExceptionSig) |> finalContinuation @@ -2194,7 +2050,7 @@ module private Ast = | SynExceptionSig (sedr, members, range) -> { Type = SynExceptionSig_ Range = r range - Properties = p [] + Properties = Map.empty FsAstNode = exceptionDef } :: [ yield! visitSynExceptionDefnRepr sedr yield! (members |> List.collect visitSynMemberSig) ] diff --git a/src/Fantomas/Trivia.fs b/src/Fantomas/Trivia.fs index a2f4420513..2ae4c26383 100644 --- a/src/Fantomas/Trivia.fs +++ b/src/Fantomas/Trivia.fs @@ -33,24 +33,6 @@ let isToken (node: TriviaNode) = | Token _ -> true | _ -> false -let filterNodes nodes = - let filterOutNodeTypes = - set [ SynExpr_Sequential // some Sequential nodes are not visited in CodePrinter - SynModuleOrNamespace_DeclaredNamespace // LongIdent inside Namespace is being processed as children. - SynModuleOrNamespaceSig_DeclaredNamespace - SynExpr_LetOrUse - SynTypeDefnRepr_ObjectModel - SynTypeDefnRepr_Simple - TypeDefnSig_ - SynTypeDefnSigRepr_ObjectModel - SynExpr_Typed - // SynType_StaticConstant - SynExpr_CompExpr ] - // SynExpr_Do ] - - nodes - |> List.filter (fun (n: Node) -> not (Set.contains n.Type filterOutNodeTypes)) - let private findFirstNodeOnLine (nodes: TriviaNode list) lineNumber : TriviaNode option = nodes |> List.filter (fun { Range = r } -> r.StartLine = lineNumber) @@ -540,10 +522,7 @@ let collectTrivia (mkRange: MkRange) tokens (ast: ParsedInput) = | { Range = Some r } :: _ -> r.StartLine | _ -> 1 - let triviaNodesFromAST = - nodes - |> filterNodes // TODO: perhaps not capture in the first place? - |> List.choose mapNodeToTriviaNode + let triviaNodesFromAST = nodes |> List.choose mapNodeToTriviaNode let hasAnyAttributesWithLinesBetweenParent = List.exists (fun (tn: TriviaNodeAssigner) -> Option.isSome tn.AttributeLinesBetweenParent) triviaNodesFromAST From 3e6b6b5800e1471c66ee3b8b5714a55b54dca925 Mon Sep 17 00:00:00 2001 From: nojaf Date: Sat, 27 Feb 2021 19:30:16 +0100 Subject: [PATCH 5/8] Make TriviaNodeAssigner directly in AstTransformer.fs. --- src/Fantomas/AstTransformer.fs | 1584 +++++++++----------------------- src/Fantomas/Trivia.fs | 30 +- 2 files changed, 460 insertions(+), 1154 deletions(-) diff --git a/src/Fantomas/AstTransformer.fs b/src/Fantomas/AstTransformer.fs index 79f91f34f9..3190981bf7 100644 --- a/src/Fantomas/AstTransformer.fs +++ b/src/Fantomas/AstTransformer.fs @@ -5,46 +5,32 @@ open FSharp.Compiler.SyntaxTree open Fantomas.TriviaTypes open Fantomas -type Id = { Ident: string; Range: Range option } +type Id = { Ident: string; Range: Range } -type FsAstNode = obj - -type Node = - { Type: FsAstType - Range: Range option - Properties: Map - FsAstNode: FsAstNode } +//type Node = +// { Type: FsAstType +// Range: Range +// LinesBetweenParent: int } module Helpers = - let r (r: Range) : Range option = Some r - - let p = Map.ofList - let inline (==>) a b = (a, box b) - - let noRange = None - let i (id: Ident) : Id = { Ident = id.idText - Range = r id.idRange } + Range = id.idRange } let li (id: LongIdent) = id |> List.map i let lid (id: LongIdentWithDots) = li id.Lid + let mkNode (t: FsAstType) (r: range) = TriviaNodeAssigner(MainNode(t), r) module private Ast = open Helpers - let rec visitSynModuleOrNamespace (modOrNs: SynModuleOrNamespace) : Node list = + let rec visitSynModuleOrNamespace (modOrNs: SynModuleOrNamespace) : TriviaNodeAssigner list = match modOrNs with | SynModuleOrNamespace (longIdent, _, synModuleOrNamespaceKind, decls, _, attrs, _, range) -> let collectIdents (idents: LongIdent) = idents - |> List.map - (fun ident -> - { Type = Ident_ - Range = r ident.idRange - Properties = Map.empty - FsAstNode = ident }) + |> List.map (fun ident -> mkNode Ident_ ident.idRange) let typeName = match synModuleOrNamespaceKind with @@ -56,10 +42,7 @@ module private Ast = [ // LongIdent inside Namespace is being processed as children. if typeName <> SynModuleOrNamespace_DeclaredNamespace then - { Type = typeName - Range = r range - Properties = Map.empty - FsAstNode = modOrNs } + mkNode typeName range yield! if synModuleOrNamespaceKind = SynModuleOrNamespaceKind.DeclaredNamespace then collectIdents longIdent @@ -68,133 +51,92 @@ module private Ast = yield! (visitSynAttributeLists range attrs) yield! (decls |> List.collect visitSynModuleDecl) ] - and visitSynModuleDecl (ast: SynModuleDecl) : Node list = - let rec visit (ast: SynModuleDecl) (finalContinuation: Node list -> Node list) : Node list = + and visitSynModuleDecl (ast: SynModuleDecl) : TriviaNodeAssigner list = + let rec visit + (ast: SynModuleDecl) + (finalContinuation: TriviaNodeAssigner list -> TriviaNodeAssigner list) + : TriviaNodeAssigner list = match ast with | SynModuleDecl.ModuleAbbrev (_, _, range) -> - [ { Type = SynModuleDecl_ModuleAbbrev - Range = r range - Properties = Map.empty - FsAstNode = ast } ] + [ mkNode SynModuleDecl_ModuleAbbrev range ] |> finalContinuation | SynModuleDecl.NestedModule (sci, _, decls, _, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = decls |> List.map visit + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + decls |> List.map visit - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynModuleDecl_NestedModule - Range = r range - Properties = Map.empty - FsAstNode = ast } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + [ mkNode SynModuleDecl_NestedModule range yield! visitSynComponentInfo sci yield! (List.collect id nodes) ] |> finalContinuation Continuation.sequence continuations finalContinuation | SynModuleDecl.Let (_, bindings, range) -> - { Type = SynModuleDecl_Let - Range = r range - Properties = Map.empty - FsAstNode = ast } + mkNode SynModuleDecl_Let range :: (bindings |> List.collect visitSynBinding) |> finalContinuation | SynModuleDecl.DoExpr (_, expr, range) -> - { Type = SynModuleDecl_DoExpr - Range = r range - Properties = Map.empty - FsAstNode = ast } + mkNode SynModuleDecl_DoExpr range :: visitSynExpr expr |> finalContinuation | SynModuleDecl.Types (typeDefs, range) -> - { Type = SynModuleDecl_Types - Range = r range - Properties = Map.empty - FsAstNode = ast } + mkNode SynModuleDecl_Types range :: (typeDefs |> List.collect visitSynTypeDefn) |> finalContinuation | SynModuleDecl.Exception (exceptionDef, range) -> - { Type = SynModuleDecl_Exception - Range = r range - Properties = Map.empty - FsAstNode = ast } + mkNode SynModuleDecl_Exception range :: (visitSynExceptionDefn exceptionDef) |> finalContinuation | SynModuleDecl.Open (target, parentRange) -> // we use the parent ranges here to match up with the trivia parsed match target with | SynOpenDeclTarget.ModuleOrNamespace (_, _range) -> - { Type = SynModuleDecl_Open - Range = r parentRange - Properties = Map.empty - FsAstNode = ast } + mkNode SynModuleDecl_Open parentRange |> List.singleton |> finalContinuation | SynOpenDeclTarget.Type (synType, _range) -> - { Type = SynModuleDecl_OpenType - Range = r parentRange - Properties = Map.empty - FsAstNode = ast } + mkNode SynModuleDecl_OpenType parentRange :: (visitSynType synType) |> finalContinuation | SynModuleDecl.Attributes (attrs, range) -> - { Type = SynModuleDecl_Attributes - Range = r range - Properties = Map.empty - FsAstNode = ast } + mkNode SynModuleDecl_Attributes range :: (visitSynAttributeLists range attrs) |> finalContinuation | SynModuleDecl.HashDirective (hash, range) -> - [ { Type = SynModuleDecl_HashDirective - Range = r range - Properties = Map.empty - FsAstNode = ast } + [ mkNode SynModuleDecl_HashDirective range visitParsedHashDirective hash ] |> finalContinuation | SynModuleDecl.NamespaceFragment (moduleOrNamespace) -> - { Type = SynModuleDecl_NamespaceFragment - Range = noRange - Properties = Map.empty - FsAstNode = ast } - :: (visitSynModuleOrNamespace moduleOrNamespace) + visitSynModuleOrNamespace moduleOrNamespace |> finalContinuation visit ast id - and visitSynExpr (synExpr: SynExpr) : Node list = - let rec visit (synExpr: SynExpr) (finalContinuation: Node list -> Node list) : Node list = + and visitSynExpr (synExpr: SynExpr) : TriviaNodeAssigner list = + let rec visit + (synExpr: SynExpr) + (finalContinuation: TriviaNodeAssigner list -> TriviaNodeAssigner list) + : TriviaNodeAssigner list = match synExpr with - | SynExpr.Paren (expr, leftParenRange, rightParenRange, range) -> + | SynExpr.Paren (expr, _, _, range) -> visit expr (fun nodes -> - [ { Type = SynExpr_Paren - Range = r range - Properties = - p [ yield "leftParenRange" ==> r leftParenRange - if rightParenRange.IsSome then - yield "rightParenRange" ==> r rightParenRange.Value ] - FsAstNode = synExpr } + [ mkNode SynExpr_Paren range yield! nodes ] |> finalContinuation) - | SynExpr.Quote (operator, isRaw, quotedSynExpr, isFromQueryExpression, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = + | SynExpr.Quote (operator, _, quotedSynExpr, _, range) -> + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = [ visit operator; visit quotedSynExpr ] - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynExpr_Quote - Range = r range - Properties = - p [ "isRaw" ==> isRaw - "isFromQueryExpression" ==> isFromQueryExpression ] - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + [ mkNode SynExpr_Quote range yield! (List.collect id nodes) ] |> finalContinuation Continuation.sequence continuations finalContinuation | SynExpr.Const (constant, range) -> - [ { Type = SynExpr_Const - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + [ mkNode SynExpr_Const range visitSynConst range constant ] |> finalContinuation | SynExpr.Typed (expr, typeName, _) -> @@ -204,62 +146,46 @@ module private Ast = // { Type = SynExpr_Typed // Range = r range // Properties = Map.empty -// FsAstNode = synExpr } +// } nodes @ visitSynType typeName |> finalContinuation) | SynExpr.Tuple (_, exprs, _, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = exprs |> List.map visit + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + exprs |> List.map visit - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynExpr_Tuple - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + [ mkNode SynExpr_Tuple range yield! (List.collect id nodes) ] |> finalContinuation Continuation.sequence continuations finalContinuation | SynExpr.ArrayOrList (_, exprs, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = exprs |> List.map visit + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + exprs |> List.map visit - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynExpr_ArrayOrList - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + [ mkNode SynExpr_ArrayOrList range yield! (List.collect id nodes) ] |> finalContinuation Continuation.sequence continuations finalContinuation | SynExpr.Record (_, _, recordFields, range) -> - { Type = SynExpr_Record - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_Record range :: (List.collect visitRecordField recordFields) |> finalContinuation | SynExpr.AnonRecd (_, _, recordFields, range) -> - { Type = SynExpr_AnonRecd - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_AnonRecd range :: (List.collect visitAnonRecordField recordFields) |> finalContinuation | SynExpr.New (_, typeName, expr, range) -> visit expr (fun nodes -> - [ { Type = SynExpr_New - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + [ mkNode SynExpr_New range yield! nodes yield! visitSynType typeName ] |> finalContinuation) | SynExpr.ObjExpr (objType, argOptions, bindings, extraImpls, _, range) -> - { Type = SynExpr_ObjExpr - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_ObjExpr range :: [ yield! visitSynType objType if argOptions.IsSome then yield! visitArgsOption argOptions.Value @@ -267,42 +193,33 @@ module private Ast = yield! bindings |> List.collect visitSynBinding ] |> finalContinuation | SynExpr.While (_, whileExpr, doExpr, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit whileExpr; visit doExpr ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit whileExpr; visit doExpr ] - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynExpr_While - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - yield! (List.collect id nodes) ] + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_While range + :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynExpr.For (_, _, identBody, _, toBody, doBody, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = [ visit identBody visit toBody visit doBody ] - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynExpr_For - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - yield! (List.collect id nodes) ] + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_For range + :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation - | SynExpr.ForEach (_, (SeqExprOnly seqExprOnly), isFromSource, pat, enumExpr, bodyExpr, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit enumExpr; visit bodyExpr ] - - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynExpr_ForEach - Range = r range - Properties = - p [ "isFromSource" ==> isFromSource - "seqExprOnly" ==> seqExprOnly ] - FsAstNode = synExpr } + | SynExpr.ForEach (_, (SeqExprOnly _), _, pat, enumExpr, bodyExpr, range) -> + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit enumExpr; visit bodyExpr ] + + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + [ mkNode SynExpr_ForEach range yield! visitSynPat pat yield! (List.collect id nodes) ] |> finalContinuation @@ -312,47 +229,29 @@ module private Ast = visit expr (fun nodes -> - [ { Type = SynExpr_ArrayOrListOfSeqExpr - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - yield! nodes ] + mkNode SynExpr_ArrayOrListOfSeqExpr range :: nodes |> finalContinuation) | SynExpr.CompExpr (_, _, expr, _) -> visit expr finalContinuation // { Type = SynExpr_CompExpr // Range = r range -// Properties = -// p [ "isArrayOrList" ==> isArrayOrList -// "isNotNakedRefCell" ==> isNotNakedRefCell ] -// FsAstNode = synExpr } - | SynExpr.Lambda (fromMethod, inLambdaSeq, args, body, _parsedData, range) -> +// Properties = Map.empty } + | SynExpr.Lambda (_, _, args, body, _parsedData, range) -> visit body (fun nodes -> - [ { Type = SynExpr_Lambda - Range = r range - Properties = - p [ "fromMethod" ==> fromMethod - "inLambdaSeq" ==> inLambdaSeq ] - FsAstNode = synExpr } + [ mkNode SynExpr_Lambda range yield! visitSynSimplePats args yield! nodes ] |> finalContinuation) | SynExpr.MatchLambda (_, _, matchClauses, _, range) -> - { Type = SynExpr_MatchLambda - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_MatchLambda range :: (List.collect visitSynMatchClause matchClauses) |> finalContinuation | SynExpr.Match (_, expr, clauses, range) -> visit expr (fun nodes -> - [ { Type = SynExpr_Match - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + [ mkNode SynExpr_Match range yield! nodes yield! (List.collect visitSynMatchClause clauses) ] |> finalContinuation) @@ -360,35 +259,20 @@ module private Ast = visit expr (fun nodes -> - { Type = SynExpr_Do - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_Do range :: nodes |> finalContinuation) | SynExpr.Assert (expr, range) -> visit expr (fun nodes -> - { Type = SynExpr_Assert - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_Assert range :: nodes |> finalContinuation) - | SynExpr.App (atomicFlag, isInfix, funcExpr, argExpr, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit funcExpr; visit argExpr ] - - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynExpr_App - Range = r range - Properties = - p [ "atomicFlag" - ==> (match atomicFlag with - | ExprAtomicFlag.Atomic -> "Atomic" - | _ -> "Not Atomic") - "isInfix" ==> isInfix ] - FsAstNode = synExpr } + | SynExpr.App (_, _, funcExpr, argExpr, range) -> + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit funcExpr; visit argExpr ] + + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_App range :: (List.collect id nodes) |> finalContinuation @@ -397,10 +281,7 @@ module private Ast = visit expr (fun nodes -> - [ { Type = SynExpr_TypeApp - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + [ mkNode SynExpr_TypeApp range yield! nodes yield! (List.collect visitSynType typeNames) ] |> finalContinuation) @@ -413,30 +294,23 @@ module private Ast = // Properties = // p [ "isRecursive" ==> isRecursive // "isUse" ==> isUse ] -// FsAstNode = synExpr } +// } (List.collect visitSynBinding bindings) @ nodes |> finalContinuation) - | SynExpr.TryWith (tryExpr, tryRange, withCases, withRange, range, _, _) -> + | SynExpr.TryWith (tryExpr, _, withCases, _, range, _, _) -> visit tryExpr (fun nodes -> - [ { Type = SynExpr_TryWith - Range = r range - Properties = - p [ "tryRange" ==> r tryRange - "withRange" ==> r withRange ] - FsAstNode = synExpr } + [ mkNode SynExpr_TryWith range yield! nodes yield! withCases |> List.collect visitSynMatchClause ] |> finalContinuation) | SynExpr.TryFinally (tryExpr, finallyExpr, range, _, _) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit tryExpr; visit finallyExpr ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit tryExpr; visit finallyExpr ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynExpr_TryFinally - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_TryFinally range :: (List.collect id nodes) |> finalContinuation @@ -445,113 +319,83 @@ module private Ast = visit ex (fun nodes -> - { Type = SynExpr_Lazy - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_Lazy range :: nodes |> finalContinuation) | SynExpr.Sequential (_, _, expr1, expr2, _) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr1; visit expr2 ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit expr1; visit expr2 ] - let finalContinuation (nodes: Node list list) : Node list = + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = // { Type = SynExpr_Sequential // Range = r range // Properties = Map.empty -// FsAstNode = synExpr } +// } (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynExpr.SequentialOrImplicitYield (_, expr1, expr2, ifNotStmt, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = [ visit expr1 visit expr2 visit ifNotStmt ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynExpr_SequentialOrImplicitYield - Range = r range - FsAstNode = synExpr - Properties = Map.empty } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_SequentialOrImplicitYield range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation - | SynExpr.IfThenElse (ifExpr, thenExpr, elseExpr, _, isFromErrorRecovery, ifToThenRange, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = + | SynExpr.IfThenElse (ifExpr, thenExpr, elseExpr, _, _, _, range) -> + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = [ visit ifExpr visit thenExpr yield! (Option.toList elseExpr |> List.map visit) ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynExpr_IfThenElse - Range = r range - Properties = - p [ "isFromErrorRecovery" ==> isFromErrorRecovery - "ifToThenRange" ==> r ifToThenRange ] - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_IfThenElse range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynExpr.Ident (id) -> - { Type = SynExpr_Ident - Range = (i id).Range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_Ident (i id).Range |> List.singleton |> finalContinuation - | SynExpr.LongIdent (isOptional, longDotId, _, range) -> - { Type = SynExpr_LongIdent - Range = r range - Properties = - p [ "isOptional" ==> isOptional - "longDotId" ==> lid longDotId ] - FsAstNode = synExpr } + | SynExpr.LongIdent (_, longDotId, _, range) -> + mkNode SynExpr_LongIdent range :: (visitLongIdentWithDots longDotId) |> finalContinuation | SynExpr.LongIdentSet (_, expr, range) -> visit expr (fun nodes -> - { Type = SynExpr_LongIdentSet - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_LongIdentSet range :: nodes |> finalContinuation) | SynExpr.DotGet (expr, _, longDotId, range) -> visit expr (fun nodes -> - [ { Type = SynExpr_DotGet - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + [ mkNode SynExpr_DotGet range yield! nodes // Idents are collected as children here to deal with unit test ``Fluent api with comments should remain on same lines`` yield! (visitLongIdentWithDots longDotId) ] |> finalContinuation) | SynExpr.DotSet (expr, _, e2, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr; visit e2 ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit expr; visit e2 ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynExpr_DotSet - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_DotSet range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynExpr.Set (e1, e2, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit e1; visit e2 ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit e1; visit e2 ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynExpr_Set - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_Set range :: (List.collect id nodes) |> finalContinuation @@ -560,46 +404,37 @@ module private Ast = visit objectExpr (fun nodes -> - [ { Type = SynExpr_DotIndexedGet - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + [ mkNode SynExpr_DotIndexedGet range yield! nodes yield! indexExprs |> List.collect visitSynIndexerArg ] |> finalContinuation) | SynExpr.DotIndexedSet (objectExpr, indexExprs, valueExpr, _, _, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit objectExpr; visit valueExpr ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit objectExpr; visit valueExpr ] - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynExpr_DotIndexedSet - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + [ mkNode SynExpr_DotIndexedSet range yield! (List.collect id nodes) yield! indexExprs |> List.collect visitSynIndexerArg ] |> finalContinuation Continuation.sequence continuations finalContinuation | SynExpr.NamedIndexedPropertySet (_, e1, e2, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit e1; visit e2 ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit e1; visit e2 ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynExpr_NamedIndexedPropertySet - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_NamedIndexedPropertySet range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynExpr.DotNamedIndexedPropertySet (expr, _, e1, e2, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr; visit e1; visit e2 ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit expr; visit e1; visit e2 ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynExpr_DotNamedIndexedPropertySet - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_DotNamedIndexedPropertySet range :: (List.collect id nodes) |> finalContinuation @@ -608,10 +443,7 @@ module private Ast = visit expr (fun nodes -> - [ { Type = SynExpr_TypeTest - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + [ mkNode SynExpr_TypeTest range yield! nodes yield! visitSynType typeName ] |> finalContinuation) @@ -619,10 +451,7 @@ module private Ast = visit expr (fun nodes -> - [ { Type = SynExpr_Upcast - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + [ mkNode SynExpr_Upcast range yield! nodes yield! visitSynType typeName ] |> finalContinuation) @@ -630,10 +459,7 @@ module private Ast = visit expr (fun nodes -> - [ { Type = SynExpr_Downcast - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + [ mkNode SynExpr_Downcast range yield! nodes yield! visitSynType typeName ] |> finalContinuation) @@ -641,101 +467,67 @@ module private Ast = visit expr (fun nodes -> - { Type = SynExpr_InferredUpcast - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_InferredUpcast range :: nodes |> finalContinuation) | SynExpr.InferredDowncast (expr, range) -> visit expr (fun nodes -> - { Type = SynExpr_InferredDowncast - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_InferredDowncast range :: nodes |> finalContinuation) | SynExpr.Null (range) -> - { Type = SynExpr_Null - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_Null range |> List.singleton |> finalContinuation | SynExpr.AddressOf (_, expr, _, range) -> visit expr (fun nodes -> - { Type = SynExpr_AddressOf - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_AddressOf range :: nodes |> finalContinuation) | SynExpr.TraitCall (typars, sign, expr, range) -> visit expr (fun nodes -> - [ { Type = SynExpr_TraitCall - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + [ mkNode SynExpr_TraitCall range yield! typars |> List.collect visitSynTypar yield! visitSynMemberSig sign yield! nodes ] |> finalContinuation) | SynExpr.JoinIn (expr, _, expr2, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr; visit expr2 ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit expr; visit expr2 ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynExpr_JoinIn - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_JoinIn range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynExpr.ImplicitZero (range) -> - { Type = SynExpr_ImplicitZero - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_ImplicitZero range |> List.singleton |> finalContinuation | SynExpr.YieldOrReturn (_, expr, range) -> visit expr (fun nodes -> - { Type = SynExpr_YieldOrReturn - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_YieldOrReturn range :: nodes |> finalContinuation) | SynExpr.YieldOrReturnFrom (_, expr, range) -> visit expr (fun nodes -> - { Type = SynExpr_YieldOrReturnFrom - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_YieldOrReturnFrom range :: nodes |> finalContinuation) | SynExpr.LetOrUseBang (_, _, _, pat, rhsExpr, andBangs, body, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = [ visit rhsExpr visit body yield! (List.map (fun (_, _, _, _, body, _) -> visit body) andBangs) ] - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynExpr_LetOrUseBang - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + [ mkNode SynExpr_LetOrUseBang range yield! visitSynPat pat yield! (List.collect id nodes) yield! @@ -748,10 +540,7 @@ module private Ast = visit expr (fun nodes -> - [ { Type = SynExpr_MatchBang - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + [ mkNode SynExpr_MatchBang range yield! nodes yield! clauses |> List.collect visitSynMatchClause ] |> finalContinuation) @@ -759,90 +548,58 @@ module private Ast = visit expr (fun nodes -> - { Type = SynExpr_DoBang - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_DoBang range :: nodes |> finalContinuation) | SynExpr.LibraryOnlyILAssembly (_, _, _, _, range) -> - { Type = SynExpr_LibraryOnlyILAssembly - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_LibraryOnlyILAssembly range |> List.singleton |> finalContinuation | SynExpr.LibraryOnlyStaticOptimization (_, _, _, range) -> - { Type = SynExpr_LibraryOnlyStaticOptimization - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_LibraryOnlyStaticOptimization range |> List.singleton |> finalContinuation | SynExpr.LibraryOnlyUnionCaseFieldGet (expr, _, _, range) -> visit expr (fun nodes -> - { Type = SynExpr_LibraryOnlyUnionCaseFieldGet - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_LibraryOnlyUnionCaseFieldGet range :: nodes |> finalContinuation) | SynExpr.LibraryOnlyUnionCaseFieldSet (e1, _, _, e2, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit e1; visit e2 ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit e1; visit e2 ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynExpr_LibraryOnlyUnionCaseFieldSet - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynExpr_LibraryOnlyUnionCaseFieldSet range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynExpr.ArbitraryAfterError (_, range) -> - { Type = SynExpr_ArbitraryAfterError - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_ArbitraryAfterError range |> List.singleton |> finalContinuation | SynExpr.FromParseError (expr, range) -> visit expr (fun nodes -> - { Type = SynExpr_FromParseError - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_FromParseError range :: nodes |> finalContinuation) | SynExpr.DiscardAfterMissingQualificationAfterDot (expr, range) -> visit expr (fun nodes -> - { Type = SynExpr_DiscardAfterMissingQualificationAfterDot - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_DiscardAfterMissingQualificationAfterDot range :: nodes |> finalContinuation) | SynExpr.Fixed (expr, range) -> visit expr (fun nodes -> - { Type = SynExpr_Fixed - Range = r range - Properties = Map.empty - FsAstNode = synExpr } - :: nodes + mkNode SynExpr_Fixed range :: nodes |> finalContinuation) | SynExpr.InterpolatedString (parts, range) -> - { Type = SynExpr_InterpolatedString - Range = r range - Properties = Map.empty - FsAstNode = synExpr } + mkNode SynExpr_InterpolatedString range :: (List.collect visitSynInterpolatedStringPart parts) |> finalContinuation @@ -851,132 +608,72 @@ module private Ast = and visitSynInterpolatedStringPart (synInterpolatedStringPart: SynInterpolatedStringPart) = match synInterpolatedStringPart with | SynInterpolatedStringPart.String (_, range) -> - { Type = SynInterpolatedStringPart_String - Range = r range - Properties = Map.empty - FsAstNode = synInterpolatedStringPart } + mkNode SynInterpolatedStringPart_String range |> List.singleton | SynInterpolatedStringPart.FillExpr (expr, ident) -> - { Type = SynInterpolatedStringPart_FillExpr - Range = None - Properties = Map.empty - FsAstNode = synInterpolatedStringPart } - :: [ yield! visitSynExpr expr - yield! (Option.toList ident |> List.map visitIdent) ] - - and visitRecordField ((longId, _) as rfn: RecordFieldName, expr: SynExpr option, _: BlockSeparator option) = - { Type = RecordField_ - Range = r longId.Range - Properties = Map.empty - FsAstNode = rfn } + visitSynExpr expr + @ (Option.toList ident |> List.map visitIdent) + + and visitRecordField ((longId, _): RecordFieldName, expr: SynExpr option, _: BlockSeparator option) = + mkNode RecordField_ longId.Range :: (match expr with | Some e -> visitSynExpr e | None -> []) - and visitAnonRecordField (_: Ident, expr: SynExpr) = - { Type = AnonRecordField_ - Range = noRange - Properties = Map.empty - FsAstNode = expr } - :: (visitSynExpr expr) - - and visitAnonRecordTypeField (_: Ident, t: SynType) = - { Type = AnonRecordTypeField_ - Range = noRange - Properties = Map.empty - FsAstNode = t } - :: (visitSynType t) - - and visitSynMemberSig (ms: SynMemberSig) : Node list = + and visitAnonRecordField (_: Ident, expr: SynExpr) = visitSynExpr expr + + and visitAnonRecordTypeField (_: Ident, t: SynType) = visitSynType t + + and visitSynMemberSig (ms: SynMemberSig) : TriviaNodeAssigner list = match ms with | SynMemberSig.Member (valSig, _, range) -> - { Type = SynMemberSig_Member - Range = r range - Properties = Map.empty - FsAstNode = ms } + mkNode SynMemberSig_Member range :: (visitSynValSig valSig) | SynMemberSig.Interface (typeName, range) -> - { Type = SynMemberSig_Interface - Range = r range - Properties = Map.empty - FsAstNode = ms } + mkNode SynMemberSig_Interface range :: (visitSynType typeName) | SynMemberSig.Inherit (typeName, range) -> - { Type = SynMemberSig_Inherit - Range = r range - Properties = Map.empty - FsAstNode = ms } + mkNode SynMemberSig_Inherit range :: (visitSynType typeName) | SynMemberSig.ValField (f, range) -> - { Type = SynMemberSig_ValField - Range = r range - Properties = Map.empty - FsAstNode = ms } + mkNode SynMemberSig_ValField range :: (visitSynField f) | SynMemberSig.NestedType (typedef, range) -> - { Type = SynMemberSig_NestedType - Range = r range - Properties = Map.empty - FsAstNode = ms } + mkNode SynMemberSig_NestedType range :: (visitSynTypeDefnSig typedef) - and visitSynIndexerArg (ia: SynIndexerArg) : Node list = + and visitSynIndexerArg (ia: SynIndexerArg) : TriviaNodeAssigner list = match ia with - | SynIndexerArg.One (e, _fromEnd, _) -> - { Type = SynIndexerArg_One - Range = noRange - Properties = Map.empty - FsAstNode = ia } - :: (visitSynExpr e) - | SynIndexerArg.Two (e1, _fromEnd1, e2, _fromEnd2, _, _) -> - { Type = SynIndexerArg_Two - Range = noRange - Properties = Map.empty - FsAstNode = ia } - :: [ yield! visitSynExpr e1 - yield! visitSynExpr e2 ] + | SynIndexerArg.One (e, _fromEnd, _) -> visitSynExpr e + | SynIndexerArg.Two (e1, _fromEnd1, e2, _fromEnd2, _, _) -> visitSynExpr e1 @ visitSynExpr e2 - and visitSynMatchClause (mc: SynMatchClause) : Node list = + and visitSynMatchClause (mc: SynMatchClause) : TriviaNodeAssigner list = match mc with | SynMatchClause.Clause (pat, e1, e2, _range, _) -> - { Type = SynMatchClause_Clause - Range = r mc.Range // _range is the same range as pat, see https://github.com/dotnet/fsharp/issues/10877 - Properties = Map.empty - FsAstNode = mc } + mkNode SynMatchClause_Clause mc.Range // _range is the same range as pat, see https://github.com/dotnet/fsharp/issues/10877 :: [ yield! visitSynPat pat if e1.IsSome then yield! visitSynExpr e1.Value yield! visitSynExpr e2 ] - and visitArgsOption (expr: SynExpr, _: Ident option) = - { Type = ArgOptions_ - Range = noRange - Properties = Map.empty - FsAstNode = expr } - :: (visitSynExpr expr) + and visitArgsOption (expr: SynExpr, _: Ident option) = visitSynExpr expr - and visitSynInterfaceImpl (ii: SynInterfaceImpl) : Node list = + and visitSynInterfaceImpl (ii: SynInterfaceImpl) : TriviaNodeAssigner list = match ii with | InterfaceImpl (typ, bindings, range) -> - { Type = InterfaceImpl_ - Range = r range - Properties = Map.empty - FsAstNode = ii } - :: [ yield! visitSynType typ - yield! (bindings |> List.collect visitSynBinding) ] + [ mkNode InterfaceImpl_ range + yield! visitSynType typ + yield! (bindings |> List.collect visitSynBinding) ] and visitSynTypeDefn (td: SynTypeDefn) = match td with | TypeDefn (sci, stdr, members, range) -> - { Type = TypeDefn_ - Range = r range - Properties = Map.empty - FsAstNode = td } - :: [ yield! visitSynComponentInfo sci - yield! visitSynTypeDefnRepr stdr - yield! (members |> List.collect visitSynMemberDefn) ] - - and visitSynTypeDefnSig (typeDefSig: SynTypeDefnSig) : Node list = + [ mkNode TypeDefn_ range + yield! visitSynComponentInfo sci + yield! visitSynTypeDefnRepr stdr + yield! (members |> List.collect visitSynMemberDefn) ] + + and visitSynTypeDefnSig (typeDefSig: SynTypeDefnSig) : TriviaNodeAssigner list = match typeDefSig with | TypeDefnSig (sci, synTypeDefnSigReprs, memberSig, _) -> // { Type = TypeDefnSig_ @@ -987,7 +684,7 @@ module private Ast = yield! visitSynTypeDefnSigRepr synTypeDefnSigReprs yield! (memberSig |> List.collect visitSynMemberSig) ] - and visitSynTypeDefnSigRepr (stdr: SynTypeDefnSigRepr) : Node list = + and visitSynTypeDefnSigRepr (stdr: SynTypeDefnSigRepr) : TriviaNodeAssigner list = match stdr with | SynTypeDefnSigRepr.ObjectModel (kind, members, _) -> // { Type = SynTypeDefnSigRepr_ObjectModel @@ -1002,116 +699,72 @@ module private Ast = // Properties = Map.empty // FsAstNode = stdr } (visitSynTypeDefnSimpleRepr simpleRepr) - | SynTypeDefnSigRepr.Exception (exceptionRepr) -> - { Type = SynTypeDefnSigRepr_Exception - Range = noRange - Properties = Map.empty - FsAstNode = stdr } - :: (visitSynExceptionDefnRepr exceptionRepr) - - and visitSynMemberDefn (mbrDef: SynMemberDefn) : Node list = + | SynTypeDefnSigRepr.Exception (exceptionRepr) -> visitSynExceptionDefnRepr exceptionRepr + + and visitSynMemberDefn (mbrDef: SynMemberDefn) : TriviaNodeAssigner list = match mbrDef with | SynMemberDefn.Open (target, parentRange) -> // we use the parent ranges here to match up with the trivia parsed match target with | SynOpenDeclTarget.ModuleOrNamespace (_, _range) -> - { Type = SynMemberDefn_Open - Range = r parentRange - Properties = Map.empty - FsAstNode = target } + mkNode SynMemberDefn_Open parentRange |> List.singleton | SynOpenDeclTarget.Type (synType, _range) -> - { Type = SynMemberDefn_OpenType - Range = r parentRange - Properties = Map.empty - FsAstNode = target } + mkNode SynMemberDefn_OpenType parentRange :: (visitSynType synType) | SynMemberDefn.Member (memberDefn, range) -> - { Type = SynMemberDefn_Member - Range = r range - Properties = Map.empty - FsAstNode = mbrDef } + mkNode SynMemberDefn_Member range :: (visitSynBinding memberDefn) | SynMemberDefn.ImplicitCtor (_, attrs, ctorArgs, _, _xmlDoc, range) -> - { Type = SynMemberDefn_ImplicitCtor - Range = r range - Properties = Map.empty - FsAstNode = mbrDef } - :: [ yield! (visitSynAttributeLists range attrs) - yield! visitSynSimplePats ctorArgs ] + [ mkNode SynMemberDefn_ImplicitCtor range + yield! (visitSynAttributeLists range attrs) + yield! visitSynSimplePats ctorArgs ] | SynMemberDefn.ImplicitInherit (inheritType, inheritArgs, _, range) -> - { Type = SynMemberDefn_ImplicitInherit - Range = r range - Properties = Map.empty - FsAstNode = mbrDef } - :: [ yield! visitSynType inheritType - yield! visitSynExpr inheritArgs ] + [ mkNode SynMemberDefn_ImplicitInherit range + yield! visitSynType inheritType + yield! visitSynExpr inheritArgs ] | SynMemberDefn.LetBindings (bindings, _, _, range) -> - { Type = SynMemberDefn_LetBindings - Range = r range - Properties = Map.empty - FsAstNode = mbrDef } + mkNode SynMemberDefn_LetBindings range :: (List.collect visitSynBinding bindings) | SynMemberDefn.AbstractSlot (valSig, _, range) -> - { Type = SynMemberDefn_AbstractSlot - Range = r range - Properties = Map.empty - FsAstNode = mbrDef } + mkNode SynMemberDefn_AbstractSlot range :: (visitSynValSig valSig) | SynMemberDefn.Interface (typ, members, range) -> - { Type = SynMemberDefn_Interface - Range = r range - Properties = Map.empty - FsAstNode = mbrDef } - :: [ yield! visitSynType typ - if members.IsSome then - yield! members.Value |> List.collect visitSynMemberDefn ] + [ mkNode SynMemberDefn_Interface range + yield! visitSynType typ + if members.IsSome then + yield! members.Value |> List.collect visitSynMemberDefn ] | SynMemberDefn.Inherit (typ, _, range) -> - { Type = SynMemberDefn_Inherit - Range = r range - Properties = Map.empty - FsAstNode = mbrDef } + mkNode SynMemberDefn_Inherit range :: (visitSynType typ) | SynMemberDefn.ValField (fld, range) -> - { Type = SynMemberDefn_ValField - Range = r range - Properties = Map.empty - FsAstNode = mbrDef } + mkNode SynMemberDefn_ValField range :: (visitSynField fld) | SynMemberDefn.NestedType (typeDefn, _, range) -> - { Type = SynMemberDefn_NestedType - Range = r range - Properties = Map.empty - FsAstNode = mbrDef } + mkNode SynMemberDefn_NestedType range :: (visitSynTypeDefn typeDefn) | SynMemberDefn.AutoProperty (attrs, _, _, typeOpt, _, _, _, _, synExpr, _, range) -> - { Type = SynMemberDefn_AutoProperty - Range = r range - Properties = Map.empty - FsAstNode = mbrDef } - :: [ yield! (visitSynAttributeLists range attrs) - if typeOpt.IsSome then - yield! visitSynType typeOpt.Value - yield! visitSynExpr synExpr ] - - and visitSynSimplePat (sp: SynSimplePat) : Node list = - let rec visit (sp: SynSimplePat) (continuation: Node list -> Node list) : Node list = + [ mkNode SynMemberDefn_AutoProperty range + yield! (visitSynAttributeLists range attrs) + if typeOpt.IsSome then + yield! visitSynType typeOpt.Value + yield! visitSynExpr synExpr ] + + and visitSynSimplePat (sp: SynSimplePat) : TriviaNodeAssigner list = + let rec visit + (sp: SynSimplePat) + (continuation: TriviaNodeAssigner list -> TriviaNodeAssigner list) + : TriviaNodeAssigner list = match sp with | SynSimplePat.Id (_, _, _, _, _, range) -> - { Type = SynSimplePat_Id - Range = r range - Properties = Map.empty - FsAstNode = sp } + mkNode SynSimplePat_Id range |> List.singleton |> continuation | SynSimplePat.Typed (simplePat, typ, range) -> visit simplePat (fun nodes -> - [ { Type = SynSimplePat_Typed - Range = r range - Properties = Map.empty - FsAstNode = sp } + [ mkNode SynSimplePat_Typed range yield! nodes yield! visitSynType typ ] |> continuation) @@ -1119,41 +772,32 @@ module private Ast = visit simplePat (fun nodes -> - [ { Type = SynSimplePat_Attrib - Range = r range - Properties = Map.empty - FsAstNode = sp } + [ mkNode SynSimplePat_Attrib range yield! nodes yield! (visitSynAttributeLists range attrs) ] |> continuation) visit sp id - and visitSynSimplePats (sp: SynSimplePats) : Node list = - let rec visit (sp: SynSimplePats) (continuation: Node list -> Node list) = + and visitSynSimplePats (sp: SynSimplePats) : TriviaNodeAssigner list = + let rec visit (sp: SynSimplePats) (continuation: TriviaNodeAssigner list -> TriviaNodeAssigner list) = match sp with | SynSimplePats.SimplePats (pats, range) -> - { Type = SynSimplePats_SimplePats - Range = r range - Properties = Map.empty - FsAstNode = sp } + mkNode SynSimplePats_SimplePats range :: (List.collect visitSynSimplePat pats) |> continuation | SynSimplePats.Typed (pats, typ, range) -> visit pats (fun nodes -> - [ { Type = SynSimplePat_Typed - Range = r range - Properties = Map.empty - FsAstNode = sp } + [ mkNode SynSimplePat_Typed range yield! nodes yield! visitSynType typ ] |> continuation) visit sp id - and visitSynBinding (binding: SynBinding) : Node list = + and visitSynBinding (binding: SynBinding) : TriviaNodeAssigner list = match binding with | Binding (_, kind, _, _, attrs, _, valData, headPat, returnInfo, expr, range, _) -> let t = @@ -1162,174 +806,124 @@ module private Ast = | SynBindingKind.NormalBinding -> NormalBinding_ | SynBindingKind.DoBinding -> DoBinding_ - { Type = t - Range = r binding.RangeOfBindingAndRhs - Properties = Map.empty - FsAstNode = binding } - :: [ yield! (visitSynAttributeLists range attrs) - yield! visitSynValData valData - yield! visitSynPat headPat - if returnInfo.IsSome then - yield! visitSynBindingReturnInfo returnInfo.Value - yield! visitSynExpr expr ] - - and visitSynValData (svd: SynValData) : Node list = + [ mkNode t binding.RangeOfBindingAndRhs + yield! visitSynAttributeLists range attrs + yield! visitSynValData valData + yield! visitSynPat headPat + yield! + (match returnInfo with + | Some ri -> visitSynBindingReturnInfo ri + | None -> []) + yield! visitSynExpr expr ] + + and visitSynValData (svd: SynValData) : TriviaNodeAssigner list = match svd with - | SynValData (_, svi, _) -> - { Type = SynValData_ - Range = noRange - Properties = Map.empty - FsAstNode = svd } - :: (visitSynValInfo svi) - - and visitSynValSig (svs: SynValSig) : Node list = + | SynValData (_, svi, _) -> visitSynValInfo svi + + and visitSynValSig (svs: SynValSig) : TriviaNodeAssigner list = match svs with | ValSpfn (attrs, _, explicitValDecls, synType, arity, _, _, _, _, expr, range) -> - { Type = ValSpfn_ - Range = r range - Properties = Map.empty - FsAstNode = svs } - :: [ yield! (visitSynAttributeLists range attrs) - yield! visitSynValTyparDecls explicitValDecls - yield! visitSynType synType - yield! visitSynValInfo arity - if expr.IsSome then - yield! visitSynExpr expr.Value ] - - and visitSynValTyparDecls (valTypeDecl: SynValTyparDecls) : Node list = + [ mkNode ValSpfn_ range + yield! (visitSynAttributeLists range attrs) + yield! visitSynValTyparDecls explicitValDecls + yield! visitSynType synType + yield! visitSynValInfo arity + if expr.IsSome then + yield! visitSynExpr expr.Value ] + + and visitSynValTyparDecls (valTypeDecl: SynValTyparDecls) : TriviaNodeAssigner list = match valTypeDecl with - | SynValTyparDecls (typardecls, _, _) -> - { Type = SynValTyparDecls_ - Range = noRange - Properties = Map.empty - FsAstNode = valTypeDecl } - :: (List.collect visitSynTyparDecl typardecls) - - and visitSynTyparDecl (std: SynTyparDecl) : Node list = + | SynValTyparDecls (typardecls, _, _) -> List.collect visitSynTyparDecl typardecls + + and visitSynTyparDecl (std: SynTyparDecl) : TriviaNodeAssigner list = match std with | TyparDecl (attrs, typar) -> - { Type = TyparDecl_ - Range = noRange - Properties = Map.empty - FsAstNode = std } - :: [ yield! (visitSynAttributeLists typar.Range attrs) - yield! visitSynTypar typar ] - - and visitSynTypar (typar: SynTypar) : Node list = + [ yield! (visitSynAttributeLists typar.Range attrs) + yield! visitSynTypar typar ] + + and visitSynTypar (typar: SynTypar) : TriviaNodeAssigner list = match typar with - | Typar _ -> - { Type = Typar_ - Range = noRange - Properties = Map.empty - FsAstNode = typar } - |> List.singleton + | Typar _ -> [] and visitTyparStaticReq (tsr: TyparStaticReq) = match tsr with | NoStaticReq -> "NoStaticReq" | HeadTypeStaticReq -> "HeadTypeStaticReq" - and visitSynBindingReturnInfo (returnInfo: SynBindingReturnInfo) : Node list = + and visitSynBindingReturnInfo (returnInfo: SynBindingReturnInfo) : TriviaNodeAssigner list = match returnInfo with | SynBindingReturnInfo (typeName, range, attrs) -> - { Type = SynBindingReturnInfo_ - Range = r range - Properties = Map.empty - FsAstNode = returnInfo } - :: [ yield! visitSynType typeName - yield! (visitSynAttributeLists range attrs) ] - - and visitSynPat (sp: SynPat) : Node list = - let rec visit (sp: SynPat) (finalContinuation: Node list -> Node list) : Node list = + [ mkNode SynBindingReturnInfo_ range + yield! visitSynType typeName + yield! (visitSynAttributeLists range attrs) ] + + and visitSynPat (sp: SynPat) : TriviaNodeAssigner list = + let rec visit + (sp: SynPat) + (finalContinuation: TriviaNodeAssigner list -> TriviaNodeAssigner list) + : TriviaNodeAssigner list = match sp with | SynPat.Const (sc, range) -> - [ { Type = SynPat_Const - Range = r range - Properties = Map.empty - FsAstNode = sp } + [ mkNode SynPat_Const range visitSynConst range sc ] |> finalContinuation | SynPat.Wild (range) -> - { Type = SynPat_Wild - Range = r range - Properties = Map.empty - FsAstNode = sp } + mkNode SynPat_Wild range |> List.singleton |> finalContinuation | SynPat.Named (synPat, _, _, _, range) -> visit synPat (fun nodes -> - { Type = SynPat_Named - Range = r range - Properties = Map.empty - FsAstNode = sp } - :: nodes + mkNode SynPat_Named range :: nodes |> finalContinuation) | SynPat.Typed (synPat, synType, range) -> visit synPat (fun nodes -> - [ { Type = SynPat_Typed - Range = r range - Properties = Map.empty - FsAstNode = sp } - yield! nodes - yield! (visitSynType synType) ] + mkNode SynPat_Typed range + :: (nodes @ visitSynType synType) |> finalContinuation) | SynPat.Attrib (synPat, attrs, range) -> visit synPat (fun nodes -> - [ { Type = SynPat_Attrib - Range = r range - Properties = Map.empty - FsAstNode = sp } + [ mkNode SynPat_Attrib range yield! nodes yield! (visitSynAttributeLists range attrs) ] |> finalContinuation) | SynPat.Or (synPat, synPat2, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit synPat; visit synPat2 ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit synPat; visit synPat2 ] - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynPat_Or - Range = r range - Properties = Map.empty - FsAstNode = sp } - yield! (List.collect id nodes) ] + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynPat_Or range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynPat.Ands (pats, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = pats |> List.map visit + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + pats |> List.map visit - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynPat_Ands - Range = r range - Properties = Map.empty - FsAstNode = sp } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynPat_Ands range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynPat.LongIdent (_, _, svtd, ctorArgs, _, range) -> - { Type = SynPat_LongIdent - Range = r range - Properties = Map.empty - FsAstNode = sp } - :: [ if svtd.IsSome then - yield! visitSynValTyparDecls svtd.Value - yield! visitSynConstructorArgs ctorArgs ] + [ mkNode SynPat_LongIdent range + if svtd.IsSome then + yield! visitSynValTyparDecls svtd.Value + yield! visitSynConstructorArgs ctorArgs ] |> finalContinuation | SynPat.Tuple (_, pats, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = pats |> List.map visit + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + pats |> List.map visit - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynPat_Tuple - Range = r range - Properties = Map.empty - FsAstNode = sp } - yield! (List.collect id nodes) ] + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynPat_Tuple range + :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation @@ -1337,117 +931,74 @@ module private Ast = visit pat (fun nodes -> - { Type = SynPat_Paren - Range = r range - Properties = Map.empty - FsAstNode = sp } - :: nodes + mkNode SynPat_Paren range :: nodes |> finalContinuation) | SynPat.ArrayOrList (_, pats, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = pats |> List.map visit + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + pats |> List.map visit - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynPat_ArrayOrList - Range = r range - Properties = Map.empty - FsAstNode = sp } - yield! (List.collect id nodes) ] + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynPat_ArrayOrList range + :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynPat.Record (pats, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = pats |> List.map (snd >> visit) + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + pats |> List.map (snd >> visit) - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynPat_Record - Range = r range - Properties = Map.empty - FsAstNode = sp } - yield! (List.collect id nodes) ] + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynPat_Record range + :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynPat.Null (range) -> - { Type = SynPat_Null - Range = r range - Properties = Map.empty - FsAstNode = sp } + mkNode SynPat_Null range |> List.singleton |> finalContinuation | SynPat.OptionalVal (_, range) -> - { Type = SynPat_OptionalVal - Range = r range - Properties = Map.empty - FsAstNode = sp } + mkNode SynPat_OptionalVal range |> List.singleton |> finalContinuation | SynPat.IsInst (typ, range) -> - { Type = SynPat_IsInst - Range = r range - Properties = Map.empty - FsAstNode = sp } - :: visitSynType typ + mkNode SynPat_IsInst range :: visitSynType typ |> finalContinuation | SynPat.QuoteExpr (expr, range) -> - { Type = SynPat_QuoteExpr - Range = r range - Properties = Map.empty - FsAstNode = sp } - :: visitSynExpr expr + mkNode SynPat_QuoteExpr range :: visitSynExpr expr |> finalContinuation | SynPat.DeprecatedCharRange (_, _, range) -> - { Type = SynPat_DeprecatedCharRange - Range = r range - Properties = Map.empty - FsAstNode = sp } + mkNode SynPat_DeprecatedCharRange range |> List.singleton |> finalContinuation | SynPat.InstanceMember (_, _, _, _, range) -> - { Type = SynPat_InstanceMember - Range = r range - Properties = Map.empty - FsAstNode = sp } + mkNode SynPat_InstanceMember range |> List.singleton |> finalContinuation | SynPat.FromParseError (pat, range) -> visit pat (fun nodes -> - { Type = SynPat_FromParseError - Range = r range - Properties = Map.empty - FsAstNode = sp } - :: nodes + mkNode SynPat_FromParseError range :: nodes |> finalContinuation) visit sp id - and visitSynConstructorArgs (ctorArgs: SynArgPats) : Node list = + and visitSynConstructorArgs (ctorArgs: SynArgPats) : TriviaNodeAssigner list = match ctorArgs with - | Pats (pats) -> - { Type = Pats_ - Range = noRange - Properties = Map.empty - FsAstNode = ctorArgs } - :: (List.collect visitSynPat pats) + | Pats (pats) -> List.collect visitSynPat pats | NamePatPairs (pats, range) -> - { Type = NamePatPairs_ - Range = r range - Properties = Map.empty - FsAstNode = ctorArgs } + mkNode NamePatPairs_ range :: (List.collect (snd >> visitSynPat) pats) - and visitSynComponentInfo (sci: SynComponentInfo) : Node list = + and visitSynComponentInfo (sci: SynComponentInfo) : TriviaNodeAssigner list = match sci with | ComponentInfo (attribs, typeParams, _, _, _, _, _, range) -> - { Type = ComponentInfo_ - Range = r range - Properties = Map.empty - FsAstNode = sci } - :: [ yield! (visitSynAttributeLists range attribs) - yield! (typeParams |> List.collect (visitSynTyparDecl)) ] - - and visitSynTypeDefnRepr (stdr: SynTypeDefnRepr) : Node list = + [ mkNode ComponentInfo_ range + yield! (visitSynAttributeLists range attribs) + yield! (typeParams |> List.collect (visitSynTyparDecl)) ] + + and visitSynTypeDefnRepr (stdr: SynTypeDefnRepr) : TriviaNodeAssigner list = match stdr with | SynTypeDefnRepr.ObjectModel (kind, members, _) -> // { Type = SynTypeDefnRepr_ObjectModel @@ -1462,162 +1013,66 @@ module private Ast = // Properties = Map.empty // FsAstNode = stdr } visitSynTypeDefnSimpleRepr simpleRepr - | SynTypeDefnRepr.Exception (exceptionRepr) -> - { Type = SynTypeDefnRepr_Exception - Range = noRange - Properties = Map.empty - FsAstNode = stdr } - :: (visitSynExceptionDefnRepr exceptionRepr) - - and visitSynTypeDefnKind (kind: SynTypeDefnKind) : Node list = + | SynTypeDefnRepr.Exception (exceptionRepr) -> visitSynExceptionDefnRepr exceptionRepr + + and visitSynTypeDefnKind (kind: SynTypeDefnKind) : TriviaNodeAssigner list = match kind with - | TyconUnspecified -> - { Type = SynTypeDefnKind_TyconUnspecified - Range = noRange - Properties = Map.empty - FsAstNode = kind } - |> List.singleton - | TyconClass -> - { Type = SynTypeDefnKind_TyconClass - Range = noRange - Properties = Map.empty - FsAstNode = kind } - |> List.singleton - | TyconInterface -> - { Type = SynTypeDefnKind_TyconInterface - Range = noRange - Properties = Map.empty - FsAstNode = kind } - |> List.singleton - | TyconStruct -> - { Type = SynTypeDefnKind_TyconStruct - Range = noRange - Properties = Map.empty - FsAstNode = kind } - |> List.singleton - | TyconRecord -> - { Type = SynTypeDefnKind_TyconRecord - Range = noRange - Properties = Map.empty - FsAstNode = kind } - |> List.singleton - | TyconUnion -> - { Type = SynTypeDefnKind_TyconUnion - Range = noRange - Properties = Map.empty - FsAstNode = kind } - |> List.singleton - | TyconAbbrev -> - { Type = SynTypeDefnKind_TyconAbbrev - Range = noRange - Properties = Map.empty - FsAstNode = kind } - |> List.singleton - | TyconHiddenRepr -> - { Type = SynTypeDefnKind_TyconHiddenRepr - Range = noRange - Properties = Map.empty - FsAstNode = kind } - |> List.singleton - | TyconAugmentation -> - { Type = SynTypeDefnKind_TyconAugmentation - Range = noRange - Properties = Map.empty - FsAstNode = kind } - |> List.singleton - | TyconILAssemblyCode -> - { Type = SynTypeDefnKind_TyconILAssemblyCode - Range = noRange - Properties = Map.empty - FsAstNode = kind } - |> List.singleton - | TyconDelegate (typ, valinfo) -> - { Type = SynTypeDefnKind_TyconDelegate - Range = noRange - Properties = Map.empty - FsAstNode = kind } - :: [ yield! visitSynType typ - yield! visitSynValInfo valinfo ] + | TyconUnspecified + | TyconClass + | TyconInterface + | TyconStruct + | TyconRecord + | TyconAbbrev + | TyconHiddenRepr + | TyconAugmentation + | TyconUnion + | TyconILAssemblyCode -> [] + | TyconDelegate (typ, valinfo) -> visitSynType typ @ visitSynValInfo valinfo and visitSynTypeDefnSimpleRepr (arg: SynTypeDefnSimpleRepr) = match arg with | SynTypeDefnSimpleRepr.None (range) -> - { Type = SynTypeDefnSimpleRepr_None - Range = r range - Properties = Map.empty - FsAstNode = arg } + mkNode SynTypeDefnSimpleRepr_None range |> List.singleton | SynTypeDefnSimpleRepr.Union (_, unionCases, range) -> - { Type = SynTypeDefnSimpleRepr_Union - Range = r range - Properties = Map.empty - FsAstNode = arg } + mkNode SynTypeDefnSimpleRepr_Union range :: (List.collect visitSynUnionCase unionCases) | SynTypeDefnSimpleRepr.Enum (enumCases, range) -> - { Type = SynTypeDefnSimpleRepr_Enum - Range = r range - Properties = Map.empty - FsAstNode = arg } + mkNode SynTypeDefnSimpleRepr_Enum range :: (List.collect visitSynEnumCase enumCases) | SynTypeDefnSimpleRepr.Record (_, recordFields, range) -> - { Type = SynTypeDefnSimpleRepr_Record - Range = r range - Properties = Map.empty - FsAstNode = arg } + mkNode SynTypeDefnSimpleRepr_Record range :: (List.collect visitSynField recordFields) | SynTypeDefnSimpleRepr.General (_, _, _, _, _, _, _, range) -> - { Type = SynTypeDefnSimpleRepr_General - Range = r range - Properties = Map.empty - FsAstNode = arg } + mkNode SynTypeDefnSimpleRepr_General range |> List.singleton | SynTypeDefnSimpleRepr.LibraryOnlyILAssembly (_, range) -> - { Type = SynTypeDefnSimpleRepr_LibraryOnlyILAssembly - Range = r range - Properties = Map.empty - FsAstNode = arg } + mkNode SynTypeDefnSimpleRepr_LibraryOnlyILAssembly range |> List.singleton | SynTypeDefnSimpleRepr.TypeAbbrev (_, typ, range) -> - { Type = SynTypeDefnSimpleRepr_TypeAbbrev - Range = r range - Properties = Map.empty - FsAstNode = arg } + mkNode SynTypeDefnSimpleRepr_TypeAbbrev range :: (visitSynType typ) - | SynTypeDefnSimpleRepr.Exception (edr) -> - { Type = SynTypeDefnSimpleRepr_Exception - Range = noRange - Properties = Map.empty - FsAstNode = arg } - :: (visitSynExceptionDefnRepr edr) - - and visitSynExceptionDefn (exceptionDef: SynExceptionDefn) : Node list = + | SynTypeDefnSimpleRepr.Exception (edr) -> visitSynExceptionDefnRepr edr + + and visitSynExceptionDefn (exceptionDef: SynExceptionDefn) : TriviaNodeAssigner list = match exceptionDef with | SynExceptionDefn (sedr, members, range) -> - { Type = SynExceptionDefn_ - Range = r range - Properties = Map.empty - FsAstNode = exceptionDef } - :: [ yield! visitSynExceptionDefnRepr sedr - yield! (members |> List.collect visitSynMemberDefn) ] - - and visitSynExceptionDefnRepr (sedr: SynExceptionDefnRepr) : Node list = + [ mkNode SynExceptionDefn_ range + yield! visitSynExceptionDefnRepr sedr + yield! (members |> List.collect visitSynMemberDefn) ] + + and visitSynExceptionDefnRepr (sedr: SynExceptionDefnRepr) : TriviaNodeAssigner list = match sedr with | SynExceptionDefnRepr (attrs, unionCase, _, _, _, range) -> - { Type = SynExceptionDefnRepr_ - Range = r range - Properties = Map.empty - FsAstNode = sedr } - :: [ yield! (visitSynAttributeLists range attrs) - yield! visitSynUnionCase unionCase ] - - and visitSynAttribute (attr: SynAttribute) : Node list = - { Type = SynAttribute_ - Range = r attr.Range - Properties = Map.empty - FsAstNode = attr } + [ mkNode SynExceptionDefnRepr_ range + yield! (visitSynAttributeLists range attrs) + yield! visitSynUnionCase unionCase ] + + and visitSynAttribute (attr: SynAttribute) : TriviaNodeAssigner list = + mkNode SynAttribute_ attr.Range :: (visitSynExpr attr.ArgExpr) - and visitSynAttributeLists (parentRange: Range) (attrs: SynAttributeList list) : Node list = + and visitSynAttributeLists (parentRange: Range) (attrs: SynAttributeList list) : TriviaNodeAssigner list = match attrs with | [ h ] -> visitSynAttributeList parentRange h | _ :: tail -> @@ -1630,109 +1085,75 @@ module private Ast = |> List.collect (fun (a, r) -> visitSynAttributeList r a) | [] -> [] - and visitSynAttributeList (parentRange: Range) (attrs: SynAttributeList) : Node list = - { Type = SynAttributeList_ - Range = r attrs.Range - Properties = p [ "linesBetweenParent", box (parentRange.StartLine - attrs.Range.EndLine - 1) ] - FsAstNode = attrs } + and visitSynAttributeList (parentRange: Range) (attrs: SynAttributeList) : TriviaNodeAssigner list = + TriviaNodeAssigner(MainNode(SynAttributeList_), attrs.Range, parentRange.StartLine - attrs.Range.EndLine - 1) :: (List.collect visitSynAttribute attrs.Attributes) - and visitSynUnionCase (uc: SynUnionCase) : Node list = + and visitSynUnionCase (uc: SynUnionCase) : TriviaNodeAssigner list = match uc with | UnionCase (attrs, _, uct, _, _, range) -> - { Type = UnionCase_ - Range = r range - Properties = Map.empty - FsAstNode = uc } - :: [ yield! visitSynUnionCaseType uct - yield! (visitSynAttributeLists range attrs) ] + [ mkNode UnionCase_ range + yield! visitSynUnionCaseType uct + yield! (visitSynAttributeLists range attrs) ] and visitSynUnionCaseType (uct: SynUnionCaseType) = match uct with - | UnionCaseFields (cases) -> - { Type = UnionCaseFields_ - Range = noRange - Properties = Map.empty - FsAstNode = uct } - :: (List.collect visitSynField cases) - | UnionCaseFullType (stype, valInfo) -> - { Type = UnionCaseFullType_ - Range = noRange - Properties = Map.empty - FsAstNode = uct } - :: [ yield! visitSynType stype - yield! visitSynValInfo valInfo ] - - and visitSynEnumCase (sec: SynEnumCase) : Node list = + | UnionCaseFields (cases) -> List.collect visitSynField cases + | UnionCaseFullType (stype, valInfo) -> visitSynType stype @ visitSynValInfo valInfo + + and visitSynEnumCase (sec: SynEnumCase) : TriviaNodeAssigner list = match sec with | EnumCase (attrs, ident, _, _, range) -> - { Type = EnumCase_ - Range = r range - Properties = Map.empty - FsAstNode = sec } - :: [ yield! (visitSynAttributeLists range attrs) - yield visitIdent ident ] - - and visitSynField (sfield: SynField) : Node list = + [ yield mkNode EnumCase_ range + yield! (visitSynAttributeLists range attrs) + yield visitIdent ident ] + + and visitSynField (sfield: SynField) : TriviaNodeAssigner list = match sfield with | Field (attrs, _, ident, typ, _, _, _, range) -> let parentRange = Option.map (fun (i: Ident) -> i.idRange) ident |> Option.defaultValue range - { Type = Field_ - Range = r range - Properties = Map.empty - FsAstNode = sfield } - :: [ yield! (visitSynAttributeLists parentRange attrs) - yield! visitSynType typ ] + [ mkNode Field_ range + yield! (visitSynAttributeLists parentRange attrs) + yield! visitSynType typ ] and visitSynType (st: SynType) = - let rec visit (st: SynType) (finalContinuation: Node list -> Node list) : Node list = + let rec visit + (st: SynType) + (finalContinuation: TriviaNodeAssigner list -> TriviaNodeAssigner list) + : TriviaNodeAssigner list = match st with - | SynType.LongIdent (li) -> - { Type = SynType_LongIdent - Range = noRange - Properties = Map.empty - FsAstNode = st } - :: (visitLongIdentWithDots li) - |> finalContinuation + | SynType.LongIdent (li) -> visitLongIdentWithDots li |> finalContinuation | SynType.App (typeName, _, typeArgs, _, _, _, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = [ yield! (List.map visit typeArgs) visit typeName ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynType_App - Range = r range - Properties = Map.empty - FsAstNode = st } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynType_App range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynType.LongIdentApp (typeName, _, _, typeArgs, _, _, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = [ yield! (List.map visit typeArgs) visit typeName ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynType_LongIdentApp - Range = r range - Properties = Map.empty - FsAstNode = st } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynType_LongIdentApp range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynType.Tuple (_, typeNames, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = List.map (snd >> visit) typeNames + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + List.map (snd >> visit) typeNames - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynType_Tuple - Range = r range - Properties = Map.empty - FsAstNode = st } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynType_Tuple range :: (List.collect id nodes) |> finalContinuation @@ -1741,68 +1162,46 @@ module private Ast = visit elementType (fun nodes -> - { Type = SynType_Array - Range = r range - Properties = Map.empty - FsAstNode = st } - :: nodes + mkNode SynType_Array range :: nodes |> finalContinuation) | SynType.Fun (argType, returnType, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit argType; visit returnType ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit argType; visit returnType ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynType_Fun - Range = r range - Properties = Map.empty - FsAstNode = st } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynType_Fun range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynType.Var (genericName, range) -> - { Type = SynType_Var - Range = r range - Properties = Map.empty - FsAstNode = st } + mkNode SynType_Var range :: (visitSynTypar genericName) |> finalContinuation | SynType.Anon (range) -> - { Type = SynType_Anon - Range = r range - Properties = Map.empty - FsAstNode = st } + mkNode SynType_Anon range |> List.singleton |> finalContinuation | SynType.WithGlobalConstraints (typeName, _, range) -> visit typeName (fun nodes -> - { Type = SynType_WithGlobalConstraints - Range = r range - Properties = Map.empty - FsAstNode = st } + mkNode SynType_WithGlobalConstraints range :: nodes |> finalContinuation) | SynType.HashConstraint (synType, range) -> visit synType (fun nodes -> - { Type = SynType_HashConstraint - Range = r range - Properties = Map.empty - FsAstNode = st } - :: nodes + mkNode SynType_HashConstraint range :: nodes |> finalContinuation) | SynType.MeasureDivide (dividendType, divisorType, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = [ visit dividendType visit divisorType ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynType_MeasureDivide - Range = r range - Properties = Map.empty - FsAstNode = st } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynType_MeasureDivide range :: (List.collect id nodes) |> finalContinuation @@ -1811,59 +1210,40 @@ module private Ast = visit measureType (fun nodes -> - { Type = SynType_MeasurePower - Range = r range - Properties = Map.empty - FsAstNode = st } - :: nodes + mkNode SynType_MeasurePower range :: nodes |> finalContinuation) | SynType.StaticConstant (constant, range) -> - [ { Type = SynType_StaticConstant - Range = r range - Properties = Map.empty - FsAstNode = st } + [ mkNode SynType_StaticConstant range visitSynConst range constant ] |> finalContinuation | SynType.StaticConstantExpr (expr, range) -> - { Type = SynType_StaticConstantExpr - Range = r range - Properties = Map.empty - FsAstNode = st } + mkNode SynType_StaticConstantExpr range :: (visitSynExpr expr) |> finalContinuation | SynType.StaticConstantNamed (expr, typ, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = [ visit expr; visit typ ] + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + [ visit expr; visit typ ] - let finalContinuation (nodes: Node list list) : Node list = - { Type = SynType_StaticConstantNamed - Range = r range - Properties = Map.empty - FsAstNode = st } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + mkNode SynType_StaticConstantNamed range :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation | SynType.AnonRecd (_, typeNames, range) -> - { Type = SynType_AnonRecd - Range = r range - Properties = Map.empty - FsAstNode = st } + mkNode SynType_AnonRecd range :: (List.collect visitAnonRecordTypeField typeNames) |> finalContinuation | SynType.Paren (innerType, range) -> visit innerType (fun nodes -> - { Type = SynType_Paren - Range = r range - Properties = Map.empty - FsAstNode = st } - :: nodes + mkNode SynType_Paren range :: nodes |> finalContinuation) visit st id - and visitSynConst (parentRange: Range) (sc: SynConst) : Node = + and visitSynConst (parentRange: Range) (sc: SynConst) : TriviaNodeAssigner = let t = match sc with | SynConst.Bool _ -> SynConst_Bool @@ -1888,24 +1268,15 @@ module private Ast = | SynConst.UInt16s _ -> SynConst_UInt16s | SynConst.Measure _ -> SynConst_Measure - { Type = t - Range = r (sc.Range parentRange) - Properties = Map.empty - FsAstNode = sc } + mkNode t (sc.Range parentRange) and visitSynValInfo (svi: SynValInfo) = match svi with | SynValInfo (args, arg) -> - { Type = SynValInfo_ - Range = noRange - Properties = Map.empty - FsAstNode = svi } - :: [ yield! - args - |> List.collect (List.collect visitSynArgInfo) - yield! visitSynArgInfo arg ] - - and visitSynArgInfo (sai: SynArgInfo) : Node list = + (List.collect (List.collect visitSynArgInfo) args) + @ visitSynArgInfo arg + + and visitSynArgInfo (sai: SynArgInfo) : TriviaNodeAssigner list = match sai with | SynArgInfo (attrs, _, ident) -> let parentRange = @@ -1913,11 +1284,7 @@ module private Ast = |> Option.map (fun i -> i.idRange) |> Option.defaultValue range.Zero - { Type = SynArgInfo_ - Range = noRange - Properties = Map.empty - FsAstNode = sai } - :: (visitSynAttributeLists parentRange attrs) + visitSynAttributeLists parentRange attrs and visitSynAccess (a: SynAccess) = match a with @@ -1940,15 +1307,11 @@ module private Ast = | MemberKind.PropertySet -> "PropertySet" | MemberKind.PropertyGetSet -> "PropertyGetSet" - and visitParsedHashDirective (hash: ParsedHashDirective) : Node = + and visitParsedHashDirective (hash: ParsedHashDirective) : TriviaNodeAssigner = match hash with - | ParsedHashDirective (_, _, range) -> - { Type = ParsedHashDirective_ - Range = r range - Properties = Map.empty - FsAstNode = hash } + | ParsedHashDirective (_, _, range) -> mkNode ParsedHashDirective_ range - and visitSynModuleOrNamespaceSig (modOrNs: SynModuleOrNamespaceSig) : Node list = + and visitSynModuleOrNamespaceSig (modOrNs: SynModuleOrNamespaceSig) : TriviaNodeAssigner list = match modOrNs with | SynModuleOrNamespaceSig (longIdent, _, synModuleOrNamespaceKind, decls, _, attrs, _, range) -> let typeName = @@ -1961,10 +1324,7 @@ module private Ast = [ // LongIdent inside Namespace is being processed as children. if typeName <> SynModuleOrNamespaceSig_DeclaredNamespace then - { Type = typeName - Range = r range - Properties = Map.empty - FsAstNode = modOrNs } + mkNode typeName range yield! if synModuleOrNamespaceKind = SynModuleOrNamespaceKind.DeclaredNamespace then visitLongIdent longIdent @@ -1973,24 +1333,22 @@ module private Ast = yield! (visitSynAttributeLists range attrs) yield! (decls |> List.collect visitSynModuleSigDecl) ] - and visitSynModuleSigDecl (ast: SynModuleSigDecl) : Node list = - let rec visit (ast: SynModuleSigDecl) (finalContinuation: Node list -> Node list) : Node list = + and visitSynModuleSigDecl (ast: SynModuleSigDecl) : TriviaNodeAssigner list = + let rec visit + (ast: SynModuleSigDecl) + (finalContinuation: TriviaNodeAssigner list -> TriviaNodeAssigner list) + : TriviaNodeAssigner list = match ast with | SynModuleSigDecl.ModuleAbbrev (_, _, range) -> - { Type = SynModuleSigDecl_ModuleAbbrev - Range = r range - Properties = Map.empty - FsAstNode = ast } + mkNode SynModuleSigDecl_ModuleAbbrev range |> List.singleton |> finalContinuation | SynModuleSigDecl.NestedModule (sci, _, decls, range) -> - let continuations : ((Node list -> Node list) -> Node list) list = List.map visit decls + let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = + List.map visit decls - let finalContinuation (nodes: Node list list) : Node list = - [ { Type = SynModuleSigDecl_NestedModule - Range = r range - Properties = Map.empty - FsAstNode = ast } + let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = + [ mkNode SynModuleSigDecl_NestedModule range yield! visitSynComponentInfo sci yield! (List.collect id nodes) ] |> finalContinuation @@ -1998,92 +1356,58 @@ module private Ast = Continuation.sequence continuations finalContinuation | SynModuleSigDecl.Val (SynValSig.ValSpfn _ as node, _) -> visitSynValSig node |> finalContinuation | SynModuleSigDecl.Types (typeDefs, range) -> - { Type = SynModuleSigDecl_Types - Range = r range - Properties = Map.empty - FsAstNode = ast } + mkNode SynModuleSigDecl_Types range :: (List.collect visitSynTypeDefnSig typeDefs) |> finalContinuation | SynModuleSigDecl.Open (target, parentRange) -> // we use the parent ranges here to match up with the trivia parsed match target with | SynOpenDeclTarget.ModuleOrNamespace (_, _range) -> - { Type = SynModuleSigDecl_Open - Range = r parentRange - Properties = Map.empty - FsAstNode = target } + mkNode SynModuleSigDecl_Open parentRange |> List.singleton |> finalContinuation | SynOpenDeclTarget.Type (synType, _range) -> - { Type = SynModuleSigDecl_OpenType - Range = r parentRange - Properties = Map.empty - FsAstNode = target } + mkNode SynModuleSigDecl_OpenType parentRange :: (visitSynType synType) |> finalContinuation | SynModuleSigDecl.HashDirective (hash, range) -> - [ { Type = SynModuleSigDecl_HashDirective - Range = r range - Properties = Map.empty - FsAstNode = ast } + [ mkNode SynModuleSigDecl_HashDirective range (visitParsedHashDirective hash) ] |> finalContinuation | SynModuleSigDecl.NamespaceFragment (moduleOrNamespace) -> - { Type = SynModuleSigDecl_NamespaceFragment - Range = noRange - Properties = Map.empty - FsAstNode = ast } - :: (visitSynModuleOrNamespaceSig moduleOrNamespace) + visitSynModuleOrNamespaceSig moduleOrNamespace |> finalContinuation | SynModuleSigDecl.Exception (synExceptionSig, range) -> - { Type = SynModuleSigDecl_Exception - Range = r range - Properties = Map.empty - FsAstNode = ast } + mkNode SynModuleSigDecl_Exception range :: (visitSynExceptionSig synExceptionSig) |> finalContinuation visit ast id - and visitSynExceptionSig (exceptionDef: SynExceptionSig) : Node list = + and visitSynExceptionSig (exceptionDef: SynExceptionSig) : TriviaNodeAssigner list = match exceptionDef with | SynExceptionSig (sedr, members, range) -> - { Type = SynExceptionSig_ - Range = r range - Properties = Map.empty - FsAstNode = exceptionDef } - :: [ yield! visitSynExceptionDefnRepr sedr - yield! (members |> List.collect visitSynMemberSig) ] - - and visitLongIdentWithDots (lid: LongIdentWithDots) : Node list = + [ mkNode SynExceptionSig_ range + yield! visitSynExceptionDefnRepr sedr + yield! (members |> List.collect visitSynMemberSig) ] + + and visitLongIdentWithDots (lid: LongIdentWithDots) : TriviaNodeAssigner list = match lid with | LongIdentWithDots (ids, _) -> List.map visitIdent ids - and visitLongIdent (li: LongIdent) : Node list = List.map visitIdent li + and visitLongIdent (li: LongIdent) : TriviaNodeAssigner list = List.map visitIdent li - and visitIdent (ident: Ident) : Node = - { Type = Ident_ - Range = r ident.idRange - Properties = Map.empty - FsAstNode = ident } + and visitIdent (ident: Ident) : TriviaNodeAssigner = mkNode Ident_ ident.idRange -let astToNode (hds: ParsedHashDirective list) (mdls: SynModuleOrNamespace list) : Node list = +let astToNode (hds: ParsedHashDirective list) (mdls: SynModuleOrNamespace list) : TriviaNodeAssigner list = let children = [ yield! List.collect Ast.visitSynModuleOrNamespace mdls yield! List.map Ast.visitParsedHashDirective hds ] - { Type = File_ - Range = None - Properties = Map.empty - FsAstNode = mdls } - :: children + children -let sigAstToNode (ast: SynModuleOrNamespaceSig list) : Node list = +let sigAstToNode (ast: SynModuleOrNamespaceSig list) : TriviaNodeAssigner list = let children = List.collect Ast.visitSynModuleOrNamespaceSig ast - { Type = SigFile_ - Range = None - Properties = Map.empty - FsAstNode = ast } - :: children + children diff --git a/src/Fantomas/Trivia.fs b/src/Fantomas/Trivia.fs index 2ae4c26383..d5aabe5628 100644 --- a/src/Fantomas/Trivia.fs +++ b/src/Fantomas/Trivia.fs @@ -175,22 +175,6 @@ let private findSynConstStringNodeAfter (nodes: TriviaNodeAssigner list) (range: | MainNode (SynConst_String), true, true -> true | _ -> false) -let private mapNodeToTriviaNode (node: Node) = - node.Range - |> Option.map - (fun range -> - let attributeParent = - Map.tryFind "linesBetweenParent" node.Properties - |> Option.bind - (fun v -> - match v with - | :? int as i when (i > 0) -> Some i - | _ -> None) - - match attributeParent with - | Some i -> TriviaNodeAssigner(MainNode(node.Type), range, i) - | None -> TriviaNodeAssigner(MainNode(node.Type), range)) - let private commentIsAfterLastTriviaNode (triviaNodes: TriviaNodeAssigner list) (range: Range) = let hasNoNodesAfterRange = triviaNodes @@ -511,19 +495,12 @@ let private triviaNodeIsNotEmpty (triviaNode: TriviaNodeAssigner) = 4. genTrivia should use ranges to identify what extra content should be added from what triviaNode *) let collectTrivia (mkRange: MkRange) tokens (ast: ParsedInput) = - let nodes = + let triviaNodesFromAST = match ast with | ParsedInput.ImplFile (ParsedImplFileInput.ParsedImplFileInput (_, _, _, _, hds, mns, _)) -> astToNode hds mns | ParsedInput.SigFile (ParsedSigFileInput.ParsedSigFileInput (_, _, _, _, mns)) -> sigAstToNode mns - let startOfSourceCode = - match nodes with - | { Range = Some r } :: _ -> r.StartLine - | _ -> 1 - - let triviaNodesFromAST = nodes |> List.choose mapNodeToTriviaNode - let hasAnyAttributesWithLinesBetweenParent = List.exists (fun (tn: TriviaNodeAssigner) -> Option.isSome tn.AttributeLinesBetweenParent) triviaNodesFromAST @@ -546,6 +523,11 @@ let collectTrivia (mkRange: MkRange) tokens (ast: ParsedInput) = let trivias = TokenParser.getTriviaFromTokens mkRange tokens + let startOfSourceCode = + match tokens with + | h :: _ -> h.LineNumber // Keep track of comments or hash defines before the first AST node + | _ -> 1 + match trivias with | [] -> [] | _ -> From 37db8764a64f996bf0ce662c53e6ae8b7034fa32 Mon Sep 17 00:00:00 2001 From: nojaf Date: Sat, 27 Feb 2021 19:43:12 +0100 Subject: [PATCH 6/8] Remove unused code --- src/Fantomas/AstTransformer.fs | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/Fantomas/AstTransformer.fs b/src/Fantomas/AstTransformer.fs index 3190981bf7..a0a8def353 100644 --- a/src/Fantomas/AstTransformer.fs +++ b/src/Fantomas/AstTransformer.fs @@ -7,11 +7,6 @@ open Fantomas type Id = { Ident: string; Range: Range } -//type Node = -// { Type: FsAstType -// Range: Range -// LinesBetweenParent: int } - module Helpers = let i (id: Ident) : Id = { Ident = id.idText From cc2c35e2665f2ca14b9507d1596780e07dd07f7e Mon Sep 17 00:00:00 2001 From: nojaf Date: Fri, 12 Mar 2021 16:25:05 +0100 Subject: [PATCH 7/8] Remove SynExpr.Const and SynPat.Const from AstTransformer.fs. --- src/Fantomas/AstTransformer.fs | 70 ++++---------- src/Fantomas/CodePrinter.fs | 149 +++++++++++++++++------------- src/Fantomas/SourceTransformer.fs | 43 +++++++-- src/Fantomas/Trivia.fs | 21 ++++- src/Fantomas/TriviaTypes.fs | 20 ++-- 5 files changed, 165 insertions(+), 138 deletions(-) diff --git a/src/Fantomas/AstTransformer.fs b/src/Fantomas/AstTransformer.fs index a0a8def353..145f932735 100644 --- a/src/Fantomas/AstTransformer.fs +++ b/src/Fantomas/AstTransformer.fs @@ -131,18 +131,11 @@ module private Ast = Continuation.sequence continuations finalContinuation | SynExpr.Const (constant, range) -> - [ mkNode SynExpr_Const range - visitSynConst range constant ] + visitSynConst range constant + |> List.singleton |> finalContinuation | SynExpr.Typed (expr, typeName, _) -> - visit - expr - (fun nodes -> - // { Type = SynExpr_Typed -// Range = r range -// Properties = Map.empty -// } - nodes @ visitSynType typeName |> finalContinuation) + visit expr (fun nodes -> nodes @ visitSynType typeName |> finalContinuation) | SynExpr.Tuple (_, exprs, _, range) -> let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = exprs |> List.map visit @@ -227,9 +220,6 @@ module private Ast = mkNode SynExpr_ArrayOrListOfSeqExpr range :: nodes |> finalContinuation) | SynExpr.CompExpr (_, _, expr, _) -> visit expr finalContinuation - // { Type = SynExpr_CompExpr -// Range = r range -// Properties = Map.empty } | SynExpr.Lambda (_, _, args, body, _parsedData, range) -> visit body @@ -284,12 +274,6 @@ module private Ast = visit body (fun nodes -> - // { Type = SynExpr_LetOrUse -// Range = r range -// Properties = -// p [ "isRecursive" ==> isRecursive -// "isUse" ==> isUse ] -// } (List.collect visitSynBinding bindings) @ nodes |> finalContinuation) | SynExpr.TryWith (tryExpr, _, withCases, _, range, _, _) -> @@ -321,10 +305,6 @@ module private Ast = [ visit expr1; visit expr2 ] let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = - // { Type = SynExpr_Sequential -// Range = r range -// Properties = Map.empty -// } (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation @@ -671,10 +651,6 @@ module private Ast = and visitSynTypeDefnSig (typeDefSig: SynTypeDefnSig) : TriviaNodeAssigner list = match typeDefSig with | TypeDefnSig (sci, synTypeDefnSigReprs, memberSig, _) -> - // { Type = TypeDefnSig_ -// Range = r range -// Properties = Map.empty -// FsAstNode = typeDefSig } [ yield! visitSynComponentInfo sci yield! visitSynTypeDefnSigRepr synTypeDefnSigReprs yield! (memberSig |> List.collect visitSynMemberSig) ] @@ -682,18 +658,9 @@ module private Ast = and visitSynTypeDefnSigRepr (stdr: SynTypeDefnSigRepr) : TriviaNodeAssigner list = match stdr with | SynTypeDefnSigRepr.ObjectModel (kind, members, _) -> - // { Type = SynTypeDefnSigRepr_ObjectModel -// Range = r range -// Properties = Map.empty -// FsAstNode = stdr } visitSynTypeDefnKind kind @ (members |> List.collect visitSynMemberSig) - | SynTypeDefnSigRepr.Simple (simpleRepr, _) -> - // { Type = SynTypeDefnSigRepr_ObjectModel -// Range = r range -// Properties = Map.empty -// FsAstNode = stdr } - (visitSynTypeDefnSimpleRepr simpleRepr) + | SynTypeDefnSigRepr.Simple (simpleRepr, _) -> (visitSynTypeDefnSimpleRepr simpleRepr) | SynTypeDefnSigRepr.Exception (exceptionRepr) -> visitSynExceptionDefnRepr exceptionRepr and visitSynMemberDefn (mbrDef: SynMemberDefn) : TriviaNodeAssigner list = @@ -859,8 +826,7 @@ module private Ast = : TriviaNodeAssigner list = match sp with | SynPat.Const (sc, range) -> - [ mkNode SynPat_Const range - visitSynConst range sc ] + List.singleton (visitSynConst range sc) |> finalContinuation | SynPat.Wild (range) -> mkNode SynPat_Wild range @@ -996,18 +962,9 @@ module private Ast = and visitSynTypeDefnRepr (stdr: SynTypeDefnRepr) : TriviaNodeAssigner list = match stdr with | SynTypeDefnRepr.ObjectModel (kind, members, _) -> - // { Type = SynTypeDefnRepr_ObjectModel -// Range = r range -// Properties = Map.empty -// FsAstNode = stdr } visitSynTypeDefnKind kind @ (members |> List.collect visitSynMemberDefn) - | SynTypeDefnRepr.Simple (simpleRepr, _) -> - // { Type = SynTypeDefnRepr_Simple -// Range = r range -// Properties = Map.empty -// FsAstNode = stdr } - visitSynTypeDefnSimpleRepr simpleRepr + | SynTypeDefnRepr.Simple (simpleRepr, _) -> visitSynTypeDefnSimpleRepr simpleRepr | SynTypeDefnRepr.Exception (exceptionRepr) -> visitSynExceptionDefnRepr exceptionRepr and visitSynTypeDefnKind (kind: SynTypeDefnKind) : TriviaNodeAssigner list = @@ -1098,10 +1055,11 @@ module private Ast = and visitSynEnumCase (sec: SynEnumCase) : TriviaNodeAssigner list = match sec with - | EnumCase (attrs, ident, _, _, range) -> + | EnumCase (attrs, ident, value, _, range) -> [ yield mkNode EnumCase_ range yield! (visitSynAttributeLists range attrs) - yield visitIdent ident ] + yield visitIdent ident + yield visitSynConst range value ] and visitSynField (sfield: SynField) : TriviaNodeAssigner list = match sfield with @@ -1239,7 +1197,7 @@ module private Ast = visit st id and visitSynConst (parentRange: Range) (sc: SynConst) : TriviaNodeAssigner = - let t = + let t sc = match sc with | SynConst.Bool _ -> SynConst_Bool | SynConst.Unit _ -> SynConst_Unit @@ -1263,7 +1221,13 @@ module private Ast = | SynConst.UInt16s _ -> SynConst_UInt16s | SynConst.Measure _ -> SynConst_Measure - mkNode t (sc.Range parentRange) + match sc with + | SynConst.Measure (n, SynMeasure.Seq (_, mr)) -> + let numberRange = + Range.mkRange mr.FileName parentRange.Start (Pos.mkPos mr.StartLine (mr.StartColumn - 1)) + + mkNode (t n) numberRange + | _ -> mkNode (t sc) (sc.Range parentRange) and visitSynValInfo (svi: SynValInfo) = match svi with diff --git a/src/Fantomas/CodePrinter.fs b/src/Fantomas/CodePrinter.fs index 8bd48b2225..978247a6a0 100644 --- a/src/Fantomas/CodePrinter.fs +++ b/src/Fantomas/CodePrinter.fs @@ -2224,7 +2224,7 @@ and genExpr astContext synExpr ctx = (function | Comment (LineCommentAfterSourceCode _) -> true | _ -> false) - (TriviaHelpers.getNodesForTypes [ SynExpr_Ident; SynExpr_Const ] ctx.TriviaMainNodes) + (Map.tryFindOrEmptyList SynExpr_Ident ctx.TriviaMainNodes) let hasCommentAfterIfKeyword = commentAfterKeyword IF (RangeHelpers.rangeStartEq synExpr.Range) ctx @@ -2243,7 +2243,7 @@ and genExpr astContext synExpr ctx = (function | Comment (LineCommentAfterSourceCode _) -> true | _ -> false) - (TriviaHelpers.getNodesForTypes [ SynExpr_Ident; SynExpr_Const ] ctx.TriviaMainNodes) + (Map.tryFindOrEmptyList SynExpr_Ident ctx.TriviaMainNodes) let hasCommentAfterThenKeyword = commentAfterKeyword THEN (RangeHelpers.``range contains`` fullRange) ctx @@ -2339,7 +2339,7 @@ and genExpr astContext synExpr ctx = (function | Comment (LineCommentAfterSourceCode _) -> true | _ -> false) - (TriviaHelpers.getNodesForTypes [ SynExpr_Ident; SynExpr_Const ] ctx.TriviaMainNodes) + (Map.tryFindOrEmptyList SynExpr_Ident ctx.TriviaMainNodes) let elifExpr = TriviaContext.``else if / elif`` fullRange @@ -2703,7 +2703,6 @@ and genExpr astContext synExpr ctx = | e -> failwithf "Unexpected expression: %O" e |> (match synExpr with | SynExpr.App _ -> genTriviaFor SynExpr_App synExpr.Range - | SynExpr.Const _ -> genTriviaFor SynExpr_Const synExpr.Range | SynExpr.AnonRecd _ -> genTriviaFor SynExpr_AnonRecd synExpr.Range | SynExpr.Record _ -> genTriviaFor SynExpr_Record synExpr.Range | SynExpr.Ident _ -> genTriviaFor SynExpr_Ident synExpr.Range @@ -3534,9 +3533,7 @@ and genTypeDefn astContext (TypeDef (ats, px, ao, tds, tcs, tdr, ms, s, preferPo +> unindent) let genTypeBody = - autoIndentAndNlnIfExpressionExceedsPageWidth ( - genTriviaFor SynTypeDefnRepr_ObjectModel tdr.Range genTypeAbbrev - ) + autoIndentAndNlnIfExpressionExceedsPageWidth (genTypeAbbrev) +> genMembers typeName +> sepEq +> sepSpace +> genTypeBody @@ -3721,11 +3718,7 @@ and sepNlnBetweenSigTypeAndMembers (ms: SynMemberSig list) = sepNlnTypeAndMembers (Some range) mainNodeType | None -> sepNone -and genSigTypeDefn astContext (SigTypeDef (ats, px, ao, tds, tcs, tdr, ms, s, preferPostfix) as node) = - let range = - match node with - | SynTypeDefnSig.TypeDefnSig (_, _, _, r) -> r - +and genSigTypeDefn astContext (SigTypeDef (ats, px, ao, tds, tcs, tdr, ms, s, preferPostfix)) = let typeName = genPreXmlDoc px +> ifElse @@ -3888,7 +3881,6 @@ and genSigTypeDefn astContext (SigTypeDef (ats, px, ao, tds, tcs, tdr, ms, s, pr +> unindent | SigExceptionRepr (SigExceptionDefRepr (ats, px, ao, uc)) -> genExceptionBody astContext ats px ao uc - |> genTriviaFor TypeDefnSig_ range and genSigSimpleRecord tdr ms ao' fs astContext = // the typeName is already printed @@ -4065,8 +4057,24 @@ and genEnumCase astContext (EnumCase (ats, px, _, (_, _)) as node) = let expr = match node with | EnumCase (_, _, identInAST, (c, r)) -> - !-identInAST +> !- " = " +> genConst c r - |> genTriviaFor EnumCase_ r + let triviaNode = + Map.tryFindOrEmptyList EnumCase_ ctx.TriviaMainNodes + |> List.tryFind (fun tn -> RangeHelpers.rangeEq tn.Range r) + + match triviaNode with + | Some ({ ContentItself = Some (Number n) } as tn) -> + printContentBefore tn + +> !-identInAST + +> !- " = " + +> !-n + +> printContentAfter tn + | Some tn -> + printContentBefore tn + +> !-identInAST + +> !- " = " + +> genConst c r + +> printContentAfter tn + | None -> !-identInAST +> !- " = " +> genConst c r expr ctx @@ -5164,6 +5172,7 @@ and genConst (c: SynConst) (r: Range) = +> enterNodeTokenByName r RPAREN +> !- ")" +> leaveNodeTokenByName r RPAREN + |> genTriviaFor SynConst_Unit r | SynConst.Bool (b) -> !-(if b then "true" else "false") | SynConst.Byte _ | SynConst.SByte _ @@ -5187,24 +5196,23 @@ and genConst (c: SynConst) (r: Range) = Map.tryFindOrEmptyList SynConst_String ctx.TriviaMainNodes |> List.tryFind (fun tv -> RangeHelpers.rangeEq tv.Range r) - let triviaStringContent = - trivia - |> Option.bind - (fun tv -> - match tv.ContentItself with - | Some (StringContent (sc)) -> Some sc - | _ -> None) - - match triviaStringContent, trivia with - | Some stringContent, Some _ -> !-stringContent - | None, - Some ({ ContentBefore = [ Keyword ({ TokenInfo = { TokenName = "KEYWORD_STRING" } + match trivia with + | Some ({ ContentItself = Some (StringContent (sc)) } as tn) -> + printContentBefore tn + +> !-sc + +> printContentAfter tn + | Some ({ ContentBefore = [ Keyword ({ TokenInfo = { TokenName = "KEYWORD_STRING" } Content = kw }) ] }) -> !-kw - | None, - Some ({ ContentBefore = [ Keyword ({ TokenInfo = { TokenName = "QMARK" } }) ] + | Some ({ ContentBefore = [ Keyword ({ TokenInfo = { TokenName = "QMARK" } }) ] ContentItself = Some (IdentBetweenTicks ibt) }) -> !-ibt - | None, Some ({ ContentBefore = [ Keyword ({ TokenInfo = { TokenName = "QMARK" } }) ] }) -> !-s - | _ -> + | Some ({ ContentBefore = [ Keyword ({ TokenInfo = { TokenName = "QMARK" } }) ] }) -> !-s + | Some tn -> + let escaped = Regex.Replace(s, "\"{1}", "\\\"") + + printContentBefore tn + +> !-(sprintf "\"%s\"" escaped) + +> printContentAfter tn + | None -> let escaped = Regex.Replace(s, "\"{1}", "\\\"") !-(sprintf "\"%s\"" escaped) <| ctx @@ -5227,45 +5235,56 @@ and genConst (c: SynConst) (r: Range) = match m with | Measure m -> !-m - genConstNumber c r + let genNumber (ctx: Context) = + match m with + | SynMeasure.Seq (_, mr) -> + let numberRange = + ctx.MkRange r.Start (Pos.mkPos mr.StartLine (mr.StartColumn - 1)) + + genConstNumber c numberRange ctx + | _ -> genConstNumber c r ctx + + genNumber +> measure +> leaveNodeTokenByName r GREATER and genConstNumber (c: SynConst) (r: Range) = fun (ctx: Context) -> - TriviaHelpers.getNodesForTypes - [ SynExpr_Const - SynPat_Const - EnumCase_ ] - ctx.TriviaMainNodes - |> List.tryFind (fun t -> RangeHelpers.rangeEq t.Range r) - |> Option.bind - (fun tn -> - match tn.ContentItself with - | Some (Number (n)) -> Some n - | _ -> None) - |> fun n -> - match n with - | Some n -> !-n - | None -> - match c with - | SynConst.Byte (v) -> !-(sprintf "%A" v) - | SynConst.SByte (v) -> !-(sprintf "%A" v) - | SynConst.Int16 (v) -> !-(sprintf "%A" v) - | SynConst.Int32 (v) -> !-(sprintf "%A" v) - | SynConst.Int64 (v) -> !-(sprintf "%A" v) - | SynConst.UInt16 (v) -> !-(sprintf "%A" v) - | SynConst.UInt16s (v) -> !-(sprintf "%A" v) - | SynConst.UInt32 (v) -> !-(sprintf "%A" v) - | SynConst.UInt64 (v) -> !-(sprintf "%A" v) - | SynConst.Double (v) -> !-(sprintf "%A" v) - | SynConst.Single (v) -> !-(sprintf "%A" v) - | SynConst.Decimal (v) -> !-(sprintf "%A" v) - | SynConst.IntPtr (v) -> !-(sprintf "%A" v) - | SynConst.UIntPtr (v) -> !-(sprintf "%A" v) - | SynConst.UserNum (v, s) -> !-(sprintf "%s%s" v s) - | _ -> failwithf "Cannot generating Const number for %A" c - <| ctx + let findNumberAsContentItself (fallback: Context -> Context) (nodeType: FsAstType) = + Map.tryFindOrEmptyList nodeType ctx.TriviaMainNodes + |> List.tryFind (fun t -> RangeHelpers.rangeEq t.Range r) + |> fun tn -> + match tn with + | Some ({ ContentItself = Some (Number (n)) } as tn) -> + printContentBefore tn + +> !-n + +> printContentAfter tn + | Some tn -> + printContentBefore tn + +> fallback + +> printContentAfter tn + | _ -> fallback + + let expr = + match c with + | SynConst.Byte (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_Byte + | SynConst.SByte (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_SByte + | SynConst.Int16 (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_Int16 + | SynConst.Int32 (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_Int32 + | SynConst.Int64 (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_Int64 + | SynConst.UInt16 (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_UInt16 + | SynConst.UInt16s (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_UInt16s + | SynConst.UInt32 (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_UInt32 + | SynConst.UInt64 (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_UInt64 + | SynConst.Double (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_Double + | SynConst.Single (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_Single + | SynConst.Decimal (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_Decimal + | SynConst.IntPtr (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_IntPtr + | SynConst.UIntPtr (v) -> findNumberAsContentItself (!-(sprintf "%A" v)) SynConst_UIntPtr + | SynConst.UserNum (v, s) -> findNumberAsContentItself (!-(sprintf "%s%s" v s)) SynConst_UserNum + | _ -> failwithf "Cannot generating Const number for %A" c + + expr ctx and genConstBytes (bytes: byte []) (r: Range) = fun (ctx: Context) -> diff --git a/src/Fantomas/SourceTransformer.fs b/src/Fantomas/SourceTransformer.fs index 7c19514c85..da05bd5de5 100644 --- a/src/Fantomas/SourceTransformer.fs +++ b/src/Fantomas/SourceTransformer.fs @@ -225,12 +225,36 @@ let synMemberDefnToFsAstType = | SynMemberDefn.NestedType _ -> SynMemberDefn_NestedType | SynMemberDefn.AutoProperty _ -> SynMemberDefn_AutoProperty -let synExprToFsAstType = +let synConstToFsAstType = + function + | SynConst.Bool _ -> SynConst_Bool + | SynConst.Unit _ -> SynConst_Unit + | SynConst.SByte _ -> SynConst_SByte + | SynConst.Byte _ -> SynConst_Byte + | SynConst.Int16 _ -> SynConst_Int16 + | SynConst.UInt16 _ -> SynConst_UInt16 + | SynConst.Int32 _ -> SynConst_Int32 + | SynConst.UInt32 _ -> SynConst_UInt32 + | SynConst.Int64 _ -> SynConst_Int64 + | SynConst.UInt64 _ -> SynConst_UInt64 + | SynConst.IntPtr _ -> SynConst_IntPtr + | SynConst.UIntPtr _ -> SynConst_UIntPtr + | SynConst.Single _ -> SynConst_Single + | SynConst.Double _ -> SynConst_Double + | SynConst.Char _ -> SynConst_Char + | SynConst.Decimal _ -> SynConst_Decimal + | SynConst.UserNum _ -> SynConst_UserNum + | SynConst.String _ -> SynConst_String + | SynConst.Bytes _ -> SynConst_Bytes + | SynConst.UInt16s _ -> SynConst_UInt16s + | SynConst.Measure _ -> SynConst_Measure + +let rec synExprToFsAstType = function | SynExpr.YieldOrReturn _ -> SynExpr_YieldOrReturn | SynExpr.IfThenElse _ -> SynExpr_IfThenElse | SynExpr.LetOrUseBang _ -> SynExpr_LetOrUseBang - | SynExpr.Const _ -> SynExpr_Const + | SynExpr.Const (c, _) -> synConstToFsAstType c | SynExpr.Lambda _ -> SynExpr_Lambda | SynExpr.Ident _ -> SynExpr_Ident | SynExpr.App _ -> SynExpr_App @@ -245,19 +269,26 @@ let synExprToFsAstType = | SynExpr.New _ -> SynExpr_New | SynExpr.Quote _ -> SynExpr_Quote | SynExpr.DotIndexedSet _ -> SynExpr_DotIndexedSet - | SynExpr.LetOrUse _ -> SynExpr_LetOrUse + | SynExpr.LetOrUse (_, _, bs, e, _) -> + match bs with + | [] -> synExprToFsAstType e + | (SynBinding.Binding (kind = kind)) :: _ -> + match kind with + | SynBindingKind.StandaloneExpression -> StandaloneExpression_ + | SynBindingKind.NormalBinding -> NormalBinding_ + | SynBindingKind.DoBinding -> DoBinding_ | SynExpr.TryWith _ -> SynExpr_TryWith | SynExpr.YieldOrReturnFrom _ -> SynExpr_YieldOrReturnFrom | SynExpr.While _ -> SynExpr_While | SynExpr.TryFinally _ -> SynExpr_TryFinally | SynExpr.Do _ -> SynExpr_Do | SynExpr.AddressOf _ -> SynExpr_AddressOf - | SynExpr.Typed _ -> SynExpr_Typed + | SynExpr.Typed (e, _, _) -> synExprToFsAstType e | SynExpr.ArrayOrList _ -> SynExpr_ArrayOrList | SynExpr.ObjExpr _ -> SynExpr_ObjExpr | SynExpr.For _ -> SynExpr_For | SynExpr.ForEach _ -> SynExpr_ForEach - | SynExpr.CompExpr _ -> SynExpr_CompExpr + | SynExpr.CompExpr (_, _, e, _) -> synExprToFsAstType e | SynExpr.MatchLambda _ -> SynExpr_MatchLambda | SynExpr.Assert _ -> SynExpr_Assert | SynExpr.TypeApp _ -> SynExpr_TypeApp @@ -289,7 +320,7 @@ let synExprToFsAstType = | SynExpr.DiscardAfterMissingQualificationAfterDot _ -> SynExpr_DiscardAfterMissingQualificationAfterDot | SynExpr.Fixed _ -> SynExpr_Fixed | SynExpr.InterpolatedString _ -> SynExpr_InterpolatedString - | SynExpr.Sequential _ -> SynExpr_Sequential + | SynExpr.Sequential (_, _, e, _, _) -> synExprToFsAstType e let synModuleSigDeclToFsAstType = function diff --git a/src/Fantomas/Trivia.fs b/src/Fantomas/Trivia.fs index d5aabe5628..c907eb4ff1 100644 --- a/src/Fantomas/Trivia.fs +++ b/src/Fantomas/Trivia.fs @@ -153,13 +153,26 @@ let private findNodeAfterLineAndColumn (nodes: TriviaNodeAssigner list) line col || (range.StartLine = line && range.StartColumn > column)) -let private findConstNodeOnLineAndColumn (nodes: TriviaNodeAssigner list) (constantRange: Range) = +let private findConstNumberNodeOnLineAndColumn (nodes: TriviaNodeAssigner list) (constantRange: Range) = nodes |> List.tryFind (fun tn -> match tn.Type with - | MainNode (SynExpr_Const) - | MainNode (SynPat_Const) -> + | MainNode (SynConst_Byte) + | MainNode (SynConst_SByte) + | MainNode (SynConst_Int16) + | MainNode (SynConst_Int32) + | MainNode (SynConst_Int64) + | MainNode (SynConst_UInt16) + | MainNode (SynConst_UInt16s) + | MainNode (SynConst_UInt32) + | MainNode (SynConst_UInt64) + | MainNode (SynConst_Double) + | MainNode (SynConst_Single) + | MainNode (SynConst_Decimal) + | MainNode (SynConst_IntPtr) + | MainNode (SynConst_UIntPtr) + | MainNode (SynConst_UserNum) -> constantRange.StartLine = tn.Range.StartLine && constantRange.StartColumn = tn.Range.StartColumn | MainNode (EnumCase_) -> @@ -439,7 +452,7 @@ let private addTriviaToTriviaNode | { Item = Number _ as number Range = range } -> - findConstNodeOnLineAndColumn triviaNodes range + findConstNumberNodeOnLineAndColumn triviaNodes range |> updateTriviaNode (fun tn -> tn.ContentItself <- Some number) triviaNodes | { Item = CharContent _ as chNode diff --git a/src/Fantomas/TriviaTypes.fs b/src/Fantomas/TriviaTypes.fs index 54667aeb9e..7a2991700f 100644 --- a/src/Fantomas/TriviaTypes.fs +++ b/src/Fantomas/TriviaTypes.fs @@ -113,8 +113,8 @@ type FsAstType = | SynModuleDecl_NamespaceFragment | SynExpr_Paren | SynExpr_Quote - | SynExpr_Const - | SynExpr_Typed + // | SynExpr_Const use SynConst instead + // | SynExpr_Typed use either the nested SynExpr or SynType | SynExpr_Tuple | SynExpr_StructTuple | SynExpr_Record @@ -126,7 +126,7 @@ type FsAstType = | SynExpr_ForEach | SynExpr_ArrayOrListOfSeqExpr | SynExpr_ArrayOrList - | SynExpr_CompExpr + // | SynExpr_CompExpr use first nested SynExpr | SynExpr_Lambda | SynExpr_MatchLambda | SynExpr_Match @@ -134,11 +134,11 @@ type FsAstType = | SynExpr_Assert | SynExpr_App | SynExpr_TypeApp - | SynExpr_LetOrUse + // | SynExpr_LetOrUse use first nested SynExpr | SynExpr_TryWith | SynExpr_TryFinally | SynExpr_Lazy - | SynExpr_Sequential + // | SynExpr_Sequential use first nested SynExpr | SynExpr_SequentialOrImplicitYield | SynExpr_IfThenElse | SynExpr_Ident @@ -191,8 +191,8 @@ type FsAstType = | ArgOptions_ | InterfaceImpl_ | TypeDefn_ - | TypeDefnSig_ - | SynTypeDefnSigRepr_ObjectModel + // | TypeDefnSig_ use first nested type + // | SynTypeDefnSigRepr_ObjectModel use first nested node | SynTypeDefnSigRepr_Exception | SynMemberDefn_Open | SynMemberDefn_OpenType @@ -219,7 +219,7 @@ type FsAstType = | TyparDecl_ | Typar_ | ValSpfn_ - | SynPat_Const + // | SynPat_Const, use SynConst instead | SynPat_Wild | SynPat_Named | SynPat_Typed @@ -262,8 +262,8 @@ type FsAstType = | Pats_ | NamePatPairs_ | ComponentInfo_ - | SynTypeDefnRepr_ObjectModel - | SynTypeDefnRepr_Simple + // | SynTypeDefnRepr_ObjectModel use first nested node + // | SynTypeDefnRepr_Simple use first nested node | SynTypeDefnRepr_Exception | SynTypeDefnKind_TyconUnspecified | SynTypeDefnKind_TyconClass From 53ae46541396bcd34563ecfbb94da7020fc984a9 Mon Sep 17 00:00:00 2001 From: nojaf Date: Sat, 13 Mar 2021 09:54:17 +0100 Subject: [PATCH 8/8] Add more explicit yield in lists. --- src/Fantomas/AstTransformer.fs | 133 ++++++++++++++------------------- 1 file changed, 56 insertions(+), 77 deletions(-) diff --git a/src/Fantomas/AstTransformer.fs b/src/Fantomas/AstTransformer.fs index 145f932735..a9e3575f11 100644 --- a/src/Fantomas/AstTransformer.fs +++ b/src/Fantomas/AstTransformer.fs @@ -117,16 +117,15 @@ module private Ast = visit expr (fun nodes -> - [ mkNode SynExpr_Paren range - yield! nodes ] + mkNode SynExpr_Paren range :: nodes |> finalContinuation) | SynExpr.Quote (operator, _, quotedSynExpr, _, range) -> let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = [ visit operator; visit quotedSynExpr ] let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = - [ mkNode SynExpr_Quote range - yield! (List.collect id nodes) ] + mkNode SynExpr_Quote range + :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation @@ -141,8 +140,8 @@ module private Ast = exprs |> List.map visit let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = - [ mkNode SynExpr_Tuple range - yield! (List.collect id nodes) ] + mkNode SynExpr_Tuple range + :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation @@ -151,8 +150,8 @@ module private Ast = exprs |> List.map visit let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = - [ mkNode SynExpr_ArrayOrList range - yield! (List.collect id nodes) ] + mkNode SynExpr_ArrayOrList range + :: (List.collect id nodes) |> finalContinuation Continuation.sequence continuations finalContinuation @@ -173,12 +172,12 @@ module private Ast = yield! visitSynType typeName ] |> finalContinuation) | SynExpr.ObjExpr (objType, argOptions, bindings, extraImpls, _, range) -> - mkNode SynExpr_ObjExpr range - :: [ yield! visitSynType objType - if argOptions.IsSome then - yield! visitArgsOption argOptions.Value - yield! extraImpls |> List.collect visitSynInterfaceImpl - yield! bindings |> List.collect visitSynBinding ] + [ yield mkNode SynExpr_ObjExpr range + yield! visitSynType objType + if argOptions.IsSome then + yield! visitArgsOption argOptions.Value + yield! extraImpls |> List.collect visitSynInterfaceImpl + yield! bindings |> List.collect visitSynBinding ] |> finalContinuation | SynExpr.While (_, whileExpr, doExpr, range) -> let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = @@ -207,7 +206,7 @@ module private Ast = [ visit enumExpr; visit bodyExpr ] let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = - [ mkNode SynExpr_ForEach range + [ yield mkNode SynExpr_ForEach range yield! visitSynPat pat yield! (List.collect id nodes) ] |> finalContinuation @@ -224,7 +223,7 @@ module private Ast = visit body (fun nodes -> - [ mkNode SynExpr_Lambda range + [ yield mkNode SynExpr_Lambda range yield! visitSynSimplePats args yield! nodes ] |> finalContinuation) @@ -236,7 +235,7 @@ module private Ast = visit expr (fun nodes -> - [ mkNode SynExpr_Match range + [ yield mkNode SynExpr_Match range yield! nodes yield! (List.collect visitSynMatchClause clauses) ] |> finalContinuation) @@ -266,7 +265,7 @@ module private Ast = visit expr (fun nodes -> - [ mkNode SynExpr_TypeApp range + [ yield mkNode SynExpr_TypeApp range yield! nodes yield! (List.collect visitSynType typeNames) ] |> finalContinuation) @@ -274,13 +273,14 @@ module private Ast = visit body (fun nodes -> - (List.collect visitSynBinding bindings) @ nodes + [ yield! (List.collect visitSynBinding bindings) + yield! nodes ] |> finalContinuation) | SynExpr.TryWith (tryExpr, _, withCases, _, range, _, _) -> visit tryExpr (fun nodes -> - [ mkNode SynExpr_TryWith range + [ yield mkNode SynExpr_TryWith range yield! nodes yield! withCases |> List.collect visitSynMatchClause ] |> finalContinuation) @@ -322,8 +322,8 @@ module private Ast = Continuation.sequence continuations finalContinuation | SynExpr.IfThenElse (ifExpr, thenExpr, elseExpr, _, _, _, range) -> let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = - [ visit ifExpr - visit thenExpr + [ yield visit ifExpr + yield visit thenExpr yield! (Option.toList elseExpr |> List.map visit) ] let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = @@ -350,7 +350,7 @@ module private Ast = visit expr (fun nodes -> - [ mkNode SynExpr_DotGet range + [ yield mkNode SynExpr_DotGet range yield! nodes // Idents are collected as children here to deal with unit test ``Fluent api with comments should remain on same lines`` yield! (visitLongIdentWithDots longDotId) ] @@ -379,7 +379,7 @@ module private Ast = visit objectExpr (fun nodes -> - [ mkNode SynExpr_DotIndexedGet range + [ yield mkNode SynExpr_DotIndexedGet range yield! nodes yield! indexExprs |> List.collect visitSynIndexerArg ] |> finalContinuation) @@ -388,7 +388,7 @@ module private Ast = [ visit objectExpr; visit valueExpr ] let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = - [ mkNode SynExpr_DotIndexedSet range + [ yield mkNode SynExpr_DotIndexedSet range yield! (List.collect id nodes) yield! indexExprs |> List.collect visitSynIndexerArg ] |> finalContinuation @@ -418,7 +418,7 @@ module private Ast = visit expr (fun nodes -> - [ mkNode SynExpr_TypeTest range + [ yield mkNode SynExpr_TypeTest range yield! nodes yield! visitSynType typeName ] |> finalContinuation) @@ -426,7 +426,7 @@ module private Ast = visit expr (fun nodes -> - [ mkNode SynExpr_Upcast range + [ yield mkNode SynExpr_Upcast range yield! nodes yield! visitSynType typeName ] |> finalContinuation) @@ -434,7 +434,7 @@ module private Ast = visit expr (fun nodes -> - [ mkNode SynExpr_Downcast range + [ yield mkNode SynExpr_Downcast range yield! nodes yield! visitSynType typeName ] |> finalContinuation) @@ -464,7 +464,7 @@ module private Ast = visit expr (fun nodes -> - [ mkNode SynExpr_TraitCall range + [ yield mkNode SynExpr_TraitCall range yield! typars |> List.collect visitSynTypar yield! visitSynMemberSig sign yield! nodes ] @@ -497,12 +497,12 @@ module private Ast = |> finalContinuation) | SynExpr.LetOrUseBang (_, _, _, pat, rhsExpr, andBangs, body, range) -> let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = - [ visit rhsExpr - visit body + [ yield visit rhsExpr + yield visit body yield! (List.map (fun (_, _, _, _, body, _) -> visit body) andBangs) ] let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = - [ mkNode SynExpr_LetOrUseBang range + [ yield mkNode SynExpr_LetOrUseBang range yield! visitSynPat pat yield! (List.collect id nodes) yield! @@ -515,7 +515,7 @@ module private Ast = visit expr (fun nodes -> - [ mkNode SynExpr_MatchBang range + [ yield mkNode SynExpr_MatchBang range yield! nodes yield! clauses |> List.collect visitSynMatchClause ] |> finalContinuation) @@ -636,14 +636,14 @@ module private Ast = and visitSynInterfaceImpl (ii: SynInterfaceImpl) : TriviaNodeAssigner list = match ii with | InterfaceImpl (typ, bindings, range) -> - [ mkNode InterfaceImpl_ range + [ yield mkNode InterfaceImpl_ range yield! visitSynType typ yield! (bindings |> List.collect visitSynBinding) ] and visitSynTypeDefn (td: SynTypeDefn) = match td with | TypeDefn (sci, stdr, members, range) -> - [ mkNode TypeDefn_ range + [ yield mkNode TypeDefn_ range yield! visitSynComponentInfo sci yield! visitSynTypeDefnRepr stdr yield! (members |> List.collect visitSynMemberDefn) ] @@ -678,11 +678,11 @@ module private Ast = mkNode SynMemberDefn_Member range :: (visitSynBinding memberDefn) | SynMemberDefn.ImplicitCtor (_, attrs, ctorArgs, _, _xmlDoc, range) -> - [ mkNode SynMemberDefn_ImplicitCtor range + [ yield mkNode SynMemberDefn_ImplicitCtor range yield! (visitSynAttributeLists range attrs) yield! visitSynSimplePats ctorArgs ] | SynMemberDefn.ImplicitInherit (inheritType, inheritArgs, _, range) -> - [ mkNode SynMemberDefn_ImplicitInherit range + [ yield mkNode SynMemberDefn_ImplicitInherit range yield! visitSynType inheritType yield! visitSynExpr inheritArgs ] | SynMemberDefn.LetBindings (bindings, _, _, range) -> @@ -692,7 +692,7 @@ module private Ast = mkNode SynMemberDefn_AbstractSlot range :: (visitSynValSig valSig) | SynMemberDefn.Interface (typ, members, range) -> - [ mkNode SynMemberDefn_Interface range + [ yield mkNode SynMemberDefn_Interface range yield! visitSynType typ if members.IsSome then yield! members.Value |> List.collect visitSynMemberDefn ] @@ -706,7 +706,7 @@ module private Ast = mkNode SynMemberDefn_NestedType range :: (visitSynTypeDefn typeDefn) | SynMemberDefn.AutoProperty (attrs, _, _, typeOpt, _, _, _, _, synExpr, _, range) -> - [ mkNode SynMemberDefn_AutoProperty range + [ yield mkNode SynMemberDefn_AutoProperty range yield! (visitSynAttributeLists range attrs) if typeOpt.IsSome then yield! visitSynType typeOpt.Value @@ -726,7 +726,7 @@ module private Ast = visit simplePat (fun nodes -> - [ mkNode SynSimplePat_Typed range + [ yield mkNode SynSimplePat_Typed range yield! nodes yield! visitSynType typ ] |> continuation) @@ -734,7 +734,7 @@ module private Ast = visit simplePat (fun nodes -> - [ mkNode SynSimplePat_Attrib range + [ yield mkNode SynSimplePat_Attrib range yield! nodes yield! (visitSynAttributeLists range attrs) ] |> continuation) @@ -752,7 +752,7 @@ module private Ast = visit pats (fun nodes -> - [ mkNode SynSimplePat_Typed range + [ yield mkNode SynSimplePat_Typed range yield! nodes yield! visitSynType typ ] |> continuation) @@ -768,7 +768,7 @@ module private Ast = | SynBindingKind.NormalBinding -> NormalBinding_ | SynBindingKind.DoBinding -> DoBinding_ - [ mkNode t binding.RangeOfBindingAndRhs + [ yield mkNode t binding.RangeOfBindingAndRhs yield! visitSynAttributeLists range attrs yield! visitSynValData valData yield! visitSynPat headPat @@ -785,7 +785,7 @@ module private Ast = and visitSynValSig (svs: SynValSig) : TriviaNodeAssigner list = match svs with | ValSpfn (attrs, _, explicitValDecls, synType, arity, _, _, _, _, expr, range) -> - [ mkNode ValSpfn_ range + [ yield mkNode ValSpfn_ range yield! (visitSynAttributeLists range attrs) yield! visitSynValTyparDecls explicitValDecls yield! visitSynType synType @@ -815,7 +815,7 @@ module private Ast = and visitSynBindingReturnInfo (returnInfo: SynBindingReturnInfo) : TriviaNodeAssigner list = match returnInfo with | SynBindingReturnInfo (typeName, range, attrs) -> - [ mkNode SynBindingReturnInfo_ range + [ yield mkNode SynBindingReturnInfo_ range yield! visitSynType typeName yield! (visitSynAttributeLists range attrs) ] @@ -849,7 +849,7 @@ module private Ast = visit synPat (fun nodes -> - [ mkNode SynPat_Attrib range + [ yield mkNode SynPat_Attrib range yield! nodes yield! (visitSynAttributeLists range attrs) ] |> finalContinuation) @@ -873,7 +873,7 @@ module private Ast = Continuation.sequence continuations finalContinuation | SynPat.LongIdent (_, _, svtd, ctorArgs, _, range) -> - [ mkNode SynPat_LongIdent range + [ yield mkNode SynPat_LongIdent range if svtd.IsSome then yield! visitSynValTyparDecls svtd.Value yield! visitSynConstructorArgs ctorArgs ] @@ -955,7 +955,7 @@ module private Ast = and visitSynComponentInfo (sci: SynComponentInfo) : TriviaNodeAssigner list = match sci with | ComponentInfo (attribs, typeParams, _, _, _, _, _, range) -> - [ mkNode ComponentInfo_ range + [ yield mkNode ComponentInfo_ range yield! (visitSynAttributeLists range attribs) yield! (typeParams |> List.collect (visitSynTyparDecl)) ] @@ -1009,14 +1009,14 @@ module private Ast = and visitSynExceptionDefn (exceptionDef: SynExceptionDefn) : TriviaNodeAssigner list = match exceptionDef with | SynExceptionDefn (sedr, members, range) -> - [ mkNode SynExceptionDefn_ range + [ yield mkNode SynExceptionDefn_ range yield! visitSynExceptionDefnRepr sedr yield! (members |> List.collect visitSynMemberDefn) ] and visitSynExceptionDefnRepr (sedr: SynExceptionDefnRepr) : TriviaNodeAssigner list = match sedr with | SynExceptionDefnRepr (attrs, unionCase, _, _, _, range) -> - [ mkNode SynExceptionDefnRepr_ range + [ yield mkNode SynExceptionDefnRepr_ range yield! (visitSynAttributeLists range attrs) yield! visitSynUnionCase unionCase ] @@ -1044,7 +1044,7 @@ module private Ast = and visitSynUnionCase (uc: SynUnionCase) : TriviaNodeAssigner list = match uc with | UnionCase (attrs, _, uct, _, _, range) -> - [ mkNode UnionCase_ range + [ yield mkNode UnionCase_ range yield! visitSynUnionCaseType uct yield! (visitSynAttributeLists range attrs) ] @@ -1068,7 +1068,7 @@ module private Ast = Option.map (fun (i: Ident) -> i.idRange) ident |> Option.defaultValue range - [ mkNode Field_ range + [ yield mkNode Field_ range yield! (visitSynAttributeLists parentRange attrs) yield! visitSynType typ ] @@ -1082,7 +1082,7 @@ module private Ast = | SynType.App (typeName, _, typeArgs, _, _, _, range) -> let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = [ yield! (List.map visit typeArgs) - visit typeName ] + yield visit typeName ] let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = mkNode SynType_App range @@ -1093,7 +1093,7 @@ module private Ast = | SynType.LongIdentApp (typeName, _, _, typeArgs, _, _, range) -> let continuations : ((TriviaNodeAssigner list -> TriviaNodeAssigner list) -> TriviaNodeAssigner list) list = [ yield! (List.map visit typeArgs) - visit typeName ] + yield visit typeName ] let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = mkNode SynType_LongIdentApp range @@ -1245,27 +1245,6 @@ module private Ast = visitSynAttributeLists parentRange attrs - and visitSynAccess (a: SynAccess) = - match a with - | SynAccess.Private -> SynAccess_Private - | SynAccess.Internal -> SynAccess_Internal - | SynAccess.Public -> SynAccess_Public - - and visitSynBindingKind (kind: SynBindingKind) = - match kind with - | SynBindingKind.DoBinding -> "Do Binding" - | SynBindingKind.StandaloneExpression -> "Standalone Expression" - | SynBindingKind.NormalBinding -> "Normal Binding" - - and visitMemberKind (mk: MemberKind) = - match mk with - | MemberKind.ClassConstructor -> "ClassConstructor" - | MemberKind.Constructor -> "Constructor" - | MemberKind.Member -> "Member" - | MemberKind.PropertyGet -> "PropertyGet" - | MemberKind.PropertySet -> "PropertySet" - | MemberKind.PropertyGetSet -> "PropertyGetSet" - and visitParsedHashDirective (hash: ParsedHashDirective) : TriviaNodeAssigner = match hash with | ParsedHashDirective (_, _, range) -> mkNode ParsedHashDirective_ range @@ -1307,7 +1286,7 @@ module private Ast = List.map visit decls let finalContinuation (nodes: TriviaNodeAssigner list list) : TriviaNodeAssigner list = - [ mkNode SynModuleSigDecl_NestedModule range + [ yield mkNode SynModuleSigDecl_NestedModule range yield! visitSynComponentInfo sci yield! (List.collect id nodes) ] |> finalContinuation @@ -1346,7 +1325,7 @@ module private Ast = and visitSynExceptionSig (exceptionDef: SynExceptionSig) : TriviaNodeAssigner list = match exceptionDef with | SynExceptionSig (sedr, members, range) -> - [ mkNode SynExceptionSig_ range + [ yield mkNode SynExceptionSig_ range yield! visitSynExceptionDefnRepr sedr yield! (members |> List.collect visitSynMemberSig) ]