Instruction selection before removing HTypeKnown

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 visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
@@ skipping 20 matching lines @@
   R visitIndexAssign(HIndexAssign node);
   R visitInterceptor(HInterceptor node);
   R visitInvokeClosure(HInvokeClosure node);
   R visitInvokeDynamicGetter(HInvokeDynamicGetter node);
   R visitInvokeDynamicMethod(HInvokeDynamicMethod node);
   R visitInvokeDynamicSetter(HInvokeDynamicSetter node);
   R visitInvokeStatic(HInvokeStatic node);
   R visitInvokeSuper(HInvokeSuper node);
   R visitInvokeConstructorBody(HInvokeConstructorBody node);
   R visitIs(HIs node);
+  R visitIsViaInterceptor(HIsViaInterceptor node);
   R visitLazyStatic(HLazyStatic node);
   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);
@@ skipping 277 matching lines @@
   visitStatic(HStatic node) => visitInstruction(node);
   visitStaticStore(HStaticStore node) => visitInstruction(node);
   visitStringConcat(HStringConcat node) => visitInstruction(node);
   visitStringify(HStringify node) => visitInstruction(node);
   visitThis(HThis node) => visitParameterValue(node);
   visitThrow(HThrow node) => visitControlFlow(node);
   visitThrowExpression(HThrowExpression node) => visitInstruction(node);
   visitTruncatingDivide(HTruncatingDivide node) => visitBinaryArithmetic(node);
   visitTry(HTry node) => visitControlFlow(node);
   visitIs(HIs node) => visitInstruction(node);
+  visitIsViaInterceptor(HIsViaInterceptor node) => visitInstruction(node);
   visitTypeConversion(HTypeConversion node) => visitCheck(node);
   visitTypeKnown(HTypeKnown node) => visitCheck(node);
   visitReadTypeVariable(HReadTypeVariable node) => visitInstruction(node);
   visitFunctionType(HFunctionType node) => visitInstruction(node);
   visitVoidType(HVoidType node) => visitInstruction(node);
   visitInterfaceType(HInterfaceType node) => visitInstruction(node);
   visitDynamicType(HDynamicType node) => visitInstruction(node);
 }
 
 class SubGraph {
@@ skipping 446 matching lines @@
   static const int INDEX_TYPECODE = 27;
   static const int IS_TYPECODE = 28;
   static const int INVOKE_DYNAMIC_TYPECODE = 29;
   static const int SHIFT_RIGHT_TYPECODE = 30;
   static const int READ_TYPE_VARIABLE_TYPECODE = 31;
   static const int FUNCTION_TYPE_TYPECODE = 32;
   static const int VOID_TYPE_TYPECODE = 33;
   static const int INTERFACE_TYPE_TYPECODE = 34;
   static const int DYNAMIC_TYPE_TYPECODE = 35;
   static const int TRUNCATING_DIVIDE_TYPECODE = 36;
+  static const int IS_VIA_INTERCEPTOR_TYPECODE = 37;
 
   HInstruction(this.inputs, this.instructionType)
       : id = idCounter++, usedBy = <HInstruction>[] {
     assert(inputs.every((e) => e != null));
   }
 
   int get hashCode => id;
 
   bool useGvn() => _useGvn;
   void setUseGvn() { _useGvn = true; }
@@ skipping 416 matching lines @@
 
   /**
    * 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;
   }
 }
 
+/**
+ * Late instructions are used after the main optimization phases.  They capture
+ * codegen decisions just prior to generating JavaScript.
+ */
+abstract class HLateInstruction extends HInstruction {
+  HLateInstruction(List<HInstruction> inputs, TypeMask type)
+      : super(inputs, type);
+}
+
 class HBoolify extends HInstruction {
   HBoolify(HInstruction value, TypeMask type)
       : super(<HInstruction>[value], type) {
     setUseGvn();
   }
 
   accept(HVisitor visitor) => visitor.visitBoolify(this);
   int typeCode() => HInstruction.BOOLIFY_TYPECODE;
   bool typeEquals(other) => other is HBoolify;
   bool dataEquals(HInstruction other) => true;
@@ skipping 768 matching lines @@
   toString() => 'phi';
   accept(HVisitor visitor) => visitor.visitPhi(this);
 }
 
 abstract class HRelational extends HInvokeBinary {
   bool usesBoolifiedInterceptor = false;
   HRelational(left, right, selector, type) : super(left, right, selector, type);
 }
 
 class HIdentity extends HRelational {
+  // Cached codegen decision.
+  String singleComparisonOp;  // null, '===', '=='
+
   HIdentity(left, right, selector, type) : super(left, right, selector, type);
   accept(HVisitor visitor) => visitor.visitIdentity(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.identity;
   int typeCode() => HInstruction.IDENTITY_TYPECODE;
   bool typeEquals(other) => other is HIdentity;
   bool dataEquals(HInstruction other) => true;
 }
 
@@ skipping 297 matching lines @@
   int typeCode() => HInstruction.IS_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HIs;
 
   bool dataEquals(HIs other) {
     return typeExpression == other.typeExpression
         && kind == other.kind;
   }
 }
 
+/**
+ * HIsViaInterceptor is a late-stage instruction for a type test that can be
+ * done entirely on an interceptor.  It is not a HCheck because the checked
+ * input is not one of the inputs.
+ */
+class HIsViaInterceptor extends HLateInstruction {
+  final DartType typeExpression;
+   HIsViaInterceptor(this.typeExpression, HInstruction interceptor,
+                     TypeMask type)
+       : super(<HInstruction>[interceptor], type) {
+    setUseGvn();
+  }
+
+  HInstruction get interceptor => inputs[0];
+
+  accept(HVisitor visitor) => visitor.visitIsViaInterceptor(this);
+  toString() => "$interceptor is $typeExpression";
+  int typeCode() => HInstruction.IS_VIA_INTERCEPTOR_TYPECODE;
+  bool typeEquals(HInstruction other) => other is HIsViaInterceptor;
+  bool dataEquals(HIs other) {
+    return typeExpression == other.typeExpression;
+  }
+}
+
 class HTypeConversion extends HCheck {
   final DartType typeExpression;
   final int kind;
   final Selector receiverTypeCheckSelector;
   final bool contextIsTypeArguments;
   TypeMask checkedType;  // Not final because we refine it.
 
   static const int CHECKED_MODE_CHECK = 0;
   static const int ARGUMENT_TYPE_CHECK = 1;
   static const int CAST_TYPE_CHECK = 2;
@@ skipping 555 matching lines @@
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }