Enable enum and deferred import support

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 1094 matching lines @@
       //return parser.parseDeclaredIdentifier();
     } else if (identical(_oldNode, node.identifier)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.body)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
   @override
-  AstNode visitFormalParameterList(FormalParameterList node) {
-    // We don't know which kind of parameter to parse.
-    throw new InsufficientContextException();
-  }
-
-  @override
   AstNode visitForStatement(ForStatement node) {
     if (identical(_oldNode, node.variables)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.initialization)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.condition)) {
       return _parser.parseExpression2();
     } else if (node.updaters.contains(_oldNode)) {
       return _parser.parseExpression2();
     } else if (identical(_oldNode, node.body)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
   @override
+  AstNode visitFormalParameterList(FormalParameterList node) {
+    // We don't know which kind of parameter to parse.
+    throw new InsufficientContextException();
+  }
+
+  @override
   AstNode visitFunctionDeclaration(FunctionDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       return _parser.parseReturnType();
     } else if (identical(_oldNode, node.name)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.functionExpression)) {
@@ skipping 328 matching lines @@
 
   @override
   AstNode visitPostfixExpression(PostfixExpression node) {
     if (identical(_oldNode, node.operand)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
   @override
+  AstNode visitPrefixExpression(PrefixExpression node) {
+    if (identical(_oldNode, node.operand)) {
+      throw new InsufficientContextException();
+    }
+    return _notAChild(node);
+  }
+
+  @override
   AstNode visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (identical(_oldNode, node.prefix)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.identifier)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
-
-  @override
-  AstNode visitPrefixExpression(PrefixExpression node) {
-    if (identical(_oldNode, node.operand)) {
-      throw new InsufficientContextException();
-    }
-    return _notAChild(node);
-  }
 
   @override
   AstNode visitPropertyAccess(PropertyAccess node) {
     if (identical(_oldNode, node.target)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.propertyName)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
@@ skipping 307 matching lines @@
 
   /**
    * Initialize a newly created exception to have no message and to have the given cause.
    *
    * @param cause the exception that caused this exception
    */
   IncrementalParseException.con2(Exception cause) : super(cause: cause);
 }
 
 /**
+ * Visitor capable of inferring the correct parser state for incremental
+ * parsing.  This visitor visits each parent/child relationship in the chain of
+ * ancestors of the node to be replaced (starting with the root of the parse
+ * tree), updating the parser to the correct state for parsing the child of the
+ * given parent.  Once it has visited all of these relationships, the parser
+ * will be in the correct state for reparsing the node to be replaced.
+ *
+ * TODO(paulberry): add support for other pieces of parser state (_inAsync,
+ * _inGenerator, _inLoop, and _inSwitch).  Note that _inLoop and _inSwitch only
+ * affect error message generation.
+ */
+class IncrementalParseStateBuilder extends SimpleAstVisitor {
+  /**
+   * The parser whose state should be built.
+   */
+  final Parser _parser;
+
+  /**
+   * The child node in the parent/child relationship currently being visited.
+   * (The corresponding parent is the node passed to the visit...() function.)
+   */
+  AstNode _childNode;
+
+  /**
+   * Create an IncrementalParseStateBuilder which will build the correct state
+   * for [_parser].
+   */
+  IncrementalParseStateBuilder(this._parser);
+
+  /**
+   * Build the correct parser state for parsing a replacement for [node].
+   */
+  void buildState(AstNode node) {
+    List<AstNode> ancestors = <AstNode>[];
+    while (node != null) {
+      ancestors.add(node);
+      node = node.parent;
+    }
+    _parser._inInitializer = false;
+    for (int i = ancestors.length - 2; i >= 0; i--) {
+      _childNode = ancestors[i];
+      ancestors[i + 1].accept(this);
+    }
+  }
+
+  @override
+  void visitArgumentList(ArgumentList node) {
+    _parser._inInitializer = false;
+  }
+
+  @override
+  void visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
+    if (identical(_childNode, node.expression)) {
+      _parser._inInitializer = true;
+    }
+  }
+
+  @override
+  void visitIndexExpression(IndexExpression node) {
+    if (identical(_childNode, node.index)) {
+      _parser._inInitializer = false;
+    }
+  }
+
+  @override
+  void visitInterpolationExpression(InterpolationExpression node) {
+    if (identical(_childNode, node.expression)) {
+      _parser._inInitializer = false;
+    }
+  }
+
+  @override
+  void visitListLiteral(ListLiteral node) {
+    if (node.elements.contains(_childNode)) {
+      _parser._inInitializer = false;
+    }
+  }
+
+  @override
+  void visitMapLiteral(MapLiteral node) {
+    if (node.entries.contains(_childNode)) {
+      _parser._inInitializer = false;
+    }
+  }
+
+  @override
+  void visitParenthesizedExpression(ParenthesizedExpression node) {
+    if (identical(_childNode, node.expression)) {
+      _parser._inInitializer = false;
+    }
+  }
+}
+
+/**
  * Instances of the class `IncrementalParser` re-parse a single AST structure within a larger
  * AST structure.
  */
 class IncrementalParser {
   /**
    * The source being parsed.
    */
   final Source _source;
 
   /**
@@ skipping 157 matching lines @@
    */
   Token _findTokenAt(Token firstToken, int offset) {
     while (firstToken.offset > offset && firstToken.type != TokenType.EOF) {
       firstToken = firstToken.previous;
     }
     return firstToken;
   }
 }
 
 /**
- * Visitor capable of inferring the correct parser state for incremental
- * parsing.  This visitor visits each parent/child relationship in the chain of
- * ancestors of the node to be replaced (starting with the root of the parse
- * tree), updating the parser to the correct state for parsing the child of the
- * given parent.  Once it has visited all of these relationships, the parser
- * will be in the correct state for reparsing the node to be replaced.
- *
- * TODO(paulberry): add support for other pieces of parser state (_inAsync,
- * _inGenerator, _inLoop, and _inSwitch).  Note that _inLoop and _inSwitch only
- * affect error message generation.
- */
-class IncrementalParseStateBuilder extends SimpleAstVisitor {
-  /**
-   * The parser whose state should be built.
-   */
-  final Parser _parser;
-
-  /**
-   * The child node in the parent/child relationship currently being visited.
-   * (The corresponding parent is the node passed to the visit...() function.)
-   */
-  AstNode _childNode;
-
-  /**
-   * Create an IncrementalParseStateBuilder which will build the correct state
-   * for [_parser].
-   */
-  IncrementalParseStateBuilder(this._parser);
-
-  /**
-   * Build the correct parser state for parsing a replacement for [node].
-   */
-  void buildState(AstNode node) {
-    List<AstNode> ancestors = <AstNode>[];
-    while (node != null) {
-      ancestors.add(node);
-      node = node.parent;
-    }
-    _parser._inInitializer = false;
-    for (int i = ancestors.length - 2; i >= 0; i--) {
-      _childNode = ancestors[i];
-      ancestors[i + 1].accept(this);
-    }
-  }
-
-  @override
-  void visitArgumentList(ArgumentList node) {
-    _parser._inInitializer = false;
-  }
-
-  @override
-  void visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
-    if (identical(_childNode, node.expression)) {
-      _parser._inInitializer = true;
-    }
-  }
-
-  @override
-  void visitIndexExpression(IndexExpression node) {
-    if (identical(_childNode, node.index)) {
-      _parser._inInitializer = false;
-    }
-  }
-
-  @override
-  void visitInterpolationExpression(InterpolationExpression node) {
-    if (identical(_childNode, node.expression)) {
-      _parser._inInitializer = false;
-    }
-  }
-
-  @override
-  void visitListLiteral(ListLiteral node) {
-    if (node.elements.contains(_childNode)) {
-      _parser._inInitializer = false;
-    }
-  }
-
-  @override
-  void visitMapLiteral(MapLiteral node) {
-    if (node.entries.contains(_childNode)) {
-      _parser._inInitializer = false;
-    }
-  }
-
-  @override
-  void visitParenthesizedExpression(ParenthesizedExpression node) {
-    if (identical(_childNode, node.expression)) {
-      _parser._inInitializer = false;
-    }
-  }
-}
-
-/**
  * Instances of the class `InsufficientContextException` represent a situation in which an AST
  * node cannot be re-parsed because there is not enough context to know how to re-parse the node.
  * Clients can attempt to re-parse the parent of the node.
  */
 class InsufficientContextException extends IncrementalParseException {
   /**
    * Initialize a newly created exception to have no message and to be its own cause.
    */
   InsufficientContextException() : super();
 
@@ skipping 156 matching lines @@
    * An [errorListener] lock, if more than `0`, then errors are not reported.
    */
   int _errorListenerLock = 0;
 
   /**
    * A flag indicating whether parser is to parse function bodies.
    */
   bool _parseFunctionBodies = true;
 
   /**
-   * A flag indicating whether the parser is to parse deferred libraries.
-   */
-  bool _parseDeferredLibraries =
-      AnalysisOptionsImpl.DEFAULT_ENABLE_DEFERRED_LOADING;
-
-  /**
-   * A flag indicating whether the parser is to parse enum declarations.
-   */
-  bool _parseEnum = AnalysisOptionsImpl.DEFAULT_ENABLE_ENUM;
-
-  /**
    * The next token to be parsed.
    */
   Token _currentToken;
 
   /**
    * A flag indicating whether the parser is currently in a function body marked as being 'async'.
    */
   bool _inAsync = false;
 
   /**
@@ skipping 24 matching lines @@
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during the parse
    */
   Parser(this._source, this._errorListener);
 
   void set currentToken(Token currentToken) {
     this._currentToken = currentToken;
   }
 
   /**
-   * Advance to the next token in the token stream, making it the new current
-   * token and return the token that was current before this method was invoked.
-   */
-  Token getAndAdvance() {
-    Token token = _currentToken;
-    _advance();
-    return token;
-  }
-
-  /**
    * Return `true` if the current token is the first token of a return type that is followed
    * by an identifier, possibly followed by a list of type parameters, followed by a
    * left-parenthesis. This is used by parseTypeAlias to determine whether or not to parse a return
    * type.
    *
    * @return `true` if we can successfully parse the rest of a type alias if we first parse a
    *         return type.
    */
   bool get hasReturnTypeInTypeAlias {
     Token next = _skipReturnType(_currentToken);
     if (next == null) {
       return false;
     }
     return _tokenMatchesIdentifier(next);
   }
 
   /**
+   * Set whether the parser is to parse the async support.
+   *
+   * @param parseAsync `true` if the parser is to parse the async support
+   */
+  void set parseAsync(bool parseAsync) {
+    // Async support cannot be disabled
+  }
+
+  /**
    * Set whether the parser is to parse deferred libraries.
    *
    * @param parseDeferredLibraries `true` if the parser is to parse deferred libraries
    */
   void set parseDeferredLibraries(bool parseDeferredLibraries) {
-    this._parseDeferredLibraries = parseDeferredLibraries;
+    // Deferred libraries support cannot be disabled
   }
 
   /**
    * Set whether the parser is to parse enum declarations.
    *
    * @param parseEnum `true` if the parser is to parse enum declarations
    */
   void set parseEnum(bool parseEnum) {
-    this._parseEnum = parseEnum;
+    // Enum support cannot be disabled
   }
 
   /**
    * Set whether parser is to parse function bodies.
    *
    * @param parseFunctionBodies `true` if parser is to parse function bodies
    */
   void set parseFunctionBodies(bool parseFunctionBodies) {
     this._parseFunctionBodies = parseFunctionBodies;
   }
 
   /**
+   * Advance to the next token in the token stream, making it the new current
+   * token and return the token that was current before this method was invoked.
+   */
+  Token getAndAdvance() {
+    Token token = _currentToken;
+    _advance();
+    return token;
+  }
+
+  /**
    * Parse an annotation.
    *
    * <pre>
    * annotation ::=
    *     '@' qualified ('.' identifier)? arguments?
    * </pre>
    *
    * @return the annotation that was parsed
    */
   Annotation parseAnnotation() {
@@ skipping 3127 matching lines @@
     if (_matchesKeyword(Keyword.CLASS)) {
       return _parseClassDeclaration(
           commentAndMetadata,
           _validateModifiersForClass(modifiers));
     } else if (_matchesKeyword(Keyword.TYPEDEF) &&
         !_tokenMatches(_peek(), TokenType.PERIOD) &&
         !_tokenMatches(_peek(), TokenType.LT) &&
         !_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
       _validateModifiersForTypedef(modifiers);
       return _parseTypeAlias(commentAndMetadata);
-    } else if (_parseEnum && _matchesKeyword(Keyword.ENUM)) {
+    } else if (_matchesKeyword(Keyword.ENUM)) {
       _validateModifiersForEnum(modifiers);
       return _parseEnumDeclaration(commentAndMetadata);
     }
     if (_matchesKeyword(Keyword.VOID)) {
       TypeName returnType = parseReturnType();
       if ((_matchesKeyword(Keyword.GET) || _matchesKeyword(Keyword.SET)) &&
           _tokenMatchesIdentifier(_peek())) {
         _validateModifiersForTopLevelFunction(modifiers);
         return _parseFunctionDeclaration(
             commentAndMetadata,
@@ skipping 437 matching lines @@
     }
     return new CompilationUnit(
         firstToken,
         scriptTag,
         directives,
         new List<CompilationUnitMember>(),
         _currentToken);
   }
 
   /**
+   * Parse a do statement.
+   *
+   * <pre>
+   * doStatement ::=
+   *     'do' statement 'while' '(' expression ')' ';'
+   * </pre>
+   *
+   * @return the do statement that was parsed
+   */
+  Statement _parseDoStatement() {
+    bool wasInLoop = _inLoop;
+    _inLoop = true;
+    try {
+      Token doKeyword = _expectKeyword(Keyword.DO);
+      Statement body = parseStatement2();
+      Token whileKeyword = _expectKeyword(Keyword.WHILE);
+      Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
+      Expression condition = parseExpression2();
+      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 documentation comment.
    *
    * <pre>
    * documentationComment ::=
    *     multiLineComment?
    *   | singleLineComment*
    * </pre>
    *
    * @return the documentation comment that was parsed, or `null` if there was no comment
    */
@@ skipping 21 matching lines @@
       return null;
     }
     List<CommentReference> references =
         _parseCommentReferences(documentationTokens);
     return Comment.createDocumentationCommentWithReferences(
         documentationTokens,
         references);
   }
 
   /**
-   * Parse a do statement.
-   *
-   * <pre>
-   * doStatement ::=
-   *     'do' statement 'while' '(' expression ')' ';'
-   * </pre>
-   *
-   * @return the do statement that was parsed
-   */
-  Statement _parseDoStatement() {
-    bool wasInLoop = _inLoop;
-    _inLoop = true;
-    try {
-      Token doKeyword = _expectKeyword(Keyword.DO);
-      Statement body = parseStatement2();
-      Token whileKeyword = _expectKeyword(Keyword.WHILE);
-      Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
-      Expression condition = parseExpression2();
-      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 an empty statement.
    *
    * <pre>
    * emptyStatement ::=
    *     ';'
    * </pre>
    *
    * @return the empty statement that was parsed
    */
   Statement _parseEmptyStatement() => new EmptyStatement(getAndAdvance());
@@ skipping 171 matching lines @@
         type = parseReturnType();
       } else if (!optional) {
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
       }
     }
     return new FinalConstVarOrType(keyword, type);
   }
 
   /**
-   * Parse a formal parameter. At most one of `isOptional` and `isNamed` can be
-   * `true`.
-   *
-   * <pre>
-   * defaultFormalParameter ::=
-   *     normalFormalParameter ('=' expression)?
-   *
-   * defaultNamedParameter ::=
-   *     normalFormalParameter (':' expression)?
-   * </pre>
-   *
-   * @param kind the kind of parameter being expected based on the presence or absence of group
-   *          delimiters
-   * @return the formal parameter that was parsed
-   */
-  FormalParameter _parseFormalParameter(ParameterKind kind) {
-    NormalFormalParameter parameter = parseNormalFormalParameter();
-    if (_matches(TokenType.EQ)) {
-      Token seperator = getAndAdvance();
-      Expression defaultValue = parseExpression2();
-      if (kind == ParameterKind.NAMED) {
-        _reportErrorForToken(
-            ParserErrorCode.WRONG_SEPARATOR_FOR_NAMED_PARAMETER,
-            seperator);
-      } else if (kind == ParameterKind.REQUIRED) {
-        _reportErrorForNode(
-            ParserErrorCode.POSITIONAL_PARAMETER_OUTSIDE_GROUP,
-            parameter);
-      }
-      return new DefaultFormalParameter(
-          parameter,
-          kind,
-          seperator,
-          defaultValue);
-    } else if (_matches(TokenType.COLON)) {
-      Token seperator = getAndAdvance();
-      Expression defaultValue = parseExpression2();
-      if (kind == ParameterKind.POSITIONAL) {
-        _reportErrorForToken(
-            ParserErrorCode.WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER,
-            seperator);
-      } else if (kind == ParameterKind.REQUIRED) {
-        _reportErrorForNode(
-            ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP,
-            parameter);
-      }
-      return new DefaultFormalParameter(
-          parameter,
-          kind,
-          seperator,
-          defaultValue);
-    } else if (kind != ParameterKind.REQUIRED) {
-      return new DefaultFormalParameter(parameter, kind, null, null);
-    }
-    return parameter;
-  }
-
-  /**
    * Parse a for statement.
    *
    * <pre>
    * forStatement ::=
    *     'for' '(' forLoopParts ')' statement
    *
    * forLoopParts ::=
    *     forInitializerStatement expression? ';' expressionList?
    *   | declaredIdentifier 'in' expression
    *   | identifier 'in' expression
@@ skipping 131 matching lines @@
           rightSeparator,
           updaters,
           rightParenthesis,
           body);
     } finally {
       _inLoop = wasInLoop;
     }
   }
 
   /**
+   * Parse a formal parameter. At most one of `isOptional` and `isNamed` can be
+   * `true`.
+   *
+   * <pre>
+   * defaultFormalParameter ::=
+   *     normalFormalParameter ('=' expression)?
+   *
+   * defaultNamedParameter ::=
+   *     normalFormalParameter (':' expression)?
+   * </pre>
+   *
+   * @param kind the kind of parameter being expected based on the presence or absence of group
+   *          delimiters
+   * @return the formal parameter that was parsed
+   */
+  FormalParameter _parseFormalParameter(ParameterKind kind) {
+    NormalFormalParameter parameter = parseNormalFormalParameter();
+    if (_matches(TokenType.EQ)) {
+      Token seperator = getAndAdvance();
+      Expression defaultValue = parseExpression2();
+      if (kind == ParameterKind.NAMED) {
+        _reportErrorForToken(
+            ParserErrorCode.WRONG_SEPARATOR_FOR_NAMED_PARAMETER,
+            seperator);
+      } else if (kind == ParameterKind.REQUIRED) {
+        _reportErrorForNode(
+            ParserErrorCode.POSITIONAL_PARAMETER_OUTSIDE_GROUP,
+            parameter);
+      }
+      return new DefaultFormalParameter(
+          parameter,
+          kind,
+          seperator,
+          defaultValue);
+    } else if (_matches(TokenType.COLON)) {
+      Token seperator = getAndAdvance();
+      Expression defaultValue = parseExpression2();
+      if (kind == ParameterKind.POSITIONAL) {
+        _reportErrorForToken(
+            ParserErrorCode.WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER,
+            seperator);
+      } else if (kind == ParameterKind.REQUIRED) {
+        _reportErrorForNode(
+            ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP,
+            parameter);
+      }
+      return new DefaultFormalParameter(
+          parameter,
+          kind,
+          seperator,
+          defaultValue);
+    } else if (kind != ParameterKind.REQUIRED) {
+      return new DefaultFormalParameter(parameter, kind, null, null);
+    }
+    return parameter;
+  }
+
+  /**
    * Parse a function body.
    *
    * <pre>
    * functionBody ::=
    *     '=>' expression ';'
    *   | block
    *
    * functionExpressionBody ::=
    *     '=>' expression
    *   | block
@@ skipping 414 matching lines @@
    * @param commentAndMetadata the metadata to be associated with the directive
    * @return the import directive that was parsed
    */
   ImportDirective _parseImportDirective(CommentAndMetadata commentAndMetadata) {
     Token importKeyword = _expectKeyword(Keyword.IMPORT);
     StringLiteral libraryUri = _parseUri();
     Token deferredToken = null;
     Token asToken = null;
     SimpleIdentifier prefix = null;
     if (_matchesKeyword(Keyword.DEFERRED)) {
-      if (_parseDeferredLibraries) {
-        deferredToken = getAndAdvance();
-      } else {
-        _reportErrorForCurrentToken(
-            ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED);
-        _advance();
-      }
+      deferredToken = getAndAdvance();
     }
     if (_matchesKeyword(Keyword.AS)) {
       asToken = getAndAdvance();
       prefix = parseSimpleIdentifier();
     } else if (deferredToken != null) {
       _reportErrorForCurrentToken(
           ParserErrorCode.MISSING_PREFIX_IN_DEFERRED_IMPORT);
     }
     List<Combinator> combinators = _parseCombinators();
     Token semicolon = _expectSemicolon();
@@ skipping 3062 matching lines @@
       _reportErrorForToken(
           ParserErrorCode.FINAL_TYPEDEF,
           modifiers.finalKeyword);
     }
     if (modifiers.varKeyword != null) {
       _reportErrorForToken(ParserErrorCode.VAR_TYPEDEF, modifiers.varKeyword);
     }
   }
 }
 /**
- * Instances of the class `SyntheticKeywordToken` implement a synthetic keyword token.
- */
-class Parser_SyntheticKeywordToken extends KeywordToken {
-  /**
-   * Initialize a newly created token to represent the given keyword.
-   *
-   * @param keyword the keyword being represented by this token
-   * @param offset the offset from the beginning of the file to the first character in the token
-   */
-  Parser_SyntheticKeywordToken(Keyword keyword, int offset)
-      : super(keyword, offset);
-
-  @override
-  int get length => 0;
-
-  @override
-  Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
-}
-
-
-/**
  * The enumeration `ParserErrorCode` defines the error codes used for errors
  * detected by the parser. The convention for this class is for the name of the
  * error code to indicate the problem that caused the error to be generated and
  * for the error message to explain what is wrong and, when appropriate, how the
  * problem can be corrected.
  */
 class ParserErrorCode extends ErrorCode {
   static const ParserErrorCode ABSTRACT_CLASS_MEMBER = const ParserErrorCode(
       'ABSTRACT_CLASS_MEMBER',
       "Members of classes cannot be declared to be 'abstract'");
@@ skipping 91 matching lines @@
 
   static const ParserErrorCode CONTINUE_OUTSIDE_OF_LOOP = const ParserErrorCode(
       'CONTINUE_OUTSIDE_OF_LOOP',
       "A continue statement cannot be used outside of a loop or switch statement");
 
   static const ParserErrorCode CONTINUE_WITHOUT_LABEL_IN_CASE =
       const ParserErrorCode(
           'CONTINUE_WITHOUT_LABEL_IN_CASE',
           "A continue statement in a switch statement must have a label as a target");
 
-  static const ParserErrorCode DEFERRED_IMPORTS_NOT_SUPPORTED =
-      const ParserErrorCode(
-          'DEFERRED_IMPORTS_NOT_SUPPORTED',
-          "Deferred imports are not supported by default");
-
   static const ParserErrorCode DEPRECATED_CLASS_TYPE_ALIAS =
       const ParserErrorCode(
           'DEPRECATED_CLASS_TYPE_ALIAS',
           "The 'typedef' mixin application was replaced with 'class'");
 
   static const ParserErrorCode DIRECTIVE_AFTER_DECLARATION =
       const ParserErrorCode(
           'DIRECTIVE_AFTER_DECLARATION',
           "Directives must appear before any declarations");
 
@@ skipping 571 matching lines @@
 
   @override
   ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
 
   @override
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
 }
 
 
 /**
+ * Instances of the class `SyntheticKeywordToken` implement a synthetic keyword token.
+ */
+class Parser_SyntheticKeywordToken extends KeywordToken {
+  /**
+   * Initialize a newly created token to represent the given keyword.
+   *
+   * @param keyword the keyword being represented by this token
+   * @param offset the offset from the beginning of the file to the first character in the token
+   */
+  Parser_SyntheticKeywordToken(Keyword keyword, int offset)
+      : super(keyword, offset);
+
+  @override
+  int get length => 0;
+
+  @override
+  Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
+}
+
+
+/**
  * Instances of the class `ResolutionCopier` copies resolution information from one AST
  * structure to another as long as the structures of the corresponding children of a pair of nodes
  * are the same.
  */
 class ResolutionCopier implements AstVisitor<bool> {
   /**
    * The AST node with which the node being visited is to be compared. This is only valid at the
    * beginning of each visit method (until [isEqualNodes] is invoked).
    */
   AstNode _toNode;
@@ skipping 456 matching lines @@
         _isEqualTokens(node.forKeyword, toNode.forKeyword),
         _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis),
         _isEqualNodes(node.loopVariable, toNode.loopVariable),
         _isEqualTokens(node.inKeyword, toNode.inKeyword),
         _isEqualNodes(node.iterable, toNode.iterable),
         _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis),
         _isEqualNodes(node.body, toNode.body));
   }
 
   @override
-  bool visitFormalParameterList(FormalParameterList node) {
-    FormalParameterList toNode = this._toNode as FormalParameterList;
-    return _and(
-        _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis),
-        _isEqualNodeLists(node.parameters, toNode.parameters),
-        _isEqualTokens(node.leftDelimiter, toNode.leftDelimiter),
-        _isEqualTokens(node.rightDelimiter, toNode.rightDelimiter),
-        _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis));
-  }
-
-  @override
   bool visitForStatement(ForStatement node) {
     ForStatement toNode = this._toNode as ForStatement;
     return _and(
         _isEqualTokens(node.forKeyword, toNode.forKeyword),
         _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis),
         _isEqualNodes(node.variables, toNode.variables),
         _isEqualNodes(node.initialization, toNode.initialization),
         _isEqualTokens(node.leftSeparator, toNode.leftSeparator),
         _isEqualNodes(node.condition, toNode.condition),
         _isEqualTokens(node.rightSeparator, toNode.rightSeparator),
         _isEqualNodeLists(node.updaters, toNode.updaters),
         _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis),
         _isEqualNodes(node.body, toNode.body));
   }
 
   @override
+  bool visitFormalParameterList(FormalParameterList node) {
+    FormalParameterList toNode = this._toNode as FormalParameterList;
+    return _and(
+        _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis),
+        _isEqualNodeLists(node.parameters, toNode.parameters),
+        _isEqualTokens(node.leftDelimiter, toNode.leftDelimiter),
+        _isEqualTokens(node.rightDelimiter, toNode.rightDelimiter),
+        _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis));
+  }
+
+  @override
   bool visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionDeclaration toNode = this._toNode as FunctionDeclaration;
     return _and(
         _isEqualNodes(node.documentationComment, toNode.documentationComment),
         _isEqualNodeLists(node.metadata, toNode.metadata),
         _isEqualTokens(node.externalKeyword, toNode.externalKeyword),
         _isEqualNodes(node.returnType, toNode.returnType),
         _isEqualTokens(node.propertyKeyword, toNode.propertyKeyword),
         _isEqualNodes(node.name, toNode.name),
         _isEqualNodes(node.functionExpression, toNode.functionExpression));
@@ skipping 393 matching lines @@
       toNode.propagatedElement = node.propagatedElement;
       toNode.propagatedType = node.propagatedType;
       toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
   @override
-  bool visitPrefixedIdentifier(PrefixedIdentifier node) {
-    PrefixedIdentifier toNode = this._toNode as PrefixedIdentifier;
+  bool visitPrefixExpression(PrefixExpression node) {
+    PrefixExpression toNode = this._toNode as PrefixExpression;
     if (_and(
-        _isEqualNodes(node.prefix, toNode.prefix),
-        _isEqualTokens(node.period, toNode.period),
-        _isEqualNodes(node.identifier, toNode.identifier))) {
+        _isEqualTokens(node.operator, toNode.operator),
+        _isEqualNodes(node.operand, toNode.operand))) {
+      toNode.propagatedElement = node.propagatedElement;
       toNode.propagatedType = node.propagatedType;
+      toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
   @override
-  bool visitPrefixExpression(PrefixExpression node) {
-    PrefixExpression toNode = this._toNode as PrefixExpression;
+  bool visitPrefixedIdentifier(PrefixedIdentifier node) {
+    PrefixedIdentifier toNode = this._toNode as PrefixedIdentifier;
     if (_and(
-        _isEqualTokens(node.operator, toNode.operator),
-        _isEqualNodes(node.operand, toNode.operand))) {
-      toNode.propagatedElement = node.propagatedElement;
+        _isEqualNodes(node.prefix, toNode.prefix),
+        _isEqualTokens(node.period, toNode.period),
+        _isEqualNodes(node.identifier, toNode.identifier))) {
       toNode.propagatedType = node.propagatedType;
-      toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
   @override
   bool visitPropertyAccess(PropertyAccess node) {
     PropertyAccess toNode = this._toNode as PropertyAccess;
     if (_and(
@@ skipping 453 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);
   }
 }