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';
@@ skipping 110 matching lines @@
 /// Entities defined within the Dart language should implement [Element].
 ///
 /// For instance, the JavaScript backend need to create synthetic variables for
 /// calling intercepted classes and such variables do not correspond to an
 /// entity in the Dart source code nor in the terminology of the Dart language
 /// and should therefore implement [Entity] directly.
 abstract class Entity implements Spannable {
   String get name;
 }
 
+/// Stripped down super interface for class like entities.
+///
+/// Currently only [ClassElement] but later also kernel based Dart classes
+/// and/or Dart-in-JS classes.
+abstract class ClassLike extends Entity {

[Siggi Cherem (dart-lang), 2016/11/03 00:52:30]

maybe it is too early to tell, but how much from ClassElement do you think we'll
end up having here in the end?

[Johnni Winther, 2016/11/03 09:55:06]

Not much: I plan to move most queries on relations to other entities (like
sub/superrelation, members) into [ClosedWorld] and similar.

+  bool get isClosure;
+  void forEachInstanceField(f(ClassLike cls, FieldLike field),
+      {bool includeSuperAndInjectedMembers: false});
+}
+
+/// Stripped down super interface for member like entities, that is,
+/// constructors, methods, fields etc.
+///
+/// Currently only [MemberElement] but later also kernel based Dart members
+/// and/or Dart-in-JS properties.
+abstract class MemberLike extends Entity {
+  bool get isField;
+  bool get isFunction;
+  bool get isGetter;
+  bool get isAssignable;
+  ClassLike get enclosingClass;
+}
+
+/// Stripped down super interface for field like entities.
+///
+/// Currently only [FieldElement] but later also kernel based Dart fields
+/// and/or Dart-in-JS field-like properties.
+abstract class FieldLike extends MemberLike {}
+
+/// Stripped down super interface for function like entities.
+///
+/// Currently only [FieldElement] but later also kernel based Dart constructors
+/// and methods and/or Dart-in-JS function-like properties.
+abstract class FunctionLike extends MemberLike {}

[Siggi Cherem (dart-lang), 2016/11/03 00:52:30]

I'm not yet convinced on using the "XLike" names :)

Other ideas:
- overload "Class, Member, Field", (or ClassElement, MemberELement, ...), move
them to a new library (e.g. new_elements), and always use them with a prefix
(e.g. n)
- use the "Entity" suffix instead? (e.g. "ClassEntity")

[Johnni Winther, 2016/11/03 09:55:06]

Moved to 'entities.dart', use 'Entity' as suffix.

+
 /**
  * A declared element of a program.
  *
  * The declared elements of a program include classes, methods,
  * fields, variables, parameters, etc.
  *
  * Sometimes it makes sense to construct "synthetic" elements that
  * have not been declared anywhere in a program, for example, there
  * are elements corresponding to "dynamic", "null", and unresolved
  * references.
@@ skipping 899 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, MemberLike {
   /// 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 32 matching lines @@
 }
 
 /// 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, FieldLike {}
 
 /// 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, FunctionLike {}
 
 /// 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, ClassLike {
   /// 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;
 }