Fasta type inference prototype #2

pkg/front_end/lib/src/fasta/kernel/builder_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.
 
 library fasta.builder_accessors;
 
 export 'frontend_accessors.dart' show wrapInvalid;
 
 import 'frontend_accessors.dart' show Accessor;
 
+import 'package:front_end/src/fasta/builder/shadow_ast.dart';
 import 'package:kernel/ast.dart';
 
 import '../errors.dart' show internalError;
 
 import '../builder/scope.dart' show AccessErrorBuilder, ProblemBuilder;
 
 import 'frontend_accessors.dart' as kernel
     show
         IndexAccessor,
         NullAwarePropertyAccessor,
@@ skipping 12 matching lines @@
 
 import '../names.dart' show callName;
 
 abstract class BuilderHelper {
   Uri get uri;
 
   Constructor lookupConstructor(Name name, {bool isSuper});
 
   Expression toSuperMethodInvocation(MethodInvocation node);
 
-  Expression toValue(node);
+  ShadowExpression toValue(node);
 
   Member lookupSuperMember(Name name, {bool isSetter: false});
 
   builderToFirstExpression(Builder builder, String name, int charOffset);
 
   finishSend(Object receiver, Arguments arguments, int charOffset);
 
-  Expression buildCompileTimeError(error, [int charOffset]);
+  ShadowExpression buildCompileTimeError(error, [int charOffset]);
 
   Initializer buildCompileTimeErrorIntializer(error, [int charOffset]);
 
   Expression buildStaticInvocation(Procedure target, Arguments arguments);
 
-  Expression buildProblemExpression(ProblemBuilder builder, int charOffset);
+  ShadowExpression buildProblemExpression(
+      ProblemBuilder builder, int charOffset);
 
-  Expression throwNoSuchMethodError(
+  ShadowExpression throwNoSuchMethodError(
       String name, Arguments arguments, int charOffset,
       {bool isSuper: false, isGetter: false, isSetter: false});
 }
 
 abstract class BuilderAccessor implements Accessor {
   BuilderHelper get helper;
 
   int get charOffset;
 
   String get plainNameForRead;
 
   Uri get uri => helper.uri;
 
   String get plainNameForWrite => plainNameForRead;
 
-  Expression buildForEffect() => buildSimpleRead();
+  ShadowExpression buildForEffect() => buildSimpleRead();
 
   Initializer buildFieldInitializer(
       Map<String, FieldInitializer> initializers) {
     // TODO(ahe): This error message is really bad.
     return helper.buildCompileTimeErrorIntializer(
         "Can't use $plainNameForRead here.", charOffset);
   }
 
   Expression makeInvalidRead() {
     return buildThrowNoSuchMethodError(new Arguments.empty(), isGetter: true);
   }
 
   Expression makeInvalidWrite(Expression value) {
     return buildThrowNoSuchMethodError(new Arguments(<Expression>[value]),
         isSetter: true);
   }
 
   /* Expression | BuilderAccessor */ doInvocation(
       int charOffset, Arguments arguments);
 
   /* Expression | BuilderAccessor */ buildPropertyAccess(
       IncompleteSend send, bool isNullAware) {
     if (send is SendAccessor) {
-      return buildMethodInvocation(
-          buildSimpleRead(), send.name, send.arguments, send.charOffset,
+      return buildMethodInvocation(buildSimpleRead() as Expression, send.name,
+          send.arguments, send.charOffset,
           isNullAware: isNullAware);
     } else {
-      return PropertyAccessor.make(helper, send.charOffset, buildSimpleRead(),
-          send.name, null, null, isNullAware);
+      return PropertyAccessor.make(helper, send.charOffset,
+          buildSimpleRead() as Expression, send.name, null, null, isNullAware);
     }
   }
 
   /* Expression | BuilderAccessor */ buildThrowNoSuchMethodError(
       Arguments arguments,
       {bool isSuper: false,
       isGetter: false,
       isSetter: false,
       String name,
       int charOffset}) {
@@ skipping 50 matching lines @@
   Expression buildPostfixIncrement(Name binaryOperator, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return buildError();
   }
 
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
     return buildError();
   }
 
-  Expression buildSimpleRead() => buildError();
+  ShadowExpression buildSimpleRead() => buildError() as ShadowExpression;
 
   Expression makeInvalidRead() => buildError();
 
   Expression makeInvalidWrite(Expression value) => buildError();
 }
 
 class ThisAccessor extends BuilderAccessor {
   final BuilderHelper helper;
 
   final int charOffset;
 
   final bool isInitializer;
 
   final bool isSuper;
 
   ThisAccessor(this.helper, this.charOffset, this.isInitializer,
       {this.isSuper: false});
 
   String get plainNameForRead => internalError(isSuper ? "super" : "this");
 
-  Expression buildSimpleRead() {
+  ShadowExpression buildSimpleRead() {
     if (!isSuper) {
-      return new ThisExpression();
+      return new ThisExpression() as ShadowExpression;
     } else {
       return helper.buildCompileTimeError(
           "Can't use `super` as an expression.", charOffset);
     }
   }
 
   Initializer buildFieldInitializer(
       Map<String, FieldInitializer> initializers) {
     String keyword = isSuper ? "super" : "this";
     return helper.buildCompileTimeErrorIntializer(
@@ skipping 70 matching lines @@
   }
 
   Expression buildPostfixIncrement(Name binaryOperator, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
     return buildAssignmentError();
   }
 
   Expression buildAssignmentError() {
     String message =
         isSuper ? "Can't assign to 'super'." : "Can't assign to 'this'.";
-    return helper.buildCompileTimeError(message, charOffset);
+    return helper.buildCompileTimeError(message, charOffset) as Expression;
   }
 
   toString() => "ThisAccessor($charOffset${isSuper ? ', super' : ''})";
 }
 
 abstract class IncompleteSend extends BuilderAccessor {
   final BuilderHelper helper;
 
   final int charOffset;
 
   final Name name;
 
   IncompleteSend(this.helper, this.charOffset, this.name);
 
   withReceiver(Object receiver, {bool isNullAware});
 }
 
 class IncompleteError extends IncompleteSend with CompileTimeErrorAccessor {
   final Object error;
 
   IncompleteError(BuilderHelper helper, int charOffset, this.error)
       : super(helper, charOffset, null);
 
   Expression buildError() {
-    return helper.buildCompileTimeError(error, charOffset);
+    return helper.buildCompileTimeError(error, charOffset) as Expression;
   }
 }
 
 class SendAccessor extends IncompleteSend {
   final Arguments arguments;
 
   SendAccessor(BuilderHelper helper, int charOffset, Name name, this.arguments)
       : super(helper, charOffset, name) {
     assert(arguments != null);
   }
 
   String get plainNameForRead => name.name;
 
-  Expression buildSimpleRead() {
+  ShadowExpression buildSimpleRead() {
     return internalError("Unhandled");
   }
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
     return internalError("Unhandled");
   }
 
   withReceiver(Object receiver, {bool isNullAware: false}) {
     if (receiver is TypeDeclarationBuilder) {
       /// `SomeType?.toString` is the same as `SomeType.toString`, not
       /// `(SomeType).toString`.
       isNullAware = false;
     }
     if (receiver is BuilderAccessor) {
       return receiver.buildPropertyAccess(this, isNullAware);
     }
     if (receiver is PrefixBuilder) {
       PrefixBuilder prefix = receiver;
       receiver = helper.builderToFirstExpression(
           prefix.exports[name.name], "${prefix.name}.${name.name}", charOffset);
       return helper.finishSend(receiver, arguments, charOffset);
     }
     Expression result;
     if (receiver is KernelClassBuilder) {
       Builder builder = receiver.findStaticBuilder(name.name, charOffset, uri);
       if (builder == null) {
         return buildThrowNoSuchMethodError(arguments);
       }
       if (builder.hasProblem) {
-        result = helper.buildProblemExpression(builder, charOffset);
+        result =
+            helper.buildProblemExpression(builder, charOffset) as Expression;
       } else {
         Member target = builder.target;
         if (target != null) {
           if (target is Field) {
             result = buildMethodInvocation(new StaticGet(target), callName,
                 arguments, charOffset + (target.name?.name?.length ?? 0),
                 isNullAware: isNullAware);
           } else {
             result = helper.buildStaticInvocation(target, arguments)
               ..fileOffset = charOffset;
           }
         } else {
           result = buildThrowNoSuchMethodError(arguments)
             ..fileOffset = charOffset;
         }
       }
     } else {
       result = buildMethodInvocation(
-          helper.toValue(receiver), name, arguments, charOffset,
+          helper.toValue(receiver) as Expression, name, arguments, charOffset,
           isNullAware: isNullAware);
     }
     return result;
   }
 
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
     return internalError("Unhandled");
   }
 
@@ skipping 19 matching lines @@
 
   toString() => "SendAccessor($charOffset, $name, $arguments)";
 }
 
 class IncompletePropertyAccessor extends IncompleteSend {
   IncompletePropertyAccessor(BuilderHelper helper, int charOffset, Name name)
       : super(helper, charOffset, name);
 
   String get plainNameForRead => name.name;
 
-  Expression buildSimpleRead() => internalError("Unhandled");
+  ShadowExpression buildSimpleRead() => internalError("Unhandled");
 
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
     return internalError("Unhandled");
   }
 
   withReceiver(Object receiver, {bool isNullAware: false}) {
     if (receiver is TypeDeclarationBuilder) {
       /// For reasons beyond comprehension, `SomeType?.toString` is the same as
       /// `SomeType.toString`, not `(SomeType).toString`. WTAF!?!
       //
@@ skipping 19 matching lines @@
         setter = builder;
       } else if (builder.isGetter) {
         setter = receiver.findStaticBuilder(name.name, charOffset, uri,
             isSetter: true);
       } else if (builder.isField && !builder.isFinal) {
         setter = builder;
       }
       return new StaticAccessor.fromBuilder(
           helper, builder, charOffset, setter);
     }
-    return PropertyAccessor.make(helper, charOffset, helper.toValue(receiver),
-        name, null, null, isNullAware);
+    return PropertyAccessor.make(helper, charOffset,
+        helper.toValue(receiver) as Expression, name, null, null, isNullAware);
   }
 
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
     return internalError("Unhandled");
   }
 
   Expression buildCompoundAssignment(
       Name binaryOperator, Expression value, int charOffset,
       {bool voidContext: false, Procedure interfaceTarget}) {
@@ skipping 23 matching lines @@
   IndexAccessor.internal(this.helper, int charOffset, Expression receiver,
       Expression index, Procedure getter, Procedure setter)
       : super.internal(receiver, index, getter, setter, charOffset);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
 
   Expression doInvocation(int charOffset, Arguments arguments) {
     return buildMethodInvocation(
-        buildSimpleRead(), callName, arguments, charOffset);
+        buildSimpleRead() as Expression, callName, arguments, charOffset);
   }
 
   toString() => "IndexAccessor()";
 
   static BuilderAccessor make(
       BuilderHelper helper,
       int charOffset,
       Expression receiver,
       Expression index,
       Procedure getter,
@@ skipping 71 matching lines @@
         setter = builderSetter.target;
       }
     }
     return new StaticAccessor(helper, charOffset, getter, setter);
   }
 
   String get plainNameForRead => (readTarget ?? writeTarget).name.name;
 
   Expression doInvocation(int charOffset, Arguments arguments) {
     if (readTarget == null || isFieldOrGetter(readTarget)) {
-      return buildMethodInvocation(buildSimpleRead(), callName, arguments,
-          charOffset + (readTarget?.name?.name?.length ?? 0));
+      return buildMethodInvocation(buildSimpleRead() as Expression, callName,
+          arguments, charOffset + (readTarget?.name?.name?.length ?? 0));
     } else {
       return helper.buildStaticInvocation(readTarget, arguments)
         ..fileOffset = charOffset;
     }
   }
 
   toString() => "StaticAccessor()";
 }
 
 class SuperPropertyAccessor extends kernel.SuperPropertyAccessor
     with BuilderAccessor {
   final BuilderHelper helper;
 
   SuperPropertyAccessor(
       this.helper, int charOffset, Name name, Member getter, Member setter)
       : super(name, getter, setter, charOffset);
 
   String get plainNameForRead => name.name;
 
   Expression doInvocation(int charOffset, Arguments arguments) {
     if (getter == null || isFieldOrGetter(getter)) {
       return buildMethodInvocation(
-          buildSimpleRead(), callName, arguments, charOffset);
+          buildSimpleRead() as Expression, callName, arguments, charOffset);
     } else {
       return new DirectMethodInvocation(new ThisExpression(), getter, arguments)
         ..fileOffset = charOffset;
     }
   }
 
   toString() => "SuperPropertyAccessor()";
 }
 
 class ThisIndexAccessor extends kernel.ThisIndexAccessor with BuilderAccessor {
   final BuilderHelper helper;
 
   final int charOffset;
 
   ThisIndexAccessor(this.helper, this.charOffset, Expression index,
       Procedure getter, Procedure setter)
       : super(index, getter, setter);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
 
   Expression doInvocation(int charOffset, Arguments arguments) {
     return buildMethodInvocation(
-        buildSimpleRead(), callName, arguments, charOffset);
+        buildSimpleRead() as Expression, callName, arguments, charOffset);
   }
 
   toString() => "ThisIndexAccessor()";
 }
 
 class SuperIndexAccessor extends kernel.SuperIndexAccessor
     with BuilderAccessor {
   final BuilderHelper helper;
 
   final int charOffset;
 
   SuperIndexAccessor(this.helper, this.charOffset, Expression index,
       Member getter, Member setter)
       : super(index, getter, setter);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
 
   Expression doInvocation(int charOffset, Arguments arguments) {
     return buildMethodInvocation(
-        buildSimpleRead(), callName, arguments, charOffset);
+        buildSimpleRead() as Expression, callName, arguments, charOffset);
   }
 
   toString() => "SuperIndexAccessor()";
 }
 
 class ThisPropertyAccessor extends kernel.ThisPropertyAccessor
     with BuilderAccessor {
   final BuilderHelper helper;
 
   ThisPropertyAccessor(
@@ skipping 42 matching lines @@
 
   VariableAccessor(this.helper, int charOffset, VariableDeclaration variable,
       [DartType promotedType])
       : super.internal(variable, charOffset, promotedType);
 
   String get plainNameForRead => variable.name;
 
   Expression doInvocation(int charOffset, Arguments arguments) {
     // Normally the offset is at the start of the token, but in this case,
     // because we insert a '.call', we want it at the end instead.
-    return buildMethodInvocation(buildSimpleRead(), callName, arguments,
-        charOffset + (variable.name?.length ?? 0));
+    return buildMethodInvocation(buildSimpleRead() as Expression, callName,
+        arguments, charOffset + (variable.name?.length ?? 0));
   }
 
   toString() => "VariableAccessor()";
 }
 
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }
 
 Expression buildMethodInvocation(
     Expression receiver, Name name, Arguments arguments, int charOffset,
     {bool isNullAware: false}) {
   if (isNullAware) {
     VariableDeclaration variable = new VariableDeclaration.forValue(receiver);
     return makeLet(
         variable,
         new ConditionalExpression(
             buildIsNull(new VariableGet(variable)),
             new NullLiteral(),
             new MethodInvocation(new VariableGet(variable), name, arguments)
               ..fileOffset = charOffset,
             const DynamicType()));
   } else {
     return new MethodInvocation(receiver, name, arguments)
       ..fileOffset = charOffset;
   }
 }