Improve recovery from compile-time errors.

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 '../fasta_codes.dart'
     show
         FastaMessage,
         codeConstFieldWithoutInitializer,
@@ skipping 993 matching lines @@
     if (builder != null && member.isField && builder.isInstanceMember) {
       return new IncompleteError(this, token,
           "Can't access 'this' in a field initializer to read '$name'.");
     }
     if (builder == null || (!isInstanceContext && builder.isInstanceMember)) {
       Name n = new Name(name, library.library);
       if (prefix != null &&
           prefix.deferred &&
           builder == null &&
           "loadLibrary" == name) {
-        return buildCompileTimeError(
-            "Deferred loading isn't implemented yet.", offsetForToken(token));
+        int offset = offsetForToken(token);
+        const String message = "Deferred loading isn't implemented yet.";
+        // We report the error twice, the first time silently and marking it as
+        // unhandled. This ensures that the compile-time error is reported
+        // eagerly by kernel-service, thus preventing any attempts from running
+        // a program that uses deferred loading. Obviously, this is a temporary
+        // solution until we can fully implement deferred loading.
+        addCompileTimeError(offset, message, wasHandled: false, silent: true);
+        return buildCompileTimeError(message, offset);
       } else if (!isQualified && isInstanceContext) {
         assert(builder == null);
         if (constantExpressionRequired || member.isField) {
           return new UnresolvedAccessor(this, n, token);
         }
         return new ThisPropertyAccessor(this, token, n, null, null);
       } else if (isBuiltinLibrary &&
           name == "main" &&
           member?.name == "_getMainClosure") {
         // TODO(ahe): https://github.com/dart-lang/sdk/issues/28989
@@ skipping 1003 matching lines @@
       name = "";
     }
     push(type);
     push(typeArguments ?? NullValue.TypeArguments);
     push(name);
   }
 
   @override
   Expression buildStaticInvocation(Member target, Arguments arguments,
       {bool isConst: false, int charOffset: -1, Member initialTarget}) {
+    initialTarget ??= target;
     List<TypeParameter> typeParameters = target.function.typeParameters;
     if (target is Constructor) {
       assert(!target.enclosingClass.isAbstract);
       typeParameters = target.enclosingClass.typeParameters;
     }
     if (!checkArguments(target.function, arguments, typeParameters)) {
       return throwNoSuchMethodError(new NullLiteral()..fileOffset = charOffset,
           target.name.name, arguments, charOffset);
     }
     if (target is Constructor) {
@@ skipping 297 matching lines @@
       function.returnType = returnType;
       declaration.variable.type = function.functionType;
       declaration.function = function;
       function.parent = declaration;
     } else {
       // If [declaration] isn't a [FunctionDeclaration], it must be because
       // there was a compile-time error.
 
       // TODO(paulberry): ensure that when integrating with analyzer, type
       // inference is still performed for the dropped declaration.
-      assert(library.compileTimeErrors.isNotEmpty);
+      assert(library.hasCompileTimeErrors);
     }
     push(declaration);
   }
 
   @override
   void endUnnamedFunction(Token beginToken, Token token) {
     debugEvent("UnnamedFunction");
     Statement body = popStatement();
     AsyncMarker asyncModifier = pop();
     exitLocalScope();
@@ skipping 513 matching lines @@
     }
     return super.handleUnrecoverableError(token, message);
   }
 
   @override
   Expression buildCompileTimeError(error, [int charOffset = -1]) {
     // TODO(ahe): This method should be passed the erroneous expression, wrap
     // it in a class (TBD) from which the erroneous expression can be easily
     // extracted. Similar for statements and initializers. See also [issue
     // 29717](https://github.com/dart-lang/sdk/issues/29717)
-    addCompileTimeError(charOffset, error);
+    addCompileTimeError(charOffset, error, wasHandled: true);
     return library.loader.throwCompileConstantError(library.loader
         .buildCompileTimeError(
             formatUnexpected(uri, charOffset, error), charOffset));
   }
 
   Expression wrapInCompileTimeError(Expression expression, String message) {
     return new Let(
         new VariableDeclaration.forValue(expression)
           ..fileOffset = expression.fileOffset,
         buildCompileTimeError(message, expression.fileOffset))
@@ skipping 113 matching lines @@
   }
 
   @override
   void handleSymbolVoid(Token token) {
     debugEvent("SymbolVoid");
     push(new Identifier(token));
   }
 
   @override
   dynamic addCompileTimeError(int charOffset, String message,
-      {bool silent: false}) {
+      {bool silent: false, bool wasHandled: false}) {
     // TODO(ahe): If constantExpressionRequired is set, set it to false to
     // avoid a long list of errors.
     return library.addCompileTimeError(charOffset, message,
-        fileUri: uri, silent: silent);
+        fileUri: uri, silent: silent, wasHandled: wasHandled);
   }
 
   @override
   void handleInvalidFunctionBody(Token token) {
     if (member.isNative) {
       push(NullValue.FunctionBody);
     } else {
       push(new Block(<Statement>[
         buildCompileTimeErrorStatement("Expected '{'.", token.charOffset)
       ]));
@@ skipping 538 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }