[Clang] raise extension warning for unknown namespaced attributes

Author: a-tarasyuk

clang/docs/ReleaseNotes.rst

@@ -384,6 +384,9 @@ related warnings within the method body.
 - Clang now disallows the use of attributes applied before an
   ``extern template`` declaration (#GH79893).
 
+- Clang now diagnoses unknown attribute namespaces and
+  provides typo correction for unrecognized namespace and attribute names (#GH120875).
+
 Improvements to Clang's diagnostics
 -----------------------------------
 

clang/include/clang/Basic/AttributeCommonInfo.h

@@ -16,11 +16,12 @@
 
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TokenKinds.h"
-
 namespace clang {
 
 class ASTRecordWriter;
 class IdentifierInfo;
+class LangOptions;
+class TargetInfo;
 
 class AttributeCommonInfo {
 public:
@@ -67,7 +68,7 @@ class AttributeCommonInfo {
     IgnoredAttribute,
     UnknownAttribute,
   };
-  enum class Scope { NONE, CLANG, GNU, MSVC, OMP, HLSL, GSL, RISCV };
+  enum class Scope { NONE, CLANG, GNU, MSVC, OMP, HLSL, GSL, RISCV, UNKNOWN };
   enum class AttrArgsInfo {
     None,
     Optional,
@@ -234,6 +235,12 @@ class AttributeCommonInfo {
     return SyntaxUsed == AS_ContextSensitiveKeyword;
   }
 
+  bool isUnknownScopeName() const;
+
+  llvm::StringRef correctScopeTypo() const;
+  llvm::StringRef correctAttributeTypo(const TargetInfo &Target,
+                                       const LangOptions &LangOpts) const;
+
   unsigned getAttributeSpellingListIndex() const {
     assert((isAttributeSpellingListCalculated() || AttrName) &&
            "Spelling cannot be found");

clang/include/clang/Basic/Attributes.h

@@ -10,7 +10,7 @@
 #define LLVM_CLANG_BASIC_ATTRIBUTES_H
 
 #include "clang/Basic/AttributeCommonInfo.h"
-
+#include "llvm/ADT/StringRef.h"
 namespace clang {
 
 class IdentifierInfo;
@@ -19,6 +19,11 @@ class TargetInfo;
 
 /// Return the version number associated with the attribute if we
 /// recognize and implement the attribute specified by the given information.
+int hasAttribute(AttributeCommonInfo::Syntax Syntax,
+                 const IdentifierInfo *Scope, llvm::StringRef AttrName,
+                 const TargetInfo &Target, const LangOptions &LangOpts,
+                 bool CheckPlugins);
+
 int hasAttribute(AttributeCommonInfo::Syntax Syntax,
                  const IdentifierInfo *Scope, const IdentifierInfo *Attr,
                  const TargetInfo &Target, const LangOptions &LangOpts);

clang/include/clang/Basic/CMakeLists.txt

@@ -79,6 +79,12 @@ clang_tablegen(CXX11AttributeInfo.inc -gen-cxx11-attribute-info
   TARGET CXX11AttributeInfo
   )
 
+clang_tablegen(AttributeSpellingList.inc -gen-attribute-spelling-list
+  -I ${CMAKE_CURRENT_SOURCE_DIR}/../../
+  SOURCE Attr.td
+  TARGET AttributeSpellingList
+  )
+
 clang_tablegen(Builtins.inc -gen-clang-builtins
   SOURCE Builtins.td
   TARGET ClangBuiltins)

clang/include/clang/Basic/DiagnosticCommonKinds.td

@@ -177,8 +177,16 @@ def err_opencl_unknown_type_specifier : Error<
   "%0 does not support the '%1' "
   "%select{type qualifier|storage class specifier}2">;
 
+def warn_unknown_attribute_namespace : Warning<
+  "unknown attribute namespace '%0'; attribute '%0::%1' ignored">,
+  InGroup<UnknownAttributes>;
+def warn_unknown_attribute_namespace_suggestion : Warning<
+  "unknown attribute namespace '%0'; did you mean '%1'?">,
+  InGroup<UnknownAttributes>;
 def warn_unknown_attribute_ignored : Warning<
   "unknown attribute %0 ignored">, InGroup<UnknownAttributes>;
+def warn_unknown_attribute_ignored_suggestion : Warning<
+  "unknown attribute %0 ignored; did you mean '%1'?">, InGroup<UnknownAttributes>;
 def warn_attribute_ignored : Warning<"%0 attribute ignored">,
   InGroup<IgnoredAttributes>;
 def err_keyword_not_supported_on_target : Error<

clang/include/clang/Basic/SimpleTypoCorrector.h

@@ -0,0 +1,31 @@
+#ifndef LLVM_CLANG_BASIC_SIMPLETYPOCORRECTOR_H
+#define LLVM_CLANG_BASIC_SIMPLETYPOCORRECTOR_H
+
+#include "clang/Basic/LLVM.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace clang {
+class SimpleTypoCorrector {
+  StringRef BestCandidate;
+  StringRef Typo;
+
+  const unsigned MaxEditDistance;
+  unsigned BestEditDistance;
+  unsigned BestIndex;
+  unsigned NextIndex;
+
+public:
+  explicit SimpleTypoCorrector(StringRef Typo)
+      : BestCandidate(), Typo(Typo), MaxEditDistance((Typo.size() + 2) / 3),
+        BestEditDistance(MaxEditDistance + 1), BestIndex(0), NextIndex(0) {}
+
+  void add(const StringRef Candidate);
+  void add(const char *Candidate);
+
+  bool hasCandidate() const;
+  StringRef getBestCandidate() const;
+  unsigned getBestDeclIndex() const;
+};
+} // namespace clang
+
+#endif // LLVM_CLANG_BASIC_SIMPLETYPOCORRECTOR_H

clang/lib/AST/CommentSema.cpp

@@ -13,6 +13,7 @@
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Basic/DiagnosticComment.h"
 #include "clang/Basic/LLVM.h"
+#include "clang/Basic/SimpleTypoCorrector.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/StringSwitch.h"
@@ -975,69 +976,26 @@ unsigned Sema::resolveParmVarReference(StringRef Name,
   return ParamCommandComment::InvalidParamIndex;
 }
 
-namespace {
-class SimpleTypoCorrector {
-  const NamedDecl *BestDecl;
-
-  StringRef Typo;
-  const unsigned MaxEditDistance;
-
-  unsigned BestEditDistance;
-  unsigned BestIndex;
-  unsigned NextIndex;
-
-public:
-  explicit SimpleTypoCorrector(StringRef Typo)
-      : BestDecl(nullptr), Typo(Typo), MaxEditDistance((Typo.size() + 2) / 3),
-        BestEditDistance(MaxEditDistance + 1), BestIndex(0), NextIndex(0) {}
-
-  void addDecl(const NamedDecl *ND);
-
-  const NamedDecl *getBestDecl() const {
-    if (BestEditDistance > MaxEditDistance)
-      return nullptr;
-
-    return BestDecl;
-  }
-
-  unsigned getBestDeclIndex() const {
-    assert(getBestDecl());
-    return BestIndex;
-  }
-};
-
-void SimpleTypoCorrector::addDecl(const NamedDecl *ND) {
-  unsigned CurrIndex = NextIndex++;
-
-  const IdentifierInfo *II = ND->getIdentifier();
-  if (!II)
-    return;
-
-  StringRef Name = II->getName();
-  unsigned MinPossibleEditDistance = abs((int)Name.size() - (int)Typo.size());
-  if (MinPossibleEditDistance > 0 &&
-      Typo.size() / MinPossibleEditDistance < 3)
-    return;
-
-  unsigned EditDistance = Typo.edit_distance(Name, true, MaxEditDistance);
-  if (EditDistance < BestEditDistance) {
-    BestEditDistance = EditDistance;
-    BestDecl = ND;
-    BestIndex = CurrIndex;
-  }
-}
-} // end anonymous namespace
-
 unsigned Sema::correctTypoInParmVarReference(
                                     StringRef Typo,
                                     ArrayRef<const ParmVarDecl *> ParamVars) {
   SimpleTypoCorrector Corrector(Typo);
-  for (unsigned i = 0, e = ParamVars.size(); i != e; ++i)
-    Corrector.addDecl(ParamVars[i]);
-  if (Corrector.getBestDecl())
+  for (unsigned i = 0, e = ParamVars.size(); i != e; ++i) {
+    const ParmVarDecl *Param = ParamVars[i];
+    if (!Param)
+      continue;
+
+    const IdentifierInfo *II = Param->getIdentifier();
+    if (!II)
+      continue;
+
+    Corrector.add(II->getName());
+  }
+
+  if (Corrector.hasCandidate())
     return Corrector.getBestDeclIndex();
-  else
-    return ParamCommandComment::InvalidParamIndex;
+
+  return ParamCommandComment::InvalidParamIndex;
 }
 
 namespace {
@@ -1083,7 +1041,14 @@ void CorrectTypoInTParamReferenceHelper(
                             SimpleTypoCorrector &Corrector) {
   for (unsigned i = 0, e = TemplateParameters->size(); i != e; ++i) {
     const NamedDecl *Param = TemplateParameters->getParam(i);
-    Corrector.addDecl(Param);
+    if (!Param)
+      continue;
+
+    const IdentifierInfo *II = Param->getIdentifier();
+    if (!II)
+      continue;
+
+    Corrector.add(II->getName());
 
     if (const TemplateTemplateParmDecl *TTP =
             dyn_cast<TemplateTemplateParmDecl>(Param))
@@ -1098,12 +1063,7 @@ StringRef Sema::correctTypoInTParamReference(
                             const TemplateParameterList *TemplateParameters) {
   SimpleTypoCorrector Corrector(Typo);
   CorrectTypoInTParamReferenceHelper(TemplateParameters, Corrector);
-  if (const NamedDecl *ND = Corrector.getBestDecl()) {
-    const IdentifierInfo *II = ND->getIdentifier();
-    assert(II && "SimpleTypoCorrector should not return this decl");
-    return II->getName();
-  }
-  return StringRef();
+  return Corrector.getBestCandidate();
 }
 
 InlineCommandRenderKind Sema::getInlineCommandRenderKind(StringRef Name) const {

clang/lib/Basic/Attributes.cpp

@@ -15,6 +15,7 @@
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/ParsedAttrInfo.h"
+#include "clang/Basic/SimpleTypoCorrector.h"
 #include "clang/Basic/TargetInfo.h"
 
 #include "llvm/ADT/StringMap.h"
@@ -32,13 +33,13 @@ static int hasAttributeImpl(AttributeCommonInfo::Syntax Syntax, StringRef Name,
 }
 
 int clang::hasAttribute(AttributeCommonInfo::Syntax Syntax,
-                        const IdentifierInfo *Scope, const IdentifierInfo *Attr,
+                        const IdentifierInfo *Scope, StringRef AttrName,
                         const TargetInfo &Target, const LangOptions &LangOpts,
                         bool CheckPlugins) {
-  StringRef Name = Attr->getName();
   // Normalize the attribute name, __foo__ becomes foo.
-  if (Name.size() >= 4 && Name.starts_with("__") && Name.ends_with("__"))
-    Name = Name.substr(2, Name.size() - 4);
+  if (AttrName.size() >= 4 && AttrName.starts_with("__") &&
+      AttrName.ends_with("__"))
+    AttrName = AttrName.substr(2, AttrName.size() - 4);
 
   // Normalize the scope name, but only for gnu and clang attributes.
   StringRef ScopeName = Scope ? Scope->getName() : "";
@@ -55,23 +56,31 @@ int clang::hasAttribute(AttributeCommonInfo::Syntax Syntax,
   // Other OpenMP attributes (e.g. [[omp::assume]]) are handled via the
   // regular attribute parsing machinery.
   if (LangOpts.OpenMP && ScopeName == "omp" &&
-      (Name == "directive" || Name == "sequence"))
+      (AttrName == "directive" || AttrName == "sequence"))
     return 1;
 
-  int res = hasAttributeImpl(Syntax, Name, ScopeName, Target, LangOpts);
+  int res = hasAttributeImpl(Syntax, AttrName, ScopeName, Target, LangOpts);
   if (res)
     return res;
 
   if (CheckPlugins) {
     // Check if any plugin provides this attribute.
     for (auto &Ptr : getAttributePluginInstances())
-      if (Ptr->hasSpelling(Syntax, Name))
+      if (Ptr->hasSpelling(Syntax, AttrName))
         return 1;
   }
 
   return 0;
 }
 
+int clang::hasAttribute(AttributeCommonInfo::Syntax Syntax,
+                        const IdentifierInfo *Scope, const IdentifierInfo *Attr,
+                        const TargetInfo &Target, const LangOptions &LangOpts,
+                        bool CheckPlugins) {
+  return hasAttribute(Syntax, Scope, Attr->getName(), Target, LangOpts,
+                      CheckPlugins);
+}
+
 int clang::hasAttribute(AttributeCommonInfo::Syntax Syntax,
                         const IdentifierInfo *Scope, const IdentifierInfo *Attr,
                         const TargetInfo &Target, const LangOptions &LangOpts) {
@@ -191,7 +200,8 @@ getScopeFromNormalizedScopeName(StringRef ScopeName) {
       .Case("hlsl", AttributeCommonInfo::Scope::HLSL)
       .Case("msvc", AttributeCommonInfo::Scope::MSVC)
       .Case("omp", AttributeCommonInfo::Scope::OMP)
-      .Case("riscv", AttributeCommonInfo::Scope::RISCV);
+      .Case("riscv", AttributeCommonInfo::Scope::RISCV)
+      .Default(AttributeCommonInfo::Scope::UNKNOWN);
 }
 
 unsigned AttributeCommonInfo::calculateAttributeSpellingListIndex() const {
@@ -206,3 +216,35 @@ unsigned AttributeCommonInfo::calculateAttributeSpellingListIndex() const {
 
 #include "clang/Sema/AttrSpellingListIndex.inc"
 }
+
+bool AttributeCommonInfo::isUnknownScopeName() const {
+  return getScopeFromNormalizedScopeName(
+             normalizeAttrScopeName(getScopeName(), getSyntax())) ==
+         AttributeCommonInfo::Scope::UNKNOWN;
+}
+
+#include "clang/Basic/AttributeSpellingList.inc"
+
+StringRef AttributeCommonInfo::correctScopeTypo() const {
+  SimpleTypoCorrector Corrector(getScopeName()->getName());
+
+  for (const auto &ArrtScopeName : AttrScopeSpellingList)
+    Corrector.add(ArrtScopeName);
+
+  return Corrector.getBestCandidate();
+}
+
+StringRef
+AttributeCommonInfo::correctAttributeTypo(const TargetInfo &Target,
+                                          const LangOptions &LangOpts) const {
+  SimpleTypoCorrector Corrector(getAttrName()->getName());
+
+  for (const auto &ArrtName : AttrSpellingList)
+    Corrector.add(ArrtName);
+
+  if (Corrector.hasCandidate() &&
+      hasAttribute(getSyntax(), getScopeName(), Corrector.getBestCandidate(),
+                   Target, LangOpts, /*CheckPlugins=*/false))
+    return Corrector.getBestCandidate();
+  return StringRef();
+}

clang/lib/Basic/CMakeLists.txt

@@ -86,6 +86,7 @@ add_clang_library(clangBasic
   SanitizerSpecialCaseList.cpp
   Sanitizers.cpp
   Sarif.cpp
+  SimpleTypoCorrector.cpp
   SourceLocation.cpp
   SourceManager.cpp
   SourceMgrAdapter.cpp