Introduce ClassLike, MemberLike, FieldLike and FunctionLike

pkg/compiler/lib/src/elements/elements.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.
 
 library elements;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../core_types.dart' show CoreClasses;
 import '../dart_types.dart';
 import '../ordered_typeset.dart' show OrderedTypeSet;
 import '../resolution/scope.dart' show Scope;
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../script.dart';
 import '../tokens/token.dart'
     show Token, isUserDefinableOperator, isMinusOperator;
 import '../tree/tree.dart';
 import '../util/characters.dart' show $_;
 import '../util/util.dart';
+import 'entities.dart';
 import 'visitor.dart' show ElementVisitor;
 
 part 'names.dart';
 
 const int STATE_NOT_STARTED = 0;
 const int STATE_STARTED = 1;
 const int STATE_DONE = 2;
 
 class ElementCategory {
   /**
@@ skipping 1007 matching lines @@
   /// element itself. For parameters, local variables and nested closures, the
   /// member context is the top level, static or instance member in which it is
   /// defined.
   MemberElement get memberContext;
 }
 
 /// A top-level, static or instance field or method, or a constructor.
 ///
 /// A [MemberElement] is the outermost executable element for any executable
 /// context.
-abstract class MemberElement extends Element implements ExecutableElement {
+abstract class MemberElement extends Element
+    implements ExecutableElement, MemberEntity {
   /// The local functions defined within this member.
   List<FunctionElement> get nestedClosures;
 
   /// The name of this member, taking privacy into account.
   Name get memberName;
 }
 
 /// A function, variable or parameter defined in an executable context.
 abstract class LocalElement extends Element
     implements AstElement, TypedElement, Local {}
@@ skipping 19 matching lines @@
 ///
 /// Parameters, local variables and local functions (can) define local entity
 /// and thus implement [Local] through [LocalElement]. For non-element locals,
 /// like `this` and boxes, specialized [Local] classes are created.
 ///
 /// Type variables can introduce locals in factories and constructors
 /// but since one type variable can introduce different locals in different
 /// factories and constructors it is not itself a [Local] but instead
 /// a non-element [Local] is created through a specialized class.
 // TODO(johnniwinther): Should [Local] have `isAssignable` or `type`?
+// TODO(johnniwinther): Move this to 'entities.dart' when it does not refer
+// to [ExecutableElement].
 abstract class Local extends Entity {
   /// The context in which this local is defined.
   ExecutableElement get executableContext;
 }
 
 /// A variable or parameter that is local to an executable context.
 ///
 /// The executable context is the [ExecutableElement] in which this variable
 /// is defined.
 abstract class LocalVariableElement extends VariableElement
     implements LocalElement {}
 
 /// A top-level, static or instance field.
-abstract class FieldElement extends VariableElement implements MemberElement {}
+abstract class FieldElement extends VariableElement
+    implements MemberElement, FieldEntity {}
 
 /// A parameter-like element of a function signature.
 ///
 /// If the function signature comes from a typedef or an inline function-typed
 /// parameter (e.g. the parameter 'f' in `method(void f())`), then its
 /// parameters are not real parameters in that they can take no argument and
 /// hold no value. Such parameter-like elements are modeled by [FormalElement].
 ///
 /// If the function signature comes from a function or constructor, its
 /// parameters are real parameters and are modeled by [ParameterElement].
@@ skipping 170 matching lines @@
     ASYNC_STAR
   ];
 
   /// Index to this marker within [values].
   ///
   /// Added to make [AsyncMarker] enum-like.
   int get index => values.indexOf(this);
 }
 
 /// A top level, static or instance function.
-abstract class MethodElement extends FunctionElement implements MemberElement {}
+abstract class MethodElement extends FunctionElement
+    implements MemberElement, FunctionEntity {}
 
 /// A local function or closure (anonymous local function).
 abstract class LocalFunctionElement extends FunctionElement
     implements LocalElement {}
 
 /// A constructor.
-abstract class ConstructorElement extends FunctionElement
-    implements MemberElement {
+abstract class ConstructorElement extends MethodElement {
   /// Returns `true` if [effectiveTarget] has been computed for this
   /// constructor.
   bool get hasEffectiveTarget;
 
   /// The effective target of this constructor, that is the non-redirecting
   /// constructor that is called on invocation of this constructor.
   ///
   /// Consider for instance this hierarchy:
   ///
   ///     class C { factory C.c() = D.d; }
@@ skipping 150 matching lines @@
    * the input source has used explicit type arguments.
    */
   GenericType get rawType;
 
   bool get isResolved;
 
   void ensureResolved(Resolution resolution);
 }
 
 abstract class ClassElement extends TypeDeclarationElement
-    implements ScopeContainerElement {
+    implements ScopeContainerElement, ClassEntity {
   /// The length of the longest inheritance path from [:Object:].
   int get hierarchyDepth;
 
   InterfaceType get rawType;
   InterfaceType get thisType;
   ClassElement get superclass;
 
   /// The direct supertype of this class.
   DartType get supertype;
 
@@ skipping 434 matching lines @@
   /// by a field.
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }