Simplify constructors translation, improve code style.

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 1482 matching lines @@
   }
   void test_nonConstMapAsExpressionStatement_typeArguments() {
     Source source = addSource(EngineTestCase.createSource(["f() {", "  <String, int> {'a' : 0, 'b' : 1};", "}"]));
     resolve(source);
     assertNoErrors();
     verify([source]);
   }
   void test_nonConstValueInInitializer_binary_bool() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final v;", "  const A.a1(bool p) : v = p && true;", "  const A.a2(bool p) : v = true && p;", "  const A.b1(bool p) : v = p || true;", "  const A.b2(bool p) : v = true || p;", "}"]));
     resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
+    assertErrors([HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_nonConstValueInInitializer_binary_dynamic() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final v;", "  const A.a1(p) : v = p + 5;", "  const A.a2(p) : v = 5 + p;", "  const A.b1(p) : v = p - 5;", "  const A.b2(p) : v = 5 - p;", "  const A.c1(p) : v = p * 5;", "  const A.c2(p) : v = 5 * p;", "  const A.d1(p) : v = p / 5;", "  const A.d2(p) : v = 5 / p;", "  const A.e1(p) : v = p ~/ 5;", "  const A.e2(p) : v = 5 ~/ p;", "  const A.f1(p) : v = p > 5;", "  const A.f2(p) : v = 5 > p;", "  const A.g1(p) : v = p < 5;", "  const A.g2(p) : v = 5 < p;", "  const A.h1(p) : v = p >= 5;", "  const A.h2(p) : v = 5 >= p;", "  const A.i1(p) : v = p <= 5;", "  const A.i2(p) : v = 5 <= p;", "  const A.j1(p) : v = p % 5;", "  const A.j2(p) : v = 5 % p;", "}"]));
     resolve(source);
     assertNoErrors();
   }
   void test_nonConstValueInInitializer_binary_int() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  final v;", "  const A.a1(int p) : v = p ^ 5;", "  const A.a2(int p) : v = 5 ^ p;", "  const A.b1(int p) : v = p & 5;", "  const A.b2(int p) : v = 5 & p;", "  const A.c1(int p) : v = p | 5;", "  const A.c2(int p) : v = 5 | p;", "  const A.d1(int p) : v = p >> 5;", "  const A.d2(int p) : v = 5 >> p;", "  const A.e1(int p) : v = p << 5;", "  const A.e2(int p) : v = 5 << p;", "}"]));
     resolve(source);
@@ skipping 1998 matching lines @@
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_typeTest_tooFew);
       });
       _ut.test('test_wrongNumberOfTypeArguments_typeTest_tooMany', () {
         final __test = new StaticTypeWarningCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfTypeArguments_typeTest_tooMany);
       });
     });
   }
 }
+class HintCodeTest extends ResolverTestCase {
+  void test_deadCode_deadBlock_conditionalElse() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  true ? 1 : 2;", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_conditionalIf() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  false ? 1 : 2;", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_else() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  if(true) {", "  } else {", "  }", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_if() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  if(false) {}", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_if_nested() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  if(false) {if(false) {}}", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_deadCode_deadBlock_while() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  while(false) {}", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_deadCode_deadCatch_catchFollowingCatch() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "f() {", "  try {} catch (e) {} catch (e) {}", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
+    verify([source]);
+  }
+  void test_deadCode_deadCatch_catchFollowingCatch_object() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  try {} on Object catch (e) {} catch (e) {}", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
+    verify([source]);
+  }
+  void test_deadCode_deadCatch_onCatchSubtype() {
+    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A {}", "f() {", "  try {} on A catch (e) {} on B catch (e) {}", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE_ON_CATCH_SUBTYPE]);
+    verify([source]);
+  }
+  void test_deadCode_deadOperandLHS_and() {
+    Source source = addSource(EngineTestCase.createSource(["f(bool b) {", "  bool c = false && b;", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_deadCode_deadOperandLHS_or() {
+    Source source = addSource(EngineTestCase.createSource(["f(bool b) {", "  bool c = true || b;", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_deadCode_statementAfterReturn_function() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  var one = 1;", "  return;", "  var two = 2;", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_deadCode_statementAfterReturn_ifStatement() {
+    Source source = addSource(EngineTestCase.createSource(["f(bool b) {", "  if(b) {", "    var one = 1;", "    return;", "    var two = 2;", "  }", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_deadCode_statementAfterReturn_method() {
+    Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {", "    var one = 1;", "    return;", "    var two = 2;", "  }", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    verify([source]);
+  }
+  void test_deadCode_statementAfterReturn_twoReturns() {
+    Source source = addSource(EngineTestCase.createSource(["f() {", "  var one = 1;", "  return;", "  var two = 2;", "  return;", "  var three = 3;", "}"]));
+    resolve(source);
+    assertErrors([HintCode.DEAD_CODE]);
+    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_conditionalIf', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_conditionalIf);
+      });
+      _ut.test('test_deadCode_deadBlock_else', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_else);
+      });
+      _ut.test('test_deadCode_deadBlock_if', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_if);
+      });
+      _ut.test('test_deadCode_deadBlock_if_nested', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_if_nested);
+      });
+      _ut.test('test_deadCode_deadBlock_while', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadBlock_while);
+      });
+      _ut.test('test_deadCode_deadCatch_catchFollowingCatch', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadCatch_catchFollowingCatch);
+      });
+      _ut.test('test_deadCode_deadCatch_catchFollowingCatch_object', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadCatch_catchFollowingCatch_object);
+      });
+      _ut.test('test_deadCode_deadCatch_onCatchSubtype', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadCatch_onCatchSubtype);
+      });
+      _ut.test('test_deadCode_deadOperandLHS_and', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadOperandLHS_and);
+      });
+      _ut.test('test_deadCode_deadOperandLHS_or', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadOperandLHS_or);
+      });
+      _ut.test('test_deadCode_statementAfterReturn_function', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_function);
+      });
+      _ut.test('test_deadCode_statementAfterReturn_ifStatement', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_ifStatement);
+      });
+      _ut.test('test_deadCode_statementAfterReturn_method', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_method);
+      });
+      _ut.test('test_deadCode_statementAfterReturn_twoReturns', () {
+        final __test = new HintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_twoReturns);
+      });
+    });
+  }
+}
 class TypeResolverVisitorTest extends EngineTestCase {
 
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
 
   /**
    * The object representing the information about the library in which the types are being
    * resolved.
@@ skipping 1321 matching lines @@
     assertErrors([CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION]);
     verify([source]);
   }
   void test_constEvalTypeBool_binary() {
     check_constEvalTypeBool_withParameter_binary("p && ''");
     check_constEvalTypeBool_withParameter_binary("p || ''");
   }
   void test_constEvalTypeBool_binary_leftTrue() {
     Source source = addSource("const C = (true || 0);");
     resolve(source);
-    assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL, AuditCode.DEAD_CODE]);
+    assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL, HintCode.DEAD_CODE]);
     verify([source]);
   }
   void test_constEvalTypeBoolNumString_equal() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "class B {", "  final a;", "  const B(num p) : a = p == const A();", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING]);
     verify([source]);
   }
   void test_constEvalTypeBoolNumString_notEqual() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "class B {", "  final a;", "  const B(String p) : a = p != const A();", "}"]));
@@ skipping 2792 matching lines @@
         } else {
           return "<unknown file- CompilationUnit.getElement() returned null>";
         }
       } else {
         return "<unknown file- CompilationUnit.getRoot() is not a CompilationUnit>";
       }
     }
     return "<unknown file- ASTNode is null>";
   }
 }
-class AuditCodeTest extends ResolverTestCase {
-  void test_deadCode_deadBlock_conditionalElse() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  true ? 1 : 2;", "}"]));
-    resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
-    verify([source]);
-  }
-  void test_deadCode_deadBlock_conditionalIf() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  false ? 1 : 2;", "}"]));
-    resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
-    verify([source]);
-  }
-  void test_deadCode_deadBlock_else() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  if(true) {", "  } else {", "  }", "}"]));
-    resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
-    verify([source]);
-  }
-  void test_deadCode_deadBlock_if() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  if(false) {}", "}"]));
-    resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
-    verify([source]);
-  }
-  void test_deadCode_deadBlock_while() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  while(false) {}", "}"]));
-    resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
-    verify([source]);
-  }
-  void test_deadCode_deadOperandLHS_and() {
-    Source source = addSource(EngineTestCase.createSource(["f(bool b) {", "  bool c = false && b;", "}"]));
-    resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
-    verify([source]);
-  }
-  void test_deadCode_deadOperandLHS_or() {
-    Source source = addSource(EngineTestCase.createSource(["f(bool b) {", "  bool c = true || b;", "}"]));
-    resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
-    verify([source]);
-  }
-  void test_deadCode_statementAfterReturn_function() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var one = 1;", "  return;", "  var two = 2;", "}"]));
-    resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
-    verify([source]);
-  }
-  void test_deadCode_statementAfterReturn_ifStatement() {
-    Source source = addSource(EngineTestCase.createSource(["f(bool b) {", "  if(b) {", "    var one = 1;", "    return;", "    var two = 2;", "  }", "}"]));
-    resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
-    verify([source]);
-  }
-  void test_deadCode_statementAfterReturn_method() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  m() {", "    var one = 1;", "    return;", "    var two = 2;", "  }", "}"]));
-    resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
-    verify([source]);
-  }
-  void test_deadCode_statementAfterReturn_twoReturns() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var one = 1;", "  return;", "  var two = 2;", "  return;", "  var three = 3;", "}"]));
-    resolve(source);
-    assertErrors([AuditCode.DEAD_CODE]);
-    verify([source]);
-  }
-  static dartSuite() {
-    _ut.group('AuditCodeTest', () {
-      _ut.test('test_deadCode_deadBlock_conditionalElse', () {
-        final __test = new AuditCodeTest();
-        runJUnitTest(__test, __test.test_deadCode_deadBlock_conditionalElse);
-      });
-      _ut.test('test_deadCode_deadBlock_conditionalIf', () {
-        final __test = new AuditCodeTest();
-        runJUnitTest(__test, __test.test_deadCode_deadBlock_conditionalIf);
-      });
-      _ut.test('test_deadCode_deadBlock_else', () {
-        final __test = new AuditCodeTest();
-        runJUnitTest(__test, __test.test_deadCode_deadBlock_else);
-      });
-      _ut.test('test_deadCode_deadBlock_if', () {
-        final __test = new AuditCodeTest();
-        runJUnitTest(__test, __test.test_deadCode_deadBlock_if);
-      });
-      _ut.test('test_deadCode_deadBlock_while', () {
-        final __test = new AuditCodeTest();
-        runJUnitTest(__test, __test.test_deadCode_deadBlock_while);
-      });
-      _ut.test('test_deadCode_deadOperandLHS_and', () {
-        final __test = new AuditCodeTest();
-        runJUnitTest(__test, __test.test_deadCode_deadOperandLHS_and);
-      });
-      _ut.test('test_deadCode_deadOperandLHS_or', () {
-        final __test = new AuditCodeTest();
-        runJUnitTest(__test, __test.test_deadCode_deadOperandLHS_or);
-      });
-      _ut.test('test_deadCode_statementAfterReturn_function', () {
-        final __test = new AuditCodeTest();
-        runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_function);
-      });
-      _ut.test('test_deadCode_statementAfterReturn_ifStatement', () {
-        final __test = new AuditCodeTest();
-        runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_ifStatement);
-      });
-      _ut.test('test_deadCode_statementAfterReturn_method', () {
-        final __test = new AuditCodeTest();
-        runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_method);
-      });
-      _ut.test('test_deadCode_statementAfterReturn_twoReturns', () {
-        final __test = new AuditCodeTest();
-        runJUnitTest(__test, __test.test_deadCode_statementAfterReturn_twoReturns);
-      });
-    });
-  }
-}
 /**
  * The class `StrictModeTest` contains tests to ensure that the correct errors and warnings
  * are reported when the analysis engine is run in strict mode.
  */
 class StrictModeTest extends ResolverTestCase {
   void fail_for() {
     Source source = addSource(EngineTestCase.createSource(["int f(List<int> list) {", "  num sum = 0;", "  for (num i = 0; i < list.length; i++) {", "    sum += list[i];", "  }", "}"]));
     resolve(source);
     assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
@@ skipping 2882 matching lines @@
 
   /**
    * 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_366_impl();
-  }
-  _jtd_constructor_366_impl() {
-    _jtd_constructor_367_impl(null);
-  }
+  ResolutionVerifier() : this.con1(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_367_impl(knownExceptions2);
-  }
-  _jtd_constructor_367_impl(Set<ASTNode> knownExceptions2) {
-    this._knownExceptions = knownExceptions2;
+  ResolutionVerifier.con1(Set<ASTNode> knownExceptions) {
+    this._knownExceptions = knownExceptions;
   }
 
   /**
    * 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 1213 matching lines @@
         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]);
+  }
+  static dartSuite() {
+    _ut.group('NonHintCodeTest', () {
+      _ut.test('test_deadCode_deadCatch_onCatchSubtype', () {
+        final __test = new NonHintCodeTest();
+        runJUnitTest(__test, __test.test_deadCode_deadCatch_onCatchSubtype);
+      });
+    });
+  }
+}
 class EnclosedScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     LibraryElement definingLibrary2 = createTestLibrary();
     GatheringErrorListener errorListener2 = new GatheringErrorListener();
     Scope rootScope = new Scope_17(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);
@@ skipping 855 matching lines @@
 //  LibraryElementBuilderTest.dartSuite();
 //  LibraryTest.dartSuite();
 //  StaticTypeAnalyzerTest.dartSuite();
 //  TypeOverrideManagerTest.dartSuite();
 //  TypeProviderImplTest.dartSuite();
 //  TypeResolverVisitorTest.dartSuite();
 //  EnclosedScopeTest.dartSuite();
 //  LibraryImportScopeTest.dartSuite();
 //  LibraryScopeTest.dartSuite();
 //  ScopeTest.dartSuite();
-//  AuditCodeTest.dartSuite();
 //  CompileTimeErrorCodeTest.dartSuite();
 //  ErrorResolverTest.dartSuite();
+//  HintCodeTest.dartSuite();
+//  NonHintCodeTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
 //  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }