[clang][Sema] Suggest/Hint Standard Library Include File

clang/docs/ReleaseNotes.rst

@@ -478,6 +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 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

@@ -5990,6 +5990,12 @@ def err_template_expansion_into_fixed_list : Error<
   "template|concept}0">;
 def note_parameter_type : Note<
   "parameter of type %0 is declared here">;
+def note_standard_lib_include_suggestion : Note<
+  "'%1%2' is defined in %0; did you mean to include it?">;
+def note_standard_lib_version : Note<
+  "'%0%1' is a %enum_select<StandardVersion>{%CPlusPlus11{c++11}|%CPlusPlus14{c++14}|"
+  "%CPlusPlus17{c++17}|%CPlusPlus20{c++20}|%CPlusPlus23{c++23}|"
+  "%CPlusPlus26{c++26}|%C99{c99}|%C11{c11}}2 feature">;
 
 // C++11 Variadic Templates
 def err_template_param_pack_default_arg : Error<

clang/include/clang/Sema/Sema.h

@@ -3613,6 +3613,16 @@ class Sema final : public SemaBase {
                                ParsedType &SuggestedType,
                                bool IsTemplateName = false);
 
+  // Try to suggest the missing standard library include files
+  //
+  // \param SymbolName the symbol name like 'cout'
+  // \param SourceLocation the location of the note being emitted
+  // \param Namespace the namespace that must end with ::, so like 'std::'
+  void NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
+                            StringRef Namespace);
+  void NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
+                            const CXXScopeSpec *SS);
+
   /// Attempt to behave like MSVC in situations where lookup of an unqualified
   /// type name has failed in a dependent context. In these situations, we
   /// automatically form a DependentTypeName that will retry lookup in a related

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,7 +30,6 @@ class NamespaceDecl;
 class DeclContext;
 namespace tooling {
 namespace stdlib {
-
 class Symbol;
 enum class Lang { C = 0, CXX, LastValue = CXX };
 
@@ -85,6 +85,7 @@ class Symbol {
   std::optional<Header> header() const;
   // Some symbols may be provided by multiple headers.
   llvm::SmallVector<Header> headers() const;
+  std::optional<LangFeatures> version() const;
 
 private:
   Symbol(unsigned ID, Lang Language) : ID(ID), Language(Language) {}

clang/lib/Sema/CMakeLists.txt

@@ -115,4 +115,5 @@ add_clang_library(clangSema
   clangEdit
   clangLex
   clangSupport
+  clangToolingInclusionsStdlib
   )

clang/lib/Sema/SemaDecl.cpp

@@ -58,10 +58,13 @@
 #include "clang/Sema/SemaSwift.h"
 #include "clang/Sema/SemaWasm.h"
 #include "clang/Sema/Template.h"
+#include "clang/Tooling/Inclusions/StandardLibrary.h"
 #include "llvm/ADT/STLForwardCompat.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Frontend/HLSL/HLSLRootSignature.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/TargetParser/Triple.h"
 #include <algorithm>
@@ -804,6 +807,72 @@ void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II,
     assert(SS && SS->isInvalid() &&
            "Invalid scope specifier has already been diagnosed");
   }
+
+  // don't note standard include files for OpenCL and Objective C
+  if ((getLangOpts().CPlusPlus || getLangOpts().C99) && !getLangOpts().OpenCL &&
+      !getLangOpts().ObjC)
+    NoteStandardIncludes(II->getName(), IILoc, SS);
+}
+
+static unsigned int GetLangFeatureDiagNum(LangFeatures Feature) {
+  switch (Feature) {
+  case C99:
+    return diag::StandardVersion::C99;
+  case C11:
+    return diag::StandardVersion::C11;
+  case CPlusPlus11:
+    return diag::StandardVersion::CPlusPlus11;
+  case CPlusPlus14:
+    return diag::StandardVersion::CPlusPlus14;
+  case CPlusPlus17:
+    return diag::StandardVersion::CPlusPlus17;
+  case CPlusPlus20:
+    return diag::StandardVersion::CPlusPlus20;
+  case CPlusPlus23:
+    return diag::StandardVersion::CPlusPlus23;
+  case CPlusPlus26:
+    return diag::StandardVersion::CPlusPlus26;
+  default:
+    llvm_unreachable("Invalid LangFeatures options.");
+  }
+}
+
+void Sema::NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
+                                StringRef Namespace) {
+  using clang::tooling::stdlib::Lang;
+
+  llvm::StringRef HeaderName = "";
+  tooling::stdlib::Lang LangOption = tooling::stdlib::Lang::C;
+  if (getLangOpts().CPlusPlus)
+    LangOption = clang::tooling::stdlib::Lang::CXX;
+
+  if (auto StdSym =
+          tooling::stdlib::Symbol::named(Namespace, SymbolName, LangOption)) {
+    if (auto Header = StdSym->header()) {
+      HeaderName = Header->name();
+      Diag(IILoc, diag::note_standard_lib_include_suggestion)
+          << HeaderName << Namespace << SymbolName;
+
+      // Noting the C/C++ version as well
+      if (auto LangVersion = StdSym->version()) {
+        Diag(IILoc, diag::note_standard_lib_version)
+            << Namespace << SymbolName << GetLangFeatureDiagNum(*LangVersion);
+      }
+    }
+  }
+}
+
+void Sema::NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
+                                const CXXScopeSpec *SS) {
+  std::string Namespace = "";
+  if (SS) {
+    llvm::raw_string_ostream Stream(Namespace);
+    if (SS->isValid())
+      SS->getScopeRep()->dump(Stream);
+    Stream.flush();
+  }
+
+  NoteStandardIncludes(SymbolName, IILoc, Namespace);
 }
 
 /// Determine whether the given result set contains either a type name
@@ -16783,6 +16852,7 @@ NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
   }
 
   Diag(Loc, diag_id) << &II;
+  NoteStandardIncludes(II.getName(), Loc, "");
   if (Corrected) {
     // If the correction is going to suggest an implicitly defined function,
     // skip the correction as not being a particularly good idea.

clang/lib/Sema/SemaExpr.cpp

@@ -2658,11 +2658,17 @@ bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
   if (!SS.isEmpty()) {
     Diag(R.getNameLoc(), diag::err_no_member)
         << Name << computeDeclContext(SS, false) << NameRange;
+    NoteStandardIncludes(Name.getAsString(), R.getNameLoc(), &SS);
     return true;
   }
 
   // Give up, we can't recover.
   Diag(R.getNameLoc(), diagnostic) << Name << NameRange;
+
+  // don't note standard include files for OpenCL and Objective C
+  if ((getLangOpts().CPlusPlus || getLangOpts().C99) && !getLangOpts().OpenCL &&
+      !getLangOpts().ObjC)
+    NoteStandardIncludes(Name.getAsString(), R.getNameLoc(), /*Namespace=*/"");
   return true;
 }