[fasta] Add and correct even more offsets

pkg/front_end/lib/src/fasta/source/outline_builder.dart

 // Copyright (c) 2016, 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.outline_builder;
 
 import 'package:kernel/ast.dart' show AsyncMarker, ProcedureKind;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
 
@@ skipping 204 matching lines @@
     TypeBuilder supertype = pop();
     List<TypeVariableBuilder> typeVariables = pop();
     String name = pop();
     if (typeVariables != null && supertype is MixinApplicationBuilder) {
       supertype.typeVariables = typeVariables;
       supertype.subclassName = name;
     }
     int modifiers = Modifier.validate(pop());
     List<MetadataBuilder> metadata = pop();
     library.addClass(metadata, modifiers, name, typeVariables, supertype,
-        interfaces, beginToken.charOffset);
+        interfaces, classKeyword.next?.charOffset ?? beginToken.charOffset);
     checkEmpty(beginToken.charOffset);
   }
 
   ProcedureKind computeProcedureKind(Token token) {
     if (token == null) return ProcedureKind.Method;
     if (optional("get", token)) return ProcedureKind.Getter;
     if (optional("set", token)) return ProcedureKind.Setter;
     return internalError("Unhandled: ${token.lexeme}");
   }
 
   @override
   void beginTopLevelMethod(Token token, Token name) {
     library.beginNestedDeclaration(name.lexeme, hasMembers: false);
   }
 
   @override
   void endTopLevelMethod(Token beginToken, Token getOrSet, Token endToken) {
     debugEvent("endTopLevelMethod");
     MethodBody kind = pop();
     AsyncMarker asyncModifier = pop();
     List<FormalParameterBuilder> formals = pop();
+    int formalsOffset = pop();
     List<TypeVariableBuilder> typeVariables = pop();
     String name = pop();
     TypeBuilder returnType = pop();
     int modifiers =
         Modifier.validate(pop(), isAbstract: kind == MethodBody.Abstract);
     List<MetadataBuilder> metadata = pop();
     checkEmpty(beginToken.charOffset);
     library.addProcedure(
         metadata,
         modifiers,
         returnType,
         name,
         typeVariables,
         formals,
         asyncModifier,
         computeProcedureKind(getOrSet),
         beginToken.charOffset,
+        formalsOffset,
         endToken.charOffset,
         nativeMethodName,
         isTopLevel: true);
     nativeMethodName = null;
   }
 
   @override
   void handleNoFunctionBody(Token token) {
     debugEvent("NoFunctionBody");
     push(MethodBody.Abstract);
@@ skipping 13 matching lines @@
   @override
   void endMethod(Token getOrSet, Token beginToken, Token endToken) {
     debugEvent("Method");
     MethodBody bodyKind = pop();
     if (bodyKind == MethodBody.RedirectingFactoryBody) {
       // This will cause an error later.
       pop();
     }
     AsyncMarker asyncModifier = pop();
     List<FormalParameterBuilder> formals = pop();
+    int formalsOffset = pop();
     List<TypeVariableBuilder> typeVariables = pop();
     dynamic nameOrOperator = pop();
     if (Operator.subtract == nameOrOperator && formals == null) {
       nameOrOperator = Operator.unaryMinus;
     }
     String name;
     ProcedureKind kind;
     if (nameOrOperator is Operator) {
       name = operatorToString(nameOrOperator);
       kind = ProcedureKind.Operator;
     } else {
       name = nameOrOperator;
       kind = computeProcedureKind(getOrSet);
     }
     TypeBuilder returnType = pop();
     int modifiers =
         Modifier.validate(pop(), isAbstract: bodyKind == MethodBody.Abstract);
     List<MetadataBuilder> metadata = pop();
     library.addProcedure(
         metadata,
         modifiers,
         returnType,
         name,
         typeVariables,
         formals,
         asyncModifier,
         kind,
         beginToken.charOffset,
+        formalsOffset,
         endToken.charOffset,
         nativeMethodName,
         isTopLevel: false);
     nativeMethodName = null;
   }
 
   @override
   void endMixinApplication(Token withKeyword) {
     debugEvent("MixinApplication");
     List<TypeBuilder> mixins = pop();
@@ skipping 56 matching lines @@
     push(popList(count) ?? NullValue.TypeVariables);
   }
 
   @override
   void handleVoidKeyword(Token token) {
     debugEvent("VoidKeyword");
     push(library.addVoidType(token.charOffset));
   }
 
   @override
-  void endFormalParameter(
-      Token covariantKeyword, Token thisKeyword, FormalParameterType kind) {
+  void endFormalParameter(Token covariantKeyword, Token thisKeyword,
+      Token nameToken, FormalParameterType kind) {
     debugEvent("FormalParameter");
     String name = pop();
     TypeBuilder type = pop();
     int modifiers = Modifier.validate(pop());
     List<MetadataBuilder> metadata = pop();
     // TODO(ahe): Needs begin token.
-    push(library.addFormalParameter(metadata, modifiers, type, name,
-        thisKeyword != null, thisKeyword?.charOffset ?? -1));
+    push(library.addFormalParameter(
+        metadata,
+        modifiers,
+        type,
+        name,
+        thisKeyword != null,
+        thisKeyword?.charOffset ?? nameToken?.charOffset ?? -1));
   }
 
   @override
   void handleValuedFormalParameter(Token equals, Token token) {
     debugEvent("ValuedFormalParameter");
     // Ignored for now.
   }
 
   @override
   void handleFormalParameterWithoutValue(Token token) {
     debugEvent("FormalParameterWithoutValue");
     // Ignored for now.
   }
 
   @override
   void endFunctionTypedFormalParameter(
       Token covariantKeyword, Token thisKeyword, FormalParameterType kind) {
     debugEvent("FunctionTypedFormalParameter");
     pop(); // Function type parameters.
+    pop(); // Formals offset
     pop(); // Type variables.
     String name = pop();
     pop(); // Return type.
     push(NullValue.Type);
     push(name);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
@@ skipping 33 matching lines @@
       }
     }
     if (formals != null) {
       for (var formal in formals) {
         if (formal is! FormalParameterBuilder) {
           internalError(formals);
         }
       }
       formals = new List<FormalParameterBuilder>.from(formals);
     }
+    push(beginToken.charOffset);
     push(formals ?? NullValue.FormalParameters);
   }
 
   @override
+  void handleNoFormalParameters(Token token) {
+    push(token.charOffset);
+    super.handleNoFormalParameters(token);
+  }
+
+  @override
   void endEnum(Token enumKeyword, Token endBrace, int count) {
     List<String> constants = popList(count);
     String name = pop();
     List<MetadataBuilder> metadata = pop();
     library.addEnum(
         metadata, name, constants, enumKeyword.charOffset, endBrace.charOffset);
     checkEmpty(enumKeyword.charOffset);
   }
 
   @override
   void beginFunctionTypeAlias(Token token) {
     library.beginNestedDeclaration(null, hasMembers: false);
   }
 
   @override
   void handleFunctionType(Token functionToken, Token endToken) {
     debugEvent("FunctionType");
     List<FormalParameterBuilder> formals = pop();
+    pop(); // formals offset
     List<TypeVariableBuilder> typeVariables = pop();
     TypeBuilder returnType = pop();
     push(library.addFunctionType(
         returnType, typeVariables, formals, functionToken.charOffset));
   }
 
   @override
   void endFunctionTypeAlias(
       Token typedefKeyword, Token equals, Token endToken) {
     debugEvent("endFunctionTypeAlias");
     List<FormalParameterBuilder> formals;
     List<TypeVariableBuilder> typeVariables;
     String name;
     TypeBuilder returnType;
     if (equals == null) {
       formals = pop();
+      pop(); // formals offset
       typeVariables = pop();
       name = pop();
       returnType = pop();
     } else {
       var type = pop();
       typeVariables = pop();
       name = pop();
       if (type is FunctionTypeBuilder) {
         // TODO(ahe): We need to start a nested declaration when parsing the
         // formals and return type so we can correctly bind
@@ skipping 79 matching lines @@
   void endFactoryMethod(
       Token beginToken, Token factoryKeyword, Token endToken) {
     debugEvent("FactoryMethod");
     MethodBody kind = pop();
     ConstructorReferenceBuilder redirectionTarget;
     if (kind == MethodBody.RedirectingFactoryBody) {
       redirectionTarget = pop();
     }
     AsyncMarker asyncModifier = pop();
     List<FormalParameterBuilder> formals = pop();
+    int formalsOffset = pop();
     var name = pop();
     int modifiers = Modifier.validate(pop());
     List<MetadataBuilder> metadata = pop();
     library.addFactoryMethod(
         metadata,
         modifiers,
         name,
         formals,
         asyncModifier,
         redirectionTarget,
         beginToken.charOffset,
+        formalsOffset,
         endToken.charOffset,
         nativeMethodName);
     nativeMethodName = null;
   }
 
   @override
   void endRedirectingFactoryBody(Token beginToken, Token endToken) {
     debugEvent("RedirectingFactoryBody");
     push(MethodBody.RedirectingFactoryBody);
   }
@@ skipping 66 matching lines @@
   Link<Token> handleMemberName(Link<Token> identifiers) {
     if (!isDartLibrary || identifiers.isEmpty) return identifiers;
     return removeNativeClause(identifiers);
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 }