dart2js cps: 'is' checks on types with type arguments.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.dart

 // Copyright (c) 2013, 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.
 
 library dart2js.ir_builder;
 
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
@@ skipping 448 matching lines @@
 
   /// Reifies the value of [variable] on the current receiver object.
   ir.Primitive buildReifyTypeVariable(TypeVariableType variable);
 
   /// Creates an access to the receiver from the current (or enclosing) method.
   ///
   /// If inside a closure class, [buildThis] will redirect access through
   /// closure fields in order to access the receiver from the enclosing method.
   ir.Primitive buildThis();
 
-  /// In JS-mode, gets an interceptor for [value].
-  /// In Dart-mode, simply returns [value].
-  ir.Primitive buildGetInterceptor(ir.Primitive value);
+  /// Creates a type test or type cast of [value] against [type].
+  ir.Primitive buildTypeOperator(ir.Primitive value,
+                                 DartType type,
+                                 {bool isTypeTest});
 
   // TODO(johnniwinther): Make these field final and remove the default values
   // when [IrBuilder] is a property of [IrBuilderVisitor] instead of a mixin.
 
   final List<ir.Parameter> _parameters = <ir.Parameter>[];
 
   IrBuilderSharedState state;
 
   /// A map from variable indexes to their values.
   ///
@@ skipping 1312 matching lines @@
       catchBuilder.removeMutableVariable(variable);
       catchBuilder.environment.update(variable, value);
     }
 
     // Handlers are always translated as having both exception and stack trace
     // parameters.  Multiple clauses do not have to use the same names for
     // them.  Choose the first of each as the name hint for the respective
     // handler parameter.
     ir.Parameter exceptionParameter =
         new ir.Parameter(catchClauseInfos.first.exceptionVariable);
-    ir.Primitive exceptionInterceptor = new ir.Parameter(null);
     LocalVariableElement traceVariable;
     CatchClauseInfo catchAll;
     for (int i = 0; i < catchClauseInfos.length; ++i) {
       CatchClauseInfo info = catchClauseInfos[i];
       if (info.type == null) {
         catchAll = info;
         catchClauseInfos.length = i;
         break;
       }
       if (traceVariable == null) {
@@ skipping 26 matching lines @@
         clauseBuilder.declareLocalVariable(clause.stackTraceVariable,
                                            initialValue: traceParameter);
       }
       clause.buildCatchBlock(clauseBuilder);
       if (clauseBuilder.isOpen) clauseBuilder.jumpTo(join);
       ir.Continuation thenContinuation = new ir.Continuation([]);
       thenContinuation.body = clauseBuilder._root;
       ir.Continuation elseContinuation = new ir.Continuation([]);
       elseContinuation.body = catchBody;
 
-      ir.Parameter typeMatches = new ir.Parameter(null);
-      ir.Continuation checkType = new ir.Continuation([typeMatches]);
-      checkType.body =
-          new ir.LetCont.many([thenContinuation, elseContinuation],
-              new ir.Branch(new ir.IsTrue(typeMatches),
-                            thenContinuation,
-                            elseContinuation));
-      catchBody =
-          new ir.LetCont(checkType,
-              new ir.TypeOperator(exceptionInterceptor, clause.type, checkType,
-                                  isTypeTest: true));
+      // Build the type test guarding this clause. We can share the environment
+      // with the nested builder because this part cannot mutate it.
+      IrBuilder checkBuilder = catchBuilder.makeDelimitedBuilder(environment);
+      ir.Primitive typeMatches =
+          checkBuilder.buildTypeOperator(exceptionParameter,
+                                         clause.type,
+                                         isTypeTest: true);
+      checkBuilder.add(new ir.LetCont.many([thenContinuation, elseContinuation],
+                           new ir.Branch(new ir.IsTrue(typeMatches),
+                                         thenContinuation,
+                                         elseContinuation)));
+      catchBody = checkBuilder._root;
     }
 
     List<ir.Parameter> catchParameters =
         <ir.Parameter>[exceptionParameter, traceParameter];
     ir.Continuation catchContinuation = new ir.Continuation(catchParameters);
-    catchBuilder.buildGetInterceptor(exceptionParameter)
-                .substituteFor(exceptionInterceptor);
     catchBuilder.add(catchBody);
     catchContinuation.body = catchBuilder._root;
 
     tryCatchBuilder.add(
         new ir.LetHandler(catchContinuation, tryBuilder._root));
     add(new ir.LetCont(join.continuation, tryCatchBuilder._root));
     environment = join.environment;
   }
 
   /// Create a return statement `return value;` or `return;` if [value] is
@@ skipping 128 matching lines @@
 
     add(new ir.LetCont(joinContinuation,
           new ir.LetCont.many(<ir.Continuation>[thenContinuation,
                                                 elseContinuation],
               new ir.Branch(new ir.IsTrue(condition),
                             thenContinuation,
                             elseContinuation))));
     return resultParameter;
   }
 
-  /// Creates a type test or type cast of [receiver] against [type].
-  ///
-  /// Set [isTypeTest] to `true` to create a type test and furthermore set
-  /// [isNotCheck] to `true` to create a negated type test.
-  ir.Primitive buildTypeOperator(ir.Primitive receiver,
-                                 DartType type,
-                                 {bool isTypeTest: false,
-                                  bool isNotCheck: false});
-
   /// Create a lazy and/or expression. [leftValue] is the value of the left
   /// operand and [buildRightValue] is called to process the value of the right
   /// operand in the context of its own [IrBuilder].
   ir.Primitive buildLogicalOperator(
       ir.Primitive leftValue,
       ir.Primitive buildRightValue(IrBuilder builder),
       {bool isLazyOr: false}) {
     // e0 && e1 is translated as if e0 ? (e1 == true) : false.
     // e0 || e1 is translated as if e0 ? true : (e1 == true).
     // The translation must convert both e0 and e1 to booleans and handle
@@ skipping 248 matching lines @@
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
   ir.Primitive buildThis() {
     return state.enclosingMethodThisParameter;
   }
 
-  ir.Primitive buildGetInterceptor(ir.Primitive value) => value;
-
   @override
   ir.Primitive buildConstructorInvocation(ConstructorElement element,
                                           CallStructure callStructure,
                                           DartType type,
                                           List<ir.Primitive> arguments) {
     assert(isOpen);
     Selector selector =
         new Selector(SelectorKind.CALL, element.memberName, callStructure);
     return _continueWithExpression(
         (k) => new ir.InvokeConstructor(type, element, selector,
             arguments, k));
   }
 
   @override
   ir.Primitive buildReifyTypeVariable(TypeVariableType variable) {
     return addPrimitive(new ir.ReifyTypeVar(variable.element));
   }
 
   @override
-  ir.Primitive buildTypeOperator(ir.Primitive receiver,
+  ir.Primitive buildTypeOperator(ir.Primitive value,
                                  DartType type,
-                                 {bool isTypeTest: false,
-                                  bool isNotCheck: false}) {
+                                 {bool isTypeTest}) {
     assert(isOpen);
     assert(isTypeTest != null);
-    assert(!isNotCheck || isTypeTest);
     ir.Primitive check = _continueWithExpression(
-            (k) => new ir.TypeOperator(receiver, type, k, isTypeTest: isTypeTest));
-    return isNotCheck ? buildNegation(check) : check;
+            (k) => new ir.TypeOperator(value,
+                       type, [], k, isTypeTest: isTypeTest));

[karlklose, 2015/05/27 07:38:34]

Please add type arguments to list literals (also in below). This could also be
const.

[asgerf, 2015/05/27 09:19:16]

Done.

+    return check;
   }
 }
 
 /// State shared between JsIrBuilders within the same function.
 ///
 /// Note that this is not shared between builders of nested functions.
 class JsIrBuilderSharedState {
   /// Maps boxed locals to their location. These locals are not part of
   /// the environment.
   final Map<Local, ClosureLocation> boxedVariables = {};
@@ skipping 216 matching lines @@
     }
     environment.update(scope.box, newBox);
   }
 
   ir.Primitive buildThis() {
     if (jsState.receiver != null) return jsState.receiver;
     assert(state.thisParameter != null);
     return state.thisParameter;
   }
 
-  ir.Primitive buildGetInterceptor(ir.Primitive value) {
-    return addPrimitive(new ir.Interceptor(value, program.interceptedClasses));
-  }
-
   @override
   ir.Primitive buildSuperFieldGet(FieldElement target) {
     return addPrimitive(new ir.GetField(buildThis(), target));
   }
 
   @override
   ir.Primitive buildSuperFieldSet(FieldElement target, ir.Primitive value) {
     add(new ir.SetField(buildThis(), target, value));
     return value;
   }
@@ skipping 54 matching lines @@
   ir.Primitive buildTypeExpression(DartType type) {
     if (type is TypeVariableType) {
       return buildTypeVariableAccess(type);
     } else if (type is InterfaceType) {
       List<ir.Primitive> arguments = <ir.Primitive>[];
       type.forEachTypeVariable((TypeVariableType variable) {
         ir.Primitive value = buildTypeVariableAccess(variable);
         arguments.add(value);
       });
       return addPrimitive(new ir.TypeExpression(type, arguments));
+    } else if (type is DynamicType) {
+      return buildNullConstant();
     } else {
       // TypedefType can reach here, and possibly other things.
       throw 'unimplemented translation of type expression $type';
     }
   }
 
   /// Obtains the internal type representation of the type held in [variable].
   ///
   /// The value of [variable] is taken from the current receiver object, or
   /// if we are currently building a constructor field initializer, from the
@@ skipping 24 matching lines @@
     ir.Primitive typeArgument = buildTypeVariableAccess(variable);
     return addPrimitive(new ir.ReifyRuntimeType(typeArgument));
   }
 
   ir.Primitive buildInvocationMirror(Selector selector,
                                      List<ir.Primitive> arguments) {
     return addPrimitive(new ir.CreateInvocationMirror(selector, arguments));
   }
 
   @override
-  ir.Primitive buildTypeOperator(ir.Primitive receiver,
+  ir.Primitive buildTypeOperator(ir.Primitive value,
                                  DartType type,
-                                 {bool isTypeTest: false,
-                                  bool isNotCheck: false}) {
+                                 {bool isTypeTest}) {
     assert(isOpen);
     assert(isTypeTest != null);
-    assert(!isNotCheck || isTypeTest);
-    ir.Primitive interceptor =
-        addPrimitive(new ir.Interceptor(receiver, program.interceptedClasses));
+    // The TypeOperator node does not allow the Object, dynamic, and Null types,
+    // because the null value satisfies them. These must be handled here.
+    if (type.isObject || type.isDynamic) {
+      // `x is Object` and `x is dynamic` are always true, even if x is null.
+      return buildBooleanConstant(true);
+    }
+    if (type is InterfaceType && type.element == program.nullClass) {
+      // `x is Null` is true if and only if x is null.
+      return addPrimitive(new ir.Identical(value, buildNullConstant()));
+    }
+    // Null cannot not satisfy the check. Use a standard subtype check.
+    List<ir.Primitive> typeArguments = const [];
+    if (type is GenericType && type.typeArguments.isNotEmpty) {
+      typeArguments = type.typeArguments.map(buildTypeExpression).toList();
+    }
     ir.Primitive check = _continueWithExpression(
-            (k) => new ir.TypeOperator(interceptor, type, k,
-                                       isTypeTest: isTypeTest));
-    return isNotCheck ? buildNegation(check) : check;
+            (k) => new ir.TypeOperator(value,
+                       type, typeArguments, k, isTypeTest: isTypeTest));
+    return check;
   }
-
 }
 
 
 /// Location of a variable relative to a given closure.
 class ClosureLocation {
   /// If not `null`, this location is [box].[field].
   /// The location of [box] can be obtained separately from an
   /// enclosing [ClosureEnvironment] or [ClosureScope].
   /// If `null`, then the location is [field] on the enclosing function object.
   final BoxLocal box;
@@ skipping 61 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }