Include the export namespace in the prelinked summary.

pkg/analyzer/lib/src/summary/prelink.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.
 
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/name_filter.dart';
 
 /**
  * Create a [PrelinkedLibraryBuilder] corresponding to the given
  * [definingUnit], which should be the defining compilation unit for a library.
@@ skipping 52 matching lines @@
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   final int numTypeParameters;
 
   _Meaning(this.unit, this.kind, this.dependency, this.numTypeParameters);
 
   /**
+ * Encode this [_Meaning] as a [PrelinkedExportName], using the given [name].
+ */
+  PrelinkedExportName encodeExportName(String name) {
+    return encodePrelinkedExportName(
+        name: name, dependency: dependency, unit: unit, kind: kind);
+  }
+
+/**
    * Encode this [_Meaning] as a [PrelinkedReference].
    */
-  PrelinkedReferenceBuilder encode() {
+  PrelinkedReferenceBuilder encodeReference() {
     return encodePrelinkedReference(
         unit: unit,
         kind: kind,
         dependency: dependency,
         numTypeParameters: numTypeParameters);
   }
 }
 
 /**
  * A [_Meaning] representing a prefix introduced by an import directive.
@@ skipping 92 matching lines @@
     }
 
     dependencyToPublicNamespace.add(aggregated);
     return aggregated;
   }
 
   /**
    * Compute the export namespace for the library whose URI is reachable from
    * [definingUnit] via [relativeUri], by aggregating together public namespace
    * information from the library and the transitive closure of its exports.
+   *
+   * If [relativeUri] is `null` (meaning the export namespace of [definingUnit]
+   * should be computed), then names defined in [definingUnit] are ignored.
    */
   Map<String, _Meaning> computeExportNamespace(String relativeUri) {
-    Map<String, _Meaning> exportNamespace =
-        aggregatePublicNamespace(relativeUri);
+    Map<String, _Meaning> exportNamespace = relativeUri == null
+        ? <String, _Meaning>{}
+        : aggregatePublicNamespace(relativeUri);
     void chaseExports(
         NameFilter filter, String relativeUri, Set<String> seenUris) {
       if (seenUris.add(relativeUri)) {
         UnlinkedPublicNamespace exportedNamespace =
             getImportCached(relativeUri);
         if (exportedNamespace != null) {
           for (UnlinkedExportPublic export in exportedNamespace.exports) {
             String exportUri = resolveUri(relativeUri, export.uri);
+            NameFilter newFilter = filter.merge(
+                new NameFilter.forUnlinkedCombinators(export.combinators));
             aggregatePublicNamespace(exportUri)
                 .forEach((String name, _Meaning meaning) {
-              if (filter.accepts(name) && !exportNamespace.containsKey(name)) {
+              if (newFilter.accepts(name) &&
+                  !exportNamespace.containsKey(name)) {
                 exportNamespace[name] = meaning;
               }
             });
-            chaseExports(
-                filter.merge(
-                    new NameFilter.forUnlinkedCombinators(export.combinators)),
-                exportUri,
-                seenUris);
+            chaseExports(newFilter, exportUri, seenUris);
           }
         }
         seenUris.remove(relativeUri);
       }
     }
     chaseExports(NameFilter.identity, relativeUri, new Set<String>());
     return exportNamespace;
   }
 
   /**
@@ skipping 10 matching lines @@
     }
     for (UnlinkedEnum enm in unit.enums) {
       privateNamespace.putIfAbsent(
           enm.name,
           () =>
               new _Meaning(unitNum, PrelinkedReferenceKind.classOrEnum, 0, 0));
     }
     for (UnlinkedExecutable executable in unit.executables) {
       privateNamespace.putIfAbsent(
           executable.name,
-          () => new _Meaning(unitNum, PrelinkedReferenceKind.other, 0,
+          () => new _Meaning(
+              unitNum,
+              executable.kind == UnlinkedExecutableKind.functionOrMethod
+                  ? PrelinkedReferenceKind.topLevelFunction
+                  : PrelinkedReferenceKind.topLevelPropertyAccessor,
+              0,
               executable.typeParameters.length));
     }
     for (UnlinkedTypedef typedef in unit.typedefs) {
       privateNamespace.putIfAbsent(
           typedef.name,
           () => new _Meaning(unitNum, PrelinkedReferenceKind.typedef, 0,
               typedef.typeParameters.length));
     }
     for (UnlinkedVariable variable in unit.variables) {
-      privateNamespace.putIfAbsent(variable.name,
-          () => new _Meaning(unitNum, PrelinkedReferenceKind.other, 0, 0));
+      privateNamespace.putIfAbsent(
+          variable.name,
+          () => new _Meaning(
+              unitNum, PrelinkedReferenceKind.topLevelPropertyAccessor, 0, 0));
+      if (!(variable.isConst || variable.isFinal)) {
+        privateNamespace.putIfAbsent(
+            variable.name + '=',
+            () => new _Meaning(unitNum,
+                PrelinkedReferenceKind.topLevelPropertyAccessor, 0, 0));
+      }
     }
   }
 
   /**
    * Filter the export namespace for the library whose URI is reachable from
    * [definingUnit] via [relativeUri], retaining only those names accepted by
    * [combinators], and store the resulting names in [result].  Names that
    * already exist in [result] are not overwritten.
    */
   void filterExportNamespace(String relativeUri,
@@ skipping 85 matching lines @@
         // Prefix references must always point to proper prefixes.
         assert(namespace != null);
       } else {
         namespace = privateNamespace;
       }
       _Meaning meaning = namespace[reference.name];
       if (meaning != null) {
         if (meaning is _PrefixMeaning) {
           prefixNamespaces[i] = meaning.namespace;
         }
-        references.add(meaning.encode());
+        references.add(meaning.encodeReference());
       } else {
         references.add(
             encodePrelinkedReference(kind: PrelinkedReferenceKind.unresolved));
       }
     }
     return encodePrelinkedUnit(references: references);
   }
 
   /**
    * Form the [PrelinkedLibrary] for the [definingUnit] that was passed to the
    * constructor.
    */
   PrelinkedLibraryBuilder prelink() {
     // Gather up the unlinked summaries for all the compilation units in the
     // library.
     List<UnlinkedUnit> units = getUnitUris(null).map(getPartCached).toList();
 
     // Create the private namespace for the library by gathering all the names
     // defined in its compilation units.
     for (int unitNum = 0; unitNum < units.length; unitNum++) {
       UnlinkedUnit unit = units[unitNum];
       if (unit != null) {
         extractPrivateNames(unit, unitNum);
       }
     }
 
+    // Fill in exported names.  This must be done before filling in prefixes
+    // defined in import declarations, because prefixes shouldn't shadow
+    // exports.
+    List<PrelinkedExportNameBuilder> exportNames =
+        <PrelinkedExportNameBuilder>[];
+    computeExportNamespace(null).forEach((String name, _Meaning meaning) {
+      if (!privateNamespace.containsKey(name)) {
+        exportNames.add(meaning.encodeExportName(name));
+      }
+    });
+
     // Fill in prefixes defined in import declarations.
     for (UnlinkedImport import in units[0].imports) {
       if (import.prefixReference != 0) {
         privateNamespace.putIfAbsent(
             units[0].references[import.prefixReference].name,
             () => new _PrefixMeaning());
       }
     }
 
     // Fill in imported names.
     List<int> importDependencies =
         definingUnit.imports.map(handleImport).toList();
 
     // Link each compilation unit.
     List<PrelinkedUnitBuilder> linkedUnits = units.map(linkUnit).toList();
 
     return encodePrelinkedLibrary(
         units: linkedUnits,
         dependencies: dependencies,
-        importDependencies: importDependencies);
+        importDependencies: importDependencies,
+        exportNames: exportNames);
   }
 
   /**
    * Resolve [relativeUri] relative to [sourceUri].  Works correctly if
    * [sourceUri] is also relative.
    */
   String resolveUri(String sourceUri, String relativeUri) {
     if (sourceUri == null) {
       return relativeUri;
     } else {
       return Uri.parse(sourceUri).resolve(relativeUri).toString();
     }
   }
 }