Avoid using Invalid{Statement,Expression,Initializer}.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.dart

 // Copyright (c) 2017, 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.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
 ///
 /// Note that these classes represent the Dart language prior to desugaring.
 /// When a single Dart construct desugars to a tree containing multiple kernel
 /// AST nodes, the shadow class extends the kernel object at the top of the
 /// desugared tree.
 ///
 /// This means that in some cases multiple shadow classes may extend the same
 /// kernel class, because multiple constructs in Dart may desugar to a tree
 /// with the same kind of root node.
 import 'package:front_end/src/base/instrumentation.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart';
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema_elimination.dart';
-import 'package:kernel/ast.dart';
+import 'package:kernel/ast.dart'
+    hide InvalidExpression, InvalidInitializer, InvalidStatement;
 import 'package:kernel/frontend/accessors.dart';
 import 'package:kernel/type_algebra.dart';
 
+import '../errors.dart' show internalError;
+
 /// Computes the return type of a (possibly factory) constructor.
 InterfaceType computeConstructorReturnType(Member constructor) {
   if (constructor is Constructor) {
     return constructor.enclosingClass.thisType;
   } else {
     return computeFactoryConstructorReturnType(constructor);
   }
 }
 
 /// Computes the return type of a factory constructor.
@@ skipping 133 matching lines @@
   /// Pointer to the last "let" expression in the cascade.
   Let nextCascade;
 
   /// Creates a [KernelCascadeExpression] using [variable] as the cascade
   /// variable.  Caller is responsible for ensuring that [variable]'s
   /// initializer is the expression preceding the first `..` of the cascade
   /// expression.
   KernelCascadeExpression(KernelVariableDeclaration variable)
       : super(
             variable,
-            makeLet(new VariableDeclaration.forValue(new InvalidExpression()),
+            makeLet(new VariableDeclaration.forValue(new _UnfinishedCascade()),
                 new VariableGet(variable))) {
     nextCascade = body;
   }
 
   /// Adds a new unfinalized section to the end of the cascade.  Should be
   /// called after the previous cascade section has been finalized.
   void extend() {
-    assert(nextCascade.variable.initializer is! InvalidExpression);
+    assert(nextCascade.variable.initializer is! _UnfinishedCascade);
     Let newCascade = makeLet(
-        new VariableDeclaration.forValue(new InvalidExpression()),
+        new VariableDeclaration.forValue(new _UnfinishedCascade()),
         nextCascade.body);
     nextCascade.body = newCascade;
     newCascade.parent = nextCascade;
     nextCascade = newCascade;
   }
 
   /// Finalizes the last cascade section with the given [expression].
   void finalize(Expression expression) {
-    assert(nextCascade.variable.initializer is InvalidExpression);
+    assert(nextCascade.variable.initializer is _UnfinishedCascade);
     nextCascade.variable.initializer = expression;
     expression.parent = nextCascade.variable;
   }
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     typeNeeded = inferrer.listener.cascadeExpressionEnter(this, typeContext) ||
         typeNeeded;
     var lhsType = inferrer.inferExpression(
@@ skipping 1321 matching lines @@
           closureContext.isAsync
               ? inferrer.coreTypes.streamClass
               : inferrer.coreTypes.iterableClass);
     }
     var inferredType = inferrer.inferExpression(
         expression, typeContext, closureContext != null);
     closureContext.handleYield(inferrer, isYieldStar, inferredType);
     inferrer.listener.yieldStatementExit(this);
   }
 }
+
+class _UnfinishedCascade extends Expression {
+  getStaticType(types) {
+    return internalError("Internal error: Unsupported operation.");
+  }
+
+  accept(v) {
+    return internalError("Internal error: Unsupported operation.");
+  }
+
+  accept1(v, arg) {
+    return internalError("Internal error: Unsupported operation.");
+  }
+
+  visitChildren(v) {
+    return internalError("Internal error: Unsupported operation.");
+  }
+
+  transformChildren(v) {
+    return internalError("Internal error: Unsupported operation.");
+  }
+}