Add public and export namespaces to LibraryElement.

pkg/analyzer/test/src/task/dart_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 test.src.task.dart_test;
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 119 matching lines @@
     context.getCacheEntry(sourceC).setValue(LIBRARY_ELEMENT1, libraryElementC);
     context.getCacheEntry(sourceC).setValue(SOURCE_KIND, SourceKind.LIBRARY);
     // request inputs
     WorkItem workItem =
         new WorkItem(context, sourceA, BuildDirectiveElementsTask.DESCRIPTOR);
     workItem.gatherInputs(null);
     Map<String, dynamic> inputs = workItem.inputs;
     expect(inputs, hasLength(5));
     expect(inputs[BuildDirectiveElementsTask.RESOLVED_UNIT2_INPUT_NAME], unitA);
     expect(
-        inputs[BuildDirectiveElementsTask.IMPORTS_LIBRARY_ELEMENT1_INPUT_NAME],
+        inputs[BuildDirectiveElementsTask.IMPORTS_LIBRARY_ELEMENT_INPUT_NAME],
         containsPair(sourceB, libraryElementB));
     expect(
-        inputs[BuildDirectiveElementsTask.EXPORTS_LIBRARY_ELEMENT1_INPUT_NAME],
+        inputs[BuildDirectiveElementsTask.EXPORTS_LIBRARY_ELEMENT_INPUT_NAME],
         containsPair(sourceC, libraryElementC));
     expect(inputs[BuildDirectiveElementsTask.IMPORTS_SOURCE_KIND_INPUT_NAME],
         containsPair(sourceB, SourceKind.LIBRARY));
     expect(inputs[BuildDirectiveElementsTask.EXPORTS_SOURCE_KIND_INPUT_NAME],
         containsPair(sourceC, SourceKind.LIBRARY));
   }
 
   test_constructor() {
     BuildDirectiveElementsTask task =
         new BuildDirectiveElementsTask(context, emptySource);
@@ skipping 205 matching lines @@
       expect(importElementC.prefix, prefixElement);
     }
   }
 
   void _assertErrorsWithCodes(List<ErrorCode> expectedErrorCodes) {
     _fillErrorListener(BUILD_DIRECTIVES_ERRORS);
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   _getExportLibraryInput(Source source) {
-    var key = BuildDirectiveElementsTask.EXPORTS_LIBRARY_ELEMENT1_INPUT_NAME;
+    var key = BuildDirectiveElementsTask.EXPORTS_LIBRARY_ELEMENT_INPUT_NAME;
     return task.inputs[key][source];
   }
 
   _getImportLibraryInput(Source source) {
-    var key = BuildDirectiveElementsTask.IMPORTS_LIBRARY_ELEMENT1_INPUT_NAME;
+    var key = BuildDirectiveElementsTask.IMPORTS_LIBRARY_ELEMENT_INPUT_NAME;
     return task.inputs[key][source];
   }
 }
 
 @reflectiveTest
 class BuildEnumMemberElementsTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source source = _newSource('/test.dart', '''
 enum MyEnum {
   A, B
@@ skipping 57 matching lines @@
 class BuildExportNamespaceTaskTest extends _AbstractDartTaskTest {
   test_perform_entyrPoint() {
     Source sourceA = _newSource('/a.dart', '''
 library lib_a;
 export 'b.dart';
 ''');
     Source sourceB = _newSource('/b.dart', '''
 library lib_b;
 main() {}
 ''');
-    _computeResult(sourceA, LIBRARY_ELEMENT3);
+    _computeResult(sourceA, LIBRARY_ELEMENT4);
     expect(task, new isInstanceOf<BuildExportNamespaceTask>());
     // validate
     {
-      LibraryElement library = outputs[LIBRARY_ELEMENT3];
+      LibraryElement library = outputs[LIBRARY_ELEMENT4];
       FunctionElement entryPoint = library.entryPoint;
       expect(entryPoint, isNotNull);
       expect(entryPoint.source, sourceB);
     }
   }
 
   test_perform_hideCombinator() {
     Source sourceA = _newSource('/a.dart', '''
 library lib_a;
 export 'b.dart' hide B1;
 class A1 {}
 class A2 {}
 class _A3 {}
 ''');
     _newSource('/b.dart', '''
 library lib_b;
 class B1 {}
 class B2 {}
 class B3 {}
 class _B4 {}
 ''');
     _newSource('/c.dart', '''
 library lib_c;
 class C1 {}
 class C2 {}
 class C3 {}
 ''');
-    _computeResult(sourceA, EXPORT_NAMESPACE);
+    _computeResult(sourceA, LIBRARY_ELEMENT4);
     expect(task, new isInstanceOf<BuildExportNamespaceTask>());
     // validate
     {
-      Namespace namespace = outputs[EXPORT_NAMESPACE];
+      LibraryElement library = outputs[LIBRARY_ELEMENT4];
+      Namespace namespace = library.exportNamespace;
       Iterable<String> definedKeys = namespace.definedNames.keys;
       expect(definedKeys, unorderedEquals(['A1', 'A2', 'B2', 'B3']));
     }
   }
 
   test_perform_showCombinator() {
     Source sourceA = _newSource('/a.dart', '''
 library lib_a;
 export 'b.dart' show B1;
 class A1 {}
 class A2 {}
 class _A3 {}
 ''');
     _newSource('/b.dart', '''
 library lib_b;
 class B1 {}
 class B2 {}
 class _B3 {}
 ''');
-    _computeResult(sourceA, EXPORT_NAMESPACE);
+    _computeResult(sourceA, LIBRARY_ELEMENT4);
     expect(task, new isInstanceOf<BuildExportNamespaceTask>());
     // validate
     {
-      Namespace namespace = outputs[EXPORT_NAMESPACE];
+      LibraryElement library = outputs[LIBRARY_ELEMENT4];
+      Namespace namespace = library.exportNamespace;
       Iterable<String> definedKeys = namespace.definedNames.keys;
       expect(definedKeys, unorderedEquals(['A1', 'A2', 'B1']));
     }
   }
 
   test_perform_showCombinator_setter() {
     Source sourceA = _newSource('/a.dart', '''
 library lib_a;
 export 'b.dart' show topLevelB;
 class A {}
 ''');
     _newSource('/b.dart', '''
 library lib_b;
 int topLevelB;
 ''');
-    _computeResult(sourceA, EXPORT_NAMESPACE);
+    _computeResult(sourceA, LIBRARY_ELEMENT4);
     expect(task, new isInstanceOf<BuildExportNamespaceTask>());
     // validate
     {
-      Namespace namespace = outputs[EXPORT_NAMESPACE];
+      LibraryElement library = outputs[LIBRARY_ELEMENT4];
+      Namespace namespace = library.exportNamespace;
       Iterable<String> definedKeys = namespace.definedNames.keys;
       expect(definedKeys, unorderedEquals(['A', 'topLevelB', 'topLevelB=']));
     }
   }
 }
 
 @reflectiveTest
 class BuildExportSourceClosureTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source sourceA = _newSource('/a.dart', '''
@@ skipping 275 matching lines @@
         task.inputs[BuildLibraryElementTask.PARTS_RESOLVED_UNIT1_INPUT_NAME];
   }
 }
 
 @reflectiveTest
 class BuildPublicNamespaceTaskTest extends _AbstractDartTaskTest {
   test_buildInputs() {
     Map<String, TaskInput> inputs =
         BuildPublicNamespaceTask.buildInputs(emptySource);
     expect(inputs, isNotNull);
-    expect(inputs.keys, unorderedEquals(
-        [BuildPublicNamespaceTask.BUILT_LIBRARY_ELEMENT_INPUT_NAME]));
+    expect(
+        inputs.keys, unorderedEquals([BuildPublicNamespaceTask.LIBRARY_INPUT]));
   }
 
   test_constructor() {
     BuildPublicNamespaceTask task =
         new BuildPublicNamespaceTask(context, emptySource);
     expect(task, isNotNull);
     expect(task.context, context);
     expect(task.target, emptySource);
   }
 
@@ skipping 23 matching lines @@
 part 'part.dart';
 a() {}
 _b() {}
 ''',
       '/part.dart': '''
 part of lib;
 _c() {}
 d() {}
 '''
     });
-    _computeResult(sources.first, PUBLIC_NAMESPACE);
+    _computeResult(sources.first, LIBRARY_ELEMENT3);
     expect(task, new isInstanceOf<BuildPublicNamespaceTask>());
     // validate
-    Namespace namespace = outputs[PUBLIC_NAMESPACE];
+    LibraryElement library = outputs[LIBRARY_ELEMENT3];
+    Namespace namespace = library.publicNamespace;
     expect(namespace.definedNames.keys, unorderedEquals(['a', 'd']));
   }
 }
 
 @reflectiveTest
 class BuildTypeProviderTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     _computeResult(AnalysisContextTarget.request, TYPE_PROVIDER);
     expect(task, new isInstanceOf<BuildTypeProviderTask>());
     // validate
@@ skipping 245 matching lines @@
     return entryMap.putIfAbsent(target, () => new CacheEntry());
   }
 
   TimestampedData<String> getContents(Source source) => source.contents;
 
   noSuchMethod(Invocation invocation) {
     print('noSuchMethod: ${invocation.memberName}');
     return super.noSuchMethod(invocation);
   }
 }