New analyzer_experimental snapshot.

pkg/analyzer_experimental/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_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source_io.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/ast.dart';
 import 'package:analyzer_experimental/src/generated/parser.dart' show ParserErrorCode;
@@ skipping 490 matching lines @@
         "class A {}",
         "A f(var p) {",
         "  if (p is! A || null == p) {",
         "    return null;",
         "  } else {",
         "    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;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = ((ifStatement.elseStatement as Block)).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
@@ skipping 691 matching lines @@
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "  static m() {}",
         "}",
         "const C = A.m;"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_constEval_symbol() {
+    addSource2("/math.dart", EngineTestCase.createSource(["library math;", "const PI = 3.14;"]));
+    Source source = addSource(EngineTestCase.createSource(["const C = #foo;", "foo() {}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
   void test_constEvalTypeBoolNumString_equal() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "class B {",
         "  final v;",
         "  const B.a1(bool p) : v = p == true;",
         "  const B.a2(bool p) : v = p == false;",
         "  const B.a3(bool p) : v = p == 0;",
         "  const B.a4(bool p) : v = p == 0.0;",
         "  const B.a5(bool p) : v = p == '';",
         "  const B.b1(int p) : v = p == true;",
         "  const B.b2(int p) : v = p == false;",
         "  const B.b3(int p) : v = p == 0;",
         "  const B.b4(int p) : v = p == 0.0;",
         "  const B.b5(int p) : v = p == '';",
         "  const B.c1(String p) : v = p == true;",
         "  const B.c2(String p) : v = p == false;",
         "  const B.c3(String p) : v = p == 0;",
         "  const B.c4(String p) : v = p == 0.0;",
         "  const B.c5(String p) : v = p == '';",
         "  const B.n1(num p) : v = p == null;",
         "  const B.n2(num p) : v = null == p;",
         "}"]));
     resolve(source);
     assertNoErrors(source);
-    verify([source]);
   }
   void test_constEvalTypeBoolNumString_notEqual() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A();",
         "}",
         "class B {",
         "  final v;",
         "  const B.a1(bool p) : v = p != true;",
         "  const B.a2(bool p) : v = p != false;",
@@ skipping 607 matching lines @@
         "class A {",
         "  m() {}",
         "  /// [m]",
         "  static foo() {",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_instanceMethodNameCollidesWithSuperclassStatic_field() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib.dart';",
+        "class B extends A {",
+        "  _m() {}",
+        "}"]));
+    addSource2("/lib.dart", EngineTestCase.createSource(["library L;", "class A {", "  static var _m;", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+  void test_instanceMethodNameCollidesWithSuperclassStatic_method() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib.dart';",
+        "class B extends A {",
+        "  _m() {}",
+        "}"]));
+    addSource2("/lib.dart", EngineTestCase.createSource(["library L;", "class A {", "  static _m() {}", "}"]));
+    resolve(source);
+    assertErrors(source, [HintCode.OVERRIDDING_PRIVATE_MEMBER]);
+    verify([source]);
+  }
   void test_invalidAnnotation_constantVariable() {
     Source source = addSource(EngineTestCase.createSource(["const C = 0;", "@C", "main() {", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_invalidAnnotation_importWithPrefix_constantVariable() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "const C = 0;"]));
     Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "@p.C", "main() {", "}"]));
     resolve(source);
@@ skipping 845 matching lines @@
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_nonVoidReturnForSetter_method_void() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  void set x(v) {}", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
+  void test_null_callMethod() {
+    Source source = addSource(EngineTestCase.createSource(["main() {", "  null.m();", "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
+  void test_null_callOperator() {
+    Source source = addSource(EngineTestCase.createSource([
+        "main() {",
+        "  null + 5;",
+        "  null == 5;",
+        "  null[0];",
+        "}"]));
+    resolve(source);
+    assertNoErrors(source);
+  }
   void test_optionalParameterInOperator_required() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator +(p) {}", "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers() {
     addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A {}"]));
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib.dart' as p;",
@@ skipping 727 matching lines @@
         runJUnitTest(__test, __test.test_constEvalTypeBoolNumString_notEqual);
       });
       _ut.test('test_constEval_propertyExtraction_fieldStatic_targetType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constEval_propertyExtraction_fieldStatic_targetType);
       });
       _ut.test('test_constEval_propertyExtraction_methodStatic_targetType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constEval_propertyExtraction_methodStatic_targetType);
       });
+      _ut.test('test_constEval_symbol', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_constEval_symbol);
+      });
       _ut.test('test_constNotInitialized_field', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constNotInitialized_field);
       });
       _ut.test('test_constNotInitialized_local', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_constNotInitialized_local);
       });
       _ut.test('test_constWithNonConstantArgument_literals', () {
         final __test = new NonErrorResolverTest();
@@ skipping 236 matching lines @@
         runJUnitTest(__test, __test.test_instanceAccessToStaticMember_fromComment);
       });
       _ut.test('test_instanceAccessToStaticMember_topLevel', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_instanceAccessToStaticMember_topLevel);
       });
       _ut.test('test_instanceMemberAccessFromStatic_fromComment', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_instanceMemberAccessFromStatic_fromComment);
       });
+      _ut.test('test_instanceMethodNameCollidesWithSuperclassStatic_field', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_instanceMethodNameCollidesWithSuperclassStatic_field);
+      });
+      _ut.test('test_instanceMethodNameCollidesWithSuperclassStatic_method', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_instanceMethodNameCollidesWithSuperclassStatic_method);
+      });
       _ut.test('test_invalidAnnotation_constantVariable', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidAnnotation_constantVariable);
       });
       _ut.test('test_invalidAnnotation_importWithPrefix_constConstructor', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_invalidAnnotation_importWithPrefix_constConstructor);
       });
       _ut.test('test_invalidAnnotation_importWithPrefix_constantVariable', () {
         final __test = new NonErrorResolverTest();
@@ skipping 332 matching lines @@
         runJUnitTest(__test, __test.test_nonVoidReturnForSetter_function_void);
       });
       _ut.test('test_nonVoidReturnForSetter_method_no', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonVoidReturnForSetter_method_no);
       });
       _ut.test('test_nonVoidReturnForSetter_method_void', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonVoidReturnForSetter_method_void);
       });
+      _ut.test('test_null_callMethod', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_null_callMethod);
+      });
+      _ut.test('test_null_callOperator', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_null_callOperator);
+      });
       _ut.test('test_optionalParameterInOperator_required', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_optionalParameterInOperator_required);
       });
       _ut.test('test_prefixCollidesWithTopLevelMembers', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_prefixCollidesWithTopLevelMembers);
       });
       _ut.test('test_proxy_annotation_prefixed', () {
         final __test = new NonErrorResolverTest();
@@ skipping 2823 matching lines @@
     _inheritanceManager = createInheritanceManager();
     InterfaceType objectType = _typeProvider.objectType;
     _numOfMembersInObject = objectType.methods.length + objectType.accessors.length;
   }
   void test_getMapOfMembersInheritedFromClasses_accessor_extends() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject + 1, mapB);
-    JUnitTestCase.assertSame(getterG, mapB[getterName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
+    JUnitTestCase.assertSame(getterG, mapB.get(getterName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_getMapOfMembersInheritedFromClasses_accessor_implements() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapB);
-    JUnitTestCase.assertNull(mapB[getterName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapB.size);
+    JUnitTestCase.assertNull(mapB.get(getterName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_getMapOfMembersInheritedFromClasses_accessor_with() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject + 1, mapB);
-    JUnitTestCase.assertSame(getterG, mapB[getterName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
+    JUnitTestCase.assertSame(getterG, mapB.get(getterName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_getMapOfMembersInheritedFromClasses_method_extends() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.supertype = classA.type;
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject + 1, mapB);
-    JUnitTestCase.assertSame(methodM, mapB[methodName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
+    JUnitTestCase.assertSame(methodM, mapB.get(methodName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_getMapOfMembersInheritedFromClasses_method_implements() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapB);
-    JUnitTestCase.assertNull(mapB[methodName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapB.size);
+    JUnitTestCase.assertNull(mapB.get(methodName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_getMapOfMembersInheritedFromClasses_method_with() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject + 1, mapB);
-    JUnitTestCase.assertSame(methodM, mapB[methodName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromClasses(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
+    JUnitTestCase.assertSame(methodM, mapB.get(methodName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_getMapOfMembersInheritedFromInterfaces_accessor_extends() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject + 1, mapB);
-    JUnitTestCase.assertSame(getterG, mapB[getterName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
+    JUnitTestCase.assertSame(getterG, mapB.get(getterName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_getMapOfMembersInheritedFromInterfaces_accessor_implements() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject + 1, mapB);
-    JUnitTestCase.assertSame(getterG, mapB[getterName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
+    JUnitTestCase.assertSame(getterG, mapB.get(getterName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_getMapOfMembersInheritedFromInterfaces_accessor_with() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject + 1, mapB);
-    JUnitTestCase.assertSame(getterG, mapB[getterName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
+    JUnitTestCase.assertSame(getterG, mapB.get(getterName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_getMapOfMembersInheritedFromInterfaces_method_extends() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type, []);
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject + 1, mapB);
-    JUnitTestCase.assertSame(methodM, mapB[methodName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
+    JUnitTestCase.assertSame(methodM, mapB.get(methodName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_getMapOfMembersInheritedFromInterfaces_method_implements() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject + 1, mapB);
-    JUnitTestCase.assertSame(methodM, mapB[methodName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
+    JUnitTestCase.assertSame(methodM, mapB.get(methodName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_getMapOfMembersInheritedFromInterfaces_method_with() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String methodName = "m";
     MethodElement methodM = ElementFactory.methodElement(methodName, _typeProvider.intType, []);
     classA.methods = <MethodElement> [methodM];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.mixins = <InterfaceType> [classA.type];
-    Map<String, ExecutableElement> mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
-    Map<String, ExecutableElement> mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
-    EngineTestCase.assertSize2(_numOfMembersInObject, mapA);
-    EngineTestCase.assertSize2(_numOfMembersInObject + 1, mapB);
-    JUnitTestCase.assertSame(methodM, mapB[methodName]);
+    MemberMap mapB = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    MemberMap mapA = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
+    JUnitTestCase.assertEquals(_numOfMembersInObject, mapA.size);
+    JUnitTestCase.assertEquals(_numOfMembersInObject + 1, mapB.size);
+    JUnitTestCase.assertSame(methodM, mapB.get(methodName));
     assertNoErrors(classA);
     assertNoErrors(classB);
   }
   void test_lookupInheritance_interface_getter() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "g";
     PropertyAccessorElement getterG = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getterG];
     ClassElementImpl classB = ElementFactory.classElement2("B", []);
     classB.interfaces = <InterfaceType> [classA.type];
@@ skipping 553 matching lines @@
         CompileTimeErrorCode.UNDEFINED_FUNCTION]);
   }
   void test_argumentDefinitionTestNonParameter() {
     Source source = addSource(EngineTestCase.createSource(["f() {", " var v = 0;", " return ?v;", "}"]));
     resolve(source);
     assertErrors(source, [
         ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST,
         CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER]);
     verify([source]);
   }
-  void test_argumentTypeNotAssignable_const() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(String p);",
-        "}",
-        "main() {",
-        "  const A(42);",
-        "}"]));
+  void test_builtInIdentifierAsType_formalParameter_field() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  var x;", "  A(static this.x);", "}"]));
     resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
     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);",
-        "}"]));
+  void test_builtInIdentifierAsType_formalParameter_simple() {
+    Source source = addSource(EngineTestCase.createSource(["f(static x) {", "}"]));
     resolve(source);
-    assertErrors(source, [CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+    assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
     verify([source]);
   }
-  void test_builtInIdentifierAsType() {
+  void test_builtInIdentifierAsType_variableDeclaration() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  typedef x;", "}"]));
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE,
-        StaticWarningCode.UNDEFINED_CLASS]);
+    assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
     verify([source]);
   }
   void test_builtInIdentifierAsTypedefName_classTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "typedef as = A with B;"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
     verify([source]);
   }
   void test_builtInIdentifierAsTypedefName_functionTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["typedef bool as();"]));
@@ skipping 178 matching lines @@
   }
   void test_constEvalThrowsException_divisionByZero() {
     Source source = addSource("const C = 1 ~/ 0;");
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE]);
     verify([source]);
   }
   void test_constEvalThrowsException_unaryBitNot_null() {
     Source source = addSource("const C = ~null;");
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
-        StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
   }
   void test_constEvalThrowsException_unaryNegated_null() {
     Source source = addSource("const C = -null;");
     resolve(source);
-    assertErrors(source, [
-        CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
-        StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+    assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
   }
   void test_constEvalThrowsException_unaryNot_null() {
     Source source = addSource("const C = !null;");
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
     verify([source]);
   }
   void test_constEvalTypeBool_binary() {
     check_constEvalTypeBool_withParameter_binary("p && ''");
     check_constEvalTypeBool_withParameter_binary("p || ''");
@@ skipping 1498 matching lines @@
   }
   void test_nonConstValueInInitializer_binary_notInt() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int a;",
         "  const A(String p) : a = 5 & p;",
         "}"]));
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.CONST_EVAL_TYPE_INT,
-        CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+        StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_nonConstValueInInitializer_binary_notNum() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final int a;",
         "  const A(String p) : a = 5 + p;",
         "}"]));
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.CONST_EVAL_TYPE_NUM,
-        CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+        StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void test_nonConstValueInInitializer_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  static int C;",
         "  final int a;",
         "  const A() : a = C;",
         "}"]));
     resolve(source);
@@ skipping 735 matching lines @@
     assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
     verify([source]);
   }
   void check_constEvalThrowsException_binary_null(String expr, bool resolved) {
     Source source = addSource("const C = ${expr};");
     resolve(source);
     if (resolved) {
       assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
       verify([source]);
     } else {
-      assertErrors(source, [
-          CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
-          StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+      assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
     }
     reset();
   }
   void check_constEvalTypeBool_withParameter_binary(String expr) {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final a;",
         "  const A(bool p) : a = ${expr};",
         "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL]);
     verify([source]);
     reset();
   }
   void check_constEvalTypeInt_withParameter_binary(String expr) {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final a;",
         "  const A(int p) : a = ${expr};",
         "}"]));
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.CONST_EVAL_TYPE_INT,
-        CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+        StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
     reset();
   }
   void check_constEvalTypeNum_withParameter_binary(String expr) {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final a;",
         "  const A(num p) : a = ${expr};",
         "}"]));
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.CONST_EVAL_TYPE_NUM,
-        CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
+        StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
     reset();
   }
   void check_wrongNumberOfParametersForOperator(String name, String parameters) {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator ${name}(${parameters}) {}", "}"]));
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR]);
     verify([source]);
     reset();
   }
   void check_wrongNumberOfParametersForOperator1(String name) {
     check_wrongNumberOfParametersForOperator(name, "");
     check_wrongNumberOfParametersForOperator(name, "a, b");
   }
   static dartSuite() {
     _ut.group('CompileTimeErrorCodeTest', () {
       _ut.test('test_ambiguousExport', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_ambiguousExport);
       });
       _ut.test('test_ambiguousImport_function', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_function);
       });
       _ut.test('test_argumentDefinitionTestNonParameter', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter);
       });
-      _ut.test('test_argumentTypeNotAssignable_const', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_argumentTypeNotAssignable_const);
-      });
-      _ut.test('test_argumentTypeNotAssignable_const_super', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_argumentTypeNotAssignable_const_super);
-      });
-      _ut.test('test_builtInIdentifierAsType', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_builtInIdentifierAsType);
-      });
       _ut.test('test_builtInIdentifierAsTypeName', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypeName);
       });
       _ut.test('test_builtInIdentifierAsTypeParameterName', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypeParameterName);
       });
+      _ut.test('test_builtInIdentifierAsType_formalParameter_field', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_builtInIdentifierAsType_formalParameter_field);
+      });
+      _ut.test('test_builtInIdentifierAsType_formalParameter_simple', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_builtInIdentifierAsType_formalParameter_simple);
+      });
+      _ut.test('test_builtInIdentifierAsType_variableDeclaration', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_builtInIdentifierAsType_variableDeclaration);
+      });
       _ut.test('test_builtInIdentifierAsTypedefName_classTypeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypedefName_classTypeAlias);
       });
       _ut.test('test_builtInIdentifierAsTypedefName_functionTypeAlias', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_builtInIdentifierAsTypedefName_functionTypeAlias);
       });
       _ut.test('test_caseExpressionTypeImplementsEquals', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 1966 matching lines @@
     FileBasedSource source = new FileBasedSource.con1(contentCache, FileUtilities2.createFile("/test.dart"));
     CompilationUnitElementImpl definingCompilationUnit = new CompilationUnitElementImpl("test.dart");
     definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
     Library library = new Library(context, _listener, source);
     library.libraryElement = _definingLibrary;
     _visitor = new ResolverVisitor.con1(library, source, _typeProvider);
     try {
       return _visitor.elementResolver_J2DAccessor as ElementResolver;
-    } catch (exception) {
+    } on JavaException catch (exception) {
       throw new IllegalArgumentException("Could not create resolver", exception);
     }
   }
 
   /**
    * Return the element associated with the label of the given statement after the resolver has
    * resolved the statement.
    *
    * @param statement the statement to be resolved
    * @param labelElement the label element to be defined in the statement's label scope
@@ skipping 58 matching lines @@
       Scope outerScope = _visitor.nameScope_J2DAccessor as Scope;
       try {
         _visitor.enclosingClass_J2DAccessor = enclosingClass;
         EnclosedScope innerScope = new ClassScope(outerScope, enclosingClass);
         _visitor.nameScope_J2DAccessor = innerScope;
         node.accept(_resolver);
       } finally {
         _visitor.enclosingClass_J2DAccessor = null;
         _visitor.nameScope_J2DAccessor = outerScope;
       }
-    } catch (exception) {
+    } on JavaException catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
 
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
    *
    * @param node the expression to be resolved
    * @param definedElements the elements that are to be defined in the scope in which the element is
    *          being resolved
    * @return the element to which the expression was resolved
    */
   void resolveNode(ASTNode node, List<Element> definedElements) {
     try {
       Scope outerScope = _visitor.nameScope_J2DAccessor as Scope;
       try {
         EnclosedScope innerScope = new EnclosedScope(outerScope);
         for (Element element in definedElements) {
           innerScope.define(element);
         }
         _visitor.nameScope_J2DAccessor = innerScope;
         node.accept(_resolver);
       } finally {
         _visitor.nameScope_J2DAccessor = outerScope;
       }
-    } catch (exception) {
+    } on JavaException catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
 
   /**
    * Return the element associated with the label of the given statement after the resolver has
    * resolved the statement.
    *
    * @param statement the statement to be resolved
    * @param labelElement the label element to be defined in the statement's label scope
    * @return the element to which the statement's label was resolved
    */
   void resolveStatement(Statement statement, LabelElementImpl labelElement) {
     try {
       LabelScope outerScope = _visitor.labelScope_J2DAccessor as LabelScope;
       try {
         LabelScope innerScope;
         if (labelElement == null) {
           innerScope = new LabelScope.con1(outerScope, false, false);
         } else {
           innerScope = new LabelScope.con2(outerScope, labelElement.name, labelElement);
         }
         _visitor.labelScope_J2DAccessor = innerScope;
         statement.accept(_resolver);
       } finally {
         _visitor.labelScope_J2DAccessor = outerScope;
       }
-    } catch (exception) {
+    } on JavaException catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
   static dartSuite() {
     _ut.group('ElementResolverTest', () {
       _ut.test('test_lookUpMethodInInterfaces', () {
         final __test = new ElementResolverTest();
         runJUnitTest(__test, __test.test_lookUpMethodInInterfaces);
       });
       _ut.test('test_visitAssignmentExpression_compound', () {
@@ skipping 459 matching lines @@
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "class A implements 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,
         CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
   }
+  void test_ambiguousImport_inPart() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library lib;",
+        "import 'lib1.dart';",
+        "import 'lib2.dart';",
+        "part 'part.dart';"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
+    Source partSource = addSource2("/part.dart", EngineTestCase.createSource(["part of lib;", "class A extends N {}"]));
+    resolve(source);
+    assertErrors(partSource, [
+        StaticWarningCode.AMBIGUOUS_IMPORT,
+        CompileTimeErrorCode.EXTENDS_NON_CLASS]);
+  }
   void test_ambiguousImport_instanceCreation() {
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "f() {new 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]);
@@ skipping 114 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_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_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 1453 matching lines @@
         runJUnitTest(__test, __test.test_ambiguousImport_as);
       });
       _ut.test('test_ambiguousImport_extends', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_extends);
       });
       _ut.test('test_ambiguousImport_implements', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_implements);
       });
+      _ut.test('test_ambiguousImport_inPart', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_ambiguousImport_inPart);
+      });
       _ut.test('test_ambiguousImport_instanceCreation', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_instanceCreation);
       });
       _ut.test('test_ambiguousImport_is', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_is);
       });
       _ut.test('test_ambiguousImport_qualifier', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 24 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_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_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 1008 matching lines @@
         provider.functionType.element,
         provider.intType.element,
         provider.listType.element,
         provider.mapType.element,
         provider.nullType.element,
         provider.numType.element,
         provider.objectType.element,
         provider.stackTraceType.element,
         provider.stringType.element,
         provider.typeType.element];
+    coreUnit.functions = <FunctionElement> [ElementFactory.functionElement3("identical", provider.boolType.element, <ClassElement> [provider.objectType.element, provider.objectType.element], null)];
     LibraryElementImpl coreLibrary = new LibraryElementImpl(sdkContext, ASTFactory.libraryIdentifier2(["dart", "core"]));
     coreLibrary.definingCompilationUnit = coreUnit;
     CompilationUnitElementImpl htmlUnit = new CompilationUnitElementImpl("html_dartium.dart");
     Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
     sdkContext.setContents(htmlSource, "");
     htmlUnit.source = htmlSource;
     ClassElementImpl elementElement = ElementFactory.classElement2("Element", []);
     InterfaceType elementType = elementElement.type;
     ClassElementImpl documentElement = ElementFactory.classElement("Document", elementType, []);
     ClassElementImpl htmlDocumentElement = ElementFactory.classElement("HtmlDocument", documentElement.type, []);
@@ skipping 400 matching lines @@
       writer.print("  ");
       writer.print(identifier.toString());
       writer.print(" (");
       writer.print(getFileName(identifier));
       writer.print(" : ");
       writer.print(identifier.offset);
       writer.println(")");
     }
   }
 }
+class MemberMapTest extends JUnitTestCase {
+
+  /**
+   * The null type.
+   */
+  InterfaceType _nullType;
+  void setUp() {
+    _nullType = new TestTypeProvider().nullType;
+  }
+  void test_MemberMap_copyConstructor() {
+    MethodElement m1 = ElementFactory.methodElement("m1", _nullType, []);
+    MethodElement m2 = ElementFactory.methodElement("m2", _nullType, []);
+    MethodElement m3 = ElementFactory.methodElement("m3", _nullType, []);
+    MemberMap map = new MemberMap();
+    map.put(m1.name, m1);
+    map.put(m2.name, m2);
+    map.put(m3.name, m3);
+    MemberMap copy = new MemberMap.con2(map);
+    JUnitTestCase.assertEquals(map.size, copy.size);
+    JUnitTestCase.assertEquals(m1, copy.get(m1.name));
+    JUnitTestCase.assertEquals(m2, copy.get(m2.name));
+    JUnitTestCase.assertEquals(m3, copy.get(m3.name));
+  }
+  void test_MemberMap_override() {
+    MethodElement m1 = ElementFactory.methodElement("m", _nullType, []);
+    MethodElement m2 = ElementFactory.methodElement("m", _nullType, []);
+    MemberMap map = new MemberMap();
+    map.put(m1.name, m1);
+    map.put(m2.name, m2);
+    JUnitTestCase.assertEquals(1, map.size);
+    JUnitTestCase.assertEquals(m2, map.get("m"));
+  }
+  void test_MemberMap_put() {
+    MethodElement m1 = ElementFactory.methodElement("m1", _nullType, []);
+    MemberMap map = new MemberMap();
+    JUnitTestCase.assertEquals(0, map.size);
+    map.put(m1.name, m1);
+    JUnitTestCase.assertEquals(1, map.size);
+    JUnitTestCase.assertEquals(m1, map.get("m1"));
+  }
+  static dartSuite() {
+    _ut.group('MemberMapTest', () {
+      _ut.test('test_MemberMap_copyConstructor', () {
+        final __test = new MemberMapTest();
+        runJUnitTest(__test, __test.test_MemberMap_copyConstructor);
+      });
+      _ut.test('test_MemberMap_override', () {
+        final __test = new MemberMapTest();
+        runJUnitTest(__test, __test.test_MemberMap_override);
+      });
+      _ut.test('test_MemberMap_put', () {
+        final __test = new MemberMapTest();
+        runJUnitTest(__test, __test.test_MemberMap_put);
+      });
+    });
+  }
+}
 class LibraryScopeTest extends ResolverTestCase {
   void test_creation_empty() {
     LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
     new LibraryScope(definingLibrary, errorListener);
   }
   void test_creation_nonEmpty() {
     AnalysisContext context = new AnalysisContextImpl();
     String importedTypeName = "A";
     ClassElement importedType = new ClassElementImpl(ASTFactory.identifier3(importedTypeName));
@@ skipping 614 matching lines @@
    * Return the type associated with the given expression after the static type analyzer has
    * computed a type for it.
    *
    * @param node the expression with which the type is associated
    * @param thisType the type of 'this'
    * @return the type associated with the expression
    */
   Type2 analyze2(Expression node, InterfaceType thisType) {
     try {
       _analyzer.thisType_J2DAccessor = thisType;
-    } catch (exception) {
+    } on JavaException catch (exception) {
       throw new IllegalArgumentException("Could not set type of 'this'", exception);
     }
     node.accept(_analyzer);
     return node.staticType;
   }
 
   /**
    * Return the type associated with the given parameter after the static type analyzer has computed
    * a type for it.
    *
@@ skipping 79 matching lines @@
     CompilationUnitElementImpl definingCompilationUnit = new CompilationUnitElementImpl("lib.dart");
     definingCompilationUnit.source = source;
     LibraryElementImpl definingLibrary = new LibraryElementImpl(context, null);
     definingLibrary.definingCompilationUnit = definingCompilationUnit;
     Library library = new Library(context, _listener, source);
     library.libraryElement = definingLibrary;
     _visitor = new ResolverVisitor.con1(library, source, _typeProvider);
     _visitor.overrideManager.enterScope();
     try {
       return _visitor.typeAnalyzer_J2DAccessor as StaticTypeAnalyzer;
-    } catch (exception) {
+    } on JavaException catch (exception) {
       throw new IllegalArgumentException("Could not create analyzer", exception);
     }
   }
 
   /**
    * Return an integer literal that has been resolved to the correct type.
    *
    * @param value the value of the literal
    * @return an integer literal that has been resolved to the correct type
    */
@@ skipping 1597 matching lines @@
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
   void test_resolveAgainstNull() {
     Source source = addSource(EngineTestCase.createSource(["f(var p) {", "  return null == p;", "}"]));
     resolve(source);
     assertNoErrors(source);
-    verify([source]);
   }
   void test_setter_inherited() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  int get x => 0;",
         "  set x(int p) {}",
         "}",
         "class B extends A {",
         "  int get x => super.x == null ? 0 : super.x;",
         "  int f() => x = 1;",
@@ skipping 250 matching lines @@
 //  TypeOverrideManagerTest.dartSuite();
 //  TypeProviderImplTest.dartSuite();
 //  TypeResolverVisitorTest.dartSuite();
 //  EnclosedScopeTest.dartSuite();
 //  LibraryImportScopeTest.dartSuite();
 //  LibraryScopeTest.dartSuite();
 //  ScopeTest.dartSuite();
 //  CompileTimeErrorCodeTest.dartSuite();
 //  ErrorResolverTest.dartSuite();
 //  HintCodeTest.dartSuite();
+//  MemberMapTest.dartSuite();
 //  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }