New analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/parser.dart

 // 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:collection';
 import 'java_core.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart';
 import 'ast.dart';
@@ skipping 381 matching lines @@
    *
    * @return the synthetic string literal that was created
    */
   SimpleStringLiteral createSyntheticStringLiteral() => new SimpleStringLiteral.full(createSyntheticToken2(TokenType.STRING), "");
 
   /**
    * Create a synthetic token representing the given keyword.
    *
    * @return the synthetic token that was created
    */
-  Token createSyntheticToken(Keyword keyword) => new KeywordToken_13(keyword, _currentToken.offset);
+  Token createSyntheticToken(Keyword keyword) => new KeywordToken_15(keyword, _currentToken.offset);
 
   /**
    * Create a synthetic token with the given type.
    *
    * @return the synthetic token that was created
    */
   Token createSyntheticToken2(TokenType type) => new StringToken(type, "", _currentToken.offset);
 
   /**
    * Check that the given expression is assignable and report an error if it isn't.
@@ skipping 1309 matching lines @@
    *          comment
    * @param sourceOffset the offset of the first character of the reference source
    * @return the comment reference that was parsed, or `null` if no reference could be found
    */
   CommentReference parseCommentReference(String referenceSource, int sourceOffset) {
     if (referenceSource.length == 0) {
       return null;
     }
     try {
       List<bool> errorFound = [false];
-      AnalysisErrorListener listener = new AnalysisErrorListener_14(errorFound);
-      StringScanner scanner = new StringScanner(null, referenceSource, listener);
-      scanner.setSourceStart(1, 1, sourceOffset);
+      AnalysisErrorListener listener = new AnalysisErrorListener_16(errorFound);
+      Scanner scanner = new Scanner(null, new SubSequenceReader(new CharSequence(referenceSource), sourceOffset), listener);
+      scanner.setSourceStart(1, 1);
       Token firstToken = scanner.tokenize();
       if (errorFound[0]) {
         return null;
       }
       Token newKeyword = null;
       if (matches3(firstToken, Keyword.NEW)) {
         newKeyword = firstToken;
         firstToken = firstToken.next;
       }
       if (matchesIdentifier2(firstToken)) {
@@ skipping 2750 matching lines @@
    * @return the type alias that was parsed
    */
   TypeAlias parseTypeAlias(CommentAndMetadata commentAndMetadata) {
     Token keyword = expect(Keyword.TYPEDEF);
     if (matchesIdentifier()) {
       Token next = peek();
       if (matches4(next, TokenType.LT)) {
         next = skipTypeParameterList(next);
         if (next != null && matches4(next, TokenType.EQ)) {
           TypeAlias typeAlias = parseClassTypeAlias(commentAndMetadata, keyword);
+          reportError9(ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS, keyword, []);
           return typeAlias;
         }
       } else if (matches4(next, TokenType.EQ)) {
         TypeAlias typeAlias = parseClassTypeAlias(commentAndMetadata, keyword);
+        reportError9(ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS, keyword, []);
         return typeAlias;
       }
     }
     return parseFunctionTypeAlias(commentAndMetadata, keyword);
   }
 
   /**
    * Parse a list of type arguments.
    *
    * <pre>
@@ skipping 1126 matching lines @@
       reportError9(ParserErrorCode.EXTERNAL_TYPEDEF, modifiers.externalKeyword, []);
     }
     if (modifiers.finalKeyword != null) {
       reportError9(ParserErrorCode.FINAL_TYPEDEF, modifiers.finalKeyword, []);
     }
     if (modifiers.varKeyword != null) {
       reportError9(ParserErrorCode.VAR_TYPEDEF, modifiers.varKeyword, []);
     }
   }
 }
-class KeywordToken_13 extends KeywordToken {
-  KeywordToken_13(Keyword arg0, int arg1) : super(arg0, arg1);
+class KeywordToken_15 extends KeywordToken {
+  KeywordToken_15(Keyword arg0, int arg1) : super(arg0, arg1);
   int get length => 0;
 }
-class AnalysisErrorListener_14 implements AnalysisErrorListener {
+class AnalysisErrorListener_16 implements AnalysisErrorListener {
   List<bool> errorFound;
-  AnalysisErrorListener_14(this.errorFound);
+  AnalysisErrorListener_16(this.errorFound);
   void onError(AnalysisError error) {
     errorFound[0] = true;
   }
 }
 /**
  * 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.
  *
@@ skipping 1260 matching lines @@
       if ("\n" == separator) {
         _writer.print("\n");
         indent();
       } else if (i > 0) {
         _writer.print(separator);
       }
       _writer.print(tokens[i].lexeme);
     }
   }
 }