Extract interceptor calls from raw is-checks.

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 13 matching lines @@
   String get name => 'SSA builder';
 
   SsaBuilderTask(JavaScriptBackend backend)
     : emitter = backend.emitter,
       backend = backend,
       super(backend.compiler);
 
   HGraph build(CodegenWorkItem work) {
     return measure(() {
       Element element = work.element.implementation;
-      HInstruction.idCounter = 0;
-      ConstantSystem constantSystem = compiler.backend.constantSystem;
-      SsaBuilder builder = new SsaBuilder(constantSystem, this, work);
-      HGraph graph;
-      ElementKind kind = element.kind;
-      if (kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
-        graph = compileConstructor(builder, work);
-      } else if (kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
-                 kind == ElementKind.FUNCTION ||
-                 kind == ElementKind.GETTER ||
-                 kind == ElementKind.SETTER) {
-        graph = builder.buildMethod(element);
-      } else if (kind == ElementKind.FIELD) {
-        assert(!element.isInstanceMember());
-        graph = builder.buildLazyInitializer(element);
-      } else {
-        compiler.internalErrorOnElement(element,
-                                        'unexpected element kind $kind');
-      }
-      assert(graph.isValid());
-      if (!identical(kind, ElementKind.FIELD)) {
-        FunctionElement function = element;
-        FunctionSignature signature = function.computeSignature(compiler);
-        signature.forEachOptionalParameter((Element parameter) {
-          // This ensures the default value will be computed.
-          builder.compileVariable(parameter);
-        });
-      }
+      return compiler.withCurrentElement(element, () {
+        HInstruction.idCounter = 0;
+        ConstantSystem constantSystem = compiler.backend.constantSystem;
+        SsaBuilder builder = new SsaBuilder(constantSystem, this, work);
+        HGraph graph;
+        ElementKind kind = element.kind;
+        if (kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
+          graph = compileConstructor(builder, work);
+        } else if (kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
+                   kind == ElementKind.FUNCTION ||
+                   kind == ElementKind.GETTER ||
+                   kind == ElementKind.SETTER) {
+          graph = builder.buildMethod(element);
+        } else if (kind == ElementKind.FIELD) {
+          assert(!element.isInstanceMember());
+          graph = builder.buildLazyInitializer(element);
+        } else {
+          compiler.internalErrorOnElement(element,
+                                          'unexpected element kind $kind');
+        }
+        assert(graph.isValid());
+        if (!identical(kind, ElementKind.FIELD)) {
+          FunctionElement function = element;
+          FunctionSignature signature = function.computeSignature(compiler);
+          signature.forEachOptionalParameter((Element parameter) {
+            // This ensures the default value will be computed.
+            builder.compileVariable(parameter);
+          });
+        }
 
-      if (compiler.tracer.enabled) {
-        String name;
-        if (element.isMember()) {
-          String className = element.getEnclosingClass().name.slowToString();
-          String memberName = element.name.slowToString();
-          name = "$className.$memberName";
-          if (element.isGenerativeConstructorBody()) {
-            name = "$name (body)";
+        if (compiler.tracer.enabled) {
+          String name;
+          if (element.isMember()) {
+            String className = element.getEnclosingClass().name.slowToString();
+            String memberName = element.name.slowToString();
+            name = "$className.$memberName";
+            if (element.isGenerativeConstructorBody()) {
+              name = "$name (body)";
+            }
+          } else {
+            name = "${element.name.slowToString()}";
           }
-        } else {
-          name = "${element.name.slowToString()}";
+          compiler.tracer.traceCompilation(
+              name, work.compilationContext, compiler);
+          compiler.tracer.traceGraph('builder', graph);
         }
-        compiler.tracer.traceCompilation(
-            name, work.compilationContext, compiler);
-        compiler.tracer.traceGraph('builder', graph);
-      }
-      return graph;
+        return graph;
+      });
     });
   }
 
   HGraph compileConstructor(SsaBuilder builder, CodegenWorkItem work) {
     return builder.buildFactory(work.element);
   }
 }
 
 
 /**
@@ skipping 2701 matching lines @@
         link = link.tail) {
       inputs.add(addTypeVariableReference(link.head));
     }
     return buildLiteralList(inputs);
   }
 
   HInstruction buildIsNode(Node node, DartType type, HInstruction expression) {
     type = type.unalias(compiler);
     if (type.kind == TypeKind.FUNCTION) {
       if (backend.rti.isSimpleFunctionType(type)) {
-        return new HIs(type, <HInstruction>[expression], HIs.RAW_CHECK);
+        // TODO(johnniwinther): Avoid interceptor if unneeded.
+        return new HIs.raw(type, expression, invokeInterceptor(expression));
       }
       Element checkFunctionSubtype = backend.getCheckFunctionSubtype();
 
       HInstruction signatureName = graph.addConstantString(
           new DartString.literal(backend.namer.getFunctionTypeName(type)),
           node, compiler);
 
       HInstruction contextName;
       HInstruction context;
       HInstruction typeArguments;
@@ skipping 16 matching lines @@
         typeArguments = graph.addConstantNull(compiler);
       }
 
       List<HInstruction> inputs = <HInstruction>[expression,
                                                  signatureName,
                                                  contextName,
                                                  context,
                                                  typeArguments];
       pushInvokeStatic(node, checkFunctionSubtype, inputs, HType.BOOLEAN);
       HInstruction call = pop();
-      return new HIs(type, <HInstruction>[expression, call],
-          HIs.COMPOUND_CHECK);
+      return new HIs.compound(type, expression, call);
     } else if (type.kind == TypeKind.TYPE_VARIABLE) {
       HInstruction runtimeType = addTypeVariableReference(type);
       Element helper = backend.getCheckSubtypeOfRuntimeType();
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
       pushInvokeStatic(null, helper, inputs, HType.BOOLEAN);
       HInstruction call = pop();
-      return new HIs(type, <HInstruction>[expression, call],
-                     HIs.VARIABLE_CHECK);
+      return new HIs.variable(type, expression, call);
     } else if (RuntimeTypes.hasTypeArguments(type)) {
       ClassElement element = type.element;
       Element helper = backend.getCheckSubtype();
       HInstruction representations =
           buildTypeArgumentRepresentations(type);
       add(representations);
       String operator =
           backend.namer.operatorIs(backend.getImplementationClass(element));
       HInstruction isFieldName = addConstantString(node, operator);
       HInstruction asFieldName = compiler.world.hasAnySubtype(element)
           ? addConstantString(node, backend.namer.substitutionName(element))
           : graph.addConstantNull(compiler);
       List<HInstruction> inputs = <HInstruction>[expression,
                                                  isFieldName,
                                                  representations,
                                                  asFieldName];
       pushInvokeStatic(node, helper, inputs, HType.BOOLEAN);
       HInstruction call = pop();
-      return
-          new HIs(type, <HInstruction>[expression, call], HIs.COMPOUND_CHECK);
+      return new HIs.compound(type, expression, call);
     } else {
-      return new HIs(type, <HInstruction>[expression], HIs.RAW_CHECK);
+      if (backend.hasDirectCheckFor(type)) {
+        return new HIs.direct(type, expression);
+      }
+      // TODO(johnniwinther): Avoid interceptor if unneeded.
+      return new HIs.raw(type, expression, invokeInterceptor(expression));
     }
   }
 
   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;
@@ skipping 2015 matching lines @@
       HInvokeStatic unwrappedException = pop();
       tryInstruction.exception = exception;
       Link<Node> link = node.catchBlocks.nodes;
 
       void pushCondition(CatchBlock catchBlock) {
         if (catchBlock.onKeyword != null) {
           DartType type = elements.getType(catchBlock.type);
           if (type == null) {
             compiler.internalError('On with no type', node: catchBlock.type);
           }
-          // TODO(karlkose): support type arguments here.
-          HInstruction condition = new HIs(type,
-                                           <HInstruction>[unwrappedException],
-                                           HIs.RAW_CHECK);
+          HInstruction condition =
+              buildIsNode(catchBlock.type, type, unwrappedException);
           push(condition);
         } else {
           VariableDefinitions declaration = catchBlock.formals.nodes.head;
           HInstruction condition = null;
           if (declaration.type == null) {
             condition = graph.addConstantBool(true, compiler);
             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);
+            condition = buildIsNode(declaration.type, type, unwrappedException);
             push(condition);
           }
         }
       }
 
       void visitThen() {
         CatchBlock catchBlock = link.head;
         link = link.tail;
         if (catchBlock.exception != null) {
           localsHandler.updateLocal(elements[catchBlock.exception],
@@ skipping 531 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;
   }
 }