Create a section of the summary for public namespace information.

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/type.dart';
 import 'package:analyzer/src/generated/resolver.dart';
@@ skipping 145 matching lines @@
    */
   void addCompilationUnitElements(CompilationUnitElement element, int unitNum) {
     UnlinkedUnitBuilder b = new UnlinkedUnitBuilder(ctx);
     referenceMap.clear();
     unlinkedReferences = <UnlinkedReferenceBuilder>[
       encodeUnlinkedReference(ctx)
     ];
     prelinkedReferences = <PrelinkedReferenceBuilder>[
       encodePrelinkedReference(ctx, kind: PrelinkedReferenceKind.classOrEnum)
     ];
+    List<UnlinkedPublicNameBuilder> names = <UnlinkedPublicNameBuilder>[];
+    for (PropertyAccessorElement accessor in element.accessors) {
+      if (accessor.isPublic) {
+        names.add(encodeUnlinkedPublicName(ctx,
+            kind: PrelinkedReferenceKind.other, name: accessor.name));
+      }
+    }
+    for (ClassElement cls in element.types) {
+      if (cls.isPublic) {
+        names.add(encodeUnlinkedPublicName(ctx,
+            kind: PrelinkedReferenceKind.classOrEnum, name: cls.name));
+      }
+    }
+    for (ClassElement enm in element.enums) {
+      if (enm.isPublic) {
+        names.add(encodeUnlinkedPublicName(ctx,
+            kind: PrelinkedReferenceKind.classOrEnum, name: enm.name));
+      }
+    }
+    for (FunctionElement function in element.functions) {
+      if (function.isPublic) {
+        names.add(encodeUnlinkedPublicName(ctx,
+            kind: PrelinkedReferenceKind.other, name: function.name));
+      }
+    }
+    for (FunctionTypeAliasElement typedef in element.functionTypeAliases) {
+      if (typedef.isPublic) {
+        names.add(encodeUnlinkedPublicName(ctx,
+            kind: PrelinkedReferenceKind.typedef, name: typedef.name));
+      }
+    }
     if (unitNum == 0) {
+      if (libraryElement.name.isNotEmpty) {
+        b.libraryName = libraryElement.name;
+      }
+      b.publicNamespace = encodeUnlinkedPublicNamespace(ctx,
+          exports: libraryElement.exports.map(serializeExport).toList(),
+          parts: libraryElement.parts
+              .map((CompilationUnitElement e) =>
+                  encodeUnlinkedPart(ctx, uri: e.uri))
+              .toList(),
+          names: names);
+      b.imports = libraryElement.imports.map(serializeImport).toList();
+    } else {
       // TODO(paulberry): we need to figure out a way to record library, part,
       // import, and export declarations that appear in non-defining
       // compilation units (even though such declarations are prohibited by the
       // language), so that if the user makes code changes that cause a
       // non-defining compilation unit to become a defining compilation unit,
       // we can create a correct summary by simply re-linking.
-      if (libraryElement.name.isNotEmpty) {
-        b.libraryName = libraryElement.name;
-      }
-      b.exports = libraryElement.exports.map(serializeExport).toList();
-      b.imports = libraryElement.imports.map(serializeImport).toList();
-      b.parts = libraryElement.parts
-          .map(
-              (CompilationUnitElement e) => encodeUnlinkedPart(ctx, uri: e.uri))
-          .toList();
+      b.publicNamespace = encodeUnlinkedPublicNamespace(ctx, names: names);
     }
     b.classes = element.types.map(serializeClass).toList();
     b.enums = element.enums.map(serializeEnum).toList();
     b.typedefs = element.functionTypeAliases.map(serializeTypedef).toList();
     List<UnlinkedExecutableBuilder> executables =
         element.functions.map(serializeExecutable).toList();
     for (PropertyAccessorElement accessor in element.accessors) {
       if (!accessor.isSynthetic) {
         executables.add(serializeExecutable(accessor));
       }
@@ skipping 413 matching lines @@
     UnlinkedVariableBuilder b = new UnlinkedVariableBuilder(ctx);
     b.name = variable.name;
     b.type = serializeTypeRef(variable.type, variable);
     b.isStatic = variable.isStatic && variable.enclosingElement is ClassElement;
     b.isFinal = variable.isFinal;
     b.isConst = variable.isConst;
     b.hasImplicitType = variable.hasImplicitType;
     return b;
   }
 }