Simplify constructors translation, improve code style.

pkg/analyzer_experimental/lib/src/generated/resolver.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;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 4253 matching lines @@
    */
   Set<Source> get compilationUnitSources => _astMap.keys.toSet();
 
   /**
    * Return the AST structure associated with the defining compilation unit for this library.
    *
    * @return the AST structure associated with the defining compilation unit for this library
    * @throws AnalysisException if an AST structure could not be created for the defining compilation
    *           unit
    */
-  CompilationUnit get definingCompilationUnit => getAST(librarySource);
+  CompilationUnit get definingCompilationUnit => getAST(_librarySource);
 
   /**
    * Return `true` if this library explicitly imports core.
    *
    * @return `true` if this library explicitly imports core
    */
   bool get explicitlyImportsCore => _explicitlyImportsCore;
 
   /**
    * Return an array containing the libraries that are exported from this library.
@@ skipping 106 matching lines @@
    */
   String getUri(UriBasedDirective directive) => _directiveUris[directive];
 
   /**
    * Set the AST structure associated with the defining compilation unit for this library to the
    * given AST structure.
    *
    * @param unit the AST structure associated with the defining compilation unit for this library
    */
   void set definingCompilationUnit(CompilationUnit unit) {
-    _astMap[librarySource] = unit;
+    _astMap[_librarySource] = unit;
   }
 
   /**
    * Set whether this library explicitly imports core to match the given value.
    *
    * @param explicitlyImportsCore `true` if this library explicitly imports core
    */
   void set explicitlyImportsCore(bool explicitlyImportsCore2) {
     this._explicitlyImportsCore = explicitlyImportsCore2;
   }
@@ skipping 238 matching lines @@
  * @coverage dart.engine.resolver
  */
 class LibraryResolver {
 
   /**
    * The analysis context in which the libraries are being analyzed.
    */
   InternalAnalysisContext _analysisContext;
 
   /**
-   * A flag indicating whether analysis is to generate audit results (e.g. type inference based
+   * A flag indicating whether analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
    */
-  bool _audit = false;
+  bool _enableHints = false;
 
   /**
    * The listener to which analysis errors will be reported, this error listener is either
    * references [recordingErrorListener], or it unions the passed
    * [AnalysisErrorListener] with the [recordingErrorListener].
    */
   RecordingErrorListener _errorListener;
 
   /**
    * A source object representing the core library (dart:core).
@@ skipping 22 matching lines @@
 
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    *
    * @param analysisContext the analysis context in which the library is being analyzed
    */
   LibraryResolver(InternalAnalysisContext analysisContext) {
     this._analysisContext = analysisContext;
     this._errorListener = new RecordingErrorListener();
     _coreLibrarySource = analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
-    _audit = analysisContext.analysisOptions.audit;
+    _enableHints = analysisContext.analysisOptions.hint;
   }
 
   /**
    * Return the analysis context in which the libraries are being analyzed.
    *
    * @return the analysis context in which the libraries are being analyzed
    */
   InternalAnalysisContext get analysisContext => _analysisContext;
 
   /**
@@ skipping 538 matching lines @@
    *           the library cannot be analyzed
    */
   void runAdditionalAnalyses2(Library library) {
     for (Source source in library.compilationUnitSources) {
       ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
       CompilationUnit unit = library.getAST(source);
       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _typeProvider);
       unit.accept(constantVerifier);
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, library.libraryElement, _typeProvider, library.inheritanceManager);
       unit.accept(errorVerifier);
-      if (_audit) {
-        new AuditVerifier(_analysisContext, errorReporter).visitCompilationUnit(unit);
+      if (_enableHints) {
+        new HintVerifier(_analysisContext, errorReporter).visitCompilationUnit(unit);
       }
     }
   }
 }
 /**
  * Instances of the class `ResolverVisitor` are used to resolve the nodes within a single
  * compilation unit.
  *
  * @coverage dart.engine.resolver
  */
@@ skipping 32 matching lines @@
   TypeOverrideManager _overrideManager = new TypeOverrideManager();
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ResolverVisitor.con1(Library library, Source source, TypeProvider typeProvider) : super.con1(library, source, typeProvider) {
-    _jtd_constructor_277_impl(library, source, typeProvider);
-  }
-  _jtd_constructor_277_impl(Library library, Source source, TypeProvider typeProvider) {
     this._inheritanceManager = library.inheritanceManager;
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
-  ResolverVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, InheritanceManager inheritanceManager2, AnalysisErrorListener errorListener) : super.con2(definingLibrary, source, typeProvider, errorListener) {
-    _jtd_constructor_278_impl(definingLibrary, source, typeProvider, inheritanceManager2, errorListener);
-  }
-  _jtd_constructor_278_impl(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, InheritanceManager inheritanceManager2, AnalysisErrorListener errorListener) {
-    this._inheritanceManager = inheritanceManager2;
+  ResolverVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, InheritanceManager inheritanceManager, AnalysisErrorListener errorListener) : super.con2(definingLibrary, source, typeProvider, errorListener) {
+    this._inheritanceManager = inheritanceManager;
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   /**
    * Return the object keeping track of which elements have had their types overridden.
    *
    * @return the object keeping track of which elements have had their types overridden
    */
   TypeOverrideManager get overrideManager => _overrideManager;
@@ skipping 733 matching lines @@
    */
   LabelScope _labelScope;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
-  ScopedVisitor.con1(Library library, Source source2, TypeProvider typeProvider2) {
-    _jtd_constructor_279_impl(library, source2, typeProvider2);
-  }
-  _jtd_constructor_279_impl(Library library, Source source2, TypeProvider typeProvider2) {
+  ScopedVisitor.con1(Library library, Source source, TypeProvider typeProvider) {
     this._definingLibrary = library.libraryElement;
-    this._source = source2;
+    this._source = source;
     LibraryScope libraryScope = library.libraryScope;
     this._errorListener = libraryScope.errorListener;
     this._nameScope = libraryScope;
-    this._typeProvider = typeProvider2;
+    this._typeProvider = typeProvider;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
-  ScopedVisitor.con2(LibraryElement definingLibrary2, Source source2, TypeProvider typeProvider2, AnalysisErrorListener errorListener2) {
-    _jtd_constructor_280_impl(definingLibrary2, source2, typeProvider2, errorListener2);
-  }
-  _jtd_constructor_280_impl(LibraryElement definingLibrary2, Source source2, TypeProvider typeProvider2, AnalysisErrorListener errorListener2) {
-    this._definingLibrary = definingLibrary2;
-    this._source = source2;
-    this._errorListener = errorListener2;
-    this._nameScope = new LibraryScope(definingLibrary2, errorListener2);
-    this._typeProvider = typeProvider2;
+  ScopedVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
+    this._definingLibrary = definingLibrary;
+    this._source = source;
+    this._errorListener = errorListener;
+    this._nameScope = new LibraryScope(definingLibrary, errorListener);
+    this._typeProvider = typeProvider;
   }
 
   /**
    * Return the library element for the library containing the compilation unit being resolved.
    *
    * @return the library element for the library containing the compilation unit being resolved
    */
   LibraryElement get definingLibrary => _definingLibrary;
 
   /**
@@ skipping 2372 matching lines @@
   bool _hasReferenceToSuper = false;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   TypeResolverVisitor.con1(Library library, Source source, TypeProvider typeProvider) : super.con1(library, source, typeProvider) {
-    _jtd_constructor_285_impl(library, source, typeProvider);
-  }
-  _jtd_constructor_285_impl(Library library, Source source, TypeProvider typeProvider) {
     _dynamicType = typeProvider.dynamicType;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
   TypeResolverVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) : super.con2(definingLibrary, source, typeProvider, errorListener) {
-    _jtd_constructor_286_impl(definingLibrary, source, typeProvider, errorListener);
-  }
-  _jtd_constructor_286_impl(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
     _dynamicType = typeProvider.dynamicType;
   }
   Object visitCatchClause(CatchClause node) {
     super.visitCatchClause(node);
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       TypeName exceptionTypeName = node.exceptionType;
       Type2 exceptionType;
       if (exceptionTypeName == null) {
         exceptionType = typeProvider.objectType;
@@ skipping 959 matching lines @@
 
   /**
    * Initialize a newly created scope to represent the potential target of an unlabeled
    * `break` or `continue`.
    *
    * @param outerScope the label scope enclosing the new label scope
    * @param onSwitchStatement `true` if this label is associated with a `switch`
    *          statement
    * @param onSwitchMember `true` if this label is associated with a `switch` member
    */
-  LabelScope.con1(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
-    _jtd_constructor_291_impl(outerScope, onSwitchStatement, onSwitchMember);
-  }
-  _jtd_constructor_291_impl(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
-    _jtd_constructor_292_impl(outerScope, EMPTY_LABEL, new LabelElementImpl(_EMPTY_LABEL_IDENTIFIER, onSwitchStatement, onSwitchMember));
-  }
+  LabelScope.con1(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) : this.con2(outerScope, EMPTY_LABEL, new LabelElementImpl(_EMPTY_LABEL_IDENTIFIER, onSwitchStatement, onSwitchMember));
 
   /**
    * Initialize a newly created scope to represent the given label.
    *
    * @param outerScope the label scope enclosing the new label scope
    * @param label the label defined in this scope
    * @param element the element to which the label resolves
    */
-  LabelScope.con2(LabelScope outerScope2, String label2, LabelElement element2) {
-    _jtd_constructor_292_impl(outerScope2, label2, element2);
-  }
-  _jtd_constructor_292_impl(LabelScope outerScope2, String label2, LabelElement element2) {
-    this._outerScope = outerScope2;
-    this._label = label2;
-    this._element = element2;
+  LabelScope.con2(LabelScope outerScope, String label, LabelElement element) {
+    this._outerScope = outerScope;
+    this._label = label;
+    this._element = element;
   }
 
   /**
    * Return the label element corresponding to the given label, or `null` if the given label
    * is not defined in this scope.
    *
    * @param targetLabel the label being looked up
    * @return the label element corresponding to the given label
    */
   LabelElement lookup(SimpleIdentifier targetLabel) => lookup2(targetLabel.name);
@@ skipping 655 matching lines @@
     if (element is MethodElement) {
       MethodElement method = element as MethodElement;
       if (method.name == "-" && method.parameters.length == 0) {
         return UNARY_MINUS;
       }
     }
     return element.name;
   }
 }
 /**
- * Instances of the class `AuditVerifier` traverse an AST structure looking for additional
- * additional suggestions not mentioned in the Dart Language Specification.
- *
- * @coverage dart.engine.resolver
- */
-class AuditVerifier {
-  DeadCodeVerifier _deadCodeVerifier;
-  AuditVerifier(AnalysisContext context, ErrorReporter errorReporter) {
-    _deadCodeVerifier = new DeadCodeVerifier(errorReporter);
-  }
-  void visitCompilationUnit(CompilationUnit node) {
-    node.accept(_deadCodeVerifier);
-  }
-}
-/**
  * Instances of the class `ConstantVerifier` traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver. In particular, it looks for errors
  * and warnings related to constant expressions.
  *
  * @coverage dart.engine.resolver
  */
 class ConstantVerifier extends RecursiveASTVisitor<Object> {
 
   /**
    * The error reporter by which errors will be reported.
@@ skipping 319 matching lines @@
           }
         }
         return ValidResult.RESULT_OBJECT;
       }
     }
     return super.visitSimpleIdentifier(node);
   }
 }
 /**
  * Instances of the class `DeadCodeVerifier` traverse an AST structure looking for cases of
- * [AuditCode#DEAD_CODE].
+ * [HintCode#DEAD_CODE].
  *
  * @coverage dart.engine.resolver
  */
 class DeadCodeVerifier extends RecursiveASTVisitor<Object> {
 
   /**
    * The error reporter by which errors will be reported.
    */
   ErrorReporter _errorReporter;
 
   /**
    * Create a new instance of the [DeadCodeVerifier].
    *
    * @param errorReporter the error reporter
    */
   DeadCodeVerifier(ErrorReporter errorReporter) {
     this._errorReporter = errorReporter;
   }
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     bool isAmpAmp = identical(operator.type, sc.TokenType.AMPERSAND_AMPERSAND);
     bool isBarBar = identical(operator.type, sc.TokenType.BAR_BAR);
-    bool foundError = false;
     if (isAmpAmp || isBarBar) {
       Expression lhsCondition = node.leftOperand;
       ValidResult lhsResult = getConstantBooleanValue(lhsCondition);
       if (lhsResult != null) {
         if (identical(lhsResult, ValidResult.RESULT_TRUE) && isBarBar) {
-          _errorReporter.reportError2(AuditCode.DEAD_CODE, node.rightOperand, []);
-          foundError = true;
+          _errorReporter.reportError2(HintCode.DEAD_CODE, node.rightOperand, []);
+          safelyVisit(lhsCondition);
+          return null;
         } else if (identical(lhsResult, ValidResult.RESULT_FALSE) && isAmpAmp) {
-          _errorReporter.reportError2(AuditCode.DEAD_CODE, node.rightOperand, []);
-          foundError = true;
+          _errorReporter.reportError2(HintCode.DEAD_CODE, node.rightOperand, []);
+          safelyVisit(lhsCondition);
+          return null;
         }
       }
     }
-    if (foundError) {
-      return null;
-    }
     return super.visitBinaryExpression(node);
   }
   Object visitBlock(Block node) {
     checkForDeadCodeStatementsAfterReturn(node);
     return super.visitBlock(node);
   }
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression conditionExpression = node.condition;
     ValidResult result = getConstantBooleanValue(conditionExpression);
     if (result != null) {
       if (identical(result, ValidResult.RESULT_TRUE)) {
-        _errorReporter.reportError2(AuditCode.DEAD_CODE, node.elseExpression, []);
+        _errorReporter.reportError2(HintCode.DEAD_CODE, node.elseExpression, []);
+        safelyVisit(node.thenExpression);
+        return null;
       } else {
-        _errorReporter.reportError2(AuditCode.DEAD_CODE, node.thenExpression, []);
+        _errorReporter.reportError2(HintCode.DEAD_CODE, node.thenExpression, []);
+        safelyVisit(node.elseExpression);
+        return null;
       }
     }
     return super.visitConditionalExpression(node);
   }
   Object visitIfStatement(IfStatement node) {
     Expression conditionExpression = node.condition;
     ValidResult result = getConstantBooleanValue(conditionExpression);
     if (result != null) {
       if (identical(result, ValidResult.RESULT_TRUE)) {
         Statement elseStatement = node.elseStatement;
         if (elseStatement != null) {
-          _errorReporter.reportError2(AuditCode.DEAD_CODE, elseStatement, []);
+          _errorReporter.reportError2(HintCode.DEAD_CODE, elseStatement, []);
+          safelyVisit(node.thenStatement);
+          return null;
         }
       } else {
-        _errorReporter.reportError2(AuditCode.DEAD_CODE, node.thenStatement, []);
+        _errorReporter.reportError2(HintCode.DEAD_CODE, node.thenStatement, []);
+        safelyVisit(node.elseStatement);
+        return null;
       }
     }
     return super.visitIfStatement(node);
   }
+  Object visitTryStatement(TryStatement node) {
+    safelyVisit(node.body);
+    NodeList<CatchClause> catchClauses = node.catchClauses;
+    int numOfCatchClauses = catchClauses.length;
+    if (numOfCatchClauses == 0) {
+      safelyVisit(node.finallyClause);
+      return null;
+    }
+    List<Type2> visitedTypes = new List<Type2>();
+    for (int i = 0; i < numOfCatchClauses; i++) {
+      CatchClause catchClause = catchClauses[i];
+      if (catchClause.onKeyword != null) {
+        TypeName typeName = catchClause.exceptionType;
+        if (typeName != null && typeName.type != null) {
+          Type2 currentType = typeName.type;
+          if (currentType.isObject) {
+            safelyVisit(catchClause);
+            if (i + 1 != numOfCatchClauses) {
+              CatchClause nextCatchClause = catchClauses[i + 1];
+              CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
+              int offset = nextCatchClause.offset;
+              int length = lastCatchClause.end - offset;
+              _errorReporter.reportError3(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
+              break;
+            }
+          }
+          for (Type2 type in visitedTypes) {
+            if (currentType.isSubtypeOf(type)) {
+              _errorReporter.reportError2(HintCode.DEAD_CODE_ON_CATCH_SUBTYPE, catchClause, [currentType.displayName, type.displayName]);
+              continue;
+            }
+          }
+          visitedTypes.add(currentType);
+        }
+        safelyVisit(catchClause);
+      } else {
+        safelyVisit(catchClause);
+        if (i + 1 != numOfCatchClauses) {
+          CatchClause nextCatchClause = catchClauses[i + 1];
+          CatchClause lastCatchClause = catchClauses[numOfCatchClauses - 1];
+          int offset = nextCatchClause.offset;
+          int length = lastCatchClause.end - offset;
+          _errorReporter.reportError3(HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH, offset, length, []);
+          break;
+        }
+      }
+    }
+    safelyVisit(node.finallyClause);
+    return null;
+  }
   Object visitWhileStatement(WhileStatement node) {
     Expression conditionExpression = node.condition;
     ValidResult result = getConstantBooleanValue(conditionExpression);
     if (result != null) {
       if (identical(result, ValidResult.RESULT_FALSE)) {
-        _errorReporter.reportError2(AuditCode.DEAD_CODE, node.body, []);
+        _errorReporter.reportError2(HintCode.DEAD_CODE, node.body, []);
+        safelyVisit(conditionExpression);
+        return null;
       }
     }
     return super.visitWhileStatement(node);
   }
 
   /**
    * Given some [Block], this method reports and error on all statements between the end of
    * the block and the first return statement (assuming there it is not at the end of the block.)
    *
    * @param node the block to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    */
   bool checkForDeadCodeStatementsAfterReturn(Block node) {
     NodeList<Statement> statements = node.statements;
     int size = statements.length;
     if (size == 0) {
       return false;
     }
     for (int i = 0; i < size; i++) {
       Statement currentStatement = statements[i];
       if (currentStatement is ReturnStatement && i != size - 1) {
         Statement nextStatement = statements[i + 1];
         Statement lastStatement = statements[size - 1];
         int offset = nextStatement.offset;
         int length = lastStatement.end - offset;
-        _errorReporter.reportError3(AuditCode.DEAD_CODE, offset, length, []);
+        _errorReporter.reportError3(HintCode.DEAD_CODE, offset, length, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Given some [Expression], this method returns [ValidResult#RESULT_TRUE] if it is
    * `true`, [ValidResult#RESULT_FALSE] if it is `false`, or `null` if the
    * expression is not a constant boolean value.
@@ skipping 13 matching lines @@
     } else {
       EvaluationResultImpl result = expression.accept(new ConstantVisitor());
       if (identical(result, ValidResult.RESULT_TRUE)) {
         return ValidResult.RESULT_TRUE;
       } else if (identical(result, ValidResult.RESULT_FALSE)) {
         return ValidResult.RESULT_FALSE;
       }
       return null;
     }
   }
+
+  /**
+   * If the given node is not `null`, visit this instance of the dead code verifier.
+   *
+   * @param node the node to be visited
+   */
+  void safelyVisit(ASTNode node) {
+    if (node != null) {
+      node.accept(this);
+    }
+  }
 }
 /**
  * Instances of the class `ErrorVerifier` traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver.
  *
  * @coverage dart.engine.resolver
  */
 class ErrorVerifier extends RecursiveASTVisitor<Object> {
 
   /**
@@ skipping 3413 matching lines @@
   static final INIT_STATE INIT_IN_FIELD_FORMAL = new INIT_STATE('INIT_IN_FIELD_FORMAL', 2);
   static final INIT_STATE INIT_IN_DEFAULT_VALUE = new INIT_STATE('INIT_IN_DEFAULT_VALUE', 3);
   static final INIT_STATE INIT_IN_INITIALIZERS = new INIT_STATE('INIT_IN_INITIALIZERS', 4);
   static final List<INIT_STATE> values = [NOT_INIT, INIT_IN_DECLARATION, INIT_IN_FIELD_FORMAL, INIT_IN_DEFAULT_VALUE, INIT_IN_INITIALIZERS];
 
   /// The name of this enum constant, as declared in the enum declaration.
   final String name;
 
   /// The position in the enum declaration.
   final int ordinal;
-  INIT_STATE(this.name, this.ordinal) {
-  }
+  INIT_STATE(this.name, this.ordinal);
   int compareTo(INIT_STATE other) => ordinal - other.ordinal;
   int get hashCode => ordinal;
   String toString() => name;
 }
 /**
+ * Instances of the class `HintVerifier` traverse an AST structure looking for additional
+ * additional suggestions not mentioned in the Dart Language Specification.
+ *
+ * @coverage dart.engine.resolver
+ */
+class HintVerifier {
+  DeadCodeVerifier _deadCodeVerifier;
+  HintVerifier(AnalysisContext context, ErrorReporter errorReporter) {
+    _deadCodeVerifier = new DeadCodeVerifier(errorReporter);
+  }
+  void visitCompilationUnit(CompilationUnit node) {
+    node.accept(_deadCodeVerifier);
+  }
+}
+/**
  * Instances of the class `PubVerifier` traverse an AST structure looking for deviations from
  * pub best practices.
  */
 class PubVerifier extends RecursiveASTVisitor<Object> {
   static String _PUBSPEC_YAML = "pubspec.yaml";
 
   /**
    * The analysis context containing the sources to be analyzed
    */
   AnalysisContext _context;
@@ skipping 178 matching lines @@
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   int compareTo(ResolverErrorCode other) => ordinal - other.ordinal;
   int get hashCode => ordinal;
   String toString() => name;
 }