Parse type substitution comments /*=T*/ in variable declarations with Fasta.

pkg/front_end/lib/src/fasta/parser/parser.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.
 
 library fasta.parser.parser;
 
 import '../fasta_codes.dart'
     show
         FastaCode,
         FastaMessage,
@@ skipping 708 matching lines @@
     } else {
       return expect(']', token);
     }
   }
 
   Token parseTypeOpt(Token token) {
     if (isGeneralizedFunctionType(token)) {
       // Function type without return type.
       return parseType(token);
     }
+    token = _injectGenericCommentTypeAssign(token);

[ahe, 2017/04/06 08:58:38]

Methods in the parser needs to be public so they can be overridden by
subclasses.

[ahe, 2017/04/06 10:04:42]

See CL 2799043004 for a detailed explanation.

[scheglov, 2017/04/06 16:15:55]

I moved these methods to Listener.

     Token peek = peekAfterIfType(token);
     if (peek != null && (peek.isIdentifier() || optional('this', peek))) {
       return parseType(token);
     }
     listener.handleNoType(token);
     return token;
   }
 
   bool isValidTypeReference(Token token) {
     final kind = token.kind;
@@ skipping 1659 matching lines @@
   }
 
   Token parseExpressionStatementOrDeclaration(Token token) {
     if (!inPlainSync && optional("await", token)) {
       return parseExpressionStatement(token);
     }
     assert(token.isIdentifier() || identical(token.stringValue, 'void'));
     Token identifier = peekIdentifierAfterType(token);
     if (identifier != null) {
       assert(identifier.isIdentifier());
+
+      // If the identifier token has a type substitution comment /*=T*/,
+      // then the set of tokens type tokens should be replaced with the
+      // tokens parsed from the comment.
+      token = _replaceTokenWithGenericCommentTypeAssign(token, identifier);
+
       Token afterId = identifier.next;
       int afterIdKind = afterId.kind;
       if (identical(afterIdKind, EQ_TOKEN) ||
           identical(afterIdKind, SEMICOLON_TOKEN) ||
           identical(afterIdKind, COMMA_TOKEN)) {
         // We are looking at "type identifier" followed by '=', ';', ','.
         return parseVariablesDeclaration(token);
       } else if (identical(afterIdKind, OPEN_PAREN_TOKEN)) {
         // We are looking at "type identifier '('".
         BeginGroupToken beginParen = afterId;
@@ skipping 64 matching lines @@
       }
     }
     return parseExpressionStatement(token);
   }
 
   Token parseExpressionStatementOrConstDeclaration(Token token) {
     assert(identical(token.stringValue, 'const'));
     if (isModifier(token.next)) {
       return parseVariablesDeclaration(token);
     }
+    _injectGenericCommentTypeAssign(token.next);
     Token identifier = peekIdentifierAfterOptionalType(token.next);
     if (identifier != null) {
       assert(identifier.isIdentifier());
       Token afterId = identifier.next;
       int afterIdKind = afterId.kind;
       if (identical(afterIdKind, EQ_TOKEN) ||
           identical(afterIdKind, SEMICOLON_TOKEN) ||
           identical(afterIdKind, COMMA_TOKEN)) {
         // We are looking at "const type identifier" followed by '=', ';', or
         // ','.
@@ skipping 801 matching lines @@
 
   Token parseVariablesDeclarationNoSemicolon(Token token) {
     // Only called when parsing a for loop, so this is for parsing locals.
     return parseVariablesDeclarationMaybeSemicolon(token, false);
   }
 
   Token parseVariablesDeclarationMaybeSemicolon(
       Token token, bool endWithSemicolon) {
     int count = 1;
     token = parseMetadataStar(token);
+
+    // If the next token has a type substitution comment /*=T*/, then
+    // the current 'var' token should be repealed and replaced.
+    if (token.keyword == Keyword.VAR) {

[ahe, 2017/04/06 08:58:38]

Use this method to match keywords:

optional('var', token)

[ahe, 2017/04/06 10:04:42]

See lines 178-184.

[scheglov, 2017/04/06 16:15:55]

Done.

+      token = _replaceTokenWithGenericCommentTypeAssign(token, token.next);
+    }
+
     token = parseModifiers(token);
     token = parseTypeOpt(token);
     listener.beginVariablesDeclaration(token);
     token = parseOptionallyInitializedIdentifier(token);
     while (optional(',', token)) {
       token = parseOptionallyInitializedIdentifier(token.next);
       ++count;
     }
     if (endWithSemicolon) {
       Token semicolon = token;
@@ skipping 473 matching lines @@
     return reportUnrecoverableError(
         token, () => code.format(uri, token.charOffset, token));
   }
 
   Token reportUnrecoverableErrorCodeWithString(
       Token token, FastaCode<StringArgument> code, String string) {
     return reportUnrecoverableError(
         token, () => code.format(uri, token.charOffset, string));
   }
 
+  /// Matches a generic comment type substitution and injects it into the token
+  /// stream before the given [token].
+  Token _injectGenericCommentTypeAssign(Token token) {
+    return _injectGenericComment(token, GENERIC_METHOD_TYPE_ASSIGN, 3);
+  }
+
   /// Matches a generic comment type parameters or type arguments and injects
   /// them into the token stream before the given [token].
   Token _injectGenericCommentTypeList(Token token) {
     return _injectGenericComment(token, GENERIC_METHOD_TYPE_LIST, 2);
   }
 
   /// Check if the given [token] has a comment token with the given [info],
   /// which should be either [GENERIC_METHOD_TYPE_ASSIGN] or
   /// [GENERIC_METHOD_TYPE_LIST].  If found, parse the comment into tokens and
   /// inject into the token stream before the [token].
@@ skipping 32 matching lines @@
     Token lastToken = firstToken;
     while (lastToken.next.info != EOF_INFO) {
       lastToken = lastToken.next;
     }
     // Inject these new tokens into the stream.
     Token previous = beforeToken.previous;
     lastToken.setNext(beforeToken);
     previous.setNext(firstToken);
     beforeToken = firstToken;
   }
+
+  /// If the [tokenWithComment] has a type substitution comment /*=T*/, then
+  /// the comment should be scanned into new tokens, and these tokens inserted
+  /// instead of tokens from the [tokenToStartReplacing] to the
+  /// [tokenWithComment]. Returns the first newly inserted token, or the
+  /// original [tokenWithComment].
+  Token _replaceTokenWithGenericCommentTypeAssign(
+      Token tokenToStartReplacing, Token tokenWithComment) {
+    Token injected = _injectGenericCommentTypeAssign(tokenWithComment);
+    if (!identical(injected, tokenWithComment)) {
+      Token prev = tokenToStartReplacing.previous;
+      prev.setNextWithoutSettingPrevious(injected);
+      tokenToStartReplacing = injected;
+      tokenToStartReplacing.previous = prev;
+    }
+    return tokenToStartReplacing;
+  }
 }
 
 typedef FastaMessage NoArgument(Uri uri, int charOffset);
 
 typedef FastaMessage TokenArgument(Uri uri, int charOffset, Token token);
 
 typedef FastaMessage StringArgument(Uri uri, int charOffset, String string);