Implement "one-shot" interceptors.

sdk/lib/_internal/compiler/implementation/ssa/nodes.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;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 32 matching lines @@
   R visitLess(HLess node);
   R visitLessEqual(HLessEqual node);
   R visitLiteralList(HLiteralList node);
   R visitLocalGet(HLocalGet node);
   R visitLocalSet(HLocalSet node);
   R visitLocalValue(HLocalValue node);
   R visitLoopBranch(HLoopBranch node);
   R visitMultiply(HMultiply node);
   R visitNegate(HNegate node);
   R visitNot(HNot node);
+  R visitOneShotInterceptor(HOneShotInterceptor);
   R visitParameterValue(HParameterValue node);
   R visitPhi(HPhi node);
   R visitRangeConversion(HRangeConversion node);
   R visitReturn(HReturn node);
   R visitShiftLeft(HShiftLeft node);
   R visitStatic(HStatic node);
   R visitStaticStore(HStaticStore node);
   R visitStringConcat(HStringConcat node);
   R visitSubtract(HSubtract node);
   R visitSwitch(HSwitch node);
@@ skipping 243 matching lines @@
   visitLazyStatic(HLazyStatic node) => visitInstruction(node);
   visitLess(HLess node) => visitRelational(node);
   visitLessEqual(HLessEqual node) => visitRelational(node);
   visitLiteralList(HLiteralList node) => visitInstruction(node);
   visitLocalGet(HLocalGet node) => visitFieldAccess(node);
   visitLocalSet(HLocalSet node) => visitFieldAccess(node);
   visitLocalValue(HLocalValue node) => visitInstruction(node);
   visitLoopBranch(HLoopBranch node) => visitConditionalBranch(node);
   visitNegate(HNegate node) => visitInvokeUnary(node);
   visitNot(HNot node) => visitInstruction(node);
+  visitOneShotInterceptor(HOneShotInterceptor node)
+      => visitInvokeDynamic(node);
   visitPhi(HPhi node) => visitInstruction(node);
   visitMultiply(HMultiply node) => visitBinaryArithmetic(node);
   visitParameterValue(HParameterValue node) => visitLocalValue(node);
   visitRangeConversion(HRangeConversion node) => visitCheck(node);
   visitReturn(HReturn node) => visitControlFlow(node);
   visitShiftLeft(HShiftLeft node) => visitBinaryBitOp(node);
   visitSubtract(HSubtract node) => visitBinaryArithmetic(node);
   visitSwitch(HSwitch node) => visitControlFlow(node);
   visitStatic(HStatic node) => visitInstruction(node);
   visitStaticStore(HStaticStore node) => visitInstruction(node);
@@ skipping 827 matching lines @@
         new HType.fromBoundedType(type, compiler, canBeNull);
 
     // No need to convert if we know the instruction has
     // [convertedType] as a bound.
     if (this.guaranteedType == convertedType) {
       return this;
     }
 
     return new HTypeConversion(convertedType, this, kind);
   }
+
+    /**
+   * Return whether the instructions do not belong to a loop or
+   * belong to the same loop.
+   */
+  bool hasSameLoopHeaderAs(HInstruction other) {
+    return block.enclosingLoopHeader == other.block.enclosingLoopHeader;
+  }
 }
 
 class HBoolify extends HInstruction {
   HBoolify(HInstruction value) : super(<HInstruction>[value]) {
     assert(!hasSideEffects());
     setUseGvn();
   }
 
   HType get guaranteedType => HType.BOOLEAN;
 
@@ skipping 142 matching lines @@
     */
   HInvoke(List<HInstruction> inputs) : super(inputs) {
     setAllSideEffects();
     setDependsOnSomething();
   }
   static const int ARGUMENTS_OFFSET = 1;
   bool canThrow() => true;
 }
 
 abstract class HInvokeDynamic extends HInvoke {
+  final InvokeDynamicSpecializer specializer;
   final Selector selector;
   Element element;
 
-  HInvokeDynamic(this.selector, this.element, List<HInstruction> inputs)
-    : super(inputs);
+  HInvokeDynamic(Selector selector,
+                 this.element,
+                 List<HInstruction> inputs,
+                 [bool isIntercepted = false])
+    : super(inputs),
+      this.selector = selector,
+      specializer = isIntercepted
+          ? InvokeDynamicSpecializer.lookupSpecializer(selector)
+          : const InvokeDynamicSpecializer();
   toString() => 'invoke dynamic: $selector';
   HInstruction get receiver => inputs[0];
 
   bool get isInterceptorCall {
     // We know it's a selector call if it follows the interceptor
     // calling convention, which adds the actual receiver as a
     // parameter to the call.
     return inputs.length - 2 == selector.argumentCount;
   }
 
   int typeCode() => HInstruction.INVOKE_DYNAMIC_TYPECODE;
   bool typeEquals(other) => other is HInvokeDynamic;
   bool dataEquals(HInvokeDynamic other) {
     return selector == other.selector
         && element == other.element;
   }
+
+  HType computeDesiredTypeForInput(HInstruction input,
+                                   HTypeMap types,
+                                   Compiler compiler) {
+    return specializer.computeDesiredTypeForInput(this, input, types, compiler);
+  }
+
+  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
+    return specializer.computeTypeFromInputTypes(this, types, compiler);
+  }
 }
 
 class HInvokeClosure extends HInvokeDynamic {
   HInvokeClosure(Selector selector, List<HInstruction> inputs)
     : super(selector, null, inputs) {
     assert(selector.isClosureCall());
   }
   accept(HVisitor visitor) => visitor.visitInvokeClosure(this);
 }
 
 class HInvokeDynamicMethod extends HInvokeDynamic {
-  final InvokeDynamicSpecializer specializer;
   HInvokeDynamicMethod(Selector selector,
                        List<HInstruction> inputs,
                        [bool isIntercepted = false])
-    : super(selector, null, inputs),
-      specializer = isIntercepted
-          ? InvokeDynamicSpecializer.lookupSpecializer(selector)
-          : const InvokeDynamicSpecializer();
+    : super(selector, null, inputs, isIntercepted);
+
   String toString() => 'invoke dynamic method: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicMethod(this);
 
   bool isIndexOperatorOnIndexablePrimitive(HTypeMap types) {
     return isInterceptorCall
         && selector.kind == SelectorKind.INDEX
         && selector.name == const SourceString('[]')
         && inputs[1].isIndexablePrimitive(types);
   }
-
-  HType computeDesiredTypeForInput(HInstruction input,
-                                   HTypeMap types,
-                                   Compiler compiler) {
-    return specializer.computeDesiredTypeForInput(this, input, types, compiler);
-  }
-
-  HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
-    return specializer.computeTypeFromInputTypes(this, types, compiler);
-  }
 }
 
 abstract class HInvokeDynamicField extends HInvokeDynamic {
   final bool isSideEffectFree;
   HInvokeDynamicField(
       Selector selector, Element element, List<HInstruction> inputs,
       this.isSideEffectFree)
       : super(selector, element, inputs);
   toString() => 'invoke dynamic field: $selector';
 }
@@ skipping 742 matching lines @@
 
   int typeCode() => HInstruction.INTERCEPTOR_TYPECODE;
   bool typeEquals(other) => other is HInterceptor;
   bool dataEquals(HInterceptor other) {
     return interceptedClasses == other.interceptedClasses
         || (interceptedClasses.length == other.interceptedClasses.length
             && interceptedClasses.containsAll(other.interceptedClasses));
   }
 }
 
+/**
+ * A "one-shot" interceptor is a call to a synthetized method that
+ * will fetch the interceptor of its first parameter, and make a call
+ * on a given selector with the remaining parameters.
+ *
+ * In order to share the same optimizations with regular interceptor
+ * calls, this class extends [HInvokeDynamic] and also has the null
+ * constant as the first input.
+ */
+class HOneShotInterceptor extends HInvokeDynamic {
+  Set<ClassElement> interceptedClasses;
+  HOneShotInterceptor(Selector selector,
+                      List<HInstruction> inputs,
+                      this.interceptedClasses)
+      : super(selector, null, inputs, true) {
+    assert(inputs[0] is HConstant);
+    assert(inputs[0].guaranteedType == HType.NULL);
+  }
+
+  String toString() => 'one shot interceptor on $selector';
+  accept(HVisitor visitor) => visitor.visitOneShotInterceptor(this);
+}
+
 /** An [HLazyStatic] is a static that is initialized lazily at first read. */
 class HLazyStatic extends HInstruction {
   final Element element;
   HLazyStatic(this.element) : super(<HInstruction>[]) {
     // TODO(4931): The first access has side-effects, but we afterwards we
     // should be able to GVN.
     setAllSideEffects();
     setDependsOnSomething();
   }
 
@@ skipping 498 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }