Create a section of the summary for public namespace information.

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/engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 474 matching lines @@
 
   /**
    * Serialize a type declaration using the given [text] as a type name, and
    * return a summary of the corresponding [UnlinkedTypeRef].  If the type
    * declaration needs to refer to types that are not available in core, those
    * types may be declared in [otherDeclarations].
    */
   UnlinkedTypeRef serializeTypeText(String text,
       {String otherDeclarations: '', bool allowErrors: false}) {
     return serializeVariableText('$otherDeclarations\n$text v;',
-            allowErrors: allowErrors)
-        .type;
+        allowErrors: allowErrors).type;
   }
 
   /**
    * Serialize the given library [text] and return the summary of the variable
    * with the given [variableName].
    */
   UnlinkedVariable serializeVariableText(String text,
       {String variableName: 'v', bool allowErrors: false}) {
     serializeLibraryText(text, allowErrors: allowErrors);
     return findVariable(variableName, failIfAbsent: true);
@@ skipping 133 matching lines @@
   }
 
   test_class_alias_abstract() {
     UnlinkedClass cls = serializeClassText(
         'abstract class C = D with E; class D {} class E {}');
     expect(cls.isAbstract, true);
   }
 
   test_class_alias_concrete() {
     UnlinkedClass cls =
-        serializeClassText('class C = D with E; class D {} class E {}');
+        serializeClassText('class C = _D with _E; class _D {} class _E {}');
     expect(cls.isAbstract, false);
+    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
+        PrelinkedReferenceKind.classOrEnum);
+    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
   }
 
   test_class_alias_flag() {
     UnlinkedClass cls =
         serializeClassText('class C = D with E; class D {} class E {}');
     expect(cls.isMixinApplication, true);
   }
 
   test_class_alias_mixin_order() {
     UnlinkedClass cls = serializeClassText('''
@@ skipping 12 matching lines @@
 class C = D with E;
 class D {
   D.foo();
   D.bar();
 }
 class E {}
 ''');
     expect(cls.executables, isEmpty);
   }
 
+  test_class_alias_private() {
+    serializeClassText('class _C = _D with _E; class _D {} class _E {}', '_C');
+    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
+  }
+
   test_class_alias_supertype() {
     UnlinkedClass cls =
         serializeClassText('class C = D with E; class D {} class E {}');
     checkTypeRef(cls.supertype, null, null, 'D');
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_concrete() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.isAbstract, false);
+    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
+        PrelinkedReferenceKind.classOrEnum);
+    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'C');
   }
 
   test_class_interface() {
     UnlinkedClass cls = serializeClassText('''
 class C implements D {}
 class D {}
 ''');
     expect(cls.interfaces, hasLength(1));
     checkTypeRef(cls.interfaces[0], null, null, 'D');
   }
@@ skipping 54 matching lines @@
   test_class_no_type_param() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.typeParameters, isEmpty);
   }
 
   test_class_non_alias_flag() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.isMixinApplication, false);
   }
 
+  test_class_private() {
+    serializeClassText('class _C {}', '_C');
+    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
+  }
+
   test_class_superclass() {
     UnlinkedClass cls = serializeClassText('class C {}');
     expect(cls.supertype, isNull);
     expect(cls.hasNoSupertype, isFalse);
   }
 
   test_class_superclass_explicit() {
     UnlinkedClass cls = serializeClassText('class C extends D {} class D {}');
     expect(cls.supertype, isNotNull);
     checkTypeRef(cls.supertype, null, null, 'D');
@@ skipping 354 matching lines @@
     expect(findVariable('v', variables: unit.variables), isNotNull);
     expect(findExecutable('f', executables: unit.executables), isNotNull);
     expect(findTypedef('F', unit: unit), isNotNull);
   }
 
   test_enum() {
     UnlinkedEnum e = serializeEnumText('enum E { v1 }');
     expect(e.name, 'E');
     expect(e.values, hasLength(1));
     expect(e.values[0].name, 'v1');
+    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
+        PrelinkedReferenceKind.classOrEnum);
+    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'E');
   }
 
   test_enum_order() {
     UnlinkedEnum e = serializeEnumText('enum E { v1, v2 }');
     expect(e.values, hasLength(2));
     expect(e.values[0].name, 'v1');
     expect(e.values[1].name, 'v2');
   }
 
+  test_enum_private() {
+    serializeEnumText('enum _E { v1 }', '_E');
+    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
+  }
+
   test_executable_abstract() {
     UnlinkedExecutable executable =
         serializeClassText('abstract class C { f(); }').executables[0];
     expect(executable.isAbstract, isTrue);
   }
 
   test_executable_concrete() {
     UnlinkedExecutable executable =
         serializeClassText('abstract class C { f() {} }').executables[0];
     expect(executable.isAbstract, isFalse);
   }
 
   test_executable_function() {
     UnlinkedExecutable executable = serializeExecutableText('f() {}');
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.hasImplicitReturnType, isTrue);
     checkDynamicTypeRef(executable.returnType);
     expect(executable.isExternal, isFalse);
+    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
+        PrelinkedReferenceKind.other);
+    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'f');
   }
 
   test_executable_function_explicit_return() {
     UnlinkedExecutable executable =
         serializeExecutableText('dynamic f() => null;');
     expect(executable.hasImplicitReturnType, isFalse);
     checkDynamicTypeRef(executable.returnType);
   }
 
   test_executable_function_external() {
     UnlinkedExecutable executable = serializeExecutableText('external f();');
     expect(executable.isExternal, isTrue);
   }
 
+  test_executable_function_private() {
+    serializeExecutableText('_f() {}', '_f');
+    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
+  }
+
   test_executable_getter() {
     UnlinkedExecutable executable = serializeExecutableText('int get f => 1;');
     expect(executable.kind, UnlinkedExecutableKind.getter);
     expect(executable.hasImplicitReturnType, isFalse);
     expect(executable.isExternal, isFalse);
     expect(findVariable('f'), isNull);
     expect(findExecutable('f='), isNull);
+    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
+        PrelinkedReferenceKind.other);
+    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() {
+    serializeExecutableText('int get _f => 1;', '_f');
+    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
+  }
+
   test_executable_getter_type() {
     UnlinkedExecutable executable = serializeExecutableText('int get f => 1;');
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'int');
     expect(executable.parameters, isEmpty);
   }
 
   test_executable_getter_type_implicit() {
     UnlinkedExecutable executable = serializeExecutableText('get f => 1;');
     checkDynamicTypeRef(executable.returnType);
     expect(executable.hasImplicitReturnType, isTrue);
@@ skipping 142 matching lines @@
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(1));
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'bool');
     expect(executable.typeParameters, isEmpty);
   }
 
   test_executable_operator_index_set() {
     UnlinkedExecutable executable = serializeClassText(
-            'class C { void operator[]=(int i, bool v) => null; }')
-        .executables[0];
+        'class C { void operator[]=(int i, bool v) => null; }').executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]=');
     expect(executable.hasImplicitReturnType, false);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(2));
     expect(executable.returnType, isNull);
     expect(executable.typeParameters, isEmpty);
@@ skipping 128 matching lines @@
   }
 
   test_executable_setter() {
     UnlinkedExecutable executable =
         serializeExecutableText('void set f(value) {}', 'f=');
     expect(executable.kind, UnlinkedExecutableKind.setter);
     expect(executable.hasImplicitReturnType, isFalse);
     expect(executable.isExternal, isFalse);
     expect(findVariable('f'), isNull);
     expect(findExecutable('f'), isNull);
+    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
+        PrelinkedReferenceKind.other);
+    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() {
     UnlinkedExecutable executable =
         serializeExecutableText('set f(value) {}', 'f=');
     // For setters, hasImplicitReturnType is always false.
     expect(executable.hasImplicitReturnType, isFalse);
     checkDynamicTypeRef(executable.returnType);
   }
 
+  test_executable_setter_private() {
+    serializeExecutableText('void set _f(value) {}', '_f=');
+    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
+  }
+
   test_executable_setter_type() {
     UnlinkedExecutable executable =
         serializeExecutableText('void set f(int value) {}', 'f=');
     expect(executable.returnType, isNull);
     expect(executable.parameters, hasLength(1));
     expect(executable.parameters[0].name, 'value');
     checkTypeRef(
         executable.parameters[0].type, 'dart:core', 'dart:core', 'int');
   }
 
@@ skipping 26 matching lines @@
   }
 
   test_executable_type_param_in_return_type() {
     // TODO(paulberry): also test top level executables.
     UnlinkedExecutable ex = serializeMethodText('T f<T>() => null;');
     checkParamTypeRef(ex.returnType, 1);
   }
 
   test_export_hide_order() {
     serializeLibraryText('export "dart:async" hide Future, Stream;');
-    expect(unlinkedUnits[0].exports, hasLength(1));
-    expect(unlinkedUnits[0].exports[0].combinators, hasLength(1));
-    expect(unlinkedUnits[0].exports[0].combinators[0].shows, isEmpty);
-    expect(unlinkedUnits[0].exports[0].combinators[0].hides, hasLength(2));
+    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));
     checkCombinatorName(
-        unlinkedUnits[0].exports[0].combinators[0].hides[0], 'Future');
+        unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides[0],
+        'Future');
     checkCombinatorName(
-        unlinkedUnits[0].exports[0].combinators[0].hides[1], 'Stream');
+        unlinkedUnits[0].publicNamespace.exports[0].combinators[0].hides[1],
+        'Stream');
   }
 
   test_export_no_combinators() {
     serializeLibraryText('export "dart:async";');
-    expect(unlinkedUnits[0].exports, hasLength(1));
-    expect(unlinkedUnits[0].exports[0].combinators, isEmpty);
+    expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.exports[0].combinators, isEmpty);
   }
 
   test_export_show_order() {
     serializeLibraryText('export "dart:async" show Future, Stream;');
-    expect(unlinkedUnits[0].exports, hasLength(1));
-    expect(unlinkedUnits[0].exports[0].combinators, hasLength(1));
-    expect(unlinkedUnits[0].exports[0].combinators[0].shows, hasLength(2));
-    expect(unlinkedUnits[0].exports[0].combinators[0].hides, isEmpty);
+    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);
     checkCombinatorName(
-        unlinkedUnits[0].exports[0].combinators[0].shows[0], 'Future');
+        unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows[0],
+        'Future');
     checkCombinatorName(
-        unlinkedUnits[0].exports[0].combinators[0].shows[1], 'Stream');
+        unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows[1],
+        'Stream');
   }
 
   test_export_uri() {
     addNamedSource('/a.dart', 'library my.lib;');
     String uriString = '"a.dart"';
     String libraryText = 'export $uriString;';
     serializeLibraryText(libraryText);
-    expect(unlinkedUnits[0].exports, hasLength(1));
-    expect(unlinkedUnits[0].exports[0].uri, 'a.dart');
+    expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.exports[0].uri, 'a.dart');
   }
 
   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);
@@ skipping 122 matching lines @@
     checkPrefix(unlinkedUnits[0].imports[0].prefixReference, 'a');
   }
 
   test_import_prefix_none() {
     serializeLibraryText('import "dart:async"; Future x;');
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
     expect(unlinkedUnits[0].imports[0].prefixReference, 0);
   }
 
+  test_import_prefix_not_in_public_namespace() {
+    serializeLibraryText('import "dart:async" as a; a.Future v;');
+    expect(unlinkedUnits[0].publicNamespace.names, hasLength(2));
+    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'v');
+    expect(unlinkedUnits[0].publicNamespace.names[1].name, 'v=');
+  }
+
   test_import_prefix_reference() {
     UnlinkedVariable variable =
         serializeVariableText('import "dart:async" as a; a.Future v;');
     checkTypeRef(variable.type, 'dart:async', 'dart:async', 'Future',
         expectedPrefix: 'a');
   }
 
   test_import_reference() {
     UnlinkedVariable variable =
         serializeVariableText('import "dart:async"; Future v;');
@@ skipping 57 matching lines @@
   }
 
   test_library_unnamed() {
     serializeLibraryText('');
     expect(unlinkedUnits[0].libraryName, isEmpty);
   }
 
   test_parts_defining_compilation_unit() {
     serializeLibraryText('');
     expect(prelinked.units, hasLength(1));
-    expect(unlinkedUnits[0].parts, isEmpty);
+    expect(unlinkedUnits[0].publicNamespace.parts, isEmpty);
   }
 
   test_parts_included() {
     addNamedSource('/part1.dart', 'part of my.lib;');
     String partString = '"part1.dart"';
     String libraryText = 'library my.lib; part $partString;';
     serializeLibraryText(libraryText);
     expect(prelinked.units, hasLength(2));
-    expect(unlinkedUnits[0].parts, hasLength(1));
-    expect(unlinkedUnits[0].parts[0].uri, 'part1.dart');
+    expect(unlinkedUnits[0].publicNamespace.parts, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.parts[0].uri, 'part1.dart');
+  }
+
+  test_public_namespace_of_part() {
+    addNamedSource('/a.dart', 'part of foo; class C {}');
+    serializeLibraryText('library foo; part "a.dart";');
+    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
+    expect(unlinkedUnits[1].publicNamespace.names, hasLength(1));
+    expect(unlinkedUnits[1].publicNamespace.names[0].name, 'C');
   }
 
   test_type_arguments_explicit() {
     UnlinkedTypeRef typeRef = serializeTypeText('List<int>');
     checkTypeRef(typeRef, 'dart:core', 'dart:core', 'List',
         allowTypeParameters: true);
     expect(typeRef.typeArguments, hasLength(1));
     checkTypeRef(typeRef.typeArguments[0], 'dart:core', 'dart:core', 'int');
   }
 
@@ skipping 186 matching lines @@
   }
 
   test_type_unresolved() {
     UnlinkedTypeRef typeRef = serializeTypeText('Foo', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, null, 'Foo');
   }
 
   test_typedef_name() {
     UnlinkedTypedef type = serializeTypedefText('typedef F();');
     expect(type.name, 'F');
+    expect(unlinkedUnits[0].publicNamespace.names, hasLength(1));
+    expect(unlinkedUnits[0].publicNamespace.names[0].kind,
+        PrelinkedReferenceKind.typedef);
+    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'F');
   }
 
   test_typedef_param_none() {
     UnlinkedTypedef type = serializeTypedefText('typedef F();');
     expect(type.parameters, isEmpty);
   }
 
   test_typedef_param_order() {
     UnlinkedTypedef type = serializeTypedefText('typedef F(x, y);');
     expect(type.parameters, hasLength(2));
     expect(type.parameters[0].name, 'x');
     expect(type.parameters[1].name, 'y');
   }
 
+  test_typedef_private() {
+    serializeTypedefText('typedef _F();', '_F');
+    expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
+  }
+
   test_typedef_return_type_explicit() {
     UnlinkedTypedef type = serializeTypedefText('typedef int F();');
     checkTypeRef(type.returnType, 'dart:core', 'dart:core', 'int');
   }
 
   test_typedef_type_param_in_parameter() {
     UnlinkedTypedef type = serializeTypedefText('typedef F<T>(T t);');
     checkParamTypeRef(type.parameters[0].type, 1);
   }
 
@@ skipping 11 matching lines @@
     UnlinkedTypedef type = serializeTypedefText('typedef F<T, U>();');
     expect(type.typeParameters, hasLength(2));
     expect(type.typeParameters[0].name, 'T');
     expect(type.typeParameters[1].name, 'U');
   }
 
   test_variable() {
     serializeVariableText('int i;', variableName: '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);
+    expect(unlinkedUnits[0].publicNamespace.names[0].name, 'i');
+    expect(unlinkedUnits[0].publicNamespace.names[1].kind,
+        PrelinkedReferenceKind.other);
+    expect(unlinkedUnits[0].publicNamespace.names[1].name, 'i=');
   }
 
   test_variable_const() {
     UnlinkedVariable variable =
         serializeVariableText('const int i = 0;', variableName: 'i');
     expect(variable.isConst, isTrue);
   }
 
   test_variable_explicit_dynamic() {
     UnlinkedVariable variable = serializeVariableText('dynamic v;');
@@ skipping 56 matching lines @@
     UnlinkedVariable variable =
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
   }
 
   test_variable_type() {
     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);
+  }
 }