Fix summarization of unqualified references to class members.

pkg/analyzer/lib/src/summary/summarize_ast.dart

 // Copyright (c) 2016, 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 serialization.summarize_ast;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
@@ skipping 58 matching lines @@
       int nameRef =
           visitor.serializeReference(typeBuilder.reference, name.name);
       return new EntityRefBuilder(
           reference: nameRef, typeArguments: typeBuilder.typeArguments);
     }
   }
 
   EntityRefBuilder serializeIdentifier(Identifier identifier) {
     EntityRefBuilder b = new EntityRefBuilder();
     if (identifier is SimpleIdentifier) {
-      b.reference = visitor.serializeReference(null, identifier.name);
+      b.reference = visitor.serializeSimpleReference(identifier.name);
     } else if (identifier is PrefixedIdentifier) {
-      int prefix = visitor.serializeReference(null, identifier.prefix.name);
+      int prefix = visitor.serializeSimpleReference(identifier.prefix.name);
       b.reference =
           visitor.serializeReference(prefix, identifier.identifier.name);
     } else {
       throw new StateError(
           'Unexpected identifier type: ${identifier.runtimeType}');
     }
     return b;
   }
 
   @override
@@ skipping 10 matching lines @@
     }
   }
 
   @override
   EntityRefBuilder serializeType(TypeName node) {
     return visitor.serializeTypeName(node);
   }
 }
 
 /**
- * An [_OtherScopedEntity] is a [_ScopedEntity] that does not refer to a type
- * parameter.  Since we don't need to track any special information about these
- * types of scoped entities, it is a singleton class.
- */
-class _OtherScopedEntity extends _ScopedEntity {
-  static final _OtherScopedEntity _instance = new _OtherScopedEntity._();
-
-  factory _OtherScopedEntity() => _instance;
-
-  _OtherScopedEntity._();
-}
-
-/**
  * A [_Scope] represents a set of name/value pairs defined locally within a
  * limited span of a compilation unit.  (Note that the spec also uses the term
  * "scope" to refer to the set of names defined at top level within a
  * compilation unit, but we do not use [_Scope] for that purpose).
  */
 class _Scope {
   /**
    * Names defined in this scope, and their meanings.
    */
   Map<String, _ScopedEntity> _definedNames = <String, _ScopedEntity>{};
 
   /**
    * Look up the meaning associated with the given [name], and return it.  If
    * [name] is not defined in this scope, return `null`.
    */
   _ScopedEntity operator [](String name) => _definedNames[name];
 
   /**
    * Let the given [name] refer to [entity] within this scope.
    */
   void operator []=(String name, _ScopedEntity entity) {
     _definedNames[name] = entity;
   }
 }
 
 /**
+ * A [_ScopedClassMember] is a [_ScopedEntity] refers to a member of a class.
+ */
+class _ScopedClassMember extends _ScopedEntity {
+  /**
+   * The name of the class.
+   */
+  final String className;
+
+  _ScopedClassMember(this.className);
+}
+
+/**
  * Base class for entities that can live inside a scope.
  */
 abstract class _ScopedEntity {}
 
 /**
  * A [_ScopedTypeParameter] is a [_ScopedEntity] that refers to a type
  * parameter of a class, typedef, or executable.
  */
 class _ScopedTypeParameter extends _ScopedEntity {
   /**
@@ skipping 63 matching lines @@
       <UnlinkedReferenceBuilder>[new UnlinkedReferenceBuilder()];
 
   /**
    * Map associating names used as prefixes in this compilation unit with their
    * associated indices into [UnlinkedUnit.references].
    */
   final Map<String, int> prefixIndices = <String, int>{};
 
   /**
    * List of [_Scope]s currently in effect.  This is used to resolve type names
-   * to type parameters within classes, typedefs, and executables.
+   * to type parameters within classes, typedefs, and executables, as well as
+   * references to class members.
    */
   final List<_Scope> scopes = <_Scope>[];
 
   /**
    * True if 'dart:core' has been explicitly imported.
    */
   bool hasCoreBeenImported = false;
 
   /**
    * Names referenced by this compilation unit.  Structured as a map from
@@ skipping 47 matching lines @@
 
   /**
    * Create a slot id for storing a propagated or inferred type.
    */
   int assignTypeSlot() => ++numSlots;
 
   /**
    * Build a [_Scope] object containing the names defined within the body of a
    * class declaration.
    */
-  _Scope buildClassMemberScope(NodeList<ClassMember> members) {
+  _Scope buildClassMemberScope(
+      String className, NodeList<ClassMember> members) {
     _Scope scope = new _Scope();
     for (ClassMember member in members) {
       // TODO(paulbery): consider replacing these if-tests with dynamic method
       // dispatch.
       if (member is MethodDeclaration) {
         if (member.isSetter || member.isOperator) {
           // We don't have to handle setters or operators because the only
-          // thing we look up is type names.
+          // things we look up are type names and identifiers.
         } else {
-          scope[member.name.name] = new _OtherScopedEntity();
+          scope[member.name.name] = new _ScopedClassMember(className);
         }
       } else if (member is FieldDeclaration) {
         for (VariableDeclaration field in member.fields.variables) {
           // A field declaration introduces two names, one with a trailing `=`.
           // We don't have to worry about the one with a trailing `=` because
-          // the only thing we look up is type names.
-          scope[field.name.name] = new _OtherScopedEntity();
+          // the only things we look up are type names and identifiers.
+          scope[field.name.name] = new _ScopedClassMember(className);
         }
       }
     }
     return scope;
   }
 
   /**
    * Serialize the given list of [annotations].  If there are no annotations,
    * the empty list is returned.
    */
@@ skipping 42 matching lines @@
       b.supertype = serializeTypeName(superclass);
     }
     if (withClause != null) {
       b.mixins = withClause.mixinTypes.map(serializeTypeName).toList();
     }
     if (implementsClause != null) {
       b.interfaces =
           implementsClause.interfaces.map(serializeTypeName).toList();
     }
     if (members != null) {
-      scopes.add(buildClassMemberScope(members));
+      scopes.add(buildClassMemberScope(name, members));
       for (ClassMember member in members) {
         member.accept(this);
       }
       scopes.removeLast();
     }
     b.executables = executables;
     b.fields = variables;
     b.isAbstract = abstractKeyword != null;
     b.documentationComment = serializeDocumentation(documentationComment);
     b.annotations = serializeAnnotations(annotations);
@@ skipping 193 matching lines @@
   int serializeReference(int prefixIndex, String name) => nameToReference
           .putIfAbsent(prefixIndex, () => <String, int>{})
           .putIfAbsent(name, () {
         int index = unlinkedReferences.length;
         unlinkedReferences.add(new UnlinkedReferenceBuilder(
             prefixReference: prefixIndex, name: name));
         return index;
       });
 
   /**
+   * Serialize a reference to a name declared either at top level or in a
+   * nested scope.
+   */
+  int serializeSimpleReference(String name) {
+    for (int i = scopes.length - 1; i >= 0; i--) {
+      _Scope scope = scopes[i];
+      _ScopedEntity entity = scope[name];
+      if (entity != null) {
+        if (entity is _ScopedClassMember) {
+          return serializeReference(
+              serializeReference(null, entity.className), name);
+        } else {
+          // Invalid reference to a type parameter.  Should never happen in
+          // legal Dart code.
+          // TODO(paulberry): could this exception ever be uncaught in illegal
+          // code?
+          throw new StateError('Invalid identifier reference');
+        }
+      }
+    }
+    return serializeReference(null, name);
+  }
+
+  /**
    * Serialize a type name (which might be defined in a nested scope, at top
    * level within this library, or at top level within an imported library) to
    * a [EntityRef].  Note that this method does the right thing if the
    * name doesn't refer to an entity other than a type (e.g. a class member).
    */
   EntityRefBuilder serializeTypeName(TypeName node) {
     if (node == null) {
       return null;
     } else {
       EntityRefBuilder b = new EntityRefBuilder();
@@ skipping 16 matching lines @@
               return b;
             }
           }
           if (scope is _TypeParameterScope) {
             indexOffset += scope.length;
           }
         }
         b.reference = serializeReference(null, name);
       } else if (identifier is PrefixedIdentifier) {
         int prefixIndex = prefixIndices.putIfAbsent(identifier.prefix.name,
-            () => serializeReference(null, identifier.prefix.name));
+            () => serializeSimpleReference(identifier.prefix.name));
         b.reference =
             serializeReference(prefixIndex, identifier.identifier.name);
       } else {
         throw new StateError(
             'Unexpected identifier type: ${identifier.runtimeType}');
       }
       if (node.typeArguments != null) {
         // Trailing type arguments of type 'dynamic' should be omitted.
         NodeList<TypeName> args = node.typeArguments.arguments;
         int numArgsToSerialize = args.length;
@@ skipping 339 matching lines @@
 /**
  * A [_TypeParameterScope] is a [_Scope] which defines [_ScopedTypeParameter]s.
  */
 class _TypeParameterScope extends _Scope {
   /**
    * Get the number of [_ScopedTypeParameter]s defined in this
    * [_TypeParameterScope].
    */
   int get length => _definedNames.length;
 }