More sophisticated handling of parameter metadata.

lib/src/source_visitor.dart

 // 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.
 
 library dart_style.src.source_visitor;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 import 'argument_list_visitor.dart';
 import 'call_chain_visitor.dart';
 import 'chunk.dart';
 import 'chunk_builder.dart';
 import 'dart_formatter.dart';
 import 'rule/argument.dart';
 import 'rule/combinator.dart';
+import 'rule/metadata.dart';
 import 'rule/rule.dart';
 import 'rule/type_argument.dart';
 import 'source_code.dart';
 import 'whitespace.dart';
 
 /// Visits every token of the AST and passes all of the relevant bits to a
 /// [ChunkBuilder].
 class SourceVisitor implements AstVisitor {
   /// The builder for the block that is currently being visited.
   ChunkBuilder builder;
@@ skipping 24 matching lines @@
   /// 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 stack of current rules for handling parameter metadata.
+  ///
+  /// Each time a parameter (or type parameter) list is begun, a single rule
+  /// for all of the metadata annotations on parameters in that list is pushed
+  /// onto this stack. We reuse this rule for all annotations so that they split
+  /// in unison.
+  final List<MetadataRule> _metadataRules = [];
+
   /// The mapping for collection literals that are managed by the argument
   /// list that contains them.
   ///
   /// When a collection literal appears inside an [ArgumentSublist], the
   /// argument list provides a rule for the body to split to ensure that all
   /// collections split in unison. It also tracks the chunk before the
   /// argument that determines whether or not the collection body is indented
   /// like an expression or a statement.
   ///
   /// Before a collection literal argument is visited, [ArgumentSublist] binds
@@ skipping 710 matching lines @@
     var requiredParams = node.parameters
         .where((param) => param is! DefaultFormalParameter)
         .toList();
     var optionalParams = node.parameters
         .where((param) => param is DefaultFormalParameter)
         .toList();
 
     builder.nestExpression();
     token(node.leftParenthesis);
 
+    _metadataRules.add(new MetadataRule());
+
     var rule;
     if (requiredParams.isNotEmpty) {
       if (requiredParams.length > 1) {
         rule = new MultiplePositionalRule(null, 0, 0);
       } else {
         rule = new SinglePositionalRule(null);
       }
 
+      _metadataRules.last.bindPositionalRule(rule);
+
       builder.startRule(rule);
       if (_isInLambda(node)) {
         // 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());
       }
@@ skipping 10 matching lines @@
       }
 
       builder.endSpan();
       builder.endRule();
     }
 
     if (optionalParams.isNotEmpty) {
       var namedRule = new NamedRule();
       if (rule != null) rule.setNamedArgsRule(namedRule);
 
+      _metadataRules.last.bindNamedRule(namedRule);
+
       builder.startRule(namedRule);
 
       // Make sure multi-line default values are indented.
       builder.startBlockArgumentNesting();
 
       namedRule
           .beforeArguments(builder.split(space: requiredParams.isNotEmpty));
 
       // "[" or "{" for optional parameters.
       token(node.leftDelimiter);
 
       for (var param in optionalParams) {
         visit(param);
 
         // Write the trailing comma.
         if (param != node.parameters.last) token(param.endToken.next);
         if (param != optionalParams.last) split();
       }
 
       builder.endBlockArgumentNesting();
       builder.endRule();
 
       // "]" or "}" for optional parameters.
       token(node.rightDelimiter);
     }
 
+    _metadataRules.removeLast();
+
     token(node.rightParenthesis);
     builder.unnest();
   }
 
   visitForStatement(ForStatement node) {
     builder.nestExpression();
     token(node.forKeyword);
     space();
     token(node.leftParenthesis);
 
@@ skipping 592 matching lines @@
 
   visitTypeParameter(TypeParameter node) {
     visitParameterMetadata(node.metadata, () {
       visit(node.name);
       token(node.extendsKeyword, before: space, after: space);
       visit(node.bound);
     });
   }
 
   visitTypeParameterList(TypeParameterList node) {
+    _metadataRules.add(new MetadataRule());
+
     _visitGenericList(node.leftBracket, node.rightBracket, node.typeParameters);
+
+    _metadataRules.removeLast();
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
     visit(node.name);
     if (node.initializer == null) return;
 
     _visitAssignment(node.equals, node.initializer);
   }
 
   visitVariableDeclarationList(VariableDeclarationList node) {
@@ skipping 84 matching lines @@
     } else {
       visitNodes(metadata, between: space, after: spaceOrNewline);
     }
   }
 
   /// Visits metadata annotations on parameters and type parameters.
   ///
   /// These are always on the same line as the parameter.
   void visitParameterMetadata(
       NodeList<Annotation> metadata, void visitParameter()) {
+    if (metadata == null || metadata.isEmpty) {
+      visitParameter();
+      return;
+    }
+
     // Split before all of the annotations or none.
-    builder.startRule();
-    visitNodes(metadata, between: split, after: split);
+    builder.startLazyRule(_metadataRules.last);
+
+    visitNodes(metadata, between: split, after: () {
+      // Don't nest until right before the last metadata. Ensures we only
+      // indent the parameter and not any of the metadata:
+      //
+      //     function(
+      //         @LongAnnotation
+      //         @LongAnnotation
+      //             indentedParameter) {}
+      builder.nestExpression(now: true);
+      split();
+    });
     visitParameter();
 
+    builder.unnest();
+
     // Wrap the rule around the parameter too. If it splits, we want to force
     // the annotations to split as well.
     builder.endRule();
   }
 
   /// Visits the `=` and the following expression in any place where an `=`
   /// appears:
   ///
   /// * Assignment
   /// * Variable declaration
   /// * Constructor initialization
   void _visitAssignment(Token equalsOperator, Expression rightHandSide) {
     space();
     token(equalsOperator);
     soloSplit(_assignmentCost(rightHandSide));
     builder.startSpan();
     visit(rightHandSide);
     builder.endSpan();
   }
 
   /// Visits a type parameter or type argument list.
   void _visitGenericList(
       Token leftBracket, Token rightBracket, List<AstNode> nodes) {
     var rule = new TypeArgumentRule();
     builder.startRule(rule);
     builder.startSpan();
     builder.nestExpression();
 
+    // TODO(rnystrom): Should the MetadataRule constrain a TypeArgumentRule
+    // as well?

[nweiz, 2015/11/30 19:17:01]

The doc comment for MetadataRule implies that it does. If it doesn't yet, that
comment should be updated.

[Bob Nystrom, 2015/11/30 21:36:14]

Done.

+
     token(leftBracket);
     rule.beforeArgument(zeroSplit());
 
     for (var node in nodes) {
       visit(node);
 
       // Write the trailing comma.
       if (node != nodes.last) {
         token(node.endToken.next);
         rule.beforeArgument(split());
@@ skipping 677 matching lines @@
   /// Gets the 1-based line number that the beginning of [token] lies on.
   int _startLine(Token token) => _lineInfo.getLocation(token.offset).lineNumber;
 
   /// Gets the 1-based line number that the end of [token] lies on.
   int _endLine(Token token) => _lineInfo.getLocation(token.end).lineNumber;
 
   /// Gets the 1-based column number that the beginning of [token] lies on.
   int _startColumn(Token token) =>
       _lineInfo.getLocation(token.offset).columnNumber;
 }