dart2js: store typeVariableReader stubs in the model.

pkg/compiler/lib/src/js_emitter/class_stub_generator.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.
 
 part of dart2js.js_emitter;
 
 class ClassStubGenerator {
   final Namer namer;
   final Compiler compiler;
   final JavaScriptBackend backend;
@@ skipping 168 matching lines @@
 
     jsAst.Expression function;
     if (backend.isInterceptedName(selector.name)) {
       function = js(r'function($receiver, #) { return # }',
                               [parameterNames, expression]);
     } else {
       function = js(r'function(#) { return # }', [parameterNames, expression]);
     }
     return new StubMethod(name, function);
   }
+
+  List<StubMethod> generateTypeVariableReaderStubs(ClassElement classElement) {

[floitsch, 2015/02/10 13:19:36]

An alternative location would be in the type_test_generator.

We could rename it to runtime_type_generator.dart.

[zarah, 2015/02/10 13:34:39]

Done.

+    List<StubMethod> stubs = <StubMethod>[];
+    List typeVariables = [];
+    ClassElement superclass = classElement;
+    while (superclass != null) {
+        for (TypeVariableType parameter in superclass.typeVariables) {
+          if (backend.emitter.readTypeVariables.contains(parameter.element)) {
+            stubs.add(

[zarah, 2015/02/10 12:50:30]

This method is copied from class_emitter. This line is different as well as the
return at the end of the method.

+                _generateTypeVariableReader(classElement, parameter.element));
+          }
+        }
+        superclass = superclass.superclass;
+      }
+
+    return stubs;
+  }
+
+  StubMethod _generateTypeVariableReader(ClassElement cls,
+                                         TypeVariableElement element) {
+    String name = namer.readTypeVariableName(element);
+    int index = RuntimeTypes.getTypeVariableIndex(element);
+    jsAst.Expression computeTypeVariable;
+
+    Substitution substitution =
+        backend.rti.computeSubstitution(
+            cls, element.typeDeclaration, alwaysGenerateFunction: true);
+    if (substitution != null) {
+      computeTypeVariable =
+          js(r'#.apply(null, this.$builtinTypeInfo)',
+             substitution.getCodeForVariable(index, backend.rti));
+    } else {
+      // TODO(ahe): These can be generated dynamically.
+      computeTypeVariable =
+          js(r'this.$builtinTypeInfo && this.$builtinTypeInfo[#]',
+              js.number(index));
+    }
+    jsAst.Expression convertRtiToRuntimeType = backend.emitter
+         .staticFunctionAccess(backend.findHelper('convertRtiToRuntimeType'));
+
+    return new StubMethod(name,

[zarah, 2015/02/10 12:50:30]

This method is copied from class_emitter. It differs from this line and below.

+                          js('function () { return #(#) }',
+                             [convertRtiToRuntimeType, computeTypeVariable]));
+  }
+
 }
 
 /// Creates two JavaScript functions: `tearOffGetter` and `tearOff`.
 ///
 /// `tearOffGetter` is internal and only used by `tearOff`.
 ///
 /// `tearOff` takes the following arguments:
 ///   * `funcs`: a list of functions. These are the functions representing the
 ///    member that is torn off. There can be more than one, since a member
 ///    can have several stubs.
@@ skipping 79 matching lines @@
           ? function() {
               if (cache === void 0) cache = #tearOff(
                   this, funcs, reflectionInfo, true, [], name).prototype;
               return cache;
             }
           : tearOffGetter(funcs, reflectionInfo, name, isIntercepted);
     }''',  {'tearOff': tearOffAccessExpression});
 
   return <jsAst.Statement>[tearOffGetter, tearOff];
 }