| // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| // ignore_for_file: avoid_dynamic_calls |
| |
| import 'package:analyzer/dart/ast/ast.dart'; |
| import 'package:analyzer/dart/ast/token.dart'; |
| import 'package:analyzer/dart/ast/visitor.dart'; |
| import 'package:analyzer/source/line_info.dart'; |
| // ignore: implementation_imports |
| import 'package:analyzer/src/clients/dart_style/rewrite_cascade.dart'; |
| |
| import 'argument_list_visitor.dart'; |
| import 'ast_extensions.dart'; |
| import 'call_chain_visitor.dart'; |
| import 'chunk.dart'; |
| import 'chunk_builder.dart'; |
| import 'comment_type.dart'; |
| import 'constants.dart'; |
| import 'dart_formatter.dart'; |
| import 'rule/argument.dart'; |
| import 'rule/combinator.dart'; |
| import 'rule/rule.dart'; |
| import 'rule/type_argument.dart'; |
| import 'source_code.dart'; |
| import 'source_comment.dart'; |
| import 'style_fix.dart'; |
| |
| /// Visits every token of the AST and passes all of the relevant bits to a |
| /// [ChunkBuilder]. |
| class SourceVisitor extends ThrowingAstVisitor { |
| /// The builder for the block that is currently being visited. |
| ChunkBuilder builder; |
| |
| final DartFormatter _formatter; |
| |
| /// Cached line info for calculating blank lines. |
| final LineInfo _lineInfo; |
| |
| /// The source being formatted. |
| final SourceCode _source; |
| |
| /// The most recently written token. |
| /// |
| /// This is used to determine how many lines are between a pair of tokens in |
| /// the original source in places where a user can control whether or not a |
| /// blank line or newline is left in the output. |
| late Token _lastToken; |
| |
| /// `true` if the visitor has written past the beginning of the selection in |
| /// the original source text. |
| bool _passedSelectionStart = false; |
| |
| /// `true` if the visitor has written past the end of the selection in the |
| /// original source text. |
| bool _passedSelectionEnd = false; |
| |
| /// The character offset of the end of the selection, if there is a selection. |
| /// |
| /// This is calculated and cached by [_findSelectionEnd]. |
| int? _selectionEnd; |
| |
| /// How many levels deep inside a constant context the visitor currently is. |
| int _constNesting = 0; |
| |
| /// Whether we are currently fixing a typedef declaration. |
| /// |
| /// Set to `true` while traversing the parameters of a typedef being converted |
| /// to the new syntax. The new syntax does not allow `int foo()` as a |
| /// parameter declaration, so it needs to be converted to `int Function() foo` |
| /// as part of the fix. |
| bool _insideNewTypedefFix = false; |
| |
| /// A stack that tracks forcing nested collections to split. |
| /// |
| /// Each entry corresponds to a collection currently being visited and the |
| /// value is whether or not it should be forced to split. Every time a |
| /// collection is entered, it sets all of the existing elements to `true` |
| /// then it pushes `false` for itself. |
| /// |
| /// When done visiting the elements, it removes its value. If it was set to |
| /// `true`, we know we visited a nested collection so we force this one to |
| /// split. |
| final List<bool> _collectionSplits = []; |
| |
| /// The mapping for blocks that are managed by the argument list that contains |
| /// them. |
| /// |
| /// When a block expression, such as a collection literal or a multiline |
| /// string, appears inside an [ArgumentSublist], the argument list provides a |
| /// rule for the body to split to ensure that all blocks split in unison. It |
| /// also tracks the chunk before the argument that determines whether or not |
| /// the block body is indented like an expression or a statement. |
| /// |
| /// Before a block argument is visited, [ArgumentSublist] binds itself to the |
| /// beginning token of each block it controls. When we later visit that |
| /// literal, we use the token to find that association. |
| /// |
| /// This mapping is also used for spread collection literals that appear |
| /// inside control flow elements to ensure that when a "then" collection |
| /// splits, the corresponding "else" one does too. |
| final Map<Token, Rule> _blockRules = {}; |
| final Map<Token, Chunk> _blockPreviousChunks = {}; |
| |
| /// Comments and new lines attached to tokens added here are suppressed |
| /// from the output. |
| final Set<Token> _suppressPrecedingCommentsAndNewLines = {}; |
| |
| /// Initialize a newly created visitor to write source code representing |
| /// the visited nodes to the given [writer]. |
| SourceVisitor(this._formatter, this._lineInfo, this._source) |
| : builder = ChunkBuilder(_formatter, _source); |
| |
| /// Runs the visitor on [node], formatting its contents. |
| /// |
| /// Returns a [SourceCode] containing the resulting formatted source and |
| /// updated selection, if any. |
| /// |
| /// This is the only method that should be called externally. Everything else |
| /// is effectively private. |
| SourceCode run(AstNode node) { |
| visit(node); |
| |
| // Output trailing comments. |
| writePrecedingCommentsAndNewlines(node.endToken.next!); |
| |
| assert(_constNesting == 0, 'Should have exited all const contexts.'); |
| |
| // Finish writing and return the complete result. |
| return builder.end(); |
| } |
| |
| @override |
| void visitAdjacentStrings(AdjacentStrings node) { |
| // We generally want to indent adjacent strings because it can be confusing |
| // otherwise when they appear in a list of expressions, like: |
| // |
| // [ |
| // "one", |
| // "two" |
| // "three", |
| // "four" |
| // ] |
| // |
| // Especially when these stings are longer, it can be hard to tell that |
| // "three" is a continuation of the previous argument. |
| // |
| // However, the indentation is distracting in argument lists that don't |
| // suffer from this ambiguity: |
| // |
| // test( |
| // "A very long test description..." |
| // "this indentation looks bad.", () { ... }); |
| // |
| // To balance these, we omit the indentation when an adjacent string |
| // expression is the only string in an argument list. |
| var shouldNest = true; |
| |
| var parent = node.parent; |
| if (parent is ArgumentList) { |
| shouldNest = false; |
| |
| for (var argument in parent.arguments) { |
| if (argument == node) continue; |
| if (argument is StringLiteral) { |
| shouldNest = true; |
| break; |
| } |
| } |
| } else if (parent is Assertion) { |
| // Treat asserts like argument lists. |
| shouldNest = false; |
| if (parent.condition != node && parent.condition is StringLiteral) { |
| shouldNest = true; |
| } |
| |
| if (parent.message != node && parent.message is StringLiteral) { |
| shouldNest = true; |
| } |
| } else if (parent is VariableDeclaration || |
| parent is AssignmentExpression && |
| parent.rightHandSide == node && |
| parent.parent is ExpressionStatement) { |
| // Don't add extra indentation in a variable initializer or assignment: |
| // |
| // var variable = |
| // "no extra" |
| // "indent"; |
| shouldNest = false; |
| } else if (parent is NamedExpression || parent is ExpressionFunctionBody) { |
| shouldNest = false; |
| } |
| |
| builder.startSpan(); |
| builder.startRule(); |
| if (shouldNest) builder.nestExpression(); |
| visitNodes(node.strings, between: splitOrNewline); |
| if (shouldNest) builder.unnest(); |
| builder.endRule(); |
| builder.endSpan(); |
| } |
| |
| @override |
| void visitAnnotation(Annotation node) { |
| token(node.atSign); |
| visit(node.name); |
| |
| builder.nestExpression(); |
| visit(node.typeArguments); |
| token(node.period); |
| visit(node.constructorName); |
| |
| if (node.arguments != null) { |
| // Metadata annotations are always const contexts. |
| _constNesting++; |
| visitArgumentList(node.arguments!, nestExpression: false); |
| _constNesting--; |
| } |
| |
| builder.unnest(); |
| } |
| |
| /// Visits an argument list. |
| /// |
| /// This is a bit complex to handle the rules for formatting positional and |
| /// named arguments. The goals, in rough order of descending priority are: |
| /// |
| /// 1. Keep everything on the first line. |
| /// 2. Keep the named arguments together on the next line. |
| /// 3. Keep everything together on the second line. |
| /// 4. Split between one or more positional arguments, trying to keep as many |
| /// on earlier lines as possible. |
| /// 5. Split the named arguments each onto their own line. |
| @override |
| void visitArgumentList(ArgumentList node, {bool nestExpression = true}) { |
| // Corner case: handle empty argument lists. |
| if (node.arguments.isEmpty) { |
| token(node.leftParenthesis); |
| |
| // If there is a comment inside the parens, do allow splitting before it. |
| if (node.rightParenthesis.precedingComments != null) soloZeroSplit(); |
| |
| token(node.rightParenthesis); |
| return; |
| } |
| |
| // If the argument list has a trailing comma, format it like a collection |
| // literal where each argument goes on its own line, they are indented +2, |
| // and the ")" ends up on its own line. |
| if (node.arguments.hasCommaAfter) { |
| _visitCollectionLiteral( |
| node.leftParenthesis, node.arguments, node.rightParenthesis); |
| return; |
| } |
| |
| if (nestExpression) builder.nestExpression(); |
| ArgumentListVisitor(this, node).visit(); |
| if (nestExpression) builder.unnest(); |
| } |
| |
| @override |
| void visitAsExpression(AsExpression node) { |
| builder.startSpan(); |
| builder.nestExpression(); |
| visit(node.expression); |
| soloSplit(); |
| token(node.asOperator); |
| space(); |
| visit(node.type); |
| builder.unnest(); |
| builder.endSpan(); |
| } |
| |
| @override |
| void visitAssertInitializer(AssertInitializer node) { |
| token(node.assertKeyword); |
| |
| var arguments = <Expression>[node.condition]; |
| if (node.message != null) arguments.add(node.message!); |
| |
| // If the argument list has a trailing comma, format it like a collection |
| // literal where each argument goes on its own line, they are indented +2, |
| // and the ")" ends up on its own line. |
| if (arguments.hasCommaAfter) { |
| _visitCollectionLiteral( |
| node.leftParenthesis, arguments, node.rightParenthesis); |
| return; |
| } |
| |
| builder.nestExpression(); |
| var visitor = ArgumentListVisitor.forArguments( |
| this, node.leftParenthesis, node.rightParenthesis, arguments); |
| visitor.visit(); |
| builder.unnest(); |
| } |
| |
| @override |
| void visitAssertStatement(AssertStatement node) { |
| _simpleStatement(node, () { |
| token(node.assertKeyword); |
| |
| var arguments = [node.condition]; |
| if (node.message != null) arguments.add(node.message!); |
| |
| // If the argument list has a trailing comma, format it like a collection |
| // literal where each argument goes on its own line, they are indented +2, |
| // and the ")" ends up on its own line. |
| if (arguments.hasCommaAfter) { |
| _visitCollectionLiteral( |
| node.leftParenthesis, arguments, node.rightParenthesis); |
| return; |
| } |
| |
| var visitor = ArgumentListVisitor.forArguments( |
| this, node.leftParenthesis, node.rightParenthesis, arguments); |
| visitor.visit(); |
| }); |
| } |
| |
| @override |
| void visitAssignedVariablePattern(AssignedVariablePattern node) { |
| token(node.name); |
| } |
| |
| @override |
| void visitAssignmentExpression(AssignmentExpression node) { |
| builder.nestExpression(); |
| |
| visit(node.leftHandSide); |
| _visitAssignment(node.operator, node.rightHandSide); |
| |
| builder.unnest(); |
| } |
| |
| @override |
| void visitAwaitExpression(AwaitExpression node) { |
| token(node.awaitKeyword); |
| space(); |
| visit(node.expression); |
| } |
| |
| @override |
| void visitBinaryExpression(BinaryExpression node) { |
| // If a binary operator sequence appears immediately after a `=>`, don't |
| // add an extra level of nesting. Instead, let the subsequent operands line |
| // up with the first, as in: |
| // |
| // method() => |
| // argument && |
| // argument && |
| // argument; |
| var nest = node.parent is! ExpressionFunctionBody; |
| |
| _visitBinary<BinaryExpression>( |
| node, |
| precedence: node.operator.type.precedence, |
| nest: nest, |
| (expression) => BinaryNode(expression.leftOperand, expression.operator, |
| expression.rightOperand)); |
| } |
| |
| @override |
| void visitBlock(Block node) { |
| // Treat empty blocks specially. In most cases, they are not allowed to |
| // split. However, an empty block as the then statement of an if with an |
| // else is always split. |
| if (!node.statements.canSplit(node.rightBracket)) { |
| token(node.leftBracket); |
| if (_splitEmptyBlock(node)) newline(); |
| token(node.rightBracket); |
| return; |
| } |
| |
| _visitBody(node.leftBracket, node.statements, node.rightBracket); |
| } |
| |
| @override |
| void visitBlockFunctionBody(BlockFunctionBody node) { |
| // Space after the parameter list. |
| space(); |
| |
| // The "async" or "sync" keyword. |
| token(node.keyword); |
| |
| // The "*" in "async*" or "sync*". |
| token(node.star); |
| if (node.keyword != null) space(); |
| |
| visit(node.block); |
| } |
| |
| @override |
| void visitBooleanLiteral(BooleanLiteral node) { |
| token(node.literal); |
| } |
| |
| @override |
| void visitBreakStatement(BreakStatement node) { |
| _simpleStatement(node, () { |
| token(node.breakKeyword); |
| visit(node.label, before: space); |
| }); |
| } |
| |
| @override |
| void visitCascadeExpression(CascadeExpression node) { |
| // Optimized path if we know the cascade will split. |
| if (node.cascadeSections.length > 1) { |
| _visitSplitCascade(node); |
| return; |
| } |
| |
| // Whether a split in the cascade target expression forces the cascade to |
| // move to the next line. It looks weird to move the cascade down if the |
| // target expression is a collection, so we don't: |
| // |
| // var list = [ |
| // stuff |
| // ] |
| // ..add(more); |
| var target = node.target; |
| var splitIfTargetSplits = true; |
| if (node.cascadeSections.length > 1) { |
| // Always split if there are multiple cascade sections. |
| } else if (target.isCollectionLiteral) { |
| splitIfTargetSplits = false; |
| } else if (target is InvocationExpression) { |
| // If the target is a call with a trailing comma in the argument list, |
| // treat it like a collection literal. |
| splitIfTargetSplits = !target.argumentList.arguments.hasCommaAfter; |
| } else if (target is InstanceCreationExpression) { |
| // If the target is a call with a trailing comma in the argument list, |
| // treat it like a collection literal. |
| splitIfTargetSplits = !target.argumentList.arguments.hasCommaAfter; |
| } |
| |
| if (splitIfTargetSplits) { |
| builder.startLazyRule(node.allowInline ? Rule() : Rule.hard()); |
| } |
| |
| visit(node.target); |
| |
| builder.nestExpression(indent: Indent.cascade, now: true); |
| builder.startBlockArgumentNesting(); |
| |
| // If the cascade section shouldn't cause the cascade to split, end the |
| // rule early so it isn't affected by it. |
| if (!splitIfTargetSplits) { |
| builder.startRule(node.allowInline ? Rule() : Rule.hard()); |
| } |
| |
| zeroSplit(); |
| |
| if (!splitIfTargetSplits) builder.endRule(); |
| |
| visitNodes(node.cascadeSections, between: zeroSplit); |
| |
| if (splitIfTargetSplits) builder.endRule(); |
| |
| builder.endBlockArgumentNesting(); |
| builder.unnest(); |
| } |
| |
| /// Format the cascade using a nested block instead of a single inline |
| /// expression. |
| /// |
| /// If the cascade has multiple sections, we know each section will be on its |
| /// own line and we know there will be at least one trailing section following |
| /// a preceding one. That let's us treat all of the earlier sections as a |
| /// separate block like we do with collections and functions, instead of a |
| /// monolithic expression. Using a block in turn makes big cascades much |
| /// faster to format (like 10x) since the block formatting is memoized and |
| /// each cascade section in it is formatted independently. |
| /// |
| /// The tricky part is that block formatting assumes the entire line will be |
| /// part of the block. This is not true of the last section in a cascade, |
| /// which may have other trailing code, like the `;` here: |
| /// |
| /// var x = someLeadingExpression |
| /// ..firstCascade() |
| /// ..secondCascade() |
| /// ..thirdCascade() |
| /// ..fourthCascade(); |
| /// |
| /// To handle that, we don't put the last section in the block and instead |
| /// format it with the surrounding expression. So, from the formatter's |
| /// view, the above casade is formatted like: |
| /// |
| /// var x = someLeadingExpression |
| /// [ begin block ] |
| /// ..firstCascade() |
| /// ..secondCascade() |
| /// ..thirdCascade() |
| /// [ end block ] |
| /// ..fourthCascade(); |
| /// |
| /// This somewhere between clever and hacky, but it works and allows cascades |
| /// of essentially unbounded length to be formatted quickly. |
| void _visitSplitCascade(CascadeExpression node) { |
| // Rule to split the block. |
| builder.startLazyRule(Rule.hard()); |
| visit(node.target); |
| |
| builder.nestExpression(indent: Indent.cascade, now: true); |
| builder.startBlockArgumentNesting(); |
| |
| // If there are comments before the first section, keep them outside of the |
| // block. That way code like: |
| // |
| // receiver // comment |
| // ..cascade(); |
| // |
| // Keeps the comment on the first line. |
| var firstCommentToken = node.cascadeSections.first.beginToken; |
| writePrecedingCommentsAndNewlines(firstCommentToken); |
| _suppressPrecedingCommentsAndNewLines.add(firstCommentToken); |
| |
| // Process the inner cascade sections as a separate block. This way the |
| // entire cascade expression isn't line split as a single monolithic unit, |
| // which is very slow. |
| builder = builder.startBlock(indent: false); |
| |
| for (var i = 0; i < node.cascadeSections.length - 1; i++) { |
| newline(); |
| visit(node.cascadeSections[i]); |
| } |
| |
| // Put comments before the last section inside the block. |
| var lastCommentToken = node.cascadeSections.last.beginToken; |
| writePrecedingCommentsAndNewlines(lastCommentToken); |
| _suppressPrecedingCommentsAndNewLines.add(lastCommentToken); |
| |
| builder = builder.endBlock(); |
| |
| // The last section is outside of the block. |
| visit(node.cascadeSections.last); |
| |
| builder.endRule(); |
| builder.endBlockArgumentNesting(); |
| builder.unnest(); |
| } |
| |
| @override |
| void visitCastPattern(CastPattern node) { |
| builder.startSpan(); |
| builder.nestExpression(); |
| visit(node.pattern); |
| soloSplit(); |
| token(node.asToken); |
| space(); |
| visit(node.type); |
| builder.unnest(); |
| builder.endSpan(); |
| } |
| |
| @override |
| void visitCatchClause(CatchClause node) { |
| token(node.onKeyword, after: space); |
| visit(node.exceptionType); |
| |
| if (node.catchKeyword != null) { |
| if (node.exceptionType != null) { |
| space(); |
| } |
| token(node.catchKeyword); |
| space(); |
| token(node.leftParenthesis); |
| visit(node.exceptionParameter); |
| token(node.comma, after: space); |
| visit(node.stackTraceParameter); |
| token(node.rightParenthesis); |
| space(); |
| } else { |
| space(); |
| } |
| visit(node.body); |
| } |
| |
| @override |
| visitCatchClauseParameter(CatchClauseParameter node) { |
| token(node.name); |
| } |
| |
| @override |
| void visitClassDeclaration(ClassDeclaration node) { |
| visitMetadata(node.metadata); |
| |
| builder.nestExpression(); |
| modifier(node.abstractKeyword); |
| modifier(node.baseKeyword); |
| modifier(node.interfaceKeyword); |
| modifier(node.finalKeyword); |
| modifier(node.sealedKeyword); |
| modifier(node.mixinKeyword); |
| token(node.classKeyword); |
| space(); |
| token(node.name); |
| visit(node.typeParameters); |
| visit(node.extendsClause); |
| _visitClauses(node.withClause, node.implementsClause); |
| visit(node.nativeClause, before: space); |
| space(); |
| |
| builder.unnest(); |
| _visitBody(node.leftBracket, node.members, node.rightBracket); |
| } |
| |
| @override |
| void visitClassTypeAlias(ClassTypeAlias node) { |
| visitMetadata(node.metadata); |
| |
| _simpleStatement(node, () { |
| modifier(node.abstractKeyword); |
| modifier(node.baseKeyword); |
| modifier(node.interfaceKeyword); |
| modifier(node.finalKeyword); |
| modifier(node.sealedKeyword); |
| modifier(node.mixinKeyword); |
| token(node.typedefKeyword); |
| space(); |
| token(node.name); |
| visit(node.typeParameters); |
| space(); |
| token(node.equals); |
| space(); |
| |
| visit(node.superclass); |
| _visitClauses(node.withClause, node.implementsClause); |
| }); |
| } |
| |
| @override |
| void visitComment(Comment node) {} |
| |
| @override |
| void visitCommentReference(CommentReference node) {} |
| |
| @override |
| void visitCompilationUnit(CompilationUnit node) { |
| visit(node.scriptTag); |
| |
| // Put a blank line between the library tag and the other directives. |
| Iterable<Directive> directives = node.directives; |
| if (directives.isNotEmpty && directives.first is LibraryDirective) { |
| visit(directives.first); |
| twoNewlines(); |
| |
| directives = directives.skip(1); |
| } |
| |
| visitNodes(directives, between: oneOrTwoNewlines); |
| |
| var needsDouble = true; |
| for (var declaration in node.declarations) { |
| var hasBody = declaration is ClassDeclaration || |
| declaration is EnumDeclaration || |
| declaration is ExtensionDeclaration; |
| |
| // Add a blank line before types with bodies. |
| if (hasBody) needsDouble = true; |
| |
| if (needsDouble) { |
| twoNewlines(); |
| } else { |
| // Variables and arrow-bodied members can be more tightly packed if |
| // the user wants to group things together. |
| oneOrTwoNewlines(); |
| } |
| |
| visit(declaration); |
| |
| needsDouble = false; |
| if (hasBody) { |
| // Add a blank line after types declarations with bodies. |
| needsDouble = true; |
| } else if (declaration is FunctionDeclaration) { |
| // Add a blank line after non-empty block functions. |
| var body = declaration.functionExpression.body; |
| if (body is BlockFunctionBody) { |
| needsDouble = body.block.statements.isNotEmpty; |
| } |
| } |
| } |
| } |
| |
| @override |
| void visitConditionalExpression(ConditionalExpression node) { |
| // TODO(rnystrom): Consider revisiting whether users prefer this after 2.13. |
| /* |
| // Flatten else-if style chained conditionals. |
| var shouldNest = node.parent is! ConditionalExpression || |
| (node.parent as ConditionalExpression).elseExpression != node; |
| if (shouldNest) builder.nestExpression(); |
| */ |
| builder.nestExpression(); |
| |
| // Start lazily so we don't force the operator to split if a line comment |
| // appears before the first operand. If we split after one clause in a |
| // conditional, always split after both. |
| builder.startLazyRule(); |
| visit(node.condition); |
| |
| // Push any block arguments all the way past the leading "?" and ":". |
| builder.nestExpression(indent: Indent.block, now: true); |
| builder.startBlockArgumentNesting(); |
| builder.unnest(); |
| |
| builder.startSpan(); |
| |
| split(); |
| token(node.question); |
| space(); |
| builder.nestExpression(); |
| visit(node.thenExpression); |
| builder.unnest(); |
| |
| split(); |
| token(node.colon); |
| space(); |
| visit(node.elseExpression); |
| |
| // If conditional expressions are directly nested, force them all to split. |
| // This line here forces the child, which implicitly forces the surrounding |
| // parent rules to split too. |
| if (node.parent is ConditionalExpression) builder.forceRules(); |
| |
| builder.endRule(); |
| builder.endSpan(); |
| builder.endBlockArgumentNesting(); |
| |
| // TODO(rnystrom): Consider revisiting whether users prefer this after 2.13. |
| /* |
| if (shouldNest) builder.unnest(); |
| */ |
| builder.unnest(); |
| } |
| |
| @override |
| void visitConfiguration(Configuration node) { |
| token(node.ifKeyword); |
| space(); |
| token(node.leftParenthesis); |
| visit(node.name); |
| |
| if (node.equalToken != null) { |
| builder.nestExpression(); |
| space(); |
| token(node.equalToken); |
| soloSplit(); |
| visit(node.value); |
| builder.unnest(); |
| } |
| |
| token(node.rightParenthesis); |
| space(); |
| visit(node.uri); |
| } |
| |
| @override |
| void visitConstantPattern(ConstantPattern node) { |
| token(node.constKeyword, after: space); |
| visit(node.expression); |
| } |
| |
| @override |
| void visitConstructorDeclaration(ConstructorDeclaration node) { |
| visitMetadata(node.metadata); |
| |
| modifier(node.externalKeyword); |
| modifier(node.constKeyword); |
| modifier(node.factoryKeyword); |
| visit(node.returnType); |
| token(node.period); |
| token(node.name); |
| |
| // Make the rule for the ":" span both the preceding parameter list and |
| // the entire initialization list. This ensures that we split before the |
| // ":" if the parameters and initialization list don't all fit on one line. |
| if (node.initializers.isNotEmpty) builder.startRule(); |
| |
| // If the redirecting constructor happens to wrap, we want to make sure |
| // the parameter list gets more deeply indented. |
| if (node.redirectedConstructor != null) builder.nestExpression(); |
| |
| _visitFunctionBody(null, node.parameters, node.body, () { |
| // Check for redirects or initializer lists. |
| if (node.redirectedConstructor != null) { |
| _visitConstructorRedirects(node); |
| builder.unnest(); |
| } else if (node.initializers.isNotEmpty) { |
| _visitConstructorInitializers(node); |
| |
| // End the rule for ":" after all of the initializers. |
| builder.endRule(); |
| } |
| }); |
| } |
| |
| void _visitConstructorRedirects(ConstructorDeclaration node) { |
| token(node.separator /* = */, before: space); |
| soloSplit(); |
| visitCommaSeparatedNodes(node.initializers); |
| visit(node.redirectedConstructor); |
| } |
| |
| void _visitConstructorInitializers(ConstructorDeclaration node) { |
| var hasTrailingComma = node.parameters.parameters.hasCommaAfter; |
| |
| if (hasTrailingComma) { |
| // Since the ")", "])", or "})" on the preceding line doesn't take up |
| // much space, it looks weird to move the ":" onto it's own line. Instead, |
| // keep it and the first initializer on the current line but add enough |
| // space before it to line it up with any subsequent initializers. |
| // |
| // Foo( |
| // parameter, |
| // ) : field = value, |
| // super(); |
| space(); |
| if (node.initializers.length > 1) { |
| var padding = ' '; |
| if (node.parameters.parameters.last.isNamed || |
| node.parameters.parameters.last.isOptionalPositional) { |
| padding = ' '; |
| } |
| _writeText(padding, node.separator!); |
| } |
| |
| // ":". |
| token(node.separator); |
| space(); |
| |
| builder.indent(6); |
| } else { |
| // Shift the itself ":" forward. |
| builder.indent(Indent.constructorInitializer); |
| |
| // If the parameters or initializers split, put the ":" on its own line. |
| split(); |
| |
| // ":". |
| token(node.separator); |
| space(); |
| |
| // Try to line up the initializers with the first one that follows the ":": |
| // |
| // Foo(notTrailing) |
| // : initializer = value, |
| // super(); // +2 from previous line. |
| // |
| // Foo( |
| // trailing, |
| // ) : initializer = value, |
| // super(); // +4 from previous line. |
| // |
| // This doesn't work if there is a trailing comma in an optional parameter, |
| // but we don't want to do a weird +5 alignment: |
| // |
| // Foo({ |
| // trailing, |
| // }) : initializer = value, |
| // super(); // Doesn't quite line up. :( |
| builder.indent(2); |
| } |
| |
| for (var i = 0; i < node.initializers.length; i++) { |
| if (i > 0) { |
| // Preceding comma. |
| token(node.initializers[i].beginToken.previous); |
| newline(); |
| } |
| |
| node.initializers[i].accept(this); |
| } |
| |
| builder.unindent(); |
| if (!hasTrailingComma) builder.unindent(); |
| } |
| |
| @override |
| void visitConstructorFieldInitializer(ConstructorFieldInitializer node) { |
| builder.nestExpression(); |
| |
| token(node.thisKeyword); |
| token(node.period); |
| visit(node.fieldName); |
| |
| _visitAssignment(node.equals, node.expression); |
| |
| builder.unnest(); |
| } |
| |
| @override |
| void visitConstructorName(ConstructorName node) { |
| visit(node.type); |
| token(node.period); |
| visit(node.name); |
| } |
| |
| @override |
| void visitContinueStatement(ContinueStatement node) { |
| _simpleStatement(node, () { |
| token(node.continueKeyword); |
| visit(node.label, before: space); |
| }); |
| } |
| |
| @override |
| void visitDeclaredIdentifier(DeclaredIdentifier node) { |
| modifier(node.keyword); |
| visit(node.type, after: space); |
| token(node.name); |
| } |
| |
| @override |
| void visitDeclaredVariablePattern(DeclaredVariablePattern node) { |
| _visitVariablePattern(node.keyword, node.type, node.name); |
| } |
| |
| @override |
| void visitDefaultFormalParameter(DefaultFormalParameter node) { |
| visit(node.parameter); |
| if (node.separator != null) { |
| builder.startSpan(); |
| builder.nestExpression(); |
| |
| if (_formatter.fixes.contains(StyleFix.namedDefaultSeparator)) { |
| // Change the separator to "=". |
| space(); |
| writePrecedingCommentsAndNewlines(node.separator!); |
| _writeText('=', node.separator!); |
| } else { |
| // The '=' separator is preceded by a space, ":" is not. |
| if (node.separator!.type == TokenType.EQ) space(); |
| token(node.separator); |
| } |
| |
| soloSplit(_assignmentCost(node.defaultValue!)); |
| visit(node.defaultValue); |
| |
| builder.unnest(); |
| builder.endSpan(); |
| } |
| } |
| |
| @override |
| void visitDoStatement(DoStatement node) { |
| builder.nestExpression(); |
| token(node.doKeyword); |
| space(); |
| builder.unnest(now: false); |
| visit(node.body); |
| |
| builder.nestExpression(); |
| space(); |
| token(node.whileKeyword); |
| space(); |
| token(node.leftParenthesis); |
| soloZeroSplit(); |
| visit(node.condition); |
| token(node.rightParenthesis); |
| token(node.semicolon); |
| builder.unnest(); |
| } |
| |
| @override |
| void visitDottedName(DottedName node) { |
| for (var component in node.components) { |
| // Write the preceding ".". |
| if (component != node.components.first) { |
| token(component.beginToken.previous); |
| } |
| |
| visit(component); |
| } |
| } |
| |
| @override |
| void visitDoubleLiteral(DoubleLiteral node) { |
| token(node.literal); |
| } |
| |
| @override |
| void visitEmptyFunctionBody(EmptyFunctionBody node) { |
| token(node.semicolon); |
| } |
| |
| @override |
| void visitEmptyStatement(EmptyStatement node) { |
| token(node.semicolon); |
| } |
| |
| @override |
| void visitEnumConstantDeclaration(EnumConstantDeclaration node) { |
| visitMetadata(node.metadata); |
| token(node.name); |
| |
| var arguments = node.arguments; |
| if (arguments != null) { |
| builder.nestExpression(); |
| visit(arguments.typeArguments); |
| |
| var constructor = arguments.constructorSelector; |
| if (constructor != null) { |
| token(constructor.period); |
| visit(constructor.name); |
| } |
| |
| visitArgumentList(arguments.argumentList, nestExpression: false); |
| builder.unnest(); |
| } |
| } |
| |
| @override |
| void visitEnumDeclaration(EnumDeclaration node) { |
| visitMetadata(node.metadata); |
| |
| builder.nestExpression(); |
| token(node.enumKeyword); |
| space(); |
| token(node.name); |
| visit(node.typeParameters); |
| _visitClauses(node.withClause, node.implementsClause); |
| space(); |
| |
| builder.unnest(); |
| |
| _beginBody(node.leftBracket, space: true); |
| |
| visitCommaSeparatedNodes(node.constants, between: splitOrTwoNewlines); |
| |
| // If there is a trailing comma, always force the constants to split. |
| var trailingComma = node.constants.last.commaAfter; |
| if (trailingComma != null) { |
| builder.forceRules(); |
| } |
| |
| // The ";" after the constants, which may occur after a trailing comma. |
| Token afterConstants = node.constants.last.endToken.next!; |
| Token? semicolon; |
| if (afterConstants.type == TokenType.SEMICOLON) { |
| semicolon = node.constants.last.endToken.next!; |
| } else if (trailingComma != null && |
| trailingComma.next!.type == TokenType.SEMICOLON) { |
| semicolon = afterConstants.next!; |
| } |
| |
| if (semicolon != null) { |
| // If there is both a trailing comma and a semicolon, move the semicolon |
| // to the next line. This doesn't look great but it's less bad than being |
| // next to the comma. |
| // TODO(rnystrom): If the formatter starts making non-whitespace changes |
| // like adding/removing trailing commas, then it should fix this too. |
| if (trailingComma != null) newline(); |
| |
| token(semicolon); |
| |
| // Put a blank line between the constants and members. |
| if (node.members.isNotEmpty) twoNewlines(); |
| } |
| |
| _visitBodyContents(node.members); |
| |
| _endBody(node.rightBracket, |
| forceSplit: semicolon != null || |
| trailingComma != null || |
| node.members.isNotEmpty || |
| // If there is a line comment after an enum constant, it won't |
| // automatically force the enum body to split since the rule for |
| // the constants is the hard rule used by the entire block and its |
| // hardening state doesn't actually change. Instead, look |
| // explicitly for a line comment here. |
| _containsLineComments(node.constants)); |
| } |
| |
| @override |
| void visitExportDirective(ExportDirective node) { |
| _visitDirectiveMetadata(node); |
| _simpleStatement(node, () { |
| token(node.exportKeyword); |
| space(); |
| visit(node.uri); |
| |
| _visitConfigurations(node.configurations); |
| _visitCombinators(node.combinators); |
| }); |
| } |
| |
| @override |
| void visitExpressionFunctionBody(ExpressionFunctionBody node) { |
| // Space after the parameter list. |
| space(); |
| |
| // The "async" or "sync" keyword and "*". |
| token(node.keyword); |
| token(node.star); |
| if (node.keyword != null || node.star != null) space(); |
| |
| // Try to keep the "(...) => " with the start of the body for anonymous |
| // functions. |
| if (node.isFunctionExpressionBody) builder.startSpan(); |
| |
| token(node.functionDefinition); // "=>". |
| |
| // Split after the "=>", using the rule created before the parameters |
| // by _visitBody(). |
| split(); |
| |
| // If the body is a binary operator expression, then we want to force the |
| // split at `=>` if the operators split. See visitBinaryExpression(). |
| if (node.expression is! BinaryExpression) builder.endRule(); |
| |
| if (node.isFunctionExpressionBody) builder.endSpan(); |
| |
| // If this function invocation appears in an argument list with trailing |
| // comma, don't add extra nesting to preserve normal indentation. |
| var isArgWithTrailingComma = false; |
| var parent = node.parent; |
| if (parent is FunctionExpression) { |
| isArgWithTrailingComma = parent.isTrailingCommaArgument; |
| } |
| |
| if (!isArgWithTrailingComma) builder.startBlockArgumentNesting(); |
| builder.startSpan(); |
| visit(node.expression); |
| builder.endSpan(); |
| if (!isArgWithTrailingComma) builder.endBlockArgumentNesting(); |
| |
| if (node.expression is BinaryExpression) builder.endRule(); |
| |
| token(node.semicolon); |
| } |
| |
| /// Parenthesize the target of the given statement's expression (assumed to |
| /// be a CascadeExpression) before removing the cascade. |
| void _fixCascadeByParenthesizingTarget(ExpressionStatement statement) { |
| var cascade = statement.expression as CascadeExpression; |
| assert(cascade.cascadeSections.length == 1); |
| |
| // Write any leading comments and whitespace immediately, as they should |
| // precede the new opening parenthesis, but then prevent them from being |
| // written again after the parenthesis. |
| writePrecedingCommentsAndNewlines(cascade.target.beginToken); |
| _suppressPrecedingCommentsAndNewLines.add(cascade.target.beginToken); |
| |
| // Finally, we can revisit a clone of this ExpressionStatement to actually |
| // remove the cascade. |
| visit( |
| fixCascadeByParenthesizingTarget( |
| expressionStatement: statement, |
| cascadeExpression: cascade, |
| ), |
| ); |
| } |
| |
| void _removeCascade(ExpressionStatement statement) { |
| var cascade = statement.expression as CascadeExpression; |
| var subexpression = cascade.cascadeSections.single; |
| builder.nestExpression(); |
| |
| if (subexpression is AssignmentExpression || |
| subexpression is MethodInvocation || |
| subexpression is PropertyAccess) { |
| // CascadeExpression("leftHandSide", "..", |
| // AssignmentExpression("target", "=", "rightHandSide")) |
| // |
| // transforms to |
| // |
| // AssignmentExpression( |
| // PropertyAccess("leftHandSide", ".", "target"), |
| // "=", |
| // "rightHandSide") |
| // |
| // CascadeExpression("leftHandSide", "..", |
| // MethodInvocation("target", ".", "methodName", ...)) |
| // |
| // transforms to |
| // |
| // MethodInvocation( |
| // PropertyAccess("leftHandSide", ".", "target"), |
| // ".", |
| // "methodName", ...) |
| // |
| // And similarly for PropertyAccess expressions. |
| visit(insertCascadeTargetIntoExpression( |
| expression: subexpression, cascadeTarget: cascade.target)); |
| } else { |
| throw UnsupportedError( |
| '--fix-single-cascade-statements: subexpression of cascade ' |
| '"$cascade" has unsupported type ${subexpression.runtimeType}.'); |
| } |
| |
| token(statement.semicolon); |
| builder.unnest(); |
| } |
| |
| /// Remove any unnecessary single cascade from the given expression statement, |
| /// which is assumed to contain a [CascadeExpression]. |
| /// |
| /// Returns true after applying the fix, which involves visiting the nested |
| /// expression. Callers must visit the nested expression themselves |
| /// if-and-only-if this method returns false. |
| bool _fixSingleCascadeStatement(ExpressionStatement statement) { |
| var cascade = statement.expression as CascadeExpression; |
| if (cascade.cascadeSections.length != 1) return false; |
| |
| var target = cascade.target; |
| if (target is AsExpression || |
| target is AwaitExpression || |
| target is BinaryExpression || |
| target is ConditionalExpression || |
| target is IsExpression || |
| target is PostfixExpression || |
| target is PrefixExpression) { |
| // In these cases, the cascade target needs to be parenthesized before |
| // removing the cascade, otherwise the semantics will change. |
| _fixCascadeByParenthesizingTarget(statement); |
| return true; |
| } else if (target is BooleanLiteral || |
| target is FunctionExpression || |
| target is IndexExpression || |
| target is InstanceCreationExpression || |
| target is IntegerLiteral || |
| target is ListLiteral || |
| target is NullLiteral || |
| target is MethodInvocation || |
| target is ParenthesizedExpression || |
| target is PrefixedIdentifier || |
| target is PropertyAccess || |
| target is SimpleIdentifier || |
| target is StringLiteral || |
| target is ThisExpression) { |
| // OK to simply remove the cascade. |
| _removeCascade(statement); |
| return true; |
| } else { |
| // If we get here, some new syntax was added to the language that the fix |
| // does not yet support. Leave it as is. |
| return false; |
| } |
| } |
| |
| @override |
| void visitExpressionStatement(ExpressionStatement node) { |
| if (_formatter.fixes.contains(StyleFix.singleCascadeStatements) && |
| node.expression is CascadeExpression && |
| _fixSingleCascadeStatement(node)) { |
| return; |
| } |
| |
| _simpleStatement(node, () { |
| visit(node.expression); |
| }); |
| } |
| |
| @override |
| void visitExtendsClause(ExtendsClause node) { |
| soloSplit(); |
| token(node.extendsKeyword); |
| space(); |
| visit(node.superclass); |
| } |
| |
| @override |
| void visitExtensionDeclaration(ExtensionDeclaration node) { |
| visitMetadata(node.metadata); |
| |
| builder.nestExpression(); |
| token(node.extensionKeyword); |
| |
| // Don't put a space after `extension` if the extension is unnamed. That |
| // way, generic unnamed extensions format like `extension<T> on ...`. |
| token(node.name, before: space); |
| |
| visit(node.typeParameters); |
| soloSplit(); |
| token(node.onKeyword); |
| space(); |
| visit(node.extendedType); |
| space(); |
| builder.unnest(); |
| _visitBody(node.leftBracket, node.members, node.rightBracket); |
| } |
| |
| @override |
| void visitExtensionTypeDeclaration(ExtensionTypeDeclaration node) { |
| visitMetadata(node.metadata); |
| |
| builder.nestExpression(); |
| token(node.extensionKeyword); |
| space(); |
| token(node.typeKeyword); |
| token(node.constKeyword, before: space); |
| space(); |
| token(node.name); |
| |
| builder.nestExpression(); |
| visit(node.typeParameters); |
| visit(node.representation); |
| builder.unnest(); |
| |
| builder.startRule(CombinatorRule()); |
| visit(node.implementsClause); |
| builder.endRule(); |
| |
| space(); |
| builder.unnest(); |
| _visitBody(node.leftBracket, node.members, node.rightBracket); |
| } |
| |
| @override |
| void visitFieldDeclaration(FieldDeclaration node) { |
| visitMetadata(node.metadata); |
| |
| _simpleStatement(node, () { |
| modifier(node.externalKeyword); |
| modifier(node.staticKeyword); |
| modifier(node.abstractKeyword); |
| modifier(node.covariantKeyword); |
| visit(node.fields); |
| }); |
| } |
| |
| @override |
| void visitFieldFormalParameter(FieldFormalParameter node) { |
| visitParameterMetadata(node.metadata, () { |
| _beginFormalParameter(node); |
| token(node.keyword, after: space); |
| visit(node.type); |
| _separatorBetweenTypeAndVariable(node.type); |
| token(node.thisKeyword); |
| token(node.period); |
| token(node.name); |
| visit(node.parameters); |
| token(node.question); |
| _endFormalParameter(node); |
| }); |
| } |
| |
| @override |
| void visitFormalParameterList(FormalParameterList node, |
| {bool nestExpression = true}) { |
| // Corner case: empty parameter lists. |
| if (node.parameters.isEmpty) { |
| token(node.leftParenthesis); |
| |
| // If there is a comment, do allow splitting before it. |
| if (node.rightParenthesis.precedingComments != null) soloZeroSplit(); |
| |
| token(node.rightParenthesis); |
| return; |
| } |
| |
| // If the parameter list has a trailing comma, format it like a collection |
| // literal where each parameter goes on its own line, they are indented +2, |
| // and the ")" ends up on its own line. |
| if (node.parameters.hasCommaAfter) { |
| _visitTrailingCommaParameterList(node); |
| return; |
| } |
| |
| var requiredParams = node.parameters |
| .where((param) => param is! DefaultFormalParameter) |
| .toList(); |
| var optionalParams = |
| node.parameters.whereType<DefaultFormalParameter>().toList(); |
| |
| if (nestExpression) builder.nestExpression(); |
| token(node.leftParenthesis); |
| |
| PositionalRule? rule; |
| if (requiredParams.isNotEmpty) { |
| rule = PositionalRule(null, argumentCount: requiredParams.length); |
| |
| builder.startRule(rule); |
| if (node.isFunctionExpressionBody) { |
| // Don't allow splitting before the first argument (i.e. right after |
| // the bare "(" in a lambda. Instead, just stuff a null chunk in there |
| // to avoid confusing the arg rule. |
| rule.beforeArgument(null); |
| } else { |
| // Split before the first argument. |
| rule.beforeArgument(zeroSplit()); |
| } |
| |
| // Make sure record and function type parameter lists are indented. |
| builder.startBlockArgumentNesting(); |
| builder.startSpan(); |
| |
| for (var param in requiredParams) { |
| visit(param); |
| _writeCommaAfter(param); |
| |
| if (param != requiredParams.last) rule.beforeArgument(split()); |
| } |
| |
| builder.endBlockArgumentNesting(); |
| builder.endSpan(); |
| builder.endRule(); |
| } |
| |
| if (optionalParams.isNotEmpty) { |
| var namedRule = NamedRule(null, 0, 0); |
| if (rule != null) rule.addNamedArgsConstraints(namedRule); |
| |
| builder.startRule(namedRule); |
| |
| // Make sure multi-line default values, record types, and inner function |
| // types are indented. |
| builder.startBlockArgumentNesting(); |
| |
| namedRule.beforeArgument(builder.split(space: requiredParams.isNotEmpty)); |
| |
| // "[" or "{" for optional parameters. |
| token(node.leftDelimiter); |
| |
| for (var param in optionalParams) { |
| visit(param); |
| _writeCommaAfter(param); |
| |
| if (param != optionalParams.last) namedRule.beforeArgument(split()); |
| } |
| |
| builder.endBlockArgumentNesting(); |
| builder.endRule(); |
| |
| // "]" or "}" for optional parameters. |
| token(node.rightDelimiter); |
| } |
| |
| token(node.rightParenthesis); |
| if (nestExpression) builder.unnest(); |
| } |
| |
| @override |
| void visitForElement(ForElement node) { |
| // Treat a spread of a collection literal like a block in a for statement |
| // and don't split after the for parts. |
| var isSpreadBody = node.body.isSpreadCollection; |
| |
| builder.nestExpression(); |
| token(node.awaitKeyword, after: space); |
| token(node.forKeyword); |
| space(); |
| token(node.leftParenthesis); |
| |
| // Start the body rule so that if the parts split, the body does too. |
| builder.startRule(); |
| |
| // The rule for the parts. |
| builder.startRule(); |
| visit(node.forLoopParts); |
| token(node.rightParenthesis); |
| builder.endRule(); |
| builder.unnest(); |
| |
| builder.nestExpression(indent: Indent.block, now: true); |
| |
| if (isSpreadBody) { |
| space(); |
| } else { |
| split(); |
| |
| // If the body is a non-spread collection or lambda, indent it. |
| builder.startBlockArgumentNesting(); |
| } |
| |
| visit(node.body); |
| |
| if (!isSpreadBody) builder.endBlockArgumentNesting(); |
| builder.unnest(); |
| |
| // If a control flow element is nested inside another, force the outer one |
| // to split. |
| if (node.body.isControlFlowElement) builder.forceRules(); |
| |
| builder.endRule(); |
| } |
| |
| @override |
| void visitForStatement(ForStatement node) { |
| builder.nestExpression(); |
| token(node.awaitKeyword, after: space); |
| token(node.forKeyword); |
| space(); |
| token(node.leftParenthesis); |
| |
| builder.startRule(); |
| |
| visit(node.forLoopParts); |
| |
| token(node.rightParenthesis); |
| builder.endRule(); |
| builder.unnest(); |
| |
| _visitLoopBody(node.body); |
| } |
| |
| @override |
| void visitForEachPartsWithDeclaration(ForEachPartsWithDeclaration node) { |
| // TODO(rnystrom): The formatting logic here is slightly different from |
| // how parameter metadata is handled and from how variable metadata is |
| // handled. I think what it does works better in the context of a for-in |
| // loop, but consider trying to unify this with one of the above. |
| // |
| // Metadata on class and variable declarations is *always* split: |
| // |
| // @foo |
| // class Bar {} |
| // |
| // Metadata on parameters has some complex logic to handle multiple |
| // parameters with metadata. It also indents the parameters farther than |
| // the metadata when split: |
| // |
| // function( |
| // @foo(long arg list...) |
| // parameter1, |
| // @foo |
| // parameter2) {} |
| // |
| // For for-in variables, we allow it to not split, like parameters, but |
| // don't indent the variable when it does split: |
| // |
| // for ( |
| // @foo |
| // @bar |
| // var blah in stuff) {} |
| // TODO(rnystrom): we used to call builder.startRule() here, but now we call |
| // it from visitForStatement2 prior to the `(`. Is that ok? |
| visitNodes(node.loopVariable.metadata, between: split, after: split); |
| visit(node.loopVariable); |
| // TODO(rnystrom): we used to call builder.endRule() here, but now we call |
| // it from visitForStatement2 after the `)`. Is that ok? |
| |
| _visitForEachPartsFromIn(node); |
| } |
| |
| void _visitForEachPartsFromIn(ForEachParts node) { |
| soloSplit(); |
| token(node.inKeyword); |
| space(); |
| visit(node.iterable); |
| } |
| |
| @override |
| void visitForEachPartsWithIdentifier(ForEachPartsWithIdentifier node) { |
| visit(node.identifier); |
| _visitForEachPartsFromIn(node); |
| } |
| |
| @override |
| void visitForEachPartsWithPattern(ForEachPartsWithPattern node) { |
| builder.startBlockArgumentNesting(); |
| visitNodes(node.metadata, between: split, after: split); |
| token(node.keyword); |
| space(); |
| visit(node.pattern); |
| builder.endBlockArgumentNesting(); |
| _visitForEachPartsFromIn(node); |
| } |
| |
| @override |
| void visitForPartsWithDeclarations(ForPartsWithDeclarations node) { |
| // Nest split variables more so they aren't at the same level |
| // as the rest of the loop clauses. |
| builder.nestExpression(); |
| |
| // Allow the variables to stay unsplit even if the clauses split. |
| builder.startRule(); |
| |
| var declaration = node.variables; |
| visitNodes(declaration.metadata, between: split, after: split); |
| modifier(declaration.keyword); |
| visit(declaration.type, after: space); |
| |
| visitCommaSeparatedNodes(declaration.variables, between: () { |
| split(); |
| }); |
| |
| builder.endRule(); |
| builder.unnest(); |
| |
| _visitForPartsFromLeftSeparator(node); |
| } |
| |
| @override |
| void visitForPartsWithExpression(ForPartsWithExpression node) { |
| visit(node.initialization); |
| _visitForPartsFromLeftSeparator(node); |
| } |
| |
| @override |
| void visitForPartsWithPattern(ForPartsWithPattern node) { |
| builder.startBlockArgumentNesting(); |
| builder.nestExpression(); |
| |
| var declaration = node.variables; |
| visitNodes(declaration.metadata, between: split, after: split); |
| token(declaration.keyword); |
| space(); |
| visit(declaration.pattern); |
| _visitAssignment(declaration.equals, declaration.expression); |
| |
| builder.unnest(); |
| builder.endBlockArgumentNesting(); |
| |
| _visitForPartsFromLeftSeparator(node); |
| } |
| |
| void _visitForPartsFromLeftSeparator(ForParts node) { |
| token(node.leftSeparator); |
| |
| // The condition clause. |
| if (node.condition != null) split(); |
| visit(node.condition); |
| token(node.rightSeparator); |
| |
| // The update clause. |
| if (node.updaters.isNotEmpty) { |
| split(); |
| |
| // Allow the updates to stay unsplit even if the clauses split. |
| builder.startRule(); |
| |
| visitCommaSeparatedNodes(node.updaters, between: split); |
| |
| builder.endRule(); |
| } |
| } |
| |
| @override |
| void visitFunctionDeclaration(FunctionDeclaration node) { |
| _visitFunctionOrMethodDeclaration( |
| metadata: node.metadata, |
| externalKeyword: node.externalKeyword, |
| propertyKeyword: node.propertyKeyword, |
| modifierKeyword: null, |
| operatorKeyword: null, |
| name: node.name, |
| returnType: node.returnType, |
| typeParameters: node.functionExpression.typeParameters, |
| formalParameters: node.functionExpression.parameters, |
| body: node.functionExpression.body, |
| ); |
| } |
| |
| @override |
| void visitFunctionDeclarationStatement(FunctionDeclarationStatement node) { |
| visit(node.functionDeclaration); |
| } |
| |
| @override |
| void visitFunctionExpression(FunctionExpression node) { |
| // Inside a function body is no longer in the surrounding const context. |
| var oldConstNesting = _constNesting; |
| _constNesting = 0; |
| |
| _visitFunctionBody(node.typeParameters, node.parameters, node.body); |
| |
| _constNesting = oldConstNesting; |
| } |
| |
| @override |
| void visitFunctionExpressionInvocation(FunctionExpressionInvocation node) { |
| // Try to keep the entire invocation one line. |
| builder.startSpan(); |
| builder.nestExpression(); |
| |
| visit(node.function); |
| visit(node.typeArguments); |
| visitArgumentList(node.argumentList, nestExpression: false); |
| |
| builder.unnest(); |
| builder.endSpan(); |
| } |
| |
| @override |
| void visitFunctionReference(FunctionReference node) { |
| visit(node.function); |
| visit(node.typeArguments); |
| } |
| |
| @override |
| void visitFunctionTypeAlias(FunctionTypeAlias node) { |
| visitMetadata(node.metadata); |
| |
| if (_formatter.fixes.contains(StyleFix.functionTypedefs)) { |
| _simpleStatement(node, () { |
| // Inlined visitGenericTypeAlias |
| _visitGenericTypeAliasHeader( |
| node.typedefKeyword, |
| node.name, |
| node.typeParameters, |
| null, |
| node.returnType?.beginToken ?? node.name); |
| |
| space(); |
| |
| // Recursively convert function-arguments to Function syntax. |
| _insideNewTypedefFix = true; |
| _visitGenericFunctionType( |
| node.returnType, null, node.name, null, node.parameters); |
| _insideNewTypedefFix = false; |
| }); |
| return; |
| } |
| |
| _simpleStatement(node, () { |
| token(node.typedefKeyword); |
| space(); |
| visit(node.returnType, after: space); |
| token(node.name); |
| visit(node.typeParameters); |
| visit(node.parameters); |
| }); |
| } |
| |
| @override |
| void visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) { |
| visitParameterMetadata(node.metadata, () { |
| if (!_insideNewTypedefFix) { |
| modifier(node.requiredKeyword); |
| modifier(node.covariantKeyword); |
| visit(node.returnType, after: space); |
| // Try to keep the function's parameters with its name. |
| builder.startSpan(); |
| token(node.name); |
| _visitParameterSignature(node.typeParameters, node.parameters); |
| token(node.question); |
| builder.endSpan(); |
| } else { |
| _beginFormalParameter(node); |
| _visitGenericFunctionType(node.returnType, null, node.name, |
| node.typeParameters, node.parameters); |
| token(node.question); |
| split(); |
| token(node.name); |
| _endFormalParameter(node); |
| } |
| }); |
| } |
| |
| @override |
| void visitGenericFunctionType(GenericFunctionType node) { |
| _visitGenericFunctionType(node.returnType, node.functionKeyword, null, |
| node.typeParameters, node.parameters); |
| token(node.question); |
| } |
| |
| @override |
| void visitGenericTypeAlias(GenericTypeAlias node) { |
| visitNodes(node.metadata, between: newline, after: newline); |
| _simpleStatement(node, () { |
| _visitGenericTypeAliasHeader(node.typedefKeyword, node.name, |
| node.typeParameters, node.equals, null); |
| |
| space(); |
| |
| visit(node.type); |
| }); |
| } |
| |
| @override |
| void visitHideCombinator(HideCombinator node) { |
| _visitCombinator(node.keyword, node.hiddenNames); |
| } |
| |
| @override |
| void visitIfElement(IfElement node) { |
| // Treat a chain of if-else elements as a single unit so that we don't |
| // unnecessarily indent each subsequent section of the chain. |
| var ifElements = [ |
| for (CollectionElement? thisNode = node; |
| thisNode is IfElement; |
| thisNode = thisNode.elseElement) |
| thisNode |
| ]; |
| |
| // If the body of the then or else branch is a spread of a collection |
| // literal, then we want to format those collections more like blocks than |
| // like standalone objects. In particular, if both the then and else branch |
| // are spread collection literals, we want to ensure that they both split |
| // if either splits. So this: |
| // |
| // [ |
| // if (condition) ...[ |
| // thenClause |
| // ] else ...[ |
| // elseClause |
| // ] |
| // ] |
| // |
| // And not something like this: |
| // |
| // [ |
| // if (condition) ...[ |
| // thenClause |
| // ] else ...[elseClause] |
| // ] |
| // |
| // To do that, if we see that either clause is a spread collection, we |
| // create a single rule and force both collections to use it. |
| var spreadRule = Rule(); |
| var spreadBrackets = <CollectionElement, Token>{}; |
| for (var element in ifElements) { |
| var spreadBracket = element.thenElement.spreadCollectionBracket; |
| if (spreadBracket != null) { |
| spreadBrackets[element] = spreadBracket; |
| beforeBlock(spreadBracket, spreadRule, null); |
| } |
| } |
| |
| var elseSpreadBracket = |
| ifElements.last.elseElement?.spreadCollectionBracket; |
| if (elseSpreadBracket != null) { |
| spreadBrackets[ifElements.last.elseElement!] = elseSpreadBracket; |
| beforeBlock(elseSpreadBracket, spreadRule, null); |
| } |
| |
| void visitChild(CollectionElement element, CollectionElement child) { |
| builder.nestExpression(indent: 2, now: true); |
| |
| // Treat a spread of a collection literal like a block in an if statement |
| // and don't split after the "else". |
| var isSpread = spreadBrackets.containsKey(element); |
| if (isSpread) { |
| space(); |
| } else { |
| split(); |
| |
| // If the then clause is a non-spread collection or lambda, make sure the |
| // body is indented. |
| builder.startBlockArgumentNesting(); |
| } |
| |
| visit(child); |
| |
| if (!isSpread) builder.endBlockArgumentNesting(); |
| builder.unnest(); |
| } |
| |
| // Wrap the whole thing in a single rule. If a split happens inside the |
| // condition or the then clause, we want the then and else clauses to split. |
| builder.startLazyRule(); |
| |
| var hasInnerControlFlow = false; |
| for (var element in ifElements) { |
| _visitIfCondition(element.ifKeyword, element.leftParenthesis, |
| element.expression, element.caseClause, element.rightParenthesis); |
| |
| visitChild(element, element.thenElement); |
| if (element.thenElement.isControlFlowElement) { |
| hasInnerControlFlow = true; |
| } |
| |
| // Handle this element's "else" keyword and prepare to write the element, |
| // but don't write it. It will either be the next element in [ifElements] |
| // or the final else element handled after the loop. |
| if (element.elseElement != null) { |
| if (spreadBrackets.containsKey(element)) { |
| space(); |
| } else { |
| split(); |
| } |
| |
| token(element.elseKeyword); |
| |
| // If there is another if element in the chain, put a space between |
| // it and this "else". |
| if (element != ifElements.last) space(); |
| } |
| } |
| |
| // Handle the final trailing else if there is one. |
| var lastElse = ifElements.last.elseElement; |
| if (lastElse != null) { |
| visitChild(lastElse, lastElse); |
| |
| if (lastElse.isControlFlowElement) { |
| hasInnerControlFlow = true; |
| } |
| } |
| |
| // If a control flow element is nested inside another, force the outer one |
| // to split. |
| if (hasInnerControlFlow) builder.forceRules(); |
| builder.endRule(); |
| } |
| |
| @override |
| void visitIfStatement(IfStatement node) { |
| _visitIfCondition(node.ifKeyword, node.leftParenthesis, node.expression, |
| node.caseClause, node.rightParenthesis); |
| |
| void visitClause(Statement clause) { |
| if (clause is Block || clause is IfStatement) { |
| space(); |
| visit(clause); |
| } else { |
| // Allow splitting in a statement-bodied if even though it's against |
| // the style guide. Since we can't fix the code itself to follow the |
| // style guide, we should at least format it as well as we can. |
| builder.indent(); |
| builder.startRule(); |
| |
| // If there is an else clause, always split before both the then and |
| // else statements. |
| if (node.elseStatement != null) { |
| builder.writeNewline(); |
| } else { |
| builder.split(nest: false, space: true); |
| } |
| |
| visit(clause); |
| |
| builder.endRule(); |
| builder.unindent(); |
| } |
| } |
| |
| visitClause(node.thenStatement); |
| |
| if (node.elseStatement != null) { |
| if (node.thenStatement is Block) { |
| space(); |
| } else { |
| // Corner case where an else follows a single-statement then clause. |
| // This is against the style guide, but we still need to handle it. If |
| // it happens, put the else on the next line. |
| newline(); |
| } |
| |
| token(node.elseKeyword); |
| visitClause(node.elseStatement!); |
| } |
| } |
| |
| @override |
| void visitImplementsClause(ImplementsClause node) { |
| _visitCombinator(node.implementsKeyword, node.interfaces); |
| } |
| |
| @override |
| void visitImportDirective(ImportDirective node) { |
| _visitDirectiveMetadata(node); |
| _simpleStatement(node, () { |
| token(node.importKeyword); |
| space(); |
| visit(node.uri); |
| |
| _visitConfigurations(node.configurations); |
| |
| if (node.asKeyword != null) { |
| soloSplit(); |
| token(node.deferredKeyword, after: space); |
| token(node.asKeyword); |
| space(); |
| visit(node.prefix); |
| } |
| |
| _visitCombinators(node.combinators); |
| }); |
| } |
| |
| @override |
| void visitIndexExpression(IndexExpression node) { |
| builder.nestExpression(); |
| |
| if (node.isCascaded) { |
| token(node.period); |
| } else { |
| visit(node.target); |
| } |
| |
| finishIndexExpression(node); |
| |
| builder.unnest(); |
| } |
| |
| /// Visit the index part of [node], excluding the target. |
| /// |
| /// Called by [CallChainVisitor] to handle index expressions in the middle of |
| /// call chains. |
| void finishIndexExpression(IndexExpression node) { |
| if (node.target is IndexExpression) { |
| // Edge case: On a chain of [] accesses, allow splitting between them. |
| // Produces nicer output in cases like: |
| // |
| // someJson['property']['property']['property']['property']... |
| soloZeroSplit(); |
| } |
| |
| builder.startSpan(Cost.index); |
| token(node.question); |
| token(node.leftBracket); |
| soloZeroSplit(); |
| visit(node.index); |
| token(node.rightBracket); |
| builder.endSpan(); |
| } |
| |
| @override |
| void visitInstanceCreationExpression(InstanceCreationExpression node) { |
| builder.startSpan(); |
| |
| var includeKeyword = true; |
| |
| if (node.keyword != null) { |
| if (node.keyword!.keyword == Keyword.NEW && |
| _formatter.fixes.contains(StyleFix.optionalNew)) { |
| includeKeyword = false; |
| } else if (node.keyword!.keyword == Keyword.CONST && |
| _formatter.fixes.contains(StyleFix.optionalConst) && |
| _constNesting > 0) { |
| includeKeyword = false; |
| } |
| } |
| |
| if (includeKeyword) { |
| token(node.keyword, after: space); |
| } else { |
| // Don't lose comments before the discarded keyword, if any. |
| writePrecedingCommentsAndNewlines(node.keyword!); |
| } |
| |
| builder.startSpan(Cost.constructorName); |
| |
| // Start the expression nesting for the argument list here, in case this |
| // is a generic constructor with type arguments. If it is, we need the type |
| // arguments to be nested too so they get indented past the arguments. |
| builder.nestExpression(); |
| visit(node.constructorName); |
| |
| _startPossibleConstContext(node.keyword); |
| |
| builder.endSpan(); |
| visitArgumentList(node.argumentList, nestExpression: false); |
| builder.endSpan(); |
| |
| _endPossibleConstContext(node.keyword); |
| |
| builder.unnest(); |
| } |
| |
| @override |
| void visitIntegerLiteral(IntegerLiteral node) { |
| token(node.literal); |
| } |
| |
| @override |
| void visitInterpolationExpression(InterpolationExpression node) { |
| builder.preventSplit(); |
| token(node.leftBracket); |
| builder.startSpan(); |
| visit(node.expression); |
| builder.endSpan(); |
| token(node.rightBracket); |
| builder.endPreventSplit(); |
| } |
| |
| @override |
| void visitInterpolationString(InterpolationString node) { |
| _writeStringLiteral(node.contents); |
| } |
| |
| @override |
| void visitIsExpression(IsExpression node) { |
| builder.startSpan(); |
| builder.nestExpression(); |
| visit(node.expression); |
| soloSplit(); |
| token(node.isOperator); |
| token(node.notOperator); |
| space(); |
| visit(node.type); |
| builder.unnest(); |
| builder.endSpan(); |
| } |
| |
| @override |
| void visitLabel(Label node) { |
| visit(node.label); |
| token(node.colon); |
| } |
| |
| @override |
| void visitLabeledStatement(LabeledStatement node) { |
| _visitLabels(node.labels); |
| visit(node.statement); |
| } |
| |
| @override |
| void visitLibraryDirective(LibraryDirective node) { |
| _visitDirectiveMetadata(node); |
| _simpleStatement(node, () { |
| token(node.libraryKeyword); |
| if (node.name2 != null) { |
| visit(node.name2, before: space); |
| } |
| }); |
| } |
| |
| @override |
| void visitLibraryIdentifier(LibraryIdentifier node) { |
| visit(node.components.first); |
| for (var component in node.components.skip(1)) { |
| token(component.beginToken.previous); // "." |
| visit(component); |
| } |
| } |
| |
| @override |
| void visitListLiteral(ListLiteral node) { |
| // Corner case: Splitting inside a list looks bad if there's only one |
| // element, so make those more costly. |
| var cost = node.elements.length <= 1 ? Cost.singleElementList : Cost.normal; |
| _visitCollectionLiteral(node.leftBracket, node.elements, node.rightBracket, |
| constKeyword: node.constKeyword, |
| typeArguments: node.typeArguments, |
| splitOuterCollection: true, |
| cost: cost); |
| } |
| |
| @override |
| void visitListPattern(ListPattern node) { |
| _visitCollectionLiteral(node.leftBracket, node.elements, node.rightBracket, |
| typeArguments: node.typeArguments); |
| } |
| |
| @override |
| void visitLogicalAndPattern(LogicalAndPattern node) { |
| _visitBinary<LogicalAndPattern>( |
| node, |
| (pattern) => BinaryNode( |
| pattern.leftOperand, pattern.operator, pattern.rightOperand)); |
| } |
| |
| @override |
| void visitLogicalOrPattern(LogicalOrPattern node) { |
| _visitBinary<LogicalOrPattern>( |
| node, |
| (pattern) => BinaryNode( |
| pattern.leftOperand, pattern.operator, pattern.rightOperand)); |
| } |
| |
| @override |
| void visitMapLiteralEntry(MapLiteralEntry node) { |
| builder.nestExpression(); |
| visit(node.key); |
| token(node.separator); |
| soloSplit(); |
| visit(node.value); |
| builder.unnest(); |
| } |
| |
| @override |
| void visitMapPattern(MapPattern node) { |
| _visitCollectionLiteral(node.leftBracket, node.elements, node.rightBracket, |
| typeArguments: node.typeArguments); |
| } |
| |
| @override |
| void visitMapPatternEntry(MapPatternEntry node) { |
| builder.nestExpression(); |
| visit(node.key); |
| token(node.separator); |
| soloSplit(); |
| visit(node.value); |
| builder.unnest(); |
| } |
| |
| @override |
| void visitMethodDeclaration(MethodDeclaration node) { |
| _visitFunctionOrMethodDeclaration( |
| metadata: node.metadata, |
| externalKeyword: node.externalKeyword, |
| propertyKeyword: node.propertyKeyword, |
| modifierKeyword: node.modifierKeyword, |
| operatorKeyword: node.operatorKeyword, |
| name: node.name, |
| returnType: node.returnType, |
| typeParameters: node.typeParameters, |
| formalParameters: node.parameters, |
| body: node.body, |
| ); |
| } |
| |
| @override |
| void visitMethodInvocation(MethodInvocation node) { |
| // If there's no target, this is a "bare" function call like "foo(1, 2)", |
| // or a section in a cascade. |
| // |
| // If it looks like a constructor or static call, we want to keep the |
| // target and method together instead of including the method in the |
| // subsequent method chain. When this happens, it's important that this |
| // code here has the same rules as in [visitInstanceCreationExpression]. |
| // |
| // That ensures that the way some code is formatted is not affected by the |
| // presence or absence of `new`/`const`. In particular, it means that if |
| // they run `dart format --fix`, and then run `dart format` *again*, the |
| // second run will not produce any additional changes. |
| if (node.target == null || node.looksLikeStaticCall) { |
| // Try to keep the entire method invocation one line. |
| builder.nestExpression(); |
| builder.startSpan(); |
| |
| if (node.target != null) { |
| builder.startSpan(Cost.constructorName); |
| visit(node.target); |
| soloZeroSplit(); |
| } |
| |
| // If target is null, this will be `..` for a cascade. |
| token(node.operator); |
| visit(node.methodName); |
| |
| if (node.target != null) builder.endSpan(); |
| |
| // TODO(rnystrom): Currently, there are no constraints between a generic |
| // method's type arguments and arguments. That can lead to some funny |
| // splitting like: |
| // |
| // method<VeryLongType, |
| // AnotherTypeArgument>(argument, |
| // argument, argument, argument); |
| // |
| // The indentation is fine, but splitting in the middle of each argument |
| // list looks kind of strange. If this ends up happening in real world |
| // code, consider putting a constraint between them. |
| builder.nestExpression(); |
| visit(node.typeArguments); |
| visitArgumentList(node.argumentList, nestExpression: false); |
| builder.unnest(); |
| |
| builder.endSpan(); |
| builder.unnest(); |
| return; |
| } |
| |
| CallChainVisitor(this, node).visit(); |
| } |
| |
| @override |
| void visitMixinDeclaration(MixinDeclaration node) { |
| visitMetadata(node.metadata); |
| |
| builder.nestExpression(); |
| modifier(node.baseKeyword); |
| token(node.mixinKeyword); |
| space(); |
| token(node.name); |
| visit(node.typeParameters); |
| |
| // If there is only a single superclass constraint, format it like an |
| // "extends" in a class. |
| var onClause = node.onClause; |
| if (onClause != null && onClause.superclassConstraints.length == 1) { |
| soloSplit(); |
| token(onClause.onKeyword); |
| space(); |
| visit(onClause.superclassConstraints.single); |
| } |
| |
| builder.startRule(CombinatorRule()); |
| |
| // If there are multiple superclass constraints, format them like the |
| // "implements" clause. |
| if (onClause != null && onClause.superclassConstraints.length > 1) { |
| visit(onClause); |
| } |
| |
| visit(node.implementsClause); |
| builder.endRule(); |
| |
| space(); |
| |
| builder.unnest(); |
| _visitBody(node.leftBracket, node.members, node.rightBracket); |
| } |
| |
| @override |
| void visitNamedExpression(NamedExpression node) { |
| visitNamedNode(node.name.label.token, node.name.colon, node.expression); |
| } |
| |
| @override |
| void visitNamedType(NamedType node) { |
| if (node.importPrefix case var importPrefix?) { |
| builder.startSpan(); |
| token(importPrefix.name); |
| soloZeroSplit(); |
| token(importPrefix.period); |
| token(node.name2); |
| builder.endSpan(); |
| } else { |
| token(node.name2); |
| } |
| |
| visit(node.typeArguments); |
| token(node.question); |
| } |
| |
| @override |
| void visitNativeClause(NativeClause node) { |
| token(node.nativeKeyword); |
| visit(node.name, before: space); |
| } |
| |
| @override |
| void visitNativeFunctionBody(NativeFunctionBody node) { |
| _simpleStatement(node, () { |
| builder.nestExpression(now: true); |
| soloSplit(); |
| token(node.nativeKeyword); |
| visit(node.stringLiteral, before: space); |
| builder.unnest(); |
| }); |
| } |
| |
| @override |
| void visitNullAssertPattern(NullAssertPattern node) { |
| visit(node.pattern); |
| token(node.operator); |
| } |
| |
| @override |
| void visitNullCheckPattern(NullCheckPattern node) { |
| visit(node.pattern); |
| token(node.operator); |
| } |
| |
| @override |
| void visitNullLiteral(NullLiteral node) { |
| token(node.literal); |
| } |
| |
| @override |
| void visitObjectPattern(ObjectPattern node) { |
| // Even though object patterns syntactically resemble constructor or |
| // function calls, we format them like collections (or like argument lists |
| // with trailing commas). In other words, like this: |
| // |
| // case Foo( |
| // first: 1, |
| // second: 2, |
| // third: 3 |
| // ): |
| // body; |
| // |
| // Not like: |
| // |
| // case Foo( |
| // first: 1, |
| // second: 2, |
| // third: 3): |
| // body; |
| // |
| // This is less consistent with the corresponding expression form, but is |
| // more consistent with all of the other delimited patterns -- list, map, |
| // and record -- which have collection-like formatting. |
| // TODO(rnystrom): If we move to consistently using collection-like |
| // formatting for all argument lists, then this will all be consistent and |
| // this comment should be removed. |
| visit(node.type); |
| _visitCollectionLiteral( |
| node.leftParenthesis, node.fields, node.rightParenthesis); |
| } |
| |
| @override |
| void visitOnClause(OnClause node) { |
| _visitCombinator(node.onKeyword, node.superclassConstraints); |
| } |
| |
| @override |
| void visitParenthesizedExpression(ParenthesizedExpression node) { |
| builder.nestExpression(); |
| token(node.leftParenthesis); |
| visit(node.expression); |
| builder.unnest(); |
| token(node.rightParenthesis); |
| } |
| |
| @override |
| void visitParenthesizedPattern(ParenthesizedPattern node) { |
| builder.nestExpression(); |
| token(node.leftParenthesis); |
| visit(node.pattern); |
| builder.unnest(); |
| token(node.rightParenthesis); |
| } |
| |
| @override |
| void visitPartDirective(PartDirective node) { |
| _visitDirectiveMetadata(node); |
| _simpleStatement(node, () { |
| token(node.partKeyword); |
| space(); |
| visit(node.uri); |
| }); |
| } |
| |
| @override |
| void visitPartOfDirective(PartOfDirective node) { |
| _visitDirectiveMetadata(node); |
| _simpleStatement(node, () { |
| token(node.partKeyword); |
| space(); |
| token(node.ofKeyword); |
| space(); |
| |
| // Part-of may have either a name or a URI. Only one of these will be |
| // non-null. We visit both since visit() ignores null. |
| visit(node.libraryName); |
| visit(node.uri); |
| }); |
| } |
| |
| @override |
| void visitPatternAssignment(PatternAssignment node) { |
| visit(node.pattern); |
| _visitAssignment(node.equals, node.expression); |
| } |
| |
| @override |
| void visitPatternField(PatternField node) { |
| var fieldName = node.name; |
| if (fieldName != null) { |
| var name = fieldName.name; |
| if (name != null) { |
| visitNamedNode(fieldName.name!, fieldName.colon, node.pattern); |
| } else { |
| // Named field with inferred name, like: |
| // |
| // var (:x) = (x: 1); |
| token(fieldName.colon); |
| visit(node.pattern); |
| } |
| } else { |
| visit(node.pattern); |
| } |
| } |
| |
| @override |
| void visitPatternVariableDeclaration(PatternVariableDeclaration node) { |
| visitMetadata(node.metadata); |
| builder.nestExpression(); |
| token(node.keyword); |
| space(); |
| visit(node.pattern); |
| _visitAssignment(node.equals, node.expression); |
| builder.unnest(); |
| } |
| |
| @override |
| void visitPatternVariableDeclarationStatement( |
| PatternVariableDeclarationStatement node) { |
| visit(node.declaration); |
| token(node.semicolon); |
| } |
| |
| @override |
| void visitPostfixExpression(PostfixExpression node) { |
| visit(node.operand); |
| token(node.operator); |
| } |
| |
| @override |
| void visitPrefixedIdentifier(PrefixedIdentifier node) { |
| CallChainVisitor(this, node).visit(); |
| } |
| |
| @override |
| void visitPrefixExpression(PrefixExpression node) { |
| token(node.operator); |
| |
| // Edge case: put a space after "-" if the operand is "-" or "--" so we |
| // don't merge the operators. |
| var operand = node.operand; |
| if (operand is PrefixExpression && |
| (operand.operator.lexeme == '-' || operand.operator.lexeme == '--')) { |
| space(); |
| } |
| |
| visit(node.operand); |
| } |
| |
| @override |
| void visitPropertyAccess(PropertyAccess node) { |
| if (node.isCascaded) { |
| token(node.operator); |
| visit(node.propertyName); |
| return; |
| } |
| |
| CallChainVisitor(this, node).visit(); |
| } |
| |
| @override |
| void visitRedirectingConstructorInvocation( |
| RedirectingConstructorInvocation node) { |
| builder.startSpan(); |
| |
| token(node.thisKeyword); |
| token(node.period); |
| visit(node.constructorName); |
| visit(node.argumentList); |
| |
| builder.endSpan(); |
| } |
| |
| @override |
| void visitRecordLiteral(RecordLiteral node) { |
| modifier(node.constKeyword); |
| _visitCollectionLiteral( |
| node.leftParenthesis, node.fields, node.rightParenthesis, |
| isRecord: true); |
| } |
| |
| @override |
| void visitRecordPattern(RecordPattern node) { |
| _visitCollectionLiteral( |
| node.leftParenthesis, node.fields, node.rightParenthesis, |
| isRecord: true); |
| } |
| |
| @override |
| void visitRecordTypeAnnotation(RecordTypeAnnotation node) { |
| var namedFields = node.namedFields; |
| |
| // Handle empty record types specially. |
| if (node.positionalFields.isEmpty && namedFields == null) { |
| token(node.leftParenthesis); |
| |
| // If there is a comment inside the parens, do allow splitting before it. |
| if (node.rightParenthesis.precedingComments != null) soloZeroSplit(); |
| |
| token(node.rightParenthesis); |
| token(node.question); |
| return; |
| } |
| |
| token(node.leftParenthesis); |
| builder.startRule(); |
| |
| // If all parameters are named, put the "{" right after "(". |
| if (node.positionalFields.isEmpty) { |
| token(namedFields!.leftBracket); |
| } |
| |
| // Process the parameters as a separate set of chunks. |
| builder = builder.startBlock(); |
| |
| // Write the positional fields. |
| for (var field in node.positionalFields) { |
| builder.split(nest: false, space: field != node.positionalFields.first); |
| visit(field); |
| _writeCommaAfter(field); |
| } |
| |
| // Then the named fields. |
| var firstClosingDelimiter = node.rightParenthesis; |
| if (namedFields != null) { |
| if (node.positionalFields.isNotEmpty) { |
| space(); |
| token(namedFields.leftBracket); |
| } |
| |
| for (var field in namedFields.fields) { |
| builder.split(nest: false, space: field != namedFields.fields.first); |
| visit(field); |
| _writeCommaAfter(field); |
| } |
| |
| firstClosingDelimiter = namedFields.rightBracket; |
| } |
| |
| // Put comments before the closing ")" or "}" inside the block. |
| if (firstClosingDelimiter.precedingComments != null) { |
| newline(); |
| writePrecedingCommentsAndNewlines(firstClosingDelimiter); |
| } |
| |
| // If there is a trailing comma, then force the record type to split. But |
| // don't force if there is only a single positional element because then |
| // the trailing comma is actually mandatory. |
| bool force; |
| if (namedFields == null) { |
| force = node.positionalFields.length > 1 && |
| node.positionalFields.last.hasCommaAfter; |
| } else { |
| force = namedFields.fields.last.hasCommaAfter; |
| } |
| |
| builder = builder.endBlock(forceSplit: force); |
| builder.endRule(); |
| |
| // Now write the delimiter(s) themselves. |
| _writeText(firstClosingDelimiter.lexeme, firstClosingDelimiter); |
| if (namedFields != null) token(node.rightParenthesis); |
| |
| token(node.question); |
| } |
| |
| @override |
| void visitRecordTypeAnnotationNamedField( |
| RecordTypeAnnotationNamedField node) { |
| visitParameterMetadata(node.metadata, () { |
| visit(node.type); |
| token(node.name, before: space); |
| }); |
| } |
| |
| @override |
| void visitRecordTypeAnnotationPositionalField( |
| RecordTypeAnnotationPositionalField node) { |
| visitParameterMetadata(node.metadata, () { |
| visit(node.type); |
| token(node.name, before: space); |
| }); |
| } |
| |
| @override |
| void visitRelationalPattern(RelationalPattern node) { |
| token(node.operator); |
| space(); |
| visit(node.operand); |
| } |
| |
| @override |
| void visitRepresentationConstructorName(RepresentationConstructorName node) { |
| token(node.period); |
| token(node.name); |
| } |
| |
| @override |
| void visitRepresentationDeclaration(RepresentationDeclaration node) { |
| visit(node.constructorName); |
| |
| token(node.leftParenthesis); |
| |
| final rule = PositionalRule(null, argumentCount: 1); |
| |
| builder.startRule(rule); |
| rule.beforeArgument(zeroSplit()); |
| |
| // Make sure record and function type parameter lists are indented. |
| builder.startBlockArgumentNesting(); |
| builder.startSpan(); |
| |
| visitParameterMetadata(node.fieldMetadata, () { |
| builder.startLazyRule(Rule(Cost.parameterType)); |
| builder.nestExpression(); |
| |
| visit(node.fieldType); |
| _separatorBetweenTypeAndVariable(node.fieldType); |
| token(node.fieldName); |
| |
| builder.unnest(); |
| builder.endRule(); |
| }); |
| |
| builder.endBlockArgumentNesting(); |
| builder.endSpan(); |
| builder.endRule(); |
| |
| token(node.rightParenthesis); |
| } |
| |
| @override |
| void visitRethrowExpression(RethrowExpression node) { |
| token(node.rethrowKeyword); |
| } |
| |
| @override |
| void visitRestPatternElement(RestPatternElement node) { |
| token(node.operator); |
| visit(node.pattern); |
| } |
| |
| @override |
| void visitReturnStatement(ReturnStatement node) { |
| _simpleStatement(node, () { |
| token(node.returnKeyword); |
| visit(node.expression, before: space); |
| }); |
| } |
| |
| @override |
| void visitScriptTag(ScriptTag node) { |
| // The lexeme includes the trailing newline. Strip it off since the |
| // formatter ensures it gets a newline after it. Since the script tag must |
| // come at the top of the file, we don't have to worry about preceding |
| // comments or whitespace. |
| _writeText(node.scriptTag.lexeme.trim(), node.scriptTag); |
| twoNewlines(); |
| } |
| |
| @override |
| void visitSetOrMapLiteral(SetOrMapLiteral node) { |
| _visitCollectionLiteral(node.leftBracket, node.elements, node.rightBracket, |
| constKeyword: node.constKeyword, |
| typeArguments: node.typeArguments, |
| splitOuterCollection: true); |
| } |
| |
| @override |
| void visitShowCombinator(ShowCombinator node) { |
| _visitCombinator(node.keyword, node.shownNames); |
| } |
| |
| @override |
| void visitSimpleFormalParameter(SimpleFormalParameter node) { |
| visitParameterMetadata(node.metadata, () { |
| _beginFormalParameter(node); |
| |
| if (_insideNewTypedefFix && node.type == null) { |
| // Parameters can use "var" instead of "dynamic". Since we are inserting |
| // "dynamic" in that case, remove the "var". |
| if (node.keyword != null) { |
| if (node.keyword!.type != Keyword.VAR) { |
| modifier(node.keyword); |
| } else { |
| // Keep any comment attached to "var". |
| writePrecedingCommentsAndNewlines(node.keyword!); |
| } |
| } |
| |
| // In function declarations and the old typedef syntax, you can have a |
| // parameter name without a type. In the new syntax, you can have a type |
| // without a name. Add "dynamic" in that case. |
| |
| // Ensure comments on the identifier comes before the inserted type. |
| token(node.name, before: () { |
| _writeText('dynamic', node.name!); |
| split(); |
| }); |
| } else { |
| modifier(node.keyword); |
| |
| visit(node.type); |
| if (node.name != null) _separatorBetweenTypeAndVariable(node.type); |
| token(node.name); |
| } |
| |
| _endFormalParameter(node); |
| }); |
| } |
| |
| @override |
| void visitSimpleIdentifier(SimpleIdentifier node) { |
| token(node.token); |
| } |
| |
| @override |
| void visitSimpleStringLiteral(SimpleStringLiteral node) { |
| _writeStringLiteral(node.literal); |
| } |
| |
| @override |
| void visitSpreadElement(SpreadElement node) { |
| token(node.spreadOperator); |
| visit(node.expression); |
| } |
| |
| @override |
| void visitStringInterpolation(StringInterpolation node) { |
| for (var element in node.elements) { |
| visit(element); |
| } |
| } |
| |
| @override |
| void visitSuperConstructorInvocation(SuperConstructorInvocation node) { |
| builder.startSpan(); |
| |
| token(node.superKeyword); |
| token(node.period); |
| visit(node.constructorName); |
| visit(node.argumentList); |
| |
| builder.endSpan(); |
| } |
| |
| @override |
| void visitSuperExpression(SuperExpression node) { |
| token(node.superKeyword); |
| } |
| |
| @override |
| void visitSuperFormalParameter(SuperFormalParameter node) { |
| visitParameterMetadata(node.metadata, () { |
| _beginFormalParameter(node); |
| token(node.keyword, after: space); |
| visit(node.type, after: split); |
| token(node.superKeyword); |
| token(node.period); |
| token(node.name); |
| visit(node.parameters); |
| token(node.question); |
| _endFormalParameter(node); |
| }); |
| } |
| |
| @override |
| void visitSwitchExpression(SwitchExpression node) { |
| if (!node.cases.canSplit(node.rightBracket)) { |
| // Don't allow splitting an empty switch expression. |
| _visitSwitchValue(node.switchKeyword, node.leftParenthesis, |
| node.expression, node.rightParenthesis); |
| token(node.leftBracket); |
| token(node.rightBracket); |
| return; |
| } |
| |
| // Start the rule for splitting between the cases before the value. That |
| // way, if the value expression splits, the cases do too. Avoids: |
| // |
| // switch ([ |
| // element, |
| // ]) { inline => caseBody }; |
| builder.startRule(); |
| |
| _visitSwitchValue(node.switchKeyword, node.leftParenthesis, node.expression, |
| node.rightParenthesis); |
| |
| token(node.leftBracket); |
| builder = builder.startBlock(space: node.cases.isNotEmpty); |
| |
| visitCommaSeparatedNodes(node.cases, between: split); |
| |
| var hasTrailingComma = |
| node.cases.isNotEmpty && node.cases.last.commaAfter != null; |
| _endBody(node.rightBracket, forceSplit: hasTrailingComma); |
| } |
| |
| @override |
| void visitSwitchExpressionCase(SwitchExpressionCase node) { |
| // If the pattern is a series of `||` patterns, then flatten them out and |
| // format them like empty cases with fallthrough in a switch statement |
| // instead of like a single indented binary pattern. Prefer: |
| // |
| // e = switch (obj) { |
| // constant1 || |
| // constant2 || |
| // constant3 => |
| // body |
| // }; |
| // |
| // Instead of: |
| // |
| // e = switch (obj) { |
| // constant1 || |
| // constant2 || |
| // constant3 => |
| // body |
| // }; |
| var orBranches = <DartPattern>[]; |
| var orTokens = <Token>[]; |
| |
| void flattenOr(DartPattern e) { |
| if (e is! LogicalOrPattern) { |
| orBranches.add(e); |
| } else { |
| flattenOr(e.leftOperand); |
| orTokens.add(e.operator); |
| flattenOr(e.rightOperand); |
| } |
| } |
| |
| flattenOr(node.guardedPattern.pattern); |
| |
| // Wrap the rule for splitting after "=>" around the pattern so that a |
| // split in the pattern forces the expression to move to the next line too. |
| builder.startLazyRule(); |
| |
| // Write the "||" operands up to the last one. |
| for (var i = 0; i < orBranches.length - 1; i++) { |
| // Note that orBranches will always have one more element than orTokens. |
| visit(orBranches[i]); |
| space(); |
| token(orTokens[i]); |
| split(); |
| } |
| |
| // Wrap the expression's nesting around the final pattern so that a split in |
| // the pattern is indented farther then the body expression. Used +2 indent |
| // because switch expressions are block-like, similar to how we split the |
| // bodies of if and for elements in collections. |
| builder.nestExpression(indent: Indent.block); |
| |
| var whenClause = node.guardedPattern.whenClause; |
| if (whenClause != null) { |
| // Wrap the when clause rule around the pattern so that if the pattern |
| // splits then we split before "when" too. |
| builder.startLazyRule(); |
| builder.nestExpression(indent: Indent.block); |
| } |
| |
| // Write the last pattern in the "||" chain. If the case pattern isn't an |
| // "||" pattern at all, this writes the one pattern. |
| visit(orBranches.last); |
| |
| if (whenClause != null) { |
| split(); |
| builder.startBlockArgumentNesting(); |
| _visitWhenClause(whenClause); |
| builder.endBlockArgumentNesting(); |
| builder.unnest(); |
| builder.endRule(); |
| } |
| |
| space(); |
| token(node.arrow); |
| split(); |
| builder.endRule(); |
| |
| builder.startBlockArgumentNesting(); |
| visit(node.expression); |
| builder.endBlockArgumentNesting(); |
| |
| builder.unnest(); |
| } |
| |
| @override |
| void visitSwitchStatement(SwitchStatement node) { |
| _visitSwitchValue(node.switchKeyword, node.leftParenthesis, node.expression, |
| node.rightParenthesis); |
| _beginBody(node.leftBracket); |
| for (var member in node.members) { |
| _visitLabels(member.labels); |
| token(member.keyword); |
| |
| if (member is SwitchCase) { |
| space(); |
| visit(member.expression); |
| } else if (member is SwitchPatternCase) { |
| space(); |
| var whenClause = member.guardedPattern.whenClause; |
| if (whenClause == null) { |
| builder.indent(); |
| visit(member.guardedPattern.pattern); |
| builder.unindent(); |
| } else { |
| // Wrap the when clause rule around the pattern so that if the pattern |
| // splits then we split before "when" too. |
| builder.startRule(); |
| builder.nestExpression(); |
| builder.startBlockArgumentNesting(); |
| visit(member.guardedPattern.pattern); |
| split(); |
| _visitWhenClause(whenClause); |
| builder.endBlockArgumentNesting(); |
| builder.unnest(); |
| builder.endRule(); |
| } |
| } else { |
| assert(member is SwitchDefault); |
| // Nothing to do. |
| } |
| |
| token(member.colon); |
| |
| if (member.statements.isNotEmpty) { |
| builder.indent(); |
| newline(); |
| visitNodes(member.statements, between: oneOrTwoNewlines); |
| builder.unindent(); |
| oneOrTwoNewlines(); |
| } else { |
| // Don't preserve blank lines between empty cases. |
| builder.writeNewline(); |
| } |
| } |
| |
| if (node.members.isNotEmpty) { |
| newline(); |
| } |
| _endBody(node.rightBracket, forceSplit: node.members.isNotEmpty); |
| } |
| |
| /// Visits the `switch (expr)` part of a switch statement or expression. |
| void _visitSwitchValue(Token switchKeyword, Token leftParenthesis, |
| Expression value, Token rightParenthesis) { |
| builder.nestExpression(); |
| token(switchKeyword); |
| space(); |
| token(leftParenthesis); |
| soloZeroSplit(); |
| visit(value); |
| token(rightParenthesis); |
| space(); |
| builder.unnest(); |
| } |
| |
| @override |
| void visitSymbolLiteral(SymbolLiteral node) { |
| token(node.poundSign); |
| var components = node.components; |
| for (var component in components) { |
| // The '.' separator |
| if (component.previous!.lexeme == '.') { |
| token(component.previous); |
| } |
| token(component); |
| } |
| } |
| |
| @override |
| void visitThisExpression(ThisExpression node) { |
| token(node.thisKeyword); |
| } |
| |
| @override |
| void visitThrowExpression(ThrowExpression node) { |
| token(node.throwKeyword); |
| space(); |
| visit(node.expression); |
| } |
| |
| @override |
| void visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) { |
| visitMetadata(node.metadata); |
| |
| _simpleStatement(node, () { |
| modifier(node.externalKeyword); |
| visit(node.variables); |
| }); |
| } |
| |
| @override |
| void visitTryStatement(TryStatement node) { |
| token(node.tryKeyword); |
| space(); |
| visit(node.body); |
| visitNodes(node.catchClauses, before: space, between: space); |
| token(node.finallyKeyword, before: space, after: space); |
| visit(node.finallyBlock); |
| } |
| |
| @override |
| void visitTypeArgumentList(TypeArgumentList node) { |
| _visitGenericList(node.leftBracket, node.rightBracket, node.arguments); |
| } |
| |
| @override |
| void visitTypeParameter(TypeParameter node) { |
| visitParameterMetadata(node.metadata, () { |
| token(node.name); |
| token(node.extendsKeyword, before: space, after: space); |
| visit(node.bound); |
| }); |
| } |
| |
| @override |
| void visitTypeParameterList(TypeParameterList node) { |
| _visitGenericList(node.leftBracket, node.rightBracket, node.typeParameters); |
| } |
| |
| @override |
| void visitVariableDeclaration(VariableDeclaration node) { |
| token(node.name); |
| if (node.initializer == null) return; |
| |
| // If there are multiple variables being declared, we want to nest the |
| // initializers farther so they don't line up with the variables. Bad: |
| // |
| // var a = |
| // aValue, |
| // b = |
| // bValue; |
| // |
| // Good: |
| // |
| // var a = |
| // aValue, |
| // b = |
| // bValue; |
| var hasMultipleVariables = |
| (node.parent as VariableDeclarationList).variables.length > 1; |
| |
| _visitAssignment(node.equals!, node.initializer!, |
| nest: hasMultipleVariables); |
| } |
| |
| @override |
| void visitVariableDeclarationList(VariableDeclarationList node) { |
| visitMetadata(node.metadata); |
| |
| // Allow but try to avoid splitting between the type and name. |
| builder.startSpan(); |
| |
| modifier(node.lateKeyword); |
| modifier(node.keyword); |
| visit(node.type); |
| _separatorBetweenTypeAndVariable(node.type, isSolo: true); |
| |
| builder.endSpan(); |
| |
| _startPossibleConstContext(node.keyword); |
| |
| // Use a single rule for all of the variables. If there are multiple |
| // declarations, we will try to keep them all on one line. If that isn't |
| // possible, we split after *every* declaration so that each is on its own |
| // line. |
| builder.startRule(); |
| |
| // If there are multiple declarations split across lines, then we want any |
| // blocks in the initializers to indent past the variables. |
| if (node.variables.length > 1) builder.startBlockArgumentNesting(); |
| |
| visitCommaSeparatedNodes(node.variables, between: split); |
| |
| if (node.variables.length > 1) builder.endBlockArgumentNesting(); |
| |
| builder.endRule(); |
| _endPossibleConstContext(node.keyword); |
| } |
| |
| @override |
| void visitVariableDeclarationStatement(VariableDeclarationStatement node) { |
| _simpleStatement(node, () { |
| visit(node.variables); |
| }); |
| } |
| |
| @override |
| void visitWhileStatement(WhileStatement node) { |
| builder.nestExpression(); |
| token(node.whileKeyword); |
| space(); |
| token(node.leftParenthesis); |
| soloZeroSplit(); |
| visit(node.condition); |
| token(node.rightParenthesis); |
| builder.unnest(); |
| |
| _visitLoopBody(node.body); |
| } |
| |
| @override |
| void visitWildcardPattern(WildcardPattern node) { |
| _visitVariablePattern(node.keyword, node.type, node.name); |
| } |
| |
| @override |
| void visitWithClause(WithClause node) { |
| _visitCombinator(node.withKeyword, node.mixinTypes); |
| } |
| |
| @override |
| void visitYieldStatement(YieldStatement node) { |
| _simpleStatement(node, () { |
| token(node.yieldKeyword); |
| token(node.star); |
| space(); |
| visit(node.expression); |
| }); |
| } |
| |
| /// Visit a [node], and if not null, optionally preceded or followed by the |
| /// specified functions. |
| void visit(AstNode? node, {void Function()? before, void Function()? after}) { |
| if (node == null) return; |
| |
| if (before != null) before(); |
| |
| node.accept(this); |
| |
| if (after != null) after(); |
| } |
| |
| /// Visit metadata annotations on declarations, and members. |
| /// |
| /// These always force the annotations to be on the previous line. |
| void visitMetadata(NodeList<Annotation> metadata) { |
| visitNodes(metadata, between: newline, after: newline); |
| } |
| |
| /// Visit metadata annotations for a directive. |
| /// |
| /// Always force the annotations to be on a previous line. |
| void _visitDirectiveMetadata(Directive directive) { |
| // Preserve a blank line before the first directive since users (in |
| // particular the test package) sometimes use that for metadata that |
| // applies to the entire library and not the following directive itself. |
| var isFirst = |
| directive == (directive.parent as CompilationUnit).directives.first; |
| |
| visitNodes(directive.metadata, |
| between: newline, after: isFirst ? oneOrTwoNewlines : newline); |
| } |
| |
| /// Visits metadata annotations on parameters and type parameters. |
| /// |
| /// Unlike other annotations, these are allowed to stay on the same line as |
| /// the parameter. |
| void visitParameterMetadata( |
| NodeList<Annotation> metadata, void Function() visitParameter) { |
| if (metadata.isEmpty) { |
| visitParameter(); |
| return; |
| } |
| |
| // Split before all of the annotations on this parameter or none of them. |
| builder.startLazyRule(); |
| |
| visitNodes(metadata, between: split, after: split); |
| visitParameter(); |
| |
| // Wrap the rule around the parameter too. If it splits, we want to force |
| // the annotations to split as well. |
| builder.endRule(); |
| } |
| |
| /// Visits [node], which may be in an argument list controlled by [rule]. |
| /// |
| /// This is called directly by [ArgumentListVisitor] so that it can pass in |
| /// the surrounding named argument rule. That way, this can ensure that a |
| /// split between the name and argument forces the argument list to split |
| /// too. |
| void visitNamedArgument(NamedExpression node, [NamedRule? rule]) { |
| visitNamedNode( |
| node.name.label.token, node.name.colon, node.expression, rule); |
| } |
| |
| /// Visits syntax of the form `identifier: <node>`: a named argument or a |
| /// named record field. |
| void visitNamedNode(Token name, Token colon, AstNode node, |
| [NamedRule? rule]) { |
| builder.nestExpression(); |
| builder.startSpan(); |
| token(name); |
| token(colon); |
| |
| // Don't allow a split between a name and a collection. Instead, we want |
| // the collection itself to split, or to split before the argument. |
| if (node is ListLiteral || |
| node is SetOrMapLiteral || |
| node is RecordLiteral) { |
| space(); |
| } else { |
| var split = soloSplit(); |
| if (rule != null) split.constrainWhenSplit(rule); |
| } |
| |
| visit(node); |
| builder.endSpan(); |
| builder.unnest(); |
| } |
| |
| /// Visits the `=` and the following expression in any place where an `=` |
| /// appears: |
| /// |
| /// * Assignment |
| /// * Variable declaration |
| /// * Constructor initialization |
| /// |
| /// If [nest] is true, an extra level of expression nesting is added after |
| /// the "=". |
| void _visitAssignment(Token equalsOperator, Expression rightHandSide, |
|