Move Entity and Local to entities.dart

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 CommonElements;
 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';
@@ skipping 91 matching lines @@
   static const ElementKind AMBIGUOUS =
       const ElementKind('ambiguous', ElementCategory.NONE);
   static const ElementKind WARN_ON_USE =
       const ElementKind('warn_on_use', ElementCategory.NONE);
   static const ElementKind ERROR =
       const ElementKind('error', ElementCategory.NONE);
 
   toString() => id;
 }
 
-/// Abstract interface for entities.
-///
-/// Implement this directly if the entity is not a Dart language entity.
-/// 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;
-}
-
 /**
  * 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 1020 matching lines @@
     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 {}
+    implements AstElement, TypedElement, Local {
+  ExecutableElement get executableContext;
+}
 
 /// A top level, static or instance field, a formal parameter or local variable.
 abstract class VariableElement extends ExecutableElement {
   @override
   VariableDefinitions get node;
 
   Expression get initializer;
 
   bool get hasConstant;
 
   /// The constant expression defining the (initial) value of the variable.
   ///
   /// If the variable is `const` the value is always non-null, possibly an
   /// [ErroneousConstantExpression], otherwise, the value is null when the
   /// initializer isn't a constant expression.
   ConstantExpression get constant;
 }
 
-/// An entity that defines a local entity (memory slot) in generated code.
-///
-/// 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, FieldEntity {}
@@ skipping 824 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;
 }