Handle deferred access of unserialized code.

pkg/compiler/lib/src/js_backend/type_variable_handler.dart

 // Copyright (c) 2013, 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;
 
 /**
  * Handles construction of TypeVariable constants needed at runtime.
  */
 class TypeVariableHandler {
   final Compiler _compiler;
-  FunctionElement _typeVariableConstructor;
+  ConstructorElement _typeVariableConstructor;
 
   /**
    * Set to 'true' on first encounter of a class with type variables.
    */
   bool _seenClassesWithTypeVariables = false;
 
   /**
    *  Maps a class element to a list with indices that point to type variables
    *  constants for each of the class' type variables.
    */
@@ skipping 47 matching lines @@
   void processTypeVariablesOf(ClassElement cls) {
     // Do not process classes twice.
     if (_typeVariables.containsKey(cls)) return;
 
     InterfaceType typeVariableType = _typeVariableClass.thisType;
     List<jsAst.Expression> constants = <jsAst.Expression>[];
 
     for (TypeVariableType currentTypeVariable in cls.typeVariables) {
       TypeVariableElement typeVariableElement = currentTypeVariable.element;
 
-      AstConstant name = new AstConstant(
-          typeVariableElement,
-          typeVariableElement.node,
-          new StringConstantExpression(currentTypeVariable.name),
-          _backend.constantSystem
-              .createString(new DartString.literal(currentTypeVariable.name)));
       jsAst.Expression boundIndex =
           _metadataCollector.reifyType(typeVariableElement.bound);
       ConstantValue boundValue = new SyntheticConstantValue(
           SyntheticConstantKind.TYPEVARIABLE_REFERENCE, boundIndex);
       ConstantExpression boundExpression =
           new SyntheticConstantExpression(boundValue);
-      AstConstant bound = new AstConstant(typeVariableElement,
-          typeVariableElement.node, boundExpression, boundValue);
-      AstConstant type = new AstConstant(
-          typeVariableElement,
-          typeVariableElement.node,
-          new TypeConstantExpression(cls.rawType),
-          _backend.constantSystem.createType(_backend.compiler, cls.rawType));
-      List<AstConstant> arguments = [type, name, bound];
+      ConstantExpression constant = new ConstructedConstantExpression(
+          _typeVariableConstructor.enclosingClass.thisType,
+          _typeVariableConstructor,
+          const CallStructure.unnamed(3), [
+        new TypeConstantExpression(cls.rawType),
+        new StringConstantExpression(currentTypeVariable.name),
+        new SyntheticConstantExpression(boundValue)
+      ]);
 
-      // TODO(johnniwinther): Support a less front-end specific creation of
-      // constructed constants.
-      AstConstant constant =
-          CompileTimeConstantEvaluator.makeConstructedConstant(
-              _compiler,
-              _backend.constants,
-              typeVariableElement,
-              typeVariableElement.node,
-              typeVariableType,
-              _typeVariableConstructor,
-              typeVariableType,
-              _typeVariableConstructor,
-              const CallStructure.unnamed(3),
-              arguments,
-              arguments);
-      ConstantValue value = constant.value;
+      _backend.constants.evaluate(constant);
+      ConstantValue value = _backend.constants.getConstantValue(constant);
       _backend.registerCompileTimeConstant(value, _compiler.globalDependencies);
       _backend.addCompileTimeConstantForEmission(value);
       _backend.constants.addCompileTimeConstantForEmission(value);
       constants
           .add(_reifyTypeVariableConstant(value, currentTypeVariable.element));
     }
     _typeVariables[cls] = constants;
   }
 
   /**
@@ skipping 37 matching lines @@
   }
 
   List<jsAst.Expression> typeVariablesOf(ClassElement classElement) {
     List<jsAst.Expression> result = _typeVariables[classElement];
     if (result == null) {
       result = const <jsAst.Expression>[];
     }
     return result;
   }
 }