[fasta] Add and correct even more offsets

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 '../scanner.dart' show ErrorToken;
 
 import '../scanner/recover.dart' show closeBraceFor, skipToEof;
 
@@ skipping 501 matching lines @@
     Token covariantKeyword;
     if (identical(token.stringValue, 'covariant') &&
         (token.next.isIdentifier() || isModifier(token.next))) {
       covariantKeyword = token;
       token = token.next;
     }
     token = parseModifiers(token);
     bool isNamedParameter = kind == FormalParameterType.NAMED;
 
     Token thisKeyword = null;
+    Token nameToken;
     if (inFunctionType && isNamedParameter) {
       token = parseType(token);
       token =
           parseIdentifier(token, IdentifierContext.formalParameterDeclaration);
     } else if (inFunctionType) {
       token = parseType(token);
       if (token.isIdentifier()) {
         token = parseIdentifier(
             token, IdentifierContext.formalParameterDeclaration);
       } else {
         listener.handleNoName(token);
       }
     } else {
       token = parseReturnTypeOpt(token);
       if (optional('this', token)) {
         thisKeyword = token;
         token = expect('.', token.next);
+        nameToken = token;
         token = parseIdentifier(token, IdentifierContext.fieldInitializer);
       } else {
+        nameToken = token;
         token = parseIdentifier(
             token, IdentifierContext.formalParameterDeclaration);
       }
     }
 
     if (optional('(', token)) {
       Token inlineFunctionTypeStart = token;
       listener.beginFunctionTypedFormalParameter(token);
       listener.handleNoTypeVariables(token);
       token = parseFormalParameters(token);
@@ skipping 28 matching lines @@
       token = parseExpression(token.next);
       listener.handleValuedFormalParameter(equal, token);
       if (kind.isRequired) {
         reportRecoverableError(equal, ErrorKind.RequiredParameterWithDefault);
       } else if (kind.isPositional && identical(':', value)) {
         reportRecoverableError(equal, ErrorKind.PositionalParameterWithEquals);
       }
     } else {
       listener.handleFormalParameterWithoutValue(token);
     }
-    listener.endFormalParameter(covariantKeyword, thisKeyword, kind);
+    listener.endFormalParameter(covariantKeyword, thisKeyword, nameToken, kind);
     return token;
   }
 
   Token parseOptionalFormalParameters(Token token, bool isNamed,
       {bool inFunctionType: false}) {
     Token begin = token;
     listener.beginOptionalFormalParameters(begin);
     assert((isNamed && optional('{', token)) || optional('[', token));
     int parameterCount = 0;
     do {
@@ skipping 672 matching lines @@
       parseReturnTypeOpt(type);
     }
     Token token =
         parseIdentifier(name, IdentifierContext.topLevelFunctionDeclaration);
 
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
+    Token formalParametersToken = token;
     token = parseFormalParametersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     token = parseFunctionBody(token, false, externalModifier != null);
     asyncAwaitKeywordsEnabled = previousAsyncAwaitKeywordsEnabled;
     Token endToken = token;
     token = token.next;
-    listener.endTopLevelMethod(start, getOrSet, endToken);
+    listener.endTopLevelMethod(
+        start, getOrSet, formalParametersToken, endToken);

[ahe, 2017/03/13 14:33:52]

Have you tested this situation:

get foo => "foo";

[jensj, 2017/03/14 12:37:12]

Well -- the name is misleading (the token is '=>') --- other than that I think
it's fine... I will add a service test that steps through such a thing though
(different CL).
Do you have an idea for a better name?

     return token;
   }
 
   /// Looks ahead to find the name of a member. Returns a link of the modifiers,
   /// set/get, (operator) name, and either the start of the method body or the
   /// end of the declaration.
   ///
   /// Examples:
   ///
   ///     int get foo;
@@ skipping 512 matching lines @@
       token = parseIdentifier(name, IdentifierContext.methodDeclaration);
     }
 
     token = parseQualifiedRestOpt(
         token, IdentifierContext.methodDeclarationContinuation);
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
+    Token formalParametersToken = token;
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
       token = parseFunctionBody(
           token, false, staticModifier == null || externalModifier != null);
     }
     asyncAwaitKeywordsEnabled = previousAsyncAwaitKeywordsEnabled;
-    listener.endMethod(getOrSet, start, token);
+    listener.endMethod(getOrSet, start, formalParametersToken, token);
     return token.next;
   }
 
   Token parseFactoryMethod(Token token) {
     assert(isFactoryDeclaration(token));
     Token start = token;
     bool isExternal = false;
     int modifierCount = 0;
     while (isModifier(token)) {
       if (optional('external', token)) {
         isExternal = true;
       }
       token = parseModifier(token);
       modifierCount++;
     }
     listener.handleModifiers(modifierCount);
     Token factoryKeyword = token;
     listener.beginFactoryMethod(factoryKeyword);
     token = expect('factory', token);
     token = parseConstructorReference(token);
+    Token formalParametersToken = token;
     token = parseFormalParameters(token);
     token = parseAsyncModifier(token);
     if (optional('=', token)) {
       token = parseRedirectingFactoryBody(token);
     } else {
       token = parseFunctionBody(token, false, isExternal);
     }
-    listener.endFactoryMethod(start, factoryKeyword, token);
+    listener.endFactoryMethod(
+        start, factoryKeyword, formalParametersToken, token);
     return token.next;
   }
 
   Token parseOperatorName(Token token) {
     assert(optional('operator', token));
     if (isUserDefinableOperator(token.next.stringValue)) {
       Token operator = token;
       token = token.next;
       listener.handleOperatorName(operator, token);
       return token.next;
     } else {
       return parseIdentifier(token, IdentifierContext.operatorName);
     }
   }
 
   Token parseFunction(Token token, Token getOrSet) {
+    Token beginToken = token;
     listener.beginFunction(token);
     token = parseModifiers(token);
     if (identical(getOrSet, token)) {
       // get <name>  => ...
       token = token.next;
       listener.handleNoType(token);
       listener.beginFunctionName(token);
       if (optional('operator', token)) {
         token = parseOperatorName(token);
       } else {
@@ skipping 14 matching lines @@
       listener.beginFunctionName(token);
       if (optional('operator', token)) {
         token = parseOperatorName(token);
       } else {
         token =
             parseIdentifier(token, IdentifierContext.localFunctionDeclaration);
       }
     }
     token = parseQualifiedRestOpt(
         token, IdentifierContext.localFunctionDeclarationContinuation);
-    listener.endFunctionName(token);
+    listener.endFunctionName(beginToken, token);
     if (getOrSet == null) {
       token = parseTypeVariablesOpt(token);
     } else {
       listener.handleNoTypeVariables(token);
     }
+    Token formalParametersToken = token;
     token = parseFormalParametersOpt(token);
     token = parseInitializersOpt(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     token = parseFunctionBody(token, false, true);
     asyncAwaitKeywordsEnabled = previousAsyncAwaitKeywordsEnabled;
-    listener.endFunction(getOrSet, token);
+    listener.endFunction(getOrSet, formalParametersToken, token);
     return token.next;
   }
 
   Token parseUnnamedFunction(Token token) {
+    Token beginToken = token;
     listener.beginUnnamedFunction(token);
     token = parseFormalParameters(token);
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
     asyncAwaitKeywordsEnabled = previousAsyncAwaitKeywordsEnabled;
-    listener.endUnnamedFunction(token);
+    listener.endUnnamedFunction(beginToken, token);
     return isBlock ? token.next : token;
   }
 
   Token parseFunctionDeclaration(Token token) {
     listener.beginFunctionDeclaration(token);
     token = parseFunction(token, null);
     listener.endFunctionDeclaration(token);
     return token;
   }
 
   Token parseFunctionExpression(Token token) {
+    Token beginToken = token;
     listener.beginFunction(token);
     listener.handleModifiers(0);
     token = parseReturnTypeOpt(token);
     listener.beginFunctionName(token);
     token = parseIdentifier(token, IdentifierContext.functionExpressionName);
-    listener.endFunctionName(token);
+    listener.endFunctionName(beginToken, token);
     token = parseTypeVariablesOpt(token);
+    Token formalParametersToken = token;
     token = parseFormalParameters(token);
     listener.handleNoInitializers();
     bool previousAsyncAwaitKeywordsEnabled = asyncAwaitKeywordsEnabled;
     token = parseAsyncModifier(token);
     bool isBlock = optional('{', token);
     token = parseFunctionBody(token, true, false);
     asyncAwaitKeywordsEnabled = previousAsyncAwaitKeywordsEnabled;
-    listener.endFunction(null, token);
+    listener.endFunction(null, formalParametersToken, token);
     return isBlock ? token.next : token;
   }
 
   Token parseConstructorReference(Token token) {
     Token start = token;
     listener.beginConstructorReference(start);
     token = parseIdentifier(token, IdentifierContext.constructorReference);
     token = parseQualifiedRestOpt(
         token, IdentifierContext.constructorReferenceContinuation);
     token = parseTypeArgumentsOpt(token);
@@ skipping 1605 matching lines @@
         break;
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, kind, arguments);
       return null;
     } else {
       return listener.handleUnrecoverableError(token, kind, arguments)?.next;
     }
   }
 }