Add a method on native classes for is checks. Reduces the code for generating is checks.

frog/leg/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 generate(WorkItem work, HGraph graph) {
     return measure(() {
@@ skipping 1109 matching lines @@
     buffer.add(" || ");
     beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
     checkObject(input, '===');
     buffer.add(" && ");
     checkType(input, element);
     endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
     endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
   }
 
   void checkType(HInstruction input, Element element) {
-    buffer.add('!!');
+    bool requiresNativeIsCheck =
+        compiler.emitter.nativeEmitter.requiresNativeIsCheck(element);
+    if (!requiresNativeIsCheck) buffer.add('!!');
     use(input, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
     buffer.add(compiler.namer.operatorIs(element));
+    if (requiresNativeIsCheck) buffer.add('()');
+  }
+
+  void handleStringSupertypeCheck(HInstruction input, Element element) {
+    assert(element !== compiler.listClass
+           && Elements.isListSupertype(element, compiler));

[floitsch, 2012/03/26 20:32:59]

I don't understand this assert.

[ngeoffray, 2012/03/27 10:48:53]

It's to make sure List and String don't share supertypes, otherwise we would
need to check more. Added a comment.

[floitsch, 2012/03/28 21:19:01]

You also added a "!" ;)

[ngeoffray, 2012/03/29 08:27:16]

Busted :)

+    beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
+    checkString(input, '===');
+    buffer.add(' || ');
+    beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+    checkObject(input, '===');
+    buffer.add(' && ');
+    checkType(input, element);
+    endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+    endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
+  }
+
+  void handleListOrSupertypeCheck(HInstruction input, Element element) {
+    beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+    checkObject(input, '===');
+    buffer.add(' && (');
+    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) {
     Element element = node.typeExpression;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       compiler.unimplemented("visitIs for type variables");
     }
     compiler.registerIsCheck(element);
     LibraryElement coreLibrary = compiler.coreLibrary;
     ClassElement objectClass = coreLibrary.find(const SourceString('Object'));
     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, '===');
     } else if (element == compiler.boolClass) {
       checkBool(input, '===');
     } else if (element == compiler.functionClass) {
       checkFunction(input, element);
     } else if (element == compiler.intClass) {
       beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
       checkNum(input, '===');
       buffer.add(' && ');
       checkInt(input, '===');
       endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
+    } else if (Elements.isStringSupertype(element, compiler)) {
+        handleStringSupertypeCheck(input, element);
+    } else if (element === compiler.listClass
+               || Elements.isListSupertype(element, compiler)) {
+      handleListOrSupertypeCheck(input, element);
     } else {
       beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
-      if (Elements.isStringSupertype(element, compiler)) {
-        checkString(input, '===');
-        buffer.add(' || ');
-      }
       checkObject(input, '===');
       buffer.add(' && ');
-      int precedence = JSPrecedence.PREFIX_PRECEDENCE;
-      bool endParen = false;
-      if (element === compiler.listClass
-          || Elements.isListSupertype(element, compiler)) {
-        buffer.add("(");
-        endParen = true;
-        beginExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
-        checkArray(input, '===');
-        buffer.add(' || ');
-        precedence = JSPrecedence.LOGICAL_OR_PRECEDENCE;
-      } else if (element.isClass() && (element.dynamic.isNative()
-                                       || isSupertypeOfNativeClass(element))) {
-        buffer.add("(");
-        endParen = true;
-      } else {
-        beginExpression(precedence);
-      }
-      checkType(input, node.typeExpression);
-      if (element.isClass() && (element.dynamic.isNative()
-                                || isSupertypeOfNativeClass(element))) {
-        buffer.add(' || ');
-        beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
-        // First check if the object is not a Dart object. If the
-        // object is a Dart object, we know the property check was
-        // sufficient.
-        compiler.registerIsCheck(objectClass);
-        buffer.add('!');
-        use(input, JSPrecedence.MEMBER_PRECEDENCE);
-        buffer.add('.');
-        buffer.add(compiler.namer.operatorIs(objectClass));
-        buffer.add(' && ');
-        buffer.add(compiler.emitter.nativeEmitter.dynamicIsCheckName);
-        buffer.add('(');
-        use(input, JSPrecedence.MEMBER_PRECEDENCE);
-        buffer.add(", '${compiler.namer.operatorIs(node.typeExpression)}')");
-        endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
-      }
-      endExpression(precedence);
-      if (endParen) buffer.add(')');
+      checkType(input, element);
       endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
     }
+
     if (node.nullOk) {
       endExpression(JSPrecedence.LOGICAL_OR_PRECEDENCE);
     }
   }
-
-  bool isSupertypeOfNativeClass(Element element) {
-    if (element.isTypeVariable()) {
-      compiler.cancel("Is check for type variable", element: work.element);
-      return false;
-    }
-    if (element.computeType(compiler) is FunctionType) return false;
-
-    if (!element.isClass()) {
-      compiler.cancel("Is check does not handle element", element: element);
-      return false;
-    }
-
-    List<ClassElement> subtypes =
-        compiler.emitter.nativeEmitter.subtypes[element];
-    if (subtypes === null) return false;
-    return true;
-  }
 }
 
 class SsaOptimizedCodeGenerator extends SsaCodeGenerator {
   final List<HTypeGuard> guards;
   int state = 0;
 
   SsaOptimizedCodeGenerator(compiler, work, parameters, parameterNames)
     : super(compiler, work, parameters, parameterNames),
       guards = <HTypeGuard>[];
 
@@ skipping 334 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endElse(HIf node) {
     if (node.elseBlock.hasBailouts()) {
       endBailoutSwitch();
     }
   }
 }