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 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.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';
@@ skipping 1447 matching lines @@
     assertNoErrors();
     verify([source]);
   }
   void test_finalNotInitialized_hasNativeClause_hasConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A native 'something' {",
         "  final int x;",
         "  A() {}",
         "}"]));
     resolve(source);
-    assertNoErrors();
+    assertErrors([ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE]);
     verify([source]);
   }
   void test_finalNotInitialized_hasNativeClause_noConstructor() {
     Source source = addSource(EngineTestCase.createSource(["class A native 'something' {", "  final int x;", "}"]));
     resolve(source);
-    assertNoErrors();
+    assertErrors([ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE]);
     verify([source]);
   }
   void test_finalNotInitialized_initializer() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final int x;", "  A() : x = 0 {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_finalNotInitialized_redirectingConstructor() {
     Source source = addSource(EngineTestCase.createSource([
@@ skipping 143 matching lines @@
     assertNoErrors();
     verify([source]);
   }
   void test_importDuplicatedLibraryName() {
     Source source = addSource(EngineTestCase.createSource([
         "library test;",
         "import 'lib.dart';",
         "import 'lib.dart';"]));
     addSource2("/lib.dart", "library lib;");
     resolve(source);
-    assertNoErrors();
+    assertErrors([HintCode.UNUSED_IMPORT, HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
   void test_importOfNonLibrary_libraryDeclared() {
-    Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';"]));
-    addSource2("/part.dart", EngineTestCase.createSource(["library lib1;"]));
+    Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';", "A a;"]));
+    addSource2("/part.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_importOfNonLibrary_libraryNotDeclared() {
-    Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';"]));
-    addSource2("/part.dart", EngineTestCase.createSource([""]));
+    Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';", "A a;"]));
+    addSource2("/part.dart", EngineTestCase.createSource(["class A {}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_inconsistentCaseExpressionTypes() {
     Source source = addSource(EngineTestCase.createSource([
         "f(var p) {",
         "  switch (p) {",
         "    case 1:",
         "      break;",
@@ skipping 474 matching lines @@
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_newWithUndefinedConstructorDefault() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}", "f() {", "  new A();", "}"]));
     resolve(source);
     assertNoErrors();
     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();
+    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();
+    verify([source]);
+  }
+  void test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod() {
+    Source source = addSource(EngineTestCase.createSource([
+        "abstract class A {",
+        "  m(p);",
+        "}",
+        "class B extends A {",
+        "  noSuchMethod(invocation) {}",
+        "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_nonBoolExpression_functionType() {
     Source source = addSource(EngineTestCase.createSource([
         "bool makeAssertion() => true;",
         "f() {",
         "  assert(makeAssertion);",
         "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
@@ skipping 296 matching lines @@
     assertNoErrors();
     verify([source]);
   }
   void test_optionalParameterInOperator_required() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  operator +(p) {}", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers() {
-    addSource2("/lib.dart", "library lib;");
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A {}"]));
     Source source = addSource(EngineTestCase.createSource([
-        "import '/lib.dart' as p;",
+        "import 'lib.dart' as p;",
         "typedef P();",
         "p2() {}",
         "var p3;",
-        "class p4 {}"]));
+        "class p4 {}",
+        "p.A a;"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_recursiveConstructorRedirect() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A.a() : this.b();",
         "  A.b() : this.c();",
         "  A.c() {}",
@@ skipping 233 matching lines @@
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_returnClass_withTypeAlias() {
     Source source = addSource(EngineTestCase.createSource(["typedef B A();", "class B {", "  A a;", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
+  void test_typeAliasCannotReferenceItself_typeVariableBounds() {
+    Source source = addSource(EngineTestCase.createSource(["typedef A<T extends A>();"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_typeArgumentNotMatchingBounds_const() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "class G<E extends A> {",
         "  const G();",
         "}",
         "f() { return const G<B>(); }"]));
     resolve(source);
     assertNoErrors();
@@ skipping 92 matching lines @@
         "  Foo.ctor();",
         "}",
         "class Bar extends Foo {",
         "  Bar() : this.ctor();",
         "  Bar.ctor() : super.ctor();",
         "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
-  void test_undefinedGetter_noSuchMethod_getter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  noSuchMethod(invocation) {}",
-        "}",
-        "f() {",
-        "  (new A()).g;",
-        "}"]));
-    resolve(source);
-    assertNoErrors();
-  }
-  void test_undefinedGetter_noSuchMethod_getter2() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  noSuchMethod(invocation) {}",
-        "}",
-        "class B {",
-        "  A a = new A();",
-        "  m() {",
-        "    a.g;",
-        "  }",
-        "}"]));
-    resolve(source);
-    assertNoErrors();
-  }
   void test_undefinedGetter_typeSubstitution() {
     Source source = addSource(EngineTestCase.createSource([
         "class A<E> {",
         "  E element;",
         "}",
         "class B extends A<List> {",
         "  m() {",
         "    element.last;",
         "  }",
         "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedIdentifier_hide() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart' hide a;"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
-  void test_undefinedIdentifier_noSuchMethod() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  noSuchMethod(invocation) {}",
-        "  f() {",
-        "    var v = a;",
-        "  }",
-        "}"]));
-    resolve(source);
-    assertNoErrors();
-  }
   void test_undefinedIdentifier_show() {
     Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart' show a;"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedMethod_functionExpression_callMethod() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  (() => null).call();", "}"]));
     resolve(source);
     assertNoErrors();
   }
   void test_undefinedMethod_functionExpression_directCall() {
     Source source = addSource(EngineTestCase.createSource(["main() {", "  (() => null)();", "}"]));
     resolve(source);
     assertNoErrors();
   }
-  void test_undefinedMethod_noSuchMethod() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  noSuchMethod(invocation) {}",
-        "}",
-        "f() {",
-        "  (new A()).m();",
-        "}"]));
-    resolve(source);
-    assertNoErrors();
-  }
   void test_undefinedOperator_index() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  operator [](a) {}",
         "  operator []=(a, b) {}",
         "}",
         "f(A a) {",
         "  a[0];",
         "  a[0] = 1;",
         "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_undefinedOperator_tilde() {
     Source source = addSource(EngineTestCase.createSource(["const A = 3;", "const B = ~((1 << A) - 1);"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
-  void test_undefinedSetter_noSuchMethod() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  noSuchMethod(invocation) {}",
-        "}",
-        "f() {",
-        "  (new A()).s = 1;",
-        "}"]));
-    resolve(source);
-    assertNoErrors();
-  }
   void test_undefinedSuperMethod_field() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  var m;",
         "}",
         "class B extends A {",
         "  f() {",
         "    super.m();",
         "  }",
         "}"]));
@@ skipping 561 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', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_nonAbstractClassInheritsAbstractMemberOne_noSuchMethod);
+      });
       _ut.test('test_nonBoolExpression_functionType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonBoolExpression_functionType);
       });
       _ut.test('test_nonBoolExpression_interfaceType', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_nonBoolExpression_interfaceType);
       });
       _ut.test('test_nonConstCaseExpression', () {
         final __test = new NonErrorResolverTest();
@@ skipping 200 matching lines @@
         runJUnitTest(__test, __test.test_staticAccessToInstanceMember_propertyAccess_propertyAccessor);
       });
       _ut.test('test_superInInvalidContext', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_superInInvalidContext);
       });
       _ut.test('test_typeAliasCannotReferenceItself_returnClass_withTypeAlias', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_returnClass_withTypeAlias);
       });
+      _ut.test('test_typeAliasCannotReferenceItself_typeVariableBounds', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_typeVariableBounds);
+      });
       _ut.test('test_typeArgumentNotMatchingBounds_const', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_const);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_new', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_typeArgumentList_0', () {
         final __test = new NonErrorResolverTest();
@@ skipping 24 matching lines @@
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_implicit);
       });
       _ut.test('test_undefinedConstructorInInitializer_implicit_typedef', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_implicit_typedef);
       });
       _ut.test('test_undefinedConstructorInInitializer_redirecting', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedConstructorInInitializer_redirecting);
       });
-      _ut.test('test_undefinedGetter_noSuchMethod_getter', () {
-        final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_undefinedGetter_noSuchMethod_getter);
-      });
-      _ut.test('test_undefinedGetter_noSuchMethod_getter2', () {
-        final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_undefinedGetter_noSuchMethod_getter2);
-      });
       _ut.test('test_undefinedGetter_typeSubstitution', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedGetter_typeSubstitution);
       });
       _ut.test('test_undefinedIdentifier_hide', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_hide);
       });
-      _ut.test('test_undefinedIdentifier_noSuchMethod', () {
-        final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_undefinedIdentifier_noSuchMethod);
-      });
       _ut.test('test_undefinedIdentifier_show', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_show);
       });
       _ut.test('test_undefinedMethod_functionExpression_callMethod', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedMethod_functionExpression_callMethod);
       });
       _ut.test('test_undefinedMethod_functionExpression_directCall', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedMethod_functionExpression_directCall);
       });
-      _ut.test('test_undefinedMethod_noSuchMethod', () {
-        final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_undefinedMethod_noSuchMethod);
-      });
       _ut.test('test_undefinedOperator_index', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedOperator_index);
       });
       _ut.test('test_undefinedOperator_tilde', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedOperator_tilde);
       });
-      _ut.test('test_undefinedSetter_noSuchMethod', () {
-        final __test = new NonErrorResolverTest();
-        runJUnitTest(__test, __test.test_undefinedSetter_noSuchMethod);
-      });
       _ut.test('test_undefinedSuperMethod_field', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedSuperMethod_field);
       });
       _ut.test('test_undefinedSuperMethod_method', () {
         final __test = new NonErrorResolverTest();
         runJUnitTest(__test, __test.test_undefinedSuperMethod_method);
       });
       _ut.test('test_wrongNumberOfParametersForOperator1', () {
         final __test = new NonErrorResolverTest();
@@ skipping 1185 matching lines @@
         "  var one = 1;",
         "  return;",
         "  var two = 2;",
         "  return;",
         "  var three = 3;",
         "}"]));
     resolve(source);
     assertErrors([HintCode.DEAD_CODE]);
     verify([source]);
   }
+  void test_unusedImport() {
+    Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;"]));
+    resolve(source);
+    assertErrors([HintCode.UNUSED_IMPORT]);
+    verify([source]);
+  }
+  void test_unusedImport_as() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'lib1.dart';",
+        "import 'lib1.dart' as one;",
+        "one.A a;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    resolve(source);
+    assertErrors([HintCode.UNUSED_IMPORT]);
+    verify([source]);
+  }
+  void test_unusedImport_hide() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'lib1.dart';",
+        "import 'lib1.dart' hide A;",
+        "A a;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    resolve(source);
+    assertErrors([HintCode.UNUSED_IMPORT]);
+    verify([source]);
+  }
+  void test_unusedImport_show() {
+    Source source = addSource(EngineTestCase.createSource([
+        "library L;",
+        "import 'lib1.dart' show A;",
+        "import 'lib1.dart' show B;",
+        "A a;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}", "class B {}"]));
+    resolve(source);
+    assertErrors([HintCode.UNUSED_IMPORT]);
+    verify([source]);
+  }
   static dartSuite() {
     _ut.group('HintCodeTest', () {
       _ut.test('test_deadCode_deadBlock_conditionalElse', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_deadBlock_conditionalElse);
       });
       _ut.test('test_deadCode_deadBlock_conditionalElse_nested', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_deadBlock_conditionalElse_nested);
       });
@@ skipping 82 matching lines @@
         runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_method);
       });
       _ut.test('test_deadCode_statementAfterReturn_nested', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_nested);
       });
       _ut.test('test_deadCode_statementAfterReturn_twoReturns', () {
         final __test = new HintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_twoReturns);
       });
+      _ut.test('test_unusedImport', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unusedImport);
+      });
+      _ut.test('test_unusedImport_as', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unusedImport_as);
+      });
+      _ut.test('test_unusedImport_hide', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unusedImport_hide);
+      });
+      _ut.test('test_unusedImport_show', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_unusedImport_show);
+      });
     });
   }
 }
 class TypeResolverVisitorTest extends EngineTestCase {
 
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
 
@@ skipping 619 matching lines @@
   LibraryElementImpl _definingLibrary;
 
   /**
    * The inheritance manager being tested.
    */
   InheritanceManager _inheritanceManager;
   void setUp() {
     _typeProvider = new TestTypeProvider();
     _inheritanceManager = createInheritanceManager();
   }
+  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.classElement2("B", []);
+    classB.supertype = classA.type;
+    Map<String, ExecutableElement> map = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    JUnitTestCase.assertSame(getterG, map[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> map = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    JUnitTestCase.assertNull(map[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> map = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    JUnitTestCase.assertSame(getterG, map[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> map = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    JUnitTestCase.assertSame(methodM, map[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> map = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    JUnitTestCase.assertNull(map[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> map = _inheritanceManager.getMapOfMembersInheritedFromClasses(classB);
+    JUnitTestCase.assertSame(methodM, map[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.classElement2("B", []);
+    classB.supertype = classA.type;
+    Map<String, ExecutableElement> map = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    JUnitTestCase.assertSame(getterG, map[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> map = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    JUnitTestCase.assertSame(getterG, map[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> map = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    JUnitTestCase.assertSame(getterG, map[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.classElement2("B", []);
+    classB.supertype = classA.type;
+    Map<String, ExecutableElement> map = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    JUnitTestCase.assertSame(methodM, map[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> map = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    JUnitTestCase.assertSame(methodM, map[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> map = _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classB);
+    JUnitTestCase.assertSame(methodM, map[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];
     JUnitTestCase.assertSame(getterG, _inheritanceManager.lookupInheritance(classB, getterName));
     assertNoErrors(classA);
     assertNoErrors(classB);
@@ skipping 295 matching lines @@
     AnalysisContextImpl context = AnalysisContextFactory.contextWithCore();
     FileBasedSource source = new FileBasedSource.con1(new ContentCache(), FileUtilities2.createFile("/test.dart"));
     CompilationUnitElementImpl definingCompilationUnit = new CompilationUnitElementImpl("test.dart");
     definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
     return new InheritanceManager(_definingLibrary);
   }
   static dartSuite() {
     _ut.group('InheritanceManagerTest', () {
+      _ut.test('test_getMapOfMembersInheritedFromClasses_accessor_extends', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromClasses_accessor_extends);
+      });
+      _ut.test('test_getMapOfMembersInheritedFromClasses_accessor_implements', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromClasses_accessor_implements);
+      });
+      _ut.test('test_getMapOfMembersInheritedFromClasses_accessor_with', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromClasses_accessor_with);
+      });
+      _ut.test('test_getMapOfMembersInheritedFromClasses_method_extends', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromClasses_method_extends);
+      });
+      _ut.test('test_getMapOfMembersInheritedFromClasses_method_implements', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromClasses_method_implements);
+      });
+      _ut.test('test_getMapOfMembersInheritedFromClasses_method_with', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromClasses_method_with);
+      });
+      _ut.test('test_getMapOfMembersInheritedFromInterfaces_accessor_extends', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromInterfaces_accessor_extends);
+      });
+      _ut.test('test_getMapOfMembersInheritedFromInterfaces_accessor_implements', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromInterfaces_accessor_implements);
+      });
+      _ut.test('test_getMapOfMembersInheritedFromInterfaces_accessor_with', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromInterfaces_accessor_with);
+      });
+      _ut.test('test_getMapOfMembersInheritedFromInterfaces_method_extends', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromInterfaces_method_extends);
+      });
+      _ut.test('test_getMapOfMembersInheritedFromInterfaces_method_implements', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromInterfaces_method_implements);
+      });
+      _ut.test('test_getMapOfMembersInheritedFromInterfaces_method_with', () {
+        final __test = new InheritanceManagerTest();
+        runJUnitTest(__test, __test.test_getMapOfMembersInheritedFromInterfaces_method_with);
+      });
       _ut.test('test_lookupInheritance_interface_getter', () {
         final __test = new InheritanceManagerTest();
         runJUnitTest(__test, __test.test_lookupInheritance_interface_getter);
       });
       _ut.test('test_lookupInheritance_interface_method', () {
         final __test = new InheritanceManagerTest();
         runJUnitTest(__test, __test.test_lookupInheritance_interface_method);
       });
       _ut.test('test_lookupInheritance_interface_setter', () {
         final __test = new InheritanceManagerTest();
@@ skipping 179 matching lines @@
     Source source = addSource(EngineTestCase.createSource([
         "library L;",
         "export 'lib1.dart';",
         "export 'lib2.dart';"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.AMBIGUOUS_EXPORT]);
     verify([source]);
   }
-  void test_ambiguousImport_as() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "import 'lib2.dart';",
-        "f(p) {p as N;}"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
-    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
-  }
-  void test_ambiguousImport_extends() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "import 'lib2.dart';",
-        "class A extends N {}"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
-    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
-    resolve(source);
-    assertErrors([
-        CompileTimeErrorCode.AMBIGUOUS_IMPORT,
-        CompileTimeErrorCode.EXTENDS_NON_CLASS]);
-  }
-  void test_ambiguousImport_function() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "import 'lib2.dart';",
-        "g() { return f(); }"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "f() {}"]));
-    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "f() {}"]));
-    resolve(source);
-    assertErrors([
-        CompileTimeErrorCode.AMBIGUOUS_IMPORT,
-        StaticTypeWarningCode.UNDEFINED_FUNCTION]);
-  }
-  void test_ambiguousImport_implements() {
-    Source source = addSource(EngineTestCase.createSource([
-        "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([
-        CompileTimeErrorCode.AMBIGUOUS_IMPORT,
-        CompileTimeErrorCode.IMPLEMENTS_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([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
-  }
-  void test_ambiguousImport_is() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "import 'lib2.dart';",
-        "f(p) {p is N;}"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
-    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
-  }
-  void test_ambiguousImport_qualifier() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "import 'lib2.dart';",
-        "g() { N.FOO; }"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
-    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
-  }
-  void test_ambiguousImport_typeArgument_instanceCreation() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "import 'lib2.dart';",
-        "class A<T> {}",
-        "f() {new A<N>();}"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
-    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
-  }
-  void test_ambiguousImport_varRead() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "import 'lib2.dart';",
-        "f() { g(v); }",
-        "g(p) {}"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "var v;"]));
-    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "var v;"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
-  }
-  void test_ambiguousImport_varWrite() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'lib1.dart';",
-        "import 'lib2.dart';",
-        "f() { v = 0; }"]));
-    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "var v;"]));
-    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "var v;"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
-  }
   void test_argumentDefinitionTestNonParameter() {
     Source source = addSource(EngineTestCase.createSource(["f() {", " var v = 0;", " return ?v;", "}"]));
     resolve(source);
     assertErrors([
         ParserErrorCode.DEPRECATED_ARGUMENT_DEFINITION_TEST,
         CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER]);
     verify([source]);
   }
   void test_argumentTypeNotAssignable_const() {
     Source source = addSource(EngineTestCase.createSource([
@@ skipping 971 matching lines @@
         "  B() : super(f);",
         "  var f;",
         "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
     verify([source]);
   }
   void test_importInternalLibrary() {
     Source source = addSource(EngineTestCase.createSource(["import 'dart:_interceptors';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY]);
+    assertErrors([
+        CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
+        HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
   void test_importInternalLibrary_collection() {
     Source source = addSource(EngineTestCase.createSource(["import 'dart:_collection-dev';"]));
     resolve(source);
-    assertErrors([CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY]);
+    assertErrors([
+        CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY,
+        HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
   void test_importOfNonLibrary() {
-    Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';"]));
-    addSource2("/part.dart", EngineTestCase.createSource(["part of lib;"]));
+    Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';", "A a;"]));
+    addSource2("/part.dart", EngineTestCase.createSource(["part of lib;", "class A{}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY]);
     verify([source]);
   }
   void test_inconsistentCaseExpressionTypes() {
     Source source = addSource(EngineTestCase.createSource([
         "f(var p) {",
         "  switch (p) {",
         "    case 1:",
         "      break;",
@@ skipping 495 matching lines @@
   void test_multipleSuperInitializers() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {",
         "  B() : super(), super() {}",
         "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS]);
     verify([source]);
   }
+  void test_nativeClauseInNonSDKCode() {
+    Source source = addSource(EngineTestCase.createSource(["class A native 'string' {}"]));
+    resolve(source);
+    assertErrors([ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE]);
+    verify([source]);
+  }
   void test_nativeFunctionBodyInNonSDKCode_function() {
     Source source = addSource(EngineTestCase.createSource(["int m(a) native 'string';"]));
     resolve(source);
     assertErrors([ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE]);
     verify([source]);
   }
   void test_nativeFunctionBodyInNonSDKCode_method() {
     Source source = addSource(EngineTestCase.createSource(["class A{", "  static int m(a) native 'string';", "}"]));
     resolve(source);
     assertErrors([ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE]);
@@ skipping 276 matching lines @@
     verify([source]);
   }
   void test_partOfNonPart() {
     Source source = addSource(EngineTestCase.createSource(["library l1;", "part 'l2.dart';"]));
     addSource2("/l2.dart", EngineTestCase.createSource(["library l2;"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.PART_OF_NON_PART]);
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers_functionTypeAlias() {
-    addSource2("/lib.dart", "library lib;");
-    Source source = addSource(EngineTestCase.createSource(["import '/lib.dart' as p;", "typedef p();"]));
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
+    Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "typedef p();", "p.A a;"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers_topLevelFunction() {
-    addSource2("/lib.dart", "library lib;");
-    Source source = addSource(EngineTestCase.createSource(["import '/lib.dart' as p;", "p() {}"]));
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
+    Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "p() {}", "p.A a;"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers_topLevelVariable() {
-    addSource2("/lib.dart", "library lib;");
-    Source source = addSource(EngineTestCase.createSource(["import '/lib.dart' as p;", "var p = null;"]));
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
+    Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "var p = null;", "p.A a;"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
   void test_prefixCollidesWithTopLevelMembers_type() {
-    addSource2("/lib.dart", "library lib;");
-    Source source = addSource(EngineTestCase.createSource(["import '/lib.dart' as p;", "class p {}"]));
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
+    Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "class p {}", "p.A a;"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
     verify([source]);
   }
   void test_privateOptionalParameter() {
     Source source = addSource(EngineTestCase.createSource(["f({var _p}) {}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER]);
     verify([source]);
   }
@@ skipping 355 matching lines @@
     resolve(source);
     assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_parameterType_required() {
     Source source = addSource(EngineTestCase.createSource(["typedef A(A a);"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
+  void test_typeAliasCannotReferenceItself_parameterType_typeArgument() {
+    Source source = addSource(EngineTestCase.createSource(["typedef A(List<A> a);"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
+    verify([source]);
+  }
+  void test_typeAliasCannotReferenceItself_returnClass_withTypeAlias() {
+    Source source = addSource(EngineTestCase.createSource([
+        "typedef C A();",
+        "typedef A B();",
+        "class C {",
+        "  B a;",
+        "}"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
+    verify([source]);
+  }
   void test_typeAliasCannotReferenceItself_returnType() {
     Source source = addSource(EngineTestCase.createSource(["typedef A A();"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotReferenceItself_returnType_indirect() {
     Source source = addSource(EngineTestCase.createSource(["typedef B A();", "typedef A B();"]));
     resolve(source);
     assertErrors([
         CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
         CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
-  void test_typeAliasCannotReferenceItself_typeVariableBounds() {
-    Source source = addSource(EngineTestCase.createSource(["typedef A<T extends A>();"]));
-    resolve(source);
-    assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
-    verify([source]);
-  }
   void test_typeAliasCannotRereferenceItself_mixin_direct() {
     Source source = addSource(EngineTestCase.createSource(["typedef M = Object with M;"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
     verify([source]);
   }
   void test_typeAliasCannotRereferenceItself_mixin_indirect() {
     Source source = addSource(EngineTestCase.createSource([
         "typedef M1 = Object with M2;",
         "typedef M2 = Object with M1;"]));
@@ skipping 228 matching lines @@
   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_as', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_ambiguousImport_as);
-      });
-      _ut.test('test_ambiguousImport_extends', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_ambiguousImport_extends);
-      });
-      _ut.test('test_ambiguousImport_function', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_ambiguousImport_function);
-      });
-      _ut.test('test_ambiguousImport_implements', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_ambiguousImport_implements);
-      });
-      _ut.test('test_ambiguousImport_instanceCreation', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_ambiguousImport_instanceCreation);
-      });
-      _ut.test('test_ambiguousImport_is', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_ambiguousImport_is);
-      });
-      _ut.test('test_ambiguousImport_qualifier', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_ambiguousImport_qualifier);
-      });
-      _ut.test('test_ambiguousImport_typeArgument_instanceCreation', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_ambiguousImport_typeArgument_instanceCreation);
-      });
-      _ut.test('test_ambiguousImport_varRead', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_ambiguousImport_varRead);
-      });
-      _ut.test('test_ambiguousImport_varWrite', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_ambiguousImport_varWrite);
-      });
       _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();
@@ skipping 696 matching lines @@
         runJUnitTest(__test, __test.test_mixinWithNonClassSuperclass_typedef);
       });
       _ut.test('test_multipleRedirectingConstructorInvocations', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_multipleRedirectingConstructorInvocations);
       });
       _ut.test('test_multipleSuperInitializers', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_multipleSuperInitializers);
       });
+      _ut.test('test_nativeClauseInNonSDKCode', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_nativeClauseInNonSDKCode);
+      });
       _ut.test('test_nativeFunctionBodyInNonSDKCode_function', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nativeFunctionBodyInNonSDKCode_function);
       });
       _ut.test('test_nativeFunctionBodyInNonSDKCode_method', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nativeFunctionBodyInNonSDKCode_method);
       });
       _ut.test('test_noAnnotationConstructorArguments', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 296 matching lines @@
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_parameterType_named);
       });
       _ut.test('test_typeAliasCannotReferenceItself_parameterType_positional', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_parameterType_positional);
       });
       _ut.test('test_typeAliasCannotReferenceItself_parameterType_required', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_parameterType_required);
       });
+      _ut.test('test_typeAliasCannotReferenceItself_parameterType_typeArgument', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_parameterType_typeArgument);
+      });
+      _ut.test('test_typeAliasCannotReferenceItself_returnClass_withTypeAlias', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_returnClass_withTypeAlias);
+      });
       _ut.test('test_typeAliasCannotReferenceItself_returnType', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_returnType);
       });
       _ut.test('test_typeAliasCannotReferenceItself_returnType_indirect', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_returnType_indirect);
       });
-      _ut.test('test_typeAliasCannotReferenceItself_typeVariableBounds', () {
-        final __test = new CompileTimeErrorCodeTest();
-        runJUnitTest(__test, __test.test_typeAliasCannotReferenceItself_typeVariableBounds);
-      });
       _ut.test('test_typeAliasCannotRereferenceItself_mixin_direct', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotRereferenceItself_mixin_direct);
       });
       _ut.test('test_typeAliasCannotRereferenceItself_mixin_indirect', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_typeAliasCannotRereferenceItself_mixin_indirect);
       });
       _ut.test('test_typeArgumentNotMatchingBounds_const', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 525 matching lines @@
     IndexExpression expression = ASTFactory.indexExpression(array, ASTFactory.identifier3("i"));
     JUnitTestCase.assertSame(operator, resolve5(expression, []));
     _listener.assertNoErrors();
   }
   void test_visitAssignmentExpression_compound() {
     InterfaceType intType = _typeProvider.intType;
     SimpleIdentifier leftHandSide = ASTFactory.identifier3("a");
     leftHandSide.staticType = intType;
     AssignmentExpression assignment = ASTFactory.assignmentExpression(leftHandSide, TokenType.PLUS_EQ, ASTFactory.integer(1));
     resolveNode(assignment, []);
-    JUnitTestCase.assertSame(getMethod(_typeProvider.numType, "+"), assignment.element);
+    JUnitTestCase.assertSame(getMethod(_typeProvider.numType, "+"), assignment.staticElement);
     _listener.assertNoErrors();
   }
   void test_visitAssignmentExpression_simple() {
     AssignmentExpression expression = ASTFactory.assignmentExpression(ASTFactory.identifier3("x"), TokenType.EQ, ASTFactory.integer(0));
     resolveNode(expression, []);
-    JUnitTestCase.assertNull(expression.element);
+    JUnitTestCase.assertNull(expression.staticElement);
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier left = ASTFactory.identifier3("i");
     left.staticType = numType;
     BinaryExpression expression = ASTFactory.binaryExpression(left, TokenType.PLUS, ASTFactory.identifier3("j"));
     resolveNode(expression, []);
-    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.element);
+    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.staticElement);
     _listener.assertNoErrors();
   }
   void test_visitBreakStatement_withLabel() {
     String label = "loop";
     LabelElementImpl labelElement = new LabelElementImpl(ASTFactory.identifier3(label), false, false);
     BreakStatement statement = ASTFactory.breakStatement2(label);
     JUnitTestCase.assertSame(labelElement, resolve(statement, labelElement));
     _listener.assertNoErrors();
   }
   void test_visitBreakStatement_withoutLabel() {
@@ skipping 152 matching lines @@
     JUnitTestCase.assertSame(method, invocation.methodName.element);
     JUnitTestCase.assertSame(parameter, ((invocation.argumentList.arguments[0] as NamedExpression)).name.label.element);
     _listener.assertNoErrors();
   }
   void test_visitPostfixExpression() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier operand = ASTFactory.identifier3("i");
     operand.staticType = numType;
     PostfixExpression expression = ASTFactory.postfixExpression(operand, TokenType.PLUS_PLUS);
     resolveNode(expression, []);
-    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.element);
+    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.staticElement);
     _listener.assertNoErrors();
   }
   void test_visitPrefixedIdentifier_dynamic() {
     Type2 dynamicType = _typeProvider.dynamicType;
     SimpleIdentifier target = ASTFactory.identifier3("a");
     VariableElementImpl variable = ElementFactory.localVariableElement(target);
     variable.type = dynamicType;
     target.element = variable;
     target.staticType = dynamicType;
     PrefixedIdentifier identifier = ASTFactory.identifier(target, ASTFactory.identifier3("b"));
@@ skipping 17 matching lines @@
     JUnitTestCase.assertSame(getter, identifier.element);
     JUnitTestCase.assertSame(getter, identifier.identifier.element);
     _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.element);
+    JUnitTestCase.assertEquals(getMethod(numType, "+"), expression.staticElement);
     _listener.assertNoErrors();
   }
   void test_visitPropertyAccess_getter_identifier() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String getterName = "b";
     PropertyAccessorElement getter = ElementFactory.getterElement(getterName, false, _typeProvider.intType);
     classA.accessors = <PropertyAccessorElement> [getter];
     SimpleIdentifier target = ASTFactory.identifier3("a");
     target.staticType = classA.type;
     PropertyAccess access = ASTFactory.propertyAccess2(target, getterName);
@@ skipping 154 matching lines @@
    * Return the element associated with the given expression after the resolver has resolved the
    * expression.
    *
    * @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
    */
   Element resolve5(IndexExpression node, List<Element> definedElements) {
     resolveNode(node, definedElements);
-    return node.element;
+    return node.staticElement;
   }
 
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
    *
    * @param node the expression to be resolved
    * @param enclosingClass the element representing the class enclosing the identifier
    * @return the element to which the expression was resolved
    */
@@ skipping 481 matching lines @@
     assertErrors([StaticWarningCode.UNDEFINED_GETTER]);
     verify([source]);
   }
   void fail_undefinedIdentifier_commentReference() {
     Source source = addSource(EngineTestCase.createSource(["/** [m] xxx [new B.c] */", "class A {", "}"]));
     resolve(source);
     assertErrors([
         StaticWarningCode.UNDEFINED_IDENTIFIER,
         StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
-  void fail_undefinedIdentifier_function() {
-    Source source = addSource(EngineTestCase.createSource(["int a() => b;"]));
-    resolve(source);
-    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
-    verify([source]);
-  }
   void fail_undefinedSetter() {
     Source source = addSource(EngineTestCase.createSource(["class C {}", "f(var p) {", "  C.m = 0;", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_SETTER]);
     verify([source]);
   }
   void fail_undefinedStaticMethodOrGetter_getter() {
     Source source = addSource(EngineTestCase.createSource(["class C {}", "f(var p) {", "  f(C.m);", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER]);
     verify([source]);
   }
   void fail_undefinedStaticMethodOrGetter_method() {
     Source source = addSource(EngineTestCase.createSource(["class C {}", "f(var p) {", "  f(C.m());", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_STATIC_METHOD_OR_GETTER]);
     verify([source]);
   }
+  void test_ambiguousImport_as() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "import 'lib2.dart';",
+        "f(p) {p as N;}"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+  }
+  void test_ambiguousImport_extends() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "import 'lib2.dart';",
+        "class A extends N {}"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
+    resolve(source);
+    assertErrors([
+        StaticWarningCode.AMBIGUOUS_IMPORT,
+        CompileTimeErrorCode.EXTENDS_NON_CLASS]);
+  }
+  void test_ambiguousImport_function() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "import 'lib2.dart';",
+        "g() { return f(); }"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "f() {}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "f() {}"]));
+    resolve(source);
+    assertErrors([
+        StaticWarningCode.AMBIGUOUS_IMPORT,
+        StaticTypeWarningCode.UNDEFINED_FUNCTION]);
+  }
+  void test_ambiguousImport_implements() {
+    Source source = addSource(EngineTestCase.createSource([
+        "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([
+        StaticWarningCode.AMBIGUOUS_IMPORT,
+        CompileTimeErrorCode.IMPLEMENTS_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([StaticWarningCode.AMBIGUOUS_IMPORT]);
+  }
+  void test_ambiguousImport_is() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "import 'lib2.dart';",
+        "f(p) {p is N;}"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+  }
+  void test_ambiguousImport_qualifier() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "import 'lib2.dart';",
+        "g() { N.FOO; }"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
+    resolve(source);
+    assertErrors([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;",
         "}",
         "class A {",
         "  N m() {}",
@@ skipping 15 matching lines @@
     Source source = addSource(EngineTestCase.createSource([
         "import 'lib1.dart';",
         "import 'lib2.dart';",
         "class A<T> {}",
         "A<N> f() {}"]));
     addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
     addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
     resolve(source);
     assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
+  void test_ambiguousImport_typeArgument_instanceCreation() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "import 'lib2.dart';",
+        "class A<T> {}",
+        "f() {new A<N>();}"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+  }
+  void test_ambiguousImport_varRead() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "import 'lib2.dart';",
+        "f() { g(v); }",
+        "g(p) {}"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "var v;"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "var v;"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+  }
+  void test_ambiguousImport_varWrite() {
+    Source source = addSource(EngineTestCase.createSource([
+        "import 'lib1.dart';",
+        "import 'lib2.dart';",
+        "f() { v = 0; }"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "var v;"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "var v;"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.AMBIGUOUS_IMPORT]);
+  }
   void test_argumentTypeNotAssignable_annotation_namedConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  const A.fromInt(int p);",
         "}",
         "@A.fromInt('0')",
         "main() {",
         "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
@@ skipping 149 matching lines @@
         "class A {",
         "  A(String p) {}",
         "}",
         "main() {",
         "  new A(42);",
         "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
+  void test_assignmentToConst_instanceVariable() {
+    Source source = addSource(EngineTestCase.createSource([
+        "class A {",
+        "  static const v = 0;",
+        "}",
+        "f() {",
+        "  A a = new A();",
+        "  a.v = 1;",
+        "}"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.ASSIGNMENT_TO_CONST]);
+    verify([source]);
+  }
+  void test_assignmentToConst_localVariable() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  const x = 0;", "  x = 1;", "}"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.ASSIGNMENT_TO_CONST]);
+    verify([source]);
+  }
   void test_assignmentToFinal_instanceVariable() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  final v = 0;",
         "}",
         "f() {",
         "  A a = new A();",
         "  a.v = 1;",
         "}"]));
     resolve(source);
@@ skipping 320 matching lines @@
     verify([source]);
   }
   void test_importDuplicatedLibraryName() {
     Source source = addSource(EngineTestCase.createSource([
         "library test;",
         "import 'lib1.dart';",
         "import 'lib2.dart';"]));
     addSource2("/lib1.dart", "library lib;");
     addSource2("/lib2.dart", "library lib;");
     resolve(source);
-    assertErrors([StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAME]);
+    assertErrors([
+        StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAME,
+        HintCode.UNUSED_IMPORT,
+        HintCode.UNUSED_IMPORT]);
     verify([source]);
   }
   void test_inconsistentMethodInheritanceGetterAndMethod() {
     Source source = addSource(EngineTestCase.createSource([
         "abstract class A {",
         "  int x();",
         "}",
         "abstract class B {",
         "  int get x;",
         "}",
@@ skipping 353 matching lines @@
     assertErrors([StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS]);
     verify([source]);
   }
   void test_newWithNonType() {
     Source source = addSource(EngineTestCase.createSource(["var A = 0;", "void f() {", "  var a = new A();", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.NEW_WITH_NON_TYPE]);
     verify([source]);
   }
   void test_newWithNonType_fromLibrary() {
-    Source source1 = addSource2("lib.dart", "");
+    Source source1 = addSource2("lib.dart", "class B {}");
     Source source2 = addSource2("lib2.dart", EngineTestCase.createSource([
         "import 'lib.dart' as lib;",
         "void f() {",
         "  var a = new lib.A();",
-        "}"]));
+        "}",
+        "lib.B b;"]));
     resolve(source1);
     resolve(source2);
     assertErrors([StaticWarningCode.NEW_WITH_NON_TYPE]);
     verify([source1]);
   }
   void test_newWithUndefinedConstructor() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {",
         "  A() {}",
         "}",
@@ skipping 402 matching lines @@
     Source source2 = addSource2("lib2.dart", EngineTestCase.createSource([
         "import 'lib.dart' as lib;",
         "void f() {",
         "  var g = lib.gg;",
         "}"]));
     resolve(source1);
     resolve(source2);
     assertErrors([StaticWarningCode.UNDEFINED_GETTER]);
     verify([source1]);
   }
+  void test_undefinedIdentifier_function() {
+    Source source = addSource(EngineTestCase.createSource(["int a() => b;"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+  }
+  void test_undefinedIdentifier_function_prefix() {
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class C {}"]));
+    Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as b;", "", "int a() => b;", "b.C c;"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+    verify([source]);
+  }
   void test_undefinedIdentifier_initializer() {
     Source source = addSource(EngineTestCase.createSource(["var a = b;"]));
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
+  void test_undefinedIdentifier_initializer_prefix() {
+    addSource2("/lib.dart", EngineTestCase.createSource(["library lib;", "class C {}"]));
+    Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as b;", "", "var a = b;", "b.C c;"]));
+    resolve(source);
+    assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
+  }
   void test_undefinedIdentifier_metadata() {
     Source source = addSource(EngineTestCase.createSource(["@undefined class A {}"]));
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedIdentifier_methodInvocation() {
     Source source = addSource(EngineTestCase.createSource(["f() { C.m(); }"]));
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_IDENTIFIER]);
   }
   void test_undefinedNamedParameter() {
     Source source = addSource(EngineTestCase.createSource(["f({a, b}) {}", "main() {", "  f(c: 1);", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.UNDEFINED_NAMED_PARAMETER]);
   }
   static dartSuite() {
     _ut.group('StaticWarningCodeTest', () {
+      _ut.test('test_ambiguousImport_as', () {
+        final __test = new StaticWarningCodeTest();
+        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_function', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_ambiguousImport_function);
+      });
+      _ut.test('test_ambiguousImport_implements', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_ambiguousImport_implements);
+      });
+      _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();
+        runJUnitTest(__test, __test.test_ambiguousImport_qualifier);
+      });
       _ut.test('test_ambiguousImport_typeAnnotation', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_typeAnnotation);
       });
       _ut.test('test_ambiguousImport_typeArgument_annotation', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_ambiguousImport_typeArgument_annotation);
       });
+      _ut.test('test_ambiguousImport_typeArgument_instanceCreation', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_ambiguousImport_typeArgument_instanceCreation);
+      });
+      _ut.test('test_ambiguousImport_varRead', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_ambiguousImport_varRead);
+      });
+      _ut.test('test_ambiguousImport_varWrite', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_ambiguousImport_varWrite);
+      });
       _ut.test('test_argumentTypeNotAssignable_annotation_namedConstructor', () {
         final __test = new StaticWarningCodeTest();
         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();
@@ skipping 48 matching lines @@
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_new_generic);
       });
       _ut.test('test_argumentTypeNotAssignable_new_optional', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_new_optional);
       });
       _ut.test('test_argumentTypeNotAssignable_new_required', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_argumentTypeNotAssignable_new_required);
       });
+      _ut.test('test_assignmentToConst_instanceVariable', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_assignmentToConst_instanceVariable);
+      });
+      _ut.test('test_assignmentToConst_localVariable', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_assignmentToConst_localVariable);
+      });
       _ut.test('test_assignmentToFinal_instanceVariable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_assignmentToFinal_instanceVariable);
       });
       _ut.test('test_assignmentToFinal_localVariable', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_assignmentToFinal_localVariable);
       });
       _ut.test('test_assignmentToFinal_prefixMinusMinus', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 456 matching lines @@
         runJUnitTest(__test, __test.test_undefinedClass_instanceCreation);
       });
       _ut.test('test_undefinedClass_variableDeclaration', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedClass_variableDeclaration);
       });
       _ut.test('test_undefinedGetter_fromLibrary', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedGetter_fromLibrary);
       });
+      _ut.test('test_undefinedIdentifier_function', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_undefinedIdentifier_function);
+      });
+      _ut.test('test_undefinedIdentifier_function_prefix', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_undefinedIdentifier_function_prefix);
+      });
       _ut.test('test_undefinedIdentifier_initializer', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_initializer);
       });
+      _ut.test('test_undefinedIdentifier_initializer_prefix', () {
+        final __test = new StaticWarningCodeTest();
+        runJUnitTest(__test, __test.test_undefinedIdentifier_initializer_prefix);
+      });
       _ut.test('test_undefinedIdentifier_metadata', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_metadata);
       });
       _ut.test('test_undefinedIdentifier_methodInvocation', () {
         final __test = new StaticWarningCodeTest();
         runJUnitTest(__test, __test.test_undefinedIdentifier_methodInvocation);
       });
       _ut.test('test_undefinedNamedParameter', () {
         final __test = new StaticWarningCodeTest();
@@ skipping 467 matching lines @@
     LibraryElementImpl importingLibrary = createTestLibrary2(context, "importing", []);
     importingLibrary.imports = <ImportElement> [import1, import2];
     {
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
       JUnitTestCase.assertEquals(typeA, scope.lookup(ASTFactory.identifier3(typeNameA), importingLibrary));
       errorListener.assertNoErrors();
       JUnitTestCase.assertEquals(typeC, scope.lookup(ASTFactory.identifier3(typeNameC), importingLibrary));
       errorListener.assertNoErrors();
       Element element = scope.lookup(ASTFactory.identifier3(typeNameB), importingLibrary);
-      errorListener.assertErrors2([CompileTimeErrorCode.AMBIGUOUS_IMPORT]);
+      errorListener.assertErrors2([StaticWarningCode.AMBIGUOUS_IMPORT]);
       EngineTestCase.assertInstanceOf(MultiplyDefinedElement, element);
       List<Element> conflictingElements = ((element as MultiplyDefinedElement)).conflictingElements;
       JUnitTestCase.assertEquals(typeB1, conflictingElements[0]);
       JUnitTestCase.assertEquals(typeB2, conflictingElements[1]);
       JUnitTestCase.assertEquals(2, conflictingElements.length);
     }
     {
       GatheringErrorListener errorListener = new GatheringErrorListener();
       Scope scope = new LibraryImportScope(importingLibrary, errorListener);
       Identifier identifier = ASTFactory.identifier3(typeNameB);
@@ skipping 18 matching lines @@
     ImportElementImpl importElement = new ImportElementImpl();
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement> [importElement];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryImportScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(importedType, scope.lookup(ASTFactory.identifier3(importedTypeName), definingLibrary));
   }
   void test_getDefiningLibrary() {
     LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    Scope scope = new LibraryImportScope(definingLibrary, errorListener);
+    LibraryImportScope scope = new LibraryImportScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(definingLibrary, scope.definingLibrary);
   }
   void test_getErrorListener() {
     LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    Scope scope = new LibraryImportScope(definingLibrary, errorListener);
+    LibraryImportScope scope = new LibraryImportScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(errorListener, scope.errorListener);
   }
   void test_prefixedAndNonPrefixed() {
     AnalysisContext context = new AnalysisContextImpl();
     String typeName = "C";
     String prefixName = "p";
     ClassElement prefixedType = ElementFactory.classElement2(typeName, []);
     ClassElement nonPrefixedType = ElementFactory.classElement2(typeName, []);
     LibraryElement prefixedLibrary = createTestLibrary2(context, "import.prefixed", []);
     ((prefixedLibrary.definingCompilationUnit as CompilationUnitElementImpl)).types = <ClassElement> [prefixedType];
@@ skipping 105 matching lines @@
   }
   Object visitBinaryExpression(BinaryExpression node) {
     node.visitChildren(this);
     if (!node.operator.isUserDefinableOperator) {
       return null;
     }
     Type2 operandType = node.leftOperand.staticType;
     if (operandType == null || operandType.isDynamic) {
       return null;
     }
-    return checkResolved2(node, node.element, MethodElement);
+    return checkResolved2(node, node.staticElement, MethodElement);
   }
   Object visitCommentReference(CommentReference node) => null;
   Object visitCompilationUnit(CompilationUnit node) {
     node.visitChildren(this);
     return checkResolved2(node, node.element, CompilationUnitElement);
   }
   Object visitExportDirective(ExportDirective node) => checkResolved2(node, node.element, ExportElement);
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     node.visitChildren(this);
     if (node.element is LibraryElement) {
@@ skipping 12 matching lines @@
       return null;
     }
     return checkResolved2(prefix, prefix.element, PrefixElement);
   }
   Object visitIndexExpression(IndexExpression node) {
     node.visitChildren(this);
     Type2 targetType = node.realTarget.staticType;
     if (targetType == null || targetType.isDynamic) {
       return null;
     }
-    return checkResolved2(node, node.element, MethodElement);
+    return checkResolved2(node, node.staticElement, MethodElement);
   }
   Object visitLibraryDirective(LibraryDirective node) => checkResolved2(node, node.element, LibraryElement);
   Object visitNamedExpression(NamedExpression node) => node.expression.accept(this);
   Object visitPartDirective(PartDirective node) => checkResolved2(node, node.element, CompilationUnitElement);
   Object visitPartOfDirective(PartOfDirective node) => checkResolved2(node, node.element, LibraryElement);
   Object visitPostfixExpression(PostfixExpression node) {
     node.visitChildren(this);
     if (!node.operator.isUserDefinableOperator) {
       return null;
     }
     Type2 operandType = node.operand.staticType;
     if (operandType == null || operandType.isDynamic) {
       return null;
     }
-    return checkResolved2(node, node.element, MethodElement);
+    return checkResolved2(node, node.staticElement, MethodElement);
   }
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefix = node.prefix;
     prefix.accept(this);
     Type2 prefixType = prefix.staticType;
     if (prefixType == null || prefixType.isDynamic) {
       return null;
     }
     return checkResolved(node, node.element);
   }
   Object visitPrefixExpression(PrefixExpression node) {
     node.visitChildren(this);
     if (!node.operator.isUserDefinableOperator) {
       return null;
     }
     Type2 operandType = node.operand.staticType;
     if (operandType == null || operandType.isDynamic) {
       return null;
     }
-    return checkResolved2(node, node.element, MethodElement);
+    return checkResolved2(node, node.staticElement, MethodElement);
   }
   Object visitPropertyAccess(PropertyAccess node) {
     Expression target = node.realTarget;
     target.accept(this);
     Type2 targetType = target.staticType;
     if (targetType == null || targetType.isDynamic) {
       return null;
     }
     return node.propertyName.accept(this);
   }
@@ skipping 71 matching lines @@
     ImportElementImpl importElement = new ImportElementImpl();
     importElement.importedLibrary = importedLibrary;
     definingLibrary.imports = <ImportElement> [importElement];
     GatheringErrorListener errorListener = new GatheringErrorListener();
     Scope scope = new LibraryScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(importedType, scope.lookup(ASTFactory.identifier3(importedTypeName), definingLibrary));
   }
   void test_getDefiningLibrary() {
     LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    Scope scope = new LibraryScope(definingLibrary, errorListener);
+    LibraryScope scope = new LibraryScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(definingLibrary, scope.definingLibrary);
   }
   void test_getErrorListener() {
     LibraryElement definingLibrary = createTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    Scope scope = new LibraryScope(definingLibrary, errorListener);
+    LibraryScope scope = new LibraryScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(errorListener, scope.errorListener);
   }
   static dartSuite() {
     _ut.group('LibraryScopeTest', () {
       _ut.test('test_creation_empty', () {
         final __test = new LibraryScopeTest();
         runJUnitTest(__test, __test.test_creation_empty);
       });
       _ut.test('test_creation_nonEmpty', () {
         final __test = new LibraryScopeTest();
@@ skipping 65 matching lines @@
     Expression node = ASTFactory.asExpression(ASTFactory.thisExpression(), ASTFactory.typeName(subclass, []));
     JUnitTestCase.assertSame(subclass.type, analyze2(node, superclassType));
     _listener.assertNoErrors();
   }
   void test_visitAssignmentExpression_compound() {
     InterfaceType numType = _typeProvider.numType;
     SimpleIdentifier identifier = resolvedVariable(_typeProvider.intType, "i");
     AssignmentExpression node = ASTFactory.assignmentExpression(identifier, TokenType.PLUS_EQ, resolvedInteger(1));
     MethodElement plusMethod = getMethod(numType, "+");
     node.staticElement = plusMethod;
-    node.element = plusMethod;
     JUnitTestCase.assertSame(numType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitAssignmentExpression_simple() {
     InterfaceType intType = _typeProvider.intType;
     Expression node = ASTFactory.assignmentExpression(resolvedVariable(intType, "i"), TokenType.EQ, resolvedInteger(0));
     JUnitTestCase.assertSame(intType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression_equals() {
@@ skipping 11 matching lines @@
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression_notEquals() {
     Expression node = ASTFactory.binaryExpression(resolvedInteger(2), TokenType.BANG_EQ, resolvedInteger(3));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression_plusID() {
     BinaryExpression node = ASTFactory.binaryExpression(resolvedInteger(1), TokenType.PLUS, resolvedDouble(2.0));
-    setStaticElement(node, getMethod(_typeProvider.numType, "+"));
+    node.staticElement = getMethod(_typeProvider.numType, "+");
     JUnitTestCase.assertSame(_typeProvider.doubleType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression_plusII() {
     BinaryExpression node = ASTFactory.binaryExpression(resolvedInteger(1), TokenType.PLUS, resolvedInteger(2));
-    setStaticElement(node, getMethod(_typeProvider.numType, "+"));
+    node.staticElement = getMethod(_typeProvider.numType, "+");
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression_slash() {
     BinaryExpression node = ASTFactory.binaryExpression(resolvedInteger(2), TokenType.SLASH, resolvedInteger(2));
-    setStaticElement(node, getMethod(_typeProvider.numType, "/"));
+    node.staticElement = getMethod(_typeProvider.numType, "/");
     JUnitTestCase.assertSame(_typeProvider.doubleType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression_star_notSpecial() {
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     InterfaceType typeA = classA.type;
     MethodElement operator = ElementFactory.methodElement("*", typeA, [_typeProvider.doubleType]);
     classA.methods = <MethodElement> [operator];
     BinaryExpression node = ASTFactory.binaryExpression(ASTFactory.asExpression(ASTFactory.identifier3("a"), ASTFactory.typeName(classA, [])), TokenType.PLUS, resolvedDouble(2.0));
-    setStaticElement(node, operator);
+    node.staticElement = operator;
     JUnitTestCase.assertSame(typeA, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBinaryExpression_starID() {
     BinaryExpression node = ASTFactory.binaryExpression(resolvedInteger(1), TokenType.PLUS, resolvedDouble(2.0));
-    setStaticElement(node, getMethod(_typeProvider.numType, "*"));
+    node.staticElement = getMethod(_typeProvider.numType, "*");
     JUnitTestCase.assertSame(_typeProvider.doubleType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBooleanLiteral_false() {
     Expression node = ASTFactory.booleanLiteral(false);
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitBooleanLiteral_true() {
     Expression node = ASTFactory.booleanLiteral(true);
@@ skipping 147 matching lines @@
     Type2 resultType = analyze(node);
     assertFunctionType(_typeProvider.intType, null, <Type2> [dynamicType], null, resultType);
     _listener.assertNoErrors();
   }
   void test_visitIndexExpression_getter() {
     InterfaceType listType = _typeProvider.listType;
     SimpleIdentifier identifier = resolvedVariable(listType, "a");
     IndexExpression node = ASTFactory.indexExpression(identifier, resolvedInteger(2));
     MethodElement indexMethod = listType.element.methods[0];
     node.staticElement = indexMethod;
-    node.element = indexMethod;
     JUnitTestCase.assertSame(listType.typeArguments[0], analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitIndexExpression_setter() {
     InterfaceType listType = _typeProvider.listType;
     SimpleIdentifier identifier = resolvedVariable(listType, "a");
     IndexExpression node = ASTFactory.indexExpression(identifier, resolvedInteger(2));
     MethodElement indexMethod = listType.element.methods[1];
     node.staticElement = indexMethod;
-    node.element = indexMethod;
     ASTFactory.assignmentExpression(node, TokenType.EQ, ASTFactory.integer(0));
     JUnitTestCase.assertSame(listType.typeArguments[0], analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitIndexExpression_typeParameters() {
     InterfaceType intType = _typeProvider.intType;
     InterfaceType listType = _typeProvider.listType;
     MethodElement methodElement = getMethod(listType, "[]");
     SimpleIdentifier identifier = ASTFactory.identifier3("list");
     InterfaceType listOfIntType = listType.substitute4(<Type2> [intType]);
     identifier.staticType = listOfIntType;
     IndexExpression indexExpression = ASTFactory.indexExpression(identifier, ASTFactory.integer(0));
     MethodElement indexMethod = MethodMember.from(methodElement, listOfIntType);
     indexExpression.staticElement = indexMethod;
-    indexExpression.element = indexMethod;
     JUnitTestCase.assertSame(intType, analyze(indexExpression));
     _listener.assertNoErrors();
   }
   void test_visitIndexExpression_typeParameters_inSetterContext() {
     InterfaceType intType = _typeProvider.intType;
     InterfaceType listType = _typeProvider.listType;
     MethodElement methodElement = getMethod(listType, "[]=");
     SimpleIdentifier identifier = ASTFactory.identifier3("list");
     InterfaceType listOfIntType = listType.substitute4(<Type2> [intType]);
     identifier.staticType = listOfIntType;
     IndexExpression indexExpression = ASTFactory.indexExpression(identifier, ASTFactory.integer(0));
     MethodElement indexMethod = MethodMember.from(methodElement, listOfIntType);
     indexExpression.staticElement = indexMethod;
-    indexExpression.element = indexMethod;
     ASTFactory.assignmentExpression(indexExpression, TokenType.EQ, ASTFactory.integer(0));
     JUnitTestCase.assertSame(intType, analyze(indexExpression));
     _listener.assertNoErrors();
   }
   void test_visitInstanceCreationExpression_named() {
     ClassElementImpl classElement = ElementFactory.classElement2("C", []);
     String constructorName = "m";
     ConstructorElementImpl constructor = ElementFactory.constructorElement(classElement, constructorName);
     constructor.returnType = classElement.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl.con1(constructor);
@@ skipping 130 matching lines @@
   }
   void test_visitPrefixExpression_bang() {
     PrefixExpression node = ASTFactory.prefixExpression(TokenType.BANG, resolvedInteger(0));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPrefixExpression_minus() {
     PrefixExpression node = ASTFactory.prefixExpression(TokenType.MINUS, resolvedInteger(0));
     MethodElement minusMethod = getMethod(_typeProvider.numType, "-");
     node.staticElement = minusMethod;
-    node.element = minusMethod;
     JUnitTestCase.assertSame(_typeProvider.numType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPrefixExpression_minusMinus() {
     PrefixExpression node = ASTFactory.prefixExpression(TokenType.MINUS_MINUS, resolvedInteger(0));
     MethodElement minusMethod = getMethod(_typeProvider.numType, "-");
     node.staticElement = minusMethod;
-    node.element = minusMethod;
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPrefixExpression_not() {
     Expression node = ASTFactory.prefixExpression(TokenType.BANG, ASTFactory.booleanLiteral(true));
     JUnitTestCase.assertSame(_typeProvider.boolType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPrefixExpression_plusPlus() {
     PrefixExpression node = ASTFactory.prefixExpression(TokenType.PLUS_PLUS, resolvedInteger(0));
     MethodElement plusMethod = getMethod(_typeProvider.numType, "+");
     node.staticElement = plusMethod;
-    node.element = plusMethod;
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPrefixExpression_tilde() {
     PrefixExpression node = ASTFactory.prefixExpression(TokenType.TILDE, resolvedInteger(0));
     MethodElement tildeMethod = getMethod(_typeProvider.intType, "~");
     node.staticElement = tildeMethod;
-    node.element = tildeMethod;
     JUnitTestCase.assertSame(_typeProvider.intType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitPropertyAccess_getter() {
     Type2 boolType = _typeProvider.boolType;
     PropertyAccessorElementImpl getter = ElementFactory.getterElement("b", false, boolType);
     PropertyAccess node = ASTFactory.propertyAccess2(ASTFactory.identifier3("a"), "b");
     node.propertyName.element = getter;
     JUnitTestCase.assertSame(boolType, analyze(node));
     _listener.assertNoErrors();
@@ skipping 20 matching lines @@
     JUnitTestCase.assertSame(_typeProvider.stringType, analyze(node));
     _listener.assertNoErrors();
   }
   void test_visitSuperExpression() {
     InterfaceType superType = ElementFactory.classElement2("A", []).type;
     InterfaceType thisType = ElementFactory.classElement("B", superType, []).type;
     Expression node = ASTFactory.superExpression();
     JUnitTestCase.assertSame(thisType, analyze2(node, thisType));
     _listener.assertNoErrors();
   }
+  void test_visitSymbolLiteral() {
+    JUnitTestCase.assertSame(_typeProvider.symbolType, analyze(ASTFactory.symbolLiteral(["a"])));
+  }
   void test_visitThisExpression() {
     InterfaceType thisType = ElementFactory.classElement("B", ElementFactory.classElement2("A", []).type, []).type;
     Expression node = ASTFactory.thisExpression();
     JUnitTestCase.assertSame(thisType, analyze2(node, thisType));
     _listener.assertNoErrors();
   }
   void test_visitThrowExpression_withoutValue() {
     Expression node = ASTFactory.throwExpression();
     JUnitTestCase.assertSame(_typeProvider.bottomType, analyze(node));
     _listener.assertNoErrors();
@@ skipping 202 matching lines @@
   SimpleIdentifier resolvedVariable(InterfaceType type2, String variableName) {
     SimpleIdentifier identifier = ASTFactory.identifier3(variableName);
     VariableElementImpl element = ElementFactory.localVariableElement(identifier);
     element.type = type2;
     identifier.element = element;
     identifier.staticType = type2;
     return identifier;
   }
 
   /**
-   * Sets the element for the node and remembers it as the static resolution.
-   */
-  void setStaticElement(BinaryExpression node, MethodElement element2) {
-    node.staticElement = element2;
-    node.element = element2;
-  }
-
-  /**
    * Set the type of the given parameter to the given type.
    *
    * @param parameter the parameter whose type is to be set
    * @param type the new type of the given parameter
    */
   void setType(FormalParameter parameter, Type2 type2) {
     SimpleIdentifier identifier = parameter.identifier;
     Element element = identifier.element;
     if (element is! ParameterElement) {
       element = new ParameterElementImpl.con1(identifier);
@@ skipping 252 matching lines @@
         runJUnitTest(__test, __test.test_visitSimpleStringLiteral);
       });
       _ut.test('test_visitStringInterpolation', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitStringInterpolation);
       });
       _ut.test('test_visitSuperExpression', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitSuperExpression);
       });
+      _ut.test('test_visitSymbolLiteral', () {
+        final __test = new StaticTypeAnalyzerTest();
+        runJUnitTest(__test, __test.test_visitSymbolLiteral);
+      });
       _ut.test('test_visitThisExpression', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitThisExpression);
       });
       _ut.test('test_visitThrowExpression_withValue', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitThrowExpression_withValue);
       });
       _ut.test('test_visitThrowExpression_withoutValue', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitThrowExpression_withoutValue);
       });
     });
   }
 }
 class NonHintCodeTest extends ResolverTestCase {
   void test_deadCode_deadCatch_onCatchSubtype() {
     Source source = addSource(EngineTestCase.createSource([
         "class A {}",
         "class B extends A {}",
         "f() {",
         "  try {} on B catch (e) {} on A catch (e) {} catch (e) {}",
         "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
+  void test_unusedImport_export() {
+    Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';", "Two two;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "export 'lib2.dart';", "class One {}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class Two {}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_unusedImport_export_infiniteLoop() {
+    Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';", "Two one;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "export 'lib2.dart';", "class One {}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "export 'lib3.dart';", "class Two {}"]));
+    addSource2("/lib3.dart", EngineTestCase.createSource(["library lib3;", "export 'lib2.dart';", "class Three {}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_unusedImport_export2() {
+    Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';", "Two one;"]));
+    addSource2("/lib1.dart", EngineTestCase.createSource(["library lib1;", "export 'lib2.dart';", "class One {}"]));
+    addSource2("/lib2.dart", EngineTestCase.createSource(["library lib2;", "export 'lib3.dart';", "class Two {}"]));
+    addSource2("/lib3.dart", EngineTestCase.createSource(["library lib3;", "class Three {}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
   static dartSuite() {
     _ut.group('NonHintCodeTest', () {
       _ut.test('test_deadCode_deadCatch_onCatchSubtype', () {
         final __test = new NonHintCodeTest();
         runJUnitTest(__test, __test.test_deadCode_deadCatch_onCatchSubtype);
       });
+      _ut.test('test_unusedImport_export', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_unusedImport_export);
+      });
+      _ut.test('test_unusedImport_export2', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_unusedImport_export2);
+      });
+      _ut.test('test_unusedImport_export_infiniteLoop', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_unusedImport_export_infiniteLoop);
+      });
     });
   }
 }
 class EnclosedScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     LibraryElement definingLibrary2 = createTestLibrary();
     GatheringErrorListener errorListener2 = new GatheringErrorListener();
-    Scope rootScope = new Scope_18(definingLibrary2, errorListener2);
+    Scope rootScope = new Scope_19(definingLibrary2, errorListener2);
     EnclosedScope scope = new EnclosedScope(rootScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     scope.define(element1);
     scope.define(element2);
     errorListener2.assertErrors3([ErrorSeverity.ERROR]);
   }
   void test_define_normal() {
     LibraryElement definingLibrary3 = createTestLibrary();
     GatheringErrorListener errorListener3 = new GatheringErrorListener();
-    Scope rootScope = new Scope_19(definingLibrary3, errorListener3);
+    Scope rootScope = new Scope_20(definingLibrary3, 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_18 extends Scope {
+class Scope_19 extends Scope {
   LibraryElement definingLibrary2;
   GatheringErrorListener errorListener2;
-  Scope_18(this.definingLibrary2, this.errorListener2) : super();
+  Scope_19(this.definingLibrary2, this.errorListener2) : super();
   LibraryElement get definingLibrary => definingLibrary2;
   AnalysisErrorListener get errorListener => errorListener2;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
-class Scope_19 extends Scope {
+class Scope_20 extends Scope {
   LibraryElement definingLibrary3;
   GatheringErrorListener errorListener3;
-  Scope_19(this.definingLibrary3, this.errorListener3) : super();
+  Scope_20(this.definingLibrary3, this.errorListener3) : super();
   LibraryElement get definingLibrary => definingLibrary3;
   AnalysisErrorListener get errorListener => errorListener3;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 class LibraryElementBuilderTest extends EngineTestCase {
 
   /**
    * The source factory used to create [Source].
    */
   SourceFactory _sourceFactory;
@@ skipping 194 matching lines @@
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ScopeTest_TestScope scope = new ScopeTest_TestScope(definingLibrary, errorListener);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier3("v2"));
     scope.define(element1);
     scope.define(element2);
     errorListener.assertNoErrors();
   }
   void test_getDefiningLibrary() {
     LibraryElement definingLibrary = createTestLibrary();
-    Scope scope = new ScopeTest_TestScope(definingLibrary, null);
+    ScopeTest_TestScope scope = new ScopeTest_TestScope(definingLibrary, null);
     JUnitTestCase.assertEquals(definingLibrary, scope.definingLibrary);
   }
   void test_getErrorListener() {
     LibraryElement definingLibrary = new LibraryElementImpl(new AnalysisContextImpl(), ASTFactory.libraryIdentifier2(["test"]));
     GatheringErrorListener errorListener = new GatheringErrorListener();
-    Scope scope = new ScopeTest_TestScope(definingLibrary, errorListener);
+    ScopeTest_TestScope scope = new ScopeTest_TestScope(definingLibrary, errorListener);
     JUnitTestCase.assertEquals(errorListener, scope.errorListener);
   }
   void test_isPrivateName_nonPrivate() {
     JUnitTestCase.assertFalse(Scope.isPrivateName("Public"));
   }
   void test_isPrivateName_private() {
     JUnitTestCase.assertTrue(Scope.isPrivateName("_Private"));
   }
   static dartSuite() {
     _ut.group('ScopeTest', () {
@@ skipping 284 matching lines @@
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(2, classes);
     JUnitTestCase.assertFalse(classes[0].hasReferenceToSuper());
     JUnitTestCase.assertTrue(classes[1].hasReferenceToSuper());
     assertNoErrors();
     verify([source]);
   }
   void test_import_hide() {
-    addSource2("lib1.dart", EngineTestCase.createSource(["library lib1;", "set foo(value) {}"]));
+    addSource2("lib1.dart", EngineTestCase.createSource(["library lib1;", "set foo(value) {}", "class A {}"]));
     addSource2("lib2.dart", EngineTestCase.createSource(["library lib2;", "set foo(value) {}"]));
     Source source = addSource2("lib3.dart", EngineTestCase.createSource([
         "import 'lib1.dart' hide foo;",
         "import 'lib2.dart';",
         "",
         "main() {",
         "  foo = 0;",
-        "}"]));
+        "}",
+        "A a;"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_import_prefix() {
     addSource2("/two.dart", EngineTestCase.createSource(["library two;", "f(int x) {", "  return x * x;", "}"]));
     Source source = addSource2("/one.dart", EngineTestCase.createSource([
         "library one;",
         "import 'two.dart' as _two;",
         "main() {",
         "  _two.f(0);",
         "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
+  void test_import_spaceInUri() {
+    addSource2("sub folder/lib.dart", EngineTestCase.createSource(["library lib;", "foo() {}"]));
+    Source source = addSource2("app.dart", EngineTestCase.createSource([
+        "import 'sub folder/lib.dart';",
+        "",
+        "main() {",
+        "  foo();",
+        "}"]));
+    resolve(source);
+    assertNoErrors();
+    verify([source]);
+  }
   void test_indexExpression_typeParameters() {
     Source source = addSource(EngineTestCase.createSource([
         "f() {",
         "  List<int> a;",
         "  a[0];",
         "  List<List<int>> b;",
         "  b[0][0];",
         "  List<List<List<int>>> c;",
         "  c[0][0][0];",
         "}"]));
@@ skipping 390 matching lines @@
         runJUnitTest(__test, __test.test_hasReferenceToSuper);
       });
       _ut.test('test_import_hide', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_import_hide);
       });
       _ut.test('test_import_prefix', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_import_prefix);
       });
+      _ut.test('test_import_spaceInUri', () {
+        final __test = new SimpleResolverTest();
+        runJUnitTest(__test, __test.test_import_spaceInUri);
+      });
       _ut.test('test_indexExpression_typeParameters', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_indexExpression_typeParameters);
       });
       _ut.test('test_indexExpression_typeParameters_invalidAssignmentWarning', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_indexExpression_typeParameters_invalidAssignmentWarning);
       });
       _ut.test('test_indirectOperatorThroughCall', () {
         final __test = new SimpleResolverTest();
@@ skipping 64 matching lines @@
         runJUnitTest(__test, __test.test_setter_inherited);
       });
       _ut.test('test_setter_static', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_setter_static);
       });
     });
   }
 }
 main() {
-//  ElementResolverTest.dartSuite();
-//  InheritanceManagerTest.dartSuite();
-//  LibraryElementBuilderTest.dartSuite();
-//  LibraryTest.dartSuite();
-//  StaticTypeAnalyzerTest.dartSuite();
-//  TypeOverrideManagerTest.dartSuite();
-//  TypeProviderImplTest.dartSuite();
-//  TypeResolverVisitorTest.dartSuite();
-//  EnclosedScopeTest.dartSuite();
-//  LibraryImportScopeTest.dartSuite();
-//  LibraryScopeTest.dartSuite();
-//  ScopeTest.dartSuite();
-//  CompileTimeErrorCodeTest.dartSuite();
-//  ErrorResolverTest.dartSuite();
-//  HintCodeTest.dartSuite();
-//  NonHintCodeTest.dartSuite();
-//  NonErrorResolverTest.dartSuite();
-//  SimpleResolverTest.dartSuite();
-//  StaticTypeWarningCodeTest.dartSuite();
-//  StaticWarningCodeTest.dartSuite();
-//  StrictModeTest.dartSuite();
-//  TypePropagationTest.dartSuite();
+  ElementResolverTest.dartSuite();
+  InheritanceManagerTest.dartSuite();
+  LibraryElementBuilderTest.dartSuite();
+  LibraryTest.dartSuite();
+  StaticTypeAnalyzerTest.dartSuite();
+  TypeOverrideManagerTest.dartSuite();
+  TypeProviderImplTest.dartSuite();
+  TypeResolverVisitorTest.dartSuite();
+  EnclosedScopeTest.dartSuite();
+  LibraryImportScopeTest.dartSuite();
+  LibraryScopeTest.dartSuite();
+  ScopeTest.dartSuite();
+  CompileTimeErrorCodeTest.dartSuite();
+  ErrorResolverTest.dartSuite();
+  HintCodeTest.dartSuite();
+  NonHintCodeTest.dartSuite();
+  NonErrorResolverTest.dartSuite();
+  SimpleResolverTest.dartSuite();
+  StaticTypeWarningCodeTest.dartSuite();
+  StaticWarningCodeTest.dartSuite();
+  StrictModeTest.dartSuite();
+  TypePropagationTest.dartSuite();
 }