Lexical support for configurable imports (DEP 40)

pkg/analyzer/lib/src/generated/parser.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.parser;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'ast.dart';
@@ skipping 178 matching lines @@
   'parseCombinators_0':
       new MethodTrampoline(0, (Parser target) => target._parseCombinators()),
   'parseCommentAndMetadata_0': new MethodTrampoline(
       0, (Parser target) => target._parseCommentAndMetadata()),
   'parseCommentReference_2': new MethodTrampoline(2,
       (Parser target, arg0, arg1) => target._parseCommentReference(arg0, arg1)),
   'parseCommentReferences_1': new MethodTrampoline(
       1, (Parser target, arg0) => target._parseCommentReferences(arg0)),
   'parseCompilationUnitMember_1': new MethodTrampoline(
       1, (Parser target, arg0) => target._parseCompilationUnitMember(arg0)),
+  'parseConfiguration_0':
+      new MethodTrampoline(0, (Parser target) => target._parseConfiguration()),
   'parseConstExpression_0': new MethodTrampoline(
       0, (Parser target) => target._parseConstExpression()),
   'parseConstructor_8': new MethodTrampoline(
       8,
       (Parser target, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) => target
           ._parseConstructor(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)),
   'parseConstructorFieldInitializer_0': new MethodTrampoline(
       0, (Parser target) => target._parseConstructorFieldInitializer()),
   'parseContinueStatement_0': new MethodTrampoline(
       0, (Parser target) => target._parseContinueStatement()),
   'parseDirective_1': new MethodTrampoline(
       1, (Parser target, arg0) => target._parseDirective(arg0)),
   'parseDirectives_0':
       new MethodTrampoline(0, (Parser target) => target._parseDirectives()),
   'parseDocumentationComment_0': new MethodTrampoline(
       0, (Parser target) => target._parseDocumentationComment()),
   'parseDoStatement_0':
       new MethodTrampoline(0, (Parser target) => target._parseDoStatement()),
+  'parseDottedName_0':
+      new MethodTrampoline(0, (Parser target) => target._parseDottedName()),
   'parseEmptyStatement_0':
       new MethodTrampoline(0, (Parser target) => target._parseEmptyStatement()),
   'parseEnumConstantDeclaration_0': new MethodTrampoline(
       0, (Parser target) => target._parseEnumConstantDeclaration()),
   'parseEnumDeclaration_1': new MethodTrampoline(
       1, (Parser target, arg0) => target._parseEnumDeclaration(arg0)),
   'parseEqualityExpression_0': new MethodTrampoline(
       0, (Parser target) => target._parseEqualityExpression()),
   'parseExportDirective_1': new MethodTrampoline(
       1, (Parser target, arg0) => target._parseExportDirective(arg0)),
@@ skipping 511 matching lines @@
       return _parser.parseIfNullExpression();
     } else if (identical(_oldNode, node.thenExpression)) {
       return _parser.parseExpressionWithoutCascade();
     } else if (identical(_oldNode, node.elseExpression)) {
       return _parser.parseExpressionWithoutCascade();
     }
     return _notAChild(node);
   }
 
   @override
+  AstNode visitConfiguration(Configuration node) {
+    if (identical(_oldNode, node.name)) {
+      throw new InsufficientContextException();
+    } else if (identical(_oldNode, node.value)) {
+      return _parser.parseStringLiteral();
+    } else if (identical(_oldNode, node.libraryUri)) {
+      return _parser.parseStringLiteral();
+    }
+    return _notAChild(node);
+  }
+
+  @override
   AstNode visitConstructorDeclaration(ConstructorDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.name)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.parameters)) {
@@ skipping 64 matching lines @@
   AstNode visitDoStatement(DoStatement node) {
     if (identical(_oldNode, node.body)) {
       return _parser.parseStatement2();
     } else if (identical(_oldNode, node.condition)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
   @override
+  AstNode visitDottedName(DottedName node) {
+    if (node.components.contains(_oldNode)) {
+      throw new InsufficientContextException();
+    }
+    return _notAChild(node);
+  }
+
+  @override
   AstNode visitDoubleLiteral(DoubleLiteral node) => _notAChild(node);
 
   @override
   AstNode visitEmptyFunctionBody(EmptyFunctionBody node) => _notAChild(node);
 
   @override
   AstNode visitEmptyStatement(EmptyStatement node) => _notAChild(node);
 
   @override
   AstNode visitEnumConstantDeclaration(EnumConstantDeclaration node) {
@@ skipping 1269 matching lines @@
    */
   bool _inSwitch = false;
 
   /**
    * A flag indicating whether the parser is currently in a constructor field
    * initializer, with no intervening parens, braces, or brackets.
    */
   bool _inInitializer = false;
 
   /**
+   * A flag indicating whether the parser is to parse conditional directives
+   * syntax.
+   */
+  bool parseConditionalDirectives = false;
+
+  /**
    * A flag indicating whether the parser is to parse generic method syntax.
    */
   bool parseGenericMethods = false;
 
   /**
    * Initialize a newly created parser to parse the content of the given
    * [_source] and to report any errors that are found to the given
    * [_errorListener].
    */
   Parser(this._source, this._errorListener);
@@ skipping 3083 matching lines @@
     }
     return new TopLevelVariableDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         _parseVariableDeclarationListAfterType(
             null, _validateModifiersForTopLevelVariable(modifiers), returnType),
         _expect(TokenType.SEMICOLON));
   }
 
   /**
+   * Parse a configuration in either an import or export directive.
+   *
+   *     configuration ::=
+   *         'if' '(' test ')' uri
+   *
+   *     test ::=
+   *         dottedName ('==' stringLiteral)?
+   *
+   *     dottedName ::=
+   *         identifier ('.' identifier)*
+   */
+  Configuration _parseConfiguration() {
+    Token ifKeyword = _expectKeyword(Keyword.IF);
+    Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
+    DottedName name = _parseDottedName();
+    Token equalToken = null;
+    StringLiteral value = null;
+    if (_matches(TokenType.EQ_EQ)) {
+      equalToken = getAndAdvance();
+      value = parseStringLiteral();

[Bob Nystrom, 2015/10/22 00:24:47]

This will allow interpolation, right? The proposal forbids that, but if you
report that error later, I suppose that's fine too.

[Brian Wilkerson, 2015/10/22 02:33:42]

Good catch. Yes, it will allow string interpolation. The analyzer's parser
excepts a superset of the Dart language, then adds warnings where appropriate.
(In this case, I have added one here.)

+    }
+    Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
+    StringLiteral libraryUri = _parseUri();
+    return new Configuration(ifKeyword, leftParenthesis, name, equalToken,
+        value, rightParenthesis, libraryUri);
+  }
+
+  /**
+   * Parse a list of configurations. If conditional directives are not
+   * supported, return an empty list without attempting to parse anything.
+   */
+  List<Configuration> _parseConfigurations() {
+    List<Configuration> configurations = <Configuration>[];
+    if (parseConditionalDirectives) {
+      while (_matchesKeyword(Keyword.IF)) {
+        Configuration configuration = _parseConfiguration();
+        if (configuration != null) {

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

This is unnecessarily defensive.  _parseConfiguration() can never return null.

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

Done

+          configurations.add(configuration);
+        }
+      }
+    }
+    return configurations;
+  }
+
+  /**
    * Parse a const expression. Return the const expression that was parsed.
    *
    *     constExpression ::=
    *         instanceCreationExpression
    *       | listLiteral
    *       | mapLiteral
    */
   Expression _parseConstExpression() {
     Token keyword = _expectKeyword(Keyword.CONST);
     if (_matches(TokenType.OPEN_SQUARE_BRACKET) || _matches(TokenType.INDEX)) {
@@ skipping 295 matching lines @@
       Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
       Token semicolon = _expect(TokenType.SEMICOLON);
       return new DoStatement(doKeyword, body, whileKeyword, leftParenthesis,
           condition, rightParenthesis, semicolon);
     } finally {
       _inLoop = wasInLoop;
     }
   }
 
   /**
+   * Parse a dotted name. Return the dotted name that was parsed.
+   *
+   *     dottedName ::=
+   *         identifier ('.' identifier)*
+   */
+  DottedName _parseDottedName() {
+    List<SimpleIdentifier> components = new List<SimpleIdentifier>();
+    components.add(parseSimpleIdentifier());
+    while (_matches(TokenType.PERIOD)) {
+      _advance();
+      components.add(parseSimpleIdentifier());
+    }
+    return new DottedName(components);
+  }
+
+  /**
    * Parse an empty statement. Return the empty statement that was parsed.
    *
    *     emptyStatement ::=
    *         ';'
    */
   Statement _parseEmptyStatement() => new EmptyStatement(getAndAdvance());
 
   EnumConstantDeclaration _parseEnumConstantDeclaration() {
     CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
     SimpleIdentifier name;
@@ skipping 86 matching lines @@
       leftEqualityExpression = true;
     }
     return expression;
   }
 
   /**
    * Parse an export directive. The [commentAndMetadata] is the metadata to be
    * associated with the directive. Return the export directive that was parsed.
    *
    *     exportDirective ::=
-   *         metadata 'export' stringLiteral combinator*';'
+   *         metadata 'export' stringLiteral configuration* combinator*';'
    */
   ExportDirective _parseExportDirective(CommentAndMetadata commentAndMetadata) {
     Token exportKeyword = _expectKeyword(Keyword.EXPORT);
     StringLiteral libraryUri = _parseUri();
+    List<Configuration> configurations = _parseConfigurations();
     List<Combinator> combinators = _parseCombinators();
     Token semicolon = _expectSemicolon();
     return new ExportDirective(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         exportKeyword,
         libraryUri,
+        configurations,
         combinators,
         semicolon);
   }
 
   /**
    * Parse a list of expressions. Return the expression that was parsed.
    *
    *     expressionList ::=
    *         expression (',' expression)*
    */
@@ skipping 596 matching lines @@
     }
     return new IfStatement(ifKeyword, leftParenthesis, condition,
         rightParenthesis, thenStatement, elseKeyword, elseStatement);
   }
 
   /**
    * Parse an import directive. The [commentAndMetadata] is the metadata to be
    * associated with the directive. Return the import directive that was parsed.
    *
    *     importDirective ::=
-   *         metadata 'import' stringLiteral (deferred)? ('as' identifier)? combinator*';'
+   *         metadata 'import' stringLiteral configuration* (deferred)? ('as' identifier)? combinator*';'
    */
   ImportDirective _parseImportDirective(CommentAndMetadata commentAndMetadata) {
     Token importKeyword = _expectKeyword(Keyword.IMPORT);
     StringLiteral libraryUri = _parseUri();
+    List<Configuration> configurations = _parseConfigurations();
     Token deferredToken = null;
     Token asToken = null;
     SimpleIdentifier prefix = null;
     if (_matchesKeyword(Keyword.DEFERRED)) {
       deferredToken = getAndAdvance();
     }
     if (_matchesKeyword(Keyword.AS)) {
       asToken = getAndAdvance();
       prefix = parseSimpleIdentifier();
     } else if (deferredToken != null) {
@@ skipping 15 matching lines @@
         }
       }
     }
     List<Combinator> combinators = _parseCombinators();
     Token semicolon = _expectSemicolon();
     return new ImportDirective(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         importKeyword,
         libraryUri,
+        configurations,
         deferredToken,
         asToken,
         prefix,
         combinators,
         semicolon);
   }
 
   /**
    * Parse a list of initialized identifiers. The [commentAndMetadata] is the
    * documentation comment and metadata to be associated with the declaration.
@@ skipping 3603 matching lines @@
         _isEqualTokens(node.colon, toNode.colon),
         _isEqualNodes(node.elseExpression, toNode.elseExpression))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
   @override
+  bool visitConfiguration(Configuration node) {
+    Configuration toNode = this._toNode as Configuration;
+    if (_and(
+        _isEqualTokens(node.ifKeyword, toNode.ifKeyword),
+        _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis),
+        _isEqualNodes(node.name, toNode.name),
+        _isEqualTokens(node.equalToken, toNode.equalToken),
+        _isEqualNodes(node.value, toNode.value),
+        _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis),
+        _isEqualNodes(node.libraryUri, toNode.libraryUri))) {
+      return true;
+    }
+    return false;
+  }
+
+  @override
   bool visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorDeclaration toNode = this._toNode as ConstructorDeclaration;
     if (_and(
         _isEqualNodes(node.documentationComment, toNode.documentationComment),
         _isEqualNodeLists(node.metadata, toNode.metadata),
         _isEqualTokens(node.externalKeyword, toNode.externalKeyword),
         _isEqualTokens(node.constKeyword, toNode.constKeyword),
         _isEqualTokens(node.factoryKeyword, toNode.factoryKeyword),
         _isEqualNodes(node.returnType, toNode.returnType),
         _isEqualTokens(node.period, toNode.period),
@@ skipping 75 matching lines @@
         _isEqualTokens(node.doKeyword, toNode.doKeyword),
         _isEqualNodes(node.body, toNode.body),
         _isEqualTokens(node.whileKeyword, toNode.whileKeyword),
         _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis),
         _isEqualNodes(node.condition, toNode.condition),
         _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis),
         _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
   @override
+  bool visitDottedName(DottedName node) {
+    DottedName toNode = this._toNode as DottedName;
+    return _isEqualNodeLists(node.components, toNode.components);
+  }
+
+  @override
   bool visitDoubleLiteral(DoubleLiteral node) {
     DoubleLiteral toNode = this._toNode as DoubleLiteral;
     if (_and(_isEqualTokens(node.literal, toNode.literal),
         node.value == toNode.value)) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
@@ skipping 1012 matching lines @@
   }
 
   /**
    * Copy resolution data from the [fromNode] to the [toNode].
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }