Address Commments

Author: Mr-Anyone

clang/docs/ReleaseNotes.rst

@@ -478,7 +478,7 @@ Improvements to Clang's diagnostics
   diagnostics. This fixes a bunch of `bool` being printed as `_Bool`, and also
   a bunch of HLSL types being printed as their C++ equivalents.
 - Clang now consistently quotes expressions in diagnostics.
-- Clang now suggest standard library include path and its associated C++ or C language version.
+- Clang now suggests including standard library headers when encountering standard types.
 - When printing types for diagnostics, clang now doesn't suppress the scopes of
   template arguments contained within nested names.
 - The ``-Wshift-bool`` warning has been added to warn about shifting a boolean. (#GH28334)

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -5991,9 +5991,9 @@ def err_template_expansion_into_fixed_list : Error<
 def note_parameter_type : Note<
   "parameter of type %0 is declared here">;
 def note_standard_lib_include_suggestion : Note<
-  "maybe try to include %0; '%1' is defined in %0">;
+  "'%1%2' is defined in %0; did you mean to include it?">;
 def note_standard_lib_version : Note<
-  "'%0' is a %1 feature">;
+  "'%0%1' is a %select{c99|c11|c++11|c++14|c++17|c++20|c++23|c++26}2 feature">;
 
 // C++11 Variadic Templates
 def err_template_param_pack_default_arg : Error<

clang/include/clang/Tooling/Inclusions/StandardLibrary.h

@@ -15,6 +15,7 @@
 #ifndef LLVM_CLANG_TOOLING_INCLUSIONS_STANDARDLIBRARY_H
 #define LLVM_CLANG_TOOLING_INCLUSIONS_STANDARDLIBRARY_H
 
+#include "clang/Basic/LangStandard.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringRef.h"
@@ -29,28 +30,6 @@ class NamespaceDecl;
 class DeclContext;
 namespace tooling {
 namespace stdlib {
-enum Version {
-  Unknown,
-
-  // c++ versions
-  CPlusPlusStart,
-  CPlusPlus11,
-  CPlusPlus14,
-  CPlusPlus17,
-  CPlusPlus20,
-  CPlusPlus23,
-  CPlusPlus26,
-  CPlusPlusEnd,
-
-  // c version
-  CStart,
-  C99,
-  C11,
-  CEnd
-};
-
-llvm::StringRef GetAsString(Version Ver);
-
 class Symbol;
 enum class Lang { C = 0, CXX, LastValue = CXX };
 
@@ -106,7 +85,7 @@ class Symbol {
   std::optional<Header> header() const;
   // Some symbols may be provided by multiple headers.
   llvm::SmallVector<Header> headers() const;
-  Version version() const;
+  std::optional<LangFeatures> version() const;
 
 private:
   Symbol(unsigned ID, Lang Language) : ID(ID), Language(Language) {}

clang/lib/Parse/ParseExprCXX.cpp

@@ -226,11 +226,6 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
     HasScopeSpecifier = true;
   }
 
-  // If `FailedNestedNameBuilding` is true, attempt to suggest the standard
-  // include file corresponding to the current `FullNamespace` and symbol.
-  std::string FullNamespace = "";
-  bool FailedNesatedNameBuilding = false;
-
   // Preferred type might change when parsing qualifiers, we need the original.
   auto SavedType = PreferredType;
   while (true) {
@@ -459,9 +454,6 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
       // We have an identifier followed by a '::'. Lookup this name
       // as the name in a nested-name-specifier.
       Token Identifier = Tok;
-      FullNamespace += Identifier.getIdentifierInfo()->getName();
-      FullNamespace += "::";
-
       SourceLocation IdLoc = ConsumeToken();
       assert(Tok.isOneOf(tok::coloncolon, tok::colon) &&
              "NextToken() not working properly!");
@@ -473,7 +465,6 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
       if (Actions.ActOnCXXNestedNameSpecifier(
               getCurScope(), IdInfo, EnteringContext, SS, CorrectionFlagPtr,
               OnlyNamespace)) {
-        FailedNesatedNameBuilding = true;
         // Identifier is not recognized as a nested name, but we can have
         // mistyped '::' instead of ':'.
         if (CorrectionFlagPtr && IsCorrectedToColon) {
@@ -563,11 +554,6 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
     break;
   }
 
-  if (FailedNesatedNameBuilding && Tok.getKind() == tok::identifier) {
-    Actions.NoteStandardIncludes(Tok.getIdentifierInfo()->getName(),
-                                 Tok.getLocation(), FullNamespace);
-  }
-
   // Even if we didn't see any pieces of a nested-name-specifier, we
   // still check whether there is a tilde in this position, which
   // indicates a potential pseudo-destructor.

clang/lib/Sema/SemaDecl.cpp

@@ -814,6 +814,29 @@ void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II,
     NoteStandardIncludes(II->getName(), IILoc, SS);
 }
 
+static unsigned int GetLangFeatureDiagNum(LangFeatures Feature){
+    switch(Feature){
+        case C99:
+            return 0;
+        case C11:
+            return 1;
+        case CPlusPlus11:
+            return 2;
+        case CPlusPlus14:
+            return 3;
+        case CPlusPlus17:
+            return 4;
+        case CPlusPlus20:
+            return 5;
+        case CPlusPlus23:
+            return 6;
+        case CPlusPlus26:
+            return 7;
+        default: 
+            llvm_unreachable("Invalid LangFeatures options.");
+    }
+}
+
 void Sema::NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
                                 StringRef Namespace) {
   using clang::tooling::stdlib::Lang;
@@ -828,15 +851,12 @@ void Sema::NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
     if (auto Header = StdSym->header()) {
       HeaderName = Header->name();
       Diag(IILoc, diag::note_standard_lib_include_suggestion)
-          << HeaderName << (Namespace + SymbolName).str();
+          << HeaderName << Namespace <<  SymbolName;
 
       // Noting the C/C++ version as well
-      if (StdSym->version() != tooling::stdlib::Unknown) {
-        llvm::StringRef CPlusPlusVersion =
-            tooling::stdlib::GetAsString(StdSym->version());
-
+      if (auto LangVersion = StdSym->version()) {
         Diag(IILoc, diag::note_standard_lib_version)
-            << (Namespace + SymbolName).str() << CPlusPlusVersion;
+            << Namespace << SymbolName << GetLangFeatureDiagNum(*LangVersion);
       }
     }
   }

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

@@ -36,9 +36,9 @@ struct SymbolHeaderMapping {
     const char *Data;  // std::vector
     unsigned ScopeLen; // ~~~~~
     unsigned NameLen;  //      ~~~~~~
-    Version CurrentVersion;
+    std::optional<LangFeatures> CurrentVersion;
 
-    Version version() const { return CurrentVersion; }
+    std::optional<LangFeatures> version() const { return CurrentVersion; }
     StringRef scope() const { return StringRef(Data, ScopeLen); }
     StringRef name() const { return StringRef(Data + ScopeLen, NameLen); }
     StringRef qualifiedName() const {
@@ -135,17 +135,17 @@ static int initialize(Lang Language) {
       ++SymIndex;
     } // Else use the same index.
 
-    Version CurrentVersion = llvm::StringSwitch<Version>(Ver)
-                                 .Case("c++11", CPlusPlus11)
-                                 .Case("c++14", CPlusPlus14)
-                                 .Case("c++17", CPlusPlus17)
-                                 .Case("c++20", CPlusPlus20)
-                                 .Case("c++23", CPlusPlus23)
-                                 .Case("c++26", CPlusPlus26)
-                                 .Case("c99", C99)
-                                 .Case("c11", C11)
-                                 .Case("unknown", Unknown)
-                                 .Default(Unknown);
+    std::optional<LangFeatures> CurrentVersion 
+        = llvm::StringSwitch<std::optional<LangFeatures>>(Ver)
+                                 .Case("c++11", std::make_optional(CPlusPlus11))
+                                 .Case("c++14", std::make_optional(CPlusPlus14))
+                                 .Case("c++17", std::make_optional(CPlusPlus17))
+                                 .Case("c++20", std::make_optional(CPlusPlus20))
+                                 .Case("c++23", std::make_optional(CPlusPlus23))
+                                 .Case("c++26", std::make_optional(CPlusPlus26))
+                                 .Case("c99", std::make_optional(C99))
+                                 .Case("c11", std::make_optional(C11))
+                                 .Default(std::nullopt);
 
     Mapping->SymbolNames[SymIndex] = {
         QName.data(), NSLen, static_cast<unsigned int>(QName.size() - NSLen),
@@ -248,7 +248,7 @@ llvm::StringRef Symbol::name() const {
 llvm::StringRef Symbol::qualifiedName() const {
   return getMappingPerLang(Language)->SymbolNames[ID].qualifiedName();
 }
-Version Symbol::version() const {
+std::optional<LangFeatures> Symbol::version() const {
   return getMappingPerLang(Language)->SymbolNames[ID].version();
 }
 std::optional<Symbol> Symbol::named(llvm::StringRef Scope, llvm::StringRef Name,
@@ -347,29 +347,6 @@ std::optional<Symbol> Recognizer::operator()(const Decl *D) {
     return std::nullopt;
   return Symbol(It->second, L);
 }
-
-llvm::StringRef GetAsString(Version Ver) {
-  switch (Ver) {
-  case tooling::stdlib::CPlusPlus11:
-    return "c++11";
-  case tooling::stdlib::CPlusPlus14:
-    return "c++14";
-  case tooling::stdlib::CPlusPlus17:
-    return "c++17";
-  case tooling::stdlib::CPlusPlus20:
-    return "c++20";
-  case tooling::stdlib::CPlusPlus23:
-    return "c++23";
-  case tooling::stdlib::CPlusPlus26:
-    return "c++26";
-  case tooling::stdlib::C99:
-    return "c99";
-  case tooling::stdlib::C11:
-    return "c11";
-  default:
-    llvm_unreachable("other optinos shouldn't be possible!");
-  }
-}
 } // namespace stdlib
 } // namespace tooling
 } // namespace clang

clang/test/Headers/stddef.c

@@ -10,20 +10,20 @@ struct astruct { char member; };
 
 ptrdiff_t p0; // c99-error{{unknown type name 'ptrdiff_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
                  c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
-                 c99-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
-                 c11-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
-                 c23-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
-                 c99-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
-                 c11-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
-                 c23-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}}
+                 c99-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+                 c11-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+                 c23-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+                 c99-modules-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+                 c11-modules-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+                 c23-modules-note {{'ptrdiff_t' is defined in <stddef.h>}}
 size_t s0; // c99-error{{unknown type name 'size_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
               c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
-              c99-note {{maybe try}} \
-              c11-note {{maybe try}} \
-              c23-note {{maybe try}} \
-              c99-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
-              c11-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
-              c23-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
+              c99-note {{'size_t' is defined in}} \
+              c11-note {{'size_t' is defined in}} \
+              c23-note {{'size_t' is defined in}} \
+              c99-modules-note {{'size_t' is defined in <stddef.h>}} \
+              c11-modules-note {{'size_t' is defined in <stddef.h>}} \
+              c23-modules-note {{'size_t' is defined in <stddef.h>}}
 rsize_t r0; // c99-error{{unknown type name 'rsize_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
                c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
 wchar_t wc0; // c99-error{{unknown type name 'wchar_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
@@ -36,30 +36,30 @@ static void f0(void) { unreachable(); } // c99-error{{call to undeclared functio
                                            c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
 max_align_t m0; // c99-error{{unknown type name 'max_align_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
                    c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
-                   c99-note {{maybe try}} \
+                   c99-note {{'max_align_t' is defined in}} \
                    c99-note {{'max_align_t' is a c11 feature}} \
-                   c11-note {{maybe try}} \
+                   c11-note {{'max_align_t' is defined in}} \
                    c11-note {{'max_align_t' is a c11 feature}} \
-                   c23-note {{maybe try}} \
+                   c23-note {{'max_align_t' is defined in}} \
                    c23-note {{'max_align_t' is a c11 feature}} \
-                   c99-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+                   c99-modules-note {{'max_align_t' is defined in <stddef.h>}} \
                    c99-modules-note {{'max_align_t' is a c11 feature}} \
-                   c11-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+                   c11-modules-note {{'max_align_t' is defined in <stddef.h>}} \
                    c11-modules-note {{'max_align_t' is a c11 feature}} \
-                   c23-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+                   c23-modules-note {{'max_align_t' is defined in <stddef.h>}} \
                    c23-modules-note {{'max_align_t' is a c11 feature}}
 size_t o0 = offsetof(struct astruct, member); // c99-error{{unknown type name 'size_t'}} c99-error{{call to undeclared function 'offsetof'}} c99-error{{expected expression}} c99-error{{use of undeclared identifier 'member'}} \
                                                  c11-error{{unknown type}} c11-error{{undeclared function}} c11-error{{expected expression}} c11-error{{undeclared identifier}} \
                                                  c23-error{{unknown type}} c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
                                                  c99-modules-error{{unknown type}} c99-modules-error{{undeclared function}} c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
                                                  c11-modules-error{{unknown type}} c11-modules-error{{undeclared function}} c11-modules-error{{expected expression}} c11-modules-error{{undeclared identifier}} \
                                                  c23-modules-error{{unknown type}} c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}} \
-                                                 c99-note {{maybe try}} \
-                                                 c11-note {{maybe try}} \
-                                                 c23-note {{maybe try}} \
-                                                 c99-modules-note {{maybe try}} \
-                                                 c11-modules-note {{maybe try}} \
-                                                 c23-modules-note {{maybe try}}
+                                                 c99-note {{'size_t' is defined in}} \
+                                                 c11-note {{'size_t' is defined in}} \
+                                                 c23-note {{'size_t' is defined in}} \
+                                                 c99-modules-note {{'size_t' is defined in}} \
+                                                 c11-modules-note {{'size_t' is defined in}} \
+                                                 c23-modules-note {{'size_t' is defined in}}
 wint_t wi0; // c99-error{{unknown type name 'wint_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
                c99-modules-error{{unknown type name 'wint_t'}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
 
@@ -79,7 +79,7 @@ static void f1(void) { unreachable(); } // c99-error{{undeclared function}} c11-
                                            c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}}
 max_align_t m1; // c99-error{{unknown type}} c99-modules-error{{'max_align_t' must be declared before it is used}} \
                    c99-modules-note@__stddef_max_align_t.h:*{{declaration here is not visible}} \
-                   c99-note {{maybe try}} \
+                   c99-note {{'max_align_t' is defined in}} \
                    c99-note {{'max_align_t' is a c11 feature}}
 size_t o1 = offsetof(struct astruct, member);
 wint_t wi1; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}} \
@@ -98,7 +98,7 @@ nullptr_t n2; // c99-error{{unknown type}} c11-error{{unknown type}} \
 static void f2(void) { unreachable(); } // c99-error{{undeclared function}} c11-error{{undeclared function}} \
                                            c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}}
 max_align_t m2; // c99-error{{unknown type}} \
-                   c99-note {{maybe try}} \
+                   c99-note {{'max_align_t' is defined in}} \
                    c99-note {{'max_align_t' is a c11 feature}}
 size_t o2 = offsetof(struct astruct, member);
 wint_t wi2; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}} \