Implement line and column numbers.

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 61 matching lines @@
 import '../modifier.dart' show
     Modifier,
     constMask,
     finalMask;
 
 import 'redirecting_factory_body.dart' show
     getRedirectionTarget;
 
 import 'kernel_builder.dart';
 
-const bool showNits = false;
-
 final Name callName = new Name("call");
 
 final Name plusName = new Name("+");
 
 final Name minusName = new Name("-");
 
 final Name multiplyName = new Name("*");
 
 final Name divisionName = new Name("/");
 
@@ skipping 25 matching lines @@
 
   final bool isInstanceMember;
 
   final Map<String, FieldInitializer> fieldInitializers =
       <String, FieldInitializer>{};
 
   final Scope enclosingScope;
 
   final bool isDartLibrary;
 
+  @override
+  final Uri uri;
+
   Scope formalParameterScope;
 
   bool isFirstIdentifier = false;
 
   bool hasParserError = false;
 
   bool inInitializer = false;
 
   bool inCatchClause = false;
 
   int functionNestingLevel = 0;
 
   Statement compileTimeErrorInTry;
 
   Statement compileTimeErrorInLoopOrSwitch;
 
   Scope switchScope;
 
   CloneVisitor cloner;
 
   BodyBuilder(KernelLibraryBuilder library, this.member, Scope scope,
       this.formalParameterScope, this.hierarchy, this.coreTypes,
-      this.classBuilder, this.isInstanceMember)
+      this.classBuilder, this.isInstanceMember, this.uri)
       : enclosingScope = scope,
         library = library,
         isDartLibrary = library.uri.scheme == "dart",
         super(scope);
 
   bool get inConstructor {
     return functionNestingLevel == 0 && member is KernelConstructorBuilder;
   }
 
   bool get isInstanceContext {
@@ skipping 104 matching lines @@
   void enterSwitchScope() {
     push(switchScope ?? NullValue.SwitchScope);
     switchScope = scope;
   }
 
   void exitSwitchScope() {
     switchScope = pop();
   }
 
   @override
-  Uri get uri => library.fileUri ?? library.uri;
-
-  @override
   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.
@@ skipping 44 matching lines @@
         field.initializer = initializer;
       }
     }
     pop(); // Type.
     pop(); // Modifiers.
   }
 
   @override
   void endMember() {
     debugEvent("Member");
-    checkEmpty();
+    checkEmpty(-1);
   }
 
   @override
   void endFunctionBody(int count, Token beginToken, Token endToken) {
     debugEvent("FunctionBody");
     if (beginToken == null) {
       assert(count == 0);
       push(NullValue.Block);
     } else {
       Block block = popBlock(count);
@@ skipping 792 matching lines @@
   }
 
   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, charOffset, uri);
     if (builder is TypeDeclarationBuilder) {
       return builder.buildTypesWithBuiltArguments(arguments);
     }
     if (builder == null)  {
-      print("$uri: Type not found: $name");
+      warning("Type not found: '$name'.", charOffset);
     } else {
-      print("$uri: Not a type: $name");
+      warning("Not a type: '$name'.", charOffset);
     }
     // TODO(ahe): Create an error somehow.
     return const DynamicType();
   }
 
   @override
   void endType(Token beginToken, Token endToken) {
     // TODO(ahe): The scope is wrong for return types of generic functions.
     debugEvent("Type");
     List<DartType> arguments = pop();
@@ skipping 124 matching lines @@
               "'${name.name}' isn't a field in this class.");
           thisKeyword = null;
         }
       } else if (thisKeyword == null) {
         variable = builder.build();
         variable.initializer = name.initializer;
       } else if (builder.isField && builder.parent == classBuilder) {
         FieldBuilder field = builder;
         if (type != null) {
           nit("Ignoring type on 'this' parameter '${name.name}'.",
-              name.fileOffset);
+              thisKeyword.charOffset);
         }
         type = field.target.type ?? const DynamicType();
         variable = new VariableDeclaration(name.name, type: type,
             initializer: name.initializer);
       } else {
         addCompileTimeError(name.fileOffset,
             "'${name.name}' isn't a field in this class.");
       }
     }
     variable ??= new VariableDeclaration(name.name,
@@ skipping 846 matching lines @@
   void handleModifiers(int count) {
     debugEvent("Modifiers");
     // TODO(ahe): Copied from outline_builder.dart.
     push(popList(count) ?? NullValue.Modifiers);
   }
 
   @override
   void handleRecoverableError(Token token, ErrorKind kind, Map arguments) {
     super.handleRecoverableError(token, kind, arguments);
     if (!hasParserError) {
-      print("$uri:${recoverableErrors.last}");
+      print(new InputError(uri, recoverableErrors.last.beginOffset,
+              recoverableErrors.last.kind).format());
     }
     hasParserError = true;
   }
 
   @override
   Token handleUnrecoverableError(Token token, ErrorKind kind, Map arguments) {
     if (isDartLibrary && kind == ErrorKind.ExpectedFunctionBody) {
       Token recover = skipNativeClause(token);
       if (recover != null) return recover;
     } else if (kind == ErrorKind.UnexpectedToken) {
       String expected = arguments["expected"];
       const List<String> trailing = const <String>[")", "}", ";", ","];
       if (trailing.contains(token.stringValue) && trailing.contains(expected)) {
         arguments.putIfAbsent("actual", () => token.value);
         handleRecoverableError(token, ErrorKind.ExpectedButGot, arguments);
       }
       return token;
     }
     return super.handleUnrecoverableError(token, kind, arguments);
   }
 
-  void warning(error, [int charOffset = -1]) {
-    String message = new InputError(uri, charOffset, error).format();
-    print(message);
-  }
-
-  void nit(error, [int charOffset = -1]) {
-    if (!showNits) return;
-    String message = new InputError(uri, charOffset, error).format();
-    print(message);
-  }
-
   @override
   Expression buildCompileTimeError(error, [int charOffset = -1]) {
     String message = new InputError(uri, charOffset, error).format();
     print(message);
     Builder constructor = library.loader.getCompileTimeError();
     return new Throw(
         buildStaticInvocation(constructor.target,
             new Arguments(<Expression>[new StringLiteral(message)]),
             isConst: false)); // TODO(ahe): Make this const.
   }
@@ skipping 473 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}");
   }
 }