Add support for type references to AccessSemantics.

pkg/analyzer2dart/lib/src/identifier_semantics.dart

 // Copyright (c) 2014, 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.
 
 /**
  * Code for classifying the semantics of identifiers appearing in a Dart file.
  */
 library analyzer2dart.identifierSemantics;
 
 import 'package:analyzer/analyzer.dart';
@@ skipping 40 matching lines @@
    */
   static const AccessKind STATIC_METHOD = const AccessKind._('STATIC_METHOD');
 
   /**
    * The destination of the access is a property getter/setter that is defined
    * statically within a class, or at top level within a library.
    */
   static const AccessKind STATIC_PROPERTY =
       const AccessKind._('STATIC_PROPERTY');
 
+  /**
+   * The destination of the access is a toplevel class.
+   */
+  static const AccessKind TOPLEVEL_CLASS =
+      const AccessKind._('TOPLEVEL_CLASS');
+
+  /**
+   * The destination of the access is a type parameter of the enclosing class.
+   */
+  static const AccessKind TYPE_PARAMETER =
+      const AccessKind._('TYPE_PARAMETER');
+
   final String name;
 
   String toString() => name;
 
   const AccessKind._(this.name);
 }
 
 /**
  * Data structure used to classify the semantics of a property access or method
  * or function invocation.
@@ skipping 13 matching lines @@
   /**
    * 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).
    */
   final Element element;
 
   /**
    * 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, or PARAMETER, or if the element
-   * being accessed is defined at toplevel within a library.
+   * 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.
    */
   final ClassElement classElement;
 
   // TODO(paulberry): would it also be useful to store the libraryElement?
 
   /**
@@ skipping 41 matching lines @@
   AccessSemantics.staticMethod(this.identifier, this.element, this.classElement,
       {this.isInvoke: false})
       : kind = AccessKind.STATIC_METHOD,
         target = null;
 
   AccessSemantics.staticProperty(this.identifier, this.element,
       this.classElement, {this.isInvoke: false})
       : kind = AccessKind.STATIC_PROPERTY,
         target = null;
 
+  AccessSemantics.toplevelClass(this.identifier, this.element)
+      : kind = AccessKind.TOPLEVEL_CLASS,
+        classElement = null,
+        isInvoke = false,
+        target = null;
+
+  AccessSemantics.typeParameter(this.identifier, this.element)
+      : kind = AccessKind.TYPE_PARAMETER,
+        classElement = null,
+        isInvoke = false,
+        target = null;
+
   /**
    * True if this is a read access to a property, or a method tear-off.  Note
    * that both [isRead] and [isWrite] will be true in the case of a
    * read-modify-write operation (e.g. "+=").
    */
   bool get isRead => !isInvoke && identifier.inGetterContext();
 
   /**
    * True if this is a write access to a property, or an (erroneous) attempt to
    * write to a method.  Note that both [isRead] and [isWrite] will be true in
@@ skipping 180 matching lines @@
     Element rhsElement = rhs.staticElement;
     if (lhsElement is PrefixElement) {
       if (rhsElement is PropertyAccessorElement) {
         if (rhsElement.isSynthetic) {
           return new AccessSemantics.staticField(rhs, rhsElement.variable, null);
         } else {
           return new AccessSemantics.staticProperty(rhs, rhsElement, null);
         }
       } else if (rhsElement is FunctionElement) {
         return new AccessSemantics.staticMethod(rhs, rhsElement, null);
+      } else if (rhsElement is ClassElement) {
+        return new AccessSemantics.toplevelClass(rhs, rhsElement);
       } else {
         return new AccessSemantics.dynamic(rhs, null);
       }
     } else if (lhsElement is ClassElement) {
       if (rhsElement is PropertyAccessorElement && rhsElement.isSynthetic) {
         return new AccessSemantics.staticField(
             rhs,
             rhsElement.variable,
             lhsElement);
       } else if (rhsElement is MethodElement) {
@@ skipping 28 matching lines @@
    * parent node before visiting this one.
    */
   @override
   AccessSemantics visitSimpleIdentifier(SimpleIdentifier node) {
     AstNode parent = node.parent;
     if (node.inDeclarationContext()) {
       // This identifier is a declaration, not a use.
       return null;
     }
     if (parent is TypeName) {
-      // TODO(paulberry): handle this case.  Or, perhaps it would be better to
-      // require clients not to visit the children of a TypeName when visiting
-      // the AST structure.
-      //
-      // TODO(paulberry): be sure to consider type literals, e.g.:
-      //   class A {}
-      //   var a = A;
+      // TODO(paulberry): do we need to handle this case?
       return null;
     }
     if ((parent is PropertyAccess && parent.propertyName == node) ||
         (parent is PrefixedIdentifier && parent.identifier == node) ||
         (parent is MethodInvocation && parent.methodName == node)) {
       // The access semantics are determined by the parent.
       return null;
     }
     // TODO(paulberry): handle PrefixElement.
     Element staticElement = node.staticElement;
@@ skipping 28 matching lines @@
       if (staticElement.enclosingElement is CompilationUnitElement) {
         return new AccessSemantics.staticMethod(node, staticElement, null);
       } else {
         return new AccessSemantics.localFunction(node, staticElement);
       }
     } else if (staticElement is MethodElement && staticElement.isStatic) {
       return new AccessSemantics.staticMethod(
           node,
           staticElement,
           staticElement.enclosingElement);
+    } else if (staticElement is TypeParameterElement) {
+      return new AccessSemantics.typeParameter(node, staticElement);
+    } else if (staticElement is ClassElement) {
+      return new AccessSemantics.toplevelClass(node, staticElement);

[Johnni Winther, 2014/11/11 12:49:45]

How do you handle 'dynamic' as a type literal?

[Paul Berry, 2014/11/11 13:22:34]

Whoops, I forgot to handle this case.  I also forgot to handle the case where
the thing being accessed is a top-level function typedef.

I'll follow up with another CL.

     }
     return new AccessSemantics.dynamic(node, null);
   }
 }