New Analysis Engine translation.

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';
 import 'package:analyzer_experimental/src/generated/element.dart';
 import 'package:analyzer_experimental/src/generated/resolver.dart';
 import 'package:analyzer_experimental/src/generated/engine.dart';
 import 'package:analyzer_experimental/src/generated/java_engine_io.dart';
 import 'package:analyzer_experimental/src/generated/ast.dart' hide Annotation;
 import 'package:analyzer_experimental/src/generated/sdk.dart' show DartSdk;
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'ast_test.dart' show ASTFactory;
 import 'element_test.dart' show ElementFactory;
 
+class NonErrorResolverTest extends ResolverTestCase {
+  void test_argumentDefinitionTestNonParameter_formalParameter() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f(var v) {", "  return ?v;", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_argumentDefinitionTestNonParameter_namedParameter() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f({var v : 0}) {", "  return ?v;", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_argumentDefinitionTestNonParameter_optionalParameter() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f([var v]) {", "  return ?v;", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_breakWithoutLabelInSwitch() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  void m(int i) {", "    switch (i) {", "      case 0:", "        break;", "    }", "  }", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_builtInIdentifierAsType_dynamic() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  dynamic x;", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_caseExpressionTypeImplementsEquals_int() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f(int i) {", "  switch(i) {", "    case(1) : return 1;", "    default: return 0;", "  }", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_caseExpressionTypeImplementsEquals_Object() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class IntWrapper {", "  final int value;", "  const IntWrapper(this.value);", "}", "", "f(IntWrapper intWrapper) {", "  switch(intWrapper) {", "    case(const IntWrapper(1)) : return 1;", "    default: return 0;", "  }", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_caseExpressionTypeImplementsEquals_String() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f(String s) {", "  switch(s) {", "    case('1') : return 1;", "    default: return 0;", "  }", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_constConstructorWithNonFinalField_const() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  const int x;", "  const A() {}", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_constConstructorWithNonFinalField_final() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  final int x;", "  const A() {}", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_constConstructorWithNonFinalField_syntheticField() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  const A();", "  set x(value) {}", "  get x {return 0;}", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_defaultValueInFunctionTypeAlias() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["typedef F([x]);"]));
+    resolve(source, []);
+    assertErrors([]);
+    verify([source]);
+  }
+  void test_duplicateDefinition_getter() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["bool get a => true;"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_fieldInitializedInInitializerAndDeclaration_fieldNotFinal() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x = 0;", "  A() : x = 1 {}", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_fieldInitializedInInitializerAndDeclaration_finalFieldNotSet() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  final int x;", "  A() : x = 1 {}", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_fieldInitializerOutsideConstructor() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x;", "  A(this.x) {}", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_fieldInitializerOutsideConstructor_defaultParameters() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x;", "  A([this.x]) {}", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_invalidAssignment() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  var x;", "  var y;", "  x = y;", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_invalidAssignment_toDynamic() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  var g;", "  g = () => 0;", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_invocationOfNonFunction_dynamic() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  var f;", "}", "class B extends A {", "  g() {", "    f();", "  }", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_invocationOfNonFunction_getter() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  var g;", "}", "f() {", "  A a;", "  a.g();", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_invocationOfNonFunction_localVariable() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  var g;", "  g();", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_newWithAbstractClass_factory() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["abstract class A {", "  factory A() { return new B(); }", "}", "class B implements A {", "  B() {}", "}", "A f() {", "  return new A();", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_nonBoolExpression_assert_bool() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  assert(true);", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_nonBoolExpression_assert_functionType() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["bool makeAssertion() => true;", "f() {", "  assert(makeAssertion);", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_rethrowOutsideCatch() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  void m() {", "    try {} catch (e) {rethrow;}", "  }", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_returnOfInvalidType_dynamic() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  static void testLogicalOp() {", "    testOr(a, b, onTypeError) {", "      try {", "        return a || b;", "      } on TypeError catch (t) {", "        return onTypeError;", "      }", "    }", "  }", "}"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_returnOfInvalidType_subtype() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {}", "class B extends A {}", "A f(B b) { return b; }"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_returnOfInvalidType_supertype() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {}", "class B extends A {}", "B f(A a) { return a; }"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_const() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {}", "class B extends A {}", "class G<E extends A> {", "  const G() {}", "}", "f() { return const G<B>(); }"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  void test_typeArgumentNotMatchingBounds_new() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {}", "class B extends A {}", "class G<E extends A> {}", "f() { return new G<B>(); }"]));
+    resolve(source, []);
+    assertNoErrors();
+    verify([source]);
+  }
+  static dartSuite() {
+    _ut.group('NonErrorResolverTest', () {
+      _ut.test('test_argumentDefinitionTestNonParameter_formalParameter', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter_formalParameter);
+      });
+      _ut.test('test_argumentDefinitionTestNonParameter_namedParameter', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter_namedParameter);
+      });
+      _ut.test('test_argumentDefinitionTestNonParameter_optionalParameter', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter_optionalParameter);
+      });
+      _ut.test('test_breakWithoutLabelInSwitch', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_breakWithoutLabelInSwitch);
+      });
+      _ut.test('test_builtInIdentifierAsType_dynamic', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_builtInIdentifierAsType_dynamic);
+      });
+      _ut.test('test_caseExpressionTypeImplementsEquals_Object', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_Object);
+      });
+      _ut.test('test_caseExpressionTypeImplementsEquals_String', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_String);
+      });
+      _ut.test('test_caseExpressionTypeImplementsEquals_int', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_int);
+      });
+      _ut.test('test_constConstructorWithNonFinalField_const', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_const);
+      });
+      _ut.test('test_constConstructorWithNonFinalField_final', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_final);
+      });
+      _ut.test('test_constConstructorWithNonFinalField_syntheticField', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_syntheticField);
+      });
+      _ut.test('test_defaultValueInFunctionTypeAlias', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_defaultValueInFunctionTypeAlias);
+      });
+      _ut.test('test_duplicateDefinition_getter', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_duplicateDefinition_getter);
+      });
+      _ut.test('test_fieldInitializedInInitializerAndDeclaration_fieldNotFinal', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_fieldInitializedInInitializerAndDeclaration_fieldNotFinal);
+      });
+      _ut.test('test_fieldInitializedInInitializerAndDeclaration_finalFieldNotSet', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_fieldInitializedInInitializerAndDeclaration_finalFieldNotSet);
+      });
+      _ut.test('test_fieldInitializerOutsideConstructor', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_fieldInitializerOutsideConstructor);
+      });
+      _ut.test('test_fieldInitializerOutsideConstructor_defaultParameters', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_fieldInitializerOutsideConstructor_defaultParameters);
+      });
+      _ut.test('test_invalidAssignment', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invalidAssignment);
+      });
+      _ut.test('test_invalidAssignment_toDynamic', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invalidAssignment_toDynamic);
+      });
+      _ut.test('test_invocationOfNonFunction_dynamic', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invocationOfNonFunction_dynamic);
+      });
+      _ut.test('test_invocationOfNonFunction_getter', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invocationOfNonFunction_getter);
+      });
+      _ut.test('test_invocationOfNonFunction_localVariable', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_invocationOfNonFunction_localVariable);
+      });
+      _ut.test('test_newWithAbstractClass_factory', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_newWithAbstractClass_factory);
+      });
+      _ut.test('test_nonBoolExpression_assert_bool', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_nonBoolExpression_assert_bool);
+      });
+      _ut.test('test_nonBoolExpression_assert_functionType', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_nonBoolExpression_assert_functionType);
+      });
+      _ut.test('test_rethrowOutsideCatch', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_rethrowOutsideCatch);
+      });
+      _ut.test('test_returnOfInvalidType_dynamic', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_returnOfInvalidType_dynamic);
+      });
+      _ut.test('test_returnOfInvalidType_subtype', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_returnOfInvalidType_subtype);
+      });
+      _ut.test('test_returnOfInvalidType_supertype', () {
+        final __test = new NonErrorResolverTest();
+        runJUnitTest(__test, __test.test_returnOfInvalidType_supertype);
+      });
+      _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);
+      });
+    });
+  }
+}
 class LibraryTest extends EngineTestCase {
   /**
    * The error listener to which all errors will be reported.
    */
   GatheringErrorListener _errorListener;
   /**
    * The source factory used to create libraries.
    */
   SourceFactory _sourceFactory;
   /**
@@ skipping 712 matching lines @@
   }
   /**
    * Add a source file to the content provider. The file path should be absolute.
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
    * @return the source object representing the added file
    */
   Source addSource(String filePath, String contents) {
     Source source = new FileBasedSource.con1(_sourceFactory, FileUtilities2.createFile(filePath));
     _sourceFactory.setContents(source, contents);
+    ChangeSet changeSet = new ChangeSet();
+    changeSet.added(source);
+    _analysisContext.applyChanges(changeSet);
     return source;
   }
   /**
    * Assert that no errors have been gathered.
    * @throws AssertionFailedError if any errors have been gathered
    */
   void assertNoErrors() {
     _errorListener.assertNoErrors();
   }
   /**
    * Create a library element that represents a library named {@code "test"} containing a single
    * empty compilation unit.
    * @return the library element that was created
    */
   LibraryElementImpl createTestLibrary() => createTestLibrary2(new AnalysisContextImpl(), "test", []);
   /**
    * Create a library element that represents a library with the given name containing a single
    * empty compilation unit.
    * @param libraryName the name of the library to be created
    * @return the library element that was created
    */
   LibraryElementImpl createTestLibrary2(AnalysisContext context, String libraryName, List<String> typeNames) {
     int count = typeNames.length;
     List<CompilationUnitElementImpl> sourcedCompilationUnits = new List<CompilationUnitElementImpl>(count);
     for (int i = 0; i < count; i++) {
       String typeName = typeNames[i];
       ClassElementImpl type = new ClassElementImpl(ASTFactory.identifier2(typeName));
       String fileName = "${typeName}.dart";
       CompilationUnitElementImpl compilationUnit = new CompilationUnitElementImpl(fileName);
-      compilationUnit.source = new FileBasedSource.con1(_sourceFactory, FileUtilities2.createFile(fileName));
+      compilationUnit.source = createSource2(fileName);
       compilationUnit.types = <ClassElement> [type];
       sourcedCompilationUnits[i] = compilationUnit;
     }
     String fileName = "${libraryName}.dart";
     CompilationUnitElementImpl compilationUnit = new CompilationUnitElementImpl(fileName);
-    compilationUnit.source = new FileBasedSource.con1(_sourceFactory, FileUtilities2.createFile(fileName));
+    compilationUnit.source = createSource2(fileName);
     LibraryElementImpl library = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2([libraryName]));
     library.definingCompilationUnit = compilationUnit;
     library.parts = sourcedCompilationUnits;
     return library;
   }
   AnalysisContext get analysisContext => _analysisContext;
   GatheringErrorListener get errorListener => _errorListener;
   SourceFactory get sourceFactory => _sourceFactory;
   /**
    * Given a library and all of its parts, resolve the contents of the library and the contents of
@@ skipping 12 matching lines @@
    * Verify that all of the identifiers in the compilation units associated with the given sources
    * have been resolved.
    * @param resolvedElementMap a table mapping the AST nodes that have been resolved to the element
    * to which they were resolved
    * @param sources the sources identifying the compilation units to be verified
    * @throws Exception if the contents of the compilation unit cannot be accessed
    */
   void verify(List<Source> sources) {
     ResolutionVerifier verifier = new ResolutionVerifier();
     for (Source source in sources) {
-      _analysisContext.parse3(source, _errorListener).accept(verifier);
+      _analysisContext.parseCompilationUnit(source).accept(verifier);
     }
     verifier.assertResolved();
   }
+  /**
+   * Create a source object representing a file with the given name and give it an empty content.
+   * @param fileName the name of the file for which a source is to be created
+   * @return the source that was created
+   */
+  FileBasedSource createSource2(String fileName) {
+    FileBasedSource source = new FileBasedSource.con1(_sourceFactory, FileUtilities2.createFile(fileName));
+    _sourceFactory.setContents(source, "");
+    return source;
+  }
   static dartSuite() {
     _ut.group('ResolverTestCase', () {
     });
   }
 }
 class TypeProviderImplTest extends EngineTestCase {
   void test_creation() {
     InterfaceType objectType = classElement("Object", null, []).type;
     InterfaceType boolType = classElement("bool", objectType, []).type;
     InterfaceType numType = classElement("num", objectType, []).type;
@@ skipping 149 matching lines @@
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void fail_fieldInitializedByMultipleInitializers() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x;", "  A() : x = 0, x = 1 {}", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
     verify([source]);
   }
-  void fail_fieldInitializedInInitializerAndDeclaration() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  final int x = 0;", "  A() : x = 1 {}", "}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
-    verify([source]);
-  }
-  void fail_fieldInitializeInParameterAndInitializer() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x;", "  A(this.x) : x = 1 {}", "}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
-    verify([source]);
-  }
-  void fail_fieldInitializerOutsideConstructor() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x;", "  m(this.x) {}", "}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]);
-    verify([source]);
-  }
   void fail_finalInitializedInDeclarationAndConstructor_assignment() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  final x = 0;", "  A() { x = 1; }", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR]);
     verify([source]);
   }
   void fail_finalInitializedInDeclarationAndConstructor_initializingFormal() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  final x = 0;", "  A(this.x) {}", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR]);
@@ skipping 392 matching lines @@
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
     verify([source]);
   }
   void fail_superInitializerInObject() {
     Source source = addSource("/test.dart", EngineTestCase.createSource([]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.SUPER_INITIALIZER_IN_OBJECT]);
     verify([source]);
   }
-  void fail_throwWithoutValueOutsideOn() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  throw;", "}"]));
-    resolve(source, []);
-    assertErrors([CompileTimeErrorCode.THROW_WITHOUT_VALUE_OUTSIDE_ON]);
-    verify([source]);
-  }
   void fail_typeArgumentsForNonGenericClass_creation_const() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {}", "f(p) {", "  return const A<int>();", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.TYPE_ARGUMENTS_FOR_NON_GENERIC_CLASS]);
     verify([source]);
   }
   void fail_typeArgumentsForNonGenericClass_creation_new() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {}", "f(p) {", "  return new A<int>();", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.TYPE_ARGUMENTS_FOR_NON_GENERIC_CLASS]);
@@ skipping 246 matching lines @@
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
   void test_extendsOrImplementsDisallowedClass_implements_String() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A implements String {}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
     verify([source]);
   }
+  void test_fieldInitializedInInitializerAndDeclaration_const() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  const int x = 0;", "  A() : x = 1 {}", "}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
+    verify([source]);
+  }
+  void test_fieldInitializedInInitializerAndDeclaration_final() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  final int x = 0;", "  A() : x = 1 {}", "}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION]);
+    verify([source]);
+  }
+  void test_fieldInitializeInParameterAndInitializer() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x;", "  A(this.x) : x = 1 {}", "}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
+    verify([source]);
+  }
+  void test_fieldInitializerOutsideConstructor() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x;", "  m(this.x) {}", "}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]);
+    verify([source]);
+  }
+  void test_fieldInitializerOutsideConstructor_defaultParameters() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  int x;", "  m([this.x]) {}", "}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]);
+    verify([source]);
+  }
   void test_implementsNonClass() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["int A;", "class B implements A {}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
     verify([source]);
   }
   void test_labelInOuterScope() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class int {}", "", "class A {", "  void m(int i) {", "    l: while (i > 0) {", "      void f() {", "        break l;", "      };", "    }", "  }", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE, ResolverErrorCode.CANNOT_BE_RESOLVED]);
@@ skipping 25 matching lines @@
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT]);
     verify([source]);
   }
   void test_nonConstMapValue() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f(a) {", "  return const {'a' : a};", "}"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE]);
     verify([source]);
   }
+  void test_rethrowOutsideCatch() {
+    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  rethrow;", "}"]));
+    resolve(source, []);
+    assertErrors([CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH]);
+    verify([source]);
+  }
   void test_uriWithInterpolation_constant() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["import 'stuff_\$platform.dart';"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.URI_WITH_INTERPOLATION]);
   }
   void test_uriWithInterpolation_nonConstant() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["library lib;", "part '\${'a'}.dart';"]));
     resolve(source, []);
     assertErrors([CompileTimeErrorCode.URI_WITH_INTERPOLATION]);
   }
@@ skipping 112 matching lines @@
         runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_implements_double);
       });
       _ut.test('test_extendsOrImplementsDisallowedClass_implements_int', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_implements_int);
       });
       _ut.test('test_extendsOrImplementsDisallowedClass_implements_num', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_extendsOrImplementsDisallowedClass_implements_num);
       });
+      _ut.test('test_fieldInitializeInParameterAndInitializer', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_fieldInitializeInParameterAndInitializer);
+      });
+      _ut.test('test_fieldInitializedInInitializerAndDeclaration_const', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_fieldInitializedInInitializerAndDeclaration_const);
+      });
+      _ut.test('test_fieldInitializedInInitializerAndDeclaration_final', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_fieldInitializedInInitializerAndDeclaration_final);
+      });
+      _ut.test('test_fieldInitializerOutsideConstructor', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_fieldInitializerOutsideConstructor);
+      });
+      _ut.test('test_fieldInitializerOutsideConstructor_defaultParameters', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_fieldInitializerOutsideConstructor_defaultParameters);
+      });
       _ut.test('test_implementsNonClass', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_implementsNonClass);
       });
       _ut.test('test_labelInOuterScope', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_labelInOuterScope);
       });
       _ut.test('test_labelUndefined_break', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 12 matching lines @@
         runJUnitTest(__test, __test.test_nonConstCaseExpression);
       });
       _ut.test('test_nonConstListElement', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonConstListElement);
       });
       _ut.test('test_nonConstMapValue', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_nonConstMapValue);
       });
+      _ut.test('test_rethrowOutsideCatch', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_rethrowOutsideCatch);
+      });
       _ut.test('test_uriWithInterpolation_constant', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_uriWithInterpolation_constant);
       });
       _ut.test('test_uriWithInterpolation_nonConstant', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_uriWithInterpolation_nonConstant);
       });
     });
   }
@@ skipping 80 matching lines @@
     return null;
   }
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (node.staticType == null && identical(node.prefix.staticType, DynamicTypeImpl.instance)) {
       return null;
     }
     return super.visitPrefixedIdentifier(node);
   }
   Object visitSimpleIdentifier(SimpleIdentifier node) {
-    ASTNode parent19 = node.parent;
-    if (parent19 is MethodInvocation && identical(node, ((parent19 as MethodInvocation)).methodName)) {
+    ASTNode parent21 = node.parent;
+    if (parent21 is MethodInvocation && identical(node, ((parent21 as MethodInvocation)).methodName)) {
       return null;
-    } else if (parent19 is RedirectingConstructorInvocation && identical(node, ((parent19 as RedirectingConstructorInvocation)).constructorName)) {
+    } else if (parent21 is RedirectingConstructorInvocation && identical(node, ((parent21 as RedirectingConstructorInvocation)).constructorName)) {
       return null;
-    } else if (parent19 is SuperConstructorInvocation && identical(node, ((parent19 as SuperConstructorInvocation)).constructorName)) {
+    } else if (parent21 is SuperConstructorInvocation && identical(node, ((parent21 as SuperConstructorInvocation)).constructorName)) {
       return null;
-    } else if (parent19 is ConstructorName && identical(node, ((parent19 as ConstructorName)).name)) {
+    } else if (parent21 is ConstructorName && identical(node, ((parent21 as ConstructorName)).name)) {
       return null;
-    } else if (parent19 is Label && identical(node, ((parent19 as Label)).label)) {
+    } else if (parent21 is Label && identical(node, ((parent21 as Label)).label)) {
       return null;
-    } else if (parent19 is ImportDirective && identical(node, ((parent19 as ImportDirective)).prefix)) {
+    } else if (parent21 is ImportDirective && identical(node, ((parent21 as ImportDirective)).prefix)) {
       return null;
     } else if (node.element is PrefixElement) {
       return null;
     }
     return super.visitSimpleIdentifier(node);
   }
   Object visitTypeName(TypeName node) {
     if (node.type == null) {
       _unresolvedTypes.add(node);
     } else {
@@ skipping 351 matching lines @@
   void test_visitSimpleIdentifier_lexicalScope_field_setter() {
     InterfaceType intType5 = _typeProvider.intType;
     ClassElementImpl classA = ElementFactory.classElement2("A", []);
     String fieldName = "a";
     FieldElement field = ElementFactory.fieldElement(fieldName, false, false, false, intType5);
     classA.fields = <FieldElement> [field];
     classA.accessors = <PropertyAccessorElement> [field.getter, field.setter];
     SimpleIdentifier node = ASTFactory.identifier2(fieldName);
     ASTFactory.assignmentExpression(node, TokenType.EQ, ASTFactory.integer(0));
     resolveInClass(node, classA);
-    Element element50 = node.element;
-    EngineTestCase.assertInstanceOf(PropertyAccessorElement, element50);
-    JUnitTestCase.assertTrue(((element50 as PropertyAccessorElement)).isSetter());
+    Element element56 = node.element;
+    EngineTestCase.assertInstanceOf(PropertyAccessorElement, element56);
+    JUnitTestCase.assertTrue(((element56 as PropertyAccessorElement)).isSetter());
     _listener.assertNoErrors();
   }
   void test_visitSuperConstructorInvocation() {
     ClassElementImpl superclass = ElementFactory.classElement2("A", []);
     ConstructorElementImpl superConstructor = ElementFactory.constructorElement(null);
     superclass.constructors = <ConstructorElement> [superConstructor];
     ClassElementImpl subclass = ElementFactory.classElement("B", superclass.type, []);
     ConstructorElementImpl subConstructor = ElementFactory.constructorElement(null);
     subclass.constructors = <ConstructorElement> [subConstructor];
     SuperConstructorInvocation invocation = ASTFactory.superConstructorInvocation([]);
@@ skipping 18 matching lines @@
     _listener.assertNoErrors();
   }
   /**
    * Create the resolver used by the tests.
    * @return the resolver that was created
    */
   ElementResolver createResolver() {
     AnalysisContextImpl context = new AnalysisContextImpl();
     SourceFactory sourceFactory = new SourceFactory.con2([new DartUriResolver(DartSdk.defaultSdk)]);
     context.sourceFactory = sourceFactory;
+    FileBasedSource source = new FileBasedSource.con1(sourceFactory, FileUtilities2.createFile("/test.dart"));
     CompilationUnitElementImpl definingCompilationUnit = new CompilationUnitElementImpl("test.dart");
-    definingCompilationUnit.source = new FileBasedSource.con1(sourceFactory, FileUtilities2.createFile("/test.dart"));
+    definingCompilationUnit.source = source;
     _definingLibrary = ElementFactory.library(context, "test");
     _definingLibrary.definingCompilationUnit = definingCompilationUnit;
-    Library library = new Library(context, _listener, null);
+    Library library = new Library(context, _listener, source);
     library.libraryElement = _definingLibrary;
-    _visitor = new ResolverVisitor(library, null, _typeProvider);
+    _visitor = new ResolverVisitor(library, source, _typeProvider);
     try {
       return _visitor.elementResolver_J2DAccessor as ElementResolver;
-    } on JavaException catch (exception) {
+    } catch (exception) {
       throw new IllegalArgumentException("Could not create resolver", exception);
     }
   }
   /**
    * Return the element associated with the label of the given statement after the resolver has
    * resolved the statement.
    * @param statement the statement to be resolved
    * @param labelElement the label element to be defined in the statement's label scope
    * @return the element to which the statement's label was resolved
    */
@@ skipping 48 matching lines @@
       Scope outerScope = _visitor.nameScope_J2DAccessor as Scope;
       try {
         _visitor.enclosingClass_J2DAccessor = enclosingClass;
         EnclosedScope innerScope = new ClassScope(outerScope, enclosingClass);
         _visitor.nameScope_J2DAccessor = innerScope;
         node.accept(_resolver);
       } finally {
         _visitor.enclosingClass_J2DAccessor = null;
         _visitor.nameScope_J2DAccessor = outerScope;
       }
-    } on JavaException catch (exception) {
+    } catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
   /**
    * Return the element associated with the given identifier after the resolver has resolved the
    * identifier.
    * @param node the expression to be resolved
    * @param definedElements the elements that are to be defined in the scope in which the element is
    * being resolved
    * @return the element to which the expression was resolved
    */
   void resolveNode(ASTNode node, List<Element> definedElements) {
     try {
       Scope outerScope = _visitor.nameScope_J2DAccessor as Scope;
       try {
         EnclosedScope innerScope = new EnclosedScope(outerScope);
         for (Element element in definedElements) {
           innerScope.define(element);
         }
         _visitor.nameScope_J2DAccessor = innerScope;
         node.accept(_resolver);
       } finally {
         _visitor.nameScope_J2DAccessor = outerScope;
       }
-    } on JavaException catch (exception) {
+    } catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
   /**
    * Return the element associated with the label of the given statement after the resolver has
    * resolved the statement.
    * @param statement the statement to be resolved
    * @param labelElement the label element to be defined in the statement's label scope
    * @return the element to which the statement's label was resolved
    */
   void resolveStatement(Statement statement, LabelElementImpl labelElement) {
     try {
       LabelScope outerScope = _visitor.labelScope_J2DAccessor as LabelScope;
       try {
         LabelScope innerScope;
         if (labelElement == null) {
           innerScope = new LabelScope.con1(outerScope, false, false);
         } else {
           innerScope = new LabelScope.con2(outerScope, labelElement.name, labelElement);
         }
         _visitor.labelScope_J2DAccessor = innerScope;
         statement.accept(_resolver);
       } finally {
         _visitor.labelScope_J2DAccessor = outerScope;
       }
-    } on JavaException catch (exception) {
+    } catch (exception) {
       throw new IllegalArgumentException("Could not resolve node", exception);
     }
   }
   static dartSuite() {
     _ut.group('ElementResolverTest', () {
       _ut.test('test_visitAssignmentExpression_compound', () {
         final __test = new ElementResolverTest();
         runJUnitTest(__test, __test.test_visitAssignmentExpression_compound);
       });
       _ut.test('test_visitAssignmentExpression_simple', () {
@@ skipping 462 matching lines @@
         runJUnitTest(__test, __test.test_breakLabelOnSwitchMember);
       });
       _ut.test('test_continueLabelOnSwitch', () {
         final __test = new ErrorResolverTest();
         runJUnitTest(__test, __test.test_continueLabelOnSwitch);
       });
     });
   }
 }
 /**
- * The class {@code AnalysisContextFactory} defines utility methods used to create analysis contexts
- * for testing purposes.
- */
-class AnalysisContextFactory {
-  /**
-   * Create an analysis context that has a fake core library already resolved.
-   * @return the analysis context that was created
-   */
-  static AnalysisContextImpl contextWithCore() {
-    AnalysisContextImpl context = new AnalysisContextImpl();
-    SourceFactory sourceFactory = new SourceFactory.con2([new DartUriResolver(DartSdk.defaultSdk), new FileUriResolver()]);
-    context.sourceFactory = sourceFactory;
-    TestTypeProvider provider = new TestTypeProvider();
-    CompilationUnitElementImpl unit = new CompilationUnitElementImpl("core.dart");
-    unit.types = <ClassElement> [provider.boolType.element, provider.doubleType.element, provider.functionType.element, provider.intType.element, provider.listType.element, provider.mapType.element, provider.numType.element, provider.objectType.element, provider.stackTraceType.element, provider.stringType.element, provider.typeType.element];
-    LibraryElementImpl library = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2(["dart", "core"]));
-    library.definingCompilationUnit = unit;
-    Map<Source, LibraryElement> elementMap = new Map<Source, LibraryElement>();
-    Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
-    elementMap[coreSource] = library;
-    context.recordLibraryElements(elementMap);
-    unit.source = coreSource;
-    return context;
-  }
-  /**
-   * Prevent the creation of instances of this class.
-   */
-  AnalysisContextFactory() {
-  }
-}
-/**
  * Instances of the class {@code TestTypeProvider} implement a type provider that can be used by
  * tests without creating the element model for the core library.
  */
 class TestTypeProvider implements TypeProvider {
   /**
    * The type representing the built-in type 'bool'.
    */
   InterfaceType _boolType;
   /**
    * The type representing the type 'bottom'.
@@ skipping 157 matching lines @@
     doubleElement.fields = fields;
     int fieldCount = fields.length;
     List<PropertyAccessorElement> accessors = new List<PropertyAccessorElement>(fieldCount);
     for (int i = 0; i < fieldCount; i++) {
       accessors[i] = fields[i].getter;
     }
     doubleElement.accessors = accessors;
     doubleElement.methods = <MethodElement> [ElementFactory.methodElement("remainder", _doubleType, [_numType]), ElementFactory.methodElement("+", _doubleType, [_numType]), ElementFactory.methodElement("-", _doubleType, [_numType]), ElementFactory.methodElement("*", _doubleType, [_numType]), ElementFactory.methodElement("%", _doubleType, [_numType]), ElementFactory.methodElement("/", _doubleType, [_numType]), ElementFactory.methodElement("~/", _doubleType, [_numType]), ElementFactory.methodElement("-", _doubleType, []), ElementFactory.methodElement("abs", _doubleType, []), ElementFactory.methodElement("round", _doubleType, []), ElementFactory.methodElement("floor", _doubleType, []), ElementFactory.methodElement("ceil", _doubleType, []), ElementFactory.methodElement("truncate", _doubleType, []), ElementFactory.methodElement("toString", _stringType, [])];
   }
 }
+/**
+ * The class {@code AnalysisContextFactory} defines utility methods used to create analysis contexts
+ * for testing purposes.
+ */
+class AnalysisContextFactory {
+  /**
+   * Create an analysis context that has a fake core library already resolved.
+   * @return the analysis context that was created
+   */
+  static AnalysisContextImpl contextWithCore() {
+    AnalysisContextImpl context = new AnalysisContextImpl();
+    SourceFactory sourceFactory = new SourceFactory.con2([new DartUriResolver(DartSdk.defaultSdk), new FileUriResolver()]);
+    context.sourceFactory = sourceFactory;
+    TestTypeProvider provider = new TestTypeProvider();
+    CompilationUnitElementImpl coreUnit = new CompilationUnitElementImpl("core.dart");
+    Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
+    coreUnit.source = coreSource;
+    coreUnit.types = <ClassElement> [provider.boolType.element, provider.doubleType.element, provider.functionType.element, provider.intType.element, provider.listType.element, provider.mapType.element, provider.numType.element, provider.objectType.element, provider.stackTraceType.element, provider.stringType.element, provider.typeType.element];
+    LibraryElementImpl coreLibrary = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2(["dart", "core"]));
+    coreLibrary.definingCompilationUnit = coreUnit;
+    CompilationUnitElementImpl htmlUnit = new CompilationUnitElementImpl("html_dartium.dart");
+    Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
+    htmlUnit.source = htmlSource;
+    LibraryElementImpl htmlLibrary = new LibraryElementImpl(context, ASTFactory.libraryIdentifier2(["dart", "dom", "html"]));
+    htmlLibrary.definingCompilationUnit = htmlUnit;
+    Map<Source, LibraryElement> elementMap = new Map<Source, LibraryElement>();
+    elementMap[coreSource] = coreLibrary;
+    elementMap[htmlSource] = htmlLibrary;
+    context.setContents(coreSource, "");
+    context.setContents(htmlSource, "");
+    context.recordLibraryElements(elementMap);
+    return context;
+  }
+  /**
+   * Prevent the creation of instances of this class.
+   */
+  AnalysisContextFactory() {
+  }
+}
 class LibraryImportScopeTest extends ResolverTestCase {
   void test_conflictingImports() {
     AnalysisContext context = new AnalysisContextImpl();
     String typeNameA = "A";
     String typeNameB = "B";
     String typeNameC = "C";
     ClassElement typeA = new ClassElementImpl(ASTFactory.identifier2(typeNameA));
     ClassElement typeB1 = new ClassElementImpl(ASTFactory.identifier2(typeNameB));
     ClassElement typeB2 = new ClassElementImpl(ASTFactory.identifier2(typeNameB));
     ClassElement typeC = new ClassElementImpl(ASTFactory.identifier2(typeNameC));
@@ skipping 93 matching lines @@
   List<ASTNode> _unresolvedNodes = new List<ASTNode>();
   /**
    * A list containing all of the AST nodes that were resolved to an element of the wrong type.
    */
   List<ASTNode> _wrongTypedNodes = new List<ASTNode>();
   /**
    * Initialize a newly created verifier to verify that all of the nodes in the visited AST
    * structures that are expected to have been resolved have an element associated with them.
    */
   ResolutionVerifier() {
-    _jtd_constructor_319_impl();
+    _jtd_constructor_323_impl();
   }
-  _jtd_constructor_319_impl() {
-    _jtd_constructor_320_impl(null);
+  _jtd_constructor_323_impl() {
+    _jtd_constructor_324_impl(null);
   }
   /**
    * Initialize a newly created verifier to verify that all of the identifiers in the visited AST
    * structures that are expected to have been resolved have an element associated with them. Nodes
    * in the set of known exceptions are not expected to have been resolved, even if they normally
    * would have been expected to have been resolved.
    * @param knownExceptions a set containing nodes that are known to not be resolvable and should
    * therefore not cause the test to fail
    */
   ResolutionVerifier.con1(Set<ASTNode> knownExceptions2) {
-    _jtd_constructor_320_impl(knownExceptions2);
+    _jtd_constructor_324_impl(knownExceptions2);
   }
-  _jtd_constructor_320_impl(Set<ASTNode> knownExceptions2) {
+  _jtd_constructor_324_impl(Set<ASTNode> knownExceptions2) {
     this._knownExceptions = knownExceptions2;
   }
   /**
    * Assert that all of the visited identifiers were resolved.
    */
   void assertResolved() {
     if (!_unresolvedNodes.isEmpty || !_wrongTypedNodes.isEmpty) {
       PrintStringWriter writer = new PrintStringWriter();
       if (!_unresolvedNodes.isEmpty) {
         writer.print("Failed to resolve ");
@@ skipping 675 matching lines @@
   /**
    * Return the type associated with the given expression after the static type analyzer has
    * computed a type for it.
    * @param node the expression with which the type is associated
    * @param thisType the type of 'this'
    * @return the type associated with the expression
    */
   Type2 analyze2(Expression node, InterfaceType thisType) {
     try {
       _analyzer.thisType_J2DAccessor = thisType;
-    } on JavaException catch (exception) {
+    } catch (exception) {
       throw new IllegalArgumentException("Could not set type of 'this'", exception);
     }
     node.accept(_analyzer);
     return node.staticType;
   }
   /**
    * Return the type associated with the given parameter after the static type analyzer has computed
    * a type for it.
    * @param node the parameter with which the type is associated
    * @return the type associated with the parameter
@@ skipping 60 matching lines @@
       EngineTestCase.assertInstanceOf(InterfaceTypeImpl, actualType);
       assertType((expectedType as InterfaceTypeImpl), (actualType as InterfaceTypeImpl));
     }
   }
   /**
    * Create the analyzer used by the tests.
    * @return the analyzer to be used by the tests
    */
   StaticTypeAnalyzer createAnalyzer() {
     AnalysisContextImpl context = new AnalysisContextImpl();
-    context.sourceFactory = new SourceFactory.con2([new DartUriResolver(DartSdk.defaultSdk)]);
+    SourceFactory sourceFactory = new SourceFactory.con2([new DartUriResolver(DartSdk.defaultSdk)]);
+    context.sourceFactory = sourceFactory;
+    FileBasedSource source = new FileBasedSource.con1(sourceFactory, FileUtilities2.createFile("/lib.dart"));
     CompilationUnitElementImpl definingCompilationUnit = new CompilationUnitElementImpl("lib.dart");
+    definingCompilationUnit.source = source;
     LibraryElementImpl definingLibrary = new LibraryElementImpl(context, null);
     definingLibrary.definingCompilationUnit = definingCompilationUnit;
-    Library library = new Library(context, _listener, null);
+    Library library = new Library(context, _listener, source);
     library.libraryElement = definingLibrary;
-    ResolverVisitor visitor = new ResolverVisitor(library, null, _typeProvider);
+    ResolverVisitor visitor = new ResolverVisitor(library, source, _typeProvider);
     try {
       return visitor.typeAnalyzer_J2DAccessor as StaticTypeAnalyzer;
-    } on JavaException catch (exception) {
+    } catch (exception) {
       throw new IllegalArgumentException("Could not create analyzer", exception);
     }
   }
   /**
    * Return an integer literal that has been resolved to the correct type.
    * @param value the value of the literal
    * @return an integer literal that has been resolved to the correct type
    */
   DoubleLiteral resolvedDouble(double value) {
     DoubleLiteral literal = ASTFactory.doubleLiteral(value);
@@ skipping 55 matching lines @@
     identifier.staticType = type37;
     return identifier;
   }
   /**
    * 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 type38) {
     SimpleIdentifier identifier17 = parameter.identifier;
-    Element element51 = identifier17.element;
-    if (element51 is! ParameterElement) {
-      element51 = new ParameterElementImpl(identifier17);
-      identifier17.element = element51;
+    Element element57 = identifier17.element;
+    if (element57 is! ParameterElement) {
+      element57 = new ParameterElementImpl(identifier17);
+      identifier17.element = element57;
     }
-    ((element51 as ParameterElementImpl)).type = type38;
+    ((element57 as ParameterElementImpl)).type = type38;
   }
   static dartSuite() {
     _ut.group('StaticTypeAnalyzerTest', () {
       _ut.test('test_visitAdjacentStrings', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitAdjacentStrings);
       });
       _ut.test('test_visitArgumentDefinitionTest', () {
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitArgumentDefinitionTest);
@@ skipping 238 matching lines @@
         final __test = new StaticTypeAnalyzerTest();
         runJUnitTest(__test, __test.test_visitThrowExpression_withoutValue);
       });
     });
   }
 }
 class EnclosedScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     LibraryElement definingLibrary2 = createTestLibrary();
     GatheringErrorListener errorListener2 = new GatheringErrorListener();
-    Scope rootScope = new Scope_10(definingLibrary2, errorListener2);
+    Scope rootScope = new Scope_12(definingLibrary2, errorListener2);
     EnclosedScope scope = new EnclosedScope(rootScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier2("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier2("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_11(definingLibrary3, errorListener3);
+    Scope rootScope = new Scope_13(definingLibrary3, errorListener3);
     EnclosedScope outerScope = new EnclosedScope(rootScope);
     EnclosedScope innerScope = new EnclosedScope(outerScope);
     VariableElement element1 = ElementFactory.localVariableElement(ASTFactory.identifier2("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(ASTFactory.identifier2("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_10 extends Scope {
+class Scope_12 extends Scope {
   LibraryElement definingLibrary2;
   GatheringErrorListener errorListener2;
-  Scope_10(this.definingLibrary2, this.errorListener2) : super();
+  Scope_12(this.definingLibrary2, this.errorListener2) : super();
   LibraryElement get definingLibrary => definingLibrary2;
   AnalysisErrorListener get errorListener => errorListener2;
   Element lookup3(String name, LibraryElement referencingLibrary) => null;
 }
-class Scope_11 extends Scope {
+class Scope_13 extends Scope {
   LibraryElement definingLibrary3;
   GatheringErrorListener errorListener3;
-  Scope_11(this.definingLibrary3, this.errorListener3) : super();
+  Scope_13(this.definingLibrary3, this.errorListener3) : super();
   LibraryElement get definingLibrary => definingLibrary3;
   AnalysisErrorListener get errorListener => errorListener3;
   Element lookup3(String name, LibraryElement referencingLibrary) => null;
 }
 class LibraryElementBuilderTest extends EngineTestCase {
   /**
    * The source factory used to create {@link Source sources}.
    */
   SourceFactory _sourceFactory;
   void setUp() {
@@ skipping 228 matching lines @@
   LibraryElement get definingLibrary => _definingLibrary;
   AnalysisErrorListener get errorListener => _errorListener;
   Element lookup3(String name, LibraryElement referencingLibrary) => localLookup(name, referencingLibrary);
 }
 class SimpleResolverTest extends ResolverTestCase {
   void fail_staticInvocation() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  static int get g => (a,b) => 0;", "}", "class B {", "  f() {", "    A.g(1,0);", "  }", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
-  }
-  void test_argumentDefinitionTestNonParameter_formalParameter() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f(var v) {", "  return ?v;", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_argumentDefinitionTestNonParameter_namedParameter() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f({var v : 0}) {", "  return ?v;", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_argumentDefinitionTestNonParameter_optionalParameter() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f([var v]) {", "  return ?v;", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_breakWithoutLabelInSwitch() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  void m(int i) {", "    switch (i) {", "      case 0:", "        break;", "    }", "  }", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_builtInIdentifierAsType_dynamic() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  dynamic x;", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_caseExpressionTypeImplementsEquals_int() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f(int i) {", "  switch(i) {", "    case(1) : return 1;", "    default: return 0;", "  }", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_caseExpressionTypeImplementsEquals_Object() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class IntWrapper {", "  final int value;", "  const IntWrapper(this.value);", "}", "", "f(IntWrapper intWrapper) {", "  switch(intWrapper) {", "    case(const IntWrapper(1)) : return 1;", "    default: return 0;", "  }", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_caseExpressionTypeImplementsEquals_String() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f(String s) {", "  switch(s) {", "    case('1') : return 1;", "    default: return 0;", "  }", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
   }
   void test_class_extends_implements() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends B implements C {}", "class B {}", "class C {}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
-  void test_constConstructorWithNonFinalField_const() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  const int x;", "  const A() {}", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_constConstructorWithNonFinalField_final() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  final int x;", "  const A() {}", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_constConstructorWithNonFinalField_syntheticField() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  const A();", "  set x(value) {}", "  get x {return 0;}", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_defaultValueInFunctionTypeAlias() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["typedef F([x]);"]));
-    resolve(source, []);
-    assertErrors([]);
-    verify([source]);
-  }
-  void test_duplicateDefinition_getter() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["bool get a => true;"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
   void test_empty() {
     Source source = addSource("/test.dart", "");
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_forEachLoops_nonConflicting() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  List list = [1,2,3];", "  for (int x in list) {}", "  for (int x in list) {}", "}"]));
     resolve(source, []);
     assertNoErrors();
@@ skipping 22 matching lines @@
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_indexExpression_typeParameters_invalidAssignmentWarning() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  List<List<int>> b;", "  b[0][0] = 'hi';", "}"]));
     resolve(source, []);
     assertErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
-  void test_invalidAssignment() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  var x;", "  var y;", "  x = y;", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_invalidAssignment_toDynamic() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  var g;", "  g = () => 0;", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_invocationOfNonFunction_dynamic() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  var f;", "}", "class B extends A {", "  g() {", "    f();", "  }", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_invocationOfNonFunction_getter() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  var g;", "}", "f() {", "  A a;", "  a.g();", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_invocationOfNonFunction_localVariable() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  var g;", "  g();", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
   void test_invoke_dynamicThroughGetter() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  List get X => [() => 0];", "  m(A a) {", "    X.last();", "  }", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_isValidMixin_badSuperclass() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A extends B {}", "class B {}"]));
     LibraryElement library = resolve(source, []);
     JUnitTestCase.assertNotNull(library);
@@ skipping 46 matching lines @@
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
   void test_methodCascades_withSetter() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  String name;", "  void m1() {}", "  void m2() {}", "  void m() {", "    A a = new A();", "    a..m1()", "     ..name = 'name'", "     ..m2();", "  }", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
-  void test_newWithAbstractClass_factory() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["abstract class A {", "  factory A() { return new B(); }", "}", "class B implements A {", "  B() {}", "}", "A f() {", "  return new A();", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_nonBoolExpression_assert_bool() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["f() {", "  assert(true);", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_nonBoolExpression_assert_functionType() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["bool makeAssertion() => true;", "f() {", "  assert(makeAssertion);", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
   void test_resolveAgainstNull() {
     Source source = addSource("/test.dart", EngineTestCase.createSource(["f(var p) {", "  return null == p;", "}"]));
     resolve(source, []);
     assertNoErrors();
     verify([source]);
   }
-  void test_returnOfInvalidType_dynamic() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {", "  static void testLogicalOp() {", "    testOr(a, b, onTypeError) {", "      try {", "        return a || b;", "      } on TypeError catch (t) {", "        return onTypeError;", "      }", "    }", "  }", "}"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_returnOfInvalidType_subtype() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {}", "class B extends A {}", "A f(B b) { return b; }"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_returnOfInvalidType_supertype() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {}", "class B extends A {}", "B f(A a) { return a; }"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_typeArgumentNotMatchingBounds_const() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {}", "class B extends A {}", "class G<E extends A> {", "  const G() {}", "}", "f() { return const G<B>(); }"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
-  void test_typeArgumentNotMatchingBounds_new() {
-    Source source = addSource("/test.dart", EngineTestCase.createSource(["class A {}", "class B extends A {}", "class G<E extends A> {}", "f() { return new G<B>(); }"]));
-    resolve(source, []);
-    assertNoErrors();
-    verify([source]);
-  }
   static dartSuite() {
     _ut.group('SimpleResolverTest', () {
-      _ut.test('test_argumentDefinitionTestNonParameter_formalParameter', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter_formalParameter);
-      });
-      _ut.test('test_argumentDefinitionTestNonParameter_namedParameter', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter_namedParameter);
-      });
-      _ut.test('test_argumentDefinitionTestNonParameter_optionalParameter', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_argumentDefinitionTestNonParameter_optionalParameter);
-      });
-      _ut.test('test_breakWithoutLabelInSwitch', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_breakWithoutLabelInSwitch);
-      });
-      _ut.test('test_builtInIdentifierAsType_dynamic', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_builtInIdentifierAsType_dynamic);
-      });
-      _ut.test('test_caseExpressionTypeImplementsEquals_Object', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_Object);
-      });
-      _ut.test('test_caseExpressionTypeImplementsEquals_String', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_String);
-      });
-      _ut.test('test_caseExpressionTypeImplementsEquals_int', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_caseExpressionTypeImplementsEquals_int);
-      });
       _ut.test('test_class_extends_implements', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_class_extends_implements);
       });
-      _ut.test('test_constConstructorWithNonFinalField_const', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_const);
-      });
-      _ut.test('test_constConstructorWithNonFinalField_final', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_final);
-      });
-      _ut.test('test_constConstructorWithNonFinalField_syntheticField', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_constConstructorWithNonFinalField_syntheticField);
-      });
-      _ut.test('test_defaultValueInFunctionTypeAlias', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_defaultValueInFunctionTypeAlias);
-      });
-      _ut.test('test_duplicateDefinition_getter', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_duplicateDefinition_getter);
-      });
       _ut.test('test_empty', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_empty);
       });
       _ut.test('test_forEachLoops_nonConflicting', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_forEachLoops_nonConflicting);
       });
       _ut.test('test_forLoops_nonConflicting', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_forLoops_nonConflicting);
       });
       _ut.test('test_functionTypeAlias', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_functionTypeAlias);
       });
       _ut.test('test_getterAndSetterWithDifferentTypes', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_getterAndSetterWithDifferentTypes);
       });
       _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_invalidAssignment', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_invalidAssignment);
-      });
-      _ut.test('test_invalidAssignment_toDynamic', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_invalidAssignment_toDynamic);
-      });
-      _ut.test('test_invocationOfNonFunction_dynamic', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_invocationOfNonFunction_dynamic);
-      });
-      _ut.test('test_invocationOfNonFunction_getter', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_invocationOfNonFunction_getter);
-      });
-      _ut.test('test_invocationOfNonFunction_localVariable', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_invocationOfNonFunction_localVariable);
-      });
       _ut.test('test_invoke_dynamicThroughGetter', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_invoke_dynamicThroughGetter);
       });
       _ut.test('test_isValidMixin_badSuperclass', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_isValidMixin_badSuperclass);
       });
       _ut.test('test_isValidMixin_constructor', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_isValidMixin_constructor);
       });
       _ut.test('test_isValidMixin_super', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_isValidMixin_super);
       });
       _ut.test('test_isValidMixin_valid', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_isValidMixin_valid);
       });
       _ut.test('test_methodCascades', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_methodCascades);
       });
       _ut.test('test_methodCascades_withSetter', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_methodCascades_withSetter);
       });
-      _ut.test('test_newWithAbstractClass_factory', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_newWithAbstractClass_factory);
-      });
-      _ut.test('test_nonBoolExpression_assert_bool', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_nonBoolExpression_assert_bool);
-      });
-      _ut.test('test_nonBoolExpression_assert_functionType', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_nonBoolExpression_assert_functionType);
-      });
       _ut.test('test_resolveAgainstNull', () {
         final __test = new SimpleResolverTest();
         runJUnitTest(__test, __test.test_resolveAgainstNull);
       });
-      _ut.test('test_returnOfInvalidType_dynamic', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_returnOfInvalidType_dynamic);
-      });
-      _ut.test('test_returnOfInvalidType_subtype', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_returnOfInvalidType_subtype);
-      });
-      _ut.test('test_returnOfInvalidType_supertype', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_returnOfInvalidType_supertype);
-      });
-      _ut.test('test_typeArgumentNotMatchingBounds_const', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_const);
-      });
-      _ut.test('test_typeArgumentNotMatchingBounds_new', () {
-        final __test = new SimpleResolverTest();
-        runJUnitTest(__test, __test.test_typeArgumentNotMatchingBounds_new);
-      });
     });
   }
 }
 main() {
 //  ElementResolverTest.dartSuite();
 //  LibraryElementBuilderTest.dartSuite();
 //  LibraryTest.dartSuite();
 //  StaticTypeAnalyzerTest.dartSuite();
 //  TypeProviderImplTest.dartSuite();
 //  TypeResolverVisitorTest.dartSuite();
 //  EnclosedScopeTest.dartSuite();
 //  LibraryImportScopeTest.dartSuite();
 //  LibraryScopeTest.dartSuite();
 //  ScopeTest.dartSuite();
 //  CompileTimeErrorCodeTest.dartSuite();
 //  ErrorResolverTest.dartSuite();
+//  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 }