Reapply "Add TypeVariable object on runtime to support reflection on type variables." and …

sdk/lib/_internal/compiler/implementation/js_backend/backend.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;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked;
 
   JavaScriptItemCompilationContext()
@@ skipping 182 matching lines @@
   Element jsArrayRemoveLast;
   Element jsArrayAdd;
   Element jsStringSplit;
   Element jsStringToString;
   Element jsStringOperatorAdd;
   Element objectEquals;
 
   ClassElement typeLiteralClass;
   ClassElement mapLiteralClass;
   ClassElement constMapLiteralClass;
+  ClassElement typeVariableClass;
 
   Element getInterceptorMethod;
   Element interceptedNames;
 
   /**
    * This element is a top-level variable (in generated output) that the
    * compiler initializes to a datastructure used to map from a Type to the
    * interceptor.  See declaration of `mapTypeToInterceptor` in
    * `interceptors.dart`.
    */
@@ skipping 186 matching lines @@
           const SourceString('propertyTypeCast')),
       const PropertyCheckedModeHelper(
           const SourceString('propertyTypeCheck')) ];
 
   // Checked mode helpers indexed by name.
   Map<String, CheckedModeHelper> checkedModeHelperByName =
       new Map<String, CheckedModeHelper>.fromIterable(
           checkedModeHelpers,
           key: (helper) => helper.name.slowToString());
 
+  TypeVariableHandler typeVariableHandler;
+
   /// Number of methods compiled before considering reflection.
   int preMirrorsMethodCount = 0;
 
   /// Resolution and codegen support for generating table of interceptors and
   /// constructors for custom elements.
   CustomElementsAnalysis customElementsAnalysis;
 
   JavaScriptBackend(Compiler compiler, bool generateSourceMap)
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<String, Selector>(),
         interceptedElements = new Map<SourceString, Set<Element>>(),
         rti = new RuntimeTypes(compiler),
         specializedGetInterceptors = new Map<String, Set<ClassElement>>(),
         super(compiler, JAVA_SCRIPT_CONSTANT_SYSTEM) {
     emitter = new CodeEmitterTask(compiler, namer, generateSourceMap);
     builder = new SsaBuilderTask(this);
     optimizer = new SsaOptimizerTask(this);
     generator = new SsaCodeGeneratorTask(this);
+    typeVariableHandler = new TypeVariableHandler(this);
     customElementsAnalysis = new CustomElementsAnalysis(this);
   }
 
   static Namer determineNamer(Compiler compiler) {
     return compiler.enableMinification ?
         new MinifyNamer(compiler) :
         new Namer(compiler);
   }
 
   bool usedByBackend(Element element) {
@@ skipping 226 matching lines @@
     indexablePrimitiveType = new HBoundedType(
         new TypeMask.nonNullSubtype(jsIndexableClass));
     readableArrayType = new HBoundedType(
         new TypeMask.nonNullSubclass(jsArrayClass));
     mutableArrayType = new HBoundedType(
         new TypeMask.nonNullSubclass(jsMutableArrayClass));
     fixedArrayType = new HBoundedType(
         new TypeMask.nonNullExact(jsFixedArrayClass));
     extendableArrayType = new HBoundedType(
         new TypeMask.nonNullExact(jsExtendableArrayClass));
+
+    typeVariableClass =
+        compiler.findHelper(const SourceString('TypeVariable'));
   }
 
   void validateInterceptorImplementsAllObjectMethods(
       ClassElement interceptorClass) {
     if (interceptorClass == null) return;
     interceptorClass.ensureResolved(compiler);
     compiler.objectClass.forEachMember((_, Element member) {
       if (member.isGenerativeConstructor()) return;
       Element interceptorMember = interceptorClass.lookupMember(member.name);
       // Interceptors must override all Object methods due to calling convention
@@ skipping 107 matching lines @@
     if (mustRetainMetadata) {
       registerCompileTimeConstant(constant, elements);
     } else {
       metadataConstants.add(new Dependency(constant, elements));
     }
   }
 
   void registerInstantiatedClass(ClassElement cls,
                                  Enqueuer enqueuer,
                                  TreeElements elements) {
+    if (!cls.typeVariables.isEmpty) {
+      typeVariableHandler.registerClassWithTypeVariables(cls);
+    }
+
     if (!seenAnyClass) {
       seenAnyClass = true;
       if (enqueuer.isResolutionQueue) {
         // TODO(9577): Make it so that these are not needed when there are no
         // native classes.
         enqueue(enqueuer, getNativeInterceptorMethod, elements);
         enqueue(enqueuer, defineNativeMethodsFinishMethod, elements);
         enqueueClass(enqueuer, jsInterceptorClass, compiler.globalDependencies);
       }
     }
@@ skipping 1029 matching lines @@
       compiler.log('Retaining metadata.');
 
       compiler.libraries.values.forEach(retainMetadataOf);
       for (Dependency dependency in metadataConstants) {
         registerCompileTimeConstant(
             dependency.constant, dependency.user);
       }
       metadataConstants.clear();
     }
 
+    if (isTreeShakingDisabled) {
+      if (enqueuer.isResolutionQueue) {
+        typeVariableHandler.onResolutionQueueEmpty(enqueuer);
+      } else {
+        typeVariableHandler.onCodegenQueueEmpty();
+      }
+    }
     customElementsAnalysis.onQueueEmpty(enqueuer);
   }
 }
 
 /// Records that [constant] is used by [user.element].
 class Dependency {
   final Constant constant;
   final TreeElements user;
 
   const Dependency(this.constant, this.user);
@@ skipping 40 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }