Implement simple dynamic type check.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   SsaCodeGeneratorTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA code generator';
 
 
   String generateMethod(WorkItem work, HGraph graph) {
@@ skipping 1709 matching lines @@
     beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
     checkArray(input, '===');
     buffer.add(' || ');
     checkType(input, element);
     buffer.add(')');
     endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
     endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
   }
 
   void visitIs(HIs node) {
-    Type type = node.typeName;
+    Type type = node.typeExpression;
     Element element = type.element;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       compiler.unimplemented("visitIs for type variables");
     } else if (element.kind === ElementKind.TYPEDEF) {
       compiler.unimplemented("visitIs for typedefs");
     }
-    compiler.registerIsCheck(element);
+    compiler.registerIsCheck(type.element);
     LibraryElement coreLibrary = compiler.coreLibrary;
     ClassElement objectClass = compiler.objectClass;
     HInstruction input = node.expression;
+
     if (node.nullOk) {
       beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
       checkNull(input);
       buffer.add(' || ');
     }
-
     if (element === objectClass || element === compiler.dynamicClass) {
       // The constant folder also does this optimization, but we make
       // it safe by assuming it may have not run.
       buffer.add('true');
     } else if (element == compiler.stringClass) {
       checkString(input, '===');
     } else if (element == compiler.doubleClass) {
       checkDouble(input, '===');
     } else if (element == compiler.numClass) {
       checkNum(input, '===');
@@ skipping 12 matching lines @@
     } else if (element === compiler.listClass
                || Elements.isListSupertype(element, compiler)) {
       handleListOrSupertypeCheck(input, element);
     } else {
       beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
       checkObject(input, '===');
       buffer.add(' && ');
       checkType(input, element);
       endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
     }
-
+    if (compiler.universe.rti.hasTypeArguments(type)) {
+      InterfaceType interfaceType = type;
+      ClassElement cls = type.element;
+      Link<Type> arguments = interfaceType.arguments;
+      buffer.add(' && ');
+      checkObject(node.typeInfo, '===');
+      cls.typeParameters.forEach((name, _) {

[ngeoffray, 2012/04/30 08:51:12]

name -> Element typeParameter ?

[karlklose, 2012/05/01 11:20:55]

typeParameters is a Map<SourceString, TypeVariableElement>, so the first
argument to the closure is actually a SourceString.

+        buffer.add(' && ');
+        beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+        use(node.typeInfo, JSPrecedence.EQUALITY_PRECEDENCE);
+        buffer.add(".${name.slowToString()} === '${arguments.head}'");
+        endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+      });
+    }
     if (node.nullOk) {
       endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
     }
   }
 }
 
 class SsaOptimizedCodeGenerator extends SsaCodeGenerator {
   SsaOptimizedCodeGenerator(compiler, work, parameters, parameterNames)
     : super(compiler, work, parameters, parameterNames);
 
@@ skipping 404 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }