Remove AstFactory from the front end.

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;
 
 export 'frontend_accessors.dart' show wrapInvalid;
 
+import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
+    show KernelArguments, KernelMethodInvocation;
+
 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 'package:front_end/src/fasta/builder/ast_factory.dart' show AstFactory;
-
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart'
     show TypePromoter;
 
 import 'package:kernel/ast.dart';
 
 import '../errors.dart' show internalError;
 
 import '../scope.dart' show AccessErrorBuilder, ProblemBuilder, Scope;
 
 import 'frontend_accessors.dart' as kernel
@@ skipping 14 matching lines @@
 
 import '../names.dart' show callName;
 
 abstract class BuilderHelper {
   Uri get uri;
 
   TypePromoter get typePromoter;
 
   int get functionNestingLevel;
 
-  AstFactory get astFactory;
-
   Constructor lookupConstructor(Name name, {bool isSuper});
 
   Expression toSuperMethodInvocation(MethodInvocation node);
 
   Expression toValue(node);
 
   Member lookupSuperMember(Name name, {bool isSetter: false});
 
   scopeLookup(Scope scope, String name, Token token,
       {bool isQualified: false, PrefixBuilder prefix});
@@ skipping 48 matching lines @@
             "Can't use $plainNameForRead here.",
             offset),
         offset);
   }
 
   Expression makeInvalidRead() {
     return buildThrowNoSuchMethodError(new Arguments.empty(), isGetter: true);
   }
 
   Expression makeInvalidWrite(Expression value) {
-    return buildThrowNoSuchMethodError(
-        helper.astFactory.arguments(<Expression>[value]),
+    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(helper.astFactory, buildSimpleRead(),
-          send.name, send.arguments, offsetForToken(send.token),
+      return 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 59 matching lines @@
       {bool isSuper: false,
       isGetter: false,
       isSetter: false,
       String name,
       int offset}) {
     return this;
   }
 
   @override
   Expression buildAssignment(Expression value, {bool voidContext: false}) {
-    return buildError(helper.astFactory.arguments(<Expression>[value]),
-        isSetter: true);
+    return buildError(new KernelArguments(<Expression>[value]), isSetter: true);
   }
 
   @override
   Expression buildCompoundAssignment(Name binaryOperator, Expression value,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
-    return buildError(helper.astFactory.arguments(<Expression>[value]),
-        isGetter: true);
+    return buildError(new KernelArguments(<Expression>[value]), isGetter: true);
   }
 
   @override
   Expression buildPrefixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
-    return buildError(
-        helper.astFactory.arguments(<Expression>[new IntLiteral(1)]),
+    return buildError(new KernelArguments(<Expression>[new IntLiteral(1)]),
         isGetter: true);
   }
 
   @override
   Expression buildPostfixIncrement(Name binaryOperator,
       {int offset: TreeNode.noOffset,
       bool voidContext: false,
       Procedure interfaceTarget}) {
-    return buildError(
-        helper.astFactory.arguments(<Expression>[new IntLiteral(1)]),
+    return buildError(new KernelArguments(<Expression>[new IntLiteral(1)]),
         isGetter: true);
   }
 
   @override
   Expression buildNullAwareAssignment(Expression value, DartType type,
       {bool voidContext: false}) {
-    return buildError(helper.astFactory.arguments(<Expression>[value]),
-        isSetter: true);
+    return buildError(new KernelArguments(<Expression>[value]), isSetter: true);
   }
 
   @override
   Expression buildSimpleRead() =>
       buildError(new Arguments.empty(), isGetter: true);
 
   @override
   Expression makeInvalidRead() =>
       buildError(new Arguments.empty(), isGetter: true);
 
   @override
   Expression makeInvalidWrite(Expression value) {
-    return buildError(helper.astFactory.arguments(<Expression>[value]),
-        isSetter: true);
+    return buildError(new KernelArguments(<Expression>[value]), isSetter: true);
   }
 }
 
 class ThisAccessor extends FastaAccessor {
   final BuilderHelper helper;
 
   final Token token;
 
   final bool isInitializer;
 
@@ skipping 40 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(
-          helper.astFactory,
-          new ThisExpression(),
-          send.name,
-          send.arguments,
-          offsetForToken(token));
+      MethodInvocation result = 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(
-          helper.astFactory, new ThisExpression(), callName, arguments, offset);
+          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>[])) {
       return helper.buildInvalidIntializer(
@@ skipping 135 matching lines @@
       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(
-                helper.astFactory,
                 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(helper.astFactory,
+      result = 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 110 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(
-        helper.astFactory, buildSimpleRead(), callName, arguments, offset);
+        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(
-        helper.astFactory, receiver, name, arguments, offset);
+    return 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(helper.astFactory, buildSimpleRead(),
-          callName, arguments, offset + (readTarget?.name?.name?.length ?? 0));
+      return 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(
-          helper.astFactory, buildSimpleRead(), callName, arguments, offset);
+          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(
-        helper.astFactory, buildSimpleRead(), callName, arguments, offset);
+        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(
-        helper.astFactory, buildSimpleRead(), callName, arguments, offset);
+        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(
-        helper.astFactory, new ThisExpression(), name, arguments, offset);
+    return 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(helper.astFactory, buildSimpleRead(), callName,
-        arguments, offset + (variable.name?.length ?? 0));
+    return 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(
-        helper.astFactory, buildSimpleRead(), callName, arguments, offset);
+        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) {
     return helper.buildCompileTimeError(
@@ skipping 23 matching lines @@
     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(AstFactory astFactory, Expression receiver,
-    Name name, Arguments arguments, int offset,
+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(astFactory, new VariableGet(variable)),
+            buildIsNull(new VariableGet(variable)),
             new NullLiteral(),
-            astFactory.methodInvocation(
+            new KernelMethodInvocation(
                 new VariableGet(variable), name, arguments)
               ..fileOffset = offset,
             const DynamicType()));
   } else {
-    return astFactory.methodInvocation(receiver, name, arguments)
+    return new KernelMethodInvocation(receiver, name, arguments)
       ..fileOffset = offset;
   }
 }