Support references to static 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 253 matching lines @@
   final CompilationUnitElementForLink enclosingElement;
 
   @override
   bool hasBeenInferred;
 
   ClassElementForLink(CompilationUnitElementForLink enclosingElement)
       : enclosingElement = enclosingElement,
         hasBeenInferred = !enclosingElement.isInBuildUnit;
 
   @override
+  List<PropertyAccessorElementForLink> get accessors;
+
+  @override
   ConstructorElementForLink get asConstructor => unnamedConstructor;
 
   @override
   ConstVariableNode get asConstVariable {
     // When a class name is used as a constant variable, it doesn't depend on
     // anything, so it is not necessary to include it in the constant
     // dependency graph.
     return null;
   }
 
@@ skipping 32 matching lines @@
       for (ConstructorElementForLink constructor in constructors) {
         _containedNames[constructor.name] = constructor;
       }
       for (FieldElementForLink field in fields) {
         // TODO(paulberry): do we need to handle nonstatic fields for
         // consistent behavior with erroneous code?
         if (field.isStatic) {
           _containedNames[field.name] = field;
         }
       }
+      for (PropertyAccessorElementForLink accessor in accessors) {
+        if (accessor.isStatic && !accessor.isSynthetic) {
+          // TODO(paulberry): add synthetic elements too?
+          _containedNames[accessor.name] = accessor;
+        }
+      }
       // TODO(paulberry): add methods.
     }
     return _containedNames.putIfAbsent(
         name, () => UndefinedElementForLink.instance);
   }
 
   /**
    * Perform type inference and cycle detection on this class and
    * store the resulting information in [compilationUnit].
    */
@@ skipping 3118 matching lines @@
    * Get the list of unlinked parameters of this element.
    */
   List<UnlinkedParam> get unlinkedParameters;
 }
 
 /**
  * Element representing a getter or setter resynthesized from a summary during
  * linking.
  */
 abstract class PropertyAccessorElementForLink
-    implements PropertyAccessorElementImpl {
+    implements PropertyAccessorElementImpl, ReferenceableElementForLink {
   void link(CompilationUnitElementInBuildUnit compilationUnit);
 }
 
 /**
  * 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(
       ClassElementForLink_Class enclosingClass,
       UnlinkedExecutable unlinkedExecutable,
       this.variable)
       : super(enclosingClass.enclosingElement, enclosingClass,
             unlinkedExecutable);
 
   @override
+  ConstructorElementForLink get asConstructor => null;
+
+  @override
+  ConstVariableNode get asConstVariable => null;
+
+  @override
+  DartType get asStaticType => returnType;
+
+  @override
+  TypeInferenceNode get asTypeInferenceNode => null;
+
+  @override
   PropertyAccessorElementForLink_Executable get correspondingGetter =>
       variable.getter;
 
   @override
   bool get isGetter =>
       _unlinkedExecutable.kind == UnlinkedExecutableKind.getter;
 
   @override
   bool get isSetter =>
       _unlinkedExecutable.kind == UnlinkedExecutableKind.setter;
 
   @override
   ElementKind get kind => _unlinkedExecutable.kind ==
       UnlinkedExecutableKind.getter ? ElementKind.GETTER : ElementKind.SETTER;
 
   @override
+  DartType buildType(DartType getTypeArgument(int i),
+          List<int> implicitFunctionTypeIndices) =>
+      DynamicTypeImpl.instance;
+
+  @override
+  ReferenceableElementForLink getContainedName(String name) =>
+      UndefinedElementForLink.instance;
+
+  @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
 /**
  * Specialization of [PropertyAccessorElementForLink] for synthetic accessors
  * implied by a field or variable declaration.
  */
@@ skipping 853 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;
   }
 }