Ensure locations are always provided, but don't store them yet.

pkg/front_end/lib/src/fasta/source/source_library_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.source_library_builder;
 
 import 'package:kernel/ast.dart' show
     AsyncMarker,
     ProcedureKind;
 
@@ skipping 57 matching lines @@
   String partOf;
 
   List<MetadataBuilder> metadata;
 
   /// The current declaration that is being built. When we start parsing a
   /// declaration (class, method, and so on), we don't have enough information
   /// to create a builder and this object records its members and types until,
   /// for example, [addClass] is called.
   DeclarationBuilder<T> currentDeclaration;
 
-  SourceLibraryBuilder(this.loader, this.fileUri) {
+  SourceLibraryBuilder(this.loader, Uri fileUri)
+      : fileUri = fileUri, super(fileUri) {
     currentDeclaration = libraryDeclaration;
   }
 
   Uri get uri;
 
   bool get isPart => partOf != null;
 
   Map<String, Builder> get members => libraryDeclaration.members;
 
   List<T> get types => libraryDeclaration.types;
 
   /// When parsing a class, this returns a map of its members (that have been
   /// parsed so far).
   Map<String, MemberBuilder> get classMembers {
     assert(currentDeclaration.parent == libraryDeclaration);
     return currentDeclaration.members;
   }
 
   List<T> get declarationTypes {
     assert(currentDeclaration.parent == libraryDeclaration);
     return currentDeclaration.types;
   }
 
-  T addNamedType(String name, List<T> arguments);
+  T addNamedType(String name, List<T> arguments, int charOffset);
 
-  T addMixinApplication(T supertype, List<T> mixins);
+  T addMixinApplication(T supertype, List<T> mixins, int charOffset);
 
   T addType(T type) {
     currentDeclaration.addType(type);
     return type;
   }
 
-  T addVoidType();
+  T addVoidType(int charOffset);
 
   ConstructorReferenceBuilder addConstructorReference(
-      String name, List<T> typeArguments, String suffix) {
-    ConstructorReferenceBuilder ref =
-        new ConstructorReferenceBuilder(name, typeArguments, suffix);
+      String name, List<T> typeArguments, String suffix, int charOffset) {
+    ConstructorReferenceBuilder ref = new ConstructorReferenceBuilder(name,
+        typeArguments, suffix, this, charOffset);
     constructorReferences.add(ref);
     return ref;
   }
 
   void beginNestedDeclaration({bool hasMembers}) {
     currentDeclaration =
         new DeclarationBuilder(<String, MemberBuilder>{}, currentDeclaration);
   }
 
   DeclarationBuilder<T> endNestedDeclaration() {
     DeclarationBuilder<T> previous = currentDeclaration;
     currentDeclaration = currentDeclaration.parent;
     return previous;
   }
 
   Uri resolve(String path) => uri.resolve(path);
 
   void addExport(List<MetadataBuilder> metadata, String uri,
-      Unhandled conditionalUris, List<Combinator> combinators) {
-    loader.read(resolve(uri)).addExporter(this, combinators);
+      Unhandled conditionalUris, List<Combinator> combinators, int charOffset) {
+    loader.read(resolve(uri)).addExporter(this, combinators, charOffset);
   }
 
   void addImport(List<MetadataBuilder> metadata, String uri,
       Unhandled conditionalUris, String prefix, List<Combinator> combinators,
-      bool deferred) {
-    imports.add(new Import(loader.read(resolve(uri)), prefix, combinators));
+      bool deferred, int charOffset, int prefixCharOffset) {
+    imports.add(new Import(this, loader.read(resolve(uri)), prefix, combinators,
+            charOffset, prefixCharOffset));
   }
 
   void addPart(List<MetadataBuilder> metadata, String path) {
     Uri resolvedUri;
     Uri newFileUri;
     if (uri.scheme == "dart") {
       resolvedUri = new Uri(scheme: "dart", path: "${uri.path}/$path");
       newFileUri = fileUri.resolve(path);
     } else {
       resolvedUri = uri.resolve(path);
       newFileUri = fileUri.resolve(path);
     }
     parts.add(loader.read(resolvedUri, newFileUri));
   }
 
   void addPartOf(List<MetadataBuilder> metadata, String name) {
     partOf = name;
   }
 
   ClassBuilder addClass(List<MetadataBuilder> metadata,
       int modifiers, String name,
       List<TypeVariableBuilder> typeVariables, T supertype,
-      List<T> interfaces);
+      List<T> interfaces, int charOffset);
 
   NamedMixinApplicationBuilder addNamedMixinApplication(
       List<MetadataBuilder> metadata, String name,
       List<TypeVariableBuilder> typeVariables, int modifiers,
-      T mixinApplication, List<T> interfaces);
+      T mixinApplication, List<T> interfaces, int charOffset);
 
   FieldBuilder addField(List<MetadataBuilder> metadata,
-      int modifiers, T type, String name);
+      int modifiers, T type, String name, int charOffset);
 
   void addFields(List<MetadataBuilder> metadata, int modifiers,
       T type, List<String> names) {
     for (String name in names) {
-      addField(metadata, modifiers, type, name);
+      // TODO(ahe): Get charOffset of name.
+      addField(metadata, modifiers, type, name, -1);
     }
   }
 
   ProcedureBuilder addProcedure(List<MetadataBuilder> metadata,
       int modifiers, T returnType, String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals, AsyncMarker asyncModifier,
-      ProcedureKind kind);
+      ProcedureKind kind, int charOffset);
 
   EnumBuilder addEnum(List<MetadataBuilder> metadata, String name,
-      List<String> constants);
+      List<String> constants, int charOffset);
 
   FunctionTypeAliasBuilder addFunctionTypeAlias(List<MetadataBuilder> metadata,
       T returnType, String name,
       List<TypeVariableBuilder> typeVariables,
-      List<FormalParameterBuilder> formals);
+      List<FormalParameterBuilder> formals, int charOffset);
 
   void addFactoryMethod(List<MetadataBuilder> metadata,
       ConstructorReferenceBuilder name, List<FormalParameterBuilder> formals,
-      AsyncMarker asyncModifier, ConstructorReferenceBuilder redirectionTarget);
+      AsyncMarker asyncModifier, ConstructorReferenceBuilder redirectionTarget,
+      int charOffset);
 
   FormalParameterBuilder addFormalParameter(
       List<MetadataBuilder> metadata, int modifiers,
-      T type, String name, bool hasThis);
+      T type, String name, bool hasThis, int charOffset);
 
-  TypeVariableBuilder addTypeVariable(String name, T bound);
+  TypeVariableBuilder addTypeVariable(String name, T bound, int charOffset);
 
   Builder addBuilder(String name, Builder builder) {
     // TODO(ahe): Set the parent correctly here. Could then change the
     // implementation of MemberBuilder.isTopLevel to test explicitly for a
     // LibraryBuilder.
     if (currentDeclaration == libraryDeclaration) {
       if (builder is MemberBuilder) {
         builder.parent = this;
       } else if (builder is TypeDeclarationBuilder) {
         builder.parent = this;
@@ skipping 88 matching lines @@
         explicitCoreImport = true;
       }
       import.finalizeImports(this);
     }
     if (!explicitCoreImport) {
       loader.coreLibrary.exports.forEach(addToScope);
     }
   }
 
   void addToScope(String name, Builder member) {
-    Builder existing = scope.lookup(name);
+    Builder existing = scope.lookup(name, member.charOffset, fileUri);
     if (existing != null) {
       if (existing != member) {
         scope.local[name] = existing.combineAmbiguousImport(name, member, this);
       }
       // TODO(ahe): handle duplicated names.
     } else {
       scope.local[name] = member;
     }
   }
 
@@ skipping 90 matching lines @@
           // parent declaration.
           parent.addType(type);
         } else {
           type.bind(builder);
         }
       }
     }
     types.clear();
   }
 }