Refactor and clean up AccessSemantics

pkg/compiler/lib/src/resolution/access_semantics.dart

 // Copyright (c) 2015, 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.
 
 // TODO(johnniwinther): Temporarily copied from analyzer2dart. Merge when
 // we shared code with the analyzer and this semantic visitor is complete.
 
 /**
  * Code for classifying the semantics of identifiers appearing in a Dart file.
  */
@@ skipping 174 matching lines @@
   /// Read from a superclass where the getter is unresolved.
   UNRESOLVED_SUPER_GETTER,
   /// Read from a superclass getter and write to an unresolved setter.
   UNRESOLVED_SUPER_SETTER,
 }
 
 /**
  * Data structure used to classify the semantics of a property access or method
  * or function invocation.
  */
-class AccessSemantics {
+abstract class AccessSemantics {
   /**
    * The kind of access.
    */
   final AccessKind kind;
 
   /**
    * The element being accessed, if statically known.  This will be null if
    * [kind] is DYNAMIC or if the element is undefined (e.g. an attempt to
    * access a non-existent static method in a class).
    */
   Element get element => null;
 
-  /**
-   * The class containing the element being accessed, if this is a static
-   * reference to an element in a class.  This will be null if [kind] is
-   * DYNAMIC, LOCAL_FUNCTION, LOCAL_VARIABLE, PARAMETER, TOPLEVEL_CLASS, or
-   * TYPE_PARAMETER, or if the element being accessed is defined at toplevel
-   * within a library.
-   *
-   * Note: it is possible for [classElement] to be non-null and for [element]
-   * to be null; for example this occurs if the element being accessed is a
-   * non-existent static method or field inside an existing class.
-   */
-  ClassElement get classElement => null;
-
-  // TODO(paulberry): would it also be useful to store the libraryElement?
-
-  // TODO(johnniwinther): Do we need this?
-  /**
-   * When [kind] is DYNAMIC_PROPERTY, the expression whose runtime type
-   * determines the class in which [identifier] should be looked up.
-   *
-   * When [kind] is not DYNAMIC_PROPERTY, this field is always null.
-   */
-  /*Expression*/ get target => null;
-
   ConstantExpression get constant => null;
 
   /// The element for the getter in case of a compound access,
   /// [element] otherwise.
   Element get getter => element;
 
   /// The element for the setter in case of a compound access,
   /// [element] otherwise.
   Element get setter => element;
 
   // TODO(johnniwinther): Make access semantics getter/setter specific.
   /// `true` if the [element] of this access is accessed statically.
   bool get isAccessedStatically => false;
 
-  AccessSemantics.expression()
-      : kind = AccessKind.EXPRESSION;
-
-  AccessSemantics.thisAccess()
-      : kind = AccessKind.THIS;
-
-  AccessSemantics.thisProperty()
-      : kind = AccessKind.THIS_PROPERTY;
-
-  AccessSemantics._(this.kind);
+  const AccessSemantics._(this.kind);
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('AccessSemantics[');
     sb.write('kind=$kind,');
     if (element != null) {
       sb.write('element=');
-      if (classElement != null) {
-        sb.write('${classElement.name}.');
+      if (element.enclosingClass != null) {
+        sb.write('${element.enclosingClass.name}.');
       }
       sb.write('${element}');
     }
     sb.write(']');
     return sb.toString();
   }
 }
 
 
 class DynamicAccess extends AccessSemantics {
-  final target;
+  const DynamicAccess.expression()
+      : super._(AccessKind.EXPRESSION);
 
-  DynamicAccess.dynamicProperty(this.target)
+  const DynamicAccess.thisAccess()
+      : super._(AccessKind.THIS);
+
+  const DynamicAccess.thisProperty()
+      : super._(AccessKind.THIS_PROPERTY);
+
+  const DynamicAccess.dynamicProperty()
       : super._(AccessKind.DYNAMIC_PROPERTY);
 
-  DynamicAccess.ifNotNullProperty(this.target)
+  const DynamicAccess.ifNotNullProperty()
       : super._(AccessKind.CONDITIONAL_DYNAMIC_PROPERTY);
 
   bool get isAccessedStatically => false;
 }
 
 class ConstantAccess extends AccessSemantics {
   final ConstantExpression constant;
 
   ConstantAccess(AccessKind kind, this.constant)
       : super._(kind);
 
   ConstantAccess.classTypeLiteral(this.constant)
       : super._(AccessKind.CLASS_TYPE_LITERAL);
 
   ConstantAccess.typedefTypeLiteral(this.constant)
       : super._(AccessKind.TYPEDEF_TYPE_LITERAL);
 
   ConstantAccess.dynamicTypeLiteral(this.constant)
       : super._(AccessKind.DYNAMIC_TYPE_LITERAL);
 
   bool get isAccessedStatically => false;
 }
 
 class StaticAccess extends AccessSemantics {
   final Element element;
 
-  ClassElement get classElement => element.enclosingClass;
-
   StaticAccess._(AccessKind kind, this.element)
       : super._(kind);
 
   StaticAccess.superSetter(MethodElement this.element)
       : super._(AccessKind.SUPER_SETTER);
 
   StaticAccess.superField(FieldElement this.element)
       : super._(AccessKind.SUPER_FIELD);
 
   StaticAccess.superFinalField(FieldElement this.element)
@@ skipping 251 matching lines @@
 
   RedirectingFactoryConstructorAccessSemantics(
       ConstructorAccessKind kind,
       Element element,
       DartType type,
       this.effectiveTargetSemantics)
       : super(kind, element, type);
 }