Introduce ClassLike, MemberLike, FieldLike and FunctionLike

pkg/compiler/lib/src/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.
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../dart_types.dart';
-import '../elements/elements.dart';
+import '../elements/elements.dart'
+    show Entity, JumpTarget, LabelDefinition, Local;
+import '../elements/entities.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
 import '../native/native.dart' as native;
 import '../tree/dartstring.dart' as ast;
 import '../types/constants.dart' show computeTypeMask;
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
@@ skipping 125 matching lines @@
         assert(instruction != list.first);
       }
     }
 
     currentBlock = node;
     visitInstructionList(node);
   }
 }
 
 class HGraph {
-  Element element; // Used for debug printing.
+  // TODO(johnniwinther): Maybe this should be [MemberLike].
+  Entity element; // Used for debug printing.
   HBasicBlock entry;
   HBasicBlock exit;
   HThis thisInstruction;
 
   /// Receiver parameter, set for methods using interceptor calling convention.
   HParameterValue explicitReceiverParameter;
   bool isRecursiveMethod = false;
   bool calledInLoop = false;
   final List<HBasicBlock> blocks = <HBasicBlock>[];
 
@@ skipping 49 matching lines @@
         ..sourceInformation = sourceInformation;
       entry.addAtExit(result);
       constants[constant] = result;
     } else if (result.block == null) {
       // The constant was not used anymore.
       entry.addAtExit(result);
     }
     return result;
   }
 
-  HConstant addDeferredConstant(ConstantValue constant, PrefixElement prefix,
+  HConstant addDeferredConstant(ConstantValue constant, Entity prefix,
       SourceInformation sourceInformation, Compiler compiler) {
-    // TODO(sigurdm,johnniwinter): These deferred constants should be created
+    // TODO(sigurdm,johnniwinther): These deferred constants should be created
     // by the constant evaluator.
     ConstantValue wrapper = new DeferredConstantValue(constant, prefix);
     compiler.deferredLoadTask.registerConstantDeferredUse(wrapper, prefix);
     return addConstant(wrapper, compiler, sourceInformation: sourceInformation);
   }
 
   HConstant addConstantInt(int i, Compiler compiler) {
     return addConstant(compiler.backend.constantSystem.createInt(i), compiler);
   }
 
@@ skipping 681 matching lines @@
   bool isValue() => instructionType.isValue;
 
   bool canBeNull() => instructionType.isNullable;
 
   bool isNull() => instructionType.isNull;
 
   bool isConflicting() => instructionType.isEmpty;
 
   /// Returns `true` if [typeMask] contains [cls].
   static bool containsType(
-      TypeMask typeMask, ClassElement cls, ClosedWorld closedWorld) {
+      TypeMask typeMask, ClassEntity cls, ClosedWorld closedWorld) {
     return closedWorld.isInstantiated(cls) &&
         typeMask.contains(cls, closedWorld);
   }
 
   /// Returns `true` if [typeMask] contains only [cls].
   static bool containsOnlyType(
-      TypeMask typeMask, ClassElement cls, ClosedWorld closedWorld) {
+      TypeMask typeMask, ClassEntity cls, ClosedWorld closedWorld) {
     return closedWorld.isInstantiated(cls) && typeMask.containsOnly(cls);
   }
 
   /// Returns `true` if [typeMask] is an instance of [cls].
   static bool isInstanceOf(
-      TypeMask typeMask, ClassElement cls, ClosedWorld closedWorld) {
+      TypeMask typeMask, ClassEntity cls, ClosedWorld closedWorld) {
     return closedWorld.isImplemented(cls) &&
         typeMask.satisfies(cls, closedWorld);
   }
 
   bool canBePrimitive(Compiler compiler) {
     return canBePrimitiveNumber(compiler) ||
         canBePrimitiveArray(compiler) ||
         canBePrimitiveBoolean(compiler) ||
         canBePrimitiveString(compiler) ||
         isNull();
@@ skipping 405 matching lines @@
     }
     return false;
   }
 
   HInstruction convertType(Compiler compiler, DartType type, int kind) {
     if (type == null) return this;
     type = type.unaliased;
     // Only the builder knows how to create [HTypeConversion]
     // instructions with generics. It has the generic type context
     // available.
-    assert(type.kind != TypeKind.TYPE_VARIABLE);
+    assert(!type.isTypeVariable);
     assert(type.treatAsRaw || type.isFunctionType);
     if (type.isDynamic) return this;
     if (type.isObject) return this;
     // The type element is either a class or the void element.
-    Element element = type.element;
     JavaScriptBackend backend = compiler.backend;
-    if (type.kind != TypeKind.INTERFACE) {
+    if (type.isVoid || type.isFunctionType) {
       return new HTypeConversion(type, kind, backend.dynamicType, this);
-    } else if (kind == HTypeConversion.BOOLEAN_CONVERSION_CHECK) {
+    }
+    assert(type.isInterfaceType);
+    if (kind == HTypeConversion.BOOLEAN_CONVERSION_CHECK) {
       // Boolean conversion checks work on non-nullable booleans.
       return new HTypeConversion(type, kind, backend.boolType, this);
     } else if (kind == HTypeConversion.CHECKED_MODE_CHECK && !type.treatAsRaw) {
       throw 'creating compound check to $type (this = ${this})';
     } else {
-      TypeMask subtype =
-          new TypeMask.subtype(element.declaration, compiler.closedWorld);
+      Entity cls = type.element;
+      TypeMask subtype = new TypeMask.subtype(cls, compiler.closedWorld);
       return new HTypeConversion(type, kind, subtype, this);
     }
   }
 
   /**
    * 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;
@@ skipping 103 matching lines @@
 }
 
 abstract class HControlFlow extends HInstruction {
   HControlFlow(inputs) : super(inputs, const TypeMask.nonNullEmpty());
   bool isControlFlow() => true;
   bool isJsStatement() => true;
 }
 
 // Allocates and initializes an instance.
 class HCreate extends HInstruction {
-  final ClassElement element;
+  final ClassEntity element;
 
   /// Does this instruction have reified type information as the last input?
   final bool hasRtiInput;
 
   /// If this field is not `null`, this call is from an inlined constructor and
   /// we have to register the instantiated type in the code generator. The
   /// [instructionType] of this node is not enough, because we also need the
   /// type arguments. See also [SsaFromAstMixin.currentInlinedInstantiations].
   List<DartType> instantiatedTypes;
 
@@ skipping 34 matching lines @@
     // calling convention, which adds the actual receiver as a
     // parameter to the call.
     return (selector != null) && (inputs.length - 2 == selector.argumentCount);
   }
 }
 
 abstract class HInvokeDynamic extends HInvoke {
   final InvokeDynamicSpecializer specializer;
   Selector selector;
   TypeMask mask;
-  Element element;
+  MemberEntity element;
 
   HInvokeDynamic(Selector selector, this.mask, this.element,
       List<HInstruction> inputs, TypeMask type,
       [bool isIntercepted = false])
       : super(inputs, type),
         this.selector = selector,
         specializer = isIntercepted
             ? InvokeDynamicSpecializer.lookupSpecializer(selector)
             : const InvokeDynamicSpecializer();
   toString() => 'invoke dynamic: selector=$selector, mask=$mask';
@@ skipping 32 matching lines @@
   HInvokeDynamicMethod(Selector selector, TypeMask mask,
       List<HInstruction> inputs, TypeMask type,
       [bool isIntercepted = false])
       : super(selector, mask, null, inputs, type, isIntercepted);
 
   String toString() => 'invoke dynamic method: selector=$selector, mask=$mask';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicMethod(this);
 }
 
 abstract class HInvokeDynamicField extends HInvokeDynamic {
-  HInvokeDynamicField(Selector selector, TypeMask mask, Element element,
+  HInvokeDynamicField(Selector selector, TypeMask mask, MemberEntity element,
       List<HInstruction> inputs, TypeMask type)
       : super(selector, mask, element, inputs, type);
   toString() => 'invoke dynamic field: selector=$selector, mask=$mask';
 }
 
 class HInvokeDynamicGetter extends HInvokeDynamicField {
-  HInvokeDynamicGetter(Selector selector, TypeMask mask, Element element,
+  HInvokeDynamicGetter(Selector selector, TypeMask mask, MemberEntity element,
       List<HInstruction> inputs, TypeMask type)
       : super(selector, mask, element, inputs, type);
   toString() => 'invoke dynamic getter: selector=$selector, mask=$mask';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicGetter(this);
 
   bool get isTearOff => element != null && element.isFunction;
 
   // There might be an interceptor input, so `inputs.last` is the dart receiver.
   bool canThrow() => isTearOff ? inputs.last.canBeNull() : super.canThrow();
 }
 
 class HInvokeDynamicSetter extends HInvokeDynamicField {
-  HInvokeDynamicSetter(Selector selector, TypeMask mask, Element element,
+  HInvokeDynamicSetter(Selector selector, TypeMask mask, MemberEntity element,
       List<HInstruction> inputs, TypeMask type)
       : super(selector, mask, element, inputs, type);
   toString() => 'invoke dynamic setter: selector=$selector, mask=$mask';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicSetter(this);
 }
 
 class HInvokeStatic extends HInvoke {
-  final Element element;
+  final MemberEntity element;
 
   final bool targetCanThrow;
 
   bool canThrow() => targetCanThrow;
 
   /// If this instruction is a call to a constructor, [instantiatedTypes]
   /// contains the type(s) used in the (Dart) `New` expression(s). The
   /// [instructionType] of this node is not enough, because we also need the
   /// type arguments. See also [SsaFromAstMixin.currentInlinedInstantiations].
   List<DartType> instantiatedTypes;
 
   /** The first input must be the target. */
   HInvokeStatic(this.element, inputs, TypeMask type,
       {this.targetCanThrow: true})
       : super(inputs, type);
 
   toString() => 'invoke static: $element';
   accept(HVisitor visitor) => visitor.visitInvokeStatic(this);
   int typeCode() => HInstruction.INVOKE_STATIC_TYPECODE;
 }
 
 class HInvokeSuper extends HInvokeStatic {
   /** The class where the call to super is being done. */
-  final ClassElement caller;
+  final ClassEntity caller;
   final bool isSetter;
   final Selector selector;
 
-  HInvokeSuper(Element element, this.caller, this.selector, inputs, type,
+  HInvokeSuper(MemberEntity element, this.caller, this.selector, inputs, type,
       SourceInformation sourceInformation,
       {this.isSetter})
       : super(element, inputs, type) {
     this.sourceInformation = sourceInformation;
   }
 
   HInstruction get receiver => inputs[0];
   HInstruction getDartReceiver(Compiler compiler) {
     return isCallOnInterceptor(compiler) ? inputs[1] : inputs[0];
   }
@@ skipping 19 matching lines @@
   // The 'inputs' are
   //     [receiver, arg1, ..., argN] or
   //     [interceptor, receiver, arg1, ... argN].
   HInvokeConstructorBody(element, inputs, type) : super(element, inputs, type);
 
   String toString() => 'invoke constructor body: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeConstructorBody(this);
 }
 
 abstract class HFieldAccess extends HInstruction {
-  final Element element;
+  // TODO(johnniwinther): This should be a [FieldLike] but JSIndexable.length is
+  // encoded using a [HFieldGet].
+  final MemberEntity element;
 
-  HFieldAccess(Element element, List<HInstruction> inputs, TypeMask type)
-      : this.element = element,
-        super(inputs, type);
+  HFieldAccess(this.element, List<HInstruction> inputs, TypeMask type)
+      : super(inputs, type);
 
   HInstruction get receiver => inputs[0];
 }
 
 class HFieldGet extends HFieldAccess {
   final bool isAssignable;
 
-  HFieldGet(Element element, HInstruction receiver, TypeMask type,
+  HFieldGet(MemberEntity element, HInstruction receiver, TypeMask type,
       {bool isAssignable})
       : this.isAssignable =
             (isAssignable != null) ? isAssignable : element.isAssignable,
         super(element, <HInstruction>[receiver], type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     setUseGvn();
     if (this.isAssignable) {
       sideEffects.setDependsOnInstancePropertyStore();
     }
@@ skipping 20 matching lines @@
 
   accept(HVisitor visitor) => visitor.visitFieldGet(this);
 
   int typeCode() => HInstruction.FIELD_GET_TYPECODE;
   bool typeEquals(other) => other is HFieldGet;
   bool dataEquals(HFieldGet other) => element == other.element;
   String toString() => "FieldGet $element";
 }
 
 class HFieldSet extends HFieldAccess {
-  HFieldSet(Element element, HInstruction receiver, HInstruction value)
+  HFieldSet(MemberEntity element, HInstruction receiver, HInstruction value)
       : super(element, <HInstruction>[receiver, value],
             const TypeMask.nonNullEmpty()) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     sideEffects.setChangesInstanceProperty();
   }
 
   bool canThrow() => receiver.canBeNull();
 
   HInstruction getDartReceiver(Compiler compiler) => receiver;
   bool onlyThrowsNSM() => true;
 
   HInstruction get value => inputs[1];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
   bool isJsStatement() => true;
   String toString() => "FieldSet $element";
 }
 
 /**
  * HReadModifyWrite is a late stage instruction for a field (property) update
  * via an assignment operation or pre- or post-increment.
  */
 class HReadModifyWrite extends HLateInstruction {
   static const ASSIGN_OP = 0;
   static const PRE_OP = 1;
   static const POST_OP = 2;
-  final Element element;
+  final FieldEntity element;
   final String jsOp;
   final int opKind;
 
-  HReadModifyWrite._(Element this.element, this.jsOp, this.opKind,
+  HReadModifyWrite._(this.element, this.jsOp, this.opKind,
       List<HInstruction> inputs, TypeMask type)
       : super(inputs, type) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     sideEffects.setChangesInstanceProperty();
     sideEffects.setDependsOnInstancePropertyStore();
   }
 
-  HReadModifyWrite.assignOp(Element element, String jsOp, HInstruction receiver,
-      HInstruction operand, TypeMask type)
+  HReadModifyWrite.assignOp(FieldEntity element, String jsOp,
+      HInstruction receiver, HInstruction operand, TypeMask type)
       : this._(
             element, jsOp, ASSIGN_OP, <HInstruction>[receiver, operand], type);
 
   HReadModifyWrite.preOp(
-      Element element, String jsOp, HInstruction receiver, TypeMask type)
+      FieldEntity element, String jsOp, HInstruction receiver, TypeMask type)
       : this._(element, jsOp, PRE_OP, <HInstruction>[receiver], type);
 
   HReadModifyWrite.postOp(
-      Element element, String jsOp, HInstruction receiver, TypeMask type)
+      FieldEntity element, String jsOp, HInstruction receiver, TypeMask type)
       : this._(element, jsOp, POST_OP, <HInstruction>[receiver], type);
 
   HInstruction get receiver => inputs[0];
 
   bool get isPreOp => opKind == PRE_OP;
   bool get isPostOp => opKind == POST_OP;
   bool get isAssignOp => opKind == ASSIGN_OP;
 
   bool canThrow() => receiver.canBeNull();
 
@@ skipping 668 matching lines @@
   HThrow(HInstruction value, SourceInformation sourceInformation,
       {this.isRethrow: false})
       : super(<HInstruction>[value]) {
     this.sourceInformation = sourceInformation;
   }
   toString() => 'throw';
   accept(HVisitor visitor) => visitor.visitThrow(this);
 }
 
 class HStatic extends HInstruction {
-  final Element element;
+  final MemberEntity element;
   HStatic(this.element, type) : super(<HInstruction>[], type) {
     assert(element != null);
-    assert(invariant(this, element.isDeclaration));
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     if (element.isAssignable) {
       sideEffects.setDependsOnStaticPropertyStore();
     }
     setUseGvn();
   }
   toString() => 'static ${element.name}';
   accept(HVisitor visitor) => visitor.visitStatic(this);
 
   int gvnHashCode() => super.gvnHashCode() ^ element.hashCode;
   int typeCode() => HInstruction.STATIC_TYPECODE;
   bool typeEquals(other) => other is HStatic;
   bool dataEquals(HStatic other) => element == other.element;
   bool isCodeMotionInvariant() => !element.isAssignable;
 }
 
 class HInterceptor extends HInstruction {
   // This field should originally be null to allow GVN'ing all
   // [HInterceptor] on the same input.
-  Set<ClassElement> interceptedClasses;
+  Set<ClassEntity> interceptedClasses;
 
   // inputs[0] is initially the only input, the receiver.
 
   // inputs[1] is a constant interceptor when the interceptor is a constant
   // except for a `null` receiver.  This is used when the receiver can't be
   // falsy, except for `null`, allowing the generation of code like
   //
   //     (a && C.JSArray_methods).get$first(a)
   //
 
@@ skipping 30 matching lines @@
 /**
  * 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;
+  Set<ClassEntity> interceptedClasses;
   HOneShotInterceptor(Selector selector, TypeMask mask,
       List<HInstruction> inputs, TypeMask type, this.interceptedClasses)
       : super(selector, mask, null, inputs, type, true) {
     assert(inputs[0] is HConstant);
     assert(inputs[0].isNull());
   }
   bool isCallOnInterceptor(Compiler compiler) => true;
 
   String toString() => 'one shot interceptor: selector=$selector, mask=$mask';
   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;
+  final FieldEntity element;
   HLazyStatic(this.element, type) : super(<HInstruction>[], type) {
     // TODO(4931): The first access has side-effects, but we afterwards we
     // should be able to GVN.
     sideEffects.setAllSideEffects();
     sideEffects.setDependsOnSomething();
   }
 
   toString() => 'lazy static ${element.name}';
   accept(HVisitor visitor) => visitor.visitLazyStatic(this);
 
   int typeCode() => 30;
   // TODO(4931): can we do better here?
   bool isCodeMotionInvariant() => false;
   bool canThrow() => true;
 }
 
 class HStaticStore extends HInstruction {
-  Element element;
+  MemberEntity element;
   HStaticStore(this.element, HInstruction value)
       : super(<HInstruction>[value], const TypeMask.nonNullEmpty()) {
     sideEffects.clearAllSideEffects();
     sideEffects.clearAllDependencies();
     sideEffects.setChangesStaticProperty();
   }
   toString() => 'static store ${element.name}';
   accept(HVisitor visitor) => visitor.visitStaticStore(this);
 
   int typeCode() => HInstruction.STATIC_STORE_TYPECODE;
@@ skipping 845 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;
 }