Refactor banned directory checking so Blink can opt into certain checks.

tools/clang/plugins/FindBadConstructsConsumer.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.
 
 #include "FindBadConstructsConsumer.h"
 
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/AST/Attr.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Sema/Sema.h"
@@ skipping 198 matching lines @@
 bool FindBadConstructsConsumer::VisitCallExpr(CallExpr* call_expr) {
   if (ipc_visitor_) ipc_visitor_->VisitCallExpr(call_expr);
   return true;
 }
 
 bool FindBadConstructsConsumer::VisitVarDecl(clang::VarDecl* var_decl) {
   CheckVarDecl(var_decl);
   return true;
 }
 
-void FindBadConstructsConsumer::CheckChromeClass(SourceLocation record_location,
+void FindBadConstructsConsumer::CheckChromeClass(LocationType location_type,
+                                                 SourceLocation record_location,
                                                  CXXRecordDecl* record) {
+  // TODO(dcheng): After emitWarning() is removed, move warning filtering into
+  // ReportIfSpellingLocNotIgnored.
+  if (location_type == LocationType::kBlink)
+    return;
+
   bool implementation_file = InImplementationFile(record_location);
 
   if (!implementation_file) {
     // Only check for "heavy" constructors/destructors in header files;
     // within implementation files, there is no performance cost.
 
     // If this is a POD or a class template or a type dependent on a
     // templated class, assume there's no ctor/dtor/virtual method
     // optimization that we should do.
     if (!IsPodOrTemplateType(*record))
       CheckCtorDtorWeight(record_location, record);
   }
 
   bool warn_on_inline_bodies = !implementation_file;
   // Check that all virtual methods are annotated with override or final.
   // Note this could also apply to templates, but for some reason Clang
   // does not always see the "override", so we get false positives.
   // See http://llvm.org/bugs/show_bug.cgi?id=18440 and
   //     http://llvm.org/bugs/show_bug.cgi?id=21942
   if (!IsPodOrTemplateType(*record))
     CheckVirtualMethods(record_location, record, warn_on_inline_bodies);
 
   CheckRefCountedDtors(record_location, record);
 
   CheckWeakPtrFactoryMembers(record_location, record);
 }
 
-void FindBadConstructsConsumer::CheckChromeEnum(SourceLocation enum_location,
+void FindBadConstructsConsumer::CheckChromeEnum(LocationType location_type,
+                                                SourceLocation enum_location,
                                                 EnumDecl* enum_decl) {
   if (!options_.check_enum_last_value)
     return;
 
+  if (location_type == LocationType::kBlink)
+    return;
+
   bool got_one = false;
   bool is_signed = false;
   llvm::APSInt max_so_far;
   EnumDecl::enumerator_iterator iter;
   for (iter = enum_decl->enumerator_begin();
        iter != enum_decl->enumerator_end();
        ++iter) {
     llvm::APSInt current_value = iter->getInitVal();
     if (!got_one) {
       max_so_far = current_value;
@@ skipping 181 matching lines @@
     }
   }
 
   return false;
 }
 
 SuppressibleDiagnosticBuilder
 FindBadConstructsConsumer::ReportIfSpellingLocNotIgnored(
     SourceLocation loc,
     unsigned diagnostic_id) {
-  return SuppressibleDiagnosticBuilder(
-      &diagnostic(), loc, diagnostic_id,
-      InBannedDirectory(instance().getSourceManager().getSpellingLoc(loc)));
+  LocationType type =
+      ClassifyLocation(instance().getSourceManager().getSpellingLoc(loc));
+  bool ignored = type == LocationType::kIgnored || type == LocationType::kBlink;

[dcheng, 2017/03/29 04:18:40]

In the future, when location type is kBlink, we won't set ignore to true for
certain diagnostic IDs.

+  return SuppressibleDiagnosticBuilder(&diagnostic(), loc, diagnostic_id,
+                                       ignored);
 }
 
 // Checks that virtual methods are correctly annotated, and have no body in a
 // header file.
 void FindBadConstructsConsumer::CheckVirtualMethods(
     SourceLocation record_location,
     CXXRecordDecl* record,
     bool warn_on_inline_bodies) {
   // Gmock objects trigger these for each MOCK_BLAH() macro used. So we have a
   // trick to get around that. If a class has member variables whose types are
@@ skipping 135 matching lines @@
   if (method->hasBody() && method->hasInlineBody()) {
     if (CompoundStmt* cs = dyn_cast<CompoundStmt>(method->getBody())) {
       if (cs->size()) {
         SourceLocation loc = cs->getLBracLoc();
         // CR_BEGIN_MSG_MAP_EX and BEGIN_SAFE_MSG_MAP_EX try to be compatible
         // to BEGIN_MSG_MAP(_EX).  So even though they are in chrome code,
         // we can't easily fix them, so explicitly whitelist them here.
         bool emit = true;
         if (loc.isMacroID()) {
           SourceManager& manager = instance().getSourceManager();
-          if (InBannedDirectory(manager.getSpellingLoc(loc)))
+          LocationType type = ClassifyLocation(manager.getSpellingLoc(loc));
+          if (type == LocationType::kIgnored || type == LocationType::kBlink)

[dcheng, 2017/03/29 04:18:40]

Ditto: this is needed for now, but this should be delegating to
ReportIfSpellingLocNotIgnored(). I'll remove emitWarning() in a followup,
eliminating this check.

             emit = false;
           else {
             StringRef name = Lexer::getImmediateMacroName(
                 loc, manager, instance().getLangOpts());
             if (name == "CR_BEGIN_MSG_MAP_EX" ||
                 name == "BEGIN_SAFE_MSG_MAP_EX")
               emit = false;
           }
         }
         if (emit)
@@ skipping 368 matching lines @@
     const clang::AutoType* auto_type =
         non_reference_type->getAs<clang::AutoType>();
     if (auto_type) {
       if (auto_type->isDeduced()) {
         QualType deduced_type = auto_type->getDeducedType();
         if (!deduced_type.isNull() && deduced_type->isPointerType() &&
             !deduced_type->isFunctionPointerType()) {
           // Check if we should even be considering this type (note that there
           // should be fewer auto types than banned namespace/directory types,
           // so check this last.
+          LocationType location_type =
+              ClassifyLocation(var_decl->getLocStart());
           if (!InBannedNamespace(var_decl) &&
-              !InBannedDirectory(var_decl->getLocStart())) {
+              location_type != LocationType::kIgnored) {

[dcheng, 2017/03/29 04:18:40]

Note: We only ignore kIgnored here: kBlink gets filtered out by the
ReportIfSpellingLocNotIgnored() checks.

             // The range starts from |var_decl|'s loc start, which is the
             // beginning of the full expression defining this |var_decl|. It
             // ends, however, where this |var_decl|'s type loc ends, since
             // that's the end of the type of |var_decl|.
             // Note that the beginning source location of type loc omits cv
             // qualifiers, which is why it's not a good candidate to use for the
             // start of the range.
             clang::SourceRange range(
                 var_decl->getLocStart(),
                 var_decl->getTypeSourceInfo()->getTypeLoc().getLocEnd());
             ReportIfSpellingLocNotIgnored(range.getBegin(),
                                           diag_auto_deduced_to_a_pointer_type_)
                 << FixItHint::CreateReplacement(
                        range,
                        GetAutoReplacementTypeAsString(
                            var_decl->getType(), var_decl->getStorageClass()));
           }
         }
       }
     } else if (non_reference_type->isPointerType()) {
       non_reference_type = non_reference_type->getPointeeType();
       continue;
     }
     break;
   }
 }
 
 }  // namespace chrome_checker