Support for static method references in constants.

pkg/analyzer/lib/src/summary/summarize_elements.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.
 
 library serialization.elements;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
@@ skipping 25 matching lines @@
     return ReferenceKind.constructor;
   } else if (element is FunctionElement) {
     return ReferenceKind.topLevelFunction;
   } else if (element is FunctionTypeAliasElement) {
     return ReferenceKind.typedef;
   } else if (element is PropertyAccessorElement) {
     if (element.enclosingElement is ClassElement) {
       return ReferenceKind.constField;
     }
     return ReferenceKind.topLevelPropertyAccessor;
+  } else if (element is MethodElement) {
+    return ReferenceKind.staticMethod;
   } else {
     throw new Exception('Unexpected element kind: ${element.runtimeType}');
   }
 }
 
 /**
  * Type of closures used by [_LibrarySerializer] to defer generation of
  * [EntityRefBuilder] objects until the end of serialization of a
  * compilation unit.
  */
@@ skipping 736 matching lines @@
           .add(() => serializeTypeRef(type, context, linked: true, slot: slot));
     }
     return slot;
   }
 
   int _getElementReferenceId(Element element, {bool linked: false}) {
     return referenceMap.putIfAbsent(element, () {
       if (element is ConstructorElement && element.displayName.isEmpty) {
         return _getElementReferenceId(element.enclosingElement, linked: linked);
       }
+      if (element is MethodElement && !element.isStatic) {
+        throw new StateError('Only static methods can be serialized.');
+      }
       if (element is PropertyAccessorElement) {
         Element enclosing = element.enclosingElement;
         if (!(enclosing is CompilationUnitElement || element.isStatic)) {
           throw new StateError(
               'Only top-level or static property accessors can be serialized.');
         }
       }
       LibraryElement dependentLibrary = element?.library;
       int unit;
       if (dependentLibrary == null) {
@@ skipping 90 matching lines @@
     return new EntityRefBuilder(
         reference: serializer._getElementReferenceId(element));
   }
 
   @override
   EntityRefBuilder serializePropertyAccess(PropertyAccess access) {
     Element element = access.propertyName.staticElement;
     assert(element != null);
     // The only supported instance property accessor - `length`.
     Expression target = access.target;
-    if (target is Identifier && element is PropertyAccessorElement &&
+    if (target is Identifier &&
+        element is PropertyAccessorElement &&
         !element.isStatic) {
       assert(element.name == 'length');
       Element prefixElement = target.staticElement;
       int prefixRef = serializer._getElementReferenceId(prefixElement);
       int lengthRef = serializer._getLengthPropertyReference(prefixRef);
       return new EntityRefBuilder(reference: lengthRef);
     }
     return new EntityRefBuilder(
         reference: serializer._getElementReferenceId(element));
   }
@@ skipping 188 matching lines @@
       exportNames.add(new LinkedExportNameBuilder(
           name: name,
           dependency: serializeDependency(dependentLibrary),
           unit: unit,
           kind: kind));
     }
     pb.exportNames = exportNames;
     return pb;
   }
 }