Fix export + local when the library is also exported.

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/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/name_filter.dart';
 
 /**
@@ skipping 281 matching lines @@
 
   /**
    * 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.
    */
   _Namespace computeExportNamespace(String relativeUri) {
-    _Namespace exportNamespace = relativeUri == null
-        ? new _Namespace()
-        : aggregatePublicNamespace(relativeUri);
-    void chaseExports(
-        NameFilter filter, String relativeUri, Set<String> seenUris) {
+    Set<String> seenUris = new Set<String>();
+    _Namespace chaseExports(String relativeUri, NameFilter filter) {
+      _Namespace exportedNamespace = relativeUri == null
+          ? new _Namespace()
+          : aggregatePublicNamespace(relativeUri);
       if (seenUris.add(relativeUri)) {
-        UnlinkedPublicNamespace exportedNamespace =
-            getImportCached(relativeUri);
-        if (exportedNamespace != null) {
-          for (UnlinkedExportPublic export in exportedNamespace.exports) {
+        UnlinkedPublicNamespace publicNamespace = getImportCached(relativeUri);
+        if (publicNamespace != null) {
+          for (UnlinkedExportPublic export in publicNamespace.exports) {
             String relativeExportUri =
                 _selectUri(export.uri, export.configurations);
             String exportUri = resolveUri(relativeUri, relativeExportUri);
             NameFilter newFilter = filter.merge(
                 new NameFilter.forUnlinkedCombinators(export.combinators));
-            aggregatePublicNamespace(exportUri)
-                .forEach((String name, _Meaning meaning) {
+            _Namespace exportNamespace = chaseExports(exportUri, newFilter);
+            exportNamespace.forEach((String name, _Meaning meaning) {
               if (newFilter.accepts(name) &&
-                  !exportNamespace.definesLibraryName(name)) {
-                exportNamespace.add(name, meaning);
+                  !exportedNamespace.definesLibraryName(name)) {
+                exportedNamespace.add(name, meaning);
               }
             });
-            chaseExports(newFilter, exportUri, seenUris);
           }
         }
         seenUris.remove(relativeUri);
       }
+      return exportedNamespace;
     }
 
-    chaseExports(NameFilter.identity, relativeUri, new Set<String>());
-    return exportNamespace;
+    return chaseExports(relativeUri, NameFilter.identity);
   }
 
   /**
    * Extract all the names defined in [unit] (which is the [unitNum]th unit in
    * the library being prelinked) and store them in [privateNamespace].
    * Excludes names introduced by `import` statements.
    */
   void extractPrivateNames(UnlinkedUnit unit, int unitNum) {
     for (UnlinkedClass cls in unit.classes) {
       _Namespace namespace = new _Namespace();
@@ skipping 264 matching lines @@
   String _selectUri(
       String defaultUri, List<UnlinkedConfiguration> configurations) {
     for (UnlinkedConfiguration configuration in configurations) {
       if (getDeclaredVariable(configuration.name) == configuration.value) {
         return configuration.uri;
       }
     }
     return defaultUri;
   }
 }