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 1472 matching lines @@
     verify([source]);
   }
 
   void test_defaultValueInFunctionTypedParameter_optional() {
     Source source = addSource(EngineTestCase.createSource(["f(g([p])) {}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_deprecatedMemberUse_hide() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library lib;",
+        "import 'lib1.dart' hide B;",
+        "A a = new A();"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource([
+        "library lib1;",
+        "class A {}",
+        "@deprecated",
+        "class B {}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_duplicateDefinition_emptyName() {
     Source source = addSource(EngineTestCase.createSource([
         "Map _globalMap = {",
         "  'a' : () {},",
         "  'b' : () {}",
         "};"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
@@ skipping 2621 matching lines @@
   }
 
   void test_undefinedIdentifier_show() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart' show a;"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_undefinedIdentifier_synthetic_whenExpression() {
+    Source source = addSource(EngineTestCase.createSource(["print(x) {}", "main() {", "  print(is String);", "}"]));
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.MISSING_IDENTIFIER]);
+  }
+
+  void test_undefinedIdentifier_synthetic_whenMethodName() {
+    Source source = addSource(EngineTestCase.createSource(["print(x) {}", "main(int p) {", "  p.();", "}"]));
+    resolve(source);
+    assertErrors(source, [ParserErrorCode.MISSING_IDENTIFIER]);
+  }
+
   void test_undefinedMethod_functionExpression_callMethod() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  (() => null).call();", "}"]));
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedMethod_functionExpression_directCall() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  (() => null)();", "}"]));
     resolve(source);
     assertNoErrors(source);
@@ skipping 309 matching lines @@
         runJUnitTest(__test, __test.test_defaultValueInFunctionTypeAlias);
       });
       _ut.test('test_defaultValueInFunctionTypedParameter_named', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_defaultValueInFunctionTypedParameter_named);
       });
       _ut.test('test_defaultValueInFunctionTypedParameter_optional', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_defaultValueInFunctionTypedParameter_optional);
       });
+      _ut.test('test_deprecatedMemberUse_hide', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_deprecatedMemberUse_hide);
+      });
       _ut.test('test_duplicateDefinition_emptyName', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_duplicateDefinition_emptyName);
       });
       _ut.test('test_duplicateDefinition_getter', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_duplicateDefinition_getter);
       });
       _ut.test('test_dynamicIdentifier', () {
         final __test = new NonErrorResolverTest();
@@ skipping 908 matching lines @@
         runJUnitTest(__test, __test.test_undefinedGetter_typeSubstitution);
       });
       _ut.test('test_undefinedIdentifier_hide', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_hide);
       });
       _ut.test('test_undefinedIdentifier_show', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_show);
       });
+      _ut.test('test_undefinedIdentifier_synthetic_whenExpression', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_undefinedIdentifier_synthetic_whenExpression);
+      });
+      _ut.test('test_undefinedIdentifier_synthetic_whenMethodName', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_undefinedIdentifier_synthetic_whenMethodName);
+      });
       _ut.test('test_undefinedMethod_functionExpression_callMethod', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedMethod_functionExpression_callMethod);
       });
       _ut.test('test_undefinedMethod_functionExpression_directCall', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedMethod_functionExpression_directCall);
       });
       _ut.test('test_undefinedOperator_index', () {
         final __test = new NonErrorResolverTest();
@@ skipping 7046 matching lines @@
         "class A {}",
         "class B {",
         "  B() : super(), this.name();",
         "  B.name() {}",
         "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR]);
     verify([source]);
   }
 
+  void test_typeAliasCannotReferenceItself_11987() {
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef void F(List<G> l);",
+        "typedef void G(List<F> l);",
+        "main() {",
+        "  F foo(G g) => g;",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [
+        CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
+        CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
+        StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+    verify([source]);
+  }
+
   void test_typeAliasCannotReferenceItself_parameterType_named() {
     Source source = addSource(EngineTestCase.createSource(["typedef A({A a});"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
 
   void test_typeAliasCannotReferenceItself_parameterType_positional() {
     Source source = addSource(EngineTestCase.createSource(["typedef A([A a]);"]));
     resolve(source);
@@ skipping 1488 matching lines @@
         runJUnitTest(__test, __test.test_superInInvalidContext_topLevelVariableInitializer);
       });
       _ut.test('test_superInRedirectingConstructor_redirectionSuper', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_superInRedirectingConstructor_redirectionSuper);
       });
       _ut.test('test_superInRedirectingConstructor_superRedirection', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_superInRedirectingConstructor_superRedirection);
       });
+      _ut.test('test_typeAliasCannotReferenceItself_11987', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_11987);
+      });
       _ut.test('test_typeAliasCannotReferenceItself_parameterType_named', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_parameterType_named);
       });
       _ut.test('test_typeAliasCannotReferenceItself_parameterType_positional', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_parameterType_positional);
       });
       _ut.test('test_typeAliasCannotReferenceItself_parameterType_required', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 330 matching lines @@
         "    sum += list[i];",
         "  }",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
-    options.strictMode = true;
     options.hint = false;
     analysisContext.analysisOptions = options;
   }
 
   void test_assert_is() {
     Source source = addSource(EngineTestCase.createSource([
         "int f(num n) {",
         "  assert (n is int);",
         "  return n & 0x0F;",
         "}"]));
@@ skipping 6939 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_22(errorListener2);
+    Scope rootScope = new Scope_23(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_23(errorListener3);
+    Scope rootScope = new Scope_24(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_22 extends Scope {
+class Scope_23 extends Scope {
   GatheringErrorListener errorListener2;
 
-  Scope_22(this.errorListener2) : super();
+  Scope_23(this.errorListener2) : super();
 
   AnalysisErrorListener get errorListener => errorListener2;
 
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 
-class Scope_23 extends Scope {
+class Scope_24 extends Scope {
   GatheringErrorListener errorListener3;
 
-  Scope_23(this.errorListener3) : super();
+  Scope_24(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 702 matching lines @@
         "    default:",
         "      continue l1;",
         "  }",
         "}"]));
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_localVariable_types_invoked() {
+    Source source = addSource(EngineTestCase.createSource([
+        "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));
+    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;
     EngineTestCase.assertLength(1, classes);
     List<ElementAnnotation> annotations = classes[0].metadata;
     EngineTestCase.assertLength(1, annotations);
@@ skipping 317 matching lines @@
         runJUnitTest(__test, __test.test_isValidMixin_super);
       });
       _ut.test('test_isValidMixin_valid', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_isValidMixin_valid);
       });
       _ut.test('test_labels_switch', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_labels_switch);
       });
+      _ut.test('test_localVariable_types_invoked', () {
+        final __test = new SimpleResolverTest();
+        runJUnitTest(__test, __test.test_localVariable_types_invoked);
+      });
       _ut.test('test_metadata_class', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_metadata_class);
       });
       _ut.test('test_metadata_field', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_metadata_field);
       });
       _ut.test('test_metadata_libraryDirective', () {
         final __test = new SimpleResolverTest();
@@ skipping 28 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> {
+  final SimpleResolverTest SimpleResolverTest_this;
+
+  List<bool> found;
+
+  RecursiveASTVisitor_27(this.SimpleResolverTest_this, this.found) : 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);
+    }
+    return null;
+  }
+}
+
 class SubtypeManagerTest extends EngineTestCase {
   /**
    * The inheritance manager being tested.
    */
   SubtypeManager _subtypeManager;
 
   /**
    * The compilation unit element containing all of the types setup in each test.
    */
   CompilationUnitElementImpl _definingCompilationUnit;
@@ skipping 327 matching lines @@
 //  HintCodeTest.dartSuite();
 //  MemberMapTest.dartSuite();
 //  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }