New analyzer snapshot.

pkg/analyzer/test/generated/resolver_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.resolver_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/scanner.dart';
@@ skipping 8792 matching lines @@
         runJUnitTest(__test, __test.test_visitTypeName_void);
       });
     });
   }
 }
 
 class ResolverTestCase extends EngineTestCase {
   /**
    * The source factory used to create [Source].
    */
-  SourceFactory sourceFactory;
+  SourceFactory _sourceFactory;
 
   /**
    * The analysis context used to parse the compilation units being resolved.
    */
-  AnalysisContextImpl analysisContext;
+  AnalysisContextImpl _analysisContext;
 
   void setUp() {
     reset();
   }
 
   /**
    * Add a source file to the content provider.
    *
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addSource(String contents) => addSource2("/test.dart", contents);
 
   /**
    * Add a source file to the content provider. The file path should be absolute.
    *
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addSource2(String filePath, String contents) {
     Source source = cacheSource(filePath, contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.added(source);
-    analysisContext.applyChanges(changeSet);
+    _analysisContext.applyChanges(changeSet);
     return source;
   }
 
   /**
    * Assert that the number of errors reported against the given source matches the number of errors
    * that are given and that they have the expected error codes. The order in which the errors were
    * gathered is ignored.
    *
    * @param source the source against which the errors should have been reported
    * @param expectedErrorCodes the error codes of the errors that should have been reported
    * @throws AnalysisException if the reported errors could not be computed
    * @throws AssertionFailedError if a different number of errors have been reported than were
    *           expected
    */
   void assertErrors(Source source, List<ErrorCode> expectedErrorCodes) {
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    for (AnalysisError error in analysisContext.computeErrors(source)) {
+    for (AnalysisError error in _analysisContext.computeErrors(source)) {
       errorListener.onError(error);
     }
     errorListener.assertErrors2(expectedErrorCodes);
   }
 
   /**
    * Assert that no errors have been reported against the given source.
    *
    * @param source the source against which no errors should have been reported
    * @throws AnalysisException if the reported errors could not be computed
    * @throws AssertionFailedError if any errors have been reported
    */
   void assertNoErrors(Source source) {
     assertErrors(source, []);
   }
 
   /**
    * Cache the source file content in the source factory but don't add the source to the analysis
    * context. The file path should be absolute.
    *
    * @param filePath the path of the file being cached
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the cached file
    */
   Source cacheSource(String filePath, String contents) {
-    Source source = new FileBasedSource.con1(sourceFactory.contentCache, FileUtilities2.createFile(filePath));
-    sourceFactory.setContents(source, contents);
+    Source source = new FileBasedSource.con1(_sourceFactory.contentCache, FileUtilities2.createFile(filePath));
+    _sourceFactory.setContents(source, contents);
     return source;
   }
 
   /**
    * Create a library element that represents a library named `"test"` containing a single
    * empty compilation unit.
    *
    * @return the library element that was created
    */
   LibraryElementImpl createTestLibrary() => createTestLibrary2(new AnalysisContextImpl(), "test", []);
@@ skipping 19 matching lines @@
     }
     String fileName = "${libraryName}.dart";
     CompilationUnitElementImpl compilationUnit = new CompilationUnitElementImpl(fileName);
     compilationUnit.source = createSource2(fileName);
     LibraryElementImpl library = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2([libraryName]));
     library.definingCompilationUnit = compilationUnit;
     library.parts = sourcedCompilationUnits;
     return library;
   }
 
+  AnalysisContext get analysisContext => _analysisContext;
+
+  SourceFactory get sourceFactory => _sourceFactory;
+
   /**
    * Return a type provider that can be used to test the results of resolution.
    *
    * @return a type provider
+   * @throws AnalysisException if dart:core cannot be resolved
    */
-  TypeProvider get typeProvider {
-    Source coreSource = analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
-    LibraryElement coreElement = analysisContext.getLibraryElement(coreSource);
-    return new TypeProviderImpl(coreElement);
-  }
+  TypeProvider get typeProvider => _analysisContext.typeProvider;
 
   /**
    * In the rare cases we want to group several tests into single "test_" method, so need a way to
    * reset test instance to reuse it.
    */
   void reset() {
-    analysisContext = AnalysisContextFactory.contextWithCore();
-    sourceFactory = analysisContext.sourceFactory;
+    _analysisContext = AnalysisContextFactory.contextWithCore();
+    _sourceFactory = _analysisContext.sourceFactory;
   }
 
   /**
    * Given a library and all of its parts, resolve the contents of the library and the contents of
    * the parts. This assumes that the sources for the library and its parts have already been added
    * to the content provider using the method [addSource].
    *
    * @param librarySource the source for the compilation unit that defines the library
    * @return the element representing the resolved library
    * @throws AnalysisException if the analysis could not be performed
    */
-  LibraryElement resolve(Source librarySource) => analysisContext.computeLibraryElement(librarySource);
+  LibraryElement resolve(Source librarySource) => _analysisContext.computeLibraryElement(librarySource);
 
   /**
    * Return the resolved compilation unit corresponding to the given source in the given library.
    *
    * @param source the source of the compilation unit to be returned
    * @param library the library in which the compilation unit is to be resolved
    * @return the resolved compilation unit
    * @throws Exception if the compilation unit could not be resolved
    */
-  CompilationUnit resolveCompilationUnit(Source source, LibraryElement library) => analysisContext.resolveCompilationUnit(source, library);
+  CompilationUnit resolveCompilationUnit(Source source, LibraryElement library) => _analysisContext.resolveCompilationUnit(source, library);
 
   /**
    * Verify that all of the identifiers in the compilation units associated with the given sources
    * have been resolved.
    *
    * @param resolvedElementMap a table mapping the AST nodes that have been resolved to the element
    *          to which they were resolved
    * @param sources the sources identifying the compilation units to be verified
    * @throws Exception if the contents of the compilation unit cannot be accessed
    */
   void verify(List<Source> sources) {
     ResolutionVerifier verifier = new ResolutionVerifier();
     for (Source source in sources) {
-      analysisContext.parseCompilationUnit(source).accept(verifier);
+      _analysisContext.parseCompilationUnit(source).accept(verifier);
     }
     verifier.assertResolved();
   }
 
   /**
    * Create a source object representing a file with the given name and give it an empty content.
    *
    * @param fileName the name of the file for which a source is to be created
    * @return the source that was created
    */
   FileBasedSource createSource2(String fileName) {
-    FileBasedSource source = new FileBasedSource.con1(sourceFactory.contentCache, FileUtilities2.createFile(fileName));
-    sourceFactory.setContents(source, "");
+    FileBasedSource source = new FileBasedSource.con1(_sourceFactory.contentCache, FileUtilities2.createFile(fileName));
+    _sourceFactory.setContents(source, "");
     return source;
   }
 
   static dartSuite() {
     _ut.group('ResolverTestCase', () {
     });
   }
 }
 
 class TypeProviderImplTest extends EngineTestCase {
@@ skipping 9942 matching lines @@
 /**
  * The class `AnalysisContextFactory` defines utility methods used to create analysis contexts
  * for testing purposes.
  */
 class AnalysisContextFactory {
   /**
    * Create an analysis context that has a fake core library already resolved.
    *
    * @return the analysis context that was created
    */
-  static AnalysisContextImpl contextWithCore() {
+  static AnalysisContextImpl contextWithCore() => initContextWithCore(new DelegatingAnalysisContextImpl());
+
+  /**
+   * Initialize the given analysis context with a fake core library already resolved.
+   *
+   * @param context the context to be initialized (not `null`)
+   * @return the analysis context that was created
+   */
+  static AnalysisContextImpl initContextWithCore(AnalysisContextImpl context) {
     AnalysisContext sdkContext = DirectoryBasedDartSdk.defaultSdk.context;
     SourceFactory sourceFactory = sdkContext.sourceFactory;
     TestTypeProvider provider = new TestTypeProvider();
     CompilationUnitElementImpl coreUnit = new CompilationUnitElementImpl("core.dart");
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     sdkContext.setContents(coreSource, "");
     coreUnit.source = coreSource;
     coreUnit.types = <ClassElement> [
         provider.boolType.element,
         provider.deprecatedType.element,
@@ skipping 42 matching lines @@
     htmlUnit.functions = <FunctionElement> [ElementFactory.functionElement3("query", elementElement, <ClassElement> [provider.stringType.element], ClassElementImpl.EMPTY_ARRAY)];
     TopLevelVariableElementImpl document = ElementFactory.topLevelVariableElement3("document", false, true, htmlDocumentElement.type);
     htmlUnit.topLevelVariables = <TopLevelVariableElement> [document];
     htmlUnit.accessors = <PropertyAccessorElement> [document.getter];
     LibraryElementImpl htmlLibrary = new LibraryElementImpl(sdkContext, ASTFactory.libraryIdentifier2(["dart", "dom", "html"]));
     htmlLibrary.definingCompilationUnit = htmlUnit;
     Map<Source, LibraryElement> elementMap = new Map<Source, LibraryElement>();
     elementMap[coreSource] = coreLibrary;
     elementMap[htmlSource] = htmlLibrary;
     (sdkContext as AnalysisContextImpl).recordLibraryElements(elementMap);
-    AnalysisContextImpl context = new DelegatingAnalysisContextImpl();
     sourceFactory = new SourceFactory.con2([
         new DartUriResolver(sdkContext.sourceFactory.dartSdk),
         new FileUriResolver()]);
     context.sourceFactory = sourceFactory;
     return context;
   }
 }
 
 class LibraryImportScopeTest extends ResolverTestCase {
   void test_conflictingImports() {
@@ skipping 2369 matching lines @@
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_unusedImport_prefix_topLevelFunction);
       });
     });
   }
 }
 
 class EnclosedScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     GatheringErrorListener errorListener2 = new GatheringErrorListener();
-    Scope rootScope = new Scope_23(errorListener2);
+    Scope rootScope = new Scope_24(errorListener2);
     EnclosedScope scope = new EnclosedScope(rootScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     scope.define(element1);
     scope.define(element2);
     errorListener2.assertErrors3([ErrorSeverity.ERROR]);
   }
 
   void test_define_normal() {
     GatheringErrorListener errorListener3 = new GatheringErrorListener();
-    Scope rootScope = new Scope_24(errorListener3);
+    Scope rootScope = new Scope_25(errorListener3);
     EnclosedScope outerScope = new EnclosedScope(rootScope);
     EnclosedScope innerScope = new EnclosedScope(outerScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v2"));
     outerScope.define(element1);
     innerScope.define(element2);
     errorListener3.assertNoErrors();
   }
 
   static dartSuite() {
     _ut.group('EnclosedScopeTest', () {
       _ut.test('test_define_duplicate', () {
         final __test = new EnclosedScopeTest();
         runJUnitTest(__test, __test.test_define_duplicate);
       });
       _ut.test('test_define_normal', () {
         final __test = new EnclosedScopeTest();
         runJUnitTest(__test, __test.test_define_normal);
       });
     });
   }
 }
 
-class Scope_23 extends Scope {
+class Scope_24 extends Scope {
   GatheringErrorListener errorListener2;
 
-  Scope_23(this.errorListener2) : super();
+  Scope_24(this.errorListener2) : super();
 
   AnalysisErrorListener get errorListener => errorListener2;
 
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 
-class Scope_24 extends Scope {
+class Scope_25 extends Scope {
   GatheringErrorListener errorListener3;
 
-  Scope_24(this.errorListener3) : super();
+  Scope_25(this.errorListener3) : super();
 
   AnalysisErrorListener get errorListener => errorListener3;
 
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 
 class LibraryElementBuilderTest extends EngineTestCase {
   /**
    * The source factory used to create [Source].
    */
@@ skipping 250 matching lines @@
   }
 }
 
 /**
  * A non-abstract subclass that can be used for testing purposes.
  */
 class ScopeTest_TestScope extends Scope {
   /**
    * The listener that is to be informed when an error is encountered.
    */
-  AnalysisErrorListener _errorListener;
+  final AnalysisErrorListener errorListener;
 
-  ScopeTest_TestScope(AnalysisErrorListener errorListener) {
-    this._errorListener = errorListener;
-  }
-
-  AnalysisErrorListener get errorListener => _errorListener;
+  ScopeTest_TestScope(this.errorListener);
 
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => localLookup(name, referencingLibrary);
 }
 
 class SimpleResolverTest extends ResolverTestCase {
   void fail_staticInvocation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int get g => (a,b) => 0;",
         "}",
@@ skipping 437 matching lines @@
         "const A = null;",
         "main() {",
         "  var myVar = (int p) => 'foo';",
         "  myVar(42);",
         "}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnit unit = analysisContext.getResolvedCompilationUnit(source, library);
     JUnitTestCase.assertNotNull(unit);
     List<bool> found = [false];
-    unit.accept(new RecursiveASTVisitor_27(this, found));
+    List<AnalysisException> thrownException = new List<AnalysisException>(1);
+    unit.accept(new RecursiveASTVisitor_28(this, found, thrownException));
+    if (thrownException[0] != null) {
+      throw new AnalysisException.con3(thrownException[0]);
+    }
     JUnitTestCase.assertTrue(found[0]);
   }
 
   void test_metadata_class() {
     Source source = addSource(EngineTestCase.createSource(["const A = null;", "@A class C {}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
@@ skipping 372 matching lines @@
         runJUnitTest(__test, __test.test_setter_inherited);
       });
       _ut.test('test_setter_static', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_setter_static);
       });
     });
   }
 }
 
-class RecursiveASTVisitor_27 extends RecursiveASTVisitor<Object> {
+class RecursiveASTVisitor_28 extends RecursiveASTVisitor<Object> {
   final SimpleResolverTest SimpleResolverTest_this;
 
   List<bool> found;
 
-  RecursiveASTVisitor_27(this.SimpleResolverTest_this, this.found) : super();
+  List<AnalysisException> thrownException;
+
+  RecursiveASTVisitor_28(this.SimpleResolverTest_this, this.found, this.thrownException) : super();
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.name == "myVar" && node.parent is MethodInvocation) {
-      found[0] = true;
-      Type2 staticType = node.staticType;
-      JUnitTestCase.assertSame(SimpleResolverTest_this.typeProvider.dynamicType, staticType);
-      FunctionType propagatedType = node.propagatedType as FunctionType;
-      JUnitTestCase.assertEquals(SimpleResolverTest_this.typeProvider.stringType, propagatedType.returnType);
+      try {
+        found[0] = true;
+        Type2 staticType = node.staticType;
+        JUnitTestCase.assertSame(SimpleResolverTest_this.typeProvider.dynamicType, staticType);
+        FunctionType propagatedType = node.propagatedType as FunctionType;
+        JUnitTestCase.assertEquals(SimpleResolverTest_this.typeProvider.stringType, propagatedType.returnType);
+      } on AnalysisException catch (e) {
+        thrownException[0] = e;
+      }
     }
     return null;
   }
 }
 
 class SubtypeManagerTest extends EngineTestCase {
   /**
    * The inheritance manager being tested.
    */
   SubtypeManager _subtypeManager;
@@ skipping 332 matching lines @@
 //  HintCodeTest.dartSuite();
 //  MemberMapTest.dartSuite();
 //  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }