Revert "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;
-      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);
+      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)";
+          }
         } else {
-          compiler.internalErrorOnElement(element,
-                                          'unexpected element kind $kind');
+          name = "${element.name.slowToString()}";
         }
-        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)";
-            }
-          } else {
-            name = "${element.name.slowToString()}";
-          }
-          compiler.tracer.traceCompilation(
-              name, work.compilationContext, compiler);
-          compiler.tracer.traceGraph('builder', graph);
-        }
-        return graph;
-      });
+        compiler.tracer.traceCompilation(
+            name, work.compilationContext, compiler);
+        compiler.tracer.traceGraph('builder', 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.raw(type, expression, invokeInterceptor(expression));
+        return new HIs(type, <HInstruction>[expression], HIs.RAW_CHECK);
       }
       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.compound(type, expression, call);
+      return new HIs(type, <HInstruction>[expression, call],
+          HIs.COMPOUND_CHECK);
     } 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.variable(type, expression, call);
+      return new HIs(type, <HInstruction>[expression, call],
+                     HIs.VARIABLE_CHECK);
     } 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.compound(type, expression, call);
+      return
+          new HIs(type, <HInstruction>[expression, call], HIs.COMPOUND_CHECK);
     } else {
-      if (backend.hasDirectCheckFor(type)) {
-        return new HIs.direct(type, expression);
-      }
-      return new HIs.raw(type, expression, invokeInterceptor(expression));
+      return new HIs(type, <HInstruction>[expression], HIs.RAW_CHECK);
     }
   }
 
   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);
           }
-          HInstruction condition =
-              buildIsNode(catchBlock.type, type, unwrappedException);
+          // TODO(karlkose): support type arguments here.
+          HInstruction condition = new HIs(type,
+                                           <HInstruction>[unwrappedException],
+                                           HIs.RAW_CHECK);
           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);
             }
-            condition = buildIsNode(declaration.type, type, unwrappedException);
+            // TODO(karlkose): support type arguments here.
+            condition = new HIs(type, <HInstruction>[unwrappedException],
+                                HIs.RAW_CHECK);
             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;
   }
 }