We inline List allocations in dart2js to get the right behavior when the passed length is null. Thi…

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Setlet<Node> get superUses;
 
@@ skipping 299 matching lines @@
       redirection = resolver.visitor.resolveConstructorRedirection(redirection);
     }
   }
 
   void checkMatchingPatchParameters(FunctionElement origin,
                                     Link<Element> originParameters,
                                     Link<Element> patchParameters) {
     while (!originParameters.isEmpty) {
       Element originParameter = originParameters.head;
       Element patchParameter = patchParameters.head;
-      // Hack: Use unparser to test parameter equality. This only works because
-      // we are restricting patch uses and the approach cannot be used
-      // elsewhere.
-      String originParameterText =
-          originParameter.parseNode(compiler).toString();
-      String patchParameterText =
-          patchParameter.parseNode(compiler).toString();
-      if (originParameterText != patchParameterText) {
+      String originParameterName = originParameter.name;
+      String patchParameterName = patchParameter.name;
+      if (originParameterName != patchParameterName) {

[Johnni Winther, 2013/12/09 12:11:01]

With this change, we allow different default values on optional parameters.

I'd prefer if you make as special handling of the List constructor. Before this
check was made we have had unintentional differences and I wan't to avoid that.

[ngeoffray, 2013/12/09 15:24:17]

OK, I have reverted this change and check that the element is the List
constructor instead.

         compiler.reportError(
             originParameter.parseNode(compiler),
             MessageKind.PATCH_PARAMETER_MISMATCH,
             {'methodName': origin.name,
-             'originParameter': originParameterText,
-             'patchParameter': patchParameterText});
+             'originParameter': originParameterName,
+             'patchParameter': patchParameterName});
         compiler.reportMessage(
             compiler.spanFromSpannable(patchParameter),
             MessageKind.PATCH_POINT_TO_PARAMETER.error(
-                {'parameterName': patchParameter.name}),
+                {'parameterName': patchParameterName}),
             Diagnostic.INFO);
       }
       DartType originParameterType = originParameter.computeType(compiler);
       DartType patchParameterType = patchParameter.computeType(compiler);
       if (originParameterType != patchParameterType) {
         compiler.reportError(
             originParameter.parseNode(compiler),
             MessageKind.PATCH_PARAMETER_TYPE_MISMATCH,
             {'methodName': origin.name,
              'parameterName': originParameter.name,
@@ skipping 4419 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }