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 14424 matching lines @@
 
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (node.staticType == null && identical(node.prefix.staticType, DynamicTypeImpl.instance)) {
       return null;
     }
     return super.visitPrefixedIdentifier(node);
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     ASTNode parent = node.parent;
-    if (parent is MethodInvocation && identical(node, (parent as MethodInvocation).methodName)) {
+    if (parent is MethodInvocation && identical(node, parent.methodName)) {
       return null;
-    } else if (parent is RedirectingConstructorInvocation && identical(node, (parent as RedirectingConstructorInvocation).constructorName)) {
+    } else if (parent is RedirectingConstructorInvocation && identical(node, parent.constructorName)) {
       return null;
-    } else if (parent is SuperConstructorInvocation && identical(node, (parent as SuperConstructorInvocation).constructorName)) {
+    } else if (parent is SuperConstructorInvocation && identical(node, parent.constructorName)) {
       return null;
-    } else if (parent is ConstructorName && identical(node, (parent as ConstructorName).name)) {
+    } else if (parent is ConstructorName && identical(node, parent.name)) {
       return null;
-    } else if (parent is ConstructorFieldInitializer && identical(node, (parent as ConstructorFieldInitializer).fieldName)) {
+    } else if (parent is ConstructorFieldInitializer && identical(node, parent.fieldName)) {
       return null;
     } else if (node.staticElement is PrefixElement) {
       return null;
     }
     return super.visitSimpleIdentifier(node);
   }
 
   Object visitTypeName(TypeName node) {
     if (node.type == null) {
       _unresolvedTypes.add(node);
     } else {
       _resolvedTypeCount++;
     }
     return null;
   }
 
   String getFileName(ASTNode node) {
     if (node != null) {
       ASTNode root = node.root;
       if (root is CompilationUnit) {
-        CompilationUnit rootCU = root as CompilationUnit;
+        CompilationUnit rootCU = root;
         if (rootCU.element != null) {
           return rootCU.element.source.fullName;
         } else {
           return "<unknown file- CompilationUnit.getElement() returned null>";
         }
       } else {
         return "<unknown file- CompilationUnit.getRoot() is not a CompilationUnit>";
       }
     }
     return "<unknown file- ASTNode is null>";
@@ skipping 5141 matching lines @@
     }
     return node.propertyName.accept(this);
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.name == "void") {
       return null;
     }
     ASTNode parent = node.parent;
     if (parent is MethodInvocation) {
-      MethodInvocation invocation = parent as MethodInvocation;
+      MethodInvocation invocation = parent;
       if (identical(invocation.methodName, node)) {
         Expression target = invocation.realTarget;
         Type2 targetType = target == null ? null : target.staticType;
         if (targetType == null || targetType.isDynamic) {
           return null;
         }
       }
     }
     return checkResolved(node, node.staticElement);
   }
@@ skipping 10 matching lines @@
         _wrongTypedNodes.add(node);
       }
     }
     return null;
   }
 
   String getFileName(ASTNode node) {
     if (node != null) {
       ASTNode root = node.root;
       if (root is CompilationUnit) {
-        CompilationUnit rootCU = root as CompilationUnit;
+        CompilationUnit rootCU = root;
         if (rootCU.element != null) {
           return rootCU.element.source.fullName;
         } else {
           return "<unknown file- CompilationUnit.getElement() returned null>";
         }
       } else {
         return "<unknown file- CompilationUnit.getRoot() is not a CompilationUnit>";
       }
     }
     return "<unknown file- ASTNode is null>";
@@ skipping 844 matching lines @@
     List<Type2> actualArguments = actualType.typeArguments;
     EngineTestCase.assertLength(length, actualArguments);
     for (int i = 0; i < length; i++) {
       assertType2(expectedArguments[i], actualArguments[i]);
     }
   }
 
   void assertType2(Type2 expectedType, Type2 actualType) {
     if (expectedType is InterfaceTypeImpl) {
       EngineTestCase.assertInstanceOf(InterfaceTypeImpl, actualType);
-      assertType(expectedType as InterfaceTypeImpl, actualType as InterfaceTypeImpl);
+      assertType(expectedType, actualType as InterfaceTypeImpl);
     }
   }
 
   /**
    * Create the analyzer used by the tests.
    *
    * @return the analyzer to be used by the tests
    */
   StaticTypeAnalyzer createAnalyzer() {
     AnalysisContextImpl context = new AnalysisContextImpl();
@@ skipping 1123 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_27(errorListener2);
+    Scope rootScope = new Scope_29(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_28(errorListener3);
+    Scope rootScope = new Scope_30(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_27 extends Scope {
+class Scope_29 extends Scope {
   GatheringErrorListener errorListener2;
 
-  Scope_27(this.errorListener2) : super();
+  Scope_29(this.errorListener2) : super();
 
   AnalysisErrorListener get errorListener => errorListener2;
 
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 
-class Scope_28 extends Scope {
+class Scope_30 extends Scope {
   GatheringErrorListener errorListener3;
 
-  Scope_28(this.errorListener3) : super();
+  Scope_30(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 140 matching lines @@
    * @return the element model that was built for the library
    * @throws Exception if the element model could not be built
    */
   LibraryElement buildLibrary(Source librarySource, List<ErrorCode> expectedErrorCodes) {
     AnalysisContextImpl context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory.con2([
         new DartUriResolver(DirectoryBasedDartSdk.defaultSdk),
         new FileUriResolver()]);
     LibraryResolver resolver = new LibraryResolver(context);
     LibraryElementBuilder builder = new LibraryElementBuilder(resolver);
-    Library library = resolver.createLibrary(librarySource) as Library;
+    Library library = resolver.createLibrary(librarySource);
     LibraryElement element = builder.buildLibrary(library);
     GatheringErrorListener listener = new GatheringErrorListener();
     listener.addAll(resolver.errorListener);
     listener.assertErrors2(expectedErrorCodes);
     return element;
   }
 
   static dartSuite() {
     _ut.group('LibraryElementBuilderTest', () {
       _ut.test('test_accessorsAcrossFiles', () {
@@ skipping 550 matching lines @@
         "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];
     List<AnalysisException> thrownException = new List<AnalysisException>(1);
-    unit.accept(new RecursiveASTVisitor_31(this, found, thrownException));
+    unit.accept(new RecursiveASTVisitor_33(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);
@@ skipping 375 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_31 extends RecursiveASTVisitor<Object> {
+class RecursiveASTVisitor_33 extends RecursiveASTVisitor<Object> {
   final SimpleResolverTest SimpleResolverTest_this;
 
   List<bool> found;
 
   List<AnalysisException> thrownException;
 
-  RecursiveASTVisitor_31(this.SimpleResolverTest_this, this.found, this.thrownException) : super();
+  RecursiveASTVisitor_33(this.SimpleResolverTest_this, this.found, this.thrownException) : super();
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.name == "myVar" && node.parent is MethodInvocation) {
       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) {
@@ skipping 344 matching lines @@
 //  HintCodeTest.dartSuite();
 //  MemberMapTest.dartSuite();
 //  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }