dart2js: support native classes in the 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 '../../dart2jslib.dart' show Compiler;
 import '../../js/js.dart' as js;
 import '../../js_backend/js_backend.dart' show
     JavaScriptBackend,
     Namer,
     ConstantEmitter;
 
+import '../js_emitter.dart' show
+    NativeEmitter;
+
 import 'package:_internal/compiler/js_lib/shared/embedded_names.dart' show
     DEFERRED_LIBRARY_URIS,
     DEFERRED_LIBRARY_HASHES,
     GET_TYPE_FROM_NAME,
     INITIALIZE_LOADED_HUNK,
+    INTERCEPTORS_BY_TAG,
     IS_HUNK_INITIALIZED,
     IS_HUNK_LOADED,
+    LEAF_TAGS,
     TYPE_TO_INTERCEPTOR_MAP;
 
 import '../js_emitter.dart' show NativeGenerator;
 import '../model.dart';
 
 class ModelEmitter {
   final Compiler compiler;
   final Namer namer;
   final ConstantEmitter constantEmitter;
+  final NativeEmitter nativeEmitter;
 
   JavaScriptBackend get backend => compiler.backend;
 
   /// For deferred loading we communicate the initializers via this global var.
   static const String deferredInitializersGlobal =
       r"$__dart_deferred_initializers__";
 
   static const String deferredExtension = "part.js";
 
-  ModelEmitter(Compiler compiler, Namer namer)
+  ModelEmitter(Compiler compiler, Namer namer, this.nativeEmitter)
       : this.compiler = compiler,
         this.namer = namer,
         constantEmitter =
             new ConstantEmitter(compiler, namer, makeConstantListTemplate);
 
   js.Expression generateEmbeddedGlobalAccess(String global) {
     // TODO(floitsch): We should not use "init" for globals.
     return js.js("init.$global");
   }
 
@@ skipping 31 matching lines @@
     if (compiler.hasBuildId) suffix = ' version: ${compiler.buildId}';
     return '// Generated by dart2js, the Dart to JavaScript compiler$suffix.\n';
   }
 
   js.Statement emitMainFragment(Program program) {
     MainFragment fragment = program.fragments.first;
     List<js.Expression> elements = fragment.libraries.map(emitLibrary).toList();
     elements.add(
         emitLazilyInitializedStatics(fragment.staticLazilyInitializedFields));
 
-    js.Statement nativeBoilerplate;
+    js.Expression code = new js.ArrayInitializer(elements);
+
+    Map<String, dynamic> holes =
+      {'deferredInitializer': emitDeferredInitializerGlobal(program.loadMap),
+       'holders': emitHolders(fragment.holders),
+       'cyclicThrow':
+         backend.emitter.staticFunctionAccess(backend.getCyclicThrowHelper()),
+       'outputContainsConstantList': program.outputContainsConstantList,
+       'embeddedGlobals': emitEmbeddedGlobals(program),
+       'constants': emitConstants(fragment.constants),
+       'staticNonFinals':
+         emitStaticNonFinalFields(fragment.staticNonFinalFields),
+       'eagerClasses': emitEagerClassInitializations(fragment.libraries),
+       'main': fragment.main,
+       'code': code};
+
+    holes.addAll(nativeHoles(program));
+
+    return js.js.statement(boilerplate, holes);
+  }
+
+  Map<String, dynamic> nativeHoles(Program program) {
+    Map<String, dynamic> nativeHoles = <String, dynamic>{};
+
+    js.Statement nativeIsolateAffinityTagInitialization;
     if (NativeGenerator.needsIsolateAffinityTagInitialization(backend)) {
-      nativeBoilerplate =
+      nativeIsolateAffinityTagInitialization =
           NativeGenerator.generateIsolateAffinityTagInitialization(
               backend,
               generateEmbeddedGlobalAccess,
               // TODO(floitsch): convertToFastObject.
               js.js("(function(x) { return x; })", []));
     } else {
-      nativeBoilerplate = js.js.statement(";");
+      nativeIsolateAffinityTagInitialization = js.js.statement(";");
     }
+    nativeHoles['nativeIsolateAffinityTagInitialization'] =
+        nativeIsolateAffinityTagInitialization;
 
-    js.Expression code = new js.ArrayInitializer(elements);
 
-    return js.js.statement(
-        boilerplate,
-        {'deferredInitializer': emitDeferredInitializerGlobal(program.loadMap),
-         'holders': emitHolders(fragment.holders),
-         'cyclicThrow':
-           backend.emitter.staticFunctionAccess(backend.getCyclicThrowHelper()),
-         'outputContainsConstantList': program.outputContainsConstantList,
-         'embeddedGlobals': emitEmbeddedGlobals(program),
-         'constants': emitConstants(fragment.constants),
-         'staticNonFinals': emitStaticNonFinalFields(fragment.staticNonFinalFields),
-         'nativeBoilerplate': nativeBoilerplate,
-         'eagerClasses': emitEagerClassInitializations(fragment.libraries),
-         'main': fragment.main,
-         'code': code});
+    js.Expression nativeInfoAccess = js.js('nativeInfo', []);
+    js.Expression constructorAccess = js.js('constructor', []);
+    Function subclassReadGenerator = (js.Expression subclass) {
+      return js.js('holdersMap[#][#].ensureResolved()', [subclass, subclass]);
+    };
+    js.Expression interceptorsByTagAccess =
+        generateEmbeddedGlobalAccess(INTERCEPTORS_BY_TAG);
+    js.Expression leafTagsAccess =
+        generateEmbeddedGlobalAccess(LEAF_TAGS);
+    js.Statement nativeInfoHandler = nativeEmitter.buildNativeInfoHandler(
+        nativeInfoAccess,
+        constructorAccess,
+        subclassReadGenerator,
+        interceptorsByTagAccess,
+        leafTagsAccess);
+
+    nativeHoles['hasNativeClasses'] = program.outputContainsNativeClasses;
+    nativeHoles['hasNotNativeClasses'] = !program.outputContainsNativeClasses;
+    nativeHoles['nativeInfoHandler'] = nativeInfoHandler;
+
+    return nativeHoles;
   }
 
   js.Block emitHolders(List<Holder> holders) {
     // The top-level variables for holders must *not* be renamed by the
     // JavaScript pretty printer because a lot of code already uses the
     // non-renamed names. The generated code looks like this:
     //
     //    var H = {}, ..., G = {};
     //    var holders = [ H, ..., G ];
     //
@@ skipping 29 matching lines @@
       globals.add(emitInitializeLoadedHunk());
     }
 
     globals.add(emitGetTypeFromName());
 
     if (program.typeToInterceptorMap != null) {
       globals.add(new js.Property(js.string(TYPE_TO_INTERCEPTOR_MAP),
                                   program.typeToInterceptorMap));
     }
 
+    if (program.outputContainsNativeClasses) {
+      globals.add(new js.Property(js.string(INTERCEPTORS_BY_TAG),
+                                  js.js('Object.create(null)', [])));
+      globals.add(new js.Property(js.string(LEAF_TAGS),
+                                  js.js('Object.create(null)', [])));
+    }
+
     js.ObjectInitializer globalsObject = new js.ObjectInitializer(globals);
 
     List<js.Statement> statements =
         [new js.ExpressionStatement(
             new js.VariableDeclarationList(
                 [new js.VariableInitialization(
                     new js.VariableDeclaration("init", allowRename: false),
                     globalsObject)]))];
     return new js.Block(statements);
   }
@@ skipping 103 matching lines @@
     }
 
     List<js.Statement> instantiations =
         libraries.expand((Library library) => library.classes)
                  .where((Class cls) => cls.isEager)
                  .map(createInstantiation)
                  .toList(growable: false);
     return new js.Block(instantiations);
   }
 
+  // This string should be referenced wherever JavaScript code makes assumptions
+  // on the mixin format.
+  static final String nativeInfoDescription =
+      "A class is encoded as follows:"
+      "   [name, class-code, holder-index], or "
+      "   [name, class-code, native-info, holder-index].";
+
   js.Expression emitLibrary(Library library) {
-    Iterable staticDescriptors = library.statics.expand((e) =>
-        [ js.string(e.name), js.number(e.holder.index), emitStaticMethod(e) ]);
-    Iterable classDescriptors = library.classes.expand((e) =>
-        [ js.string(e.name), js.number(e.holder.index), emitClass(e) ]);
+    Iterable staticDescriptors = library.statics.expand((StaticMethod m) =>
+        [js.string(m.name), js.number(m.holder.index), emitStaticMethod(m)]);
+
+    Iterable classDescriptors = library.classes.expand((Class cls) {
+      js.LiteralString name = js.string(cls.name);
+      js.LiteralNumber holderIndex = js.number(cls.holder.index);
+      js.Expression emittedClass = emitClass(cls);
+      if (cls.nativeInfo == null) {
+        return [name, emittedClass, holderIndex];
+      } else {
+        return [name, emittedClass, js.string(cls.nativeInfo), holderIndex];
+      }
+    });
 
     js.Expression staticArray =
         new js.ArrayInitializer(staticDescriptors.toList(growable: false));
     js.Expression classArray =
         new js.ArrayInitializer(classDescriptors.toList(growable: false));
 
     return new js.ArrayInitializer([staticArray, classArray]);
   }
 
   js.Expression _generateConstructor(Class cls) {
@@ skipping 93 matching lines @@
 
   static final String boilerplate = """
 {
 // Declare deferred-initializer global.
 #deferredInitializer;
 
 !function(start, program) {
 
   // Initialize holder objects.
   #holders;
+  var nativeInfos = Object.create(null);
 
   function setupProgram() {
     for (var i = 0; i < program.length - 1; i++) {
       setupLibrary(program[i]);
     }
     setupLazyStatics(program[i]);
   }
 
   function setupLibrary(library) {
     var statics = library[0];
     for (var i = 0; i < statics.length; i += 3) {
       var holderIndex = statics[i + 1];
       setupStatic(statics[i], holders[holderIndex], statics[i + 2]);
     }
 
     var classes = library[1];
     for (var i = 0; i < classes.length; i += 3) {
-      var holderIndex = classes[i + 1];
-      holdersMap[classes[i]] = holders[holderIndex];
-      setupClass(classes[i], holders[holderIndex], classes[i + 2]);
+      var name = classes[i];
+      var cls = classes[i + 1];
+
+      if (#hasNativeClasses) {
+        // $nativeInfoDescription.
+        var indexOrNativeInfo = classes[i + 2];
+        if (typeof indexOrNativeInfo == "number") {
+          var holderIndex = classes[i + 2];
+        } else {
+          nativeInfos[name] = indexOrNativeInfo;
+          holderIndex = classes[i + 3];
+          i++;
+        }
+      }
+
+      if (#hasNotNativeClasses) {

[zarah, 2015/01/28 10:54:40]

hasNoNativeClasses

[floitsch, 2015/01/28 13:28:27]

Done.

+        var holderIndex = classes[i + 2];
+      }
+
+      holdersMap[name] = holders[holderIndex];
+      setupClass(name, holders[holderIndex], cls);
     }
   }
 
   function setupLazyStatics(statics) {
     for (var i = 0; i < statics.length; i += 4) {
       var name = statics[i];
       var getterName = statics[i + 1];
       var holderIndex = statics[i + 2];
       var initializer = statics[i + 3];
       setupLazyStatic(name, getterName, holders[holderIndex], initializer);
@@ skipping 119 matching lines @@
     function makeConstList(list) {
       // By assigning a function to the properties they become part of the
       // hidden class. The actual values of the fields don't matter, since we
       // only check if they exist.
       list.immutable\$list = Array;
       list.fixed\$length = Array;
       return list;
     }
   }
 
+  if (#hasNativeClasses) {
+    function handleNativeClassInfos() {
+      for (var nativeClass in nativeInfos) {
+        var constructor = holdersMap[nativeClass][nativeClass].ensureResolved();
+        var nativeInfo = nativeInfos[nativeClass];
+        #nativeInfoHandler;
+      }
+    }
+  }
+
   setupProgram();
 
   // Initialize constants.
   #constants;
 
   // Initialize globals.
   #embeddedGlobals;
 
+  // TODO(floitsch): this order means that native classes may not be
+  // referenced from constants. I'm mostly afraid of things like using them as
+  // generic arguments (which should be fine, but maybe there are other
+  // similar things).
+  // Initialize natives.
+  if (#hasNativeClasses) handleNativeClassInfos();
+
   // Initialize static non-final fields.
   #staticNonFinals;
 
   // Add native boilerplate code.
-  #nativeBoilerplate;
+  #nativeIsolateAffinityTagInitialization;
 
   // Initialize eager classes.
   #eagerClasses;
 
   var end = Date.now();
   print('Setup: ' + (end - start) + ' ms.');
 
   #main();  // Start main.
 
 }(Date.now(), #code)
 }""";
 
 }