Remove the type token used to pass element information to arrays.

compiler/java/com/google/dart/compiler/backend/js/GenerateJavascriptAST.java

 // Copyright (c) 2011, 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.
 
 package com.google.dart.compiler.backend.js;
 
 import com.google.common.collect.Lists;
 import com.google.dart.compiler.DartCompilationError;
 import com.google.dart.compiler.DartCompilerContext;
 import com.google.dart.compiler.InternalCompilerException;
@@ skipping 1019 matching lines @@
       // We do the constructor invocation before we declare the temporary variable. This is
       // necessary to ensure that the created temporary does not conflict with the parameters.
       JsInvocation constructorInvocation = new JsInvocation();
       JsName constructorJsName = getJsName(element);
       JsNameRef constructorRef = AstUtil.newNameRef(curClassJsName.makeRef(), constructorJsName);
       constructorInvocation.setQualifier(AstUtil.newNameRef(constructorRef, "call"));
 
       // Add the arguments to the constructor invocation. Note that the constructor call is still
       // missing the 'tmp' variable. We will add it later.
       List<DartParameter> params = x.getFunction().getParams();
+      List<JsName> jsArgNames = new ArrayList<JsName>();
       for (DartParameter p : params) {
         // TODO(ngeoffray): We should actually copy the arguments. See b/4424659.
         JsName argName = getJsName(p.getNormalizedNode().getSymbol());
+        jsArgNames.add(argName);
         constructorInvocation.getArguments().add(argName.makeRef());
       }
 
       JsName tempVar = factoryScope.declareTemporary();
       // Add the 'tmp' var to the constructor call.
       constructorInvocation.getArguments().add(0, tempVar.makeRef());
 
       factoryFunction.setBody(AstUtil.newBlock(
           constructorInvocation.makeStmt(),
           new JsReturn(tempVar.makeRef())));
 
       if (optStrategy.canInlineInitializers(element)) {
         rtt.maybeAddClassRuntimeTypeToConstructor(classElement, factoryFunction, tempVar.makeRef());
         generateInitializersInlined(x, factoryFunction, factoryScope, tempVar);
       } else {
         addInitializers(x, factoryFunction, tempVar);
         rtt.maybeAddClassRuntimeTypeToConstructor(classElement, factoryFunction, tempVar.makeRef());
         JsNew jsNew = new JsNew(curClassJsName.makeRef());
+        if (classElement.getNativeName() != null && x.getFunction().getBody() == null) {

[floitsch, 2012/01/16 13:23:26]

I don't understand this code. (In any case add comments).

[mmendez, 2012/01/17 12:48:04]

Added a comment in the code to match the comment in the code review description.

For native classes that declare a body-less constructor, we will pass the
factory arguments to the native "new" expression.

In this case, it causes the length of the array to be passed to the "new
Array..." JS expression being generated which allows us to use the generated
factory method for instantiating the native class as well as optionally adding
the runtime type information if necessary without a temporary object.
 
On 2012/01/16 13:23:26, floitsch wrote:

+          List<JsExpression> newArguments = jsNew.getArguments();
+          for (JsName jsArgName : jsArgNames) {
+            newArguments.add(jsArgName.makeRef());
+          }
+        }
         factoryFunction.getBody().getStatements().add(0, AstUtil.newVar(x, tempVar, jsNew));
       }
 
       generateAll(x.getFunction().getParams(), factoryFunction.getParameters(), JsParameter.class);
 
       assert currentScopeInfo != null;
       inFactory = false;
       inFactoryOrStaticContext = false;
       currentScopeInfo = null;
 
@@ skipping 2874 matching lines @@
       JsBlock blockStatics) {
     GenerateJavascriptVisitor generator =
         new GenerateJavascriptVisitor(unit, context, translationContext,
             optStrategy, typeProvider, generateClosureCompatibleCode);
     // Generate the Javascript AST.
     node.accept(generator);
     // Set aside the static initializations
     generator.addStaticInitsToBlock(blockStatics);
   }
 }