Kernel-ify buildIsNode logic and add generics type variable checking in buildIsNode.

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 '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 205 matching lines @@
     if (typeBuilder.checkOrTrustTypes) {
       return typeBuilder.potentiallyCheckOrTrustType(
           value, compiler.coreTypes.boolType,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value, commonMasks.boolType);
     add(result);
     return result;
   }
 
+  void _addClassTypeVariablesIfNeeded(ir.Member constructor) {
+    var enclosing = astAdapter.getElement(constructor).enclosingElement;
+    if (backend.classNeedsRti(enclosing)) {
+      enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
+        HParameterValue param =
+            addParameter(typeVariable.element, commonMasks.nonNullType);
+        localsHandler.directLocals[
+            localsHandler.getTypeVariableAsLocal(typeVariable)] = param;
+      });
+    }
+  }
+
   /// Builds generative constructors.
   ///
   /// Generative constructors are built in two stages.
   ///
   /// First, the field values for every instance field for every class in the
   /// class hierarchy are collected. Then, create a function body that sets
   /// all of the instance fields to the collected values and call the
   /// constructor bodies for all constructors in the hierarchy.
   void buildConstructor(ir.Constructor constructor) {
     openFunction();
+    _addClassTypeVariablesIfNeeded(constructor);
 
     // Collect field values for the current class.
     // TODO(het): Does kernel always put field initializers in the constructor
     //            initializer list? If so then this is unnecessary...
     Map<ir.Field, HInstruction> fieldValues =
         _collectFieldValues(constructor.enclosingClass);
 
     _buildInitializers(constructor, fieldValues);
 
     final constructorArguments = <HInstruction>[];
@@ skipping 146 matching lines @@
       HInstruction original, DartType type, int kind) {
     HInstruction reifiedType = buildFunctionType(type);
     return new HTypeConversion.viaMethodOnType(
         type, kind, original.instructionType, reifiedType, original);
   }
 
   /// Builds a SSA graph for FunctionNodes, found in FunctionExpressions and
   /// Procedures.
   void buildFunctionNode(ir.FunctionNode functionNode) {
     openFunction();
+    if (functionNode.parent is ir.Procedure &&
+        (functionNode.parent as ir.Procedure).kind ==
+            ir.ProcedureKind.Factory) {
+      _addClassTypeVariablesIfNeeded(functionNode.parent);
+    }
     functionNode.body.accept(this);
     closeFunction();
   }
 
   void addImplicitInstantiation(DartType type) {
     if (type != null) {
       currentImplicitInstantiations.add(type);
     }
   }
 
@@ skipping 1523 matching lines @@
   }
 
   @override
   void visitIsExpression(ir.IsExpression isExpression) {
     isExpression.operand.accept(this);
     HInstruction expression = pop();
     push(buildIsNode(isExpression, isExpression.type, expression));
   }
 
   HInstruction buildIsNode(
-      ir.Node node, ir.DartType dart_type, HInstruction expression) {
-    // TODO(sra): Convert the type testing logic here to use ir.DartType.
-    DartType type = astAdapter.getDartType(dart_type);
-
-    type = localsHandler.substInContext(type).unaliased;
-
-    if (type is MethodTypeVariableType) {
-      return graph.addConstantBool(true, closedWorld);
+      ir.Node node, ir.DartType type, HInstruction expression) {
+    // Note: The call to "unalias" this type like in the original SSA builder is
+    // unnecessary in kernel because Kernel has no notion of typedef.
+    // TODO(efortuna): Add test for this.
+    DartType typeValue = localsHandler.substInContext(
+        astAdapter.getDartType(type));
+    if (type is ir.InvalidType) {
+      generateTypeError(node, (typeValue.element as ErroneousElement).message);
+      return new HIs.compound(
+          typeValue, expression, pop(), commonMasks.boolType);
     }
 
-    if (type is MalformedType) {
-      ErroneousElement element = type.element;
-      generateTypeError(node, element.message);
-      return new HIs.compound(type, expression, pop(), commonMasks.boolType);
+    if (type is ir.FunctionType) {
+      List arguments = [buildFunctionType(typeValue), expression];
+      _pushDynamicInvocation(node, null, arguments,
+          selector: new Selector.call(
+              new PrivateName('_isTest', backend.helpers.jsHelperLibrary),
+              CallStructure.ONE_ARG));
+      return new HIs.compound(
+          typeValue, expression, pop(), commonMasks.boolType);
     }
 
-    if (type.isFunctionType) {
-      List arguments = <HInstruction>[buildFunctionType(type), expression];
-      _pushDynamicInvocation(node, commonMasks.boolType, arguments,
-          selector: new Selector.call(
-              new PrivateName('_isTest', astAdapter.jsHelperLibrary),
-              CallStructure.ONE_ARG));
-      return new HIs.compound(type, expression, pop(), commonMasks.boolType);
+    if (type is ir.TypeParameterType) {
+      HInstruction runtimeType =
+          typeBuilder.addTypeVariableReference(typeValue, sourceElement);
+      _pushStaticInvocation(astAdapter.checkSubtypeOfRuntimeType,
+          <HInstruction>[expression, runtimeType], commonMasks.boolType);
+      return new HIs.variable(
+          typeValue, expression, pop(), commonMasks.boolType);
     }
 
-    if (type.isTypeVariable) {
-      HInstruction runtimeType =
-          typeBuilder.addTypeVariableReference(type, sourceElement);
-      _pushStaticInvocation(astAdapter.checkSubtypeOfRuntimeType,
-          <HInstruction>[expression, runtimeType], commonMasks.boolType);
-      return new HIs.variable(type, expression, pop(), commonMasks.boolType);
+    if (_isInterfaceWithNoDynamicTypes(type)) {
+      HInstruction representations = typeBuilder
+          .buildTypeArgumentRepresentations(typeValue, sourceElement);
+      add(representations);
+      ClassElement element = typeValue.element;
+      js.Name operator = backend.namer.operatorIs(element);
+      HInstruction isFieldName =
+          graph.addConstantStringFromName(operator, closedWorld);
+      HInstruction asFieldName = closedWorld.hasAnyStrictSubtype(element)
+          ? graph.addConstantStringFromName(
+              backend.namer.substitutionName(element), closedWorld)
+          : graph.addConstantNull(closedWorld);
+      List<HInstruction> inputs = <HInstruction>[
+        expression,
+        isFieldName,
+        representations,
+        asFieldName
+      ];
+      _pushStaticInvocation(
+          astAdapter.checkSubtype, inputs, commonMasks.boolType);
+      return new HIs.compound(
+          typeValue, expression, pop(), commonMasks.boolType);
     }
 
-    // TODO(sra): Type with type parameters.
+    if (backend.hasDirectCheckFor(typeValue)) {
+      return new HIs.direct(typeValue, expression, commonMasks.boolType);
+    }
+    // The interceptor is not always needed.  It is removed by optimization
+    // when the receiver type or tested type permit.
+    return new HIs.raw(typeValue, expression, _interceptorFor(expression),
+        commonMasks.boolType);
+  }
 
-    if (backend.hasDirectCheckFor(type)) {
-      return new HIs.direct(type, expression, commonMasks.boolType);
+  bool _isInterfaceWithNoDynamicTypes(ir.DartType type) {
+    bool isMethodTypeVariableType(ir.DartType typeArgType) {
+      return (typeArgType is ir.TypeParameterType &&
+          typeArgType.parameter.parent is ir.FunctionNode);
     }
 
-    // The interceptor is not always needed.  It is removed by optimization
-    // when the receiver type or tested type permit.
-    HInterceptor interceptor = _interceptorFor(expression);
-    return new HIs.raw(type, expression, interceptor, commonMasks.boolType);
+    return type is ir.InterfaceType &&
+        (type as ir.InterfaceType).typeArguments.any(
+            (ir.DartType typeArgType) =>
+                typeArgType is! ir.DynamicType &&
+                typeArgType is! ir.InvalidType &&
+                !isMethodTypeVariableType(type));
   }
 
   @override
   void visitThrow(ir.Throw throwNode) {
     _visitThrowExpression(throwNode.expression);
     if (isReachable) {
       push(new HThrowExpression(pop(), null));
       isReachable = false;
     }
   }
@@ skipping 281 matching lines @@
     kernelBuilder.open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
   }
 }