Include the export namespace in the prelinked summary.

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';
@@ skipping 397 matching lines @@
   }
 
   /**
    * Verify that the given [typeRef] represents the type `dynamic`.
    */
   void checkDynamicTypeRef(UnlinkedTypeRef typeRef) {
     checkTypeRef(typeRef, null, null, null);
   }
 
   /**
+   * Verify that the given [exportName] represents a reference to an entity
+   * declared in a file reachable via [absoluteUri] and [relativeUri], having
+   * name [expectedName].  [expectedKind] is the kind of object referenced.
+   * [expectedTargetUnit] is the index of the compilation unit in which the
+   * target of the [exportName] is expected to appear; if not specified it is
+   * assumed to be the defining compilation unit.
+   */
+  void checkExportName(
+      PrelinkedExportName exportName,
+      String absoluteUri,
+      String relativeUri,
+      String expectedName,
+      PrelinkedReferenceKind expectedKind,
+      {int expectedTargetUnit: 0}) {
+    expect(exportName, new isInstanceOf<PrelinkedExportName>());
+    // Exported names must come from other libraries.
+    expect(exportName.dependency, isNot(0));
+    checkDependency(exportName.dependency, absoluteUri, relativeUri);
+    expect(exportName.name, expectedName);
+    expect(exportName.kind, expectedKind);
+    expect(exportName.unit, expectedTargetUnit);
+  }
+
+  /**
    * Verify that the dependency table contains an entry for a file reachable
    * via the given [absoluteUri] and [relativeUri].
    *
    * The [PrelinkedDependency] is returned.
    */
   PrelinkedDependency checkHasDependency(
       String absoluteUri, String relativeUri) {
     if (expectAbsoluteUrisInDependencies) {
       // The element model doesn't (yet) store enough information to recover
       // relative URIs, so we have to use the absolute URI.
@@ skipping 123 matching lines @@
    */
   void checkUnresolvedTypeRef(
       UnlinkedTypeRef typeRef, String expectedPrefix, String expectedName) {
     // When serializing from the element model, unresolved type refs lose their
     // name.
     checkTypeRef(typeRef, null, null, checkAstDerivedData ? expectedName : null,
         expectedPrefix: expectedPrefix,
         expectedKind: PrelinkedReferenceKind.unresolved);
   }
 
-  fail_dependencies_export_to_export_unused() {
+  test_dependencies_export_to_export_unused() {
     // TODO(paulberry): fix this test.
     addNamedSource('/a.dart', 'export "b.dart";');
     addNamedSource('/b.dart', '');
     serializeLibraryText('export "a.dart";');
     // The main test library depends on b.dart, even though it doesn't
     // re-export any names defined in b.dart, because a change to b.dart might
     // cause it to start exporting a name that the main test library *does*
     // use.
     checkHasDependency(absUri('/b.dart'), 'b.dart');
   }
 
-  fail_dependencies_export_unused() {
+  test_dependencies_export_unused() {
     // TODO(paulberry): fix this test.
     addNamedSource('/a.dart', '');
     serializeLibraryText('export "a.dart";');
     // The main test library depends on a.dart, even though it doesn't
     // re-export any names defined in a.dart, because a change to a.dart might
     // cause it to start exporting a name that the main test library *will*
     // re-export.
     checkHasDependency(absUri('/a.dart'), 'a.dart');
   }
 
@@ skipping 887 matching lines @@
         executables: serializeClassText('class C { C(); }').executables);
     expect(executable.returnType, isNull);
   }
 
   test_constructor_return_type_parameterized() {
     UnlinkedExecutable executable = findExecutable('',
         executables: serializeClassText('class C<T, U> { C(); }').executables);
     expect(executable.returnType, isNull);
   }
 
-  test_dependencies_export_none() {
-    // Exports are not listed as dependencies since no change to the exported
-    // file can change the summary of the exporting file.
-    // TODO(paulberry): this needs to change since the element model for a
-    // library includes its export namespace.
-    addNamedSource('/a.dart', 'library a; export "b.dart";');
-    addNamedSource('/b.dart', 'library b;');
-    serializeLibraryText('export "a.dart";');
-    checkLacksDependency(absUri('/a.dart'), 'a.dart');
-    checkLacksDependency(absUri('/b.dart'), 'b.dart');
-  }
-
   test_dependencies_import_to_export() {
     addNamedSource('/a.dart', 'library a; export "b.dart"; class A {}');
     addNamedSource('/b.dart', 'library b;');
     serializeLibraryText('import "a.dart"; A a;');
     checkHasDependency(absUri('/a.dart'), 'a.dart');
     // The main test library depends on b.dart, because names defined in
     // b.dart are exported by a.dart.
     checkHasDependency(absUri('/b.dart'), 'b.dart');
   }
 
@@ skipping 180 matching lines @@
   test_executable_function() {
     String text = '  f() {}';
     UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.hasImplicitReturnType, isTrue);
     checkDynamicTypeRef(executable.returnType);
     expect(executable.isExternal, isFalse);
     expect(executable.nameOffset, text.indexOf('f'));
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        PrelinkedReferenceKind.other);
+        PrelinkedReferenceKind.topLevelFunction);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
   }
 
   test_executable_function_explicit_return() {
     UnlinkedExecutable executable =
         serializeExecutableText('dynamic f() => null;');
     expect(executable.hasImplicitReturnType, isFalse);
     checkDynamicTypeRef(executable.returnType);
   }
@@ skipping 12 matching lines @@
     String text = 'int get f => 1;';
     UnlinkedExecutable executable = serializeExecutableText(text);
     expect(executable.kind, UnlinkedExecutableKind.getter);
     expect(executable.hasImplicitReturnType, isFalse);
     expect(executable.isExternal, isFalse);
     expect(executable.nameOffset, text.indexOf('f'));
     expect(findVariable('f'), isNull);
     expect(findExecutable('f='), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        PrelinkedReferenceKind.other);
+        PrelinkedReferenceKind.topLevelPropertyAccessor);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f');
   }
 
   test_executable_getter_external() {
     UnlinkedExecutable executable =
         serializeExecutableText('external int get f;');
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_getter_private() {
@@ skipping 309 matching lines @@
     String text = 'void set f(value) {}';
     UnlinkedExecutable executable = serializeExecutableText(text, 'f=');
     expect(executable.kind, UnlinkedExecutableKind.setter);
     expect(executable.hasImplicitReturnType, isFalse);
     expect(executable.isExternal, isFalse);
     expect(executable.nameOffset, text.indexOf('f'));
     expect(findVariable('f'), isNull);
     expect(findExecutable('f'), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        PrelinkedReferenceKind.other);
+        PrelinkedReferenceKind.topLevelPropertyAccessor);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f=');
   }
 
   test_executable_setter_external() {
     UnlinkedExecutable executable =
         serializeExecutableText('external void set f(value);', 'f=');
     expect(executable.isExternal, isTrue);
   }
 
   test_executable_setter_implicit_return() {
@@ skipping 66 matching lines @@
   test_executable_type_param_in_return_type_function() {
     UnlinkedExecutable ex = serializeExecutableText('T f<T>() => null;');
     checkParamTypeRef(ex.returnType, 1);
   }
 
   test_executable_type_param_in_return_type_method() {
     UnlinkedExecutable ex = serializeMethodText('T f<T>() => null;');
     checkParamTypeRef(ex.returnType, 1);
   }
 
+  test_export_class() {
+    addNamedSource('/a.dart', 'class C {}');
+    serializeLibraryText('export "a.dart";');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'C',
+        PrelinkedReferenceKind.classOrEnum);
+  }
+
+  test_export_class_alias() {
+    addNamedSource(
+        '/a.dart', 'class C extends _D with _E {} class _D {} class _E {}');
+    serializeLibraryText('export "a.dart";');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'C',
+        PrelinkedReferenceKind.classOrEnum);
+  }
+
+  test_export_enum() {
+    addNamedSource('/a.dart', 'enum E { v }');
+    serializeLibraryText('export "a.dart";');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'E',
+        PrelinkedReferenceKind.classOrEnum);
+  }
+
+  test_export_from_part() {
+    addNamedSource('/a.dart', 'library foo; part "b.dart";');
+    addNamedSource('/b.dart', 'part of foo; f() {}');
+    serializeLibraryText('export "a.dart";');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        PrelinkedReferenceKind.topLevelFunction,
+        expectedTargetUnit: 1);
+  }
+
+  test_export_function() {
+    addNamedSource('/a.dart', 'f() {}');
+    serializeLibraryText('export "a.dart";');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        PrelinkedReferenceKind.topLevelFunction);
+  }
+
+  test_export_getter() {
+    addNamedSource('/a.dart', 'get f => null');
+    serializeLibraryText('export "a.dart";');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        PrelinkedReferenceKind.topLevelPropertyAccessor);
+  }
+
+  test_export_hide() {
+    addNamedSource('/a.dart', 'f() {} g() {}');
+    serializeLibraryText('export "a.dart" hide g;');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        PrelinkedReferenceKind.topLevelFunction);
+  }
+
   test_export_hide_order() {
     serializeLibraryText('export "dart:async" hide Future, Stream;');
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(
         unlinkedUnits[0].publicNamespace.exports[0].combinators, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows,
         isEmpty);
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides,
         hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides[0],
         'Future');
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides[1],
         'Stream');
+    expect(prelinked.exportNames, isNotEmpty);
+  }
+
+  test_export_names_excludes_names_from_library() {
+    addNamedSource('/a.dart', 'part of my.lib; int y; int _y;');
+    serializeLibraryText('library my.lib; part "a.dart"; int x; int _x;');
+    expect(prelinked.exportNames, isEmpty);
   }
 
   test_export_no_combinators() {
     serializeLibraryText('export "dart:async";');
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators, isEmpty);
   }
 
+  test_export_not_shadowed_by_prefix() {
+    addNamedSource('/a.dart', 'f() {}');
+    serializeLibraryText('export "a.dart"; import "dart:core" as f; f.int _x;');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        PrelinkedReferenceKind.topLevelFunction);
+  }
+
   test_export_offset() {
     String libraryText = '    export "dart:async";';
     serializeLibraryText(libraryText);
     expect(unlinkedUnits[0].exports[0].uriOffset,
         libraryText.indexOf('"dart:async"'));
     expect(unlinkedUnits[0].exports[0].uriEnd, libraryText.indexOf(';'));
     expect(unlinkedUnits[0].exports[0].offset, libraryText.indexOf('export'));
   }
 
+  test_export_private() {
+    // Private names should not be exported.
+    addNamedSource('/a.dart', '_f() {}');
+    serializeLibraryText('export "a.dart";');
+    expect(prelinked.exportNames, isEmpty);
+  }
+
+  test_export_setter() {
+    addNamedSource('/a.dart', 'void set f(value) {}');
+    serializeLibraryText('export "a.dart";');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f=',
+        PrelinkedReferenceKind.topLevelPropertyAccessor);
+  }
+
+  test_export_shadowed() {
+    // f() is not shown in exportNames because it is already defined at top
+    // level in the library.
+    addNamedSource('/a.dart', 'f() {}');
+    serializeLibraryText('export "a.dart"; f() {}');
+    expect(prelinked.exportNames, isEmpty);
+  }
+
+  test_export_shadowed_variable() {
+    // Neither `v` nor `v=` is shown in exportNames because both are defined at
+    // top level in the library by the declaration `var v;`.
+    addNamedSource('/a.dart', 'var v;');
+    serializeLibraryText('export "a.dart"; var v;');
+    expect(prelinked.exportNames, isEmpty);
+  }
+
+  test_export_shadowed_variable_const() {
+    // `v=` is shown in exportNames because the top level declaration
+    // `const v = 0;` only shadows `v`, not `v=`.
+    addNamedSource('/a.dart', 'var v;');
+    serializeLibraryText('export "a.dart"; const v = 0;');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'v=',
+        PrelinkedReferenceKind.topLevelPropertyAccessor);
+  }
+
+  test_export_shadowed_variable_final() {
+    // `v=` is shown in exportNames because the top level declaration
+    // `final v = 0;` only shadows `v`, not `v=`.
+    addNamedSource('/a.dart', 'var v;');
+    serializeLibraryText('export "a.dart"; final v = 0;');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'v=',
+        PrelinkedReferenceKind.topLevelPropertyAccessor);
+  }
+
+  test_export_show() {
+    addNamedSource('/a.dart', 'f() {} g() {}');
+    serializeLibraryText('export "a.dart" show f;');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'f',
+        PrelinkedReferenceKind.topLevelFunction);
+  }
+
   test_export_show_order() {
     serializeLibraryText('export "dart:async" show Future, Stream;');
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(
         unlinkedUnits[0].publicNamespace.exports[0].combinators, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows,
         hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides,
         isEmpty);
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows[0],
         'Future');
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows[1],
         'Stream');
   }
 
+  test_export_typedef() {
+    addNamedSource('/a.dart', 'typedef F();');
+    serializeLibraryText('export "a.dart";');
+    expect(prelinked.exportNames, hasLength(1));
+    checkExportName(prelinked.exportNames[0], absUri('/a.dart'), 'a.dart', 'F',
+        PrelinkedReferenceKind.typedef);
+  }
+
   test_export_uri() {
     addNamedSource('/a.dart', 'library my.lib;');
     String uriString = '"a.dart"';
     String libraryText = 'export $uriString;';
     serializeLibraryText(libraryText);
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].uri, 'a.dart');
   }
 
+  test_export_variable() {
+    addNamedSource('/a.dart', 'var v;');
+    serializeLibraryText('export "a.dart";');
+    expect(prelinked.exportNames, hasLength(2));
+    PrelinkedExportName getter =
+        prelinked.exportNames.firstWhere((e) => e.name == 'v');
+    expect(getter, isNotNull);
+    checkExportName(getter, absUri('/a.dart'), 'a.dart', 'v',
+        PrelinkedReferenceKind.topLevelPropertyAccessor);
+    PrelinkedExportName setter =
+        prelinked.exportNames.firstWhere((e) => e.name == 'v=');
+    expect(setter, isNotNull);
+    checkExportName(setter, absUri('/a.dart'), 'a.dart', 'v=',
+        PrelinkedReferenceKind.topLevelPropertyAccessor);
+  }
+
   test_field() {
     UnlinkedClass cls = serializeClassText('class C { int i; }');
     UnlinkedVariable variable = findVariable('i', variables: cls.fields);
     expect(variable, isNotNull);
     expect(variable.isConst, isFalse);
     expect(variable.isStatic, isFalse);
     expect(variable.isFinal, isFalse);
     expect(findExecutable('i', executables: cls.executables), isNull);
     expect(findExecutable('i=', executables: cls.executables), isNull);
   }
@@ skipping 691 matching lines @@
   }
 
   test_variable() {
     String text = 'int i;';
     UnlinkedVariable v = serializeVariableText(text, variableName: 'i');
     expect(v.nameOffset, text.indexOf('i;'));
     expect(findExecutable('i'), isNull);
     expect(findExecutable('i='), isNull);
     expect(unlinkedUnits[0].publicNamespace.names, hasLength(2));
     expect(unlinkedUnits[0].publicNamespace.names[0].kind,
-        PrelinkedReferenceKind.other);
+        PrelinkedReferenceKind.topLevelPropertyAccessor);
     expect(unlinkedUnits[0].publicNamespace.names[0].name, 'i');
     expect(unlinkedUnits[0].publicNamespace.names[0].numTypeParameters, 0);
     expect(unlinkedUnits[0].publicNamespace.names[1].kind,
-        PrelinkedReferenceKind.other);
+        PrelinkedReferenceKind.topLevelPropertyAccessor);
     expect(unlinkedUnits[0].publicNamespace.names[1].name, 'i=');
     expect(unlinkedUnits[0].publicNamespace.names[1].numTypeParameters, 0);
   }
 
   test_variable_const() {
     UnlinkedVariable variable =
         serializeVariableText('const int i = 0;', variableName: 'i');
     expect(variable.isConst, isTrue);
   }
 
@@ skipping 76 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);
   }
 }