Version 0.8.10.1

dart/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';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'ast_test.dart' show ASTFactory;
 import 'element_test.dart' show ElementFactory;
 class TypePropagationTest extends ResolverTestCase {
-  void fail_functionExpression_asInvocationArgument_functionExpressionInvocation() {
-    String code = EngineTestCase.createSource([
-        "main() {",
-        "  (f(String value)) {} ((v) {",
-        "    v;",
-        "  });",
-        "}"]);
-    Source source = addSource(code);
-    LibraryElement library = resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
-    Type2 dynamicType = typeProvider.dynamicType;
-    Type2 stringType = typeProvider.stringType;
-    FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", FormalParameter);
-    JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
-    JUnitTestCase.assertSame(dynamicType, vParameter.identifier.staticType);
-    SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
-    JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
-    JUnitTestCase.assertSame(dynamicType, vIdentifier.staticType);
-  }
   void fail_propagatedReturnType_functionExpression() {
     String code = EngineTestCase.createSource(["main() {", "  var v = (() {return 42;})();", "}"]);
     check_propagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
   void test_as() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  bool get g => true;",
         "}",
         "A f(var p) {",
@@ skipping 124 matching lines @@
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     Type2 intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", SimpleFormalParameter);
     JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
     Type2 stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", SimpleFormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
   }
+  void test_functionExpression_asInvocationArgument_functionExpressionInvocation() {
+    String code = EngineTestCase.createSource([
+        "main() {",
+        "  (f(String value)) {} ((v) {",
+        "    v;",
+        "  });",
+        "}"]);
+    Source source = addSource(code);
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    Type2 dynamicType = typeProvider.dynamicType;
+    Type2 stringType = typeProvider.stringType;
+    FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", FormalParameter);
+    JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
+    JUnitTestCase.assertSame(dynamicType, vParameter.identifier.staticType);
+    SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", SimpleIdentifier);
+    JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
+    JUnitTestCase.assertSame(dynamicType, vIdentifier.staticType);
+  }
   void test_functionExpression_asInvocationArgument_keepIfLessSpecific() {
     String code = EngineTestCase.createSource([
         "class MyList {",
         "  forEach(f(Object value)) {}",
         "}",
         "f(MyList list) {",
         "  list.forEach((int v) {",
         "    v;",
         "  });",
         "}"]);
@@ skipping 555 matching lines @@
         runJUnitTest(__test, __test.test_forEach);
       });
       _ut.test('test_functionExpression_asInvocationArgument', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument);
       });
       _ut.test('test_functionExpression_asInvocationArgument_fromInferredInvocation', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument_fromInferredInvocation);
       });
+      _ut.test('test_functionExpression_asInvocationArgument_functionExpressionInvocation', () {
+        final __test = new TypePropagationTest();
+        runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument_functionExpressionInvocation);
+      });
       _ut.test('test_functionExpression_asInvocationArgument_keepIfLessSpecific', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument_keepIfLessSpecific);
       });
       _ut.test('test_functionExpression_asInvocationArgument_replaceIfMoreSpecific', () {
         final __test = new TypePropagationTest();
         runJUnitTest(__test, __test.test_functionExpression_asInvocationArgument_replaceIfMoreSpecific);
       });
       _ut.test('test_initializer', () {
         final __test = new TypePropagationTest();
@@ skipping 2157 matching lines @@
         "  B(S p) : super(p);",
         "  B.named(S p) : super.named(p);",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_proxy_annotation_prefixed() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
+        "import 'meta.dart';",
         "@proxy",
         "class A {}",
         "f(A a) {",
         "  a.m();",
         "  var x = a.g;",
         "  a.s = 1;",
         "  var y = a + a;",
         "  a++;",
         "  ++a;",
         "}"]));
+    addSource2("/meta.dart", EngineTestCase.createSource([
+        "library meta;",
+        "const proxy = const _Proxy();",
+        "class _Proxy { const _Proxy(); }"]));
     resolve(source);
     assertNoErrors(source);
   }
   void test_proxy_annotation_prefixed2() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
+        "import 'meta.dart';",
         "@proxy",
         "class A {}",
         "class B {",
         "  f(A a) {",
         "    a.m();",
         "    var x = a.g;",
         "    a.s = 1;",
         "    var y = a + a;",
         "    a++;",
         "    ++a;",
         "  }",
         "}"]));
+    addSource2("/meta.dart", EngineTestCase.createSource([
+        "library meta;",
+        "const proxy = const _Proxy();",
+        "class _Proxy { const _Proxy(); }"]));
     resolve(source);
     assertNoErrors(source);
   }
   void test_proxy_annotation_prefixed3() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
+        "import 'meta.dart';",
         "class B {",
         "  f(A a) {",
         "    a.m();",
         "    var x = a.g;",
         "    a.s = 1;",
         "    var y = a + a;",
         "    a++;",
         "    ++a;",
         "  }",
         "}",
         "@proxy",
         "class A {}"]));
+    addSource2("/meta.dart", EngineTestCase.createSource([
+        "library meta;",
+        "const proxy = const _Proxy();",
+        "class _Proxy { const _Proxy(); }"]));
     resolve(source);
     assertNoErrors(source);
   }
   void test_proxy_annotation_simple() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
+        "import 'meta.dart';",
         "@proxy",
         "class B {",
         "  m() {",
         "    n();",
         "    var x = g;",
         "    s = 1;",
         "    var y = this + this;",
         "  }",
         "}"]));
+    addSource2("/meta.dart", EngineTestCase.createSource([
+        "library meta;",
+        "const proxy = const _Proxy();",
+        "class _Proxy { const _Proxy(); }"]));
     resolve(source);
     assertNoErrors(source);
   }
   void test_recursiveConstructorRedirect() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.a() : this.b();",
         "  A.b() : this.c();",
         "  A.c() {}",
         "}"]));
@@ skipping 169 matching lines @@
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_returnWithoutValue_void() {
     Source source = addSource(EngineTestCase.createSource(["void f() { return; }"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_reversedTypeArguments() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class Codec<S1, T1> {",
+        "  Codec<T1, S1> get inverted => new _InvertedCodec<T1, S1>(this);",
+        "}",
+        "class _InvertedCodec<T2, S2> extends Codec<T2, S2> {",
+        "  _InvertedCodec(Codec<S2, T2> codec);",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_staticAccessToInstanceMember_annotation() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A.name();",
         "}",
         "@A.name()",
         "main() {",
         "}"]));
     resolve(source);
     assertNoErrors(source);
@@ skipping 187 matching lines @@
         "  if (p is String) {",
         "    callMe(() {",
         "      p.length;",
         "    });",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_typePromotion_if_extends_moreSpecific() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class V {}",
+        "class VP extends V {}",
+        "class A<T> {}",
+        "class B<S> extends A<S> {",
+        "  var b;",
+        "}",
+        "",
+        "main(A<V> p) {",
+        "  if (p is B<VP>) {",
+        "    p.b;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_typePromotion_if_hasAssignment_outsideAfter() {
     Source source = addSource(EngineTestCase.createSource([
         "main(Object p) {",
         "  if (p is String) {",
         "    p.length;",
         "  }",
         "  p = 0;",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_typePromotion_if_hasAssignment_outsideBefore() {
     Source source = addSource(EngineTestCase.createSource([
         "main(Object p, Object p2) {",
         "  p = p2;",
         "  if (p is String) {",
         "    p.length;",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_typePromotion_if_implements_moreSpecific() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class V {}",
+        "class VP extends V {}",
+        "class A<T> {}",
+        "class B<S> implements A<S> {",
+        "  var b;",
+        "}",
+        "",
+        "main(A<V> p) {",
+        "  if (p is B<VP>) {",
+        "    p.b;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typePromotion_if_inClosure_assignedAfter_inSameFunction() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main() {",
+        "  f(Object p) {",
+        "    if (p is String) {",
+        "      p.length;",
+        "    }",
+        "    p = 0;",
+        "  };",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_typePromotion_if_is_and_left() {
     Source source = addSource(EngineTestCase.createSource([
         "bool tt() => true;",
         "main(Object p) {",
         "  if (p is String && tt()) {",
         "    p.length;",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
@@ skipping 44 matching lines @@
     Source source = addSource(EngineTestCase.createSource([
         "main(Object p) {",
         "  if (p is String) {",
         "    p.length;",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_typeType_class() {
+    Source source = addSource(EngineTestCase.createSource(["class C {}", "f(Type t) {}", "main() {", "  f(C);", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typeType_class_prefixed() {
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class C {}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib.dart' as p;",
+        "f(Type t) {}",
+        "main() {",
+        "  f(p.C);",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typeType_functionTypeAlias() {
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef F();",
+        "f(Type t) {}",
+        "main() {",
+        "  f(F);",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_typeType_functionTypeAlias_prefixed() {
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "typedef F();"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib.dart' as p;",
+        "f(Type t) {}",
+        "main() {",
+        "  f(p.F);",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_undefinedConstructorInInitializer_explicit_named() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.named() {}",
         "}",
         "class B extends A {",
         "  B() : super.named();",
         "}"]));
     resolve(source);
     assertNoErrors(source);
@@ skipping 145 matching lines @@
         "}",
         "class B extends A {",
         "  f() {",
         "    super.m();",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_unqualifiedReferenceToNonLocalStaticMember_fromComment_new() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  A() {}",
+        "  A.named() {}",
+        "}",
+        "/// [new A] or [new A.named]",
+        "main() {",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_wrongNumberOfParametersForOperator_index() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator []=(a, b) {}", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_wrongNumberOfParametersForOperator_minus() {
     check_wrongNumberOfParametersForOperator("-", "");
     check_wrongNumberOfParametersForOperator("-", "a");
   }
@@ skipping 925 matching lines @@
         runJUnitTest(__test, __test.test_returnOfInvalidType_void);
       });
       _ut.test('test_returnWithoutValue_noReturnType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_returnWithoutValue_noReturnType);
       });
       _ut.test('test_returnWithoutValue_void', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_returnWithoutValue_void);
       });
+      _ut.test('test_reversedTypeArguments', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_reversedTypeArguments);
+      });
       _ut.test('test_staticAccessToInstanceMember_annotation', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_staticAccessToInstanceMember_annotation);
       });
       _ut.test('test_staticAccessToInstanceMember_method', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_staticAccessToInstanceMember_method);
       });
       _ut.test('test_staticAccessToInstanceMember_propertyAccess_field', () {
         final __test = new NonErrorResolverTest();
@@ skipping 56 matching lines @@
         runJUnitTest(__test, __test.test_typePromotion_functionType_return_ignoreIfNotMoreSpecific);
       });
       _ut.test('test_typePromotion_functionType_return_voidToDynamic', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typePromotion_functionType_return_voidToDynamic);
       });
       _ut.test('test_typePromotion_if_accessedInClosure_noAssignment', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typePromotion_if_accessedInClosure_noAssignment);
       });
+      _ut.test('test_typePromotion_if_extends_moreSpecific', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_extends_moreSpecific);
+      });
       _ut.test('test_typePromotion_if_hasAssignment_outsideAfter', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_outsideAfter);
       });
       _ut.test('test_typePromotion_if_hasAssignment_outsideBefore', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_outsideBefore);
       });
+      _ut.test('test_typePromotion_if_implements_moreSpecific', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_implements_moreSpecific);
+      });
+      _ut.test('test_typePromotion_if_inClosure_assignedAfter_inSameFunction', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_inClosure_assignedAfter_inSameFunction);
+      });
       _ut.test('test_typePromotion_if_is_and_left', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typePromotion_if_is_and_left);
       });
       _ut.test('test_typePromotion_if_is_and_right', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typePromotion_if_is_and_right);
       });
       _ut.test('test_typePromotion_if_is_and_subThenSuper', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typePromotion_if_is_and_subThenSuper);
       });
       _ut.test('test_typePromotion_if_is_parenthesized', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typePromotion_if_is_parenthesized);
       });
       _ut.test('test_typePromotion_if_is_single', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typePromotion_if_is_single);
       });
+      _ut.test('test_typeType_class', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typeType_class);
+      });
+      _ut.test('test_typeType_class_prefixed', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typeType_class_prefixed);
+      });
+      _ut.test('test_typeType_functionTypeAlias', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typeType_functionTypeAlias);
+      });
+      _ut.test('test_typeType_functionTypeAlias_prefixed', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typeType_functionTypeAlias_prefixed);
+      });
       _ut.test('test_undefinedConstructorInInitializer_explicit_named', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_explicit_named);
       });
       _ut.test('test_undefinedConstructorInInitializer_explicit_unnamed', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_explicit_unnamed);
       });
       _ut.test('test_undefinedConstructorInInitializer_hasOptionalParameters', () {
         final __test = new NonErrorResolverTest();
@@ skipping 44 matching lines @@
         runJUnitTest(__test, __test.test_undefinedSetter_importWithPrefix);
       });
       _ut.test('test_undefinedSuperMethod_field', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedSuperMethod_field);
       });
       _ut.test('test_undefinedSuperMethod_method', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedSuperMethod_method);
       });
+      _ut.test('test_unqualifiedReferenceToNonLocalStaticMember_fromComment_new', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_unqualifiedReferenceToNonLocalStaticMember_fromComment_new);
+      });
       _ut.test('test_wrongNumberOfParametersForOperator1', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForOperator1);
       });
       _ut.test('test_wrongNumberOfParametersForOperator_index', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForOperator_index);
       });
       _ut.test('test_wrongNumberOfParametersForOperator_minus', () {
         final __test = new NonErrorResolverTest();
@@ skipping 771 matching lines @@
   void test_typePromotion_if_and_right_hasAssignment() {
     Source source = addSource(EngineTestCase.createSource([
         "main(Object p) {",
         "  if (p is String && (p = null) == null) {",
         "    p.length;",
         "  }",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
+  void test_typePromotion_if_extends_notMoreSpecific_dynamic() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class V {}",
+        "class A<T> {}",
+        "class B<S> extends A<S> {",
+        "  var b;",
+        "}",
+        "",
+        "main(A<V> p) {",
+        "  if (p is B) {",
+        "    p.b;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_if_extends_notMoreSpecific_notMoreSpecificTypeArg() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class V {}",
+        "class A<T> {}",
+        "class B<S> extends A<S> {",
+        "  var b;",
+        "}",
+        "",
+        "main(A<V> p) {",
+        "  if (p is B<int>) {",
+        "    p.b;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
   void test_typePromotion_if_hasAssignment_after() {
     Source source = addSource(EngineTestCase.createSource([
         "main(Object p) {",
         "  if (p is String) {",
         "    p.length;",
         "    p = 0;",
         "  }",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
   void test_typePromotion_if_hasAssignment_before() {
     Source source = addSource(EngineTestCase.createSource([
         "main(Object p) {",
         "  if (p is String) {",
         "    p = 0;",
         "    p.length;",
         "  }",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
+  void test_typePromotion_if_hasAssignment_inClosure_anonymous_after() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  if (p is String) {",
+        "    p.length;",
+        "  }",
+        "  () {p = 0;};",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_if_hasAssignment_inClosure_anonymous_before() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  () {p = 0;};",
+        "  if (p is String) {",
+        "    p.length;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_if_hasAssignment_inClosure_function_after() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  if (p is String) {",
+        "    p.length;",
+        "  }",
+        "  f() {p = 0;};",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_if_hasAssignment_inClosure_function_before() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main(Object p) {",
+        "  f() {p = 0;};",
+        "  if (p is String) {",
+        "    p.length;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_if_implements_notMoreSpecific_dynamic() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class V {}",
+        "class A<T> {}",
+        "class B<S> implements A<S> {",
+        "  var b;",
+        "}",
+        "",
+        "main(A<V> p) {",
+        "  if (p is B) {",
+        "    p.b;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
+  void test_typePromotion_if_with_notMoreSpecific_dynamic() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class V {}",
+        "class A<T> {}",
+        "class B<S> extends Object with A<S> {",
+        "  var b;",
+        "}",
+        "",
+        "main(A<V> p) {",
+        "  if (p is B) {",
+        "    p.b;",
+        "  }",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+  }
   void test_undefinedGetter() {
     Source source = addSource(EngineTestCase.createSource(["class T {}", "f(T e) { return e.m; }"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
   void test_undefinedGetter_static() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "var a = A.B;"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
@@ skipping 441 matching lines @@
         runJUnitTest(__test, __test.test_typePromotion_conditional_useInThen_hasAssignment);
       });
       _ut.test('test_typePromotion_if_accessedInClosure_hasAssignment', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_typePromotion_if_accessedInClosure_hasAssignment);
       });
       _ut.test('test_typePromotion_if_and_right_hasAssignment', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_typePromotion_if_and_right_hasAssignment);
       });
+      _ut.test('test_typePromotion_if_extends_notMoreSpecific_dynamic', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_extends_notMoreSpecific_dynamic);
+      });
+      _ut.test('test_typePromotion_if_extends_notMoreSpecific_notMoreSpecificTypeArg', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_extends_notMoreSpecific_notMoreSpecificTypeArg);
+      });
       _ut.test('test_typePromotion_if_hasAssignment_after', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_after);
       });
       _ut.test('test_typePromotion_if_hasAssignment_before', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_before);
       });
+      _ut.test('test_typePromotion_if_hasAssignment_inClosure_anonymous_after', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_inClosure_anonymous_after);
+      });
+      _ut.test('test_typePromotion_if_hasAssignment_inClosure_anonymous_before', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_inClosure_anonymous_before);
+      });
+      _ut.test('test_typePromotion_if_hasAssignment_inClosure_function_after', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_inClosure_function_after);
+      });
+      _ut.test('test_typePromotion_if_hasAssignment_inClosure_function_before', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_hasAssignment_inClosure_function_before);
+      });
+      _ut.test('test_typePromotion_if_implements_notMoreSpecific_dynamic', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_implements_notMoreSpecific_dynamic);
+      });
+      _ut.test('test_typePromotion_if_with_notMoreSpecific_dynamic', () {
+        final __test = new StaticTypeWarningCodeTest();
+        runJUnitTest(__test, __test.test_typePromotion_if_with_notMoreSpecific_dynamic);
+      });
       _ut.test('test_undefinedGetter', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedGetter);
       });
       _ut.test('test_undefinedGetter_static', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedGetter_static);
       });
       _ut.test('test_undefinedMethod', () {
         final __test = new StaticTypeWarningCodeTest();
@@ skipping 3570 matching lines @@
         "class A {",
         "  static f() {}",
         "}",
         "@A.f",
         "main() {",
         "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
     verify([source]);
   }
+  void test_invalidAnnotation_unresolved_identifier() {
+    Source source = addSource(EngineTestCase.createSource(["@unresolved", "main() {", "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
+  }
+  void test_invalidAnnotation_unresolved_invocation() {
+    Source source = addSource(EngineTestCase.createSource(["@Unresolved()", "main() {", "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
+  }
+  void test_invalidAnnotation_unresolved_prefixedIdentifier() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'dart:math' as p;",
+        "@p.unresolved",
+        "main() {",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
+  }
   void test_invalidConstructorName_notEnclosingClassName_defined() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  B() : super();", "}", "class B {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME]);
   }
   void test_invalidConstructorName_notEnclosingClassName_undefined() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  B() : super();", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME]);
   }
@@ skipping 927 matching lines @@
         "main() {",
         "  {",
         "    print(v);",
         "  }",
         "  var v = 2;",
         "}",
         "print(x) {}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
   }
-  void test_referenceToDeclaredVariableInInitializer_closure() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var x = (x) {};", "}"]));
-    resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
-    verify([source]);
-  }
-  void test_referenceToDeclaredVariableInInitializer_getter() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  int x = x + 1;", "}"]));
-    resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
-    verify([source]);
-  }
-  void test_referenceToDeclaredVariableInInitializer_setter() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  int x = x++;", "}"]));
-    resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
-    verify([source]);
-  }
-  void test_referenceToDeclaredVariableInInitializer_unqualifiedInvocation() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var x = x();", "}"]));
-    resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER]);
-    verify([source]);
-  }
   void test_rethrowOutsideCatch() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  rethrow;", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH]);
     verify([source]);
   }
   void test_returnInGenerativeConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() { return 0; }", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR]);
@@ skipping 1032 matching lines @@
         runJUnitTest(__test, __test.test_invalidAnnotation_notConstantVariable);
       });
       _ut.test('test_invalidAnnotation_notVariableOrConstructorInvocation', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_invalidAnnotation_notVariableOrConstructorInvocation);
       });
       _ut.test('test_invalidAnnotation_staticMethodReference', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_invalidAnnotation_staticMethodReference);
       });
+      _ut.test('test_invalidAnnotation_unresolved_identifier', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_invalidAnnotation_unresolved_identifier);
+      });
+      _ut.test('test_invalidAnnotation_unresolved_invocation', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_invalidAnnotation_unresolved_invocation);
+      });
+      _ut.test('test_invalidAnnotation_unresolved_prefixedIdentifier', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_invalidAnnotation_unresolved_prefixedIdentifier);
+      });
       _ut.test('test_invalidConstructorName_notEnclosingClassName_defined', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_invalidConstructorName_notEnclosingClassName_defined);
       });
       _ut.test('test_invalidConstructorName_notEnclosingClassName_undefined', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_invalidConstructorName_notEnclosingClassName_undefined);
       });
       _ut.test('test_invalidFactoryNameNotAClass_notClassName', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 424 matching lines @@
         runJUnitTest(__test, __test.test_redirectToNonClass_notAType);
       });
       _ut.test('test_redirectToNonClass_undefinedIdentifier', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_redirectToNonClass_undefinedIdentifier);
       });
       _ut.test('test_redirectToNonConstConstructor', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_redirectToNonConstConstructor);
       });
-      _ut.test('test_referenceToDeclaredVariableInInitializer_closure', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_referenceToDeclaredVariableInInitializer_closure);
-      });
-      _ut.test('test_referenceToDeclaredVariableInInitializer_getter', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_referenceToDeclaredVariableInInitializer_getter);
-      });
-      _ut.test('test_referenceToDeclaredVariableInInitializer_setter', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_referenceToDeclaredVariableInInitializer_setter);
-      });
-      _ut.test('test_referenceToDeclaredVariableInInitializer_unqualifiedInvocation', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_referenceToDeclaredVariableInInitializer_unqualifiedInvocation);
-      });
       _ut.test('test_referencedBeforeDeclaration_hideInBlock_function', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_referencedBeforeDeclaration_hideInBlock_function);
       });
       _ut.test('test_referencedBeforeDeclaration_hideInBlock_local', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_referencedBeforeDeclaration_hideInBlock_local);
       });
       _ut.test('test_referencedBeforeDeclaration_hideInBlock_subBlock', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 1681 matching lines @@
         "class A {",
         "  operator +(int p) {}",
         "}",
         "f(A a) {",
         "  a + '0';",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
+  void test_argumentTypeNotAssignable_cascadeSEcond() {
+    Source source = addSource(EngineTestCase.createSource([
+        "// filler filler filler filler filler filler filler filler filler filler",
+        "class A {",
+        "  B ma() {}",
+        "}",
+        "class B {",
+        "  mb(String p) {}",
+        "}",
+        "",
+        "main() {",
+        "  A a = new A();",
+        "  a..  ma().mb(0);",
+        "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    verify([source]);
+  }
   void test_argumentTypeNotAssignable_const() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(String p);",
         "}",
         "main() {",
         "  const A(42);",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_const_super() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A(String p);",
         "}",
         "class B extends A {",
         "  const B() : super(42);",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
+  void test_argumentTypeNotAssignable_functionExpressionInvocation_required() {
+    Source source = addSource(EngineTestCase.createSource(["main() {", "  (int x) {} ('');", "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    verify([source]);
+  }
   void test_argumentTypeNotAssignable_index() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  operator [](int index) {}",
         "}",
         "f(A a) {",
         "  a['0'];",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
@@ skipping 435 matching lines @@
     resolve(source);
     assertErrors(source, [StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAME]);
     verify([source]);
   }
   void test_extraPositionalArguments() {
     Source source = addSource(EngineTestCase.createSource(["f() {}", "main() {", "  f(0, 1, '2');", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS]);
     verify([source]);
   }
+  void test_extraPositionalArguments_functionExpression() {
+    Source source = addSource(EngineTestCase.createSource(["main() {", "  (int x) {} (0, 1);", "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.EXTRA_POSITIONAL_ARGUMENTS]);
+    verify([source]);
+  }
   void test_fieldInitializedInInitializerAndDeclaration_final() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int x = 0;",
         "  A() : x = 1 {}",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
     verify([source]);
   }
@@ skipping 839 matching lines @@
     resolve(source);
     assertErrors(source, [StaticWarningCode.NOT_A_TYPE]);
     verify([source]);
   }
   void test_notEnoughRequiredArguments() {
     Source source = addSource(EngineTestCase.createSource(["f(int a, String b) {}", "main() {", "  f();", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
     verify([source]);
   }
+  void test_notEnoughRequiredArguments_functionExpression() {
+    Source source = addSource(EngineTestCase.createSource(["main() {", "  (int x) {} ();", "}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
+    verify([source]);
+  }
   void test_partOfDifferentLibrary() {
     Source source = addSource(EngineTestCase.createSource(["library lib;", "part 'part.dart';"]));
     addSource2("/part.dart", EngineTestCase.createSource(["part of lub;"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.PART_OF_DIFFERENT_LIBRARY]);
     verify([source]);
   }
   void test_redirectToInvalidFunctionType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A implements B {",
@@ skipping 215 matching lines @@
     Source source = addSource(EngineTestCase.createSource(["var a = b;"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_initializer_prefix() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class C {}"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as b;", "", "var a = b;", "b.C c;"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
-  void test_undefinedIdentifier_metadata() {
-    Source source = addSource(EngineTestCase.createSource(["@undefined class A {}"]));
-    resolve(source);
-    assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
-  }
   void test_undefinedIdentifier_methodInvocation() {
     Source source = addSource(EngineTestCase.createSource(["f() { C.m(); }"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_private_getter() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A {", "  var _foo;", "}"]));
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib.dart';",
         "class B extends A {",
@@ skipping 87 matching lines @@
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_annotation_namedConstructor);
       });
       _ut.test('test_argumentTypeNotAssignable_annotation_unnamedConstructor', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_annotation_unnamedConstructor);
       });
       _ut.test('test_argumentTypeNotAssignable_binary', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_binary);
       });
+      _ut.test('test_argumentTypeNotAssignable_cascadeSEcond', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_argumentTypeNotAssignable_cascadeSEcond);
+      });
       _ut.test('test_argumentTypeNotAssignable_const', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_const);
       });
       _ut.test('test_argumentTypeNotAssignable_const_super', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_const_super);
       });
+      _ut.test('test_argumentTypeNotAssignable_functionExpressionInvocation_required', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_argumentTypeNotAssignable_functionExpressionInvocation_required);
+      });
       _ut.test('test_argumentTypeNotAssignable_index', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_index);
       });
       _ut.test('test_argumentTypeNotAssignable_invocation_callParameter', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_invocation_callParameter);
       });
       _ut.test('test_argumentTypeNotAssignable_invocation_callVariable', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 168 matching lines @@
         runJUnitTest(__test, __test.test_equalKeysInMap);
       });
       _ut.test('test_exportDuplicatedLibraryName', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_exportDuplicatedLibraryName);
       });
       _ut.test('test_extraPositionalArguments', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_extraPositionalArguments);
       });
+      _ut.test('test_extraPositionalArguments_functionExpression', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_extraPositionalArguments_functionExpression);
+      });
       _ut.test('test_fieldInitializedInInitializerAndDeclaration_final', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_fieldInitializedInInitializerAndDeclaration_final);
       });
       _ut.test('test_fieldInitializerNotAssignable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_fieldInitializerNotAssignable);
       });
       _ut.test('test_fieldInitializingFormalNotAssignable', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 300 matching lines @@
         runJUnitTest(__test, __test.test_nonVoidReturnForSetter_method);
       });
       _ut.test('test_notAType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_notAType);
       });
       _ut.test('test_notEnoughRequiredArguments', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_notEnoughRequiredArguments);
       });
+      _ut.test('test_notEnoughRequiredArguments_functionExpression', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_notEnoughRequiredArguments_functionExpression);
+      });
       _ut.test('test_partOfDifferentLibrary', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_partOfDifferentLibrary);
       });
       _ut.test('test_redirectToInvalidFunctionType', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_redirectToInvalidFunctionType);
       });
       _ut.test('test_redirectToInvalidReturnType', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 104 matching lines @@
         runJUnitTest(__test, __test.test_undefinedIdentifier_function_prefix);
       });
       _ut.test('test_undefinedIdentifier_initializer', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_initializer);
       });
       _ut.test('test_undefinedIdentifier_initializer_prefix', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_initializer_prefix);
       });
-      _ut.test('test_undefinedIdentifier_metadata', () {
-        final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_undefinedIdentifier_metadata);
-      });
       _ut.test('test_undefinedIdentifier_methodInvocation', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_methodInvocation);
       });
       _ut.test('test_undefinedIdentifier_private_getter', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_private_getter);
       });
       _ut.test('test_undefinedIdentifier_private_setter', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 528 matching lines @@
     LibraryElement importedLibrary = createTestLibrary2(context, "imported", []);
     ((importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [importedType];
     LibraryElementImpl definingLibrary = createTestLibrary2(context, "importing", []);
     ImportElementImpl importElement = new ImportElementImpl();
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement> [importElement];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(importedType, scope.lookup(ASTFactory.identifier3(importedTypeName), definingLibrary));
   }
-  void test_getDefiningLibrary() {
-    LibraryElement definingLibrary = createTestLibrary();
-    GatheringErrorListener errorListener = new GatheringErrorListener();
-    LibraryImportScope scope = new LibraryImportScope(definingLibrary, errorListener);
-    JUnitTestCase.assertEquals(definingLibrary, scope.definingLibrary);
-  }
   void test_getErrorListener() {
     LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     LibraryImportScope scope = new LibraryImportScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(errorListener, scope.errorListener);
   }
   void test_nonConflictingImports_fromSdk() {
     AnalysisContext context = AnalysisContextFactory.contextWithCore();
     String typeName = "List";
     ClassElement type = ElementFactory.classElement2(typeName, []);
@@ skipping 57 matching lines @@
         runJUnitTest(__test, __test.test_conflictingImports);
       });
       _ut.test('test_creation_empty', () {
         final __test = new LibraryImportScopeTest();
         runJUnitTest(__test, __test.test_creation_empty);
       });
       _ut.test('test_creation_nonEmpty', () {
         final __test = new LibraryImportScopeTest();
         runJUnitTest(__test, __test.test_creation_nonEmpty);
       });
-      _ut.test('test_getDefiningLibrary', () {
-        final __test = new LibraryImportScopeTest();
-        runJUnitTest(__test, __test.test_getDefiningLibrary);
-      });
       _ut.test('test_getErrorListener', () {
         final __test = new LibraryImportScopeTest();
         runJUnitTest(__test, __test.test_getErrorListener);
       });
       _ut.test('test_nonConflictingImports_fromSdk', () {
         final __test = new LibraryImportScopeTest();
         runJUnitTest(__test, __test.test_nonConflictingImports_fromSdk);
       });
       _ut.test('test_nonConflictingImports_sameElement', () {
         final __test = new LibraryImportScopeTest();
@@ skipping 284 matching lines @@
     LibraryElement importedLibrary = createTestLibrary2(context, "imported", []);
     ((importedLibrary.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [importedType];
     LibraryElementImpl definingLibrary = createTestLibrary2(context, "importing", []);
     ImportElementImpl importElement = new ImportElementImpl();
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement> [importElement];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(importedType, scope.lookup(ASTFactory.identifier3(importedTypeName), definingLibrary));
   }
-  void test_getDefiningLibrary() {
-    LibraryElement definingLibrary = createTestLibrary();
-    GatheringErrorListener errorListener = new GatheringErrorListener();
-    LibraryScope scope = new LibraryScope(definingLibrary, errorListener);
-    JUnitTestCase.assertEquals(definingLibrary, scope.definingLibrary);
-  }
   void test_getErrorListener() {
     LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     LibraryScope scope = new LibraryScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(errorListener, scope.errorListener);
   }
   static dartSuite() {
     _ut.group('LibraryScopeTest', () {
       _ut.test('test_creation_empty', () {
         final __test = new LibraryScopeTest();
         runJUnitTest(__test, __test.test_creation_empty);
       });
       _ut.test('test_creation_nonEmpty', () {
         final __test = new LibraryScopeTest();
         runJUnitTest(__test, __test.test_creation_nonEmpty);
       });
-      _ut.test('test_getDefiningLibrary', () {
-        final __test = new LibraryScopeTest();
-        runJUnitTest(__test, __test.test_getDefiningLibrary);
-      });
       _ut.test('test_getErrorListener', () {
         final __test = new LibraryScopeTest();
         runJUnitTest(__test, __test.test_getErrorListener);
       });
     });
   }
 }
 class StaticTypeAnalyzerTest extends EngineTestCase {
 
   /**
@@ skipping 1255 matching lines @@
         "  bool operator ==(x) {}",
         "  get hashCode => 0;",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_proxy_annotation_prefixed() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
+        "import 'meta.dart';",
         "@proxy",
         "class A {}",
         "f(var a) {",
         "  a = new A();",
         "  a.m();",
         "  var x = a.g;",
         "  a.s = 1;",
         "  var y = a + a;",
         "  a++;",
         "  ++a;",
         "}"]));
+    addSource2("/meta.dart", EngineTestCase.createSource([
+        "library meta;",
+        "const proxy = const _Proxy();",
+        "class _Proxy { const _Proxy(); }"]));
     resolve(source);
     assertNoErrors(source);
   }
   void test_proxy_annotation_prefixed2() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
+        "import 'meta.dart';",
         "@proxy",
         "class A {}",
         "class B {",
         "  f(var a) {",
         "    a = new A();",
         "    a.m();",
         "    var x = a.g;",
         "    a.s = 1;",
         "    var y = a + a;",
         "    a++;",
         "    ++a;",
         "  }",
         "}"]));
+    addSource2("/meta.dart", EngineTestCase.createSource([
+        "library meta;",
+        "const proxy = const _Proxy();",
+        "class _Proxy { const _Proxy(); }"]));
     resolve(source);
     assertNoErrors(source);
   }
   void test_proxy_annotation_prefixed3() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
+        "import 'meta.dart';",
         "class B {",
         "  f(var a) {",
         "    a = new A();",
         "    a.m();",
         "    var x = a.g;",
         "    a.s = 1;",
         "    var y = a + a;",
         "    a++;",
         "    ++a;",
         "  }",
         "}",
         "@proxy",
         "class A {}"]));
+    addSource2("/meta.dart", EngineTestCase.createSource([
+        "library meta;",
+        "const proxy = const _Proxy();",
+        "class _Proxy { const _Proxy(); }"]));
     resolve(source);
     assertNoErrors(source);
   }
   void test_undefinedGetter_inSubtype() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {",
         "  get b => 0;",
         "}",
         "f(var a) {",
@@ skipping 375 matching lines @@
       });
       _ut.test('test_unusedImport_prefix_topLevelFunction', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_unusedImport_prefix_topLevelFunction);
       });
     });
   }
 }
 class EnclosedScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
-    LibraryElement definingLibrary2 = createTestLibrary();
     GatheringErrorListener errorListener2 = new GatheringErrorListener();
-    Scope rootScope = new Scope_21(definingLibrary2, errorListener2);
+    Scope rootScope = new Scope_21(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() {
-    LibraryElement definingLibrary3 = createTestLibrary();
     GatheringErrorListener errorListener3 = new GatheringErrorListener();
-    Scope rootScope = new Scope_22(definingLibrary3, errorListener3);
+    Scope rootScope = new Scope_22(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_21 extends Scope {
-  LibraryElement definingLibrary2;
   GatheringErrorListener errorListener2;
-  Scope_21(this.definingLibrary2, this.errorListener2) : super();
-  LibraryElement get definingLibrary => definingLibrary2;
+  Scope_21(this.errorListener2) : super();
   AnalysisErrorListener get errorListener => errorListener2;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 class Scope_22 extends Scope {
-  LibraryElement definingLibrary3;
   GatheringErrorListener errorListener3;
-  Scope_22(this.definingLibrary3, this.errorListener3) : super();
-  LibraryElement get definingLibrary => definingLibrary3;
+  Scope_22(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].
    */
   SourceFactory _sourceFactory;
   void setUp() {
@@ skipping 172 matching lines @@
       });
       _ut.test('test_singleFile', () {
         final __test = new LibraryElementBuilderTest();
         runJUnitTest(__test, __test.test_singleFile);
       });
     });
   }
 }
 class ScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
-    LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    ScopeTest_TestScope scope = new ScopeTest_TestScope(definingLibrary, errorListener);
+    ScopeTest_TestScope scope = new ScopeTest_TestScope(errorListener);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     scope.define(element1);
     scope.define(element2);
     errorListener.assertErrors3([ErrorSeverity.ERROR]);
   }
   void test_define_normal() {
-    LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    ScopeTest_TestScope scope = new ScopeTest_TestScope(definingLibrary, errorListener);
+    ScopeTest_TestScope scope = new ScopeTest_TestScope(errorListener);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v2"));
     scope.define(element1);
     scope.define(element2);
     errorListener.assertNoErrors();
   }
-  void test_getDefiningLibrary() {
-    LibraryElement definingLibrary = createTestLibrary();
-    ScopeTest_TestScope scope = new ScopeTest_TestScope(definingLibrary, null);
-    JUnitTestCase.assertEquals(definingLibrary, scope.definingLibrary);
-  }
   void test_getErrorListener() {
-    LibraryElement definingLibrary = new LibraryElementImpl(new AnalysisContextImpl(), ASTFactory.libraryIdentifier2(["test"]));
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    ScopeTest_TestScope scope = new ScopeTest_TestScope(definingLibrary, errorListener);
+    ScopeTest_TestScope scope = new ScopeTest_TestScope(errorListener);
     JUnitTestCase.assertEquals(errorListener, scope.errorListener);
   }
   void test_isPrivateName_nonPrivate() {
     JUnitTestCase.assertFalse(Scope.isPrivateName("Public"));
   }
   void test_isPrivateName_private() {
     JUnitTestCase.assertTrue(Scope.isPrivateName("_Private"));
   }
   static dartSuite() {
     _ut.group('ScopeTest', () {
       _ut.test('test_define_duplicate', () {
         final __test = new ScopeTest();
         runJUnitTest(__test, __test.test_define_duplicate);
       });
       _ut.test('test_define_normal', () {
         final __test = new ScopeTest();
         runJUnitTest(__test, __test.test_define_normal);
       });
-      _ut.test('test_getDefiningLibrary', () {
-        final __test = new ScopeTest();
-        runJUnitTest(__test, __test.test_getDefiningLibrary);
-      });
       _ut.test('test_getErrorListener', () {
         final __test = new ScopeTest();
         runJUnitTest(__test, __test.test_getErrorListener);
       });
       _ut.test('test_isPrivateName_nonPrivate', () {
         final __test = new ScopeTest();
         runJUnitTest(__test, __test.test_isPrivateName_nonPrivate);
       });
       _ut.test('test_isPrivateName_private', () {
         final __test = new ScopeTest();
         runJUnitTest(__test, __test.test_isPrivateName_private);
       });
     });
   }
 }
 /**
  * A non-abstract subclass that can be used for testing purposes.
  */
 class ScopeTest_TestScope extends Scope {
 
   /**
-   * The element representing the library in which this scope is enclosed.
-   */
-  LibraryElement _definingLibrary;
-
-  /**
    * The listener that is to be informed when an error is encountered.
    */
   AnalysisErrorListener _errorListener;
-  ScopeTest_TestScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) {
-    this._definingLibrary = definingLibrary;
+  ScopeTest_TestScope(AnalysisErrorListener errorListener) {
     this._errorListener = errorListener;
   }
-  LibraryElement get definingLibrary => _definingLibrary;
   AnalysisErrorListener get errorListener => _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;",
         "}",
         "class B {",
@@ skipping 870 matching lines @@
 //  ErrorResolverTest.dartSuite();
 //  HintCodeTest.dartSuite();
 //  MemberMapTest.dartSuite();
 //  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
-}
+}