Upgrade to analyzer 0.27.0.

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';
 
@@ skipping 515 matching lines @@
     space();
 
     visit(node.elseExpression);
 
     builder.endRule();
     builder.endSpan();
     builder.endBlockArgumentNesting();
     builder.unnest();
   }
 
+  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.libraryUri);
+  }
+
   visitConstructorDeclaration(ConstructorDeclaration node) {
     visitMemberMetadata(node.metadata);
 
     modifier(node.externalKeyword);
     modifier(node.constKeyword);
     modifier(node.factoryKeyword);
     visit(node.returnType);
     token(node.period);
     visit(node.name);
 
@@ skipping 113 matching lines @@
     token(node.whileKeyword);
     space();
     token(node.leftParenthesis);
     soloZeroSplit();
     visit(node.condition);
     token(node.rightParenthesis);
     token(node.semicolon);
     builder.unnest();
   }
 
+  visitDottedName(DottedName node) {
+    for (var component in node.components) {
+      // Write the preceding ".".
+      if (component != node.components.first) {
+        token(component.beginToken.previous);
+      }
+
+      visit(component);
+    }
+  }
+
   visitDoubleLiteral(DoubleLiteral node) {
     token(node.literal);
   }
 
   visitEmptyFunctionBody(EmptyFunctionBody node) {
     token(node.semicolon);
   }
 
   visitEmptyStatement(EmptyStatement node) {
     token(node.semicolon);
@@ skipping 17 matching lines @@
   }
 
   visitExportDirective(ExportDirective node) {
     visitDeclarationMetadata(node.metadata);
 
     _simpleStatement(node, () {
       token(node.keyword);
       space();
       visit(node.uri);
 
+      _visitConfigurations(node.configurations);
+
       builder.startRule(new CombinatorRule());
       visitNodes(node.combinators);
       builder.endRule();
     });
   }
 
   visitExpressionFunctionBody(ExpressionFunctionBody node) {
     // Space after the parameter list.
     space();
 
@@ skipping 339 matching lines @@
   }
 
   visitImportDirective(ImportDirective node) {
     visitDeclarationMetadata(node.metadata);
 
     _simpleStatement(node, () {
       token(node.keyword);
       space();
       visit(node.uri);
 
+      _visitConfigurations(node.configurations);
+
       if (node.asKeyword != null) {
         soloSplit();
         token(node.deferredKeyword, after: space);
         token(node.asKeyword);
         space();
         visit(node.prefix);
       }
 
       builder.startRule(new CombinatorRule());
       visitNodes(node.combinators);
@@ skipping 915 matching lines @@
 
     builder = builder.endBlock(ignoredRule,
         forceSplit: hasLeadingNewline || forceSplit);
 
     builder.endRule();
 
     // Now write the delimiter itself.
     _writeText(rightBracket.lexeme, rightBracket.offset);
   }
 
+  /// Visits a list of configurations in an import or export directive.
+  void _visitConfigurations(NodeList<Configuration> configurations) {
+    if (configurations.isEmpty) return;
+
+    builder.startRule();
+
+    for (var configuration in configurations) {
+      split();
+      visit(configuration);
+    }
+
+    builder.endRule();
+  }
+
   /// Visits a "combinator".
   ///
   /// This is a [keyword] followed by a list of [nodes], with specific line
   /// splitting rules. As the name implies, this is used for [HideCombinator]
   /// and [ShowCombinator], but it also used for "with" and "implements"
   /// clauses in class declarations, which are formatted the same way.
   ///
   /// This assumes the current rule is a [CombinatorRule].
   void _visitCombinator(Token keyword, Iterable<AstNode> nodes) {
     // Allow splitting before the keyword.
@@ skipping 352 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;
 }