Fasta type inference prototype #2

pkg/front_end/lib/src/fasta/kernel/frontend_accessors.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.
 
 // Note: copied from package:kernel at revision 7346348.
 
 /// A library to help transform compounds and null-aware accessors into
 /// let expressions.
 library kernel.frontend.accessors;
 
+import 'package:front_end/src/fasta/builder/shadow_ast.dart';
+import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 import 'package:kernel/ast.dart';
 
 import '../names.dart' show indexGetName, indexSetName;
 
 /// An [Accessor] represents a subexpression for which we can't yet build a
 /// kernel [Expression] because we don't yet know the context in which it is
 /// used.
 ///
 /// Once the context is known, an [Accessor] can be converted into an
 /// [Expression] by calling a "build" method.
 ///
 /// For example, when building a kernel representation for `a[x] = b`, after
 /// parsing `a[x]` but before parsing `= b`, we don't yet know whether to
 /// generate an invocation of `operator[]` or `operator[]=`, so we generate an
 /// [Accessor] object.  Later, after `= b` is parsed, [buildAssignment] will be
 /// called.
 abstract class Accessor {
   /// Builds an [Expression] representing a read from the accessor.
-  Expression buildSimpleRead() {
-    return _finish(_makeSimpleRead());
+  ShadowExpression buildSimpleRead() {
+    return _finish(_makeSimpleRead() as ShadowExpression);
   }
 
   /// Builds an [Expression] representing an assignment with the accessor on
   /// the LHS and [value] on the RHS.
   ///
   /// The returned expression evaluates to the assigned value, unless
   /// [voidContext] is true, in which case it may evaluate to anything.
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
-    return _finish(_makeSimpleWrite(value, voidContext));
+    return _finish(_makeSimpleWrite(value, voidContext) as ShadowExpression)
+        as Expression;
   }
 
   /// Returns an [Expression] representing a null-aware assignment (`??=`) with
   /// the accessor on the LHS and [value] on the RHS.
   ///
   /// The returned expression evaluates to the assigned value, unless
   /// [voidContext] is true, in which case it may evaluate to anything.
   ///
   /// [type] is the static type of the RHS.
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
     if (voidContext) {
-      return _finish(new ConditionalExpression(buildIsNull(_makeRead()),
-          _makeWrite(value, false), new NullLiteral(), type));
+      return _finish(new ConditionalExpression(
+          buildIsNull(_makeRead()),
+          _makeWrite(value, false),
+          new NullLiteral(),
+          type) as ShadowExpression) as Expression;
     }
     var tmp = new VariableDeclaration.forValue(_makeRead());
     return _finish(makeLet(
         tmp,
-        new ConditionalExpression(buildIsNull(new VariableGet(tmp)),
-            _makeWrite(value, false), new VariableGet(tmp), type)));
+        new ConditionalExpression(
+            buildIsNull(new VariableGet(tmp)),
+            _makeWrite(value, false),
+            new VariableGet(tmp),
+            type)) as ShadowExpression) as Expression;
   }
 
   /// Returns an [Expression] representing a compound assignment (e.g. `+=`)
   /// with the accessor on the LHS and [value] on the RHS.
   Expression buildCompoundAssignment(
       Name binaryOperator, Expression value, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return _finish(_makeWrite(
         makeBinary(
             _makeRead(), binaryOperator, interfaceTarget, value, charOffset),
-        voidContext));
+        voidContext) as ShadowExpression) as Expression;
   }
 
   /// Returns an [Expression] representing a pre-increment or pre-decrement
   /// of the accessor.
   Expression buildPrefixIncrement(Name binaryOperator, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return buildCompoundAssignment(
         binaryOperator, new IntLiteral(1), charOffset,
         voidContext: voidContext, interfaceTarget: interfaceTarget);
   }
 
   /// Returns an [Expression] representing a post-increment or post-decrement
   /// of the accessor.
   Expression buildPostfixIncrement(Name binaryOperator, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     if (voidContext) {
       return buildPrefixIncrement(binaryOperator, charOffset,
           voidContext: true, interfaceTarget: interfaceTarget);
     }
     var value = new VariableDeclaration.forValue(_makeRead());
     valueAccess() => new VariableGet(value);
     var dummy = new VariableDeclaration.forValue(_makeWrite(
         makeBinary(valueAccess(), binaryOperator, interfaceTarget,
             new IntLiteral(1), charOffset),
         true));
-    return _finish(makeLet(value, makeLet(dummy, valueAccess())));
+    return _finish(
+            makeLet(value, makeLet(dummy, valueAccess())) as ShadowExpression)
+        as Expression;
   }
 
   Expression _makeSimpleRead() => _makeRead();
 
   Expression _makeSimpleWrite(Expression value, bool voidContext) {
     return _makeWrite(value, voidContext);
   }
 
   Expression _makeRead();
 
   Expression _makeWrite(Expression value, bool voidContext);
 
-  Expression _finish(Expression body) => body;
+  ShadowExpression _finish(ShadowExpression body) => body;
 
   /// Returns an [Expression] representing a compile-time error.
   ///
   /// At runtime, an exception will be thrown.
   makeInvalidRead() => new InvalidExpression();
 
   /// Returns an [Expression] representing a compile-time error wrapping
   /// [value].
   ///
   /// At runtime, [value] will be evaluated before throwing an exception.
   makeInvalidWrite(Expression value) => wrapInvalid(value);
 }
 
 class VariableAccessor extends Accessor {
   VariableDeclaration variable;
   int charOffset;
   DartType promotedType;
 
   VariableAccessor(this.variable, [this.promotedType]);
 
   VariableAccessor.internal(this.variable, this.charOffset, this.promotedType);
 
   _makeRead() =>
-      new VariableGet(variable, promotedType)..fileOffset = charOffset;
+      new KernelVariableGet(variable, promotedType)..fileOffset = charOffset;
 
   _makeWrite(Expression value, bool voidContext) {
     return variable.isFinal || variable.isConst
         ? makeInvalidWrite(value)
         : new VariableSet(variable, value)..fileOffset = charOffset;
   }
 }
 
 class PropertyAccessor extends Accessor {
   VariableDeclaration _receiverVariable;
@@ skipping 28 matching lines @@
   }
 
   _makeRead() =>
       new PropertyGet(receiverAccess(), name, getter)..fileOffset = charOffset;
 
   _makeWrite(Expression value, bool voidContext) {
     return new PropertySet(receiverAccess(), name, value, setter)
       ..fileOffset = charOffset;
   }
 
-  _finish(Expression body) => makeLet(_receiverVariable, body);
+  _finish(ShadowExpression body) =>
+      makeLet(_receiverVariable, body as Expression) as ShadowExpression;
 }
 
 /// Special case of [PropertyAccessor] to avoid creating an indirect access to
 /// 'this'.
 class ThisPropertyAccessor extends Accessor {
   Name name;
   Member getter, setter;
   final int charOffset;
 
   ThisPropertyAccessor(this.name, this.getter, this.setter, this.charOffset);
@@ skipping 18 matching lines @@
       : this.receiver = makeOrReuseVariable(receiver);
 
   receiverAccess() => new VariableGet(receiver);
 
   _makeRead() => new PropertyGet(receiverAccess(), name, getter);
 
   _makeWrite(Expression value, bool voidContext) {
     return new PropertySet(receiverAccess(), name, value, setter);
   }
 
-  _finish(Expression body) => makeLet(
+  _finish(ShadowExpression body) => makeLet(
       receiver,
-      new ConditionalExpression(
-          buildIsNull(receiverAccess()), new NullLiteral(), body, type));
+      new ConditionalExpression(buildIsNull(receiverAccess()),
+          new NullLiteral(), body as Expression, type)) as ShadowExpression;
 }
 
 class SuperPropertyAccessor extends Accessor {
   Name name;
   Member getter, setter;
   final int charOffset;
 
   SuperPropertyAccessor(this.name, this.getter, this.setter, this.charOffset);
 
   _makeRead() {
@@ skipping 85 matching lines @@
     var dummy = new VariableDeclaration.forValue(new MethodInvocation(
         receiverAccess(),
         indexSetName,
         new Arguments(
             <Expression>[indexAccess(), new VariableGet(valueVariable)]),
         setter)..fileOffset = charOffset);
     return makeLet(
         valueVariable, makeLet(dummy, new VariableGet(valueVariable)));
   }
 
-  Expression _finish(Expression body) {
-    return makeLet(receiverVariable, makeLet(indexVariable, body));
+  ShadowExpression _finish(ShadowExpression body) {
+    return makeLet(receiverVariable, makeLet(indexVariable, body as Expression))
+        as ShadowExpression;
   }
 }
 
 /// Special case of [IndexAccessor] to avoid creating an indirect access to
 /// 'this'.
 class ThisIndexAccessor extends Accessor {
   Expression index;
   VariableDeclaration indexVariable;
   Procedure getter, setter;
 
@@ skipping 29 matching lines @@
     var dummy = new VariableDeclaration.forValue(new MethodInvocation(
         new ThisExpression(),
         indexSetName,
         new Arguments(
             <Expression>[indexAccess(), new VariableGet(valueVariable)]),
         setter));
     return makeLet(
         valueVariable, makeLet(dummy, new VariableGet(valueVariable)));
   }
 
-  Expression _finish(Expression body) => makeLet(indexVariable, body);
+  ShadowExpression _finish(ShadowExpression body) =>
+      makeLet(indexVariable, body as Expression) as ShadowExpression;
 }
 
 class SuperIndexAccessor extends Accessor {
   Expression index;
   VariableDeclaration indexVariable;
   Member getter, setter;
 
   SuperIndexAccessor(this.index, this.getter, this.setter);
 
   indexAccess() {
@@ skipping 25 matching lines @@
     var valueVariable = new VariableDeclaration.forValue(value);
     var dummy = new VariableDeclaration.forValue(new SuperMethodInvocation(
         indexSetName,
         new Arguments(
             <Expression>[indexAccess(), new VariableGet(valueVariable)]),
         setter));
     return makeLet(
         valueVariable, makeLet(dummy, new VariableGet(valueVariable)));
   }
 
-  Expression _finish(Expression body) {
-    return makeLet(indexVariable, body);
+  ShadowExpression _finish(ShadowExpression body) {
+    return makeLet(indexVariable, body as Expression) as ShadowExpression;
   }
 }
 
 class StaticAccessor extends Accessor {
   Member readTarget;
   Member writeTarget;
   int charOffset;
 
   StaticAccessor(this.readTarget, this.writeTarget, this.charOffset);
 
@@ skipping 16 matching lines @@
 
   _makeSimpleRead() => expression;
 
   _makeRead() {
     value ??= new VariableDeclaration.forValue(expression);
     return new VariableGet(value);
   }
 
   _makeWrite(Expression value, bool voidContext) => makeInvalidWrite(value);
 
-  Expression _finish(Expression body) => makeLet(value, body);
+  ShadowExpression _finish(ShadowExpression body) =>
+      makeLet(value, body as Expression) as ShadowExpression;
 }
 
 Expression makeLet(VariableDeclaration variable, Expression body) {
   if (variable == null) return body;
   return new Let(variable, body);
 }
 
 Expression makeBinary(Expression left, Name operator, Procedure interfaceTarget,
     Expression right, int charOffset) {
   return new MethodInvocation(
@@ skipping 10 matching lines @@
 
 VariableDeclaration makeOrReuseVariable(Expression value) {
   // TODO: Devise a way to remember if a variable declaration was reused
   // or is fresh (hence needs a let binding).
   return new VariableDeclaration.forValue(value);
 }
 
 Expression wrapInvalid(Expression e) {
   return new Let(new VariableDeclaration.forValue(e), new InvalidExpression());
 }