Remove holders for runtime type information.

sdk/lib/_internal/compiler/implementation/js_backend/emitter.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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 282 matching lines @@
     // Example:
     // defineClass("A", ["x", "y"], {
     //  foo$1: function(y) {
     //   print(this.x + y);
     //  },
     //  bar$2: function(t, v) {
     //   this.x = t - v;
     //  },
     // });
 
-    // function(cls, fields, prototype) {
-    var defineClass = js.fun(['cls', 'fields', 'prototype'], [
+    var defineClass = js.fun(['name', 'cls', 'fields', 'prototype'], [
       js('var constructor'),
 
-      // if (typeof fields == "function") {
       js.if_(js('typeof fields == "function"'), [
         js('constructor = fields')
       ], /* else */ [
         js('var str = "function " + cls + "("'),
         js('var body = ""'),
 
-        // for (var i = 0; i < fields.length; i++) {
         js.for_('var i = 0', 'i < fields.length', 'i++', [
-          // if (i != 0) str += ", ";
           js.if_('i != 0', js('str += ", "')),
 
           js('var field = fields[i]'),
           js('field = generateAccessor(field, prototype)'),
           js('str += field'),
           js('body += ("this." + field + " = " + field + ";\\n")')
         ]),
 
         js('str += (") {" + body + "}\\nreturn " + cls)'),
 
         js('constructor = new Function(str)()')
       ]),
 
       js('constructor.prototype = prototype'),
-      js('constructor.builtin\$cls = cls'),
+      js(r'constructor.builtin$cls = name'),
 
-      // return constructor;
       js.return_('constructor')
     ]);
     // Declare a function called "generateAccessor".  This is used in
     // defineClassFunction (it's a local declaration in init()).
     return [
         generateAccessorFunction,
         js('$generateAccessorHolder = generateAccessor'),
         new jsAst.FunctionDeclaration(
             new jsAst.VariableDeclaration('defineClass'), defineClass) ];
   }
 
   /** Needs defineClass to be defined. */
   List buildProtoSupportCheck() {
     // On Firefox and Webkit browsers we can manipulate the __proto__
     // directly. Opera claims to have __proto__ support, but it is buggy.
     // So we have to do more checks.
     // Opera bug was filed as DSK-370158, and fixed as CORE-47615
     // (http://my.opera.com/desktopteam/blog/2012/07/20/more-12-01-fixes).
     // If the browser does not support __proto__ we need to instantiate an
     // object with the correct (internal) prototype set up correctly, and then
     // copy the members.
     // TODO(8541): Remove this work around.
 
     return [
       js('var $supportsProtoName = false'),
-      js('var tmp = defineClass("c", ["f?"], {}).prototype'),
+      js('var tmp = defineClass("c", "c", ["f?"], {}).prototype'),
 
       js.if_(js('tmp.__proto__'), [
         js('tmp.__proto__ = {}'),
         js.if_(js(r'typeof tmp.get$f != "undefined"'),
                js('$supportsProtoName = true'))
 
       ])
     ];
   }
 
@@ skipping 227 matching lines @@
     //    constructor.
     // For engines where we have access to the '__proto__' we can manipulate
     // the object literal directly. For other engines we have to create a new
     // object and copy over the members.
 
     List<jsAst.Node> statements = [
       js('var pendingClasses = {}'),
 
       js('var hasOwnProperty = Object.prototype.hasOwnProperty'),
 
-      // for (var cls in collectedClasses)
       js.forIn('cls', 'collectedClasses', [
-        // if (hasOwnProperty.call(collectedClasses, cls))
         js.if_('hasOwnProperty.call(collectedClasses, cls)', [
           js('var desc = collectedClasses[cls]'),
 
           /* The 'fields' are either a constructor function or a
            * string encoding fields, constructor and superclass.  Get
            * the superclass and the fields in the format
-           * Super;field1,field2 from the null-string property on the
-           * descriptor.
+           *   '[name/]Super;field1,field2'
+           * from the null-string property on the descriptor.
+           * The 'name/' is optional and contains the name that should be used
+           * when printing the runtime type string.  It is used, for example, to
+           * print the runtime type JSInt as 'int'.
            */
-          js('var fields = desc[""], supr'),
+          js('var classData = desc[""], supr, name, fields'),
+          js('var split = classData.split("/")'),
+          js.if_('split.length == 2', [
+            js('name = split[0]'),
+            js('fields = split[1]')
+          ], /* else */ [
+            js('name = cls'),
+            js('fields = classData')
+          ]),
 
           js.if_('typeof fields == "string"', [
             js('var s = fields.split(";")'),
             js('fields = s[1] == "" ? [] : s[1].split(",")'),
             js('supr = s[0]'),
           ], /* else */ [
             js('supr = desc.super'),
           ]),
 
           optional(needsMixinSupport, js.if_('supr && supr.indexOf("+") > 0', [
             js('s = supr.split("+")'),
             js('supr = s[0]'),
             js('var mixin = collectedClasses[s[1]]'),
             js.forIn('d', 'mixin', [
               js.if_('hasOwnProperty.call(mixin, d)'
                      '&& !hasOwnProperty.call(desc, d)',
                 js('desc[d] = mixin[d]'))
             ]),
           ])),
 
-          js('isolateProperties[cls] = defineClass(cls, fields, desc)'),
+          js('isolateProperties[cls] = defineClass(name, cls, fields, desc)'),
           js.if_('supr', js('pendingClasses[cls] = supr'))
         ])
       ]),
 
       js('var finishedClasses = {}'),
 
       buildFinishClass(),
     ];
 
     addTrivialNsmHandlers(statements);
@@ skipping 556 matching lines @@
   }
 
   void emitIsTests(ClassElement classElement, ClassBuilder builder) {
     assert(invariant(classElement, classElement.isDeclaration));
 
     void generateIsTest(Element other) {
       if (other == compiler.objectClass && other != classElement) {
         // Avoid emitting [:$isObject:] on all classes but [Object].
         return;
       }
+      other = backend.getImplementationClass(other);
       builder.addProperty(namer.operatorIs(other), js('true'));
     }
 
     void generateSubstitution(Element other, {bool emitNull: false}) {
       RuntimeTypes rti = backend.rti;
       // TODO(karlklose): support typedefs with variables.
       jsAst.Expression expression;
       bool needsNativeCheck = nativeEmitter.requiresNativeIsCheck(other);
       if (other.kind == ElementKind.CLASS) {
         String substitution = rti.getSupertypeSubstitution(classElement, other,
             alwaysGenerateFunction: true);
         if (substitution != null) {
           expression = new jsAst.LiteralExpression(substitution);
         } else if (emitNull || needsNativeCheck) {
           expression = new jsAst.LiteralNull();
         }
       }
       if (expression != null) {
         builder.addProperty(namer.substitutionName(other), expression);
       }
     }
 
     generateIsTestsOn(classElement, generateIsTest, generateSubstitution);
   }
 
   void emitRuntimeTypeSupport(CodeBuffer buffer) {
     RuntimeTypes rti = backend.rti;
-    TypeChecks typeChecks = rti.getRequiredChecks();
+    TypeChecks typeChecks = rti.requiredChecks;
 
-    /// Classes that are not instantiated and native classes need a holder
-    /// object for their checks, because there will be no class defined for
-    /// them.
-
-    // TODO(9556): Get rid of holders.
-    //
-    //  - For primitive classes, use the interceptors (e.g JSInt).
-    //
-    //  - For uninstantiated classes, define the class anyway.  It will not need
-    //    fields or a constructor, or any methods, so the class definition will
-    //    be smaller than a holder.
-
-    bool needsHolder(ClassElement cls) {
-      return !neededClasses.contains(cls) ||
-        rti.isJsNative(cls);
-    }
-
-    /**
-     * Generates a holder object if it is needed.  A holder is a JavaScript
-     * object literal with a field [builtin$cls] that contains the name of the
-     * class as a string (just like object constructors do).  The is-checks for
-     * the class are are added to the holder object later.
-     */
-    void maybeGenerateHolder(ClassElement cls) {
-      if (!needsHolder(cls)) return;
-      String holder = namer.isolateAccess(cls);
-      String name = namer.getRuntimeTypeName(cls);
-      buffer.write('$holder$_=$_{builtin\$cls:$_"$name"');
-      buffer.write('}$N');
-    }
-
-    // Create representation objects for classes that we do not have a class
-    // definition for (because they are uninstantiated or native).
-    for (ClassElement cls in rti.allArguments) {
-      maybeGenerateHolder(cls);
-    }
-
-    // Add checks to the constructors of instantiated classes or to the created
-    // holder object.
+    // Add checks to the constructors of instantiated classes.
     for (ClassElement cls in typeChecks) {
-      String holder = namer.isolateAccess(cls);
+      String holder = namer.isolateAccess(backend.getImplementationClass(cls));
       for (ClassElement check in typeChecks[cls]) {
         buffer.write('$holder.${namer.operatorIs(check)}$_=${_}true$N');
         String body = rti.getSupertypeSubstitution(cls, check);
         if (body != null) {
           buffer.write('$holder.${namer.substitutionName(check)}$_=${_}$body$N');
         }
       };
     }
   }
 
@@ skipping 154 matching lines @@
     /* Do nothing. */
   }
 
   /// Returns `true` if fields added.
   bool emitClassFields(ClassElement classElement,
                        ClassBuilder builder,
                        String superName,
                        { bool classIsNative: false }) {
     assert(superName != null);
     String separator = '';
-    StringBuffer buffer = new StringBuffer('$superName;');
+    String nativeName = namer.getPrimitiveInterceptorRuntimeName(classElement);
+    StringBuffer buffer = new StringBuffer();
+    if (nativeName != null) {
+      buffer.write('$nativeName/');
+    }
+    buffer.write('$superName;');
     int bufferClassLength = buffer.length;
 
     visitClassFields(classElement, (Element member,
                                     String name,
                                     String accessorName,
                                     bool needsGetter,
                                     bool needsSetter,
                                     bool needsCheckedSetter) {
       // Ignore needsCheckedSetter - that is handled below.
       bool needsAccessor = (needsGetter || needsSetter);
@@ skipping 16 matching lines @@
             buffer.write(':$name');
             // Only the native classes can have renaming accessors.
             assert(classIsNative);
           }
 
           int getterCode = 0;
           if (needsGetter) {
             // 01:  function() { return this.field; }
             // 10:  function(receiver) { return receiver.field; }
             // 11:  function(receiver) { return this.field; }
             getterCode += backend.fieldHasInterceptedGetter(member) ? 2 : 0;

[ahe, 2013/07/19 16:30:25]

Read my comment on line 2602 first.

Consider CssStyleDeclaration.cssText:

CssStyleDeclaration is not instantiated, so we have not recorded that cssText
should be intercepted.

So this is equivalent to:

getterCode += 0;

             getterCode += backend.isInterceptorClass(classElement) ? 0 : 1;

[ahe, 2013/07/19 16:30:25]

For CssStyleDeclaration.cssText, classElement is an interceptor class, so we add
0.

getterCode remains 0.

             // TODO(sra): 'isInterceptorClass' might not be the correct test for
             // methods forced to use the interceptor convention because the
             // method's class was elsewhere mixed-in to an interceptor.
             assert(getterCode != 0);

[ahe, 2013/07/19 16:30:25]

This assertion fails.

           }
           int setterCode = 0;
           if (needsSetter) {
             // 01:  function(value) { this.field = value; }
             // 10:  function(receiver, value) { receiver.field = value; }
             // 11:  function(receiver, value) { this.field = value; }
             setterCode += backend.fieldHasInterceptedSetter(member) ? 2 : 0;
             setterCode += backend.isInterceptorClass(classElement) ? 0 : 1;
             assert(setterCode != 0);
           }
@@ skipping 1097 matching lines @@
   }
 
   /**
    * Compute all the classes that must be emitted.
    */
   void computeNeededClasses() {
     instantiatedClasses =
         compiler.codegenWorld.instantiatedClasses.where(computeClassFilter())
             .toSet();
 
-    // The set of classes that must be emitted are based on instantiated
-    // classes.
+    RuntimeTypes rti = backend.rti;
+
+    // We need to generate classes that are instantiated or used as a type
+    // arguments.
     neededClasses.addAll(instantiatedClasses);
+    rti.allArguments.forEach((ClassElement c) {
+      // Types that we represent with JS native types (like int and String) do
+      // not need a class definition as we use the interceptor classes instead.
+      if (!rti.isJsNative(c)) {
+        neededClasses.add(c);

[ahe, 2013/07/19 16:30:25]

I'm not sure how this is supposed to work?

These classes might have been tree-shaken away and the rest of the compiler has
not analyzed them.  For example,  consider this class:

@DomName('CSSStyleDeclaration')
class CssStyleDeclaration extends Interceptor native
"CSSStyleDeclaration,MSStyleCSSProperties,CSS2Properties" {
  factory CssStyleDeclaration() => new CssStyleDeclaration.css('');

  factory CssStyleDeclaration.css(String css) {
    final style = new Element.tag('div').style;
    style.cssText = css;
    return style;
  }


  @DomName('CSSStyleDeclaration.cssText')
  @DocsEditable()
  String cssText;

...
}

This class is not necessarily instantiated, but instantiated classes might still
use it in a type annotation.

But if it is not instantiated, we have not recorded that the element
corresponding to cssText is intercepted.  However, this is a native class, so
scroll up to line 1475, and see my comments.

+      }
+    });
 
     // Then add all superclasses of these classes.
     for (ClassElement element in neededClasses.toList() /* copy */) {
       for (ClassElement superclass = element.superclass;
           superclass != null;
           superclass = superclass.superclass) {
         if (neededClasses.contains(superclass)) break;
         neededClasses.add(superclass);
       }
     }
@@ skipping 248 matching lines @@
     ..addAll(buildLazyInitializerFunctionIfNecessary())
     ..addAll(buildFinishIsolateConstructor())
     );
     jsAst.FunctionDeclaration decl = new jsAst.FunctionDeclaration(
         new jsAst.VariableDeclaration('init'), fun);
     buffer.write(jsAst.prettyPrint(decl, compiler).getText());
   }
 
   String assembleProgram() {
     measure(() {
-      computeNeededClasses();
-
       // Compute the required type checks to know which classes need a
       // 'is$' method.
       computeRequiredTypeChecks();
 
+      computeNeededClasses();
+
       mainBuffer.add(GENERATED_BY);
       addComment(HOOKS_API_USAGE, mainBuffer);
       mainBuffer.add('function ${namer.isolateName}()$_{}\n');
       mainBuffer.add('init()$N$n');
       // Shorten the code by using [namer.CURRENT_ISOLATE] as temporary.
       isolateProperties = namer.CURRENT_ISOLATE;
       mainBuffer.add(
           'var $isolateProperties$_=$_$isolatePropertiesName$N');
 
       if (!regularClasses.isEmpty ||
@@ skipping 166 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;