Clang plugin: Support for Blink in web/.

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 442 matching lines @@
       return true;
     }
   }
 
   return false;
 }
 
 SuppressibleDiagnosticBuilder
 FindBadConstructsConsumer::ReportIfSpellingLocNotIgnored(
     SourceLocation loc,
+    const Decl* record,
     unsigned diagnostic_id) {
-  LocationType type =
-      ClassifyLocation(instance().getSourceManager().getSpellingLoc(loc));
+  LocationType type = ClassifyLocation(
+      instance().getSourceManager().getSpellingLoc(loc), record);
   bool ignored =
       type == LocationType::kThirdParty || type == LocationType::kBlink;
   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,
@@ skipping 51 matching lines @@
 
   SourceManager& manager = instance().getSourceManager();
   const LangOptions& lang_opts = instance().getLangOpts();
 
   // Complain if a method is annotated virtual && (override || final).
   if (has_virtual && (override_attr || final_attr)) {
     // ... but only if virtual does not originate in a macro from a banned file.
     // Note this is just an educated guess: the assumption here is that any
     // macro for declaring methods will probably be at the start of the method's
     // source range.
-    ReportIfSpellingLocNotIgnored(method->getLocStart(),
+    ReportIfSpellingLocNotIgnored(method->getLocStart(), method,
                                   diag_redundant_virtual_specifier_)
         << "'virtual'"
         << (override_attr ? static_cast<Attr*>(override_attr) : final_attr)
         << FixItRemovalForVirtual(manager, lang_opts, method);
   }
 
   // Complain if a method is an override and is not annotated with override or
   // final.
   if (is_override && !override_attr && !final_attr) {
     SourceRange range = method->getSourceRange();
@@ skipping 30 matching lines @@
           break;
         } else if (token.is(tok::equal)) {
           loc = l;
           break;
         }
       }
     }
     // Again, only emit the warning if it doesn't originate from a macro in
     // a system header.
     if (loc.isValid()) {
-      ReportIfSpellingLocNotIgnored(loc, diag_method_requires_override_)
+      ReportIfSpellingLocNotIgnored(loc, method, diag_method_requires_override_)
           << FixItHint::CreateInsertion(loc, " override");
     } else {
-      ReportIfSpellingLocNotIgnored(range.getBegin(),
+      ReportIfSpellingLocNotIgnored(range.getBegin(), method,
                                     diag_method_requires_override_);
     }
   }
 
   if (final_attr && override_attr) {
-    ReportIfSpellingLocNotIgnored(override_attr->getLocation(),
+    ReportIfSpellingLocNotIgnored(override_attr->getLocation(), method,
                                   diag_redundant_virtual_specifier_)
         << override_attr << final_attr
         << FixItHint::CreateRemoval(override_attr->getRange());
   }
 
   if (final_attr && !is_override) {
-    ReportIfSpellingLocNotIgnored(method->getLocStart(),
+    ReportIfSpellingLocNotIgnored(method->getLocStart(), method,
                                   diag_base_method_virtual_and_final_)
         << FixItRemovalForVirtual(manager, lang_opts, method)
         << FixItHint::CreateRemoval(final_attr->getRange());
   }
 }
 
 void FindBadConstructsConsumer::CheckVirtualBodies(
     const CXXMethodDecl* method) {
   // Virtual methods should not have inline definitions beyond "{}". This
   // only matters for header files.
   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();
-          LocationType type = ClassifyLocation(manager.getSpellingLoc(loc));
+          LocationType type =
+              ClassifyLocation(manager.getSpellingLoc(loc), method);
           if (type == LocationType::kThirdParty || type == LocationType::kBlink)
             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;
           }
         }
@@ skipping 370 matching lines @@
         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());
+              ClassifyLocation(var_decl->getLocStart(), var_decl);
           if (!InBannedNamespace(var_decl) &&
               location_type != LocationType::kThirdParty) {
             // 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(),
+            ReportIfSpellingLocNotIgnored(range.getBegin(), var_decl,
                                           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