Introduce code to generate UnlinkedPublicNamespace directly from an AST.

pkg/analyzer/test/src/summary/summary_test.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_test;
 
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
+import 'package:analyzer/src/generated/parser.dart';
+import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
-import 'package:analyzer/src/summary/builder.dart';
+import 'package:analyzer/src/generated/source_io.dart';
+import 'package:analyzer/src/summary/base.dart';
 import 'package:analyzer/src/summary/format.dart';
+import 'package:analyzer/src/summary/public_namespace_computer.dart'
+    as public_namespace;
 import 'package:analyzer/src/summary/summarize_elements.dart'
     as summarize_elements;
 import 'package:unittest/unittest.dart';
 
 import '../../generated/resolver_test.dart';
 import '../../reflective_tests.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(SummarizeElementsTest);
 }
 
 /**
  * Override of [SummaryTest] which creates summaries from the element model.
  */
 @reflectiveTest
 class SummarizeElementsTest extends ResolverTestCase with SummaryTest {
+  final BuilderContext builderContext = new BuilderContext();
+
+  /**
+   * The list of absolute unit URIs corresponding to the compilation units in
+   * [unlinkedUnits].
+   */
+  List<String> unitUris;
+
   @override
   bool get checkAstDerivedData => false;
 
   /**
+   * 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') {
+          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));
+      }
+      if (orderByName) {
+        result.sort((Object a, Object b) {
+          if (a is Map && b is Map) {
+            return Comparable.compare(a['name'], b['name']);
+          } else {
+            return 0;
+          }
+        });
+      }
+      return result;
+    } else {
+      return obj;
+    }
+  }
+
+  /**
    * Serialize the library containing the given class [element], then
    * deserialize it and return the summary of the class.
    */
   UnlinkedClass serializeClassElement(ClassElement element) {
     serializeLibraryElement(element.library);
     return findClass(element.name, failIfAbsent: true);
   }
 
   /**
    * Serialize the given [library] element, then deserialize it and store the
-   * resulting summary in [lib].
+   * resulting summary in [prelinked] and [unlinkedUnits].
    */
   void serializeLibraryElement(LibraryElement library) {
-    BuilderContext builderContext = new BuilderContext();
     summarize_elements.LibrarySerializationResult serializedLib =
         summarize_elements.serializeLibrary(
             builderContext, library, typeProvider);
     prelinked =
         new PrelinkedLibrary.fromBuffer(serializedLib.prelinked.toBuffer());
     unlinkedUnits = serializedLib.unlinkedUnits
         .map((UnlinkedUnitBuilder b) =>
             new UnlinkedUnit.fromBuffer(b.toBuffer()))
         .toList();
+    unitUris = serializedLib.unitUris;
   }
 
   @override
   void serializeLibraryText(String text, {bool allowErrors: false}) {
     Source source = addSource(text);
     LibraryElement library = resolve2(source);
     if (!allowErrors) {
       assertNoErrors(source);
     }
     serializeLibraryElement(library);
     expect(
         unlinkedUnits[0].imports.length, prelinked.importDependencies.length);
     expect(prelinked.units.length, unlinkedUnits.length);
     for (int i = 0; i < prelinked.units.length; i++) {
       expect(unlinkedUnits[i].references.length,
           prelinked.units[i].references.length);
     }
+    verifyPublicNamespace();
   }
 
   @override
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableGenericMethods = true;
     resetWithOptions(options);
   }
 
   test_class_no_superclass() {
     UnlinkedClass cls = serializeClassElement(typeProvider.objectType.element);
     expect(cls.supertype, isNull);
     expect(cls.hasNoSupertype, isTrue);
   }
+
+  /**
+   * Verify that [public_namespace.computePublicNamespace] produces data that's
+   * equivalent to that produced by [summarize_elements.serializeLibrary].
+   */
+  void verifyPublicNamespace() {
+    for (int i = 0; i < unlinkedUnits.length; i++) {
+      Source source = analysisContext.sourceFactory.forUri(unitUris[i]);
+      String text = analysisContext.getContents(source).data;
+      CharacterReader reader = new CharSequenceReader(text);
+      Scanner scanner =
+          new Scanner(source, reader, AnalysisErrorListener.NULL_LISTENER);
+      Parser parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
+      CompilationUnit unit = parser.parseCompilationUnit(scanner.tokenize());
+      UnlinkedPublicNamespace namespace =
+          new UnlinkedPublicNamespace.fromBuffer(public_namespace
+              .computePublicNamespace(builderContext, unit)
+              .toBuffer());
+      expect(canonicalize(namespace),
+          canonicalize(unlinkedUnits[i].publicNamespace),
+          reason: 'publicNamespace(${unitUris[i]})');
+    }
+  }
 }
 
 /**
  * Base class containing most summary tests.  This allows summary tests to be
  * re-used to exercise all the different ways in which summaries can be
  * generated (e.g. direct from the AST, from the element model, from a
  * "relinking" process, etc.)
  */
 abstract class SummaryTest {
   /**
@@ skipping 2154 matching lines @@
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 
   test_varible_private() {
     serializeVariableText('int _i;', variableName: '_i');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 }