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 427 matching lines @@
   void test_is_subclass() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {",
         "  B m() => this;",
         "}",
         "A f(A p) {",
         "  if (p is B) {",
         "    return p.m();",
         "  }",
+        "  return p;",
         "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[2] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
     JUnitTestCase.assertNotNull(invocation.methodName.propagatedElement);
   }
 
   void test_is_while() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "A f(var p) {",
         "  while (p is A) {",
         "    return p;",
         "  }",
+        "  return p;",
         "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     WhileStatement whileStatement = body.block.statements[0] as WhileStatement;
@@ skipping 721 matching lines @@
         "  switch(s) {",
         "    case('1') : return 1;",
         "    default: return 0;",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_commentReference_beforeFunction_blockBody() {
+    String code = EngineTestCase.createSource(["/// [p]", "foo(int p) {", "}"]);
+    Source source = addSource(code);
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = analysisContext.parseCompilationUnit(source);
+    SimpleIdentifier ref = EngineTestCase.findNode(unit, code, "p]", SimpleIdentifier);
+    EngineTestCase.assertInstanceOf(ParameterElement, ref.staticElement);
+  }
+
+  void test_commentReference_beforeFunction_expressionBody() {
+    String code = EngineTestCase.createSource(["/// [p]", "foo(int p) => null;"]);
+    Source source = addSource(code);
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = analysisContext.parseCompilationUnit(source);
+    SimpleIdentifier ref = EngineTestCase.findNode(unit, code, "p]", SimpleIdentifier);
+    EngineTestCase.assertInstanceOf(ParameterElement, ref.staticElement);
+  }
+
+  void test_commentReference_beforeMethod() {
+    String code = EngineTestCase.createSource([
+        "abstract class A {",
+        "  /// [p1]",
+        "  ma(int p1) {}",
+        "  /// [p2]",
+        "  mb(int p2);",
+        "}"]);
+    Source source = addSource(code);
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = analysisContext.parseCompilationUnit(source);
+    {
+      SimpleIdentifier ref = EngineTestCase.findNode(unit, code, "p1]", SimpleIdentifier);
+      EngineTestCase.assertInstanceOf(ParameterElement, ref.staticElement);
+    }
+    {
+      SimpleIdentifier ref = EngineTestCase.findNode(unit, code, "p2]", SimpleIdentifier);
+      EngineTestCase.assertInstanceOf(ParameterElement, ref.staticElement);
+    }
+  }
+
+  void test_commentReference_class() {
+    String code = EngineTestCase.createSource(["/// [foo]", "class A {", "  foo() {}", "}"]);
+    Source source = addSource(code);
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = analysisContext.parseCompilationUnit(source);
+    SimpleIdentifier ref = EngineTestCase.findNode(unit, code, "foo]", SimpleIdentifier);
+    EngineTestCase.assertInstanceOf(MethodElement, ref.staticElement);
+  }
+
   void test_concreteClassWithAbstractMember() {
     Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  m();", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_conflictingInstanceGetterAndSuperclassMember_instance() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
@@ skipping 526 matching lines @@
         "  final int x;",
         "  A(this.x);",
         "  A.named() : this (42);",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_functionDeclaration_scope_returnType() {
-    Source source = addSource(EngineTestCase.createSource(["int f(int) {}"]));
+    Source source = addSource(EngineTestCase.createSource(["int f(int) { return 0; }"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_functionDeclaration_scope_signature() {
     Source source = addSource(EngineTestCase.createSource(["const app = 0;", "f(@app int app) {}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
@@ skipping 238 matching lines @@
   }
 
   void test_inconsistentMethodInheritance_accessors_typeParameter2() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A<E> {",
         "  E get x {return 1;}",
         "}",
         "class B<E> {",
         "  E get x {return 1;}",
         "}",
-        "class C<E> extends A<E> implements B<E> {",
-        "}"]));
+        "class C<E> extends A<E> implements B<E> {}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_inconsistentMethodInheritance_accessors_typeParameters_diamond() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class F<E> extends B<E> {}",
         "class D<E> extends F<E> {",
         "  external E get g;",
@@ skipping 198 matching lines @@
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_invalidAssignment_compoundAssignment() {
     Source source = addSource(EngineTestCase.createSource([
         "class byte {",
         "  int _value;",
         "  byte(this._value);",
-        "  byte operator +(int val) {}",
+        "  byte operator +(int val) { return this; }",
         "}",
         "",
         "void main() {",
         "  byte b = new byte(52);",
         "  b += 3;",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
@@ skipping 239 matching lines @@
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_invalidOverrideReturnType_returnType_void() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  void m() {}",
         "}",
         "class B extends A {",
-        "  int m() {}",
+        "  int m() { return 0; }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_invalidReferenceToThis_constructor() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {", "    var v = this;", "  }", "}"]));
     resolve(source);
     assertNoErrors(source);
@@ skipping 330 matching lines @@
     verify([source]);
   }
 
   void test_newWithUndefinedConstructorDefault() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "f() {", "  new A();", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
-  void test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_accessor() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  int get g => 0;",
-        "}",
-        "abstract class B extends A {",
-        "  int get g;",
-        "}",
-        "class C extends B {",
-        "}"]));
-    resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
-  void test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_method() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  m(p) {}",
-        "}",
-        "abstract class B extends A {",
-        "  m(p);",
-        "}",
-        "class C extends B {",
-        "}"]));
-    resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
   void test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_accessor() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  int get g;",
         "}",
         "class B extends A {",
         "  noSuchMethod(v) => '';",
         "}"]));
     resolve(source);
     assertNoErrors(source);
@@ skipping 1543 matching lines @@
         runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_Object);
       });
       _ut.test('test_caseExpressionTypeImplementsEquals_String', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_String);
       });
       _ut.test('test_caseExpressionTypeImplementsEquals_int', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_int);
       });
+      _ut.test('test_commentReference_beforeFunction_blockBody', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_commentReference_beforeFunction_blockBody);
+      });
+      _ut.test('test_commentReference_beforeFunction_expressionBody', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_commentReference_beforeFunction_expressionBody);
+      });
+      _ut.test('test_commentReference_beforeMethod', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_commentReference_beforeMethod);
+      });
+      _ut.test('test_commentReference_class', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_commentReference_class);
+      });
       _ut.test('test_concreteClassWithAbstractMember', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_concreteClassWithAbstractMember);
       });
       _ut.test('test_conflictingInstanceGetterAndSuperclassMember_instance', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_conflictingInstanceGetterAndSuperclassMember_instance);
       });
       _ut.test('test_conflictingStaticGetterAndInstanceSetter_thisClass', () {
         final __test = new NonErrorResolverTest();
@@ skipping 584 matching lines @@
         runJUnitTest(__test, __test.test_newWithAbstractClass_factory);
       });
       _ut.test('test_newWithUndefinedConstructor', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_newWithUndefinedConstructor);
       });
       _ut.test('test_newWithUndefinedConstructorDefault', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_newWithUndefinedConstructorDefault);
       });
-      _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_accessor', () {
-        final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_accessor);
-      });
-      _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_method', () {
-        final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_method);
-      });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_accessor', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_accessor);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_method', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod_method);
       });
       _ut.test('test_nonBoolExpression_functionType', () {
         final __test = new NonErrorResolverTest();
@@ skipping 919 matching lines @@
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
     verify([source]);
   }
 
   void test_invalidAssignment_compoundAssignment() {
     Source source = addSource(EngineTestCase.createSource([
         "class byte {",
         "  int _value;",
         "  byte(this._value);",
-        "  int operator +(int val) {}",
+        "  int operator +(int val) { return 0; }",
         "}",
         "",
         "void main() {",
         "  byte b = new byte(52);",
         "  b += 3;",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
@@ skipping 200 matching lines @@
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
 
   void test_returnOfInvalidType_expressionFunctionBody_localFunction() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  String m() {",
         "    int f() => '0';",
+        "    return '0';",
         "  }",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
 
   void test_returnOfInvalidType_expressionFunctionBody_method() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int f() => '0';", "}"]));
     resolve(source);
@@ skipping 20 matching lines @@
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
 
   void test_returnOfInvalidType_localFunction() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  String m() {",
         "    int f() { return '0'; }",
+        "    return '0';",
         "  }",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
     verify([source]);
   }
 
   void test_returnOfInvalidType_method() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  int f() { return '0'; }", "}"]));
     resolve(source);
@@ skipping 43 matching lines @@
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
 
   void test_typeArgumentNotMatchingBounds_functionReturnType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
-        "G<B> f() {}"]));
+        "G<B> f() { return null; }"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
 
   void test_typeArgumentNotMatchingBounds_functionTypeAlias() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
@@ skipping 35 matching lines @@
     assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
 
   void test_typeArgumentNotMatchingBounds_methodReturnType() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
         "class G<E extends A> {}",
         "class C {",
-        "  G<B> m() {}",
+        "  G<B> m() { return null; }",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
     verify([source]);
   }
 
   void test_typeArgumentNotMatchingBounds_new() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B {}",
@@ skipping 942 matching lines @@
     verify([source]);
   }
 
   void fail_isNotInt() {
     Source source = addSource(EngineTestCase.createSource(["var v = 1 is! int;"]));
     resolve(source);
     assertErrors(source, [HintCode.IS_NOT_INT]);
     verify([source]);
   }
 
+  void fail_missingReturn_function() {
+    Source source = addSource(EngineTestCase.createSource(["int f() {}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.MISSING_RETURN]);
+    verify([source]);
+  }
+
+  void fail_missingReturn_method() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  int m() {}", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.MISSING_RETURN]);
+    verify([source]);
+  }
+
   void fail_overrideEqualsButNotHashCode() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  bool operator ==(x) {}", "}"]));
     resolve(source);
     assertErrors(source, [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalElse() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  true ? 1 : 2;", "}"]));
     resolve(source);
@@ skipping 221 matching lines @@
         "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_assignment() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  @deprecated",
-        "  A operator+(A a) {}",
+        "  A operator+(A a) { return a; }",
         "}",
         "f(A a) {",
         "  A b;",
         "  a += b;",
         "}"]));
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
@@ skipping 2675 matching lines @@
     check_constEvalTypeNum_withParameter_binary("p * ''");
     check_constEvalTypeNum_withParameter_binary("p / ''");
     check_constEvalTypeNum_withParameter_binary("p ~/ ''");
     check_constEvalTypeNum_withParameter_binary("p > ''");
     check_constEvalTypeNum_withParameter_binary("p < ''");
     check_constEvalTypeNum_withParameter_binary("p >= ''");
     check_constEvalTypeNum_withParameter_binary("p <= ''");
     check_constEvalTypeNum_withParameter_binary("p % ''");
   }
 
-  void test_constEvalTypeNum_plus_String() {
-    Source source = addSource("const C = 'a' + 'b';");
-    resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_TYPE_NUM]);
-    verify([source]);
-  }
-
   void test_constFormalParameter_fieldFormalParameter() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  var x;", "  A(const this.x) {}", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
     verify([source]);
   }
 
   void test_constFormalParameter_simpleFormalParameter() {
     Source source = addSource(EngineTestCase.createSource(["f(const x) {}"]));
     resolve(source);
@@ skipping 2810 matching lines @@
         runJUnitTest(__test, __test.test_constEvalTypeBool_binary_leftTrue);
       });
       _ut.test('test_constEvalTypeInt_binary', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalTypeInt_binary);
       });
       _ut.test('test_constEvalTypeNum_binary', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEvalTypeNum_binary);
       });
-      _ut.test('test_constEvalTypeNum_plus_String', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_constEvalTypeNum_plus_String);
-      });
       _ut.test('test_constEval_newInstance_constConstructor', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEval_newInstance_constConstructor);
       });
       _ut.test('test_constEval_propertyExtraction_targetNotConst', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constEval_propertyExtraction_targetNotConst);
       });
       _ut.test('test_constFormalParameter_fieldFormalParameter', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 1839 matching lines @@
     variable.type = classA.type;
     target.staticElement = variable;
     target.staticType = classA.type;
     PrefixedIdentifier identifier = ASTFactory.identifier(target, ASTFactory.identifier3(getterName));
     resolveNode(identifier, []);
     JUnitTestCase.assertSame(getter, identifier.staticElement);
     JUnitTestCase.assertSame(getter, identifier.identifier.staticElement);
     _listener.assertNoErrors();
   }
 
+  void test_visitPrefixedIdentifier_staticClassMember_getter() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    String propName = "b";
+    PropertyAccessorElement getter = ElementFactory.getterElement(propName, false, _typeProvider.intType);
+    PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
+    classA.accessors = <PropertyAccessorElement> [getter, setter];
+    SimpleIdentifier target = ASTFactory.identifier3("A");
+    target.staticElement = classA;
+    target.staticType = classA.type;
+    PrefixedIdentifier identifier = ASTFactory.identifier(target, ASTFactory.identifier3(propName));
+    resolveNode(identifier, []);
+    JUnitTestCase.assertSame(getter, identifier.staticElement);
+    JUnitTestCase.assertSame(getter, identifier.identifier.staticElement);
+    _listener.assertNoErrors();
+  }
+
+  void test_visitPrefixedIdentifier_staticClassMember_method() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    String propName = "m";
+    PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
+    classA.accessors = <PropertyAccessorElement> [setter];
+    MethodElement method = ElementFactory.methodElement("m", _typeProvider.intType, []);
+    classA.methods = <MethodElement> [method];
+    SimpleIdentifier target = ASTFactory.identifier3("A");
+    target.staticElement = classA;
+    target.staticType = classA.type;
+    PrefixedIdentifier identifier = ASTFactory.identifier(target, ASTFactory.identifier3(propName));
+    ASTFactory.assignmentExpression(identifier, TokenType.EQ, ASTFactory.nullLiteral());
+    resolveNode(identifier, []);
+    JUnitTestCase.assertSame(method, identifier.staticElement);
+    JUnitTestCase.assertSame(method, identifier.identifier.staticElement);
+    _listener.assertNoErrors();
+  }
+
+  void test_visitPrefixedIdentifier_staticClassMember_setter() {
+    ClassElementImpl classA = ElementFactory.classElement2("A", []);
+    String propName = "b";
+    PropertyAccessorElement getter = ElementFactory.getterElement(propName, false, _typeProvider.intType);
+    PropertyAccessorElement setter = ElementFactory.setterElement(propName, false, _typeProvider.intType);
+    classA.accessors = <PropertyAccessorElement> [getter, setter];
+    SimpleIdentifier target = ASTFactory.identifier3("A");
+    target.staticElement = classA;
+    target.staticType = classA.type;
+    PrefixedIdentifier identifier = ASTFactory.identifier(target, ASTFactory.identifier3(propName));
+    ASTFactory.assignmentExpression(identifier, TokenType.EQ, ASTFactory.nullLiteral());
+    resolveNode(identifier, []);
+    JUnitTestCase.assertSame(setter, identifier.staticElement);
+    JUnitTestCase.assertSame(setter, identifier.identifier.staticElement);
+    _listener.assertNoErrors();
+  }
+
   void test_visitPrefixExpression() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier operand = ASTFactory.identifier3("i");
     operand.staticType = numType;
     PrefixExpression expression = ASTFactory.prefixExpression(TokenType.PLUS_PLUS, operand);
     resolveNode(expression, []);
     JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.staticElement);
     _listener.assertNoErrors();
   }
 
@@ skipping 362 matching lines @@
         runJUnitTest(__test, __test.test_visitPrefixExpression);
       });
       _ut.test('test_visitPrefixedIdentifier_dynamic', () {
         final __test = new ElementResolverTest();
         runJUnitTest(__test, __test.test_visitPrefixedIdentifier_dynamic);
       });
       _ut.test('test_visitPrefixedIdentifier_nonDynamic', () {
         final __test = new ElementResolverTest();
         runJUnitTest(__test, __test.test_visitPrefixedIdentifier_nonDynamic);
       });
+      _ut.test('test_visitPrefixedIdentifier_staticClassMember_getter', () {
+        final __test = new ElementResolverTest();
+        runJUnitTest(__test, __test.test_visitPrefixedIdentifier_staticClassMember_getter);
+      });
+      _ut.test('test_visitPrefixedIdentifier_staticClassMember_method', () {
+        final __test = new ElementResolverTest();
+        runJUnitTest(__test, __test.test_visitPrefixedIdentifier_staticClassMember_method);
+      });
+      _ut.test('test_visitPrefixedIdentifier_staticClassMember_setter', () {
+        final __test = new ElementResolverTest();
+        runJUnitTest(__test, __test.test_visitPrefixedIdentifier_staticClassMember_setter);
+      });
       _ut.test('test_visitPropertyAccess_getter_identifier', () {
         final __test = new ElementResolverTest();
         runJUnitTest(__test, __test.test_visitPropertyAccess_getter_identifier);
       });
       _ut.test('test_visitPropertyAccess_getter_super', () {
         final __test = new ElementResolverTest();
         runJUnitTest(__test, __test.test_visitPropertyAccess_getter_super);
       });
       _ut.test('test_visitPropertyAccess_setter_this', () {
         final __test = new ElementResolverTest();
@@ skipping 357 matching lines @@
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_ambiguousImport_typeAnnotation() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "typedef N FT(N p);",
         "N f(N p) {",
         "  N v;",
+        "  return null;",
         "}",
         "class A {",
-        "  N m() {}",
+        "  N m() { return null; }",
         "}",
         "class B<T extends N> {}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
     assertErrors(source, [
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT,
         StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_ambiguousImport_typeArgument_annotation() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "class A<T> {}",
-        "A<N> f() {}"]));
+        "A<N> f() { return null; }"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_ambiguousImport_typeArgument_instanceCreation() {
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
@@ skipping 60 matching lines @@
         "  operator +(int p) {}",
         "}",
         "f(A a) {",
         "  a + '0';",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
-  void test_argumentTypeNotAssignable_cascadeSEcond() {
+  void test_argumentTypeNotAssignable_cascadeSecond() {
     Source source = addSource(EngineTestCase.createSource([
         "// filler filler filler filler filler filler filler filler filler filler",
         "class A {",
-        "  B ma() {}",
+        "  B ma() { return new B(); }",
         "}",
         "class B {",
         "  mb(String p) {}",
         "}",
         "",
         "main() {",
         "  A a = new A();",
         "  a..  ma().mb(0);",
         "}"]));
     resolve(source);
@@ skipping 975 matching lines @@
         "  String m() { return 'a'; }",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
 
   void test_invalidMethodOverrideReturnType_void() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
-        "  int m() {}",
+        "  int m() { return 0; }",
         "}",
         "class B extends A {",
         "  void m() {}",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.INVALID_METHOD_OVERRIDE_RETURN_TYPE]);
     verify([source]);
   }
 
   void test_invalidOverrideDifferentDefaultValues_named() {
@@ skipping 335 matching lines @@
         "  o();",
         "  p();",
         "}",
         "class C extends A {",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR]);
     verify([source]);
   }
 
+  void test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_accessor() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int get g => 0;",
+        "}",
+        "abstract class B extends A {",
+        "  int get g;",
+        "}",
+        "class C extends B {}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    verify([source]);
+  }
+
+  void test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_method() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  m(p) {}",
+        "}",
+        "abstract class B extends A {",
+        "  m(p);",
+        "}",
+        "class C extends B {}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    verify([source]);
+  }
+
+  void test_nonAbstractClassInheritsAbstractMemberOne_ensureCorrectFunctionSubtypeIsUsedInImplementation() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class C {",
+        "  foo(int x) => x;",
+        "}",
+        "abstract class D {",
+        "  foo(x, [y]);",
+        "}",
+        "class E extends C implements D {}"]));
+    resolve(source);
+    assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
+    verify([source]);
+  }
+
   void test_nonAbstractClassInheritsAbstractMemberOne_getter_fromInterface() {
     Source source = addSource(EngineTestCase.createSource([
         "class I {",
         "  int get g {return 1;}",
         "}",
         "class C implements I {",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE]);
     verify([source]);
@@ skipping 130 matching lines @@
         "  try {",
         "  } on T catch (e) {",
         "  }",
         "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NON_TYPE_IN_CATCH_CLAUSE]);
     verify([source]);
   }
 
   void test_nonVoidReturnForOperator() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int operator []=(a, b) {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  int operator []=(a, b) { return a; }",
+        "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR]);
     verify([source]);
   }
 
   void test_nonVoidReturnForSetter_function() {
     Source source = addSource(EngineTestCase.createSource(["int set x(int v) {", "  return 42;", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.NON_VOID_RETURN_FOR_SETTER]);
     verify([source]);
@@ skipping 192 matching lines @@
   }
 
   void test_typeParameterReferencedByStatic_methodParameter() {
     Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  static m(K k) {}", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
 
   void test_typeParameterReferencedByStatic_methodReturn() {
-    Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  static K m() {}", "}"]));
+    Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  static K m() { return null; }", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
   }
 
   void test_typeParameterReferencedByStatic_setter() {
     Source source = addSource(EngineTestCase.createSource(["class A<K> {", "  static set s(K k) {}", "}"]));
     resolve(source);
     assertErrors(source, [StaticWarningCode.TYPE_PARAMETER_REFERENCED_BY_STATIC]);
     verify([source]);
@@ skipping 241 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', () {
+      _ut.test('test_argumentTypeNotAssignable_cascadeSecond', () {
         final __test = new StaticWarningCodeTest();
-        runJUnitTest(__test, __test.test_argumentTypeNotAssignable_cascadeSEcond);
+        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', () {
@@ skipping 453 matching lines @@
         runJUnitTest(__test, __test.test_newWithUndefinedConstructorDefault);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberFivePlus', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberFivePlus);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberFour', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberFour);
       });
+      _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_accessor', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_accessor);
+      });
+      _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_method', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_abstractOverridesConcrete_method);
+      });
+      _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_ensureCorrectFunctionSubtypeIsUsedInImplementation', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_ensureCorrectFunctionSubtypeIsUsedInImplementation);
+      });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_getter_fromInterface', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_getter_fromInterface);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_getter_fromSuperclass', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_getter_fromSuperclass);
       });
       _ut.test('test_nonAbstractClassInheritsAbstractMemberOne_method_fromInterface', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 220 matching lines @@
         runJUnitTest(__test, __test.test_undefinedStaticMethodOrGetter_method_inSuperclass);
       });
       _ut.test('test_undefinedStaticMethodOrGetter_setter_inSuperclass', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedStaticMethodOrGetter_setter_inSuperclass);
       });
     });
   }
 }
 
+/**
+ * Helper for creating and managing single [AnalysisContext].
+ */
+class AnalysisContextHelper {
+  AnalysisContext context;
+
+  SourceFactory _sourceFactory;
+
+  ContentCache _cache;
+
+  /**
+   * Creates new [AnalysisContext] using [AnalysisContextFactory#contextWithCore].
+   */
+  AnalysisContextHelper() {
+    context = AnalysisContextFactory.contextWithCore();
+    _sourceFactory = context.sourceFactory;
+    _cache = _sourceFactory.contentCache;
+  }
+
+  Source addSource(String path, String code) {
+    Source source = new FileBasedSource.con1(_cache, FileUtilities2.createFile(path));
+    {
+      _sourceFactory.setContents(source, "");
+      ChangeSet changeSet = new ChangeSet();
+      changeSet.added(source);
+      context.applyChanges(changeSet);
+    }
+    context.setContents(source, code);
+    return source;
+  }
+
+  CompilationUnit resolveDefiningUnit(Source source) {
+    LibraryElement libraryElement = context.computeLibraryElement(source);
+    return context.resolveCompilationUnit(source, libraryElement);
+  }
+}
+
 class ErrorResolverTest extends ResolverTestCase {
   void test_breakLabelOnSwitchMember() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  void m(int i) {",
         "    switch (i) {",
         "      l: case 0:",
         "        break;",
         "      case 1:",
         "        break l;",
@@ skipping 550 matching lines @@
     new LibraryImportScope(definingLibrary, errorListener);
   }
 
   void test_creation_nonEmpty() {
     AnalysisContext context = new AnalysisContextImpl();
     String importedTypeName = "A";
     ClassElement importedType = new ClassElementImpl(ASTFactory.identifier3(importedTypeName));
     LibraryElement importedLibrary = createTestLibrary2(context, "imported", []);
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [importedType];
     LibraryElementImpl definingLibrary = createTestLibrary2(context, "importing", []);
-    ImportElementImpl importElement = new ImportElementImpl();
+    ImportElementImpl importElement = new ImportElementImpl(0);
     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_getErrorListener() {
     LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
@@ skipping 435 matching lines @@
     new LibraryScope(definingLibrary, errorListener);
   }
 
   void test_creation_nonEmpty() {
     AnalysisContext context = new AnalysisContextImpl();
     String importedTypeName = "A";
     ClassElement importedType = new ClassElementImpl(ASTFactory.identifier3(importedTypeName));
     LibraryElement importedLibrary = createTestLibrary2(context, "imported", []);
     (importedLibrary.definingCompilationUnit as CompilationUnitElementImpl).types = <ClassElement> [importedType];
     LibraryElementImpl definingLibrary = createTestLibrary2(context, "importing", []);
-    ImportElementImpl importElement = new ImportElementImpl();
+    ImportElementImpl importElement = new ImportElementImpl(0);
     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_getErrorListener() {
     LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
@@ skipping 1298 matching lines @@
   void test_divisionOptimization_supressIfDivisionNotDefinedInCore() {
     Source source = addSource(EngineTestCase.createSource(["f(x, y) {", "  var v = (x / y).toInt();", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_divisionOptimization_supressIfDivisionOverridden() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
-        "  num operator /(x) {}",
+        "  num operator /(x) { return x; }",
         "}",
         "f(A x, A y) {",
         "  var v = (x / y).toInt();",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_duplicateImport_as() {
@@ skipping 28 matching lines @@
         "import 'lib1.dart';",
         "import 'lib1.dart' show A;",
         "A a;",
         "B b;"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}", "class B {}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_missingReturn_emptyFunctionBody() {
+    Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  int m();", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_missingReturn_expressionFunctionBody() {
+    Source source = addSource(EngineTestCase.createSource(["int f() => 0;"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_missingReturn_noReturnType() {
+    Source source = addSource(EngineTestCase.createSource(["f() {}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_missingReturn_voidReturnType() {
+    Source source = addSource(EngineTestCase.createSource(["void f() {}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_overriddingPrivateMember_sameLibrary() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  _m(int x) => 0;",
         "}",
         "class B extends A {",
         "  _m(int x) => 0;",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideEqualsButNotHashCode() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
-        "  bool operator ==(x) {}",
+        "  bool operator ==(x) { return x; }",
         "  get hashCode => 0;",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_proxy_annotation_prefixed() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
@@ skipping 355 matching lines @@
         runJUnitTest(__test, __test.test_duplicateImport_as);
       });
       _ut.test('test_duplicateImport_hide', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_duplicateImport_hide);
       });
       _ut.test('test_duplicateImport_show', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_duplicateImport_show);
       });
+      _ut.test('test_missingReturn_emptyFunctionBody', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_missingReturn_emptyFunctionBody);
+      });
+      _ut.test('test_missingReturn_expressionFunctionBody', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_missingReturn_expressionFunctionBody);
+      });
+      _ut.test('test_missingReturn_noReturnType', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_missingReturn_noReturnType);
+      });
+      _ut.test('test_missingReturn_voidReturnType', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_missingReturn_voidReturnType);
+      });
       _ut.test('test_overriddingPrivateMember_sameLibrary', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_overriddingPrivateMember_sameLibrary);
       });
       _ut.test('test_overrideEqualsButNotHashCode', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_overrideEqualsButNotHashCode);
       });
       _ut.test('test_proxy_annotation_prefixed', () {
         final __test = new NonHintCodeTest();
@@ skipping 83 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_24(errorListener2);
+    Scope rootScope = new Scope_25(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_25(errorListener3);
+    Scope rootScope = new Scope_26(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_24 extends Scope {
+class Scope_25 extends Scope {
   GatheringErrorListener errorListener2;
 
-  Scope_24(this.errorListener2) : super();
+  Scope_25(this.errorListener2) : super();
 
   AnalysisErrorListener get errorListener => errorListener2;
 
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 
-class Scope_25 extends Scope {
+class Scope_26 extends Scope {
   GatheringErrorListener errorListener3;
 
-  Scope_25(this.errorListener3) : super();
+  Scope_26(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 711 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_28(this, found, thrownException));
+    unit.accept(new RecursiveASTVisitor_29(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_28 extends RecursiveASTVisitor<Object> {
+class RecursiveASTVisitor_29 extends RecursiveASTVisitor<Object> {
   final SimpleResolverTest SimpleResolverTest_this;
 
   List<bool> found;
 
   List<AnalysisException> thrownException;
 
-  RecursiveASTVisitor_28(this.SimpleResolverTest_this, this.found, this.thrownException) : super();
+  RecursiveASTVisitor_29(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();
 }