Improve compile-time error handling.

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 20 matching lines @@
 import 'package:front_end/src/fasta/scanner/token.dart' show
     BeginGroupToken,
     Token,
     isBinaryOperator,
     isMinusOperator;
 
 import '../errors.dart' show
     InputError,
     internalError;
 
-import '../errors.dart' as errors show
-    inputError;
-
 import '../source/scope_listener.dart' show
     JumpTargetKind,
     NullValue,
     ScopeListener;
 
 import '../builder/scope.dart' show
     AccessErrorBuilder,
     AmbiguousBuilder,
     Scope;
 
@@ skipping 358 matching lines @@
     } else {
       if (node is !Throw) {
         node = wrapInvalid(node);
       }
       initializer =
           new LocalInitializer(new VariableDeclaration.forValue(node));
     }
     if (member is KernelConstructorBuilder) {
       member.addInitializer(initializer);
     } else {
-      inputError("Can't have initializers: ${member.name}", token.charOffset);
+      addCompileTimeError(token.charOffset,
+          "Can't have initializers: ${member.name}");
     }
   }
 
   @override
   void handleNoInitializers() {
     debugEvent("NoInitializers");
   }
 
   @override
   void endInitializers(int count, Token beginToken, Token endToken) {
     debugEvent("Initializers");
   }
 
   @override
   void finishFunction(FormalParameters formals,
       AsyncMarker asyncModifier, Statement body) {
     debugEvent("finishFunction");
     KernelFunctionBuilder builder = member;
     if (builder is KernelConstructorBuilder) {
       if (asyncModifier != AsyncMarker.Sync) {
         // TODO(ahe): Change this to a null check.
-        inputError("Can't be marked as ${asyncModifier}: ${builder.name}",
-            body?.fileOffset);
+        addCompileTimeError(body?.fileOffset,
+            "Can't be marked as ${asyncModifier}: ${builder.name}");
       }
     } else if (builder is KernelProcedureBuilder) {
       builder.asyncModifier = asyncModifier;
     } else {
       internalError("Unhandled: ${builder.runtimeType}");
     }
     builder.body = body;
     if (formals?.optional != null) {
       Iterator<FormalParameterBuilder> formalBuilders =
           builder.formals.skip(formals.required.length).iterator;
@@ skipping 705 matching lines @@
   }
 
   @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();
     var name = pop();
     if (name is List) {
       if (name.length != 2) {
-        return internalError("Unexpected: $name.length");
+        internalError("Unexpected: $name.length");
       }
       var prefix = name[0];
       if (prefix is Identifier) {
         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, 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);
+        push(const DynamicType());
+        addCompileTimeError(beginToken.charOffset,
+            "Can't be used as a type: '${debugName(prefix, suffix)}'.");
+        return;
       }
     }
     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);
@@ skipping 61 matching lines @@
     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);
+        addCompileTimeError(thisKeyword.charOffset,
+            "'this' parameters can only be used on constructors.");
+        thisKeyword = null;
       }
     }
     Identifier name = pop();
     DartType type = pop();
     pop(); // Modifiers.
     ignore(Unhandled.Metadata);
     VariableDeclaration variable;
     if (!inCatchClause && functionNestingLevel == 0) {
       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) {
+        if (thisKeyword == null) {
+          internalError("Internal error: formal missing for '${name.name}'");
+        } else {
+          addCompileTimeError(thisKeyword.charOffset,
+              "'${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);
         }
         type = field.target.type ?? const DynamicType();
         variable = new VariableDeclaration(name.name, type: type,
             initializer: name.initializer);
       } else {
-        return inputError("'${name.name}' isn't a field in this class.",
-            name.fileOffset);
+        addCompileTimeError(name.fileOffset,
+            "'${name.name}' isn't a field in this class.");
       }
-    } else {
-      variable = new VariableDeclaration(name.name,
-          type: type ?? const DynamicType(), initializer: name.initializer);
     }
+    variable ??= new VariableDeclaration(name.name,
+        type: type ?? const DynamicType(), initializer: name.initializer);
     push(variable);
   }
 
   @override
   void endOptionalFormalParameters(
       int count, Token beginToken, Token endToken) {
     debugEvent("OptionalFormalParameters");
     FormalParameterType kind = optional("{", beginToken)
         ? FormalParameterType.NAMED : FormalParameterType.POSITIONAL;
     push(new OptionalFormals(kind, popList(count)));
@@ skipping 526 matching lines @@
       ///       lvalue = #t;
       ///       body;
       ///     }
       variable = new VariableDeclaration.forValue(null);
       body = combineStatements(
           new ExpressionStatement(
               lvalue.buildAssignment(
                   new VariableGet(variable), voidContext: true)),
           body);
     } else {
-      throw inputError("Expected lvalue, but got ${lvalue}",
-          forToken.next.next.charOffset);
+      variable = new VariableDeclaration.forValue(
+          buildCompileTimeError("Expected lvalue, but got ${lvalue}",
+              forToken.next.next.charOffset));
     }
     Statement result = new ForInStatement(variable, expression, body,
         isAsync: awaitToken != null);
     if (breakTarget.hasUsers) {
       result = new LabeledStatement(result);
       breakTarget.resolveBreaks(result);
     }
     exitLoopOrSwitch(result);
   }
 
@@ skipping 362 matching lines @@
       return internalError("Unhandled: ${builder.runtimeType}");
     }
   }
 
   @override
   void handleOperator(Token token) {
     debugEvent("Operator");
     push(new Operator(token.stringValue)..fileOffset = token.charOffset);
   }
 
-  dynamic inputError(String message, [int charOffset = -1]) {
-    return errors.inputError(uri, charOffset, message);
+  dynamic addCompileTimeError(int charOffset, String message) {
+    return library.addCompileTimeError(charOffset, message, uri);
   }
 
   @override
   void handleInvalidFunctionBody(Token token) {
     if (!lastErrorWasNativeFunctionBody) {
       push(new Block(<Statement>[new InvalidStatement()]));
     }
     lastErrorWasNativeFunctionBody = false;
   }
 
@@ skipping 446 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}");
   }
 }