clang plugin: Put inner classes bugfix behind a flag.

tools/clang/plugins/FindBadConstructs.cpp

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file defines a bunch of recurring problems in the Chromium C++ code.
 //
 // Checks that are implemented:
 // - Constructors/Destructors should not be inlined if they are of a complex
 //   class type.
 // - Missing "virtual" keywords on methods that should be virtual.
@@ skipping 32 matching lines @@
   if (const TypedefType* typedefed = dyn_cast<TypedefType>(type))
     return UnwrapType(typedefed->desugar().getTypePtr());
   return type;
 }
 
 // Searches for constructs that we know we don't want in the Chromium code base.
 class FindBadConstructsConsumer : public ChromeClassTester {
  public:
   FindBadConstructsConsumer(CompilerInstance& instance,
                             bool check_refcounted_dtors,
-                            bool check_virtuals_in_implementations)
-      : ChromeClassTester(instance),
+                            bool check_virtuals_in_implementations,
+                            bool check_inner_classes)
+      : ChromeClassTester(instance, check_inner_classes),
         check_refcounted_dtors_(check_refcounted_dtors),
         check_virtuals_in_implementations_(check_virtuals_in_implementations) {
   }
 
   virtual void CheckChromeClass(SourceLocation record_location,
                                 CXXRecordDecl* record) {
     bool implementation_file = InImplementationFile(record_location);
 
     if (!implementation_file) {
       // Only check for "heavy" constructors/destructors in header files;
@@ skipping 323 matching lines @@
         break;
       }
     }
   }
 };
 
 class FindBadConstructsAction : public PluginASTAction {
  public:
   FindBadConstructsAction()
       : check_refcounted_dtors_(true),
-        check_virtuals_in_implementations_(true) {
+        check_virtuals_in_implementations_(true),
+        check_inner_classes_(false) {
   }
 
  protected:
   // Overridden from PluginASTAction:
   virtual ASTConsumer* CreateASTConsumer(CompilerInstance& instance,
                                          llvm::StringRef ref) {
     return new FindBadConstructsConsumer(
-        instance, check_refcounted_dtors_, check_virtuals_in_implementations_);
+        instance, check_refcounted_dtors_, check_virtuals_in_implementations_,
+        check_inner_classes_);
   }
 
   virtual bool ParseArgs(const CompilerInstance& instance,
                          const std::vector<std::string>& args) {
     bool parsed = true;
 
     for (size_t i = 0; i < args.size() && parsed; ++i) {
       if (args[i] == "skip-refcounted-dtors") {
         check_refcounted_dtors_ = false;
       } else if (args[i] == "skip-virtuals-in-implementations") {
         check_virtuals_in_implementations_ = false;
+      } else if (args[i] == "check-inner-classes") {
+        check_inner_classes_ = true;
       } else {
         parsed = false;
         llvm::errs() << "Unknown argument: " << args[i] << "\n";
       }
     }
 
     return parsed;
   }
 
  private:
   bool check_refcounted_dtors_;
   bool check_virtuals_in_implementations_;
+  bool check_inner_classes_;
 };
 
 }  // namespace
 
 static FrontendPluginRegistry::Add<FindBadConstructsAction>
 X("find-bad-constructs", "Finds bad C++ constructs");