Enable full type-checks in checked mode.

sdk/lib/_internal/compiler/implementation/ssa/builder.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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 341 matching lines @@
   }
 
   /**
    * Returns an [HInstruction] for the given element. If the element is
    * boxed or stored in a closure then the method generates code to retrieve
    * the value.
    */
   HInstruction readLocal(Element element) {
     if (isAccessedDirectly(element)) {
       if (directLocals[element] == null) {
-        builder.compiler.internalError("Cannot find value $element",
-                                       element: element);
+        if (element.isTypeVariable()) {
+          builder.compiler.internalError(
+              "Runtime type information not available for $element",
+              element: builder.compiler.currentElement);

[ngeoffray, 2013/04/15 10:59:14]

Thank you :)

+        } else {
+          builder.compiler.internalError(
+              "Cannot find value $element",
+              element: element);
+        }
       }
       return directLocals[element];
     } else if (isStoredInClosureField(element)) {
       Element redirect = redirectionMapping[element];
       HInstruction receiver = readLocal(closureData.closureElement);
       HInstruction fieldGet = new HFieldGet(redirect, receiver);
       fieldGet.instructionType = builder.getTypeOfCapturedVariable(element);
       builder.add(fieldGet);
       return fieldGet;
     } else if (isBoxed(element)) {
@@ skipping 545 matching lines @@
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
     SendSet node = variable.parseNode(compiler);
     openFunction(variable, node);
     Link<Node> link = node.arguments;
     assert(!link.isEmpty && link.tail.isEmpty);
     visit(link.head);
     HInstruction value = pop();
-    value = potentiallyCheckType(value, variable.computeType(compiler));
+    value = potentiallyCheckType(node, value, variable.computeType(compiler));
     close(new HReturn(value)).addSuccessor(graph.exit);
     return closeFunction();
   }
 
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
    *
    * Returns [:null:] if the constructor does not have a body.
    */
@@ skipping 69 matching lines @@
                                                   function,
                                                   compiledArguments);
     assert(succeeded);
 
     // Create the inlining state after evaluating the arguments, that
     // may have an impact on the state of the current method.
     InliningState state = new InliningState(
         function, returnElement, returnType, elements, stack, localsHandler);
     localsHandler = new LocalsHandler.from(localsHandler);
 
-    FunctionSignature signature = function.computeSignature(compiler);
-    int index = 0;
-    signature.orderedForEachParameter((Element parameter) {
-      HInstruction argument = compiledArguments[index++];
-      localsHandler.updateLocal(parameter, argument);
-      potentiallyCheckType(argument, parameter.computeType(compiler));
-    });
-
     if (function.isConstructor()) {
       ClassElement enclosing = function.getEnclosingClass();
       if (backend.needsRti(enclosing)) {
         assert(currentNode is NewExpression);
         InterfaceType type = elements.getType(currentNode);
         Link<DartType> typeVariable = enclosing.typeVariables;
         type.typeArguments.forEach((DartType argument) {
           HInstruction instruction =
               analyzeTypeArgument(argument, currentNode);
           localsHandler.updateLocal(typeVariable.head.element, instruction);
           typeVariable = typeVariable.tail;
         });
         while (!typeVariable.isEmpty) {
           localsHandler.updateLocal(typeVariable.head.element,
                                     graph.addConstantNull(constantSystem));
           typeVariable = typeVariable.tail;
         }
       }
     }
 
+    FunctionSignature signature = function.computeSignature(compiler);
+    int index = 0;
+    signature.orderedForEachParameter((Element parameter) {
+      HInstruction argument = compiledArguments[index++];
+      localsHandler.updateLocal(parameter, argument);
+      potentiallyCheckType(currentNode, argument,
+                           parameter.computeType(compiler));
+    });
+
     // TODO(kasperl): Bad smell. We shouldn't be constructing elements here.
     returnElement = new ElementX(const SourceString("result"),
                                  ElementKind.VARIABLE,
                                  function);
     localsHandler.updateLocal(returnElement,
                               graph.addConstantNull(constantSystem));
     elements = compiler.enqueuer.resolution.getCachedElements(function);
     assert(elements != null);
     returnType = signature.returnType;
     stack = <HInstruction>[];
@@ skipping 61 matching lines @@
     if (newElements == null) {
       compiler.internalError("Element not resolved: $function");
     }
 
     if (canBeInlined == null) {
       canBeInlined = InlineWeeder.canBeInlined(functionExpression, newElements);
       backend.canBeInlined[function] = canBeInlined;
       if (!canBeInlined) return false;
     }
 
+    // TODO(karlklose): remove this and enable inlining of these methods.
+    if (compiler.enableTypeAssertions &&
+        element.computeType(compiler).containsTypeVariables) {
+      return false;
+    }
+
     assert(canBeInlined);
     InliningState state = enterInlinedMethod(
         function, selector, arguments, currentNode);
     inlinedFrom(element, () {
       functionExpression.body.accept(this);
     });
     leaveInlinedMethod(state);
     return true;
   }
 
@@ skipping 268 matching lines @@
 
     // Analyze the constructor and all referenced constructors and collect
     // initializers and constructor bodies.
     List<FunctionElement> constructors = <FunctionElement>[functionElement];
     buildInitializers(functionElement, constructors, fieldValues);
 
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, Element member) {
-          constructorArguments.add(potentiallyCheckType(
+          constructorArguments.add(potentiallyCheckType(function,
               fieldValues[member], member.computeType(compiler)));
         },
         includeBackendMembers: true,
         includeSuperMembers: true);
 
     InterfaceType type = classElement.computeType(compiler);
     HType ssaType = new HType.nonNullExact(type, compiler);
     HForeignNew newObject = new HForeignNew(classElement,
                                             ssaType,
                                             constructorArguments);
@@ skipping 138 matching lines @@
   void openFunction(Element element, Expression node) {
     assert(invariant(element, element.isImplementation));
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     localsHandler.startFunction(element, node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
+    // Add the type parameters of the class as parameters of this method.  This
+    // must be done before adding the normal parameters, because their types
+    // may contain references to type variables.
+    var enclosing = element.enclosingElement;
+    if ((element.isConstructor() || element.isGenerativeConstructorBody())
+        && backend.needsRti(enclosing)) {
+      enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
+        HParameterValue param = addParameter(typeVariable.element);
+        localsHandler.directLocals[typeVariable.element] = param;
+      });
+    }
+
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       FunctionSignature signature = functionElement.computeSignature(compiler);
       signature.orderedForEachParameter((Element parameterElement) {
         if (elements.isParameterChecked(parameterElement)) {
           addParameterCheckInstruction(parameterElement);
         }
       });
 
       // Put the type checks in the first successor of the entry,
       // because that is where the type guards will also be inserted.
       // This way we ensure that a type guard will dominate the type
       // check.
       signature.orderedForEachParameter((Element parameterElement) {
         if (element.isGenerativeConstructorBody()) {
           ClosureScope scopeData =
               localsHandler.closureData.capturingScopes[node];
           if (scopeData != null
               && scopeData.capturedVariableMapping.containsKey(
                   parameterElement)) {
             // The parameter will be a field in the box passed as the
             // last parameter. So no need to have it.
             return;
           }
         }
         HInstruction newParameter = potentiallyCheckType(
+            node,
             localsHandler.directLocals[parameterElement],
             parameterElement.computeType(compiler));
         localsHandler.directLocals[parameterElement] = newParameter;
       });
 
       returnType = signature.returnType;
     } else {
       // Otherwise it is a lazy initializer which does not have parameters.
       assert(element is VariableElement);
     }
-
-    // Add the type parameters of the class as parameters of this
-    // method.
-    var enclosing = element.enclosingElement;
-    if ((element.isConstructor() || element.isGenerativeConstructorBody())
-        && backend.needsRti(enclosing)) {
-      enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
-        HParameterValue param = addParameter(typeVariable.element);
-        localsHandler.directLocals[typeVariable.element] = param;
-      });
-    }
   }
 
   HInstruction potentiallyCheckType(
-      HInstruction original, DartType type,
+      Node node, HInstruction original, DartType type,
       { int kind: HTypeConversion.CHECKED_MODE_CHECK }) {
     if (!compiler.enableTypeAssertions) return original;
-    HInstruction other = original.convertType(compiler, type, kind);
-    if (other != original) add(other);
-    return other;
+    if (type.isDynamic || type.element == compiler.objectClass) {
+      return original;
+    }
+    if (kind == HTypeConversion.CHECKED_MODE_CHECK &&
+        !type.isMalformed) {
+      HInstruction checked =
+          buildIsNode(node, type, original, checkedModeTest: true);
+      add(checked);
+      return checked;
+    } else {

[ngeoffray, 2013/04/15 10:59:14]

You should remove this else. A checked mode check should not be a
HTypeConversion anymore.

+      HInstruction other = original.convertType(compiler, type, kind);
+      if (other != original) add(other);
+      return other;
+    }
   }
 
   HGraph closeFunction() {
     // TODO(kasperl): Make this goto an implicit return.
     if (!isAborted()) close(new HGoto()).addSuccessor(graph.exit);
     graph.finalize();
     return graph;
   }
 
   HBasicBlock addNewBlock() {
@@ skipping 54 matching lines @@
   }
 
   HInstruction pop() {
     return stack.removeLast();
   }
 
   void dup() {
     stack.add(stack.last);
   }
 
-  HInstruction popBoolified() {
+  HInstruction popBoolified(Node node) {
     HInstruction value = pop();
     if (compiler.enableTypeAssertions) {
       return potentiallyCheckType(
+          node,
           value,
           compiler.boolClass.computeType(compiler),
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value);
     add(result);
     return result;
   }
 
   HInstruction attachPosition(HInstruction target, Node node) {
@@ skipping 337 matching lines @@
         if (initializer.asExpression() != null) {
           pop();
         }
       }
     }
     HInstruction buildCondition() {
       if (node.condition == null) {
         return graph.addConstantBool(true, constantSystem);
       }
       visit(node.condition);
-      return popBoolified();
+      return popBoolified(node);
     }
     void buildUpdate() {
       for (Expression expression in node.update) {
         visit(expression);
         assert(!isAborted());
         // The result of the update instruction isn't used, and can just
         // be dropped.
         HInstruction updateInstruction = pop();
       }
     }
     void buildBody() {
       visit(node.body);
     }
     handleLoop(node, buildInitializer, buildCondition, buildUpdate, buildBody);
   }
 
   visitWhile(While node) {
     HInstruction buildCondition() {
       visit(node.condition);
-      return popBoolified();
+      return popBoolified(node);
     }
     handleLoop(node,
                () {},
                buildCondition,
                () {},
                () { visit(node.body); });
   }
 
   visitDoWhile(DoWhile node) {
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
@@ skipping 59 matching lines @@
         } else {
           info = new HLabeledBlockInformation.implicit(bodyInfo, target,
                                                        isContinue: true);
         }
         bodyEntryBlock.setBlockFlow(info, conditionBlock);
       }
       open(conditionBlock);
 
       visit(node.condition);
       assert(!isAborted());
-      HInstruction conditionInstruction = popBoolified();
+      HInstruction conditionInstruction = popBoolified(node);
       HBasicBlock conditionEndBlock = close(
           new HLoopBranch(conditionInstruction, HLoopBranch.DO_WHILE_LOOP));
 
       HBasicBlock avoidCriticalEdge = addNewBlock();
       conditionEndBlock.addSuccessor(avoidCriticalEdge);
       open(avoidCriticalEdge);
       close(new HGoto());
       avoidCriticalEdge.addSuccessor(loopEntryBlock); // The back-edge.
 
       conditionExpression =
@@ skipping 94 matching lines @@
   visitIf(If node) {
     handleIf(node,
              () => visit(node.condition),
              () => visit(node.thenPart),
              node.elsePart != null ? () => visit(node.elsePart) : null);
   }
 
   void handleIf(Node diagnosticNode,
                 void visitCondition(), void visitThen(), void visitElse()) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, diagnosticNode);
-    branchBuilder.handleIf(visitCondition, visitThen, visitElse);
+    branchBuilder.handleIf(diagnosticNode, visitCondition, visitThen,
+                           visitElse);
   }
 
   void visitLogicalAndOr(Send node, Operator op) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
     branchBuilder.handleLogicalAndOrWithLeftNode(
+        node,
         node.receiver,
         () { visit(node.argumentsNode); },
         isAnd: (const SourceString("&&") == op.source));
   }
 
   void visitLogicalNot(Send node) {
     assert(node.argumentsNode is Prefix);
     visit(node.receiver);
-    HNot not = new HNot(popBoolified());
+    HNot not = new HNot(popBoolified(node));
     pushWithPosition(not, node);
   }
 
   void visitUnary(Send node, Operator op) {
     if (node.isParameterCheck) {
       Element element = elements[node.receiver];
       Node function = element.enclosingElement.parseNode(compiler);
       ClosureClassMap parameterClosureData =
           compiler.closureToClassMapper.getMappingForNestedFunction(function);
       Element fieldCheck =
@@ skipping 35 matching lines @@
         HIdentity eq = new HIdentity(left, right);
         add(eq);
         pushWithPosition(new HNot(eq), op);
         return;
     }
 
     pushWithPosition(
           buildInvokeDynamic(send, selector, left, [right]),
           op);
     if (op.source.stringValue == '!=') {
-      pushWithPosition(new HNot(popBoolified()), op);
+      pushWithPosition(new HNot(popBoolified(send)), op);
     }
   }
 
   HInstruction generateInstanceSendReceiver(Send send) {
     assert(Elements.isInstanceSend(send, elements));
     if (send.receiver == null) {
       return localsHandler.readThis();
     }
     visit(send.receiver);
     return pop();
@@ skipping 121 matching lines @@
                                  HInstruction value) {
     assert(!Elements.isInstanceSend(send, elements));
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.isSetter()) {
         HStatic target = new HStatic(element);
         add(target);
         addWithPosition(
             new HInvokeStatic(<HInstruction>[target, value], HType.UNKNOWN),
             send);
       } else {
-        value = potentiallyCheckType(value, element.computeType(compiler));
+        value =
+            potentiallyCheckType(send, value, element.computeType(compiler));
         addWithPosition(new HStaticStore(element, value), send);
       }
       stack.add(value);
     } else if (Elements.isErroneousElement(element)) {
       // An erroneous element indicates an unresolved static setter.
       generateThrowNoSuchMethod(send,
                                 getTargetName(element, 'set'),
                                 argumentNodes: send.arguments);
     } else {
       stack.add(value);
       // If the value does not already have a name, give it here.
       if (value.sourceElement == null) {
         value.sourceElement = element;
       }
-      HInstruction checked = potentiallyCheckType(
-          value, element.computeType(compiler));
+      HInstruction checked =
+          potentiallyCheckType(send, value, element.computeType(compiler));
       if (!identical(checked, value)) {
         pop();
         stack.add(checked);
       }
       localsHandler.updateLocal(element, checked);
     }
   }
 
   HInstruction invokeInterceptor(Set<ClassElement> intercepted,
                                  HInstruction receiver,
@@ skipping 155 matching lines @@
       isNot = true;
     }
     DartType type = elements.getType(typeAnnotation);
     if (type.isMalformed) {
       String reasons = Types.fetchReasonsFromMalformedType(type);
       if (compiler.enableTypeAssertions) {
         generateMalformedSubtypeError(node, expression, type, reasons);
       } else {
         generateRuntimeError(node, '$type is malformed: $reasons');
       }
-      return;
+    } else {
+      HInstruction instruction = buildIsNode(node, type, expression);
+      if (isNot) {
+        add(instruction);
+        instruction = new HNot(instruction);
+      }
+      push(instruction);
     }
+  }
 
-    HInstruction instruction;
+  HInstruction buildIsNode(Node node, DartType type, HInstruction expression,
+                           {bool checkedModeTest: false}) {

[ngeoffray, 2013/04/15 10:59:14]

I'd prefer if the call sites always added the named argument, and the default
value would be null.

+    HType returnType =
+        checkedModeTest ? expression.instructionType : HType.BOOLEAN;
     if (type.kind == TypeKind.TYPE_VARIABLE) {
       HInstruction runtimeType = addTypeVariableReference(type);
-      Element helper = backend.getGetObjectIsSubtype();
+      Element helper = checkedModeTest ? backend.getAssertObjectIsSubtype()
+                                       : backend.getObjectIsSubtype();
       HInstruction helperCall = new HStatic(helper);
       add(helperCall);
       List<HInstruction> inputs = <HInstruction>[helperCall, expression,
                                                  runtimeType];
-      HInstruction call = new HInvokeStatic(inputs, HType.BOOLEAN);
+      HInstruction call = new HInvokeStatic(inputs, returnType);
       add(call);
-      instruction = new HIs(type, <HInstruction>[expression, call],
-                            HIs.VARIABLE_CHECK);
+      return new HIs(type, <HInstruction>[expression, call],
+                     HIs.VARIABLE_CHECK, checkedModeTest, returnType);
     } else if (RuntimeTypes.hasTypeArguments(type)) {
       Element element = type.element;
       bool needsNativeCheck =
-          backend.emitter.nativeEmitter.requiresNativeIsCheck(element);
-      Element helper = backend.getCheckSubtype();
+        backend.emitter.nativeEmitter.requiresNativeIsCheck(element);
+      Element helper = checkedModeTest ? backend.getAssertSubtype()
+                                       : backend.getCheckSubtype();
       HInstruction helperCall = new HStatic(helper);
       add(helperCall);
       HInstruction representations =
-        buildTypeArgumentRepresentations(type);
+          buildTypeArgumentRepresentations(type);
       add(representations);
       HInstruction isFieldName =
-          addConstantString(node, backend.namer.operatorIs(element));
+        addConstantString(node, backend.namer.operatorIs(element));
       // TODO(karlklose): use [:null:] for [asField] if [element] does not
       // have a subclass.
       HInstruction asFieldName =
           addConstantString(node, backend.namer.substitutionName(element));
       HInstruction native =
           graph.addConstantBool(needsNativeCheck, constantSystem);
       List<HInstruction> inputs = <HInstruction>[helperCall,
                                                  expression,
                                                  isFieldName,
                                                  representations,
                                                  asFieldName,
                                                  native];
-      HInstruction call = new HInvokeStatic(inputs, HType.BOOLEAN);
+      HInstruction call = new HInvokeStatic(inputs, returnType);
       add(call);
-      instruction = new HIs(type, <HInstruction>[expression, call],
-                            HIs.COMPOUND_CHECK);
+      return new HIs(type, <HInstruction>[expression, call],
+                     HIs.COMPOUND_CHECK, checkedModeTest, returnType);
+    } else if (checkedModeTest) {
+      FunctionElement helper = backend.getCheckedModeHelper(type);
+      HInstruction helperCall = new HStatic(helper);
+      add(helperCall);
+      List<HInstruction> inputs = <HInstruction>[helperCall, expression];
+      if (helper.functionSignature.requiredParameterCount == 2) {
+        // 2 arguments implies that the method is either [propertyTypeCheck]
+        // or [propertyTypeCast].
+        String isFieldName = backend.namer.operatorIs(type.element);
+        inputs.add(addConstantString(node, isFieldName));
+      }
+      HInstruction call = new HInvokeStatic(inputs, returnType);
+      add(call);
+      return new HIs(type, <HInstruction>[expression, call], HIs.RAW_ASSERT,
+                     checkedModeTest, returnType);
     } else {
-      instruction = new HIs(type, <HInstruction>[expression], HIs.RAW_CHECK);
+      assert(!checkedModeTest);
+      return new HIs(type, <HInstruction>[expression], HIs.RAW_CHECK, false,
+                     returnType);
     }
-    if (isNot) {
-      add(instruction);
-      instruction = new HNot(instruction);
-    }
-    push(instruction);
   }
 
   void addDynamicSendArgumentsToList(Send node, List<HInstruction> list) {
     Selector selector = elements.getSelector(node);
     if (selector.namedArgumentCount == 0) {
       addGenericSendArgumentsToList(node.arguments, list);
     } else {
       // Visit positional arguments and add them to the list.
       Link<Node> arguments = node.arguments;
       int positionalArgumentCount = selector.positionalArgumentCount;
@@ skipping 1126 matching lines @@
       native.handleSsaNative(this, node.expression);
       return;
     }
     assert(invariant(node, !node.isRedirectingFactoryBody));
     HInstruction value;
     if (node.expression == null) {
       value = graph.addConstantNull(constantSystem);
     } else {
       visit(node.expression);
       value = pop();
-      value = potentiallyCheckType(value, returnType);
+      value = potentiallyCheckType(node, value, returnType);
     }
 
     handleInTryStatement();
 
     if (!inliningStack.isEmpty) {
       localsHandler.updateLocal(returnElement, value);
     } else {
       close(attachPosition(new HReturn(value), node)).addSuccessor(graph.exit);
     }
   }
@@ skipping 47 matching lines @@
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       inputs.add(pop());
     }
     push(new HLiteralList(inputs));
   }
 
   visitConditional(Conditional node) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
-    brancher.handleConditional(() => visit(node.condition),
+    brancher.handleConditional(node,
+                               () => visit(node.condition),
                                () => visit(node.thenExpression),
                                () => visit(node.elseExpression));
   }
 
   visitStringInterpolation(StringInterpolation node) {
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result);
   }
 
@@ skipping 82 matching lines @@
             new HInvokeDynamicGetter(selector, null, interceptor, !hasGetter);
         // Add the receiver as an argument to the getter call on the
         // interceptor.
         iterator.inputs.add(receiver);
       }
       add(iterator);
     }
     HInstruction buildCondition() {
       Selector selector = elements.getMoveNextSelector(node);
       push(new HInvokeDynamicMethod(selector, <HInstruction>[iterator]));
-      return popBoolified();
+      return popBoolified(node);
     }
     void buildBody() {
       Selector call = elements.getCurrentSelector(node);
       bool hasGetter = compiler.world.hasAnyUserDefinedGetter(call);
       push(new HInvokeDynamicGetter(call, null, iterator, !hasGetter));
 
       Element variable;
       if (node.declaredIdentifier.asSend() != null) {
         variable = elements[node.declaredIdentifier];
       } else {
@@ skipping 415 matching lines @@
       if (tail.isEmpty) {
         left();
         return;
       }
 
       void right() {
         buildTests(tail);
       }
       SsaBranchBuilder branchBuilder =
           new SsaBranchBuilder(this, remainingCases.head);
-      branchBuilder.handleLogicalAndOr(left, right, isAnd: false);
+      branchBuilder.handleLogicalAndOr(remainingCases.head, left, right,
+                                       isAnd: false);
     }
 
     if (node.isDefaultCase) {
       // Default case must be last.
       assert(cases.tail.isEmpty);
       // Perform the tests until one of them match, but then always execute the
       // statements.
       // TODO(lrn): Stop performing tests when all expressions are compile-time
       // constant strings or integers.
       handleIf(node, () { buildTests(labelsAndCases); }, (){}, null);
@@ skipping 80 matching lines @@
           }
           if (type.isMalformed) {
             // TODO(johnniwinther): Handle malformed types in [HIs] instead.
             HInstruction condition =
                 graph.addConstantBool(true, constantSystem);
             stack.add(condition);
           } else {
             // TODO(karlkose): support type arguments here.
             HInstruction condition = new HIs(type,
                                              <HInstruction>[unwrappedException],
-                                             HIs.RAW_CHECK);
+                                             HIs.RAW_CHECK,
+                                             false,
+                                             HType.BOOLEAN);
             push(condition);
           }
         } else {
           VariableDefinitions declaration = catchBlock.formals.nodes.head;
           HInstruction condition = null;
           if (declaration.type == null) {
             condition = graph.addConstantBool(true, constantSystem);
             stack.add(condition);
           } else {
             // TODO(aprelev@gmail.com): Once old catch syntax is removed
             // "if" condition above and this "else" branch should be deleted as
             // type of declared variable won't matter for the catch
             // condition.
             DartType type = elements.getType(declaration.type);
             if (type == null) {
               compiler.cancel('Catch with unresolved type', node: catchBlock);
             }
             // TODO(karlkose): support type arguments here.
             condition = new HIs(type, <HInstruction>[unwrappedException],
-                                HIs.RAW_CHECK, nullOk: true);
+                                HIs.RAW_CHECK, false, HType.BOOLEAN,
+                                nullOk: true);
             push(condition);
           }
         }
       }
 
       void visitThen() {
         CatchBlock catchBlock = link.head;
         link = link.tail;
 
         if (compiler.enableTypeAssertions) {
@@ skipping 330 matching lines @@
   SsaBranchBuilder(this.builder, [this.diagnosticNode]);
 
   Compiler get compiler => builder.compiler;
 
   void checkNotAborted() {
     if (builder.isAborted()) {
       compiler.unimplemented("aborted control flow", node: diagnosticNode);
     }
   }
 
-  void buildCondition(void visitCondition(),
+  void buildCondition(Node node,
+                      void visitCondition(),
                       SsaBranch conditionBranch,
                       SsaBranch thenBranch,
                       SsaBranch elseBranch) {
     startBranch(conditionBranch);
     visitCondition();
     checkNotAborted();
     assert(identical(builder.current, builder.lastOpenedBlock));
-    HInstruction conditionValue = builder.popBoolified();
+    HInstruction conditionValue = builder.popBoolified(node);
     HIf branch = new HIf(conditionValue);
     HBasicBlock conditionExitBlock = builder.current;
     builder.close(branch);
     conditionBranch.exitLocals = builder.localsHandler;
     conditionExitBlock.addSuccessor(thenBranch.block);
     conditionExitBlock.addSuccessor(elseBranch.block);
     bool conditionBranchLocalsCanBeReused =
         mergeLocals(conditionBranch, thenBranch, mayReuseFromLocals: true);
     mergeLocals(conditionBranch, elseBranch,
                 mayReuseFromLocals: conditionBranchLocalsCanBeReused);
@@ skipping 41 matching lines @@
       builder.goto(builder.current, joinBranch.block);
       mergeLocals(branch, joinBranch, mayReuseFromLocals: true);
     }
     if (isExpression) {
       checkNotAborted();
       return builder.pop();
     }
     return null;
   }
 
-  handleIf(void visitCondition(), void visitThen(), void visitElse()) {
+  handleIf(Node node, void visitCondition(), void visitThen(),
+           void visitElse()) {
     if (visitElse == null) {
       // Make sure to have an else part to avoid a critical edge. A
       // critical edge is an edge that connects a block with multiple
       // successors to a block with multiple predecessors. We avoid
       // such edges because they prevent inserting copies during code
       // generation of phi instructions.
       visitElse = () {};
     }
 
-    _handleDiamondBranch(visitCondition, visitThen, visitElse, false);
+    _handleDiamondBranch(node, visitCondition, visitThen, visitElse, false);
   }
 
-  handleConditional(void visitCondition(), void visitThen(), void visitElse()) {
+  handleConditional(Node node, void visitCondition(), void visitThen(),
+                    void visitElse()) {
     assert(visitElse != null);
-    _handleDiamondBranch(visitCondition, visitThen, visitElse, true);
+    _handleDiamondBranch(node, visitCondition, visitThen, visitElse, true);
   }
 
-  void handleLogicalAndOr(void left(), void right(), {bool isAnd}) {
+  void handleLogicalAndOr(Node node, void left(), void right(), {bool isAnd}) {
     // x && y is transformed into:
     //   t0 = boolify(x);
     //   if (t0) {
     //     t1 = boolify(y);
     //   }
     //   result = phi(t1, false);
     //
     // x || y is transformed into:
     //   t0 = boolify(x);
     //   if (not(t0)) {
     //     t1 = boolify(y);
     //   }
     //   result = phi(t1, true);
     HInstruction boolifiedLeft;
     HInstruction boolifiedRight;
 
     void visitCondition() {
       left();
-      boolifiedLeft = builder.popBoolified();
+      boolifiedLeft = builder.popBoolified(node);
       builder.stack.add(boolifiedLeft);
       if (!isAnd) {
         builder.push(new HNot(builder.pop()));
       }
     }
 
     void visitThen() {
       right();
-      boolifiedRight = builder.popBoolified();
+      boolifiedRight = builder.popBoolified(node);
     }
 
-    handleIf(visitCondition, visitThen, null);
+    handleIf(node, visitCondition, visitThen, null);
     HConstant notIsAnd =
         builder.graph.addConstantBool(!isAnd, builder.constantSystem);
     HPhi result = new HPhi.manyInputs(null,
                                       <HInstruction>[boolifiedRight, notIsAnd]);
     builder.current.addPhi(result);
     builder.stack.add(result);
   }
 
-  void handleLogicalAndOrWithLeftNode(Node left,
+  void handleLogicalAndOrWithLeftNode(Node node,
+                                      Node left,
                                       void visitRight(),
                                       {bool isAnd}) {
     // This method is similar to [handleLogicalAndOr] but optimizes the case
     // where left is a logical "and" or logical "or".
     //
     // For example (x && y) && z is transformed into x && (y && z):
     //   t0 = boolify(x);
     //   if (t0) {
     //     t1 = boolify(y);
     //     if (t1) {
     //       t2 = boolify(z);
     //     }
     //     t3 = phi(t2, false);
     //   }
     //   result = phi(t3, false);
 
     Send send = left.asSend();
     if (send != null &&
         (isAnd ? send.isLogicalAnd : send.isLogicalOr)) {
       Node newLeft = send.receiver;
       Link<Node> link = send.argumentsNode.nodes;
       assert(link.tail.isEmpty);
       Node middle = link.head;
       handleLogicalAndOrWithLeftNode(
+          node,
           newLeft,
-          () => handleLogicalAndOrWithLeftNode(middle, visitRight,
+          () => handleLogicalAndOrWithLeftNode(node, middle, visitRight,
                                                isAnd: isAnd),
           isAnd: isAnd);
     } else {
-      handleLogicalAndOr(() => builder.visit(left), visitRight, isAnd: isAnd);
+      handleLogicalAndOr(node, () => builder.visit(left), visitRight,
+                         isAnd: isAnd);
     }
   }
 
-  void _handleDiamondBranch(void visitCondition(),
+  void _handleDiamondBranch(Node node,
+                            void visitCondition(),
                             void visitThen(),
                             void visitElse(),
                             bool isExpression) {
     SsaBranch conditionBranch = new SsaBranch(this);
     SsaBranch thenBranch = new SsaBranch(this);
     SsaBranch elseBranch = new SsaBranch(this);
     SsaBranch joinBranch = new SsaBranch(this);
 
     conditionBranch.startLocals = builder.localsHandler;
     builder.goto(builder.current, conditionBranch.block);
 
-    buildCondition(visitCondition, conditionBranch, thenBranch, elseBranch);
+    buildCondition(node, visitCondition, conditionBranch, thenBranch,
+                   elseBranch);
     HInstruction thenValue =
         buildBranch(thenBranch, visitThen, joinBranch, isExpression);
     HInstruction elseValue =
         buildBranch(elseBranch, visitElse, joinBranch, isExpression);
 
     if (isExpression) {
       assert(thenValue != null && elseValue != null);
       HPhi phi =
           new HPhi.manyInputs(null, <HInstruction>[thenValue, elseValue]);
       joinBranch.block.addPhi(phi);
@@ skipping 16 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }