Include all static class members in UnlinkedPublicName.members.

pkg/analyzer/test/src/summary/summary_common.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 analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 25 matching lines @@
 /**
  * Convert a summary object (or a portion of one) into a canonical form that
  * can be easily compared using [expect].  If [orderByName] is true, and the
  * object is a [List], it is sorted by the `name` field of its elements.
  */
 Object canonicalize(Object obj, {bool orderByName: false}) {
   if (obj is SummaryClass) {
     Map<String, Object> result = <String, Object>{};
     obj.toMap().forEach((String key, Object value) {
       bool orderByName = false;
-      if (obj is UnlinkedPublicNamespace && key == 'names') {
+      if (obj is UnlinkedPublicNamespace && key == 'names' ||
+          obj is UnlinkedPublicName && key == 'members') {
         orderByName = true;
       }
       result[key] = canonicalize(value, orderByName: orderByName);
     });
     return result;
   } else if (obj is List) {
     List<Object> result = <Object>[];
     for (Object item in obj) {
       result.add(canonicalize(item));
     }
@@ skipping 1092 matching lines @@
     expect(cls.isAbstract, false);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     UnlinkedPublicName className = unlinkedUnits[0].publicNamespace.names[0];
     expect(className.kind, ReferenceKind.classOrEnum);
     expect(className.name, 'C');
     expect(className.numTypeParameters, 0);
     // executables
     Map<String, UnlinkedPublicName> executablesMap =
         <String, UnlinkedPublicName>{};
     className.members.forEach((e) => executablesMap[e.name] = e);
-    expect(executablesMap, hasLength(2));
-    {
-      UnlinkedPublicName executable = executablesMap['fieldStaticConst'];
-      expect(executable.kind, ReferenceKind.propertyAccessor);
+    expect(executablesMap, hasLength(4));
+    Map<String, ReferenceKind> expectedExecutableKinds =
+        <String, ReferenceKind>{
+      'fieldStaticConst': ReferenceKind.propertyAccessor,
+      'fieldStaticFinal': ReferenceKind.propertyAccessor,
+      'fieldStatic': ReferenceKind.propertyAccessor,
+      'methodStaticPublic': ReferenceKind.method,
+    };
+    expectedExecutableKinds.forEach((String name, ReferenceKind expectedKind) {
+      UnlinkedPublicName executable = executablesMap[name];
+      expect(executable.kind, expectedKind);
       expect(executable.members, isEmpty);
-    }
-    {
-      UnlinkedPublicName executable = executablesMap['methodStaticPublic'];
-      expect(executable.kind, ReferenceKind.method);
-      expect(executable.members, isEmpty);
-    }
+    });
   }
 
   test_class_constMembers_constructors() {
     UnlinkedClass cls = serializeClassText('''
 class C {
   const C();
   const C.constructorNamedPublicConst();
   C.constructorNamedPublic();
   C._constructorNamedPrivate();
 }
@@ skipping 5759 matching lines @@
   test_field() {
     UnlinkedClass cls = serializeClassText('class C { int i; }');
     UnlinkedVariable variable = findVariable('i', variables: cls.fields);
     expect(variable, isNotNull);
     expect(variable.isConst, isFalse);
     expect(variable.isStatic, isFalse);
     expect(variable.isFinal, isFalse);
     expect(variable.constExpr, isNull);
     expect(findExecutable('i', executables: cls.executables), isNull);
     expect(findExecutable('i=', executables: cls.executables), isNull);
+    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
+    expect(unlinkedUnits[0].publicNamespace.names[0].members, isEmpty);
   }
 
   test_field_const() {
     UnlinkedVariable variable =
         serializeClassText('class C { static const int i = 0; }').fields[0];
     expect(variable.isConst, isTrue);
     _assertUnlinkedConst(variable.constExpr,
         operators: [UnlinkedConstOperation.pushInt], ints: [0]);
   }
 
@@ skipping 130 matching lines @@
     UnlinkedVariable v =
         serializeClassText('class C { final v = 0; }').fields[0];
     checkLinkedTypeSlot(v.propagatedTypeSlot, 'dart:core', 'dart:core', 'int');
   }
 
   test_field_static() {
     UnlinkedVariable variable =
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
     expect(variable.constExpr, isNull);
+    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
+    expect(unlinkedUnits[0].publicNamespace.names[0].members, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.names[0].members[0].name, 'i');
+    expect(unlinkedUnits[0].publicNamespace.names[0].members[0].kind,
+        ReferenceKind.propertyAccessor);
+    expect(
+        unlinkedUnits[0].publicNamespace.names[0].members[0].numTypeParameters,
+        0);
+    expect(
+        unlinkedUnits[0].publicNamespace.names[0].members[0].members, isEmpty);
   }
 
   test_field_static_final() {
     UnlinkedVariable variable =
         serializeClassText('class C { static final int i = 0; }').fields[0];
     expect(variable.isStatic, isTrue);
     expect(variable.isFinal, isTrue);
     expect(variable.constExpr, isNull);
   }
 
@@ skipping 2626 matching lines @@
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.relativeUri, this.numTypeParameters: 0});
 }