dart2js: add support for configuration-specific imports.

pkg/compiler/lib/src/tree/nodes.dart

 // Copyright (c) 2012, 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.
 
 part of tree;
 
 abstract class Visitor<R> {
   const Visitor();
 
   R visitNode(Node node);
 
   R visitAssert(Assert node) => visitStatement(node);
   R visitAsyncForIn(AsyncForIn node) => visitLoop(node);
   R visitAsyncModifier(AsyncModifier node) => visitNode(node);
   R visitAwait(Await node) => visitExpression(node);
   R visitBlock(Block node) => visitStatement(node);
   R visitBreakStatement(BreakStatement node) => visitGotoStatement(node);
   R visitCascade(Cascade node) => visitExpression(node);
   R visitCascadeReceiver(CascadeReceiver node) => visitExpression(node);
   R visitCaseMatch(CaseMatch node) => visitNode(node);
   R visitCatchBlock(CatchBlock node) => visitNode(node);
   R visitClassNode(ClassNode node) => visitNode(node);
   R visitCombinator(Combinator node) => visitNode(node);
   R visitConditional(Conditional node) => visitExpression(node);
+  R visitConditionalUri(ConditionalUri node) => visitNode(node);
   R visitContinueStatement(ContinueStatement node) => visitGotoStatement(node);
+  R visitDottedName(DottedName node) => visitExpression(node);
   R visitDoWhile(DoWhile node) => visitLoop(node);
   R visitEmptyStatement(EmptyStatement node) => visitStatement(node);
   R visitEnum(Enum node) => visitNode(node);
   R visitExport(Export node) => visitLibraryDependency(node);
   R visitExpression(Expression node) => visitNode(node);
   R visitExpressionStatement(ExpressionStatement node) => visitStatement(node);
   R visitFor(For node) => visitLoop(node);
   R visitFunctionDeclaration(FunctionDeclaration node) => visitStatement(node);
   R visitFunctionExpression(FunctionExpression node) => visitExpression(node);
   R visitGotoStatement(GotoStatement node) => visitStatement(node);
   R visitIdentifier(Identifier node) => visitExpression(node);
+  R visitImport(Import node) => visitLibraryDependency(node);
   R visitIf(If node) => visitStatement(node);
-  R visitImport(Import node) => visitLibraryDependency(node);
   R visitLabel(Label node) => visitNode(node);
   R visitLabeledStatement(LabeledStatement node) => visitStatement(node);
   R visitLibraryDependency(LibraryDependency node) => visitLibraryTag(node);
   R visitLibraryName(LibraryName node) => visitLibraryTag(node);
   R visitLibraryTag(LibraryTag node) => visitNode(node);
   R visitLiteral(Literal node) => visitExpression(node);
   R visitLiteralBool(LiteralBool node) => visitLiteral(node);
   R visitLiteralDouble(LiteralDouble node) => visitLiteral(node);
   R visitLiteralInt(LiteralInt node) => visitLiteral(node);
   R visitLiteralList(LiteralList node) => visitExpression(node);
@@ skipping 103 matching lines @@
   Await asAwait() => null;
   Block asBlock() => null;
   BreakStatement asBreakStatement() => null;
   Cascade asCascade() => null;
   CascadeReceiver asCascadeReceiver() => null;
   CaseMatch asCaseMatch() => null;
   CatchBlock asCatchBlock() => null;
   ClassNode asClassNode() => null;
   Combinator asCombinator() => null;
   Conditional asConditional() => null;
+  ConditionalUri asConditionalUri() => null;
   ContinueStatement asContinueStatement() => null;
+  DottedName asDottedName() => null;
   DoWhile asDoWhile() => null;
   EmptyStatement asEmptyStatement() => null;
   Enum asEnum() => null;
   ErrorExpression asErrorExpression() => null;
   Export asExport() => null;
   Expression asExpression() => null;
   ExpressionStatement asExpressionStatement() => null;
   For asFor() => null;
   SyncForIn asSyncForIn() => null;
   AsyncForIn asAsyncForIn() => null;
@@ skipping 842 matching lines @@
   Token getBeginToken() {
     if (constKeyword != null) return constKeyword;
     return firstBeginToken(typeArguments, elements);
   }
 
   Token getEndToken() => elements.getEndToken();
 }
 
 class LiteralSymbol extends Expression {
   final Token hashToken;
+  // TODO: this could be a DottedNamed.
   final NodeList identifiers;
 
   LiteralSymbol(this.hashToken, this.identifiers);
 
   LiteralSymbol asLiteralSymbol() => this;
 
   void visitChildren(Visitor visitor) {
     if (identifiers != null) identifiers.accept(visitor);
   }
 
@@ skipping 25 matching lines @@
 
   accept(Visitor visitor) => visitor.visitIdentifier(this);
 
   visitChildren(Visitor visitor) {}
 
   Token getBeginToken() => token;
 
   Token getEndToken() => token;
 }
 
+// TODO(floitsch): a dotted identifier isn't really an expression. Should it
+// inherit from Node instead?
+class DottedName extends Expression {
+  final Token token;
+  final NodeList identifiers;
+
+  DottedName(this.token, this.identifiers);
+
+  DottedName asDottedName() => this;
+
+  void visitChildren(Visitor visitor) {
+    identifiers.accept(visitor);
+  }
+
+  accept(Visitor visitor) => visitor.visitDottedName(this);
+
+  Token getBeginToken() => token;
+  Token getEndToken() => identifiers.getEndToken();
+
+  String get slowNameString {
+    Unparser unparser = new Unparser();
+    unparser.unparseNodeListOfIdentifiers(identifiers);
+    return unparser.result;
+  }
+}
+
 class Operator extends Identifier {
   static const COMPLEX_OPERATORS =
       const ["--", "++", '+=', "-=", "*=", "/=", "%=", "&=", "|=", "~/=", "^=",
              ">>=", "<<=", "??="];
 
   static const INCREMENT_OPERATORS = const <String>["++", "--"];
 
   Operator(Token token) : super(token);
 
   Operator asOperator() => this;
@@ skipping 877 matching lines @@
   Token getEndToken() => name.getEndToken().next;
 }
 
 /**
  * This tag describes a dependency between one library and the exported
  * identifiers of another library. The other library is specified by the [uri].
  * Combinators filter away some identifiers from the other library.
  */
 abstract class LibraryDependency extends LibraryTag {
   final StringNode uri;
+  final NodeList conditionalUris;
   final NodeList combinators;
 
   LibraryDependency(this.uri,
+                    this.conditionalUris,
                     this.combinators,
                     List<MetadataAnnotation> metadata)
     : super(metadata);
 
   LibraryDependency asLibraryDependency() => this;
+
+  bool get hasConditionalUris => conditionalUris != null;
 }
 
 /**
  * An [:import:] library tag.
  *
  * An import tag is dependency on another library where the exported identifiers
  * are put into the import scope of the importing library. The import scope is
  * only visible inside the library.
  */
 class Import extends LibraryDependency {
   final Identifier prefix;
   final Token importKeyword;
   final bool isDeferred;
 
-  Import(this.importKeyword, StringNode uri,
+  Import(this.importKeyword, StringNode uri, NodeList conditionalUris,
          this.prefix, NodeList combinators,
          List<MetadataAnnotation> metadata,
          {this.isDeferred})
-      : super(uri, combinators, metadata);
+      : super(uri, conditionalUris, combinators, metadata);
 
   bool get isImport => true;
 
   Import asImport() => this;
 
   accept(Visitor visitor) => visitor.visitImport(this);
 
   visitChildren(Visitor visitor) {
     uri.accept(visitor);
     if (prefix != null) prefix.accept(visitor);
     if (combinators != null) combinators.accept(visitor);
   }
 
   Token getBeginToken() => importKeyword;
 
   Token getEndToken() {
     if (combinators != null) return combinators.getEndToken().next;
     if (prefix != null) return prefix.getEndToken().next;
+    if (conditionalUris != null) return conditionalUris.getEndToken().next;
     return uri.getEndToken().next;
   }
 }
 
 /**
+ * A conditional uri inside an import or export clause.
+ *
+ * Example:
+ *
+ *     import 'foo.dart'
+ *       if (some.condition == "someValue") 'bar.dart'
+ *       if (other.condition) 'gee.dart';
+ */
+class ConditionalUri extends Node {
+  final Token ifToken;
+  final DottedName key;
+  // Value may be null.
+  final LiteralString value;
+  final StringNode uri;
+
+  ConditionalUri(this.ifToken, this.key, this.value, this.uri);
+
+  ConditionalUri asConditionalUri() => this;
+
+  accept(Visitor visitor) => visitor.visitConditionalUri(this);
+
+  visitChildren(Visitor visitor) {
+    key.accept(visitor);
+    if (value != null) value.accept(visitor);
+    uri.accept(visitor);
+  }
+
+  Token getBeginToken() => ifToken;
+
+  Token getEndToken() => uri.getEndToken();
+}
+
+/**
  * An `enum` declaration.
  *
  * An `enum` defines a number of named constants inside a non-extensible class
  */
 class Enum extends Node {
   /** The name of the enum class. */
   final Identifier name;
   /** The names of the enum constants. */
   final NodeList names;
   final Token enumToken;
@@ skipping 18 matching lines @@
  *
  * An export tag is dependency on another library where the exported identifiers
  * are put into the export scope of the exporting library. The export scope is
  * not visible inside the library.
  */
 class Export extends LibraryDependency {
   final Token exportKeyword;
 
   Export(this.exportKeyword,
          StringNode uri,
+         NodeList conditionalUris,
          NodeList combinators,
          List<MetadataAnnotation> metadata)
-      : super(uri, combinators, metadata);
+      : super(uri, conditionalUris, combinators, metadata);
 
   bool get isExport => true;
 
   Export asExport() => this;
 
   accept(Visitor visitor) => visitor.visitExport(this);
 
   visitChildren(Visitor visitor) {
     uri.accept(visitor);
     if (combinators != null) combinators.accept(visitor);
   }
 
   Token getBeginToken() => exportKeyword;
 
   Token getEndToken() {
     if (combinators != null) return combinators.getEndToken().next;
+    if (conditionalUris != null) return conditionalUris.getEndToken().next;
     return uri.getEndToken().next;
   }
 }
 
 class Part extends LibraryTag {
   final StringNode uri;
 
   final Token partKeyword;
 
   Part(this.partKeyword, this.uri, List<MetadataAnnotation> metadata)
@@ skipping 289 matching lines @@
 
   // VariableDefinitions.
   get metadata => null;
   get type => null;
 
   // Typedef.
   get typeParameters => null;
   get formals => null;
   get typedefKeyword => null;
 }