plugins/InspectionGadgets/src/com/siyeh/ig/InspectionGadgetsPlugin.java

   1 /*
   2 * Copyright 2003-2009 Dave Griffith, Bas Leijdekkers
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16 package com.siyeh.ig;
  17
  18 import com.intellij.codeInspection.GlobalInspectionTool;
  19 import com.intellij.codeInspection.InspectionProfileEntry;
  20 import com.intellij.codeInspection.InspectionToolProvider;
  21 import com.intellij.codeInspection.booleanIsAlwaysInverted.BooleanMethodIsAlwaysInvertedInspection;
  22 import com.intellij.openapi.components.ApplicationComponent;
  23 import com.siyeh.InspectionGadgetsBundle;
  24 import com.siyeh.ig.abstraction.*;
  25 import com.siyeh.ig.assignment.*;
  26 import com.siyeh.ig.bitwise.IncompatibleMaskInspection;
  27 import com.siyeh.ig.bitwise.PointlessBitwiseExpressionInspection;
  28 import com.siyeh.ig.bitwise.ShiftOutOfRangeInspection;
  29 import com.siyeh.ig.bugs.*;
  30 import com.siyeh.ig.classlayout.*;
  31 import com.siyeh.ig.classmetrics.*;
  32 import com.siyeh.ig.cloneable.*;
  33 import com.siyeh.ig.controlflow.*;
  34 import com.siyeh.ig.dataflow.*;
  35 import com.siyeh.ig.dependency.*;
  36 import com.siyeh.ig.encapsulation.*;
  37 import com.siyeh.ig.errorhandling.*;
  38 import com.siyeh.ig.finalization.FinalizeCallsSuperFinalizeInspection;
  39 import com.siyeh.ig.finalization.FinalizeInspection;
  40 import com.siyeh.ig.finalization.FinalizeNotProtectedInspection;
  41 import com.siyeh.ig.finalization.NoExplicitFinalizeCallsInspection;
  42 import com.siyeh.ig.global.MethodReturnAlwaysConstantInspection;
  43 import com.siyeh.ig.imports.*;
  44 import com.siyeh.ig.inheritance.*;
  45 import com.siyeh.ig.initialization.*;
  46 import com.siyeh.ig.internationalization.*;
  47 import com.siyeh.ig.j2me.*;
  48 import com.siyeh.ig.javabeans.ClassWithoutConstructorInspection;
  49 import com.siyeh.ig.javabeans.ClassWithoutNoArgConstructorInspection;
  50 import com.siyeh.ig.javabeans.FieldHasSetterButNoGetterInspection;
  51 import com.siyeh.ig.jdk.*;
  52 import com.siyeh.ig.jdk15.*;
  53 import com.siyeh.ig.junit.*;
  54 import com.siyeh.ig.logging.*;
  55 import com.siyeh.ig.maturity.*;
  56 import com.siyeh.ig.memory.StaticCollectionInspection;
  57 import com.siyeh.ig.memory.StringBufferFieldInspection;
  58 import com.siyeh.ig.memory.SystemGCInspection;
  59 import com.siyeh.ig.memory.ZeroLengthArrayInitializationInspection;
  60 import com.siyeh.ig.methodmetrics.*;
  61 import com.siyeh.ig.modularization.ModuleWithTooFewClassesInspection;
  62 import com.siyeh.ig.modularization.ModuleWithTooManyClassesInspection;
  63 import com.siyeh.ig.naming.*;
  64 import com.siyeh.ig.numeric.*;
  65 import com.siyeh.ig.packaging.*;
  66 import com.siyeh.ig.performance.*;
  67 import com.siyeh.ig.portability.*;
  68 import com.siyeh.ig.resources.*;
  69 import com.siyeh.ig.security.*;
  70 import com.siyeh.ig.serialization.*;
  71 import com.siyeh.ig.style.*;
  72 import com.siyeh.ig.telemetry.InspectionGadgetsTelemetry;
  73 import com.siyeh.ig.threading.*;
  74 import com.siyeh.ig.visibility.*;
  75 import org.jetbrains.annotations.NonNls;
  76 import org.jetbrains.annotations.NotNull;
  77
  78 import java.io.*;
  79 import java.util.*;
  80
  81 @SuppressWarnings({"OverlyCoupledClass",
  82         "OverlyCoupledMethod",
  83         "OverlyLongMethod",
  84         "ClassWithTooManyMethods"})
  85 public class InspectionGadgetsPlugin implements ApplicationComponent,
  86         InspectionToolProvider {
  87
  88     private static final int NUM_INSPECTIONS = 621;
  89     private final List<Class<? extends InspectionProfileEntry>> m_inspectionClasses =
  90             new ArrayList(NUM_INSPECTIONS);
  91     @NonNls private static final String DESCRIPTION_DIRECTORY_NAME =
  92             "src/inspectionDescriptions/";
  93     private final InspectionGadgetsTelemetry telemetry =
  94             new InspectionGadgetsTelemetry();
  95     public static final boolean TELEMETRY_ENABLED = false;
  96     @NonNls private static final String INSPECTION = "Inspection";
  97     @NonNls private static final String BUILD_FIXES_ONLY_ON_THE_FLY = "(r)";
  98
  99     public static void main(String[] args) throws FileNotFoundException {
 100         final PrintStream out;
 101         if (args.length == 0) {
 102             out = System.out;
 103         } else {
 104             final OutputStream stream = new FileOutputStream(args[0]);
 105             out = new PrintStream(stream);
 106         }
 107         try {
 108             final InspectionGadgetsPlugin plugin =
 109                     new InspectionGadgetsPlugin();
 110             plugin.createDocumentation(out);
 111         } finally {
 112             out.close();
 113         }
 114     }
 115
 116     private void createDocumentation(PrintStream out) {
 117         final Class<? extends InspectionProfileEntry>[] classes =
 118                 getInspectionClasses();
 119         Arrays.sort(classes, new InspectionComparator());
 120
 121         final int numQuickFixes = countQuickFixes(classes, out);
 122         out.println(InspectionGadgetsBundle.message(
 123                 "create.documentation.count.inspections.message",
 124                 Integer.valueOf(classes.length)));
 125         out.println(InspectionGadgetsBundle.message(
 126                 "create.documentation.count.quick.fixes.message",
 127                 Integer.valueOf(numQuickFixes)));
 128         String currentGroupName = "";
 129
 130         for (final Class<? extends InspectionProfileEntry> aClass : classes) {
 131             final String className = aClass.getName();
 132             try {
 133                 final InspectionProfileEntry inspection =
 134                         aClass.newInstance();
 135                 final String groupDisplayName =
 136                         inspection.getGroupDisplayName();
 137                 if (!groupDisplayName.equals(currentGroupName)) {
 138                     currentGroupName = groupDisplayName;
 139                     out.println();
 140                     out.print("   * ");
 141                     out.println(currentGroupName);
 142                 }
 143                 printInspectionDescription(inspection, out);
 144             } catch (InstantiationException ignore) {
 145                 out.println(InspectionGadgetsBundle.message(
 146                         "create.documentation.couldn.t.instantiate.class",
 147                         className));
 148             } catch (IllegalAccessException ignore) {
 149                 out.println(InspectionGadgetsBundle.message(
 150                         "create.documentation.couldnt.access.class", className));
 151             } catch (ClassCastException ignore) {
 152                 out.println(InspectionGadgetsBundle.message(
 153                         "create.documentation.couldnt.cast.class", className));
 154             }
 155         }
 156
 157         out.println();
 158         out.println(InspectionGadgetsBundle.message(
 159                 "create.documentation.inspections.enabled.by.default.message"));
 160         for (final Class<? extends InspectionProfileEntry> aClass : classes) {
 161             final String className = aClass.getName();
 162             try {
 163                 final InspectionProfileEntry inspection =
 164                         aClass.newInstance();
 165                 if (inspection.isEnabledByDefault()) {
 166                     out.println('\t' + inspection.getDisplayName());
 167                 }
 168             } catch (InstantiationException ignore) {
 169                 out.println(InspectionGadgetsBundle.message(
 170                         "create.documentation.couldn.t.instantiate.class",
 171                         className));
 172             } catch (IllegalAccessException ignore) {
 173                 out.println(InspectionGadgetsBundle.message(
 174                         "create.documentation.couldnt.access.class", className));
 175             } catch (ClassCastException ignore) {
 176                 out.println(InspectionGadgetsBundle.message(
 177                         "create.documentation.couldnt.cast.class", className));
 178             }
 179         }
 180         final File descriptionDirectory = new File(DESCRIPTION_DIRECTORY_NAME);
 181         final File[] descriptionFiles = descriptionDirectory.listFiles();
 182         final Set<File> descriptionFilesSet = new HashSet<File>(
 183                 descriptionFiles.length);
 184         for (File descriptionFile : descriptionFiles) {
 185             final String name = descriptionFile.getName();
 186             if (!(name.length() > 0 && name.charAt(0) == '.')) {
 187                 descriptionFilesSet.add(descriptionFile);
 188             }
 189         }
 190         for (final Class<? extends InspectionProfileEntry> aClass : classes) {
 191             final String className = aClass.getName();
 192             final String simpleClassName =
 193                     className.substring(className.lastIndexOf('.') + 1,
 194                             className.length() -
 195                                     INSPECTION.length());
 196             @NonNls final String fileName =
 197                     DESCRIPTION_DIRECTORY_NAME + simpleClassName + ".html";
 198             final File descriptionFile = new File(fileName);
 199             if (descriptionFile.exists()) {
 200                 descriptionFilesSet.remove(descriptionFile);
 201             } else {
 202                 out.println(InspectionGadgetsBundle.message(
 203                         "create.documentation.couldnt.find.documentation.file.error.message",
 204                         fileName));
 205             }
 206         }
 207         for (final File file : descriptionFilesSet) {
 208             out.println(
 209                     InspectionGadgetsBundle.message(
 210                             "create.documentation.unused.documentation.file.error.message",
 211                             file.getAbsolutePath()));
 212         }
 213     }
 214
 215     private static void printInspectionDescription(InspectionProfileEntry inspection,
 216                                                    PrintStream out) {
 217         boolean hasQuickFix = false;
 218         BaseInspection baseInspection = null;
 219         if (!(inspection instanceof GlobalInspectionTool)) {
 220             baseInspection = (BaseInspection) inspection;
 221             hasQuickFix = baseInspection.hasQuickFix();
 222         }
 223         final String displayName = inspection.getDisplayName();
 224         out.print("      * ");
 225         out.print(displayName);
 226         if (hasQuickFix) {
 227             if (baseInspection.buildQuickFixesOnlyForOnTheFlyErrors()) {
 228                 out.print(BUILD_FIXES_ONLY_ON_THE_FLY);
 229             } else {
 230                 out.print("(*)");
 231             }
 232         }
 233         out.println();
 234     }
 235
 236     private static int countQuickFixes(
 237             Class<? extends InspectionProfileEntry>[] classes, PrintStream out) {
 238         int numQuickFixes = 0;
 239         for (final Class<? extends InspectionProfileEntry> aClass : classes) {
 240             final String className = aClass.getName();
 241             try {
 242                 final InspectionProfileEntry inspection =
 243                         aClass.newInstance();
 244                 if (!(inspection instanceof GlobalInspectionTool)) {
 245                     if (((BaseInspection) inspection).hasQuickFix()) {
 246                         numQuickFixes++;
 247                     }
 248                 }
 249             } catch (InstantiationException ignore) {
 250                 out.print(InspectionGadgetsBundle.message(
 251                         "create.documentation.couldn.t.instantiate.class",
 252                         className));
 253             } catch (IllegalAccessException ignore) {
 254                 out.print(InspectionGadgetsBundle.message(
 255                         "create.documentation.couldnt.access.class", className));
 256             } catch (ClassCastException ignore) {
 257                 out.print(InspectionGadgetsBundle.message(
 258                         "create.documentation.couldnt.cast.class", className));
 259             }
 260         }
 261         return numQuickFixes;
 262     }
 263
 264     @NotNull
 265     public String getComponentName() {
 266         return "InspectionGadgets";
 267     }
 268
 269     public Class<? extends InspectionProfileEntry>[] getInspectionClasses() {
 270         if (m_inspectionClasses.isEmpty()) {
 271             registerAbstractionInspections();
 272             registerAssignmentInspections();
 273             registerBitwiseInspections();
 274             registerBugInspections();
 275             registerClassLayoutInspections();
 276             registerClassMetricsInspections();
 277             registerCloneInspections();
 278             registerControlFlowInspections();
 279             registerDataFlowInspections();
 280             registerEncapsulationInspections();
 281             registerErrorHandlingInspections();
 282             registerFinalizationInspections();
 283             registerImportInspections();
 284             registerInheritanceInspections();
 285             registerInitializerInspections();
 286             registerInternationalInspections();
 287             registerJ2MEInspections();
 288             registerJavaBeansInspections();
 289             registerJdk5SpecificInspections();
 290             registerJdkInspections();
 291             registerJUnitInspections();
 292             registerLoggingInspections();
 293             registerMaturityInspections();
 294             registerMemoryInspections();
 295             registerMethodMetricsInspections();
 296             registerNamingInspections();
 297             registerNumericInspections();
 298             registerPerformanceInspections();
 299             registerPortabilityInspections();
 300             registerResourceManagementInspections();
 301             registerSecurityInspections();
 302             registerSerializationInspections();
 303             registerStyleInspections();
 304             registerThreadingInspections();
 305             registerVisibilityInspections();
 306             m_inspectionClasses.add(MethodReturnAlwaysConstantInspection.class);
 307             m_inspectionClasses.add(BooleanMethodIsAlwaysInvertedInspection.class);
 308             registerPackagingInspections();
 309             registerModularizationInspections();
 310             registerDependencyInspections();
 311         }
 312         final int numInspections = m_inspectionClasses.size();
 313         final Class<? extends InspectionProfileEntry>[] classArray =
 314                 new Class[numInspections];
 315         return m_inspectionClasses.toArray(classArray);
 316     }
 317
 318     private void registerPackagingInspections() {
 319         m_inspectionClasses.add(PackageInMultipleModulesInspection.class);
 320         m_inspectionClasses.add(DisjointPackageInspection.class);
 321         m_inspectionClasses.add(ClassUnconnectedToPackageInspection.class);
 322         m_inspectionClasses.add(PackageWithTooManyClassesInspection.class);
 323         m_inspectionClasses.add(PackageWithTooFewClassesInspection.class);
 324     }
 325
 326     private void registerModularizationInspections() {
 327         m_inspectionClasses.add(ModuleWithTooManyClassesInspection.class);
 328         m_inspectionClasses.add(ModuleWithTooFewClassesInspection.class);
 329     }
 330
 331     private void registerDependencyInspections() {
 332         m_inspectionClasses.add(ClassWithTooManyDependenciesInspection.class);
 333         m_inspectionClasses.add(ClassWithTooManyDependentsInspection.class);
 334         m_inspectionClasses.add(ClassWithTooManyTransitiveDependenciesInspection.class);
 335         m_inspectionClasses.add(ClassWithTooManyTransitiveDependentsInspection.class);
 336         m_inspectionClasses.add(CyclicClassDependencyInspection.class);
 337         m_inspectionClasses.add(CyclicPackageDependencyInspection.class);
 338     }
 339
 340     public void initComponent() {
 341     }
 342
 343     private void registerResourceManagementInspections() {
 344         m_inspectionClasses.add(ChannelResourceInspection.class);
 345         m_inspectionClasses.add(DriverManagerGetConnectionInspection.class);
 346         m_inspectionClasses.add(HibernateResourceInspection.class);
 347         m_inspectionClasses.add(IOResourceInspection.class);
 348         m_inspectionClasses.add(JDBCResourceInspection.class);
 349         m_inspectionClasses.add(JNDIResourceInspection.class);
 350         m_inspectionClasses.add(SocketResourceInspection.class);
 351     }
 352
 353     private void registerLoggingInspections() {
 354         m_inspectionClasses.add(ClassWithMultipleLoggersInspection.class);
 355         m_inspectionClasses.add(ClassWithoutLoggerInspection.class);
 356         m_inspectionClasses.add(LoggingConditionDisagreesWithLogStatementInspection.class);
 357         m_inspectionClasses.add(LoggerInitializedWithForeignClassInspection.class);
 358         m_inspectionClasses.add(LogStatementGuardedByLogConditionInspection.class);
 359         m_inspectionClasses.add(NonStaticFinalLoggerInspection.class);
 360         //m_inspectionClasses.add(PublicMethodWithoutLoggingInspection.class);
 361     }
 362
 363     private void registerSecurityInspections() {
 364         m_inspectionClasses.add(ClassLoaderInstantiationInspection.class);
 365         m_inspectionClasses.add(CloneableClassInSecureContextInspection.class);
 366         m_inspectionClasses.add(CustomClassloaderInspection.class);
 367         m_inspectionClasses.add(CustomSecurityManagerInspection.class);
 368         m_inspectionClasses.add(DeserializableClassInSecureContextInspection.class);
 369         m_inspectionClasses.add(DesignForExtensionInspection.class);
 370         m_inspectionClasses.add(JDBCExecuteWithNonConstantStringInspection.class);
 371         m_inspectionClasses.add(JDBCPrepareStatementWithNonConstantStringInspection.class);
 372         m_inspectionClasses.add(LoadLibraryWithNonConstantStringInspection.class);
 373         m_inspectionClasses.add(NonFinalCloneInspection.class);
 374         m_inspectionClasses.add(NonStaticInnerClassInSecureContextInspection.class);
 375         m_inspectionClasses.add(PublicStaticArrayFieldInspection.class);
 376         m_inspectionClasses.add(PublicStaticCollectionFieldInspection.class);
 377         m_inspectionClasses.add(RuntimeExecWithNonConstantStringInspection.class);
 378         m_inspectionClasses.add(SerializableClassInSecureContextInspection.class);
 379         m_inspectionClasses.add(SystemSetSecurityManagerInspection.class);
 380         m_inspectionClasses.add(SystemPropertiesInspection.class);
 381         m_inspectionClasses.add(UnsecureRandomNumberGenerationInspection.class);
 382     }
 383
 384     private void registerImportInspections() {
 385         m_inspectionClasses.add(JavaLangImportInspection.class);
 386         m_inspectionClasses.add(OnDemandImportInspection.class);
 387         m_inspectionClasses.add(RedundantImportInspection.class);
 388         m_inspectionClasses.add(SamePackageImportInspection.class);
 389         m_inspectionClasses.add(SingleClassImportInspection.class);
 390         m_inspectionClasses.add(StaticImportInspection.class);
 391         m_inspectionClasses.add(UnusedImportInspection.class);
 392     }
 393
 394     private void registerNamingInspections() {
 395         m_inspectionClasses.add(AnnotationNamingConventionInspection.class);
 396         m_inspectionClasses.add(BooleanMethodNameMustStartWithQuestionInspection.class);
 397         m_inspectionClasses.add(ClassNamePrefixedWithPackageNameInspection.class);
 398         m_inspectionClasses.add(ClassNameSameAsAncestorNameInspection.class);
 399         m_inspectionClasses.add(ClassNamingConventionInspection.class);
 400         m_inspectionClasses.add(ConfusingMainMethodInspection.class);
 401         m_inspectionClasses.add(ConstantNamingConventionInspection.class);
 402         m_inspectionClasses.add(DollarSignInNameInspection.class);
 403         m_inspectionClasses.add(EnumeratedClassNamingConventionInspection.class);
 404         m_inspectionClasses.add(EnumeratedConstantNamingConventionInspection.class);
 405         m_inspectionClasses.add(ExceptionNameDoesntEndWithExceptionInspection.class);
 406         m_inspectionClasses.add(InstanceMethodNamingConventionInspection.class);
 407         m_inspectionClasses.add(InstanceVariableNamingConventionInspection.class);
 408         m_inspectionClasses.add(InterfaceNamingConventionInspection.class);
 409         m_inspectionClasses.add(LocalVariableNamingConventionInspection.class);
 410         m_inspectionClasses.add(MethodNameSameAsClassNameInspection.class);
 411         m_inspectionClasses.add(MethodNameSameAsParentNameInspection.class);
 412         m_inspectionClasses.add(MethodNamesDifferOnlyByCaseInspection.class);
 413         m_inspectionClasses.add(NonBooleanMethodNameMayNotStartWithQuestionInspection.class);
 414         m_inspectionClasses.add(NonExceptionNameEndsWithExceptionInspection.class);
 415         m_inspectionClasses.add(OverloadedMethodsWithSameNumberOfParametersInspection.class);
 416         m_inspectionClasses.add(OverloadedVarargsMethodInspection.class);
 417 //        m_inspectionClasses.add(PackageNamingConventionInspection.class);
 418         m_inspectionClasses.add(ParameterNameDiffersFromOverriddenParameterInspection.class);
 419         m_inspectionClasses.add(ParameterNamingConventionInspection.class);
 420         m_inspectionClasses.add(QuestionableNameInspection.class);
 421         m_inspectionClasses.add(StandardVariableNamesInspection.class);
 422         m_inspectionClasses.add(StaticMethodNamingConventionInspection.class);
 423         m_inspectionClasses.add(StaticVariableNamingConventionInspection.class);
 424         m_inspectionClasses.add(TypeParameterNamingConventionInspection.class);
 425         m_inspectionClasses.add(UpperCaseFieldNameNotConstantInspection.class);
 426     }
 427
 428     private void registerControlFlowInspections() {
 429         m_inspectionClasses.add(BreakStatementInspection.class);
 430         m_inspectionClasses.add(BreakStatementWithLabelInspection.class);
 431         m_inspectionClasses.add(ConditionalExpressionInspection.class);
 432         m_inspectionClasses.add(ConditionalExpressionWithIdenticalBranchesInspection.class);
 433         m_inspectionClasses.add(ConfusingElseInspection.class);
 434         m_inspectionClasses.add(ConstantConditionalExpressionInspection.class);
 435         m_inspectionClasses.add(ConstantIfStatementInspection.class);
 436         m_inspectionClasses.add(ContinueStatementInspection.class);
 437         m_inspectionClasses.add(ContinueStatementWithLabelInspection.class);
 438         m_inspectionClasses.add(DefaultNotLastCaseInSwitchInspection.class);
 439         m_inspectionClasses.add(DoubleNegationInspection.class);
 440         m_inspectionClasses.add(DuplicateBooleanBranchInspection.class);
 441         m_inspectionClasses.add(DuplicateConditionInspection.class);
 442         m_inspectionClasses.add(EnumSwitchStatementWhichMissesCasesInspection.class);
 443         m_inspectionClasses.add(FallthruInSwitchStatementInspection.class);
 444         m_inspectionClasses.add(ForLoopReplaceableByWhileInspection.class);
 445         m_inspectionClasses.add(ForLoopWithMissingComponentInspection.class);
 446         m_inspectionClasses.add(IfMayBeConditionalInspection.class);
 447         m_inspectionClasses.add(IfStatementWithIdenticalBranchesInspection.class);
 448         m_inspectionClasses.add(IfStatementWithTooManyBranchesInspection.class);
 449         m_inspectionClasses.add(InfiniteLoopStatementInspection.class);
 450         m_inspectionClasses.add(LabeledStatementInspection.class);
 451         m_inspectionClasses.add(LoopConditionNotUpdatedInsideLoopInspection.class);
 452         m_inspectionClasses.add(LoopStatementsThatDontLoopInspection.class);
 453         m_inspectionClasses.add(LoopWithImplicitTerminationConditionInspection.class);
 454         m_inspectionClasses.add(NegatedConditionalInspection.class);
 455         m_inspectionClasses.add(NegatedIfElseInspection.class);
 456         m_inspectionClasses.add(NestedConditionalExpressionInspection.class);
 457         m_inspectionClasses.add(NestedSwitchStatementInspection.class);
 458         m_inspectionClasses.add(OverlyComplexBooleanExpressionInspection.class);
 459         m_inspectionClasses.add(PointlessBooleanExpressionInspection.class);
 460         m_inspectionClasses.add(PointlessIndexOfComparisonInspection.class);
 461         m_inspectionClasses.add(SimplifiableConditionalExpressionInspection.class);
 462         m_inspectionClasses.add(SwitchStatementDensityInspection.class);
 463         m_inspectionClasses.add(SwitchStatementInspection.class);
 464         m_inspectionClasses.add(SwitchStatementWithConfusingDeclarationInspection.class);
 465         m_inspectionClasses.add(SwitchStatementWithTooFewBranchesInspection.class);
 466         m_inspectionClasses.add(SwitchStatementWithTooManyBranchesInspection.class);
 467         m_inspectionClasses.add(SwitchStatementsWithoutDefaultInspection.class);
 468         m_inspectionClasses.add(TrivialIfInspection.class);
 469         m_inspectionClasses.add(UnnecessaryConditionalExpressionInspection.class);
 470         m_inspectionClasses.add(UnnecessaryContinueInspection.class);
 471         m_inspectionClasses.add(UnnecessaryDefaultInspection.class);
 472         m_inspectionClasses.add(UnnecessaryLabelOnBreakStatementInspection.class);
 473         m_inspectionClasses.add(UnnecessaryLabelOnContinueStatementInspection.class);
 474         m_inspectionClasses.add(UnnecessaryReturnInspection.class);
 475         m_inspectionClasses.add(UnusedLabelInspection.class);
 476     }
 477
 478     private void registerBugInspections() {
 479         m_inspectionClasses.add(ArchaicSystemPropertyAccessInspection.class);
 480         m_inspectionClasses.add(ArrayEqualsInspection.class);
 481         m_inspectionClasses.add(AssertWithSideEffectsInspection.class);
 482         m_inspectionClasses.add(ConstantAssertConditionInspection.class);
 483         m_inspectionClasses.add(CastConflictsWithInstanceofInspection.class);
 484         m_inspectionClasses.add(CastToIncompatibleInterfaceInspection.class);
 485         m_inspectionClasses.add(ClassNewInstanceInspection.class);
 486         m_inspectionClasses.add(CollectionAddedToSelfInspection.class);
 487         m_inspectionClasses.add(ComparableImplementedButEqualsNotOverriddenInspection.class);
 488         m_inspectionClasses.add(ComparatorMethodParameterNotUsedInspection.class);
 489         m_inspectionClasses.add(CompareToUsesNonFinalVariableInspection.class);
 490         m_inspectionClasses.add(CovariantCompareToInspection.class);
 491         m_inspectionClasses.add(CovariantEqualsInspection.class);
 492         m_inspectionClasses.add(EmptyInitializerInspection.class);
 493         m_inspectionClasses.add(EmptyStatementBodyInspection.class);
 494         m_inspectionClasses.add(EqualsBetweenInconvertibleTypesInspection.class);
 495         m_inspectionClasses.add(EqualsUsesNonFinalVariableInspection.class);
 496         m_inspectionClasses.add(EqualsWhichDoesntCheckParameterClassInspection.class);
 497         m_inspectionClasses.add(ThrowableInstanceNeverThrownInspection.class);
 498         m_inspectionClasses.add(ForLoopThatDoesntUseLoopVariableInspection.class);
 499         m_inspectionClasses.add(HashCodeUsesNonFinalVariableInspection.class);
 500         m_inspectionClasses.add(IgnoreResultOfCallInspection.class);
 501         m_inspectionClasses.add(ImplicitArrayToStringInspection.class);
 502         m_inspectionClasses.add(InfiniteRecursionInspection.class);
 503         m_inspectionClasses.add(InstanceofIncompatibleInterfaceInspection.class);
 504         m_inspectionClasses.add(InstantiationOfUtilityClassInspection.class);
 505         m_inspectionClasses.add(IteratorHasNextCallsIteratorNextInspection.class);
 506         m_inspectionClasses.add(IteratorNextDoesNotThrowNoSuchElementExceptionInspection.class);
 507         m_inspectionClasses.add(MalformedFormatStringInspection.class);
 508         m_inspectionClasses.add(MalformedRegexInspection.class);
 509         if (classExists("javax.xml.xpath.XPath")) {
 510             m_inspectionClasses.add(MalformedXPathInspection.class);
 511         }
 512         m_inspectionClasses.add(MismatchedArrayReadWriteInspection.class);
 513         m_inspectionClasses.add(MismatchedCollectionQueryUpdateInspection.class);
 514         m_inspectionClasses.add(MisspelledCompareToInspection.class);
 515         m_inspectionClasses.add(MisspelledHashcodeInspection.class);
 516         m_inspectionClasses.add(MisspelledEqualsInspection.class);
 517         m_inspectionClasses.add(MisspelledToStringInspection.class);
 518         m_inspectionClasses.add(NewStringBufferWithCharArgumentInspection.class);
 519         m_inspectionClasses.add(NonShortCircuitBooleanInspection.class);
 520         m_inspectionClasses.add(NullArgumentToVariableArgMethodInspection.class);
 521         m_inspectionClasses.add(NumberEqualityInspection.class);
 522         m_inspectionClasses.add(ObjectEqualityInspection.class);
 523         m_inspectionClasses.add(ObjectEqualsNullInspection.class);
 524         m_inspectionClasses.add(ObjectToStringInspection.class);
 525         m_inspectionClasses.add(PrimitiveArrayArgumentToVariableArgMethodInspection.class);
 526         m_inspectionClasses.add(ReflectionForUnavailableAnnotationInspection.class);
 527         m_inspectionClasses.add(ReplaceAllDotInspection.class);
 528         m_inspectionClasses.add(ResultOfObjectAllocationIgnoredInspection.class);
 529         m_inspectionClasses.add(ResultSetIndexZeroInspection.class);
 530         m_inspectionClasses.add(ReturnNullInspection.class);
 531         m_inspectionClasses.add(StaticCallOnSubclassInspection.class);
 532         m_inspectionClasses.add(StaticFieldReferenceOnSubclassInspection.class);
 533         m_inspectionClasses.add(StringEqualityInspection.class);
 534         m_inspectionClasses.add(SubtractionInCompareToInspection.class);
 535         m_inspectionClasses.add(SuspiciousIndentAfterControlStatementInspection.class);
 536         m_inspectionClasses.add(SuspiciousSystemArraycopyInspection.class);
 537         m_inspectionClasses.add(SuspiciousToArrayCallInspection.class);
 538         m_inspectionClasses.add(TextLabelInSwitchStatementInspection.class);
 539         m_inspectionClasses.add(ThrowableResultOfMethodCallIgnoredInspection.class);
 540         m_inspectionClasses.add(UseOfPropertiesAsHashtableInspection.class);
 541         m_inspectionClasses.add(VariableNotUsedInsideIfInspection.class);
 542     }
 543
 544     private static boolean classExists(String className) {
 545         final Class<?> aClass;
 546         try {
 547             aClass = Class.forName(className);
 548         } catch (ClassNotFoundException ignore) {
 549             return false;
 550         }
 551         return aClass != null;
 552     }
 553
 554     private void registerAbstractionInspections() {
 555         m_inspectionClasses.add(CastToConcreteClassInspection.class);
 556         m_inspectionClasses.add(ClassReferencesSubclassInspection.class);
 557         m_inspectionClasses.add(DeclareCollectionAsInterfaceInspection.class);
 558         m_inspectionClasses.add(FeatureEnvyInspection.class);
 559         m_inspectionClasses.add(InstanceVariableOfConcreteClassInspection.class);
 560         m_inspectionClasses.add(InstanceofChainInspection.class);
 561         m_inspectionClasses.add(InstanceofInterfacesInspection.class);
 562         m_inspectionClasses.add(InstanceofThisInspection.class);
 563         m_inspectionClasses.add(LocalVariableOfConcreteClassInspection.class);
 564         m_inspectionClasses.add(MagicNumberInspection.class);
 565         m_inspectionClasses.add(MethodOnlyUsedFromInnerClassInspection.class);
 566         m_inspectionClasses.add(MethodReturnOfConcreteClassInspection.class);
 567         m_inspectionClasses.add(OverlyStrongTypeCastInspection.class);
 568         m_inspectionClasses.add(ParameterOfConcreteClassInspection.class);
 569         m_inspectionClasses.add(PublicMethodNotExposedInInterfaceInspection.class);
 570         m_inspectionClasses.add(StaticMethodOnlyUsedInOneClassInspection.class);
 571         m_inspectionClasses.add(StaticVariableOfConcreteClassInspection.class);
 572         m_inspectionClasses.add(TypeMayBeWeakenedInspection.class);
 573     }
 574
 575     private void registerAssignmentInspections() {
 576         m_inspectionClasses.add(AssignmentToCatchBlockParameterInspection.class);
 577         m_inspectionClasses.add(AssignmentToForLoopParameterInspection.class);
 578         m_inspectionClasses.add(AssignmentToMethodParameterInspection.class);
 579         m_inspectionClasses.add(AssignmentToNullInspection.class);
 580         m_inspectionClasses.add(AssignmentToStaticFieldFromInstanceMethodInspection.class);
 581         m_inspectionClasses.add(AssignmentUsedAsConditionInspection.class);
 582         m_inspectionClasses.add(IncrementDecrementUsedAsExpressionInspection.class);
 583         m_inspectionClasses.add(NestedAssignmentInspection.class);
 584         m_inspectionClasses.add(ReplaceAssignmentWithOperatorAssignmentInspection.class);
 585     }
 586
 587     private void registerJdk5SpecificInspections() {
 588         m_inspectionClasses.add(CollectionsFieldAccessReplaceableByMethodCallInspection .class);
 589         m_inspectionClasses.add(ForCanBeForeachInspection.class);
 590         m_inspectionClasses.add(EnumerationCanBeIterationInspection.class);
 591         m_inspectionClasses.add(IndexOfReplaceableByContainsInspection.class);
 592         m_inspectionClasses.add(RawUseOfParameterizedTypeInspection.class);
 593         m_inspectionClasses.add(UnnecessaryBoxingInspection.class);
 594         m_inspectionClasses.add(UnnecessaryUnboxingInspection.class);
 595         m_inspectionClasses.add(WhileCanBeForeachInspection.class);
 596     }
 597
 598     private void registerClassLayoutInspections() {
 599         m_inspectionClasses.add(AnonymousInnerClassInspection.class);
 600         m_inspectionClasses.add(ClassInTopLevelPackageInspection.class);
 601         m_inspectionClasses.add(ClassInitializerInspection.class);
 602         m_inspectionClasses.add(ClassMayBeInterfaceInspection.class);
 603         m_inspectionClasses.add(ClassNameDiffersFromFileNameInspection.class);
 604         m_inspectionClasses.add(ConstantDeclaredInAbstractClassInspection.class);
 605         m_inspectionClasses.add(ConstantDeclaredInInterfaceInspection.class);
 606         m_inspectionClasses.add(EmptyClassInspection.class);
 607         m_inspectionClasses.add(FinalClassInspection.class);
 608         m_inspectionClasses.add(FinalMethodInFinalClassInspection.class);
 609         m_inspectionClasses.add(FinalMethodInspection.class);
 610         m_inspectionClasses.add(FinalPrivateMethodInspection.class);
 611         m_inspectionClasses.add(FinalStaticMethodInspection.class);
 612         m_inspectionClasses.add(InnerClassOnInterfaceInspection.class);
 613         m_inspectionClasses.add(LimitedScopeInnerClassInspection.class);
 614         m_inspectionClasses.add(ListenerMayUseAdapterInspection.class);
 615         m_inspectionClasses.add(MarkerInterfaceInspection.class);
 616         m_inspectionClasses.add(MissingDeprecatedAnnotationInspection.class);
 617         m_inspectionClasses.add(MissingOverrideAnnotationInspection.class);
 618         m_inspectionClasses.add(MultipleTopLevelClassesInFileInspection.class);
 619         m_inspectionClasses.add(NoopMethodInAbstractClassInspection.class);
 620         m_inspectionClasses.add(ProtectedMemberInFinalClassInspection.class);
 621         m_inspectionClasses.add(PublicConstructorInNonPublicClassInspection.class);
 622         m_inspectionClasses.add(SingletonInspection.class);
 623         m_inspectionClasses.add(StaticNonFinalFieldInspection.class);
 624         m_inspectionClasses.add(UtilityClassInspection.class);
 625         m_inspectionClasses.add(UtilityClassWithPublicConstructorInspection.class);
 626         m_inspectionClasses.add(UtilityClassWithoutPrivateConstructorInspection.class);
 627
 628     }
 629
 630     private void registerInheritanceInspections() {
 631         m_inspectionClasses.add(AbstractClassExtendsConcreteClassInspection.class);
 632         m_inspectionClasses.add(AbstractClassNeverImplementedInspection.class);
 633         m_inspectionClasses.add(AbstractClassWithoutAbstractMethodsInspection.class);
 634         m_inspectionClasses.add(AbstractMethodOverridesAbstractMethodInspection.class);
 635         m_inspectionClasses.add(AbstractMethodOverridesConcreteMethodInspection.class);
 636         m_inspectionClasses.add(AbstractMethodWithMissingImplementationsInspection.class);
 637         m_inspectionClasses.add(ExtendsAnnotationInspection.class);
 638         m_inspectionClasses.add(ExtendsConcreteCollectionInspection.class);
 639         m_inspectionClasses.add(ExtendsUtilityClassInspection.class);
 640         m_inspectionClasses.add(InterfaceNeverImplementedInspection.class);
 641         m_inspectionClasses.add(NonProtectedConstructorInAbstractClassInspection.class);
 642         m_inspectionClasses.add(RedundantMethodOverrideInspection.class);
 643         m_inspectionClasses.add(RefusedBequestInspection.class);
 644         m_inspectionClasses.add(StaticInheritanceInspection.class);
 645         m_inspectionClasses.add(TypeParameterExtendsFinalClassInspection.class);
 646     }
 647
 648     private void registerJavaBeansInspections() {
 649         m_inspectionClasses.add(ClassWithoutConstructorInspection.class);
 650         m_inspectionClasses.add(ClassWithoutNoArgConstructorInspection.class);
 651         m_inspectionClasses.add(FieldHasSetterButNoGetterInspection.class);
 652     }
 653
 654     private void registerCloneInspections() {
 655         m_inspectionClasses.add(CloneCallsConstructorsInspection.class);
 656         m_inspectionClasses.add(CloneCallsSuperCloneInspection.class);
 657         m_inspectionClasses.add(CloneDeclaresCloneNotSupportedInspection.class);
 658         m_inspectionClasses.add(CloneInNonCloneableClassInspection.class);
 659         m_inspectionClasses.add(CloneableImplementsCloneInspection.class);
 660     }
 661
 662     private void registerVisibilityInspections() {
 663         m_inspectionClasses.add(AmbiguousMethodCallInspection.class);
 664         m_inspectionClasses.add(AnonymousClassVariableHidesContainingMethodVariableInspection.class);
 665         m_inspectionClasses.add(ClassEscapesItsScopeInspection.class);
 666         m_inspectionClasses.add(FieldHidesSuperclassFieldInspection.class);
 667         m_inspectionClasses.add(InnerClassVariableHidesOuterClassVariableInspection.class);
 668         m_inspectionClasses.add(LocalVariableHidingMemberVariableInspection.class);
 669         m_inspectionClasses.add(MethodOverridesPackageLocalMethodInspection.class);
 670         m_inspectionClasses.add(MethodOverloadsParentMethodInspection.class);
 671         m_inspectionClasses.add(MethodOverridesPrivateMethodInspection.class);
 672         m_inspectionClasses.add(MethodOverridesStaticMethodInspection.class);
 673         m_inspectionClasses.add(TypeParameterHidesVisibleTypeInspection.class);
 674         m_inspectionClasses.add(ParameterHidingMemberVariableInspection.class);
 675     }
 676
 677     private void registerEncapsulationInspections() {
 678         m_inspectionClasses.add(AssignmentToCollectionFieldFromParameterInspection.class);
 679         m_inspectionClasses.add(AssignmentToDateFieldFromParameterInspection.class);
 680         m_inspectionClasses.add(PackageVisibleFieldInspection.class);
 681         m_inspectionClasses.add(PackageVisibleInnerClassInspection.class);
 682         m_inspectionClasses.add(ProtectedFieldInspection.class);
 683         m_inspectionClasses.add(ProtectedInnerClassInspection.class);
 684         m_inspectionClasses.add(PublicFieldInspection.class);
 685         m_inspectionClasses.add(PublicInnerClassInspection.class);
 686         m_inspectionClasses.add(ReturnOfCollectionFieldInspection.class);
 687         m_inspectionClasses.add(ReturnOfDateFieldInspection.class);
 688         m_inspectionClasses.add(UseOfAnotherObjectsPrivateFieldInspection.class);
 689     }
 690
 691     private void registerInitializerInspections() {
 692         m_inspectionClasses.add(AbstractMethodCallInConstructorInspection.class);
 693         m_inspectionClasses.add(InstanceVariableInitializationInspection.class);
 694         m_inspectionClasses.add(InstanceVariableUninitializedUseInspection.class);
 695         m_inspectionClasses.add(NonFinalStaticVariableUsedInClassInitializationInspection.class);
 696         m_inspectionClasses.add(NonThreadSafeLazyInitializationInspection.class);
 697         m_inspectionClasses.add(OverridableMethodCallDuringObjectConstructionInspection.class);
 698         m_inspectionClasses.add(OverriddenMethodCallDuringObjectConstructionInspection.class);
 699         m_inspectionClasses.add(StaticVariableInitializationInspection.class);
 700         m_inspectionClasses.add(StaticVariableUninitializedUseInspection.class);
 701         m_inspectionClasses.add(ThisEscapedInConstructorInspection.class);
 702     }
 703
 704     private void registerBitwiseInspections() {
 705         m_inspectionClasses.add(IncompatibleMaskInspection.class);
 706         m_inspectionClasses.add(PointlessBitwiseExpressionInspection.class);
 707         m_inspectionClasses.add(ShiftOutOfRangeInspection.class);
 708     }
 709
 710     private void registerStyleInspections() {
 711         m_inspectionClasses.add(CallToStringConcatCanBeReplacedByOperatorInspection.class);
 712         m_inspectionClasses.add(CStyleArrayDeclarationInspection.class);
 713         m_inspectionClasses.add(ChainedEqualityInspection.class);
 714         m_inspectionClasses.add(ChainedMethodCallInspection.class);
 715         m_inspectionClasses.add(ConfusingOctalEscapeInspection.class);
 716         m_inspectionClasses.add(ConstantOnLHSOfComparisonInspection.class);
 717         m_inspectionClasses.add(ConstantOnRHSOfComparisonInspection.class);
 718         m_inspectionClasses.add(ControlFlowStatementWithoutBracesInspection.class);
 719         m_inspectionClasses.add(EqualsCalledOnEnumConstantInspection.class);
 720         m_inspectionClasses.add(ExtendsObjectInspection.class);
 721         m_inspectionClasses.add(FieldMayBeFinalInspection.class);
 722         m_inspectionClasses.add(ImplicitCallToSuperInspection.class);
 723         m_inspectionClasses.add(ListIndexOfReplaceableByContainsInspection.class);
 724         m_inspectionClasses.add(LiteralAsArgToStringEqualsInspection.class);
 725         m_inspectionClasses.add(MissortedModifiersInspection.class);
 726         m_inspectionClasses.add(MultipleDeclarationInspection.class);
 727         m_inspectionClasses.add(MultipleTypedDeclarationInspection.class);
 728         m_inspectionClasses.add(UnnecessaryConstantArrayCreationExpressionInspection.class);
 729         m_inspectionClasses.add(NestedMethodCallInspection.class);
 730         m_inspectionClasses.add(RedundantFieldInitializationInspection.class);
 731         m_inspectionClasses.add(RedundantImplementsInspection.class);
 732         m_inspectionClasses.add(ReturnThisInspection.class);
 733         m_inspectionClasses.add(TypeParameterExtendsObjectInspection.class);
 734         m_inspectionClasses.add(UnnecessarilyQualifiedStaticUsageInspection.class);
 735         m_inspectionClasses.add(UnnecessaryAnnotationParenthesesInspection.class);
 736         m_inspectionClasses.add(UnnecessaryBlockStatementInspection.class);
 737         m_inspectionClasses.add(UnnecessaryCallToStringValueOfInspection.class);
 738         m_inspectionClasses.add(UnnecessaryConstructorInspection.class);
 739         m_inspectionClasses.add(UnnecessaryEnumModifierInspection.class);
 740         m_inspectionClasses.add(UnnecessaryFinalOnLocalVariableInspection.class);
 741         m_inspectionClasses.add(UnnecessaryFinalOnParameterInspection.class);
 742         m_inspectionClasses.add(UnnecessaryFullyQualifiedNameInspection.class);
 743         m_inspectionClasses.add(UnnecessaryInheritDocInspection.class);
 744         m_inspectionClasses.add(UnnecessaryInterfaceModifierInspection.class);
 745         m_inspectionClasses.add(UnnecessaryParenthesesInspection.class);
 746         m_inspectionClasses.add(UnnecessaryQualifierForThisInspection.class);
 747         m_inspectionClasses.add(UnnecessarySemicolonInspection.class);
 748         m_inspectionClasses.add(UnnecessarySuperConstructorInspection.class);
 749         m_inspectionClasses.add(UnnecessarySuperQualifierInspection.class);
 750         m_inspectionClasses.add(UnnecessaryThisInspection.class);
 751         m_inspectionClasses.add(UnqualifiedFieldAccessInspection.class);
 752         m_inspectionClasses.add(UnqualifiedStaticUsageInspection.class);
 753     }
 754
 755     private void registerDataFlowInspections() {
 756         m_inspectionClasses.add(ConstantValueVariableUseInspection .class);
 757         m_inspectionClasses.add(LawOfDemeterInspection.class);
 758         m_inspectionClasses.add(OrredNotEqualExpressionInspection.class);
 759         m_inspectionClasses.add(ReuseOfLocalVariableInspection.class);
 760         m_inspectionClasses.add(TooBroadScopeInspection.class);
 761         m_inspectionClasses.add(UnnecessaryLocalVariableInspection.class);
 762     }
 763
 764     private void registerErrorHandlingInspections() {
 765         m_inspectionClasses.add(BadExceptionCaughtInspection.class);
 766         m_inspectionClasses.add(BadExceptionDeclaredInspection.class);
 767         m_inspectionClasses.add(BadExceptionThrownInspection.class);
 768         m_inspectionClasses.add(CatchGenericClassInspection.class);
 769         m_inspectionClasses.add(CaughtExceptionImmediatelyRethrownInspection.class);
 770         m_inspectionClasses.add(CheckedExceptionClassInspection.class);
 771         m_inspectionClasses.add(ContinueOrBreakFromFinallyBlockInspection.class);
 772         m_inspectionClasses.add(EmptyCatchBlockInspection.class);
 773         m_inspectionClasses.add(EmptyFinallyBlockInspection.class);
 774         m_inspectionClasses.add(EmptyTryBlockInspection.class);
 775         m_inspectionClasses.add(ErrorRethrownInspection.class);
 776         m_inspectionClasses.add(ExceptionFromCatchWhichDoesntWrapInspection.class);
 777         m_inspectionClasses.add(FinallyBlockCannotCompleteNormallyInspection.class);
 778         m_inspectionClasses.add(InstanceofCatchParameterInspection.class);
 779         m_inspectionClasses.add(NestedTryStatementInspection.class);
 780         m_inspectionClasses.add(NonFinalFieldOfExceptionInspection.class);
 781         m_inspectionClasses.add(ReturnFromFinallyBlockInspection.class);
 782         m_inspectionClasses.add(ThreadDeathRethrownInspection.class);
 783         m_inspectionClasses.add(ThrowCaughtLocallyInspection.class);
 784         m_inspectionClasses.add(ThrowFromFinallyBlockInspection.class);
 785         m_inspectionClasses.add(TooBroadCatchInspection.class);
 786         m_inspectionClasses.add(UncheckedExceptionClassInspection.class);
 787         m_inspectionClasses.add(UnusedCatchParameterInspection.class);
 788     }
 789
 790     private void registerFinalizationInspections() {
 791         m_inspectionClasses.add(FinalizeCallsSuperFinalizeInspection.class);
 792         m_inspectionClasses.add(FinalizeInspection.class);
 793         m_inspectionClasses.add(FinalizeNotProtectedInspection.class);
 794         m_inspectionClasses.add(NoExplicitFinalizeCallsInspection.class);
 795     }
 796
 797     private void registerSerializationInspections() {
 798         m_inspectionClasses.add(ComparatorNotSerializableInspection.class);
 799         m_inspectionClasses.add(ExternalizableWithSerializationMethodsInspection.class);
 800         m_inspectionClasses.add(NonSerializableFieldInSerializableClassInspection.class);
 801         m_inspectionClasses.add(NonSerializableObjectBoundToHttpSessionInspection.class);
 802         m_inspectionClasses.add(NonSerializableObjectPassedToObjectStreamInspection.class);
 803         m_inspectionClasses.add(NonSerializableWithSerialVersionUIDFieldInspection.class);
 804         m_inspectionClasses.add(NonSerializableWithSerializationMethodsInspection.class);
 805         m_inspectionClasses.add(ReadObjectAndWriteObjectPrivateInspection.class);
 806         m_inspectionClasses.add(ReadObjectInitializationInspection.class);
 807         m_inspectionClasses.add(ReadResolveAndWriteReplaceProtectedInspection.class);
 808         m_inspectionClasses.add(SerialPersistentFieldsWithWrongSignatureInspection.class);
 809         m_inspectionClasses.add(SerialVersionUIDNotStaticFinalInspection.class);
 810         m_inspectionClasses.add(SerializableHasSerialVersionUIDFieldInspection.class);
 811         m_inspectionClasses.add(SerializableHasSerializationMethodsInspection.class);
 812         m_inspectionClasses.add(SerializableInnerClassHasSerialVersionUIDFieldInspection.class);
 813         m_inspectionClasses.add(SerializableInnerClassWithNonSerializableOuterClassInspection.class);
 814         m_inspectionClasses.add(SerializableWithUnconstructableAncestorInspection.class);
 815         m_inspectionClasses.add(TransientFieldInNonSerializableClassInspection.class);
 816         m_inspectionClasses.add(TransientFieldNotInitializedInspection.class);
 817     }
 818
 819     private void registerThreadingInspections() {
 820         m_inspectionClasses.add(AccessToNonThreadSafeStaticFieldFromInstanceInspection.class);
 821         m_inspectionClasses.add(AccessToStaticFieldLockedOnInstanceInspection.class);
 822         m_inspectionClasses.add(ArithmeticOnVolatileFieldInspection.class);
 823         m_inspectionClasses.add(AwaitNotInLoopInspection.class);
 824         m_inspectionClasses.add(AwaitWithoutCorrespondingSignalInspection.class);
 825         m_inspectionClasses.add(BusyWaitInspection.class);
 826         m_inspectionClasses.add(CallToNativeMethodWhileLockedInspection.class);
 827         m_inspectionClasses.add(ConditionSignalInspection.class);
 828         m_inspectionClasses.add(DoubleCheckedLockingInspection.class);
 829         m_inspectionClasses.add(EmptySynchronizedStatementInspection.class);
 830         m_inspectionClasses.add(ExtendsThreadInspection.class);
 831         m_inspectionClasses.add(FieldAccessedSynchronizedAndUnsynchronizedInspection.class);
 832         m_inspectionClasses.add(MethodMayBeSynchronizedInspection.class);
 833         m_inspectionClasses.add(NakedNotifyInspection.class);
 834         m_inspectionClasses.add(NestedSynchronizedStatementInspection.class);
 835         m_inspectionClasses.add(NonSynchronizedMethodOverridesSynchronizedMethodInspection.class);
 836         m_inspectionClasses.add(NotifyCalledOnConditionInspection.class);
 837         m_inspectionClasses.add(NotifyNotInSynchronizedContextInspection.class);
 838         m_inspectionClasses.add(NotifyWithoutCorrespondingWaitInspection.class);
 839         m_inspectionClasses.add(ObjectNotifyInspection.class);
 840         m_inspectionClasses.add(PublicFieldAccessedInSynchronizedContextInspection.class);
 841         m_inspectionClasses.add(SafeLockInspection.class);
 842         m_inspectionClasses.add(SignalWithoutCorrespondingAwaitInspection.class);
 843         m_inspectionClasses.add(SleepWhileHoldingLockInspection.class);
 844         m_inspectionClasses.add(SynchronizationOnLocalVariableOrMethodParameterInspection .class);
 845         m_inspectionClasses.add(SynchronizeOnLockInspection.class);
 846         m_inspectionClasses.add(SynchronizeOnNonFinalFieldInspection.class);
 847         m_inspectionClasses.add(SynchronizedOnLiteralObjectInspection.class);
 848         m_inspectionClasses.add(SynchronizeOnThisInspection.class);
 849         m_inspectionClasses.add(SynchronizedMethodInspection.class);
 850         m_inspectionClasses.add(SystemRunFinalizersOnExitInspection.class);
 851         m_inspectionClasses.add(ThreadPriorityInspection.class);
 852         m_inspectionClasses.add(ThreadRunInspection.class);
 853         m_inspectionClasses.add(ThreadStartInConstructionInspection.class);
 854         m_inspectionClasses.add(ThreadStopSuspendResumeInspection.class);
 855         m_inspectionClasses.add(ThreadWithDefaultRunMethodInspection.class);
 856         m_inspectionClasses.add(ThreadYieldInspection.class);
 857         m_inspectionClasses.add(UnconditionalWaitInspection.class);
 858         m_inspectionClasses.add(VolatileArrayFieldInspection.class);
 859         m_inspectionClasses.add(VolatileLongOrDoubleFieldInspection.class);
 860         m_inspectionClasses.add(WaitCalledOnConditionInspection.class);
 861         m_inspectionClasses.add(WaitNotInLoopInspection.class);
 862         m_inspectionClasses.add(WaitNotInSynchronizedContextInspection.class);
 863         m_inspectionClasses.add(WaitOrAwaitWithoutTimeoutInspection.class);
 864         m_inspectionClasses.add(WaitWhileHoldingTwoLocksInspection.class);
 865         m_inspectionClasses.add(WaitWithoutCorrespondingNotifyInspection.class);
 866         m_inspectionClasses.add(WhileLoopSpinsOnFieldInspection.class);
 867     }
 868
 869     private void registerMethodMetricsInspections() {
 870         m_inspectionClasses.add(ParametersPerConstructorInspection.class);
 871         m_inspectionClasses.add(CyclomaticComplexityInspection.class);
 872         m_inspectionClasses.add(MethodCouplingInspection.class);
 873         m_inspectionClasses.add(MethodWithMultipleLoopsInspection.class);
 874         m_inspectionClasses.add(MultipleReturnPointsPerMethodInspection.class);
 875         m_inspectionClasses.add(NestingDepthInspection.class);
 876         m_inspectionClasses.add(NonCommentSourceStatementsInspection.class);
 877         m_inspectionClasses.add(ParametersPerMethodInspection.class);
 878         m_inspectionClasses.add(ThreeNegationsPerMethodInspection.class);
 879         m_inspectionClasses.add(ThrownExceptionsPerMethodInspection.class);
 880     }
 881
 882     private void registerClassMetricsInspections() {
 883         m_inspectionClasses.add(AnonymousClassComplexityInspection.class);
 884         m_inspectionClasses.add(AnonymousClassMethodCountInspection.class);
 885         m_inspectionClasses.add(ClassComplexityInspection.class);
 886         m_inspectionClasses.add(ClassCouplingInspection.class);
 887         m_inspectionClasses.add(ClassInheritanceDepthInspection.class);
 888         m_inspectionClasses.add(ClassNestingDepthInspection.class);
 889         m_inspectionClasses.add(ConstructorCountInspection.class);
 890         m_inspectionClasses.add(FieldCountInspection.class);
 891         m_inspectionClasses.add(MethodCountInspection.class);
 892     }
 893
 894     private void registerPortabilityInspections() {
 895         m_inspectionClasses.add(HardcodedFileSeparatorsInspection.class);
 896         m_inspectionClasses.add(HardcodedLineSeparatorsInspection.class);
 897         m_inspectionClasses.add(NativeMethodsInspection.class);
 898         m_inspectionClasses.add(RuntimeExecInspection.class);
 899         m_inspectionClasses.add(SystemExitInspection.class);
 900         m_inspectionClasses.add(SystemGetenvInspection.class);
 901         m_inspectionClasses.add(UseOfAWTPeerClassInspection.class);
 902         m_inspectionClasses.add(UseOfJDBCDriverClassInspection.class);
 903         m_inspectionClasses.add(UseOfProcessBuilderInspection.class);
 904         m_inspectionClasses.add(UseOfSunClassesInspection.class);
 905     }
 906
 907     private void registerJdkInspections() {
 908         m_inspectionClasses.add(AnnotationClassInspection.class);
 909         m_inspectionClasses.add(AnnotationInspection.class);
 910         m_inspectionClasses.add(AssertAsNameInspection.class);
 911         m_inspectionClasses.add(AssertStatementInspection.class);
 912         m_inspectionClasses.add(AutoBoxingInspection.class);
 913         m_inspectionClasses.add(AutoUnboxingInspection.class);
 914         m_inspectionClasses.add(EnumAsNameInspection.class);
 915         m_inspectionClasses.add(EnumClassInspection.class);
 916         m_inspectionClasses.add(ForeachStatementInspection.class);
 917         m_inspectionClasses.add(VarargParameterInspection.class);
 918     }
 919
 920     private void registerInternationalInspections() {
 921         m_inspectionClasses.add(CharacterComparisonInspection.class);
 922         m_inspectionClasses.add(DateToStringInspection.class);
 923         m_inspectionClasses.add(MagicCharacterInspection.class);
 924         m_inspectionClasses.add(NumericToStringInspection.class);
 925         m_inspectionClasses.add(SimpleDateFormatWithoutLocaleInspection.class);
 926         m_inspectionClasses.add(StringCompareToInspection.class);
 927         m_inspectionClasses.add(StringConcatenationInspection.class);
 928         m_inspectionClasses.add(StringEqualsIgnoreCaseInspection.class);
 929         m_inspectionClasses.add(StringEqualsInspection.class);
 930         m_inspectionClasses.add(StringToUpperWithoutLocaleInspection.class);
 931         m_inspectionClasses.add(StringTokenizerInspection.class);
 932         m_inspectionClasses.add(TimeToStringInspection.class);
 933     }
 934
 935     private void registerPerformanceInspections() {
 936         m_inspectionClasses.add(BooleanConstructorInspection.class);
 937         m_inspectionClasses.add(CallToSimpleGetterInClassInspection.class);
 938         m_inspectionClasses.add(CallToSimpleSetterInClassInspection.class);
 939         m_inspectionClasses.add(CollectionContainsUrlInspection.class);
 940         m_inspectionClasses.add(CollectionsMustHaveInitialCapacityInspection.class);
 941         m_inspectionClasses.add(ConstantStringInternInspection.class);
 942         m_inspectionClasses.add(DynamicRegexReplaceableByCompiledPatternInspection.class);
 943         m_inspectionClasses.add(EqualsHashCodeCalledOnUrlInspection.class);
 944         m_inspectionClasses.add(FieldMayBeStaticInspection.class);
 945         m_inspectionClasses.add(InnerClassMayBeStaticInspection.class);
 946         m_inspectionClasses.add(InstantiatingObjectToGetClassObjectInspection.class);
 947         m_inspectionClasses.add(JavaLangReflectInspection.class);
 948         m_inspectionClasses.add(KeySetIterationMayUseEntrySetInspection.class);
 949         m_inspectionClasses.add(LengthOneStringInIndexOfInspection.class);
 950         m_inspectionClasses.add(LengthOneStringsInConcatenationInspection.class);
 951         m_inspectionClasses.add(ManualArrayToCollectionCopyInspection.class);
 952         m_inspectionClasses.add(ManualArrayCopyInspection.class);
 953         m_inspectionClasses.add(MapReplaceableByEnumMapInspection.class);
 954         m_inspectionClasses.add(MethodMayBeStaticInspection.class);
 955         m_inspectionClasses.add(ClassInitializerMayBeStaticInspection.class);
 956         m_inspectionClasses.add(ObjectAllocationInLoopInspection.class);
 957         m_inspectionClasses.add(RandomDoubleForRandomIntegerInspection.class);
 958         m_inspectionClasses.add(RedundantStringFormatCallInspection.class);
 959         m_inspectionClasses.add(SetReplaceableByEnumSetInspection.class);
 960         m_inspectionClasses.add(SizeReplaceableByIsEmptyInspection.class);
 961         m_inspectionClasses.add(StringBufferMustHaveInitialCapacityInspection.class);
 962         m_inspectionClasses.add(StringBufferReplaceableByStringBuilderInspection.class);
 963         m_inspectionClasses.add(StringBufferReplaceableByStringInspection.class);
 964         m_inspectionClasses.add(StringBufferToStringInConcatenationInspection.class);
 965         m_inspectionClasses.add(StringConcatenationInLoopsInspection.class);
 966         m_inspectionClasses.add(StringConcatenationInsideStringBufferAppendInspection.class);
 967         m_inspectionClasses.add(StringConstructorInspection.class);
 968         m_inspectionClasses.add(StringEqualsEmptyStringInspection.class);
 969         m_inspectionClasses.add(StringReplaceableByStringBufferInspection.class);
 970         m_inspectionClasses.add(StringToStringInspection.class);
 971         m_inspectionClasses.add(SubstringZeroInspection.class);
 972         m_inspectionClasses.add(TailRecursionInspection.class);
 973         m_inspectionClasses.add(ToArrayCallWithZeroLengthArrayArgumentInspection.class);
 974         m_inspectionClasses.add(TrivialStringConcatenationInspection.class);
 975         m_inspectionClasses.add(UnnecessaryTemporaryOnConversionToStringInspection.class);
 976         m_inspectionClasses.add(UnnecessaryTemporaryOnConversionFromStringInspection.class);
 977     }
 978
 979     private void registerMemoryInspections() {
 980         m_inspectionClasses.add(StaticCollectionInspection.class);
 981         m_inspectionClasses.add(StringBufferFieldInspection.class);
 982         m_inspectionClasses.add(SystemGCInspection.class);
 983         m_inspectionClasses.add(ZeroLengthArrayInitializationInspection.class);
 984     }
 985
 986     private void registerJ2MEInspections() {
 987         m_inspectionClasses.add(AbstractClassWithOnlyOneDirectInheritorInspection.class);
 988         m_inspectionClasses.add(AnonymousInnerClassMayBeStaticInspection.class);
 989         m_inspectionClasses.add(ArrayLengthInLoopConditionInspection.class);
 990         m_inspectionClasses.add(CheckForOutOfMemoryOnLargeArrayAllocationInspection.class);
 991         m_inspectionClasses.add(ConnectionResourceInspection.class);
 992         m_inspectionClasses.add(FieldRepeatedlyAccessedInspection.class);
 993         m_inspectionClasses.add(InterfaceWithOnlyOneDirectInheritorInspection.class);
 994         m_inspectionClasses.add(MethodCallInLoopConditionInspection.class);
 995         m_inspectionClasses.add(MultiplyOrDivideByPowerOfTwoInspection.class);
 996         m_inspectionClasses.add(OverlyLargePrimitiveArrayInitializerInspection.class);
 997         m_inspectionClasses.add(PrivateMemberAccessBetweenOuterAndInnerClassInspection.class);
 998         m_inspectionClasses.add(RecordStoreResourceInspection.class);
 999         m_inspectionClasses.add(SimplifiableIfStatementInspection.class);
1000         m_inspectionClasses.add(SingleCharacterStartsWithInspection.class);
1001     }
1002
1003     private void registerMaturityInspections() {
1004         m_inspectionClasses.add(SuppressionAnnotationInspection.class);
1005         m_inspectionClasses.add(SystemOutErrInspection.class);
1006         m_inspectionClasses.add(ThrowablePrintStackTraceInspection.class);
1007         m_inspectionClasses.add(TodoCommentInspection.class);
1008         m_inspectionClasses.add(ThreadDumpStackInspection.class);
1009         //m_inspectionClasses.add(ClassWithoutToStringInspection.class);
1010         //   - the same inspection is provided by "Generate toString()" plugin, and the other version has a quickfix
1011         m_inspectionClasses.add(ObsoleteCollectionInspection.class);
1012     }
1013
1014     private void registerNumericInspections() {
1015         m_inspectionClasses.add(BadOddnessInspection.class);
1016         m_inspectionClasses.add(BigDecimalEqualsInspection.class);
1017         m_inspectionClasses.add(CachedNumberConstructorCallInspection.class);
1018         m_inspectionClasses.add(CastThatLosesPrecisionInspection.class);
1019         m_inspectionClasses.add(CharUsedInArithmeticContextInspection.class);
1020         m_inspectionClasses.add(ComparisonOfShortAndCharInspection.class);
1021         m_inspectionClasses.add(ComparisonToNaNInspection.class);
1022         m_inspectionClasses.add(ConfusingFloatingPointLiteralInspection.class);
1023         m_inspectionClasses.add(ConstantMathCallInspection.class);
1024         m_inspectionClasses.add(DivideByZeroInspection.class);
1025         m_inspectionClasses.add(FloatingPointEqualityInspection.class);
1026         m_inspectionClasses.add(ImplicitNumericConversionInspection.class);
1027         m_inspectionClasses.add(IntegerDivisionInFloatingPointContextInspection.class);
1028         m_inspectionClasses.add(IntegerMultiplicationImplicitCastToLongInspection.class);
1029         m_inspectionClasses.add(IntLiteralMayBeLongLiteralInspection.class);
1030         m_inspectionClasses.add(LongLiteralsEndingWithLowercaseLInspection.class);
1031         m_inspectionClasses.add(NonReproducibleMathCallInspection.class);
1032         m_inspectionClasses.add(OctalLiteralInspection.class);
1033         m_inspectionClasses.add(OctalAndDecimalIntegersMixedInspection.class);
1034         m_inspectionClasses.add(OverlyComplexArithmeticExpressionInspection.class);
1035         m_inspectionClasses.add(PointlessArithmeticExpressionInspection.class);
1036         m_inspectionClasses.add(UnaryPlusInspection.class);
1037         m_inspectionClasses.add(UnnecessaryUnaryMinusInspection.class);
1038         m_inspectionClasses.add(UnpredictableBigDecimalConstructorCallInspection.class);
1039     }
1040
1041     private void registerJUnitInspections() {
1042         m_inspectionClasses.add(AssertEqualsBetweenInconvertibleTypesInspection.class);
1043         m_inspectionClasses.add(AssertEqualsMayBeAssertSameInspection.class);
1044         m_inspectionClasses.add(AssertsWithoutMessagesInspection.class);
1045         m_inspectionClasses.add(BeforeClassOrAfterClassIsPublicStaticVoidNoArgInspection.class);
1046         m_inspectionClasses.add(BeforeOrAfterIsPublicVoidNoArgInspection.class);
1047         m_inspectionClasses.add(ParameterizedParametersStaticCollectionInspection.class);
1048         m_inspectionClasses.add(ConstantJUnitAssertArgumentInspection.class);
1049         m_inspectionClasses.add(JUnit4AnnotatedMethodInJUnit3TestCaseInspection.class);
1050         m_inspectionClasses.add(JUnitAbstractTestClassNamingConventionInspection.class);
1051         m_inspectionClasses.add(JUnitTestClassNamingConventionInspection.class);
1052         m_inspectionClasses.add(MisspelledSetUpInspection.class);
1053         m_inspectionClasses.add(MisspelledTearDownInspection.class);
1054         m_inspectionClasses.add(MisorderedAssertEqualsParametersInspection.class);
1055         m_inspectionClasses.add(MultipleExceptionsDeclaredOnTestMethodInspection.class);
1056         m_inspectionClasses.add(TestCaseWithConstructorInspection.class);
1057         m_inspectionClasses.add(SetupCallsSuperSetupInspection.class);
1058         m_inspectionClasses.add(SetupIsPublicVoidNoArgInspection.class);
1059         m_inspectionClasses.add(SimplifiableJUnitAssertionInspection.class);
1060         m_inspectionClasses.add(StaticSuiteInspection.class);
1061         m_inspectionClasses.add(TestCaseInProductCodeInspection.class);
1062         m_inspectionClasses.add(TestCaseWithNoTestMethodsInspection.class);
1063         m_inspectionClasses.add(TeardownCallsSuperTeardownInspection.class);
1064         m_inspectionClasses.add(TeardownIsPublicVoidNoArgInspection.class);
1065         m_inspectionClasses.add(TestMethodInProductCodeInspection.class);
1066         m_inspectionClasses.add(TestMethodIsPublicVoidNoArgInspection.class);
1067         m_inspectionClasses.add(TestMethodWithoutAssertionInspection.class);
1068         m_inspectionClasses.add(UnconstructableTestCaseInspection.class);
1069     }
1070
1071     public void disposeComponent() {
1072     }
1073
1074     public static boolean isTelemetryEnabled() {
1075         return TELEMETRY_ENABLED;
1076     }
1077
1078     public InspectionGadgetsTelemetry getTelemetry() {
1079         return telemetry;
1080     }
1081 }