Avoid using Invalid{Statement,Expression,Initializer}.

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, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, MemberKind, optional;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
 
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart'
     show FieldNode;
 
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'
     show TypeInferrer;
 
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart'
     show TypePromoter;
 
-import 'package:kernel/ast.dart';
+import 'package:kernel/ast.dart'
+    hide InvalidExpression, InvalidInitializer, InvalidStatement;
 
 import 'package:kernel/clone.dart' show CloneVisitor;
 
 import 'package:kernel/transformations/flags.dart' show TransformerFlag;
 
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 
 import 'package:kernel/core_types.dart' show CoreTypes;
 
 import 'frontend_accessors.dart' show buildIsNull, makeBinary, makeLet;
@@ skipping 418 matching lines @@
     var node = pop();
     Initializer initializer;
     if (node is Initializer) {
       initializer = node;
     } else if (node is FastaAccessor) {
       initializer = node.buildFieldInitializer(fieldInitializers);
     } else if (node is ConstructorInvocation) {
       initializer =
           buildSuperInitializer(node.target, node.arguments, token.charOffset);
     } else {
+      Expression value = toValue(node);
       if (node is! Throw) {
-        // TODO(ahe): This is probably an internal error.
-        needsImplicitSuperInitializer = false;
-        node = wrapInvalid(node);
+        value = wrapInCompileTimeError(value, "Expected an initializer.");
       }
       initializer = buildInvalidIntializer(node, token.charOffset);
     }
     _typeInferrer.inferInitializer(initializer);
     if (member is KernelConstructorBuilder) {
       member.addInitializer(initializer);
     } else {
       addCompileTimeError(
           token.charOffset, "Can't have initializers: ${member.name}");
     }
@@ skipping 746 matching lines @@
     Block block = popBlock(count, beginToken);
     exitLocalScope();
     push(block);
   }
 
   @override
   void handleAssignmentExpression(Token token) {
     debugEvent("AssignmentExpression");
     Expression value = popForValue();
     var accessor = pop();
-    if (accessor is TypeDeclarationBuilder) {
-      push(wrapInvalid(new KernelTypeLiteral(
-          accessor.buildTypesWithBuiltArguments(library, null))));
-    } else if (accessor is! FastaAccessor) {
+    if (accessor is TypeDeclarationBuilder || accessor is! FastaAccessor) {

[ahe, 2017/05/29 13:14:47]

This change is what's causing the new compile-time errors. In a later CL, I'll
switch to representing types as accessors, and this will behave correctly.

       push(buildCompileTimeError("Can't assign to this.", token.charOffset));
     } else {
       push(new DelayedAssignment(
           this, token, accessor, value, token.stringValue));
     }
   }
 
   @override
   void enterLoop(int charOffset) {
     if (peek() is LabelTarget) {
@@ skipping 510 matching lines @@
     VariableDeclaration stackTrace;
     if (catchParameters != null) {
       if (catchParameters.required.length > 0) {
         exception = catchParameters.required[0];
       }
       if (catchParameters.required.length > 1) {
         stackTrace = catchParameters.required[1];
       }
       if (catchParameters.required.length > 2 ||
           catchParameters.optional != null) {
-        body = new Block(<Statement>[new InvalidStatement()]);
-        compileTimeErrorInTry ??= buildCompileTimeErrorStatement(
-            "Invalid catch arguments.", catchKeyword.next.charOffset);
+        body = new Block(<Statement>[
+          compileTimeErrorInTry ??= buildCompileTimeErrorStatement(
+              "Invalid catch arguments.", catchKeyword.next.charOffset)
+        ]);
       }
     }
     push(new Catch(exception, body, guard: type, stackTrace: stackTrace));
   }
 
   @override
   void endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) {
     Statement finallyBlock = popStatementIfNotNull(finallyKeyword);
     List<Catch> catches = popList(catchCount);
     Statement tryBlock = popStatement();
@@ skipping 65 matching lines @@
   }
 
   @override
   void handleUnaryPrefixAssignmentExpression(Token token) {
     debugEvent("UnaryPrefixAssignmentExpression");
     var accessor = pop();
     if (accessor is FastaAccessor) {
       push(accessor.buildPrefixIncrement(incrementOperator(token),
           offset: token.charOffset));
     } else {
-      push(wrapInvalid(toValue(accessor)));
+      push(wrapInCompileTimeError(toValue(accessor), "Can't assign to this."));
     }
   }
 
   @override
   void handleUnaryPostfixAssignmentExpression(Token token) {
     debugEvent("UnaryPostfixAssignmentExpression");
     var accessor = pop();
     if (accessor is FastaAccessor) {
       push(new DelayedPostfixIncrement(
           this, token, accessor, incrementOperator(token), null));
     } else {
-      push(wrapInvalid(toValue(accessor)));
+      push(wrapInCompileTimeError(toValue(accessor), "Can't assign to this."));
     }
   }
 
   @override
   void endConstructorReference(
       Token start, Token periodBeforeName, Token endToken) {
     debugEvent("ConstructorReference");
     // A constructor reference can contain up to three identifiers:
     //
     //     a) type <type-arguments>?
@@ skipping 249 matching lines @@
 
   @override
   void endFunctionName(Token beginToken, Token token) {
     debugEvent("FunctionName");
     Identifier name = pop();
     VariableDeclaration variable = new KernelVariableDeclaration(
         name.name, functionNestingLevel,
         isFinal: true, isLocalFunction: true)
       ..fileOffset = offsetForToken(name.token);
     push(new KernelFunctionDeclaration(
-        variable, new FunctionNode(new InvalidStatement()))
+        variable,
+        // The function node is created later.
+        null)
       ..fileOffset = beginToken.charOffset);
     declareVariable(variable);
     enterLocalScope();
   }
 
   void enterFunction() {
     debugEvent("enterFunction");
     functionNestingLevel++;
     push(switchScope ?? NullValue.SwitchScope);
     switchScope = null;
@@ skipping 500 matching lines @@
   @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);
     String message = formatUnexpected(uri, charOffset, error);
     Builder constructor = library.loader.getCompileTimeError();
     return new Throw(buildStaticInvocation(constructor.target,
-        new KernelArguments(<Expression>[new StringLiteral(message)])));
+        new KernelArguments(<Expression>[new StringLiteral(message)]),
+        charOffset: charOffset));
+  }
+
+  Expression wrapInCompileTimeError(Expression expression, String message) {
+    return new Let(
+        new VariableDeclaration.forValue(expression)
+          ..fileOffset = expression.fileOffset,
+        buildCompileTimeError(message, expression.fileOffset))
+      ..fileOffset = expression.fileOffset;
   }
 
   Expression buildAbstractClassInstantiationError(String className,
       [int charOffset = -1]) {
     warning("The class '$className' is abstract and can't be instantiated.",
         charOffset);
     Builder constructor = library.loader.getAbstractClassInstantiationError();
     return new Throw(buildStaticInvocation(constructor.target,
         new KernelArguments(<Expression>[new StringLiteral(className)])));
   }
@@ skipping 30 matching lines @@
   }
 
   @override
   Expression buildProblemExpression(ProblemBuilder builder, int charOffset) {
     return buildCompileTimeError(builder.message, charOffset);
   }
 
   @override
   void handleOperator(Token token) {
     debugEvent("Operator");
-    push(new Operator(token.stringValue)..fileOffset = token.charOffset);
+    push(new Operator(token.stringValue, token.charOffset));
   }
 
   @override
   void handleSymbolVoid(Token token) {
     debugEvent("SymbolVoid");
     push(new Identifier(token));
   }
 
   @override
   dynamic addCompileTimeError(int charOffset, String message,
       {bool silent: 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);
   }
 
   @override
   void handleInvalidFunctionBody(Token token) {
     if (member.isNative) {
       push(NullValue.FunctionBody);
     } else {
-      push(new Block(<Statement>[new InvalidStatement()]));
+      push(new Block(<Statement>[
+        buildCompileTimeErrorStatement("Expected '{'.", token.charOffset)
+      ]));
     }
   }
 
   @override
   void warning(String message, [int charOffset = -1]) {
     if (constantExpressionRequired) {
       addCompileTimeError(charOffset, message);
     } else {
       super.warning(message, charOffset);
     }
@@ skipping 48 matching lines @@
   final Token token;
   String get name => token.lexeme;
 
   Identifier(this.token);
 
   Expression get initializer => null;
 
   String toString() => "identifier($name)";
 }
 
-// TODO(ahe): Shouldn't need to be an expression.
-class Operator extends InvalidExpression {
+class Operator {
   final String name;
 
-  Operator(this.name);
+  final int charOffset;
+
+  Operator(this.name, this.charOffset);
 
   String toString() => "operator($name)";
 }
 
 class InitializedIdentifier extends Identifier {
   final Expression initializer;
 
   InitializedIdentifier(Token token, this.initializer) : super(token);
 
   String toString() => "initialized-identifier($name, $initializer)";
 }
 
-// TODO(ahe): Shouldn't need to be an expression.
-class Label extends InvalidExpression {
+class Label {
   String name;
 
   Label(this.name);
 
   String toString() => "label($name)";
 }
 
 abstract class ContextAccessor extends FastaAccessor {
   final BuilderHelper helper;
 
@@ skipping 406 matching lines @@
     if (starToken == null) {
       return AsyncMarker.Async;
     } else {
       assert(identical(starToken.stringValue, "*"));
       return AsyncMarker.AsyncStar;
     }
   } else {
     return internalError("Unknown async modifier: $asyncToken");
   }
 }