Add KernelXyzExpression stubs and factory methods.

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_inferrer.dart';
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart';
 import 'package:kernel/ast.dart';
 
+/// Shadow object for [AsExpression].
+class KernelAsExpression extends AsExpression implements KernelExpression {
+  KernelAsExpression(Expression operand, DartType type) : super(operand, type);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [AwaitExpression].
+class KernelAwaitExpression extends AwaitExpression
+    implements KernelExpression {
+  KernelAwaitExpression(Expression operand) : super(operand);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
 /// Concrete shadow object representing a statement block in kernel form.
 class KernelBlock extends Block implements KernelStatement {
   KernelBlock(List<Statement> statements) : super(statements);
 
   @override
   void _inferStatement(KernelTypeInferrer inferrer) {
     for (var statement in statements) {
       inferrer.inferStatement(statement);
     }
   }
 }
 
 /// Concrete shadow object representing a boolean literal in kernel form.
 class KernelBoolLiteral extends BoolLiteral implements KernelExpression {
   KernelBoolLiteral(bool value) : super(value);
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     return inferrer.inferBoolLiteral(typeContext, typeNeeded);
   }
 }
 
+/// Shadow object for [ConditionalExpression].
+class KernelConditionalExpression extends ConditionalExpression
+    implements KernelExpression {
+  KernelConditionalExpression(Expression condition, Expression then,
+      Expression otherwise, DartType staticType)
+      : super(condition, then, otherwise, staticType);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [ConstructorInvocation].
+class KernelConstructorInvocation extends ConstructorInvocation
+    implements KernelExpression {
+  KernelConstructorInvocation(Constructor target, Arguments arguments,
+      {bool isConst: false})
+      : super(target, arguments, isConst: isConst);
+
+  KernelConstructorInvocation.byReference(
+      Reference targetReference, Arguments arguments)
+      : super.byReference(targetReference, arguments);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [DirectMethodInvocation].
+class KernelDirectMethodInvocation extends DirectMethodInvocation
+    implements KernelExpression {
+  KernelDirectMethodInvocation(
+      Expression receiver, Procedure target, Arguments arguments)
+      : super(receiver, target, arguments);
+
+  KernelDirectMethodInvocation.byReference(
+      Expression receiver, Reference targetReference, Arguments arguments)
+      : super.byReference(receiver, targetReference, arguments);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [DirectPropertyGet].
+class KernelDirectPropertyGet extends DirectPropertyGet
+    implements KernelExpression {
+  KernelDirectPropertyGet(Expression receiver, Member target)
+      : super(receiver, target);
+
+  KernelDirectPropertyGet.byReference(
+      Expression receiver, Reference targetReference)
+      : super.byReference(receiver, targetReference);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [DirectPropertySet].
+class KernelDirectPropertySet extends DirectPropertySet
+    implements KernelExpression {
+  KernelDirectPropertySet(Expression receiver, Member target, Expression value)
+      : super(receiver, target, value);
+
+  KernelDirectPropertySet.byReference(
+      Expression receiver, Reference targetReference, Expression value)
+      : super.byReference(receiver, targetReference, value);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
 /// Concrete shadow object representing a double literal in kernel form.
 class KernelDoubleLiteral extends DoubleLiteral implements KernelExpression {
   KernelDoubleLiteral(double value) : super(value);
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     return inferrer.inferDoubleLiteral(typeContext, typeNeeded);
   }
 }
@@ skipping 130 matching lines @@
       : super(expressions, typeArgument: typeArgument, isConst: isConst);
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(paulberry): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
+/// Shadow object for [LogicalExpression].
+class KernelLogicalExpression extends LogicalExpression
+    implements KernelExpression {
+  KernelLogicalExpression(Expression left, String operator, Expression right)
+      : super(left, operator, right);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [MapLiteral].
+class KernelMapLiteral extends MapLiteral implements KernelExpression {
+  KernelMapLiteral(List<MapEntry> entries,
+      {DartType keyType: const DynamicType(),
+      DartType valueType: const DynamicType(),
+      bool isConst: false})
+      : super(entries,
+            keyType: keyType, valueType: valueType, isConst: isConst);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [MethodInvocation].
+class KernelMethodInvocation extends MethodInvocation
+    implements KernelExpression {
+  KernelMethodInvocation(Expression receiver, Name name, Arguments arguments)
+      : super(receiver, name, arguments);
+
+  KernelMethodInvocation.byReference(Expression receiver, Name name,
+      Arguments arguments, Reference interfaceTargetReference)
+      : super.byReference(receiver, name, arguments, interfaceTargetReference);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [Not].
+class KernelNot extends Not implements KernelExpression {
+  KernelNot(Expression operand) : super(operand);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
 /// Concrete shadow object representing a null literal in kernel form.
 class KernelNullLiteral extends NullLiteral implements KernelExpression {
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(paulberry): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }
 
+/// Shadow object for [PropertyGet].
+class KernelPropertyGet extends PropertyGet implements KernelExpression {
+  KernelPropertyGet(Expression receiver, Name name) : super(receiver, name);
+
+  KernelPropertyGet.byReference(
+      Expression receiver, Name name, Reference interfaceTargetReference)
+      : super.byReference(receiver, name, interfaceTargetReference);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [PropertyGet].
+class KernelPropertySet extends PropertySet implements KernelExpression {
+  KernelPropertySet(Expression receiver, Name name, Expression value)
+      : super(receiver, name, value);
+
+  KernelPropertySet.byReference(Expression receiver, Name name,
+      Expression value, Reference interfaceTargetReference)
+      : super.byReference(receiver, name, value, interfaceTargetReference);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [Rethrow].
+class KernelRethrow extends Rethrow implements KernelExpression {
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
 /// Concrete shadow object representing a return statement in kernel form.
 class KernelReturnStatement extends ReturnStatement implements KernelStatement {
   KernelReturnStatement([KernelExpression expression]) : super(expression);
 
   @override
   void _inferStatement(KernelTypeInferrer inferrer) {
     // TODO(paulberry): implement.
   }
 }
 
@@ skipping 10 matching lines @@
 class KernelStaticGet extends StaticGet implements KernelExpression {
   KernelStaticGet(Member target) : super(target);
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     return inferrer.inferStaticGet(typeContext, typeNeeded, target.getterType);
   }
 }
 
+/// Shadow object for [StaticInvocation].
+class KernelStaticInvocation extends StaticInvocation
+    implements KernelExpression {
+  KernelStaticInvocation(Procedure target, Arguments arguments,
+      {bool isConst: false})
+      : super(target, arguments, isConst: isConst);
+
+  KernelStaticInvocation.byReference(
+      Reference targetReference, Arguments arguments)
+      : super.byReference(targetReference, arguments);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [StaticSet].
+class KernelStaticSet extends StaticSet implements KernelExpression {
+  KernelStaticSet(Member target, Expression value) : super(target, value);
+
+  KernelStaticSet.byReference(Reference targetReference, Expression value)
+      : super.byReference(targetReference, value);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
 /// Concrete shadow object representing a string concatenation in kernel form.
 class KernelStringConcatenation extends StringConcatenation
     implements KernelExpression {
   KernelStringConcatenation(List<Expression> expressions) : super(expressions);
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(scheglov) Add and use inferStringConcatenation() instead.
     return inferrer.inferStringLiteral(typeContext, typeNeeded);
   }
 }
 
 /// Concrete shadow object representing a string literal in kernel form.
 class KernelStringLiteral extends StringLiteral implements KernelExpression {
   KernelStringLiteral(String value) : super(value);
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     return inferrer.inferStringLiteral(typeContext, typeNeeded);
   }
 }
 
+/// Shadow object for [SuperMethodInvocation].
+class KernelSuperMethodInvocation extends SuperMethodInvocation
+    implements KernelExpression {
+  KernelSuperMethodInvocation(Name name, Arguments arguments,
+      [Procedure interfaceTarget])
+      : super(name, arguments, interfaceTarget);
+
+  KernelSuperMethodInvocation.byReference(
+      Name name, Arguments arguments, Reference interfaceTargetReference)
+      : super.byReference(name, arguments, interfaceTargetReference);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [SuperPropertyGet].
+class KernelSuperPropertyGet extends SuperPropertyGet
+    implements KernelExpression {
+  KernelSuperPropertyGet(Name name, [Member interfaceTarget])
+      : super(name, interfaceTarget);
+
+  KernelSuperPropertyGet.byReference(
+      Name name, Reference interfaceTargetReference)
+      : super.byReference(name, interfaceTargetReference);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [SuperPropertySet].
+class KernelSuperPropertySet extends SuperPropertySet
+    implements KernelExpression {
+  KernelSuperPropertySet(Name name, Expression value, Member interfaceTarget)
+      : super(name, value, interfaceTarget);
+
+  KernelSuperPropertySet.byReference(
+      Name name, Expression value, Reference interfaceTargetReference)
+      : super.byReference(name, value, interfaceTargetReference);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [SymbolLiteral].
+class KernelSymbolLiteral extends SymbolLiteral implements KernelExpression {
+  KernelSymbolLiteral(String value) : super(value);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [ThisExpression].
+class KernelThisExpression extends ThisExpression implements KernelExpression {
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
+/// Shadow object for [Throw].
+class KernelThrow extends Throw implements KernelExpression {
+  KernelThrow(Expression expression) : super(expression);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
 /// Concrete implementation of [TypeInferenceEngine] specialized to work with
 /// kernel objects.
 class KernelTypeInferenceEngine extends TypeInferenceEngineImpl<KernelField> {
   KernelTypeInferenceEngine(Instrumentation instrumentation, bool strongMode)
       : super(instrumentation, strongMode);
 
   @override
   void clearFieldInitializer(KernelField field) {
     field.initializer = null;
   }
@@ skipping 117 matching lines @@
       return statement._inferStatement(this);
     } else {
       // Encountered a statement type for which type inference is not yet
       // implemented, so just skip it for now.
       // TODO(paulberry): once the BodyBuilder uses shadow classes for
       // everything, this case should no longer be needed.
     }
   }
 }
 
+/// Shadow object for [TypeLiteral].
+class KernelTypeLiteral extends TypeLiteral implements KernelExpression {
+  KernelTypeLiteral(DartType type) : super(type);
+
+  @override
+  DartType _inferExpression(
+      KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
+    // TODO(scheglov): implement.
+    return typeNeeded ? const DynamicType() : null;
+  }
+}
+
 /// Concrete implementation of [TypePromoter] specialized to work with kernel
 /// objects.
 ///
 /// Note: the second type parameter really ought to be
 /// KernelVariableDeclaration, but we can't do that yet because BodyBuilder
 /// still uses raw VariableDeclaration objects sometimes.
 /// TODO(paulberry): fix this.
 class KernelTypePromoter
     extends TypePromoterImpl<Expression, VariableDeclaration> {
   @override
@@ skipping 111 matching lines @@
       // KernelVariableDeclaration.
       mutatedInClosure = true;
       declaredType = variable.type;
     }
     return inferrer.inferVariableGet(typeContext, typeNeeded, mutatedInClosure,
         _fact, _scope, fileOffset, declaredType, (type) {
       promotedType = type;
     });
   }
 }