dart2js-kernel: Handle some more 'is' cases

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
 import '../common/tasks.dart' show CompilerTask;
@@ skipping 367 matching lines @@
         expression, graph.addConstantNull(compiler), null, backend.boolType));
   }
 
   @override
   void defaultExpression(ir.Expression expression) {
     // TODO(het): This is only to get tests working.
     String message = 'Unhandled ir.${expression.runtimeType}  $expression';
     HInstruction nullValue = graph.addConstantNull(compiler);
     HInstruction errorMessage =
         graph.addConstantString(new DartString.literal(message), compiler);
-    HInstruction trap = new HForeignCode(
-        js.js.parseForeignJS("#.#"),
-        backend.dynamicType,
-        <HInstruction>[nullValue, errorMessage]);
-    trap.sideEffects..setAllSideEffects()..setDependsOnSomething();
+    HInstruction trap = new HForeignCode(js.js.parseForeignJS("#.#"),
+        backend.dynamicType, <HInstruction>[nullValue, errorMessage]);
+    trap.sideEffects
+      ..setAllSideEffects()
+      ..setDependsOnSomething();
     push(trap);
   }
 
   /// Returns the current source element.
   ///
   /// The returned element is a declaration element.
   // TODO(efortuna): Update this when we implement inlining.
   @override
   Element get sourceElement => astAdapter.getElement(target);
 
@@ skipping 542 matching lines @@
       // Invoke the getter
       _pushStaticInvocation(staticTarget, const <HInstruction>[],
           astAdapter.returnTypeOf(staticTarget));
     } else if (staticTarget is ir.Field && staticTarget.isConst) {
       assert(staticTarget.initializer != null);
       stack.add(graph.addConstant(
           astAdapter.getConstantFor(staticTarget.initializer), compiler));
     } else {
       if (_isLazyStatic(staticTarget)) {
         push(new HLazyStatic(astAdapter.getField(staticTarget),
-                             astAdapter.inferredTypeOf(staticTarget)));
+            astAdapter.inferredTypeOf(staticTarget)));
       } else {
         push(new HStatic(astAdapter.getMember(staticTarget),
-                         astAdapter.inferredTypeOf(staticTarget)));
+            astAdapter.inferredTypeOf(staticTarget)));
       }
     }
   }
 
   bool _isLazyStatic(ir.Member target) {
     return astAdapter.isLazyStatic(target);
   }
 
   @override
   void visitStaticSet(ir.StaticSet staticSet) {
@@ skipping 665 matching lines @@
     TypeMask typeMask = new TypeMask.nonNullExact(
         astAdapter.getElement(target.enclosingClass), compiler.closedWorld);
     _pushStaticInvocation(target, arguments, typeMask);
   }
 
   @override
   void visitIsExpression(ir.IsExpression isExpression) {
     isExpression.operand.accept(this);
     HInstruction expression = pop();
 
+    // TODO(sra): Convert the type testing logic here to use ir.DartType.
     DartType type = astAdapter.getDartType(isExpression.type);
 
+    type = localsHandler.substInContext(type).unaliased;
+
+    if (type is MethodTypeVariableType) {
+      push(graph.addConstantBool(true, compiler));
+      return;
+    }
+
+    if (type is MalformedType) {
+      ErroneousElement element = type.element;
+      generateTypeError(isExpression, element.message);
+      push(new HIs.compound(type, expression, pop(), backend.boolType));
+      return;
+    }
+
+    if (type.isFunctionType) {
+      List arguments = <HInstruction>[buildFunctionType(type), expression];
+      _pushDynamicInvocation(isExpression, backend.boolType, arguments,
+          selector: new Selector.call(
+              new PrivateName('_isTest', astAdapter.jsHelperLibrary),
+              CallStructure.ONE_ARG));
+      push(new HIs.compound(type, expression, pop(), backend.boolType));
+      return;
+    }
+
+    if (type.isTypeVariable) {
+      HInstruction runtimeType =
+          typeBuilder.addTypeVariableReference(type, sourceElement);
+      _pushStaticInvocation(astAdapter.checkSubtypeOfRuntimeType,
+          <HInstruction>[expression, runtimeType], backend.boolType);
+      push(new HIs.variable(type, expression, pop(), backend.boolType));
+      return;
+    }
+
+    // TODO(sra): Type with type parameters.
+
     if (backend.hasDirectCheckFor(type)) {
       push(new HIs.direct(type, expression, backend.boolType));
       return;
     }
 
     // The interceptor is not always needed.  It is removed by optimization
     // when the receiver type or tested type permit.
     HInterceptor interceptor = _interceptorFor(expression);
     push(new HIs.raw(type, expression, interceptor, backend.boolType));
   }
@@ skipping 19 matching lines @@
     push(new HNot(popBoolified(), backend.boolType));
   }
 
   @override
   void visitStringConcatenation(ir.StringConcatenation stringConcat) {
     KernelStringBuilder stringBuilder = new KernelStringBuilder(this);
     stringConcat.accept(stringBuilder);
     stack.add(stringBuilder.result);
   }
 }