Support references to top level getters in the summary linker.

pkg/analyzer/lib/src/summary/link.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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 350 matching lines @@
 
   List<ConstructorElementForLink> _constructors;
   ConstructorElementForLink _unnamedConstructor;
   bool _unnamedConstructorComputed = false;
   List<FieldElementForLink_ClassField> _fields;
   InterfaceType _supertype;
   InterfaceType _type;
   List<MethodElementForLink> _methods;
   List<InterfaceType> _mixins;
   List<InterfaceType> _interfaces;
-  List<PropertyAccessorElement> _accessors;
+  List<PropertyAccessorElementForLink> _accessors;
 
   ClassElementForLink_Class(
       CompilationUnitElementForLink enclosingElement, this._unlinkedClass)
       : super(enclosingElement);
 
   @override
   List<PropertyAccessorElement> get accessors {
     if (_accessors == null) {
-      _accessors = <PropertyAccessorElement>[];
+      _accessors = <PropertyAccessorElementForLink>[];
       Map<String, SyntheticVariableElementForLink> syntheticVariables =
           <String, SyntheticVariableElementForLink>{};
       for (UnlinkedExecutable unlinkedExecutable
           in _unlinkedClass.executables) {
         if (unlinkedExecutable.kind == UnlinkedExecutableKind.getter ||
             unlinkedExecutable.kind == UnlinkedExecutableKind.setter) {
           String name = unlinkedExecutable.name;
           if (unlinkedExecutable.kind == UnlinkedExecutableKind.setter) {
             assert(name.endsWith('='));
             name = name.substring(0, name.length - 1);
           }
           SyntheticVariableElementForLink syntheticVariable = syntheticVariables
               .putIfAbsent(name, () => new SyntheticVariableElementForLink());
           PropertyAccessorElementForLink_Executable accessor =
-              new PropertyAccessorElementForLink_Executable(
+              new PropertyAccessorElementForLink_Executable(enclosingElement,
                   this, unlinkedExecutable, syntheticVariable);
           _accessors.add(accessor);
           if (unlinkedExecutable.kind == UnlinkedExecutableKind.getter) {
             syntheticVariable._getter = accessor;
           } else {
             syntheticVariable._setter = accessor;
           }
         }
       }
       for (FieldElementForLink_ClassField field in fields) {
@@ skipping 286 matching lines @@
   /**
    * The absolute URI of this compilation unit.
    */
   final String _absoluteUri;
 
   List<ClassElementForLink_Class> _types;
   Map<String, ReferenceableElementForLink> _containedNames;
   List<TopLevelVariableElementForLink> _topLevelVariables;
   List<ClassElementForLink_Enum> _enums;
   List<TopLevelFunctionElementForLink> _functions;
+  List<PropertyAccessorElementForLink> _accessors;
 
   /**
    * Index of this unit in the list of units in the enclosing library.
    */
   final int unitNum;
 
   CompilationUnitElementForLink(UnlinkedUnit unlinkedUnit, this.unitNum,
       int numReferences, this._absoluteUri)
       : _references = new List<ReferenceableElementForLink>(numReferences),
         _unlinkedUnit = unlinkedUnit;
 
   @override
+  List<PropertyAccessorElementForLink> get accessors {
+    if (_accessors == null) {
+      _accessors = <PropertyAccessorElementForLink>[];
+      Map<String, SyntheticVariableElementForLink> syntheticVariables =
+          <String, SyntheticVariableElementForLink>{};
+      for (UnlinkedExecutable unlinkedExecutable in _unlinkedUnit.executables) {
+        if (unlinkedExecutable.kind == UnlinkedExecutableKind.getter ||
+            unlinkedExecutable.kind == UnlinkedExecutableKind.setter) {
+          String name = unlinkedExecutable.name;
+          if (unlinkedExecutable.kind == UnlinkedExecutableKind.setter) {
+            assert(name.endsWith('='));
+            name = name.substring(0, name.length - 1);
+          }
+          SyntheticVariableElementForLink syntheticVariable = syntheticVariables
+              .putIfAbsent(name, () => new SyntheticVariableElementForLink());
+          PropertyAccessorElementForLink_Executable accessor =
+              new PropertyAccessorElementForLink_Executable(
+                  this, null, unlinkedExecutable, syntheticVariable);
+          _accessors.add(accessor);
+          if (unlinkedExecutable.kind == UnlinkedExecutableKind.getter) {
+            syntheticVariable._getter = accessor;
+          } else {
+            syntheticVariable._setter = accessor;
+          }
+        }
+      }
+      // TODO(paulberry): also add synthetic accessors.
+    }
+    return _accessors;
+  }
+
+  @override
   LibraryElementForLink get enclosingElement;
 
   @override
   List<ClassElementForLink_Enum> get enums {
     if (_enums == null) {
       _enums = <ClassElementForLink_Enum>[];
       for (UnlinkedEnum unlinkedEnum in _unlinkedUnit.enums) {
         _enums.add(new ClassElementForLink_Enum(this, unlinkedEnum));
       }
     }
@@ skipping 79 matching lines @@
       }
       for (ClassElementForLink_Enum enm in enums) {
         _containedNames[enm.name] = enm;
       }
       for (TopLevelVariableElementForLink variable in topLevelVariables) {
         _containedNames[variable.name] = variable;
       }
       for (TopLevelFunctionElementForLink function in functions) {
         _containedNames[function.name] = function;
       }
+      for (PropertyAccessorElementForLink accessor in accessors) {
+        // TODO(paulberry): consider handling synthetic accessors and getting
+        // rid of the loop above for topLevelVariables.
+        if (!accessor.isSynthetic) {
+          _containedNames[accessor.name] = accessor;
+        }
+      }
       // TODO(paulberry): fill in other top level entities (typedefs
       // and executables).
     }
     return _containedNames.putIfAbsent(
         name, () => UndefinedElementForLink.instance);
   }
 
   /**
    * Compute the type referred to by the given linked type [slot] (interpreted
    * relative to [typeParameterContext]).  If there is no inferred type in the
@@ skipping 2654 matching lines @@
 /**
  * Specialization of [PropertyAccessorElementForLink] for non-synthetic
  * accessors explicitly declared in the source code.
  */
 class PropertyAccessorElementForLink_Executable extends ExecutableElementForLink
     implements PropertyAccessorElementForLink {
   @override
   SyntheticVariableElementForLink variable;
 
   PropertyAccessorElementForLink_Executable(
+      CompilationUnitElementForLink enclosingUnit,
       ClassElementForLink_Class enclosingClass,
       UnlinkedExecutable unlinkedExecutable,
       this.variable)
-      : super(enclosingClass.enclosingElement, enclosingClass,
-            unlinkedExecutable);
+      : super(enclosingUnit, enclosingClass, unlinkedExecutable);
 
   @override
   ConstructorElementForLink get asConstructor => null;
 
   @override
   ConstVariableNode get asConstVariable => null;
 
   @override
   DartType get asStaticType => returnType;
 
@@ skipping 892 matching lines @@
       if (type is InterfaceType) {
         Element result = type.lookUpGetter(name, compilationUnit.library);
         result ??= type.lookUpMethod(name, compilationUnit.library);
         return result;
       }
     }
     // TODO(scheglov): implement for propagated types
     return null;
   }
 }