Implement dynamic function checks.

dart/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 50 matching lines @@
   R visitStringConcat(HStringConcat node);
   R visitStringify(HStringify node);
   R visitSubtract(HSubtract node);
   R visitSwitch(HSwitch node);
   R visitThis(HThis node);
   R visitThrow(HThrow node);
   R visitThrowExpression(HThrowExpression node);
   R visitTry(HTry node);
   R visitTypeConversion(HTypeConversion node);
   R visitTypeKnown(HTypeKnown node);
+  R visitReadTypeVariable(HReadTypeVariable node);
+  R visitFunctionType(HFunctionType node);
+  R visitVoidType(HVoidType node);
+  R visitInterfaceType(HInterfaceType node);
+  R visitDynamicType(HDynamicType node);
 }
 
 abstract class HGraphVisitor {
   visitDominatorTree(HGraph graph) {
     void visitBasicBlockAndSuccessors(HBasicBlock block) {
       visitBasicBlock(block);
       List dominated = block.dominatedBlocks;
       for (int i = 0; i < dominated.length; i++) {
         visitBasicBlockAndSuccessors(dominated[i]);
       }
@@ skipping 242 matching lines @@
   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);
   visitTry(HTry node) => visitControlFlow(node);
   visitIs(HIs 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 {
   // The first and last block of the sub-graph.
   final HBasicBlock start;
   final HBasicBlock end;
 
   const SubGraph(this.start, this.end);
 
   bool contains(HBasicBlock block) {
@@ skipping 433 matching lines @@
   static const int STATIC_TYPECODE = 21;
   static const int STATIC_STORE_TYPECODE = 22;
   static const int FIELD_GET_TYPECODE = 23;
   static const int TYPE_CONVERSION_TYPECODE = 24;
   static const int TYPE_KNOWN_TYPECODE = 25;
   static const int INVOKE_STATIC_TYPECODE = 26;
   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;
 
   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 163 matching lines @@
   }
 
   bool isPrimitiveOrNull(Compiler compiler) {
     return isIndexablePrimitive(compiler)
         || isNumberOrNull(compiler)
         || isBooleanOrNull(compiler)
         || isNull();
   }
 
   /**
-   * Type of the unstruction.
+   * Type of the instruction.
    */
   TypeMask instructionType;
 
   Selector get selector => null;
   HInstruction getDartReceiver(Compiler compiler) => null;
   bool onlyThrowsNSM() => false;
 
   bool isInBasicBlock() => block != null;
 
   bool gvnEquals(HInstruction other) {
@@ skipping 1760 matching lines @@
                        this.finallyBlock);
 
   HBasicBlock get start => body.start;
   HBasicBlock get end =>
       finallyBlock == null ? catchBlock.end : finallyBlock.end;
 
   bool accept(HStatementInformationVisitor visitor) =>
     visitor.visitTryInfo(this);
 }
 
-
-
 class HSwitchBlockInformation implements HStatementInformation {
   final HExpressionInformation expression;
   final List<HStatementInformation> statements;
   final TargetElement target;
   final List<LabelElement> labels;
 
   HSwitchBlockInformation(this.expression,
                           this.statements,
                           this.target,
                           this.labels);
 
   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);
 }
+
+class HReadTypeVariable extends HInstruction {
+  /// The type variable being read.
+  final TypeVariableType dartType;
+
+  final bool hasReceiver;
+
+  HReadTypeVariable(this.dartType,
+                    HInstruction receiver,
+                    TypeMask instructionType)
+      : hasReceiver = true,
+        super(<HInstruction>[receiver], instructionType) {
+    setUseGvn();
+  }
+
+  HReadTypeVariable.noReceiver(this.dartType,
+                               HInstruction typeArgument,
+                               TypeMask instructionType)
+      : hasReceiver = false,
+        super(<HInstruction>[typeArgument], instructionType) {
+    setUseGvn();
+  }
+
+  accept(HVisitor visitor) => visitor.visitReadTypeVariable(this);
+
+  bool canThrow() => false;
+
+  int typeCode() => HInstruction.READ_TYPE_VARIABLE_TYPECODE;
+  bool typeEquals(HInstruction other) => other is HReadTypeVariable;
+
+  bool dataEquals(HReadTypeVariable other) {
+    return dartType.element == other.dartType.element
+        && hasReceiver == other.hasReceiver;
+  }
+}
+
+abstract class HRuntimeType extends HInstruction {
+  final DartType dartType;
+
+  HRuntimeType(List<HInstruction> inputs,
+               this.dartType,
+               TypeMask instructionType)
+      : super(inputs, instructionType) {
+    setUseGvn();
+  }
+
+  bool canThrow() => false;
+
+  int typeCode() {
+    throw 'abstract method';
+  }
+
+  bool typeEquals(HInstruction other) {
+    throw 'abstract method';
+  }
+
+  bool dataEquals(HRuntimeType other) {
+    return dartType == other.dartType;
+  }
+}
+
+class HFunctionType extends HRuntimeType {
+  HFunctionType(List<HInstruction> inputs,
+                FunctionType dartType,
+                TypeMask instructionType)
+      : super(inputs, dartType, instructionType);
+
+  accept(HVisitor visitor) => visitor.visitFunctionType(this);
+
+  int typeCode() => HInstruction.FUNCTION_TYPE_TYPECODE;
+
+  bool typeEquals(HInstruction other) => other is HFunctionType;
+}
+
+class HVoidType extends HRuntimeType {
+  HVoidType(VoidType dartType, TypeMask instructionType)
+      : super(const <HInstruction>[], dartType, instructionType);
+
+  accept(HVisitor visitor) => visitor.visitVoidType(this);
+
+  int typeCode() => HInstruction.VOID_TYPE_TYPECODE;
+
+  bool typeEquals(HInstruction other) => other is HVoidType;
+}
+
+class HInterfaceType extends HRuntimeType {
+  HInterfaceType(List<HInstruction> inputs,
+                 InterfaceType dartType,
+                 TypeMask instructionType)
+      : super(inputs, dartType, instructionType);
+
+  accept(HVisitor visitor) => visitor.visitInterfaceType(this);
+
+  int typeCode() => HInstruction.INTERFACE_TYPE_TYPECODE;
+
+  bool typeEquals(HInstruction other) => other is HInterfaceType;
+}
+
+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;
+}