Lexical support for configurable imports (DEP 40)

pkg/analyzer/lib/src/generated/ast.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 engine.ast;
 
 import 'dart:collection';
 
 import 'element.dart';
 import 'engine.dart' show AnalysisEngine;
@@ skipping 1145 matching lines @@
   ConditionalExpression visitConditionalExpression(
           ConditionalExpression node) =>
       new ConditionalExpression(
           cloneNode(node.condition),
           cloneToken(node.question),
           cloneNode(node.thenExpression),
           cloneToken(node.colon),
           cloneNode(node.elseExpression));
 
   @override
+  Configuration visitConfiguration(Configuration node) => new Configuration(
+      cloneToken(node.ifKeyword),
+      cloneToken(node.leftParenthesis),
+      cloneNode(node.name),
+      cloneToken(node.equalToken),
+      cloneNode(node.value),
+      cloneToken(node.rightParenthesis),
+      cloneNode(node.libraryUri));
+
+  @override
   ConstructorDeclaration visitConstructorDeclaration(
           ConstructorDeclaration node) =>
       new ConstructorDeclaration(
           cloneNode(node.documentationComment),
           cloneNodeList(node.metadata),
           cloneToken(node.externalKeyword),
           cloneToken(node.constKeyword),
           cloneToken(node.factoryKeyword),
           cloneNode(node.returnType),
           cloneToken(node.period),
@@ skipping 43 matching lines @@
   DoStatement visitDoStatement(DoStatement node) => new DoStatement(
       cloneToken(node.doKeyword),
       cloneNode(node.body),
       cloneToken(node.whileKeyword),
       cloneToken(node.leftParenthesis),
       cloneNode(node.condition),
       cloneToken(node.rightParenthesis),
       cloneToken(node.semicolon));
 
   @override
+  DottedName visitDottedName(DottedName node) =>
+      new DottedName(cloneNodeList(node.components));
+
+  @override
   DoubleLiteral visitDoubleLiteral(DoubleLiteral node) =>
       new DoubleLiteral(cloneToken(node.literal), node.value);
 
   @override
   EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) =>
       new EmptyFunctionBody(cloneToken(node.semicolon));
 
   @override
   EmptyStatement visitEmptyStatement(EmptyStatement node) =>
       new EmptyStatement(cloneToken(node.semicolon));
@@ skipping 14 matching lines @@
           cloneNodeList(node.constants),
           cloneToken(node.rightBracket));
 
   @override
   ExportDirective visitExportDirective(ExportDirective node) {
     ExportDirective directive = new ExportDirective(
         cloneNode(node.documentationComment),
         cloneNodeList(node.metadata),
         cloneToken(node.keyword),
         cloneNode(node.uri),
+        cloneNodeList(node.configurations),
         cloneNodeList(node.combinators),
         cloneToken(node.semicolon));
     directive.source = node.source;
     directive.uriContent = node.uriContent;
     return directive;
   }
 
   @override
   ExpressionFunctionBody visitExpressionFunctionBody(
           ExpressionFunctionBody node) =>
@@ skipping 150 matching lines @@
       new ImplementsClause(
           cloneToken(node.implementsKeyword), cloneNodeList(node.interfaces));
 
   @override
   ImportDirective visitImportDirective(ImportDirective node) {
     ImportDirective directive = new ImportDirective(
         cloneNode(node.documentationComment),
         cloneNodeList(node.metadata),
         cloneToken(node.keyword),
         cloneNode(node.uri),
+        cloneNodeList(node.configurations),
         cloneToken(node.deferredKeyword),
         cloneToken(node.asKeyword),
         cloneNode(node.prefix),
         cloneNodeList(node.combinators),
         cloneToken(node.semicolon));
     directive.source = node.source;
     directive.uriContent = node.uriContent;
     return directive;
   }
 
@@ skipping 589 matching lines @@
   bool visitConditionalExpression(ConditionalExpression node) {
     ConditionalExpression other = _other as ConditionalExpression;
     return isEqualNodes(node.condition, other.condition) &&
         isEqualTokens(node.question, other.question) &&
         isEqualNodes(node.thenExpression, other.thenExpression) &&
         isEqualTokens(node.colon, other.colon) &&
         isEqualNodes(node.elseExpression, other.elseExpression);
   }
 
   @override
+  bool visitConfiguration(Configuration node) {
+    Configuration other = _other as Configuration;
+    return isEqualTokens(node.ifKeyword, other.ifKeyword) &&
+        isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
+        isEqualNodes(node.name, other.name) &&
+        isEqualTokens(node.equalToken, other.equalToken) &&
+        isEqualNodes(node.value, other.value) &&
+        isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
+        isEqualNodes(node.libraryUri, other.libraryUri);
+  }
+
+  @override
   bool visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorDeclaration other = _other as ConstructorDeclaration;
     return isEqualNodes(
             node.documentationComment, other.documentationComment) &&
         _isEqualNodeLists(node.metadata, other.metadata) &&
         isEqualTokens(node.externalKeyword, other.externalKeyword) &&
         isEqualTokens(node.constKeyword, other.constKeyword) &&
         isEqualTokens(node.factoryKeyword, other.factoryKeyword) &&
         isEqualNodes(node.returnType, other.returnType) &&
         isEqualTokens(node.period, other.period) &&
@@ skipping 57 matching lines @@
     return isEqualTokens(node.doKeyword, other.doKeyword) &&
         isEqualNodes(node.body, other.body) &&
         isEqualTokens(node.whileKeyword, other.whileKeyword) &&
         isEqualTokens(node.leftParenthesis, other.leftParenthesis) &&
         isEqualNodes(node.condition, other.condition) &&
         isEqualTokens(node.rightParenthesis, other.rightParenthesis) &&
         isEqualTokens(node.semicolon, other.semicolon);
   }
 
   @override
+  bool visitDottedName(DottedName node) {
+    DottedName other = _other as DottedName;
+    return _isEqualNodeLists(node.components, other.components);
+  }
+
+  @override
   bool visitDoubleLiteral(DoubleLiteral node) {
     DoubleLiteral other = _other as DoubleLiteral;
     return isEqualTokens(node.literal, other.literal) &&
         node.value == other.value;
   }
 
   @override
   bool visitEmptyFunctionBody(EmptyFunctionBody node) {
     EmptyFunctionBody other = _other as EmptyFunctionBody;
     return isEqualTokens(node.semicolon, other.semicolon);
@@ skipping 1005 matching lines @@
   R visitClassTypeAlias(ClassTypeAlias node);
 
   R visitComment(Comment node);
 
   R visitCommentReference(CommentReference node);
 
   R visitCompilationUnit(CompilationUnit node);
 
   R visitConditionalExpression(ConditionalExpression node);
 
+  R visitConfiguration(Configuration node);
+
   R visitConstructorDeclaration(ConstructorDeclaration node);
 
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node);
 
   R visitConstructorName(ConstructorName node);
 
   R visitContinueStatement(ContinueStatement node);
 
   R visitDeclaredIdentifier(DeclaredIdentifier node);
 
   R visitDefaultFormalParameter(DefaultFormalParameter node);
 
   R visitDoStatement(DoStatement node);
 
+  R visitDottedName(DottedName node);
+
   R visitDoubleLiteral(DoubleLiteral node);
 
   R visitEmptyFunctionBody(EmptyFunctionBody node);
 
   R visitEmptyStatement(EmptyStatement node);
 
   R visitEnumConstantDeclaration(EnumConstantDeclaration node);
 
   R visitEnumDeclaration(EnumDeclaration node);
 
@@ skipping 1940 matching lines @@
   accept(AstVisitor visitor) => visitor.visitConditionalExpression(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_condition, visitor);
     _safelyVisitChild(_thenExpression, visitor);
     _safelyVisitChild(_elseExpression, visitor);
   }
 }
 
+/**
+ * A configuration in either an import or export directive.
+ *
+ *     configuration ::=
+ *         'if' '(' test ')' uri
+ *
+ *     test ::=
+ *         dottedName ('==' stringLiteral)?
+ *
+ *     dottedName ::=
+ *         identifier ('.' identifier)*
+ */
+class Configuration extends AstNode {
+  Token ifKeyword;
+  Token leftParenthesis;
+  DottedName _name;
+  Token equalToken;
+  StringLiteral _value;
+  Token rightParenthesis;
+  StringLiteral _libraryUri;
+
+  Configuration(
+      this.ifKeyword,
+      this.leftParenthesis,
+      DottedName name,
+      this.equalToken,
+      StringLiteral value,
+      this.rightParenthesis,
+      StringLiteral libraryUri) {
+    _name = _becomeParentOf(name);
+    _value = _becomeParentOf(value);
+    _libraryUri = _becomeParentOf(libraryUri);
+  }
+
+  @override
+  Token get beginToken => ifKeyword;
+
+  @override
+  Iterable get childEntities => new ChildEntities()
+    ..add(ifKeyword)
+    ..add(leftParenthesis)
+    ..add(_name)
+    ..add(equalToken)
+    ..add(_value)
+    ..add(rightParenthesis)
+    ..add(_libraryUri);
+
+  @override
+  Token get endToken => _libraryUri.endToken;
+
+  StringLiteral get libraryUri => _libraryUri;
+
+  void set libraryUri(StringLiteral libraryUri) {
+    _libraryUri = _becomeParentOf(libraryUri);
+  }
+
+  DottedName get name => _name;
+
+  void set name(DottedName name) {
+    _name = _becomeParentOf(name);
+  }
+
+  StringLiteral get value => _value;
+
+  void set value(StringLiteral value) {
+    _value = _becomeParentOf(value);
+  }
+
+  @override
+  accept(AstVisitor visitor) => visitor.visitConfiguration(this);
+
+  @override
+  void visitChildren(AstVisitor visitor) {
+    _safelyVisitChild(_name, visitor);
+    _safelyVisitChild(_value, visitor);
+    _safelyVisitChild(_libraryUri, visitor);
+  }
+}
+
 /// Instances of the class [ConstantEvaluator] evaluate constant expressions to
 /// produce their compile-time value.
 ///
 /// According to the Dart Language Specification:
 ///
 /// > A constant expression is one of the following:
 /// >
 /// > * A literal number.
 /// > * A literal boolean.
 /// > * A literal string where any interpolated expression is a compile-time
@@ skipping 1314 matching lines @@
   accept(AstVisitor visitor) => visitor.visitDoStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_body, visitor);
     _safelyVisitChild(_condition, visitor);
   }
 }
 
 /**
+ * A dotted name, usedd in a configuration within an import or export directive.
+ *
+ * > dottedName ::=
+ * >     [SimpleIdentifier] ('.' [SimpleIdentifier])*
+ */
+class DottedName extends AstNode {

[Paul Berry, 2015/10/21 17:10:47]

This looks almost identical to the definition of LibraryIdentifier (in fact it
looks like you copied it and removed some methods).  Is there any way we could
share the implementations rather than duplicate code?

(I suspect that the extra methods in LibraryIdentifier, and the fact that it
extends Identifier, are not actually necessary, because LibraryIdentifier is
only syntactically valid inside "library" and "part of" declarations, where the
expression semantics don't make sense.  So maybe we could just drop
LibraryIdentifier entirely and use DottedName in its place.  That's a breaking
change, of course, but so is the rest of this CL).

[Brian Wilkerson, 2015/10/21 20:05:23]

I like the idea of removing LibraryIdentifier. I'll look into it.

+  /**
+   * The components of the identifier.
+   */
+  NodeList<SimpleIdentifier> _components;
+
+  /**
+   * Initialize a newly created prefixed identifier.

[Paul Berry, 2015/10/21 17:10:47]

s/prefixed identifier/dotted name/

[Brian Wilkerson, 2015/10/21 20:05:23]

Done

+   */
+  DottedName(List<SimpleIdentifier> components) {
+    _components = new NodeList<SimpleIdentifier>(this, components);
+  }
+
+  @override
+  Token get beginToken => _components.beginToken;
+
+  @override
+  // TODO(paulberry): add "." tokens.
+  Iterable get childEntities => new ChildEntities()..addAll(_components);
+
+  /**
+   * Return the components of the identifier.
+   */
+  NodeList<SimpleIdentifier> get components => _components;
+
+  @override
+  Token get endToken => _components.endToken;
+
+  @override
+  accept(AstVisitor visitor) => visitor.visitDottedName(this);
+
+  @override
+  void visitChildren(AstVisitor visitor) {
+    _components.accept(visitor);
+  }
+}
+
+/**
  * A floating point literal expression.
  *
  * > doubleLiteral ::=
  * >     decimalDigit+ ('.' decimalDigit*)? exponent?
  * >   | '.' decimalDigit+ exponent?
  * >
  * > exponent ::=
  * >     ('e' | 'E') ('+' | '-')? decimalDigit+
  */
 class DoubleLiteral extends Literal {
@@ skipping 398 matching lines @@
  * > exportDirective ::=
  * >     [Annotation] 'export' [StringLiteral] [Combinator]* ';'
  */
 class ExportDirective extends NamespaceDirective {
   /**
    * Initialize a newly created export directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute. The list of [combinators] can be `null` if there
    * are no combinators.
    */
-  ExportDirective(Comment comment, List<Annotation> metadata, Token keyword,
-      StringLiteral libraryUri, List<Combinator> combinators, Token semicolon)
-      : super(comment, metadata, keyword, libraryUri, combinators, semicolon);
+  ExportDirective(
+      Comment comment,
+      List<Annotation> metadata,
+      Token keyword,
+      StringLiteral libraryUri,
+      List<Configuration> configurations,
+      List<Combinator> combinators,
+      Token semicolon)
+      : super(comment, metadata, keyword, libraryUri, configurations,
+            combinators, semicolon);
 
   @override
   Iterable get childEntities => super._childEntities
     ..add(_uri)
     ..addAll(combinators)
     ..add(semicolon);
 
   @override
   ExportElement get element => super.element as ExportElement;
 
@@ skipping 1988 matching lines @@
   R visitCompilationUnit(CompilationUnit node) => visitNode(node);
 
   R visitCompilationUnitMember(CompilationUnitMember node) =>
       visitDeclaration(node);
 
   @override
   R visitConditionalExpression(ConditionalExpression node) =>
       visitExpression(node);
 
   @override
+  R visitConfiguration(Configuration node) => visitNode(node);
+
+  @override
   R visitConstructorDeclaration(ConstructorDeclaration node) =>
       visitClassMember(node);
 
   @override
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node) =>
       visitConstructorInitializer(node);
 
   R visitConstructorInitializer(ConstructorInitializer node) => visitNode(node);
 
   @override
@@ skipping 10 matching lines @@
   @override
   R visitDefaultFormalParameter(DefaultFormalParameter node) =>
       visitFormalParameter(node);
 
   R visitDirective(Directive node) => visitAnnotatedNode(node);
 
   @override
   R visitDoStatement(DoStatement node) => visitStatement(node);
 
   @override
+  R visitDottedName(DottedName node) => visitNode(node);
+
+  @override
   R visitDoubleLiteral(DoubleLiteral node) => visitLiteral(node);
 
   @override
   R visitEmptyFunctionBody(EmptyFunctionBody node) => visitFunctionBody(node);
 
   @override
   R visitEmptyStatement(EmptyStatement node) => visitStatement(node);
 
   @override
   R visitEnumConstantDeclaration(EnumConstantDeclaration node) =>
@@ skipping 718 matching lines @@
    * corresponding attribute. The [deferredKeyword] can be `null` if the import
    * is not deferred. The [asKeyword] and [prefix] can be `null` if the import
    * does not specify a prefix. The list of [combinators] can be `null` if there
    * are no combinators.
    */
   ImportDirective(
       Comment comment,
       List<Annotation> metadata,
       Token keyword,
       StringLiteral libraryUri,
+      List<Configuration> configurations,
       this.deferredKeyword,
       this.asKeyword,
       SimpleIdentifier prefix,
       List<Combinator> combinators,
       Token semicolon)
-      : super(comment, metadata, keyword, libraryUri, combinators, semicolon) {
+      : super(comment, metadata, keyword, libraryUri, configurations,
+            combinators, semicolon) {
     _prefix = _becomeParentOf(prefix);
   }
 
   /**
    * The token representing the 'as' token, or `null` if the imported names are
    * not prefixed.
    */
   @deprecated // Use "this.asKeyword"
   Token get asToken => asKeyword;
 
@@ skipping 276 matching lines @@
         _mapToken(node.question),
         _cloneNode(node.thenExpression),
         _mapToken(node.colon),
         _cloneNode(node.elseExpression));
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
+  Configuration visitConfiguration(Configuration node) => new Configuration(
+      _mapToken(node.ifKeyword),
+      _mapToken(node.leftParenthesis),
+      _cloneNode(node.name),
+      _mapToken(node.equalToken),
+      _cloneNode(node.value),
+      _mapToken(node.rightParenthesis),
+      _cloneNode(node.libraryUri));
+
+  @override
   ConstructorDeclaration visitConstructorDeclaration(
       ConstructorDeclaration node) {
     ConstructorDeclaration copy = new ConstructorDeclaration(
         _cloneNode(node.documentationComment),
         _cloneNodeList(node.metadata),
         _mapToken(node.externalKeyword),
         _mapToken(node.constKeyword),
         _mapToken(node.factoryKeyword),
         _cloneNode(node.returnType),
         _mapToken(node.period),
@@ skipping 49 matching lines @@
   DoStatement visitDoStatement(DoStatement node) => new DoStatement(
       _mapToken(node.doKeyword),
       _cloneNode(node.body),
       _mapToken(node.whileKeyword),
       _mapToken(node.leftParenthesis),
       _cloneNode(node.condition),
       _mapToken(node.rightParenthesis),
       _mapToken(node.semicolon));
 
   @override
+  DottedName visitDottedName(DottedName node) =>
+      new DottedName(_cloneNodeList(node.components));
+
+  @override
   DoubleLiteral visitDoubleLiteral(DoubleLiteral node) {
     DoubleLiteral copy = new DoubleLiteral(_mapToken(node.literal), node.value);
     copy.propagatedType = node.propagatedType;
     copy.staticType = node.staticType;
     return copy;
   }
 
   @override
   EmptyFunctionBody visitEmptyFunctionBody(EmptyFunctionBody node) =>
       new EmptyFunctionBody(_mapToken(node.semicolon));
@@ skipping 17 matching lines @@
       _cloneNodeList(node.constants),
       _mapToken(node.rightBracket));
 
   @override
   ExportDirective visitExportDirective(ExportDirective node) {
     ExportDirective copy = new ExportDirective(
         _cloneNode(node.documentationComment),
         _cloneNodeList(node.metadata),
         _mapToken(node.keyword),
         _cloneNode(node.uri),
+        _cloneNodeList(node.configurations),
         _cloneNodeList(node.combinators),
         _mapToken(node.semicolon));
     copy.element = node.element;
     return copy;
   }
 
   @override
   ExpressionFunctionBody visitExpressionFunctionBody(
           ExpressionFunctionBody node) =>
       new ExpressionFunctionBody(
@@ skipping 164 matching lines @@
       new ImplementsClause(
           _mapToken(node.implementsKeyword), _cloneNodeList(node.interfaces));
 
   @override
   ImportDirective visitImportDirective(ImportDirective node) =>
       new ImportDirective(
           _cloneNode(node.documentationComment),
           _cloneNodeList(node.metadata),
           _mapToken(node.keyword),
           _cloneNode(node.uri),
+          _cloneNodeList(node.configurations),
           _mapToken(node.deferredKeyword),
           _mapToken(node.asKeyword),
           _cloneNode(node.prefix),
           _cloneNodeList(node.combinators),
           _mapToken(node.semicolon));
 
   @override
   IndexExpression visitIndexExpression(IndexExpression node) {
     Token period = _mapToken(node.period);
     IndexExpression copy;
@@ skipping 2253 matching lines @@
  * >     [ExportDirective]
  * >   | [ImportDirective]
  */
 abstract class NamespaceDirective extends UriBasedDirective {
   /**
    * The token representing the 'import' or 'export' keyword.
    */
   Token keyword;
 
   /**
+   * The configurations used to control which library will actually be loaded at
+   * run-time.
+   */
+  NodeList<Configuration> _configurations;
+
+  /**
    * The combinators used to control which names are imported or exported.
    */
   NodeList<Combinator> _combinators;
 
   /**
    * The semicolon terminating the directive.
    */
   Token semicolon;
 
   /**
    * Initialize a newly created namespace directive. Either or both of the
    * [comment] and [metadata] can be `null` if the directive does not have the
    * corresponding attribute. The list of [combinators] can be `null` if there
    * are no combinators.
    */
-  NamespaceDirective(Comment comment, List<Annotation> metadata, this.keyword,
-      StringLiteral libraryUri, List<Combinator> combinators, this.semicolon)
+  NamespaceDirective(
+      Comment comment,
+      List<Annotation> metadata,
+      this.keyword,
+      StringLiteral libraryUri,
+      List<Configuration> configurations,
+      List<Combinator> combinators,
+      this.semicolon)
       : super(comment, metadata, libraryUri) {
+    _configurations = new NodeList<Configuration>(this, configurations);
     _combinators = new NodeList<Combinator>(this, combinators);
   }
 
   /**
    * Return the combinators used to control how names are imported or exported.
    */
   NodeList<Combinator> get combinators => _combinators;
 
+  /**
+   * Return the configurations used to control which library will actually be
+   * loaded at run-time.
+   */
+  NodeList<Configuration> get configurations => _configurations;
+
   @override
   Token get endToken => semicolon;
 
   @override
   Token get firstTokenAfterCommentAndMetadata => keyword;
 
   @override
   LibraryElement get uriElement;
 }
 
@@ skipping 657 matching lines @@
       node.thenExpression = _newNode as Expression;
       return true;
     } else if (identical(node.elseExpression, _oldNode)) {
       node.elseExpression = _newNode as Expression;
       return true;
     }
     return visitNode(node);
   }
 
   @override
+  bool visitConfiguration(Configuration node) {
+    if (identical(node.name, _oldNode)) {
+      node.name = _newNode as DottedName;
+      return true;
+    } else if (identical(node.value, _oldNode)) {
+      node.value = _newNode as StringLiteral;
+      return true;
+    } else if (identical(node.libraryUri, _oldNode)) {
+      node.libraryUri = _newNode as StringLiteral;
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
   bool visitConstructorDeclaration(ConstructorDeclaration node) {
     if (identical(node.returnType, _oldNode)) {
       node.returnType = _newNode as Identifier;
       return true;
     } else if (identical(node.name, _oldNode)) {
       node.name = _newNode as SimpleIdentifier;
       return true;
     } else if (identical(node.parameters, _oldNode)) {
       node.parameters = _newNode as FormalParameterList;
       return true;
@@ skipping 72 matching lines @@
       node.body = _newNode as Statement;
       return true;
     } else if (identical(node.condition, _oldNode)) {
       node.condition = _newNode as Expression;
       return true;
     }
     return visitNode(node);
   }
 
   @override
+  bool visitDottedName(DottedName node) {
+    if (_replaceInList(node.components)) {
+      return true;
+    }
+    return visitNode(node);
+  }
+
+  @override
   bool visitDoubleLiteral(DoubleLiteral node) => visitNode(node);
 
   @override
   bool visitEmptyFunctionBody(EmptyFunctionBody node) => visitNode(node);
 
   @override
   bool visitEmptyStatement(EmptyStatement node) => visitNode(node);
 
   @override
   bool visitEnumConstantDeclaration(EnumConstantDeclaration node) {
@@ skipping 1863 matching lines @@
     return null;
   }
 
   @override
   R visitConditionalExpression(ConditionalExpression node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
+  R visitConfiguration(Configuration node) {
+    node.visitChildren(this);
+    return null;
+  }
+
+  @override
   R visitConstructorDeclaration(ConstructorDeclaration node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     node.visitChildren(this);
     return null;
   }
@@ skipping 22 matching lines @@
     return null;
   }
 
   @override
   R visitDoStatement(DoStatement node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
+  R visitDottedName(DottedName node) {
+    node.visitChildren(this);
+    return null;
+  }
+
+  @override
   R visitDoubleLiteral(DoubleLiteral node) {
     node.visitChildren(this);
     return null;
   }
 
   @override
   R visitEmptyFunctionBody(EmptyFunctionBody node) {
     node.visitChildren(this);
     return null;
   }
@@ skipping 1029 matching lines @@
   @override
   R visitCommentReference(CommentReference node) => null;
 
   @override
   R visitCompilationUnit(CompilationUnit node) => null;
 
   @override
   R visitConditionalExpression(ConditionalExpression node) => null;
 
   @override
+  R visitConfiguration(Configuration node) => null;
+
+  @override
   R visitConstructorDeclaration(ConstructorDeclaration node) => null;
 
   @override
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node) => null;
 
   @override
   R visitConstructorName(ConstructorName node) => null;
 
   @override
   R visitContinueStatement(ContinueStatement node) => null;
 
   @override
   R visitDeclaredIdentifier(DeclaredIdentifier node) => null;
 
   @override
   R visitDefaultFormalParameter(DefaultFormalParameter node) => null;
 
   @override
   R visitDoStatement(DoStatement node) => null;
 
   @override
+  R visitDottedName(DottedName node) => null;
+
+  @override
   R visitDoubleLiteral(DoubleLiteral node) => null;
 
   @override
   R visitEmptyFunctionBody(EmptyFunctionBody node) => null;
 
   @override
   R visitEmptyStatement(EmptyStatement node) => null;
 
   @override
   R visitEnumConstantDeclaration(EnumConstantDeclaration node) => null;
@@ skipping 1870 matching lines @@
   Object visitConditionalExpression(ConditionalExpression node) {
     _visitNode(node.condition);
     _writer.print(" ? ");
     _visitNode(node.thenExpression);
     _writer.print(" : ");
     _visitNode(node.elseExpression);
     return null;
   }
 
   @override
+  Object visitConfiguration(Configuration node) {
+    _writer.print('if (');
+    _visitNode(node.name);
+    _visitNodeWithPrefix(" == ", node.value);
+    _writer.print(') ');
+    _visitNode(node.libraryUri);
+    return null;
+  }
+
+  @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     _visitNodeListWithSeparatorAndSuffix(node.metadata, " ", " ");
     _visitTokenWithSuffix(node.externalKeyword, " ");
     _visitTokenWithSuffix(node.constKeyword, " ");
     _visitTokenWithSuffix(node.factoryKeyword, " ");
     _visitNode(node.returnType);
     _visitNodeWithPrefix(".", node.name);
     _visitNode(node.parameters);
     _visitNodeListWithSeparatorAndPrefix(" : ", node.initializers, ", ");
     _visitNodeWithPrefix(" = ", node.redirectedConstructor);
@@ skipping 49 matching lines @@
   Object visitDoStatement(DoStatement node) {
     _writer.print("do ");
     _visitNode(node.body);
     _writer.print(" while (");
     _visitNode(node.condition);
     _writer.print(");");
     return null;
   }
 
   @override
+  Object visitDottedName(DottedName node) {
+    _visitNodeListWithSeparator(node.components, ".");
+    return null;
+  }
+
+  @override
   Object visitDoubleLiteral(DoubleLiteral node) {
     _writer.print(node.literal.lexeme);
     return null;
   }
 
   @override
   Object visitEmptyFunctionBody(EmptyFunctionBody node) {
     _writer.print(';');
     return null;
   }
@@ skipping 1438 matching lines @@
   @override
   R visitCommentReference(CommentReference node) => visitNode(node);
 
   @override
   R visitCompilationUnit(CompilationUnit node) => visitNode(node);
 
   @override
   R visitConditionalExpression(ConditionalExpression node) => visitNode(node);
 
   @override
+  R visitConfiguration(Configuration node) => visitNode(node);
+
+  @override
   R visitConstructorDeclaration(ConstructorDeclaration node) => visitNode(node);
 
   @override
   R visitConstructorFieldInitializer(ConstructorFieldInitializer node) =>
       visitNode(node);
 
   @override
   R visitConstructorName(ConstructorName node) => visitNode(node);
 
   @override
   R visitContinueStatement(ContinueStatement node) => visitNode(node);
 
   @override
   R visitDeclaredIdentifier(DeclaredIdentifier node) => visitNode(node);
 
   @override
   R visitDefaultFormalParameter(DefaultFormalParameter node) => visitNode(node);
 
   @override
   R visitDoStatement(DoStatement node) => visitNode(node);
 
   @override
+  R visitDottedName(DottedName node) => visitNode(node);
+
+  @override
   R visitDoubleLiteral(DoubleLiteral node) => visitNode(node);
 
   @override
   R visitEmptyFunctionBody(EmptyFunctionBody node) => visitNode(node);
 
   @override
   R visitEmptyStatement(EmptyStatement node) => visitNode(node);
 
   @override
   R visitEnumConstantDeclaration(EnumConstantDeclaration node) =>
@@ skipping 894 matching lines @@
   }
 
   @override
   accept(AstVisitor visitor) => visitor.visitYieldStatement(this);
 
   @override
   void visitChildren(AstVisitor visitor) {
     _safelyVisitChild(_expression, visitor);
   }
 }