Fix incremental parsing of import combinators.

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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
 import "dart:math" as math;
@@ skipping 243 matching lines @@
   'parseClassDeclaration_2': new MethodTrampoline(
       2,
       (Parser target, arg0, arg1) => target._parseClassDeclaration(arg0, arg1)),
   'parseClassMembers_2': new MethodTrampoline(
       2,
       (Parser target, arg0, arg1) => target._parseClassMembers(arg0, arg1)),
   'parseClassTypeAlias_3': new MethodTrampoline(
       3,
       (Parser target, arg0, arg1, arg2) =>
           target._parseClassTypeAlias(arg0, arg1, arg2)),
+  'parseCombinator_0': new MethodTrampoline(
+      0,
+      (Parser target) => target.parseCombinator()),
   '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(
@@ skipping 965 matching lines @@
   AstNode visitImportDirective(ImportDirective node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.uri)) {
       return _parser.parseStringLiteral();
     } else if (identical(_oldNode, node.prefix)) {
       return _parser.parseSimpleIdentifier();
     } else if (node.combinators.contains(_oldNode)) {
-      throw new IncrementalParseException();
-      //return parser.parseCombinator();
+      return _parser.parseCombinator();

[Brian Wilkerson, 2014/11/26 14:44:38]

Does this handle the case where one combinator is split into two? For example:

import 'foo.dart' show A;

import 'foo.dart' show B, hide A;

It looks like it would only parse one of the two combinators.

[Paul Berry, 2014/11/26 16:08:38]

Yes, it works correctly.  Note: I'm assuming you mean "import 'foo.dart' show B
hide A;".  ',' is only allowed between identifiers within a combinator, not
between combinators.

You are correct that the call to _parser.parseCombinator() only parses one of
the combinators, but that's not a problem, because when the result is returned
to IncrementalParser.reparse(), the first thing it does is to check that the new
node can replace the old node without gaining or losing tokens.  In this case,
it can't, because if "show A" is replaced by "show B", the tokens "hide A" will
be lost.  So it sets advanceToParent = true and tries again at the next level up
the parse tree.

Having said that, your example seems valuable to explicitly test.  I'll add that
test in a follow up CL.

     }
     return _notAChild(node);
   }
 
   @override
   AstNode visitIndexExpression(IndexExpression node) {
     if (identical(_oldNode, node.target)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.index)) {
       return _parser.parseExpression2();
@@ skipping 666 matching lines @@
             new IncrementalParseDispatcher(parser, oldNode);
         IncrementalParseStateBuilder contextBuilder =
             new IncrementalParseStateBuilder(parser);
         contextBuilder.buildState(oldNode);
         newNode = parent.accept(dispatcher);
         //
         // Validate that the new node can replace the old node.
         //
         Token mappedToken = _tokenMap.get(oldNode.endToken.next);
         if (mappedToken == null ||
+            newNode == null ||
             mappedToken.offset != newNode.endToken.next.offset ||
             newNode.offset != oldNode.offset) {
           advanceToParent = true;
         }
       } on InsufficientContextException catch (exception) {
         advanceToParent = true;
       } catch (exception) {
         return null;
       }
       if (advanceToParent) {
@@ skipping 932 matching lines @@
           type);
     }
     return _parseInitializedIdentifierList(
         commentAndMetadata,
         modifiers.staticKeyword,
         _validateModifiersForField(modifiers),
         type);
   }
 
   /**
+   * Parse a single import combinator.  If no combinator is found, return
+   * `null`.
+   *
+   * <pre>
+   * combinator ::=
+   *     'show' identifier (',' identifier)*
+   *   | 'hide' identifier (',' identifier)*
+   * </pre>
+   */
+  Combinator parseCombinator() {
+    if (_matchesString(_SHOW) || _matchesString(_HIDE)) {
+      Token keyword = andAdvance;
+      List<SimpleIdentifier> names = _parseIdentifierList();
+      if (keyword.lexeme == _SHOW) {
+        return new ShowCombinator(keyword, names);
+      } else {
+        return new HideCombinator(keyword, names);
+      }
+    }
+    return null;
+  }
+
+  /**
    * Parse a compilation unit, starting with the given token.
    *
    * @param token the first token of the compilation unit
    * @return the compilation unit that was parsed
    */
   CompilationUnit parseCompilationUnit(Token token) {
     InstrumentationBuilder instrumentation =
         Instrumentation.builder2("dart.engine.Parser.parseCompilationUnit");
     try {
       _currentToken = token;
@@ skipping 2400 matching lines @@
    * <pre>
    * combinator ::=
    *     'show' identifier (',' identifier)*
    *   | 'hide' identifier (',' identifier)*
    * </pre>
    *
    * @return the combinators that were parsed
    */
   List<Combinator> _parseCombinators() {
     List<Combinator> combinators = new List<Combinator>();
-    while (_matchesString(_SHOW) || _matchesString(_HIDE)) {
-      Token keyword = _expect(TokenType.IDENTIFIER);
-      if (keyword.lexeme == _SHOW) {
-        List<SimpleIdentifier> shownNames = _parseIdentifierList();
-        combinators.add(new ShowCombinator(keyword, shownNames));
-      } else {
-        List<SimpleIdentifier> hiddenNames = _parseIdentifierList();
-        combinators.add(new HideCombinator(keyword, hiddenNames));
+    while (true) {
+      Combinator combinator = parseCombinator();
+      if (combinator == null) {
+        break;
       }
+      combinators.add(combinator);
     }
     return combinators;
   }
 
   /**
    * Parse the documentation comment and metadata preceding a declaration. This method allows any
    * number of documentation comments to occur before, after or between the metadata, but only
    * returns the last (right-most) documentation comment that is found.
    *
    * <pre>
@@ skipping 6690 matching lines @@
    * Copy resolution data from one node to another.
    *
    * @param fromNode the node from which resolution information will be copied
    * @param toNode the node to which resolution information will be copied
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }