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

pkg/front_end/lib/src/fasta/kernel/body_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.body_builder;
 
 import 'package:front_end/src/fasta/parser/parser.dart' show
     FormalParameterType,
     optional;
 
@@ skipping 262 matching lines @@
   }
 
   void exitSwitchScope() {
     switchScope = pop();
   }
 
   @override
   Uri get uri => library.fileUri ?? library.uri;
 
   @override
-  JumpTarget createJumpTarget(JumpTargetKind kind) => new JumpTarget(kind);
+  JumpTarget createJumpTarget(JumpTargetKind kind, int charOffset) {
+    return new JumpTarget(kind, member, charOffset);
+  }
 
   @override
   void endMetadata(Token beginToken, Token periodBeforeName, Token endToken) {
     debugEvent("Metadata");
     pop(); // Arguments.
     popIfNotNull(periodBeforeName); // Postfix.
     pop(); // Type arguments.
     pop(); // Expression or type name (depends on arguments).
     // TODO(ahe): Implement metadata on local declarations.
   }
@@ skipping 405 matching lines @@
     }
     return null;
   }
 
   @override
   void beginExpression(Token token) {
     debugEvent("beginExpression");
     isFirstIdentifier = true;
   }
 
-  Builder computeSetter(Builder builder, Scope scope, String name) {
+  Builder computeSetter(
+      Builder builder, Scope scope, String name, int charOffset) {
     if (builder.isSetter) return builder;
-    if (builder.isGetter) return scope.lookupSetter(name);
+    if (builder.isGetter) return scope.lookupSetter(name, charOffset, uri);
     return builder.isField ? (builder.isFinal ? null : builder) : null;
   }
 
   @override
   void handleIdentifier(Token token) {
     debugEvent("handleIdentifier");
     String name = token.value;
     if (isFirstIdentifier) {
       assert(!inInitializer || this.scope == enclosingScope ||
           this.scope.parent == enclosingScope);
       // This deals with this kind of initializer: `C(a) : a = a;`
       Scope scope = inInitializer ? enclosingScope : this.scope;
-      Builder builder = scope.lookup(name);
+      Builder builder = scope.lookup(name, token.charOffset, uri);
       push(builderToFirstExpression(builder, name, token.charOffset));
     } else {
       push(new Identifier(name)..fileOffset = token.charOffset);
     }
   }
 
   @override
   builderToFirstExpression(Builder builder, String name, int charOffset,
       {bool isPrefix: false}) {
     if (builder == null || (!isInstanceContext && builder.isInstanceMember)) {
       if (!isPrefix && identical(name, "dynamic") && builder == null) {
-        return new KernelNamedTypeBuilder(name, null);
+        return new KernelNamedTypeBuilder(name, null, charOffset, uri);
       }
       Name n = new Name(name, library.library);
       if (!isPrefix && isInstanceContext) {
         assert(builder == null);
         return new ThisPropertyAccessor(this, charOffset, n, null, null);
       } else {
         return new UnresolvedIdentifier(n)
             ..fileOffset = charOffset;
       }
     } else if (builder.isTypeDeclaration) {
@@ skipping 14 matching lines @@
     } else {
       if (builder is AccessErrorBuilder) {
         AccessErrorBuilder error = builder;
         builder = error.builder;
       }
       if (builder.target == null) {
         return internalError("Unhandled: ${builder}");
       }
       Member getter = builder.target.hasGetter ? builder.target : null;
       Member setter = builder.target.hasSetter ? builder.target : null;
-      setter ??= computeSetter(builder, scope, name)?.target;
+      setter ??= computeSetter(builder, scope, name, charOffset)?.target;
       return
           new StaticAccessor(this, charOffset, getter, setter);
     }
   }
 
   @override
   void handleQualified(Token period) {
     debugEvent("Qualified");
     Identifier name = pop();
     var receiver = pop();
@@ skipping 118 matching lines @@
     TreeNode node = pop();
     VariableDeclaration variable;
     if (node is VariableDeclaration) {
       variable = node;
     } else if (node is Identifier) {
       variable = new VariableDeclaration(node.name);
     } else {
       internalError("unhandled identifier: ${node.runtimeType}");
     }
     push(variable);
-    scope[variable.name] = new KernelVariableBuilder(variable);
+    scope[variable.name] = new KernelVariableBuilder(variable,
+        // TODO(ahe): This should be `member ?? classBuilder ?? part`, but we
+        // don't have an object representing the current part.
+        member ?? classBuilder);
   }
 
   @override
   void endVariablesDeclaration(int count, Token endToken) {
     debugEvent("VariablesDeclaration");
     List<VariableDeclaration> variables = popList(count);
     DartType type = pop();
     int modifiers = Modifier.validate(pop());
     bool isConst = (modifiers & constMask) != 0;
     bool isFinal = (modifiers & finalMask) != 0;
@@ skipping 31 matching lines @@
               new TypeLiteral(accessor.buildTypesWithBuiltArguments(null))));
     } else if (accessor is! BuilderAccessor) {
       push(buildCompileTimeError("Can't assign to this.", token.charOffset));
     } else {
       push(new DelayedAssignment(this, token.charOffset, accessor, value,
               token.stringValue));
     }
   }
 
   @override
-  void enterLoop() {
+  void enterLoop(int charOffset) {
     if (peek() is LabelTarget) {
       LabelTarget target = peek();
-      enterBreakTarget(target.breakTarget);
-      enterContinueTarget(target.continueTarget);
+      enterBreakTarget(charOffset, target.breakTarget);
+      enterContinueTarget(charOffset, target.continueTarget);
     } else{
-      enterBreakTarget();
-      enterContinueTarget();
+      enterBreakTarget(charOffset);
+      enterContinueTarget(charOffset);
     }
   }
 
   void exitLoopOrSwitch(Statement statement) {
     if (compileTimeErrorInLoopOrSwitch != null) {
       push(compileTimeErrorInLoopOrSwitch);
       compileTimeErrorInLoopOrSwitch = null;
     } else {
       push(statement);
     }
@@ skipping 153 matching lines @@
     } else {
       List parts = popList(identifierCount);
       value = symbolPartToString(parts.first);
       for (int i = 1; i < parts.length; i++) {
         value += ".${symbolPartToString(parts[i])}";
       }
     }
     push(new SymbolLiteral(value));
   }
 
-  DartType toKernelType(String name, List<DartType> arguments) {
+  DartType toKernelType(String name, List<DartType> arguments, int charOffset) {
     if (identical(name, "void")) return const VoidType();
     if (identical(name, "dynamic")) return const DynamicType();
-    Builder builder = scope.lookup(name);
+    Builder builder = scope.lookup(name, charOffset, uri);
     if (builder is TypeDeclarationBuilder) {
       return builder.buildTypesWithBuiltArguments(arguments);
     }
     if (builder == null)  {
       print("$uri: Type not found: $name");
     } else {
       print("$uri: Not a type: $name");
     }
     // TODO(ahe): Create an error somehow.
     return const DynamicType();
@@ skipping 14 matching lines @@
         prefix = prefix.name;
       }
       var suffix = name[1];
       if (suffix is Identifier) {
         suffix = suffix.name;
       }
       Builder builder;
       if (prefix is Builder) {
         builder = prefix;
       } else {
-        builder = scope.lookup(prefix);
+        builder = scope.lookup(prefix, beginToken.charOffset, uri);
       }
       if (builder is PrefixBuilder) {
         name = builder.exports[suffix];
       } else {
         return inputError(
             "Can't be used as a type: '${debugName(prefix, suffix)}'.",
             beginToken.charOffset);
       }
     }
     if (name is Identifier) {
       name = name.name;
     }
     if (name is BuilderAccessor) {
       warning("'${beginToken.value}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is UnresolvedIdentifier) {
       warning("'${name.name}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is TypeVariableBuilder) {
       push(name.buildTypesWithBuiltArguments(arguments));
     } else if (name is TypeDeclarationBuilder) {
       push(name.buildTypesWithBuiltArguments(arguments));
     } else if (name is TypeBuilder) {
       push(name.build());
     } else {
-      push(toKernelType(name, arguments));
+      push(toKernelType(name, arguments, beginToken.charOffset));
     }
     if (peek() is TypeParameterType) {
       TypeParameterType type = peek();
       if (!isInstanceContext && type.parameter.parent is Class) {
         pop();
         warning("Type variables can only be used in instance methods.",
             beginToken.charOffset);
         push(const DynamicType());
       }
     }
@@ skipping 38 matching lines @@
   @override
   void endThrowExpression(Token throwToken, Token endToken) {
     debugEvent("ThrowExpression");
     Expression expression = popForValue();
     push(new Throw(expression));
   }
 
   @override
   void endFormalParameter(Token thisKeyword) {
     debugEvent("FormalParameter");
+    // TODO(ahe): Need beginToken here.
+    int charOffset = thisKeyword?.charOffset;
     if (thisKeyword != null) {
       if (!inConstructor) {
         return inputError("'this' parameters can only be used on constructors.",
             thisKeyword.charOffset);
       }
     }
     Identifier name = pop();
     DartType type = pop();
     pop(); // Modifiers.
     ignore(Unhandled.Metadata);
     VariableDeclaration variable;
     if (!inCatchClause && functionNestingLevel == 0) {
-      var builder = formalParameterScope.lookup(name.name);
+      var builder = formalParameterScope.lookup(name.name, charOffset, uri);
       if (builder == null) {
         return inputError("'${name.name}' isn't a field in this class.",
             name.fileOffset);
       }
       if (thisKeyword == null) {
         variable = builder.build();
         variable.initializer = name.initializer;
       } else if (builder.isField && builder.parent == classBuilder) {
         FieldBuilder field = builder;
         if (type != null) {
@@ skipping 57 matching lines @@
     debugEvent("FormalParameters");
     OptionalFormals optional;
     if (count > 0 && peek() is OptionalFormals) {
       optional = pop();
       count--;
     }
     FormalParameters formals = new FormalParameters(
         popList(count) ?? <VariableDeclaration>[], optional);
     push(formals);
     if (inCatchClause || functionNestingLevel != 0) {
-      enterLocalScope(formals.computeFormalParameterScope(scope));
+      enterLocalScope(formals.computeFormalParameterScope(
+              scope, member ?? classBuilder ?? library));
     }
   }
 
   @override
   void beginCatchClause(Token token) {
     debugEvent("beginCatchClause");
     inCatchClause = true;
   }
 
   @override
@@ skipping 344 matching lines @@
   }
 
   @override
   void endFunctionName(Token token) {
     debugEvent("FunctionName");
     Identifier name = pop();
     VariableDeclaration variable = new VariableDeclaration(
         name.name, isFinal: true);
     push(new FunctionDeclaration(variable,
             new FunctionNode(new InvalidStatement())));
-    scope[variable.name] = new KernelVariableBuilder(variable);
+    scope[variable.name] = new KernelVariableBuilder(variable,
+        // TODO(ahe): This should be `member ?? classBuilder ?? part`, but we
+        // don't have an object representing the current part.
+        member ?? classBuilder);
     enterLocalScope();
   }
 
   @override
   void beginFunction(Token token) {
     debugEvent("beginFunction");
     functionNestingLevel++;
   }
 
   @override
@@ skipping 129 matching lines @@
     debugEvent("Label");
     Identifier identifier = pop();
     push(new Label(identifier.name));
   }
 
   @override
   void beginLabeledStatement(Token token, int labelCount) {
     debugEvent("beginLabeledStatement");
     List<Label> labels = popList(labelCount);
     enterLocalScope();
-    LabelTarget target = new LabelTarget();
+    LabelTarget target = new LabelTarget(member, token.charOffset);
     for (Label label in labels) {
       scope[label.name] = target;
     }
     push(target);
   }
 
   @override
   void endLabeledStatement(int labelCount) {
     debugEvent("LabeledStatement");
     Statement statement = popStatement();
@@ skipping 64 matching lines @@
   void endYieldStatement(Token yieldToken, Token starToken, Token endToken) {
     debugEvent("YieldStatement");
     push(new YieldStatement(popForValue(), isYieldStar: starToken != null));
   }
 
   @override
   void beginSwitchBlock(Token token) {
     debugEvent("beginSwitchBlock");
     enterLocalScope();
     enterSwitchScope();
-    enterBreakTarget();
+    enterBreakTarget(token.charOffset);
   }
 
   @override
   void beginSwitchCase(int labelCount, int expressionCount, Token firstToken) {
     debugEvent("beginSwitchCase");
     List labelsAndExpressions = popList(labelCount + expressionCount);
     List<Label> labels = <Label>[];
     List<Expression> expressions = <Expression>[];
     if (labelsAndExpressions != null) {
       for (var labelOrExpression in labelsAndExpressions) {
         if (labelOrExpression is Label) {
           labels.add(labelOrExpression);
         } else {
           expressions.add(toValue(labelOrExpression));
         }
       }
     }
     assert(scope == switchScope);
     for (Label label in labels) {
       Builder existing = scope.local[label.name];
       if (existing == null) {
-        scope[label.name] = createGotoTarget();
+        scope[label.name] = createGotoTarget(firstToken.charOffset);
       } else {
         // TODO(ahe): Should validate this is a goto target and not duplicated.
       }
     }
     push(expressions);
     push(labels);
     enterLocalScope();
   }
 
   @override
@@ skipping 21 matching lines @@
 
   @override
   void endSwitchBlock(int caseCount, Token beginToken, Token endToken) {
     debugEvent("SwitchBlock");
     List<SwitchCase> cases =
         new List<SwitchCase>.filled(caseCount, null, growable: true);
     for (int i = caseCount - 1; i >= 0; i--) {
       List<Label> labels = pop();
       SwitchCase current = cases[i] = pop();
       for (Label label in labels) {
-        JumpTarget target = switchScope.lookup(label.name);
+        JumpTarget target =
+            switchScope.lookup(label.name, label.fileOffset, uri);
         if (target != null) {
           target.resolveGotos(current);
         }
       }
       // TODO(ahe): Validate that there's only one default and it's last.
     }
     JumpTarget target = exitBreakTarget();
     exitSwitchScope();
     exitLocalScope();
     Expression expression = popForValue();
@@ skipping 13 matching lines @@
 
   @override
   void handleBreakStatement(
       bool hasTarget, Token breakKeyword, Token endToken) {
     debugEvent("BreakStatement");
     var target = breakTarget;
     String name;
     if (hasTarget) {
       Identifier identifier = pop();
       name = identifier.name;
-      target = scope.lookup(identifier.name);
+      target = scope.lookup(
+          identifier.name, breakKeyword.next.charOffset, uri);
     }
     if (target == null && name == null) {
       push(compileTimeErrorInLoopOrSwitch =
           buildCompileTimeErrorStatement(
               "No target of break.", breakKeyword.charOffset));
     } else if (target == null || target is! JumpTarget
         || !target.isBreakTarget) {
       push(compileTimeErrorInLoopOrSwitch =
           buildCompileTimeErrorStatement("Can't break to '$name'.",
               breakKeyword.next.charOffset));
     } else {
       BreakStatement statement = new BreakStatement(null);
       target.addBreak(statement);
       push(statement);
     }
   }
 
   @override
   void handleContinueStatement(
       bool hasTarget, Token continueKeyword, Token endToken) {
     debugEvent("ContinueStatement");
     var target = continueTarget;
     String name;
     if (hasTarget) {
       Identifier identifier = pop();
       name = identifier.name;
-      target = scope.lookup(identifier.name);
+      target = scope.lookup(
+          identifier.name, continueKeyword.next.charOffset, uri);
       if (target != null && target is! JumpTarget) {
         push(compileTimeErrorInLoopOrSwitch =
             buildCompileTimeErrorStatement(
                 "Target of continue must be a label.",
                 continueKeyword.charOffset));
         return;
       }
       if (target == null) {
         if (switchScope == null) {
           push(buildCompileTimeErrorStatement("Can't find label '$name'.",
                   continueKeyword.next.charOffset));
           return;
         }
-        switchScope[identifier.name] = target = createGotoTarget();
+        switchScope[identifier.name] = target =
+            createGotoTarget(identifier.fileOffset);
       }
       if (target.isGotoTarget) {
         ContinueSwitchStatement statement = new ContinueSwitchStatement(null);
         target.addGoto(statement);
         push(statement);
         return;
       }
     }
     if (target == null) {
       push(compileTimeErrorInLoopOrSwitch =
@@ skipping 372 matching lines @@
     return accessor.buildPostfixIncrement(binaryOperator, voidContext: true,
         interfaceTarget: interfaceTarget);
   }
 }
 
 class JumpTarget extends Builder {
   final List<Statement> users = <Statement>[];
 
   final JumpTargetKind kind;
 
-  JumpTarget(this.kind);
+  JumpTarget(this.kind, MemberBuilder member, int charOffset)
+      : super(member, charOffset, member.fileUri);
 
   bool get isBreakTarget => kind == JumpTargetKind.Break;
 
   bool get isContinueTarget => kind == JumpTargetKind.Continue;
 
   bool get isGotoTarget => kind == JumpTargetKind.Goto;
 
   bool get hasUsers => users.isNotEmpty;
 
   void addBreak(BreakStatement statement) {
@@ skipping 30 matching lines @@
   void resolveGotos(SwitchCase target) {
     assert(isGotoTarget);
     for (ContinueSwitchStatement user in users) {
       user.target = target;
     }
     users.clear();
   }
 }
 
 class LabelTarget extends Builder implements JumpTarget {
-  final JumpTarget breakTarget = new JumpTarget(JumpTargetKind.Break);
+  final JumpTarget breakTarget;
 
-  final JumpTarget continueTarget = new JumpTarget(JumpTargetKind.Continue);
+  final JumpTarget continueTarget;
 
-  LabelTarget();
+  LabelTarget(MemberBuilder member, int charOffset)
+      : breakTarget = new JumpTarget(JumpTargetKind.Break, member, charOffset),
+        continueTarget =
+            new JumpTarget(JumpTargetKind.Continue, member, charOffset),
+        super(member, charOffset, member.fileUri);
 
   bool get hasUsers => breakTarget.hasUsers || continueTarget.hasUsers;
 
   List<Statement> get users => internalError("Unsupported operation.");
 
   JumpTargetKind get kind => internalError("Unsupported operation.");
 
   bool get isBreakTarget => true;
 
   bool get isContinueTarget => true;
@@ skipping 73 matching lines @@
           namedParameters.add(new NamedType(parameter.name, parameter.type));
         }
         namedParameters.sort();
       }
     }
     return new FunctionType(positionalParameters, returnType,
         namedParameters: namedParameters,
         requiredParameterCount: requiredParameterCount);
   }
 
-  Scope computeFormalParameterScope(Scope parent) {
+  Scope computeFormalParameterScope(Scope parent, Builder builder) {
     if (required.length == 0 && optional == null) return parent;
     Map<String, Builder> local = <String, Builder>{};
     for (VariableDeclaration parameter in required) {
-      local[parameter.name] = new KernelVariableBuilder(parameter);
+      local[parameter.name] = new KernelVariableBuilder(parameter, builder);
     }
     if (optional != null) {
       for (VariableDeclaration parameter in optional.formals) {
-        local[parameter.name] = new KernelVariableBuilder(parameter);
+        local[parameter.name] = new KernelVariableBuilder(parameter, builder);
       }
     }
     return new Scope(local, parent, isModifiable: false);
   }
 }
 
 /// Returns a block like this:
 ///
 ///     {
 ///       statement;
@@ skipping 24 matching lines @@
   } else if (node is TypeDeclarationBuilder) {
     return node.name;
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisPropertyAccessor) {
     return node.name.name;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }