Fix constructor invocation type inference.

pkg/front_end/lib/src/fasta/kernel/body_builder.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.body_builder;
 
 import '../fasta_codes.dart'
     show FastaMessage, codeExpectedButGot, codeExpectedFunctionBody;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
 
 import '../parser/identifier_context.dart' show IdentifierContext;
 
 import 'package:front_end/src/fasta/builder/ast_factory.dart' show AstFactory;
 
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart'
-    show KernelField;
+    show KernelArguments, KernelField;
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show offsetForToken;
 
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart'
     show FieldNode;
 
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart'
     show TypeInferrer;
 
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart'
@@ skipping 532 matching lines @@
               buildCompileTimeError(
                   "Expected named argument.", arguments[i].fileOffset));
         }
       }
     }
     if (firstNamedArgumentIndex < arguments.length) {
       List<Expression> positional = new List<Expression>.from(
           arguments.getRange(0, firstNamedArgumentIndex));
       List<NamedExpression> named = new List<NamedExpression>.from(
           arguments.getRange(firstNamedArgumentIndex, arguments.length));
-      push(new Arguments(positional, named: named));
+      push(astFactory.arguments(positional, named: named));
     } else {
-      push(new Arguments(arguments));
+      push(astFactory.arguments(arguments));
     }
   }
 
   @override
   void handleParenthesizedExpression(BeginGroupToken token) {
     debugEvent("ParenthesizedExpression");
     push(new ParenthesizedExpression(this, popForValue(), token.endGroup));
   }
 
   @override
@@ skipping 193 matching lines @@
       message = "Method not found: '$errorName'.";
     }
     if (constantExpressionRequired) {
       return buildCompileTimeError(message, charOffset);
     }
     warning(message, charOffset);
     Constructor constructor =
         coreTypes.getClass("dart:core", "NoSuchMethodError").constructors.first;
     return new Throw(new ConstructorInvocation(
         constructor,
-        new Arguments(<Expression>[
+        astFactory.arguments(<Expression>[
           astFactory.nullLiteral(null),
           new SymbolLiteral(name),
           new ListLiteral(arguments.positional),
           new MapLiteral(arguments.named.map((arg) {
             return new MapEntry(new SymbolLiteral(arg.name), arg.value);
           }).toList()),
           astFactory.nullLiteral(null)
         ])));
   }
 
@@ skipping 1128 matching lines @@
     debugEvent("endConstLiteral");
     var literal = pop();
     constantExpressionRequired = pop();
     push(literal);
   }
 
   @override
   void endNewExpression(Token token) {
     debugEvent("NewExpression");
     Token nameToken = token.next;
-    Arguments arguments = pop();
+    KernelArguments arguments = pop();
     String name = pop();
     List<DartType> typeArguments = pop();
     var type = pop();
     bool savedConstantExpressionRequired = pop();
     () {
       if (arguments == null) {
         push(buildCompileTimeError("No arguments.", nameToken.charOffset));
         return;
       }
 
       if (typeArguments != null) {
         assert(arguments.types.isEmpty);
-        arguments.types.addAll(typeArguments);
+        astFactory.setExplicitArgumentTypes(arguments, typeArguments);
       }
 
       String errorName;
       if (type is ClassBuilder) {
         Builder b = type.findConstructorOrFactory(name, token.charOffset, uri);
         Member target;
         if (b == null) {
           // Not found. Reported below.
         } else if (b.isConstructor) {
           if (type.isAbstract) {
@@ skipping 579 matching lines @@
     }
     return super.handleUnrecoverableError(token, message);
   }
 
   @override
   Expression buildCompileTimeError(error, [int charOffset = -1]) {
     addCompileTimeError(charOffset, error);
     String message = formatUnexpected(uri, charOffset, error);
     Builder constructor = library.loader.getCompileTimeError();
     return new Throw(buildStaticInvocation(constructor.target,
-        new Arguments(<Expression>[new StringLiteral(message)])));
+        astFactory.arguments(<Expression>[new StringLiteral(message)])));
   }
 
   Expression buildAbstractClassInstantiationError(String className,
       [int charOffset = -1]) {
     warning("The class '$className' is abstract and can't be instantiated.",
         charOffset);
     Builder constructor = library.loader.getAbstractClassInstantiationError();
     return new Throw(buildStaticInvocation(constructor.target,
-        new Arguments(<Expression>[new StringLiteral(className)])));
+        astFactory.arguments(<Expression>[new StringLiteral(className)])));
   }
 
   Statement buildCompileTimeErrorStatement(error, [int charOffset = -1]) {
     return astFactory
         .expressionStatement(buildCompileTimeError(error, charOffset));
   }
 
   @override
   Initializer buildInvalidIntializer(Expression expression,
       [int charOffset = -1]) {
@@ skipping 562 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is FastaAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }