Implement character offsets for fields and enum constants.

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;
 
+import '../parser/identifier_context.dart' show IdentifierContext;
+
 import '../scanner/token.dart' show Token;
 
 import '../util/link.dart' show Link;
 
 import '../combinator.dart' show Combinator;
 
 import '../errors.dart' show internalError;
 
 import '../builder/builder.dart';
 
@@ skipping 46 matching lines @@
   String nativeMethodName;
 
   OutlineBuilder(SourceLibraryBuilder library)
       : library = library,
         isDartLibrary = library.uri.scheme == "dart";
 
   @override
   Uri get uri => library.fileUri;
 
   @override
+  int popCharOffset() => pop();
+
+  List<String> popIdentifierList(int count) {
+    if (count == 0) return null;
+    List<String> list = new List<String>.filled(count, null, growable: true);
+    for (int i = count - 1; i >= 0; i--) {
+      popCharOffset();
+      list[i] = pop();
+    }
+    return list;
+  }
+
+  @override
   void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
     debugEvent("Metadata");
     List arguments = pop();
+    popIfNotNull(periodBeforeName); // charOffset.
     String postfix = popIfNotNull(periodBeforeName);
     List<TypeBuilder> typeArguments = pop();
     if (arguments == null) {
+      int charOffset = pop();
       String expression = pop();
       push(new MetadataBuilder.fromExpression(
-          expression, postfix, library, beginToken.charOffset));
+          expression, postfix, library, charOffset));
     } else {
+      int charOffset = pop();
       String typeName = pop();
       push(new MetadataBuilder.fromConstructor(
           library.addConstructorReference(
-              typeName, typeArguments, postfix, beginToken.next.charOffset),
+              typeName, typeArguments, postfix, charOffset),
           arguments,
           library,
           beginToken.charOffset));
     }
   }
 
   @override
   void endHide(Token hideKeyword) {
     debugEvent("Hide");
     List<String> names = pop();
@@ skipping 11 matching lines @@
   void endCombinators(int count) {
     debugEvent("Combinators");
     push(popList(count) ?? NullValue.Combinators);
   }
 
   @override
   void endExport(Token exportKeyword, Token semicolon) {
     debugEvent("Export");
     List<Combinator> combinators = pop();
     Unhandled conditionalUris = pop();
+    popCharOffset();
     String uri = pop();
     List<MetadataBuilder> metadata = pop();
     if (uri != null) {
       library.addExport(metadata, uri, conditionalUris, combinators,
           exportKeyword.charOffset);
     }
     checkEmpty(exportKeyword.charOffset);
   }
 
   @override
   void endImport(Token importKeyword, Token deferredKeyword, Token asKeyword,
       Token semicolon) {
     debugEvent("endImport");
     List<Combinator> combinators = pop();
+    int prefixOffset = popIfNotNull(asKeyword) ?? -1;
     String prefix = popIfNotNull(asKeyword);
     Unhandled conditionalUris = pop();
+    popCharOffset();
     String uri = pop();
     List<MetadataBuilder> metadata = pop();
     if (uri != null) {
-      library.addImport(
-          metadata,
-          uri,
-          conditionalUris,
-          prefix,
-          combinators,
-          deferredKeyword != null,
-          importKeyword.charOffset,
-          asKeyword?.next?.charOffset ?? -1);
+      library.addImport(metadata, uri, conditionalUris, prefix, combinators,
+          deferredKeyword != null, importKeyword.charOffset, prefixOffset);
     }
     checkEmpty(importKeyword.charOffset);
   }
 
   @override
   void handleRecoverExpression(Token token) {
     debugEvent("RecoverExpression");
     push(NullValue.Expression);
+    push(token.charOffset);
   }
 
   @override
   void endPart(Token partKeyword, Token semicolon) {
     debugEvent("Part");
+    popCharOffset();
     String uri = pop();
     List<MetadataBuilder> metadata = pop();
     if (uri != null) {
       library.addPart(metadata, uri);
     }
     checkEmpty(partKeyword.charOffset);
   }
 
   @override
   void handleOperatorName(Token operatorKeyword, Token token) {
     debugEvent("OperatorName");
     push(operatorFromString(token.stringValue));
+    push(token.charOffset);
+  }
+
+  @override
+  void handleIdentifier(Token token, IdentifierContext context) {
+    super.handleIdentifier(token, context);
+    push(token.charOffset);
+  }
+
+  @override
+  void handleNoName(Token token) {
+    super.handleNoName(token);
+    push(token.charOffset);
+  }
+
+  @override
+  void endLiteralString(int interpolationCount, Token endToken) {
+    debugEvent("endLiteralString");
+    if (interpolationCount == 0) {
+      Token token = pop();
+      push(unescapeString(token.lexeme));
+      push(token.charOffset);
+    } else {
+      internalError("String interpolation not implemented.");
+    }
+  }
+
+  @override
+  void handleStringJuxtaposition(int literalCount) {
+    debugEvent("StringJuxtaposition");
+    List<String> list =
+        new List<String>.filled(literalCount, null, growable: false);
+    int charOffset = -1;
+    for (int i = literalCount - 1; i >= 0; i--) {
+      charOffset = pop();
+      list[i] = pop();
+    }
+    push(list.join(""));
+    push(charOffset);
   }
 
   @override
   void endIdentifierList(int count) {
     debugEvent("endIdentifierList");
-    push(popList(count) ?? NullValue.IdentifierList);
+    push(popIdentifierList(count) ?? NullValue.IdentifierList);
   }
 
   @override
   void handleQualified(Token period) {
     debugEvent("handleQualified");
+    int charOffset = pop();
     String name = pop();
+    charOffset = pop(); // We just want the charOffset of receiver.
     String receiver = pop();
     push("$receiver.$name");
+    push(charOffset);
   }
 
   @override
   void endLibraryName(Token libraryKeyword, Token semicolon) {
     debugEvent("endLibraryName");
+    popCharOffset();
     String name = pop();
     List<MetadataBuilder> metadata = pop();
     library.name = name;
     library.metadata = metadata;
   }
 
   @override
   void beginClassDeclaration(Token begin, Token name) {
     library.beginNestedDeclaration(name.lexeme);
   }
 
   @override
   void endClassDeclaration(
       int interfacesCount,
       Token beginToken,
       Token classKeyword,
       Token extendsKeyword,
       Token implementsKeyword,
       Token endToken) {
     debugEvent("endClassDeclaration");
     List<TypeBuilder> interfaces = popList(interfacesCount);
     TypeBuilder supertype = pop();
     List<TypeVariableBuilder> typeVariables = pop();
+    int charOffset = 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, classKeyword.next?.charOffset ?? beginToken.charOffset);
+        interfaces, 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();
+    int charOffset = 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,
+        charOffset,
         formalsOffset,
         endToken.charOffset,
         nativeMethodName,
         isTopLevel: true);
     nativeMethodName = null;
   }
 
   @override
   void handleNoFunctionBody(Token token) {
     debugEvent("NoFunctionBody");
@@ skipping 16 matching lines @@
     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();
+    int charOffset = 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,
+        charOffset,
         formalsOffset,
         endToken.charOffset,
         nativeMethodName,
         isTopLevel: false);
     nativeMethodName = null;
   }
 
   @override
   void endMixinApplication(Token withKeyword) {
     debugEvent("MixinApplication");
     List<TypeBuilder> mixins = pop();
     TypeBuilder supertype = pop();
     push(library.addMixinApplication(supertype, mixins, -1));
   }
 
   @override
   void beginNamedMixinApplication(Token begin, Token name) {
     library.beginNestedDeclaration(name.lexeme, hasMembers: false);
   }
 
   @override
   void endNamedMixinApplication(Token beginToken, Token classKeyword,
       Token equals, Token implementsKeyword, Token endToken) {
     debugEvent("endNamedMixinApplication");
     List<TypeBuilder> interfaces = popIfNotNull(implementsKeyword);
     TypeBuilder mixinApplication = pop();
     List<TypeVariableBuilder> typeVariables = pop();
+    int charOffset = pop();
     String name = pop();
     if (typeVariables != null && mixinApplication is MixinApplicationBuilder) {
       mixinApplication.typeVariables = typeVariables;
       mixinApplication.subclassName = name;
     }
     int modifiers = Modifier.validate(pop());
     List<MetadataBuilder> metadata = pop();
     library.addNamedMixinApplication(metadata, name, typeVariables, modifiers,
-        mixinApplication, interfaces, beginToken.charOffset);
+        mixinApplication, interfaces, charOffset);
     checkEmpty(beginToken.charOffset);
   }
 
   @override
   void endTypeArguments(int count, Token beginToken, Token endToken) {
     debugEvent("TypeArguments");
     push(popList(count) ?? NullValue.TypeArguments);
   }
 
   @override
   void handleScript(Token token) {
     debugEvent("Script");
   }
 
   @override
   void handleType(Token beginToken, Token endToken) {
     debugEvent("Type");
     List<TypeBuilder> arguments = pop();
+    int charOffset = pop();
     String name = pop();
-    push(library.addNamedType(name, arguments, beginToken.charOffset));
+    push(library.addNamedType(name, arguments, charOffset));
   }
 
   @override
   void endTypeList(int count) {
     debugEvent("TypeList");
     push(popList(count) ?? NullValue.TypeList);
   }
 
   @override
   void endTypeVariables(int count, Token beginToken, Token endToken) {
     debugEvent("TypeVariables");
     push(popList(count) ?? NullValue.TypeVariables);
   }
 
   @override
   void handleVoidKeyword(Token token) {
     debugEvent("VoidKeyword");
     push(library.addVoidType(token.charOffset));
   }
 
   @override
   void endFormalParameter(Token covariantKeyword, Token thisKeyword,
       Token nameToken, FormalParameterType kind) {
     debugEvent("FormalParameter");
+    int charOffset = pop();
     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 ?? nameToken?.charOffset ?? -1));
+        metadata, modifiers, type, name, thisKeyword != null, charOffset));
   }
 
   @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.
+    int charOffset = pop();
     String name = pop();
     pop(); // Return type.
     push(NullValue.Type);
     push(name);
+    push(charOffset);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
     debugEvent("OptionalFormalParameters");
     FormalParameterType kind = optional("{", beginToken)
         ? FormalParameterType.NAMED
         : FormalParameterType.POSITIONAL;
     // When recovering from an empty list of optional arguments, count may be
@@ skipping 40 matching lines @@
   }
 
   @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);
+    List constantNamesAndOffsets = popList(count * 2);
+    int charOffset = pop();
     String name = pop();
     List<MetadataBuilder> metadata = pop();
-    library.addEnum(
-        metadata, name, constants, enumKeyword.charOffset, endBrace.charOffset);
+    library.addEnum(metadata, name, constantNamesAndOffsets, 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;
+    int charOffset;
     if (equals == null) {
       formals = pop();
       pop(); // formals offset
       typeVariables = pop();
+      charOffset = pop();
       name = pop();
       returnType = pop();
     } else {
       var type = pop();
       typeVariables = pop();
+      charOffset = 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
         // `type.typeVariables`. A typedef can have type variables, and a new
         // function type can also have type variables (representing the type of
         // a generic function).
         formals = type.formals;
         returnType = type.returnType;
       } else {
         // TODO(ahe): Improve this error message.
         library.addCompileTimeError(
             equals.charOffset, "Can't create typedef from non-function type.");
       }
     }
     List<MetadataBuilder> metadata = pop();
-    library.addFunctionTypeAlias(metadata, returnType, name, typeVariables,
-        formals, typedefKeyword.charOffset);
+    library.addFunctionTypeAlias(
+        metadata, returnType, name, typeVariables, formals, charOffset);
     checkEmpty(typedefKeyword.charOffset);
   }
 
   @override
   void endTopLevelFields(int count, Token beginToken, Token endToken) {
     debugEvent("endTopLevelFields");
-    List<String> names = popList(count);
+    List namesAndOffsets = popList(count * 2);
     TypeBuilder type = pop();
     int modifiers = Modifier.validate(pop());
     List<MetadataBuilder> metadata = pop();
-    library.addFields(metadata, modifiers, type, names);
+    library.addFields(metadata, modifiers, type, namesAndOffsets);
     checkEmpty(beginToken.charOffset);
   }
 
   @override
   void endFields(
       int count, Token covariantToken, Token beginToken, Token endToken) {
     debugEvent("Fields");
-    List<String> names = popList(count);
+    List namesAndOffsets = popList(count * 2);
     TypeBuilder type = pop();
     int modifiers = Modifier.validate(pop());
     List<MetadataBuilder> metadata = pop();
-    library.addFields(metadata, modifiers, type, names);
+    library.addFields(metadata, modifiers, type, namesAndOffsets);
   }
 
   @override
   void endTypeVariable(Token token, Token extendsOrSuper) {
     debugEvent("endTypeVariable");
     TypeBuilder bound = pop();
+    int charOffset = pop();
     String name = pop();
     // TODO(paulberry): type variable metadata should not be ignored.  See
     // dartbug.com/28981.
     /* List<MetadataBuilder> metadata = */ pop();
-    push(library.addTypeVariable(name, bound, token.charOffset));
+    push(library.addTypeVariable(name, bound, charOffset));
   }
 
   @override
   void endPartOf(Token partKeyword, Token semicolon, bool hasName) {
     debugEvent("endPartOf");
+    popCharOffset();
     String containingLibrary = pop();
     List<MetadataBuilder> metadata = pop();
     if (hasName) {
       library.addPartOf(metadata, containingLibrary, null);
     } else {
       library.addPartOf(metadata, null, containingLibrary);
     }
   }
 
   @override
   void endConstructorReference(
       Token start, Token periodBeforeName, Token endToken) {
     debugEvent("ConstructorReference");
+    popIfNotNull(periodBeforeName); // charOffset.
     String suffix = popIfNotNull(periodBeforeName);
     List<TypeBuilder> typeArguments = pop();
+    int charOffset = pop();
     String name = pop();
     push(library.addConstructorReference(
-        name, typeArguments, suffix, start.charOffset));
+        name, typeArguments, suffix, charOffset));
   }
 
   @override
   void beginFactoryMethod(Token token) {
     library.beginNestedDeclaration(null, hasMembers: false);
   }
 
   @override
   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,
+        factoryKeyword.next.charOffset,
         formalsOffset,
         endToken.charOffset,
         nativeMethodName);
     nativeMethodName = null;
   }
 
   @override
   void endRedirectingFactoryBody(Token beginToken, Token endToken) {
     debugEvent("RedirectingFactoryBody");
     push(MethodBody.RedirectingFactoryBody);
@@ skipping 67 matching lines @@
   Link<Token> handleMemberName(Link<Token> identifiers) {
     if (!isDartLibrary || identifiers.isEmpty) return identifiers;
     return removeNativeClause(identifiers);
   }
 
   @override
   void debugEvent(String name) {
     // printEvent(name);
   }
 }