dart2js: Allow multiple invocations of type.ensureResolved in new emitter.

pkg/compiler/lib/src/js_emitter/new_emitter/model_emitter.dart

 // Copyright (c) 2014, 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 dart2js.new_js_emitter.model_emitter;
 
 import '../../constants/values.dart' show ConstantValue, FunctionConstantValue;
 import '../../dart2jslib.dart' show Compiler;
 import '../../dart_types.dart' show DartType;
 import '../../elements/elements.dart' show ClassElement, FunctionElement;
@@ skipping 848 matching lines @@
       var getterName = statics[i + 1];
       var holderIndex = statics[i + 2];
       var initializer = statics[i + 3];
       setupLazyStatic(name, getterName, holders[holderIndex], initializer);
     }
   }
 
   function setupStatic(name, holder, descriptor) {
     if (typeof descriptor == 'string') {
       holder[name] = function() {
+        if (descriptor == null) {
+          // Already compiled. This happens when we have calls to the static as
+          // arguments to the static: `foo(foo(499))`;
+          return holder[name].apply(this, arguments);
+        }
         var method = compile(name, descriptor);
         holder[name] = method;
+        descriptor = null;  // GC the descriptor.
         return method.apply(this, arguments);
       };
     } else {
       // Parse the tear off information and generate compile handlers.
       // TODO(herhut): Share parser with instance methods.      
       function compileAllStubs() {
         var funs;
         var fun = compile(name, descriptor[0]);
         fun[#callName] = descriptor[1];
         holder[name] = fun;
@@ skipping 14 matching lines @@
               tearOff(funs, descriptor[3], true, name, false);
         }
         if (pos < descriptor.length) {
           fun[#argumentCount] = descriptor[pos];
           fun[#defaultArgumentValues] = descriptor[pos + 1];
         }
       }
 
       function setupCompileAllAndDelegateStub(name) {
         holder[name] = function() {
-          compileAllStubs();
+          // The descriptor is null if we already compiled this function. This
+          // happens when we have calls to the static as arguments to the
+          // static: `foo(foo(499))`;
+          if (descriptor != null) {
+            compileAllStubs();
+            descriptor = null;  // GC the descriptor.
+          }
           return holder[name].apply(this, arguments);
         };
       }
 
       setupCompileAllAndDelegateStub(name);
       for (var pos = 4; pos < descriptor.length; pos += 3) {
         setupCompileAllAndDelegateStub(descriptor[pos]);
       }
       if (descriptor[2] != null) {  // tear-off name.
         setupCompileAllAndDelegateStub(descriptor[2])
@@ skipping 20 matching lines @@
           holder[name] = null;
         }
         holder[getterName] = function() { return this[name]; };
       }
       return result;
     };
   }
 
   function setupClass(name, holder, descriptor) {
     var patch = function() {
-      var constructor = compileConstructor(name, descriptor);
-      holder[name] = constructor;
-      constructor.ensureResolved = function() { return this; };
-      if (this === patch) return constructor;  // Was used as "ensureResolved".
+      if (patch.ensureResolved == patch) {
+        // We have not yet been compiled.
+        var constructor = compileConstructor(name, descriptor);
+        holder[name] = constructor;
+        name = holder = descriptor = null;  // GC the captured arguments.
+        // Make sure we can invoke 'ensureResolved' multiple times on the patch
+        // function.
+        patch.ensureResolved = function() { return constructor; };
+        constructor.ensureResolved = function() { return this; };
+      } else {
+        // This can happen when arguments to the constructor are of the same
+        // class, like in `new A(new A(null))`.
+        constructor = patch.ensureResolved();
+      }
+      // If the patch has been called as "ensureResolved" return.
+      if (this === patch) return constructor;
       var object = new constructor();
       constructor.apply(object, arguments);
       return object;
     };
 
     // We store the patch function on itself to make it
     // possible to resolve superclass references without constructing instances.
     patch.ensureResolved = patch;
     holder[name] = patch;
   }
@@ skipping 115 matching lines @@
 
   var end = Date.now();
   // print('Setup: ' + (end - start) + ' ms.');
 
   #invokeMain;  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }