Implement is-checks against type variables.

sdk/lib/_internal/compiler/implementation/ssa/builder.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 ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 2565 matching lines @@
 
   HInstruction getRuntimeTypeInfo(HInstruction target) {
     pushInvokeHelper1(backend.getGetRuntimeTypeInfo(), target, HType.UNKNOWN);
     return pop();
   }
 
   // TODO(karlklose): change construction of the representations to be GVN'able
   // (dartbug.com/7182).
   List<HInstruction> buildTypeArgumentRepresentations(DartType type) {
     HInstruction createForeignArray(String code, inputs) {
       return createForeign(code, HType.READABLE_ARRAY, inputs);

[ngeoffray, 2013/02/18 09:27:58]

I'd remove this helper, it's only called once.

[karlklose, 2013/02/18 16:02:01]

Done.

     }
 
     // Compute the representation of the type arguments, including access
     // to the runtime type information for type variables as instructions.
     HInstruction representations;
     if (type.element.isTypeVariable()) {
       return <HInstruction>[addTypeVariableReference(type)];
     } else {
       assert(type.element.isClass());
       List<HInstruction> arguments = <HInstruction>[];
@@ skipping 38 matching lines @@
       DartType type = elements.getType(typeAnnotation);
       if (type.isMalformed) {
         String reasons = Types.fetchReasonsFromMalformedType(type);
         if (compiler.enableTypeAssertions) {
           generateMalformedSubtypeError(node, expression, type, reasons);
         } else {
           generateRuntimeError(node, '$type is malformed: $reasons');
         }
         return;
       }
-      if (type.element.isTypeVariable()) {
-        // TODO(karlklose): remove this check when the backend can deal with
-        // checks of the form [:o is T:] where [:T:] is a type variable.
-        stack.add(graph.addConstantBool(true, constantSystem));
-        return;
-      }
 
       HInstruction instruction;
-      if (type.element.isTypeVariable() ||
-          RuntimeTypeInformation.hasTypeArguments(type)) {
+      if (type.element.isTypeVariable()) {

[ngeoffray, 2013/02/18 09:27:58]

Don't we have a check on the type to know if it's a type variable?

[karlklose, 2013/02/18 16:02:01]

No, we only have these helpers on elements. Replaced it with a test of the
TypeKind.

+        List<HInstruction> representations =
+            buildTypeArgumentRepresentations(type);
+        assert(representations.length == 1);
+        HInstruction runtimeType = representations[0];

[ngeoffray, 2013/02/18 09:27:58]

Instead of asserting it's 1 and fetching the first element, have to methods for
buildTypeArgumentRepresentations: one for type variable, and one for the other
cases?

[karlklose, 2013/02/18 16:02:01]

Done.

+        Element helper =
+            compiler.findHelper(const SourceString('objectIsSubtype'));
+        HInstruction helperCall = new HStatic(helper);
+        add(helperCall);
+        List<HInstruction> inputs = <HInstruction>[helperCall, expression,
+                                                   runtimeType];
+        instruction = new HInvokeStatic(inputs, HType.UNKNOWN);

[ngeoffray, 2013/02/18 09:27:58]

HType.BOOLEAN?

[karlklose, 2013/02/18 16:02:01]

Done.

+        add(instruction);

[ngeoffray, 2013/02/18 09:27:58]

Register in codegen world?

[karlklose, 2013/02/18 16:02:01]

Done.

+
+      } else if (RuntimeTypeInformation.hasTypeArguments(type)) {
 
         void argumentsCheck() {
           HInstruction typeInfo = getRuntimeTypeInfo(expression);
           Element helper =
               compiler.findHelper(const SourceString('checkArguments'));
           HInstruction helperCall = new HStatic(helper);
           add(helperCall);
           List<HInstruction> representations =
               buildTypeArgumentRepresentations(type);
           Element element = type.element;
           String substitution = backend.namer.substitutionName(element);
           if (backend.emitter.nativeEmitter.requiresNativeIsCheck(element)) {
             substitution = '$substitution()';
           }
           HInstruction fieldGet =
               createForeign('#.$substitution', HType.UNKNOWN, [expression]);
           HInstruction representationList = new HLiteralList(representations);
           add(fieldGet);
           add(representationList);
           List<HInstruction> inputs = <HInstruction>[helperCall,
                                                      fieldGet,
                                                      typeInfo,
                                                      representationList];
           push(new HInvokeStatic(inputs, HType.UNKNOWN));
         }
 
         void classCheck() { push(new HIs(type, <HInstruction>[expression])); }
 
         SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
-        branchBuilder.handleLogicalAndOr(classCheck, argumentsCheck, isAnd: true);
+        branchBuilder.handleLogicalAndOr(classCheck, argumentsCheck,
+                                         isAnd: true);
         instruction = pop();
       } else {
         instruction = new HIs(type, <HInstruction>[expression]);
         add(instruction);
       }
       if (isNot) {
         instruction = new HNot(instruction);
         add(instruction);
       }
       stack.add(instruction);
@@ skipping 2369 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }