Move buildMethodInvocation to BodyBuilder.

pkg/front_end/lib/src/fasta/kernel/fasta_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.fasta_accessors;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
-    show KernelArguments, KernelMethodInvocation;
+    show KernelArguments;
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
 
 import 'package:front_end/src/scanner/token.dart' show Token;
 
-import 'frontend_accessors.dart' show Accessor, buildIsNull, makeLet;
+import 'frontend_accessors.dart' show Accessor;
 
 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 '../errors.dart' show internalError;
 
 import '../scope.dart' show AccessErrorBuilder, ProblemBuilder, Scope;
 
 import 'frontend_accessors.dart' as kernel
     show
         IndexAccessor,
         NullAwarePropertyAccessor,
         PropertyAccessor,
@@ skipping 18 matching lines @@
   int get functionNestingLevel;
 
   bool get constantExpressionRequired;
 
   Constructor lookupConstructor(Name name, {bool isSuper});
 
   Expression toSuperMethodInvocation(MethodInvocation node);
 
   Expression toValue(node);
 
-  Member lookupSuperMember(Name name, {bool isSetter: false});
+  Member lookupSuperMember(Name name, {bool isSetter});
 
   scopeLookup(Scope scope, String name, Token token,
       {bool isQualified: false, PrefixBuilder prefix});
 
   finishSend(Object receiver, Arguments arguments, int offset);
 
   Expression buildCompileTimeError(error, [int offset]);
 
   Initializer buildInvalidIntializer(Expression expression, [int offset]);
 
   Initializer buildSuperInitializer(
       Constructor constructor, Arguments arguments,
       [int offset]);
 
   Initializer buildRedirectingInitializer(
       Constructor constructor, Arguments arguments,
       [int charOffset = -1]);
 
   Expression buildStaticInvocation(Procedure target, Arguments arguments);
 
   Expression buildProblemExpression(ProblemBuilder builder, int offset);
 
   Expression throwNoSuchMethodError(
       String name, Arguments arguments, int offset,
-      {bool isSuper: false, isGetter: false, isSetter: false});
+      {bool isSuper, bool isGetter, bool isSetter});
 
   bool checkArguments(FunctionNode function, Arguments arguments,
       List<TypeParameter> typeParameters);
 
   StaticGet makeStaticGet(Member readTarget, Token token);
 
-  dynamic addCompileTimeError(int charOffset, String message,
-      {bool silent: false});
+  dynamic addCompileTimeError(int charOffset, String message, {bool silent});
+
+  Expression buildMethodInvocation(
+      Expression receiver, Name name, Arguments arguments, int offset,
+      {bool isConstantExpression, bool isNullAware});
 }
 
 abstract class FastaAccessor implements Accessor {
   BuilderHelper get helper;
 
   String get plainNameForRead;
 
   Uri get uri => helper.uri;
 
   String get plainNameForWrite => plainNameForRead;
@@ skipping 21 matching lines @@
     return buildThrowNoSuchMethodError(new KernelArguments(<Expression>[value]),
         isSetter: true);
   }
 
   /* Expression | FastaAccessor | Initializer */ doInvocation(
       int offset, Arguments arguments);
 
   /* Expression | FastaAccessor */ buildPropertyAccess(
       IncompleteSend send, bool isNullAware) {
     if (send is SendAccessor) {
-      return buildMethodInvocation(buildSimpleRead(), send.name, send.arguments,
-          offsetForToken(send.token),
+      return helper.buildMethodInvocation(buildSimpleRead(), send.name,
+          send.arguments, offsetForToken(send.token),
           isNullAware: isNullAware);
     } else {
       return PropertyAccessor.make(helper, send.token, buildSimpleRead(),
           send.name, null, null, isNullAware);
     }
   }
 
   /* Expression | FastaAccessor */ buildThrowNoSuchMethodError(
       Arguments arguments,
       {bool isSuper: false,
@@ skipping 133 matching lines @@
   }
 
   buildPropertyAccess(IncompleteSend send, bool isNullAware) {
     if (isInitializer && send is SendAccessor) {
       return buildConstructorInitializer(
           offsetForToken(send.token), send.name, send.arguments);
     }
     if (send is SendAccessor) {
       // Notice that 'this' or 'super' can't be null. So we can ignore the
       // value of [isNullAware].
-      MethodInvocation result = buildMethodInvocation(new ThisExpression(),
-          send.name, send.arguments, offsetForToken(token));
+      MethodInvocation result = helper.buildMethodInvocation(
+          new ThisExpression(),
+          send.name,
+          send.arguments,
+          offsetForToken(token));
       return isSuper ? helper.toSuperMethodInvocation(result) : result;
     } else {
       if (isSuper) {
         Member getter = helper.lookupSuperMember(send.name);
         Member setter = helper.lookupSuperMember(send.name, isSetter: true);
         return new SuperPropertyAccessor(
             helper, send.token, send.name, getter, setter);
       } else {
         return new ThisPropertyAccessor(
             helper, send.token, send.name, null, null);
       }
     }
   }
 
   doInvocation(int offset, Arguments arguments) {
     if (isInitializer) {
       return buildConstructorInitializer(offset, new Name(""), arguments);
     } else {
-      return buildMethodInvocation(
+      return helper.buildMethodInvocation(
           new ThisExpression(), callName, arguments, offset);
     }
   }
 
   Initializer buildConstructorInitializer(
       int offset, Name name, Arguments arguments) {
     Constructor constructor = helper.lookupConstructor(name, isSuper: isSuper);
     if (constructor == null ||
         !helper.checkArguments(
             constructor.function, arguments, <TypeParameter>[])) {
@@ skipping 119 matching lines @@
           receiver.findStaticBuilder(name.name, offsetForToken(token), uri);
       if (builder == null || builder is AccessErrorBuilder) {
         return buildThrowNoSuchMethodError(arguments);
       }
       if (builder.hasProblem) {
         result = helper.buildProblemExpression(builder, offsetForToken(token));
       } else {
         Member target = builder.target;
         if (target != null) {
           if (target is Field) {
-            result = buildMethodInvocation(
+            result = helper.buildMethodInvocation(
                 new StaticGet(target),
                 callName,
                 arguments,
                 offsetForToken(token) + (target.name?.name?.length ?? 0),
                 isNullAware: isNullAware);
           } else {
             result = helper.buildStaticInvocation(target, arguments)
               ..fileOffset = offsetForToken(token);
           }
         } else {
           result = buildThrowNoSuchMethodError(arguments)
             ..fileOffset = offsetForToken(token);
         }
       }
     } else {
-      result = buildMethodInvocation(
+      result = helper.buildMethodInvocation(
           helper.toValue(receiver), name, arguments, offsetForToken(token),
           isNullAware: isNullAware);
     }
     return result;
   }
 
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
     return internalError("Unhandled");
   }
@@ skipping 109 matching lines @@
 
   IndexAccessor.internal(this.helper, Token token, Expression receiver,
       Expression index, Procedure getter, Procedure setter)
       : super.internal(helper, receiver, index, getter, setter, token);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
 
   Expression doInvocation(int offset, Arguments arguments) {
-    return buildMethodInvocation(
-        buildSimpleRead(), callName, arguments, offset);
+    return helper.buildMethodInvocation(
+      buildSimpleRead(),
+      callName,
+      arguments,
+      offset,
+    );
   }
 
   toString() => "IndexAccessor()";
 
   static FastaAccessor make(
       BuilderHelper helper,
       Token token,
       Expression receiver,
       Expression index,
       Procedure getter,
@@ skipping 12 matching lines @@
 
   PropertyAccessor.internal(this.helper, Token token, Expression receiver,
       Name name, Member getter, Member setter)
       : super.internal(helper, receiver, name, getter, setter, token);
 
   String get plainNameForRead => name.name;
 
   bool get isThisPropertyAccessor => receiver is ThisExpression;
 
   Expression doInvocation(int offset, Arguments arguments) {
-    return buildMethodInvocation(receiver, name, arguments, offset);
+    return helper.buildMethodInvocation(receiver, name, arguments, offset);
   }
 
   toString() => "PropertyAccessor()";
 
   static FastaAccessor make(
       BuilderHelper helper,
       Token token,
       Expression receiver,
       Name name,
       Member getter,
@@ skipping 36 matching lines @@
         setter = builderSetter.target;
       }
     }
     return new StaticAccessor(helper, token, getter, setter);
   }
 
   String get plainNameForRead => (readTarget ?? writeTarget).name.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
     if (readTarget == null || isFieldOrGetter(readTarget)) {
-      return buildMethodInvocation(buildSimpleRead(), callName, arguments,
-          offset + (readTarget?.name?.name?.length ?? 0));
+      return helper.buildMethodInvocation(buildSimpleRead(), callName,
+          arguments, offset + (readTarget?.name?.name?.length ?? 0));
     } else {
       return helper.buildStaticInvocation(readTarget, arguments)
         ..fileOffset = offset;
     }
   }
 
   toString() => "StaticAccessor()";
 }
 
 class SuperPropertyAccessor extends kernel.SuperPropertyAccessor
     with FastaAccessor {
   SuperPropertyAccessor(BuilderHelper helper, Token token, Name name,
       Member getter, Member setter)
       : super(helper, name, getter, setter, token);
 
   String get plainNameForRead => name.name;
 
   Expression doInvocation(int offset, Arguments arguments) {
     if (getter == null || isFieldOrGetter(getter)) {
-      return buildMethodInvocation(
+      return helper.buildMethodInvocation(
           buildSimpleRead(), callName, arguments, offset);
     } else {
       return new DirectMethodInvocation(new ThisExpression(), getter, arguments)
         ..fileOffset = offset;
     }
   }
 
   toString() => "SuperPropertyAccessor()";
 }
 
 class ThisIndexAccessor extends kernel.ThisIndexAccessor with FastaAccessor {
   ThisIndexAccessor(BuilderHelper helper, Token token, Expression index,
       Procedure getter, Procedure setter)
       : super(helper, index, getter, setter, token);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
 
   Expression doInvocation(int offset, Arguments arguments) {
-    return buildMethodInvocation(
+    return helper.buildMethodInvocation(
         buildSimpleRead(), callName, arguments, offset);
   }
 
   toString() => "ThisIndexAccessor()";
 }
 
 class SuperIndexAccessor extends kernel.SuperIndexAccessor with FastaAccessor {
   SuperIndexAccessor(BuilderHelper helper, Token token, Expression index,
       Member getter, Member setter)
       : super(helper, index, getter, setter, token);
 
   String get plainNameForRead => "[]";
 
   String get plainNameForWrite => "[]=";
 
   Expression doInvocation(int offset, Arguments arguments) {
-    return buildMethodInvocation(
+    return helper.buildMethodInvocation(
         buildSimpleRead(), callName, arguments, offset);
   }
 
   toString() => "SuperIndexAccessor()";
 }
 
 class ThisPropertyAccessor extends kernel.ThisPropertyAccessor
     with FastaAccessor {
   final BuilderHelper helper;
 
   ThisPropertyAccessor(
       this.helper, Token token, Name name, Member getter, Member setter)
       : super(helper, name, getter, setter, token);
 
   String get plainNameForRead => name.name;
 
   bool get isThisPropertyAccessor => true;
 
   Expression doInvocation(int offset, Arguments arguments) {
     Member interfaceTarget = getter;
     if (interfaceTarget is Field) {
       // TODO(ahe): In strong mode we should probably rewrite this to
       // `this.name.call(arguments)`.
       interfaceTarget = null;
     }
-    return buildMethodInvocation(new ThisExpression(), name, arguments, offset);
+    return helper.buildMethodInvocation(
+        new ThisExpression(), name, arguments, offset);
   }
 
   toString() => "ThisPropertyAccessor()";
 }
 
 class NullAwarePropertyAccessor extends kernel.NullAwarePropertyAccessor
     with FastaAccessor {
   final BuilderHelper helper;
 
   NullAwarePropertyAccessor(this.helper, Token token, Expression receiver,
@@ skipping 13 matching lines @@
   VariableAccessor(
       BuilderHelper helper, Token token, VariableDeclaration variable,
       [DartType promotedType])
       : super(helper, variable, promotedType, token);
 
   String get plainNameForRead => variable.name;
 
   Expression doInvocation(int offset, 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,
+    return helper.buildMethodInvocation(buildSimpleRead(), callName, arguments,
         offset + (variable.name?.length ?? 0));
   }
 
   toString() => "VariableAccessor()";
 }
 
 class ReadOnlyAccessor extends kernel.ReadOnlyAccessor with FastaAccessor {
   final String plainNameForRead;
 
   ReadOnlyAccessor(BuilderHelper helper, Expression expression,
       this.plainNameForRead, Token token)
       : super(helper, expression, token);
 
   Expression doInvocation(int offset, Arguments arguments) {
-    return buildMethodInvocation(
+    return helper.buildMethodInvocation(
         buildSimpleRead(), callName, arguments, offset);
   }
 }
 
 class ParenthesizedExpression extends ReadOnlyAccessor {
   ParenthesizedExpression(
       BuilderHelper helper, Expression expression, Token token)
       : super(helper, expression, "<a parenthesized expression>", token);
 
   Expression makeInvalidWrite(Expression value) {
@@ skipping 23 matching lines @@
       {bool isGetter: false, bool isSetter: false, int offset}) {
     return helper.throwNoSuchMethodError(
         plainNameForRead, arguments, offset ?? offsetForToken(this.token),
         isGetter: isGetter, isSetter: isSetter);
   }
 }
 
 bool isFieldOrGetter(Member member) {
   return member is Field || (member is Procedure && member.isGetter);
 }
-
-Expression buildMethodInvocation(
-    Expression receiver, Name name, Arguments arguments, int offset,
-    {bool isNullAware: false}) {
-  if (isNullAware) {
-    VariableDeclaration variable = new VariableDeclaration.forValue(receiver);
-    return makeLet(
-        variable,
-        new ConditionalExpression(
-            buildIsNull(new VariableGet(variable)),
-            new NullLiteral(),
-            new KernelMethodInvocation(
-                new VariableGet(variable), name, arguments)
-              ..fileOffset = offset,
-            const DynamicType()));
-  } else {
-    return new KernelMethodInvocation(receiver, name, arguments)
-      ..fileOffset = offset;
-  }
-}