New analyzer snapshot.

pkg/analyzer/test/generated/element_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext, AnalysisContextImpl;
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'ast_test.dart' show ASTFactory;
-import 'resolver_test.dart' show TestTypeProvider;
+import 'resolver_test.dart' show TestTypeProvider, AnalysisContextHelper;
 
 class ElementLocationImplTest extends EngineTestCase {
   void test_create_encoding() {
     String encoding = "a;b;c";
     ElementLocationImpl location = new ElementLocationImpl.con2(encoding);
     JUnitTestCase.assertEquals(encoding, location.encoding);
   }
 
   void test_equals_equal() {
     String encoding = "a;b;c";
@@ skipping 189 matching lines @@
     List<PrefixElement> prefixes = library.prefixes;
     EngineTestCase.assertLength(2, prefixes);
     if (identical(prefixA, prefixes[0])) {
       JUnitTestCase.assertSame(prefixB, prefixes[1]);
     } else {
       JUnitTestCase.assertSame(prefixB, prefixes[0]);
       JUnitTestCase.assertSame(prefixA, prefixes[1]);
     }
   }
 
+  void test_getVisibleLibraries_cycle() {
+    AnalysisContext context = createAnalysisContext();
+    LibraryElementImpl library = ElementFactory.library(context, "app");
+    LibraryElementImpl libraryA = ElementFactory.library(context, "A");
+    libraryA.imports = <ImportElementImpl> [ElementFactory.importFor(library, null, [])];
+    library.imports = <ImportElementImpl> [ElementFactory.importFor(libraryA, null, [])];
+    List<LibraryElement> libraries = library.visibleLibraries;
+    EngineTestCase.assertEqualsIgnoreOrder(<LibraryElement> [library, libraryA], libraries);
+  }
+
+  void test_getVisibleLibraries_directExports() {
+    AnalysisContext context = createAnalysisContext();
+    LibraryElementImpl library = ElementFactory.library(context, "app");
+    LibraryElementImpl libraryA = ElementFactory.library(context, "A");
+    library.exports = <ExportElementImpl> [ElementFactory.exportFor(libraryA, [])];
+    List<LibraryElement> libraries = library.visibleLibraries;
+    EngineTestCase.assertEqualsIgnoreOrder(<LibraryElement> [library], libraries);
+  }
+
+  void test_getVisibleLibraries_directImports() {
+    AnalysisContext context = createAnalysisContext();
+    LibraryElementImpl library = ElementFactory.library(context, "app");
+    LibraryElementImpl libraryA = ElementFactory.library(context, "A");
+    library.imports = <ImportElementImpl> [ElementFactory.importFor(libraryA, null, [])];
+    List<LibraryElement> libraries = library.visibleLibraries;
+    EngineTestCase.assertEqualsIgnoreOrder(<LibraryElement> [library, libraryA], libraries);
+  }
+
+  void test_getVisibleLibraries_indirectExports() {
+    AnalysisContext context = createAnalysisContext();
+    LibraryElementImpl library = ElementFactory.library(context, "app");
+    LibraryElementImpl libraryA = ElementFactory.library(context, "A");
+    LibraryElementImpl libraryAA = ElementFactory.library(context, "AA");
+    libraryA.exports = <ExportElementImpl> [ElementFactory.exportFor(libraryAA, [])];
+    library.imports = <ImportElementImpl> [ElementFactory.importFor(libraryA, null, [])];
+    List<LibraryElement> libraries = library.visibleLibraries;
+    EngineTestCase.assertEqualsIgnoreOrder(<LibraryElement> [library, libraryA, libraryAA], libraries);
+  }
+
+  void test_getVisibleLibraries_indirectImports() {
+    AnalysisContext context = createAnalysisContext();
+    LibraryElementImpl library = ElementFactory.library(context, "app");
+    LibraryElementImpl libraryA = ElementFactory.library(context, "A");
+    LibraryElementImpl libraryAA = ElementFactory.library(context, "AA");
+    LibraryElementImpl libraryB = ElementFactory.library(context, "B");
+    libraryA.imports = <ImportElementImpl> [ElementFactory.importFor(libraryAA, null, [])];
+    library.imports = <ImportElementImpl> [
+        ElementFactory.importFor(libraryA, null, []),
+        ElementFactory.importFor(libraryB, null, [])];
+    List<LibraryElement> libraries = library.visibleLibraries;
+    EngineTestCase.assertEqualsIgnoreOrder(<LibraryElement> [library, libraryA, libraryAA, libraryB], libraries);
+  }
+
+  void test_getVisibleLibraries_noImports() {
+    AnalysisContext context = createAnalysisContext();
+    LibraryElementImpl library = ElementFactory.library(context, "app");
+    EngineTestCase.assertEqualsIgnoreOrder(<LibraryElement> [library], library.visibleLibraries);
+  }
+
   void test_isUpToDate() {
     AnalysisContext context = createAnalysisContext();
     context.sourceFactory = new SourceFactory.con2([]);
     LibraryElement library = ElementFactory.library(context, "foo");
     context.sourceFactory.setContents(library.definingCompilationUnit.source, "sdfsdff");
     JUnitTestCase.assertFalse(library.isUpToDate2(0));
     JUnitTestCase.assertTrue(library.isUpToDate2(JavaSystem.currentTimeMillis() + 1000));
   }
 
   void test_setImports() {
@@ skipping 17 matching lines @@
         runJUnitTest(__test, __test.test_creation);
       });
       _ut.test('test_getImportedLibraries', () {
         final __test = new LibraryElementImplTest();
         runJUnitTest(__test, __test.test_getImportedLibraries);
       });
       _ut.test('test_getPrefixes', () {
         final __test = new LibraryElementImplTest();
         runJUnitTest(__test, __test.test_getPrefixes);
       });
+      _ut.test('test_getVisibleLibraries_cycle', () {
+        final __test = new LibraryElementImplTest();
+        runJUnitTest(__test, __test.test_getVisibleLibraries_cycle);
+      });
+      _ut.test('test_getVisibleLibraries_directExports', () {
+        final __test = new LibraryElementImplTest();
+        runJUnitTest(__test, __test.test_getVisibleLibraries_directExports);
+      });
+      _ut.test('test_getVisibleLibraries_directImports', () {
+        final __test = new LibraryElementImplTest();
+        runJUnitTest(__test, __test.test_getVisibleLibraries_directImports);
+      });
+      _ut.test('test_getVisibleLibraries_indirectExports', () {
+        final __test = new LibraryElementImplTest();
+        runJUnitTest(__test, __test.test_getVisibleLibraries_indirectExports);
+      });
+      _ut.test('test_getVisibleLibraries_indirectImports', () {
+        final __test = new LibraryElementImplTest();
+        runJUnitTest(__test, __test.test_getVisibleLibraries_indirectImports);
+      });
+      _ut.test('test_getVisibleLibraries_noImports', () {
+        final __test = new LibraryElementImplTest();
+        runJUnitTest(__test, __test.test_getVisibleLibraries_noImports);
+      });
       _ut.test('test_isUpToDate', () {
         final __test = new LibraryElementImplTest();
         runJUnitTest(__test, __test.test_isUpToDate);
       });
       _ut.test('test_setImports', () {
         final __test = new LibraryElementImplTest();
         runJUnitTest(__test, __test.test_setImports);
       });
     });
   }
@@ skipping 1929 matching lines @@
     getter.static = isStatic;
     getter.variable = field;
     getter.returnType = type;
     field.getter = getter;
     FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
     getter.type = getterType;
     return getter;
   }
 
   static ImportElementImpl importFor(LibraryElement importedLibrary, PrefixElement prefix, List<NamespaceCombinator> combinators) {
-    ImportElementImpl spec = new ImportElementImpl();
+    ImportElementImpl spec = new ImportElementImpl(0);
     spec.importedLibrary = importedLibrary;
     spec.prefix = prefix;
     spec.combinators = combinators;
     return spec;
   }
 
   static LibraryElementImpl library(AnalysisContext context, String libraryName) {
     String fileName = "/${libraryName}.dart";
     FileBasedSource source = new FileBasedSource.con1(context.sourceFactory.contentCache, FileUtilities2.createFile(fileName));
     CompilationUnitElementImpl unit = new CompilationUnitElementImpl(fileName);
@@ skipping 200 matching lines @@
   }
 
   void test_getMethod_undeclared() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement method = ElementFactory.methodElement(methodName, null, []);
     classA.methods = <MethodElement> [method];
     JUnitTestCase.assertNull(classA.getMethod("${methodName}x"));
   }
 
+  void test_getNode() {
+    AnalysisContextHelper contextHelper = new AnalysisContextHelper();
+    AnalysisContext context = contextHelper.context;
+    Source source = contextHelper.addSource("/test.dart", EngineTestCase.createSource(["class A {}", "class B {}"]));
+    LibraryElement libraryElement = context.computeLibraryElement(source);
+    CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
+    {
+      ClassElement elementA = unitElement.getType("A");
+      ClassDeclaration nodeA = elementA.node;
+      JUnitTestCase.assertNotNull(nodeA);
+      JUnitTestCase.assertEquals("A", nodeA.name.name);
+      JUnitTestCase.assertSame(elementA, nodeA.element);
+    }
+    {
+      ClassElement elementB = unitElement.getType("B");
+      ClassDeclaration nodeB = elementB.node;
+      JUnitTestCase.assertNotNull(nodeB);
+      JUnitTestCase.assertEquals("B", nodeB.name.name);
+      JUnitTestCase.assertSame(elementB, nodeB.element);
+    }
+  }
+
   void test_hasNonFinalField_false_const() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.fields = <FieldElement> [ElementFactory.fieldElement("f", false, false, true, classA.type)];
     JUnitTestCase.assertFalse(classA.hasNonFinalField());
   }
 
   void test_hasNonFinalField_false_final() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     classA.fields = <FieldElement> [ElementFactory.fieldElement("f", false, true, false, classA.type)];
     JUnitTestCase.assertFalse(classA.hasNonFinalField());
@@ skipping 145 matching lines @@
         runJUnitTest(__test, __test.test_getAllSupertypes_recursive);
       });
       _ut.test('test_getMethod_declared', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_getMethod_declared);
       });
       _ut.test('test_getMethod_undeclared', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_getMethod_undeclared);
       });
+      _ut.test('test_getNode', () {
+        final __test = new ClassElementImplTest();
+        runJUnitTest(__test, __test.test_getNode);
+      });
       _ut.test('test_hasNonFinalField_false_const', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_hasNonFinalField_false_const);
       });
       _ut.test('test_hasNonFinalField_false_final', () {
         final __test = new ClassElementImplTest();
         runJUnitTest(__test, __test.test_hasNonFinalField_false_final);
       });
       _ut.test('test_hasNonFinalField_false_recursive', () {
         final __test = new ClassElementImplTest();
@@ skipping 97 matching lines @@
     JUnitTestCase.assertTrue(classElement.isAccessibleIn(library2));
   }
 
   void test_isAccessibleIn_public_sameLibrary() {
     LibraryElementImpl library = ElementFactory.library(createAnalysisContext(), "lib");
     ClassElement classElement = ElementFactory.classElement2("C", []);
     (library.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [classElement];
     JUnitTestCase.assertTrue(classElement.isAccessibleIn(library));
   }
 
+  void test_isPrivate_false() {
+    Element element = ElementFactory.classElement2("C", []);
+    JUnitTestCase.assertFalse(element.isPrivate);
+  }
+
+  void test_isPrivate_null() {
+    Element element = ElementFactory.classElement2(null, []);
+    JUnitTestCase.assertTrue(element.isPrivate);
+  }
+
+  void test_isPrivate_true() {
+    Element element = ElementFactory.classElement2("_C", []);
+    JUnitTestCase.assertTrue(element.isPrivate);
+  }
+
+  void test_isPublic_false() {
+    Element element = ElementFactory.classElement2("_C", []);
+    JUnitTestCase.assertFalse(element.isPublic);
+  }
+
+  void test_isPublic_null() {
+    Element element = ElementFactory.classElement2(null, []);
+    JUnitTestCase.assertFalse(element.isPublic);
+  }
+
+  void test_isPublic_true() {
+    Element element = ElementFactory.classElement2("C", []);
+    JUnitTestCase.assertTrue(element.isPublic);
+  }
+
   void test_SORT_BY_OFFSET() {
     ClassElementImpl classElementA = ElementFactory.classElement2("A", []);
     classElementA.nameOffset = 1;
     ClassElementImpl classElementB = ElementFactory.classElement2("B", []);
     classElementB.nameOffset = 2;
     JUnitTestCase.assertEquals(0, Element.SORT_BY_OFFSET(classElementA, classElementA));
     JUnitTestCase.assertTrue(Element.SORT_BY_OFFSET(classElementA, classElementB) < 0);
     JUnitTestCase.assertTrue(Element.SORT_BY_OFFSET(classElementB, classElementA) > 0);
   }
 
@@ skipping 16 matching lines @@
         runJUnitTest(__test, __test.test_isAccessibleIn_private_sameLibrary);
       });
       _ut.test('test_isAccessibleIn_public_differentLibrary', () {
         final __test = new ElementImplTest();
         runJUnitTest(__test, __test.test_isAccessibleIn_public_differentLibrary);
       });
       _ut.test('test_isAccessibleIn_public_sameLibrary', () {
         final __test = new ElementImplTest();
         runJUnitTest(__test, __test.test_isAccessibleIn_public_sameLibrary);
       });
+      _ut.test('test_isPrivate_false', () {
+        final __test = new ElementImplTest();
+        runJUnitTest(__test, __test.test_isPrivate_false);
+      });
+      _ut.test('test_isPrivate_null', () {
+        final __test = new ElementImplTest();
+        runJUnitTest(__test, __test.test_isPrivate_null);
+      });
+      _ut.test('test_isPrivate_true', () {
+        final __test = new ElementImplTest();
+        runJUnitTest(__test, __test.test_isPrivate_true);
+      });
+      _ut.test('test_isPublic_false', () {
+        final __test = new ElementImplTest();
+        runJUnitTest(__test, __test.test_isPublic_false);
+      });
+      _ut.test('test_isPublic_null', () {
+        final __test = new ElementImplTest();
+        runJUnitTest(__test, __test.test_isPublic_null);
+      });
+      _ut.test('test_isPublic_true', () {
+        final __test = new ElementImplTest();
+        runJUnitTest(__test, __test.test_isPublic_true);
+      });
     });
   }
 }
 
 class FunctionTypeImplTest extends EngineTestCase {
   void test_creation() {
     JUnitTestCase.assertNotNull(new FunctionTypeImpl.con1(new FunctionElementImpl.con1(ASTFactory.identifier3("f"))));
   }
 
   void test_getElement() {
@@ skipping 44 matching lines @@
     FunctionType t = ElementFactory.functionElement6("t", null, <ClassElement> [a]).type;
     FunctionType s = ElementFactory.functionElement5("s", <ClassElement> [a]).type;
     JUnitTestCase.assertTrue(t.isSubtypeOf(s));
     JUnitTestCase.assertFalse(s.isSubtypeOf(t));
     JUnitTestCase.assertTrue(t.isAssignableTo(s));
     JUnitTestCase.assertFalse(s.isAssignableTo(t));
   }
 
   void test_isSubtypeOf_baseCase_classFunction() {
     ClassElementImpl functionElement = ElementFactory.classElement2("Function", []);
-    InterfaceTypeImpl functionType = new InterfaceTypeImpl_26(functionElement);
+    InterfaceTypeImpl functionType = new InterfaceTypeImpl_27(functionElement);
     FunctionType f = ElementFactory.functionElement("f").type;
     JUnitTestCase.assertTrue(f.isSubtypeOf(functionType));
   }
 
   void test_isSubtypeOf_baseCase_notFunctionType() {
     FunctionType f = ElementFactory.functionElement("f").type;
     InterfaceType t = ElementFactory.classElement2("C", []).type;
     JUnitTestCase.assertFalse(f.isSubtypeOf(t));
   }
 
@@ skipping 478 matching lines @@
         runJUnitTest(__test, __test.test_substitute2_equal);
       });
       _ut.test('test_substitute2_notEqual', () {
         final __test = new FunctionTypeImplTest();
         runJUnitTest(__test, __test.test_substitute2_notEqual);
       });
     });
   }
 }
 
-class InterfaceTypeImpl_26 extends InterfaceTypeImpl {
-  InterfaceTypeImpl_26(ClassElement arg0) : super.con1(arg0);
+class InterfaceTypeImpl_27 extends InterfaceTypeImpl {
+  InterfaceTypeImpl_27(ClassElement arg0) : super.con1(arg0);
 
   bool get isDartCoreFunction => true;
 }
 
 main() {
   ElementKindTest.dartSuite();
   FunctionTypeImplTest.dartSuite();
   InterfaceTypeImplTest.dartSuite();
   TypeParameterTypeImplTest.dartSuite();
   VoidTypeImplTest.dartSuite();
   ClassElementImplTest.dartSuite();
   ElementLocationImplTest.dartSuite();
   ElementImplTest.dartSuite();
   LibraryElementImplTest.dartSuite();
   MultiplyDefinedElementImplTest.dartSuite();
 }