Pluggable lint verifiers first step and basic lint task tests.

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 4452 matching lines @@
     // Find to-do comments
     new ToDoFinder(errorReporter).findIn(unit);
     // pub analysis
     // TODO(danrubel/jwren) Commented out until bugs in the pub verifier are
     // fixed
     //    unit.accept(new PubVerifier(context, errorReporter));
   }
 }
 
 
-/**
- * Traverses a library's worth of dart code at a time to generate lint warnings
- * over the set of sources.
- *
- * See [LintCode].
- */
+/// Traverses a library's worth of dart code at a time to generate lint warnings
+/// over the set of sources.
+///
+/// See [LintCode].
 class LintGenerator {
 
-  final List<CompilationUnit> _compilationUnits;
+  /// A global container for contributed verifiers.
+  static final List<LintVerifier> VERIFIERS = <LintVerifier>[];
+
+  final Iterable<CompilationUnit> _compilationUnits;
   final AnalysisErrorListener _errorListener;
+  final Iterable<LintVerifier> _verifiers;
 
-  LintGenerator(this._compilationUnits, this._errorListener);
+  LintGenerator(this._compilationUnits, this._errorListener,
+      [Iterable<LintVerifier> verifiers])

[scheglov, 2015/01/10 00:58:11]

Why is it optional?
Do we expect that we will ever want to create LintGenerator without providing a
list?

[pquitslund, 2015/01/12 16:44:43]

Actually, the common use case is to NOT provide the list and use the global
container that gets contributed to via plugins. Providing verifiers sidesteps
contributions for testing purposes.

+      : _verifiers = verifiers != null ? verifiers : VERIFIERS;
 
   void generate() {
     TimeCounter_TimeCounterHandle timeCounter =
         PerformanceStatistics.lint.start();
     try {
       _compilationUnits.forEach((cu) {
         if (cu.element != null) {
           _generate(cu, cu.element.source);
         }
       });
     } finally {
       timeCounter.stop();
     }
   }
 
   void _generate(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
-    unit.accept(new LintVerifier(errorReporter));
+    _verifiers.forEach((verifier) {
+      verifier.reporter = errorReporter;
+      return unit.accept(verifier);
+    });
   }
 }
 
-class LintVerifier extends RecursiveAstVisitor<Object> {
-
-  final ErrorReporter _reporter;
-
-  LintVerifier(this._reporter);
+/// Implementers contribute lint warnings via the provided error [reporter].
+abstract class LintVerifier extends RecursiveAstVisitor<Object> {
+  /// Used to report lint warnings.
+  /// NOTE: this is set by the framework before visit begins.
+  ErrorReporter reporter;
 }
 
 
 /**
  * Instances of the class {@code HtmlTagInfo} record information about the tags used in an HTML
  * file.
  */
 class HtmlTagInfo {
   /**
    * An array containing all of the tags used in the HTML file.
@@ skipping 10979 matching lines @@
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 }