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

pkg/front_end/lib/src/fasta/kernel/kernel_procedure_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.kernel_procedure_builder;
 
 import 'package:kernel/ast.dart' show
     Arguments,
     AsyncMarker,
     Constructor,
@@ skipping 22 matching lines @@
 import 'package:kernel/type_algebra.dart' show
     containsTypeVariable,
     substitute;
 
 import '../errors.dart' show
     internalError;
 
 import '../modifier.dart' show
     abstractMask;
 
+import '../util/relativize.dart' show
+    relativizeUri;
+
 import 'kernel_builder.dart' show
     ClassBuilder,
     ConstructorReferenceBuilder,
     FormalParameterBuilder,
     KernelFormalParameterBuilder,
+    KernelLibraryBuilder,
     KernelTypeBuilder,
     KernelTypeVariableBuilder,
     MetadataBuilder,
     ProcedureBuilder,
     TypeBuilder,
     TypeVariableBuilder,
     memberError;
 
 abstract class KernelFunctionBuilder
     extends ProcedureBuilder<KernelTypeBuilder> {
   FunctionNode function;
 
   Statement actualBody;
 
   KernelFunctionBuilder(
       List<MetadataBuilder> metadata,
       int modifiers, KernelTypeBuilder returnType, String name,
       List<TypeVariableBuilder> typeVariables,
-      List<FormalParameterBuilder> formals)
-      : super(metadata, modifiers, returnType, name, typeVariables, formals);
+      List<FormalParameterBuilder> formals,
+      KernelLibraryBuilder compilationUnit, int charOffset)
+      : super(metadata, modifiers, returnType, name, typeVariables, formals,
+          compilationUnit, charOffset);
 
   void set body(Statement newBody) {
     if (isAbstract && newBody != null) {
       return internalError("Attempting to set body on abstract method.");
     }
     actualBody = newBody;
     if (function != null) {
       function.body = newBody;
       newBody?.parent = function;
     }
@@ skipping 68 matching lines @@
 
   AsyncMarker actualAsyncModifier;
 
   final ConstructorReferenceBuilder redirectionTarget;
 
   KernelProcedureBuilder(
       List<MetadataBuilder> metadata,
       int modifiers, KernelTypeBuilder returnType, String name,
       List<TypeVariableBuilder> typeVariables,
       List<FormalParameterBuilder> formals, this.actualAsyncModifier,
-      ProcedureKind kind, [this.redirectionTarget])
-      : procedure = new Procedure(null, kind, null),
-        super(metadata, modifiers, returnType, name, typeVariables, formals);
+      ProcedureKind kind, KernelLibraryBuilder compilationUnit, int charOffset,
+      [this.redirectionTarget])
+      : procedure = new Procedure(null, kind, null,
+            fileUri: relativizeUri(compilationUnit?.fileUri)),
+        super(metadata, modifiers, returnType, name, typeVariables, formals,
+            compilationUnit, charOffset);
 
   ProcedureKind get kind => procedure.kind;
 
   AsyncMarker get asyncModifier => actualAsyncModifier;
 
   Statement get body {
     if (actualBody == null && redirectionTarget == null && !isAbstract &&
         !isExternal) {
       actualBody = new EmptyStatement();
     }
@@ skipping 29 matching lines @@
     if (isFactory) {
       if (this.typeVariables != null) {
         return memberError(target, "Factories can't be generic.");
       }
       List<KernelTypeVariableBuilder> typeVariables;
       KernelTypeBuilder returnType = this.returnType;
       List<FormalParameterBuilder> formals;
       if (classTypeVariables != null) {
         typeVariables = <KernelTypeVariableBuilder>[];
         for (KernelTypeVariableBuilder variable in classTypeVariables) {
-          typeVariables.add(new KernelTypeVariableBuilder(variable.name));
+          typeVariables.add(new KernelTypeVariableBuilder(
+                  variable.name, null, -1));
         }
         Map<TypeVariableBuilder, TypeBuilder> substitution =
             <TypeVariableBuilder, TypeBuilder>{};
         int i = 0;
         for (KernelTypeVariableBuilder variable in classTypeVariables) {
           substitution[variable] = typeVariables[i++].asTypeBuilder();
         }
         i = 0;
         for (KernelTypeVariableBuilder variable in classTypeVariables) {
           typeVariables[i++].bound = variable?.bound?.subst(substitution);
         }
         returnType = returnType?.subst(substitution);
         i = 0;
         if (this.formals != null) {
           for (KernelFormalParameterBuilder formal in this.formals) {
             KernelTypeBuilder type = formal.type?.subst(substitution);
             if (type != formal.type) {
               formals ??= this.formals.toList();
               formals[i] = new KernelFormalParameterBuilder(formal.metadata,
-                  formal.modifiers, type, formal.name, formal.hasThis);
+                  formal.modifiers, type, formal.name, formal.hasThis, null,
+                  -1);
             }
             i++;
           }
         }
       }
       formals ??= this.formals;
-      return new KernelProcedureBuilder(
+      KernelProcedureBuilder factory = new KernelProcedureBuilder(
           metadata, modifiers, returnType, name, typeVariables, formals,
-          actualAsyncModifier, kind, redirectionTarget)
+          actualAsyncModifier, kind, null, -1, redirectionTarget)
           ..parent = parent;
+      factory.procedure.fileUri = procedure.fileUri;
+      return factory;
     } else {
       return new KernelConstructorBuilder(metadata, modifiers & ~abstractMask,
-          returnType, name, typeVariables, formals)
+          returnType, name, typeVariables, formals, null, -1)

[Johnni Winther, 2017/02/13 08:42:03]

Set [fileUri] on this?

[ahe, 2017/02/13 10:44:23]

This code is removed by CL 2682333004.

           ..parent = parent;
     }
   }
 
   Procedure get target => procedure;
 }
 
 // TODO(ahe): Move this to own file?
 class KernelConstructorBuilder extends KernelFunctionBuilder {
   final Constructor constructor = new Constructor(null);
 
   bool hasMovedSuperInitializer = false;
 
   SuperInitializer superInitializer;
 
   RedirectingInitializer redirectingInitializer;
 
   KernelConstructorBuilder(
       List<MetadataBuilder> metadata,
       int modifiers, KernelTypeBuilder returnType, String name,
       List<TypeVariableBuilder> typeVariables,
-      List<FormalParameterBuilder> formals)
-      : super(metadata, modifiers, returnType, name, typeVariables, formals);
+      List<FormalParameterBuilder> formals,
+      KernelLibraryBuilder compilationUnit, int charOffset)
+      : super(metadata, modifiers, returnType, name, typeVariables, formals,
+          compilationUnit, charOffset);
 
   bool get isInstanceMember => false;
 
   bool get isConstructor => true;
 
   AsyncMarker get asyncModifier => AsyncMarker.Sync;
 
   ProcedureKind get kind => null;
 
   Constructor build(Library library) {
@@ skipping 69 matching lines @@
         }
       }
       initializers.add(initializer..parent = constructor);
       initializers.add(superInitializer);
       return;
     }
     initializers.add(initializer);
     initializer.parent = constructor;
   }
 }