Fix constructor invocation type inference.

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.
 
 import 'package:front_end/src/fasta/builder/ast_factory.dart';
 
 /// A library to help transform compounds and null-aware accessors into
 /// let expressions.
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
@@ skipping 303 matching lines @@
     } else {
       return new IndexAccessor.internal(
           helper, receiver, index, getter, setter, token);
     }
   }
 
   IndexAccessor.internal(BuilderHelper helper, this.receiver, this.index,
       this.getter, this.setter, Token token)
       : super(helper, token);
 
-  Expression _makeSimpleRead() => helper.astFactory.methodInvocation(
-      receiver, indexGetName, new Arguments(<Expression>[index]), getter)
+  Expression _makeSimpleRead() => helper.astFactory.methodInvocation(receiver,
+      indexGetName, helper.astFactory.arguments(<Expression>[index]), getter)
     ..fileOffset = offsetForToken(token);
 
   Expression _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return helper.astFactory.methodInvocation(receiver, indexSetName,
-        new Arguments(<Expression>[index, value]), setter)
+        helper.astFactory.arguments(<Expression>[index, value]), setter)
       ..fileOffset = offsetForToken(token);
   }
 
   receiverAccess() {
     // We cannot reuse the receiver if it is a variable since it might be
     // reassigned in the index expression.
     receiverVariable ??= new VariableDeclaration.forValue(receiver);
     return new VariableGet(receiverVariable)
       ..fileOffset = offsetForToken(token);
   }
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
     return new VariableGet(indexVariable)..fileOffset = offsetForToken(token);
   }
 
   Expression _makeRead() {
-    return builtGetter = helper.astFactory.methodInvocation(receiverAccess(),
-        indexGetName, new Arguments(<Expression>[indexAccess()]), getter)
+    return builtGetter = helper.astFactory.methodInvocation(
+        receiverAccess(),
+        indexGetName,
+        helper.astFactory.arguments(<Expression>[indexAccess()]),
+        getter)
       ..fileOffset = offsetForToken(token);
   }
 
   Expression _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return helper.astFactory.methodInvocation(receiverAccess(), indexSetName,
-        new Arguments(<Expression>[indexAccess(), value]), setter)
+        helper.astFactory.arguments(<Expression>[indexAccess(), value]), setter)
       ..fileOffset = offsetForToken(token);
   }
 
   // TODO(dmitryas): remove this method after the "[]=" operator of the Context
   // class is made to return a value.
   _makeWriteAndReturn(Expression value) {
     // The call to []= does not return the value like direct-style assignments
     // do.  We need to bind the value in a let.
     var valueVariable = new VariableDeclaration.forValue(value);
     var dummy = new VariableDeclaration.forValue(helper.astFactory
         .methodInvocation(
             receiverAccess(),
             indexSetName,
-            new Arguments(
+            helper.astFactory.arguments(
                 <Expression>[indexAccess(), new VariableGet(valueVariable)]),
             setter)
           ..fileOffset = offsetForToken(token));
     return makeLet(
         valueVariable, makeLet(dummy, new VariableGet(valueVariable)));
   }
 
   Expression _finish(Expression body) {
     return makeLet(receiverVariable, makeLet(indexVariable, body));
   }
 }
 
 /// Special case of [IndexAccessor] to avoid creating an indirect access to
 /// 'this'.
 class ThisIndexAccessor extends Accessor {
   Expression index;
   VariableDeclaration indexVariable;
   Procedure getter, setter;
 
   ThisIndexAccessor(
       BuilderHelper helper, this.index, this.getter, this.setter, Token token)
       : super(helper, token);
 
   Expression _makeSimpleRead() {
     return helper.astFactory.methodInvocation(new ThisExpression(),
-        indexGetName, new Arguments(<Expression>[index]), getter);
+        indexGetName, helper.astFactory.arguments(<Expression>[index]), getter);
   }
 
   Expression _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
-    return helper.astFactory.methodInvocation(new ThisExpression(),
-        indexSetName, new Arguments(<Expression>[index, value]), setter);
+    return helper.astFactory.methodInvocation(
+        new ThisExpression(),
+        indexSetName,
+        helper.astFactory.arguments(<Expression>[index, value]),
+        setter);
   }
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
     return new VariableGet(indexVariable);
   }
 
   Expression _makeRead() => builtGetter = helper.astFactory.methodInvocation(
       new ThisExpression(),
       indexGetName,
-      new Arguments(<Expression>[indexAccess()]),
+      helper.astFactory.arguments(<Expression>[indexAccess()]),
       getter);
 
   Expression _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
     return helper.astFactory.methodInvocation(
         new ThisExpression(),
         indexSetName,
-        new Arguments(<Expression>[indexAccess(), value]),
+        helper.astFactory.arguments(<Expression>[indexAccess(), value]),
         setter);
   }
 
   _makeWriteAndReturn(Expression value) {
     var valueVariable = new VariableDeclaration.forValue(value);
     var dummy = new VariableDeclaration.forValue(helper.astFactory
         .methodInvocation(
             new ThisExpression(),
             indexSetName,
-            new Arguments(
+            helper.astFactory.arguments(
                 <Expression>[indexAccess(), new VariableGet(valueVariable)]),
             setter));
     return makeLet(
         valueVariable, makeLet(dummy, new VariableGet(valueVariable)));
   }
 
   Expression _finish(Expression body) => makeLet(indexVariable, body);
 }
 
 class SuperIndexAccessor extends Accessor {
   Expression index;
   VariableDeclaration indexVariable;
   Member getter, setter;
 
   SuperIndexAccessor(
       BuilderHelper helper, this.index, this.getter, this.setter, Token token)
       : super(helper, token);
 
   indexAccess() {
     indexVariable ??= new VariableDeclaration.forValue(index);
     return new VariableGet(indexVariable);
   }
 
   Expression _makeSimpleRead() => new SuperMethodInvocation(
-      indexGetName, new Arguments(<Expression>[index]), getter);
+      indexGetName, helper.astFactory.arguments(<Expression>[index]), getter);
 
   Expression _makeSimpleWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
-    return new SuperMethodInvocation(
-        indexSetName, new Arguments(<Expression>[index, value]), setter);
+    return new SuperMethodInvocation(indexSetName,
+        helper.astFactory.arguments(<Expression>[index, value]), setter);
   }
 
   Expression _makeRead() {
-    return builtGetter = new SuperMethodInvocation(
-        indexGetName, new Arguments(<Expression>[indexAccess()]), getter);
+    return builtGetter = new SuperMethodInvocation(indexGetName,
+        helper.astFactory.arguments(<Expression>[indexAccess()]), getter);
   }
 
   Expression _makeWrite(Expression value, bool voidContext) {
     if (!voidContext) return _makeWriteAndReturn(value);
-    return new SuperMethodInvocation(indexSetName,
-        new Arguments(<Expression>[indexAccess(), value]), setter);
+    return new SuperMethodInvocation(
+        indexSetName,
+        helper.astFactory.arguments(<Expression>[indexAccess(), value]),
+        setter);
   }
 
   _makeWriteAndReturn(Expression value) {
     var valueVariable = new VariableDeclaration.forValue(value);
     var dummy = new VariableDeclaration.forValue(new SuperMethodInvocation(
         indexSetName,
-        new Arguments(
+        helper.astFactory.arguments(
             <Expression>[indexAccess(), new VariableGet(valueVariable)]),
         setter));
     return makeLet(
         valueVariable, makeLet(dummy, new VariableGet(valueVariable)));
   }
 
   Expression _finish(Expression body) {
     return makeLet(indexVariable, body);
   }
 }
@@ skipping 39 matching lines @@
 }
 
 Expression makeLet(VariableDeclaration variable, Expression body) {
   if (variable == null) return body;
   return new Let(variable, body);
 }
 
 Expression makeBinary(AstFactory astFactory, Expression left, Name operator,
     Procedure interfaceTarget, Expression right,
     {int offset: TreeNode.noOffset}) {
-  return astFactory.methodInvocation(
-      left, operator, new Arguments(<Expression>[right]), interfaceTarget)
+  return astFactory.methodInvocation(left, operator,
+      astFactory.arguments(<Expression>[right]), interfaceTarget)
     ..fileOffset = offset;
 }
 
 final Name _equalOperator = new Name('==');
 
 Expression buildIsNull(AstFactory astFactory, Expression value,
     {int offset: TreeNode.noOffset}) {
   return makeBinary(astFactory, value, _equalOperator, null, new NullLiteral(),
       offset: offset);
 }
 
 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());
 }