Merge from 'main' to 'sycl-web' (37 commits)

Author: iclsrc

clang-tools-extra/include-cleaner/lib/HTMLReport.cpp

@@ -502,10 +502,27 @@ void writeHTMLReport(FileID File, const include_cleaner::Includes &Includes,
                      const Preprocessor &PP, PragmaIncludes *PI,
                      llvm::raw_ostream &OS) {
   Reporter R(OS, Ctx, PP, Includes, PI, File);
-  const auto& SM = Ctx.getSourceManager();
+  const auto &SM = Ctx.getSourceManager();
   for (Decl *Root : Roots)
     walkAST(*Root, [&](SourceLocation Loc, const NamedDecl &D, RefType T) {
-      if(!SM.isWrittenInMainFile(SM.getSpellingLoc(Loc)))
+      // FIXME: we should merge this logic with `walkUsed` to prevent
+      // divergences in the future. It isn't trivial though, as we also update
+      // RefType. Since HTMLReport is only used for debugging purposes,
+      // divergences aren't critical.
+      auto SpellLoc = SM.getSpellingLoc(Loc);
+      // Tokens resulting from macro concatenation ends up in scratch space and
+      // clang currently doesn't have a good/simple APIs for tracking where
+      // pieces of a concataned token originated from.
+      // So we use the macro expansion location instead, and downgrade reference
+      // type to ambigious to prevent false negatives.
+      if (SM.isWrittenInScratchSpace(SpellLoc)) {
+        Loc = SM.getExpansionLoc(Loc);
+        if (T == RefType::Explicit)
+          T = RefType::Ambiguous;
+        SpellLoc = SM.getSpellingLoc(Loc);
+      }
+      auto FID = SM.getFileID(SpellLoc);
+      if (FID != SM.getMainFileID() && FID != SM.getPreambleFileID())
         return;
       R.addRef(SymbolReference{D, Loc, T});
     });

clang-tools-extra/include-cleaner/lib/Record.cpp

@@ -424,7 +424,7 @@ toFileEntries(llvm::ArrayRef<StringRef> FileNames, FileManager &FM) {
   llvm::SmallVector<FileEntryRef> Results;
 
   for (auto FName : FileNames) {
-    // FIMXE: log the failing cases?
+    // FIXME: log the failing cases?
     if (auto FE = FM.getOptionalFileRef(FName))
       Results.push_back(*FE);
   }

clang-tools-extra/test/clang-tidy/checkers/bugprone/invalid-enum-default-initialization.cpp

@@ -42,7 +42,7 @@ Enum2 E2_2 = Enum2();
 // CHECK-NOTES: :14:6: note: enum is defined here
 
 void f1() {
-  static Enum1 S; // FIMXE: warn for this?
+  static Enum1 S; // FIXME: warn for this?
   Enum1 A;
   Enum1 B = Enum1();
   // CHECK-NOTES: :[[@LINE-1]]:13: warning: enum value of type 'Enum1' initialized with invalid value of 0, enum doesn't have a zero-value enumerator
@@ -62,7 +62,7 @@ void f2() {
   // CHECK-NOTES: :9:12: note: enum is defined here
   // CHECK-NOTES: :[[@LINE-3]]:17: warning: enum value of type 'Enum1' initialized with invalid value of 0, enum doesn't have a zero-value enumerator
   // CHECK-NOTES: :9:12: note: enum is defined here
-  Enum1 D[5] = {}; // FIMXE: warn for this?
+  Enum1 D[5] = {}; // FIXME: warn for this?
   // CHECK-NOTES: :[[@LINE-1]]:16: warning: enum value of type 'Enum1' initialized with invalid value of 0, enum doesn't have a zero-value enumerator
   // CHECK-NOTES: :9:12: note: enum is defined here
 }

clang/bindings/python/clang/cindex.py

@@ -3170,19 +3170,55 @@ def string(self) -> CompletionString | None:
             return None
         return CompletionString(res)
 
+    __deprecation_message = (
+        "'CompletionChunk.{}' will be removed in a future release. "
+        "All uses of 'CompletionChunk.{}' should be replaced by checking "
+        "if 'CompletionChunk.kind` is equal to 'CompletionChunkKind.{}'."
+    )
+
     def isKindOptional(self) -> bool:
+        deprecation_message = self.__deprecation_message.format(
+            "isKindOptional",
+            "isKindOptional",
+            "OPTIONAL",
+        )
+        warnings.warn(deprecation_message, DeprecationWarning)
         return self.kind == CompletionChunkKind.OPTIONAL
 
     def isKindTypedText(self) -> bool:
+        deprecation_message = self.__deprecation_message.format(
+            "isKindTypedText",
+            "isKindTypedText",
+            "TYPED_TEXT",
+        )
+        warnings.warn(deprecation_message, DeprecationWarning)
         return self.kind == CompletionChunkKind.TYPED_TEXT
 
     def isKindPlaceHolder(self) -> bool:
+        deprecation_message = self.__deprecation_message.format(
+            "isKindPlaceHolder",
+            "isKindPlaceHolder",
+            "PLACEHOLDER",
+        )
+        warnings.warn(deprecation_message, DeprecationWarning)
         return self.kind == CompletionChunkKind.PLACEHOLDER
 
     def isKindInformative(self) -> bool:
+        deprecation_message = self.__deprecation_message.format(
+            "isKindInformative",
+            "isKindInformative",
+            "INFORMATIVE",
+        )
+        warnings.warn(deprecation_message, DeprecationWarning)
         return self.kind == CompletionChunkKind.INFORMATIVE
 
     def isKindResultType(self) -> bool:
+        deprecation_message = self.__deprecation_message.format(
+            "isKindResultType",
+            "isKindResultType",
+            "RESULT_TYPE",
+        )
+        warnings.warn(deprecation_message, DeprecationWarning)
         return self.kind == CompletionChunkKind.RESULT_TYPE
 
 

clang/docs/LanguageExtensions.rst

@@ -2884,6 +2884,50 @@ between the host and device is known to be compatible.
   );
   #pragma OPENCL EXTENSION __cl_clang_non_portable_kernel_param_types : disable
 
+``__cl_clang_function_scope_local_variables``
+----------------------------------------------
+
+This extension allows declaring variables in the local address space within
+function scope, including non-kernel functions or nested scopes within a kernel,
+using regular OpenCL extension pragma mechanism detailed in `the OpenCL
+Extension Specification, section 1.2
+<https://www.khronos.org/registry/OpenCL/specs/3.0-unified/html/OpenCL_Ext.html#extensions-overview>`_.
+
+This relaxes the `Declaration Scopes and Variable Types
+<https://registry.khronos.org/OpenCL/specs/3.0-unified/html/OpenCL_C.html#_usage_for_declaration_scopes_and_variable_types>`_
+rule that limits local-address-space variable declarations to the outermost
+compound statement inside the body of the kernel function.
+
+To expose static local allocations at kernel scope, targets can either force-
+inline non-kernel functions that declare local memory or pass a kernel-allocated
+local buffer to those functions via an implicit argument.
+
+.. code-block:: c++
+
+  #pragma OPENCL EXTENSION __cl_clang_function_scope_local_variables : enable
+  kernel void kernel1(...)
+  {
+    {
+      local float a; // compiled - no diagnostic generated
+    }
+  }
+  void foo()
+  {
+    local float c; // compiled - no diagnostic generated
+  }
+
+  #pragma OPENCL EXTENSION __cl_clang_function_scope_local_variables : disable
+  kernel void kernel2(...)
+  {
+    {
+      local float a; // error - variables in the local address space can only be declared in the outermost scope of a kernel function
+    }
+  }
+  void bar()
+  {
+    local float c; // error - non-kernel function variable cannot be declared in local address space
+  }
+
 Remove address space builtin function
 -------------------------------------
 

clang/docs/ReleaseNotes.rst

@@ -198,6 +198,7 @@ Miscellaneous Clang Crashes Fixed
 - Fixed a crash when attempting to jump over initialization of a variable with variably modified type. (#GH175540)
 - Fixed a crash when using loop hint with a value dependent argument inside a
   generic lambda. (#GH172289)
+- Fixed a crash in C++ overload resolution with ``_Atomic``-qualified argument types. (#GH170433)
 
 OpenACC Specific Changes
 ------------------------
@@ -302,6 +303,13 @@ Sanitizers
 
 Python Binding Changes
 ----------------------
+- Add deprecation warnings to ``CompletionChunk.isKind...`` methods.
+  These will be removed in a future release. Existing uses should be adapted
+  to directly compare equality of the ``CompletionChunk`` kind with
+  the corresponding ``CompletionChunkKind`` variant.
+
+  Affected methods: ``isKindOptional``, ``isKindTypedText``, ``isKindPlaceHolder``,
+  ``isKindInformative`` and ``isKindResultType``.
 
 OpenMP Support
 --------------

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -2797,7 +2797,7 @@ DEF_TRAVERSE_STMT(CXXNewExpr, {
 DEF_TRAVERSE_STMT(OffsetOfExpr, {
   // The child-iterator will pick up the expression representing
   // the field.
-  // FIMXE: for code like offsetof(Foo, a.b.c), should we get
+  // FIXME: for code like offsetof(Foo, a.b.c), should we get
   // making a MemberExpr callbacks for Foo.a, Foo.a.b, and Foo.a.b.c?
   TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
 })

clang/include/clang/Analysis/Analyses/LifetimeSafety/Checker.h

@@ -28,7 +28,7 @@ namespace clang::lifetimes::internal {
 void runLifetimeChecker(const LoanPropagationAnalysis &LoanPropagation,
                         const LiveOriginsAnalysis &LiveOrigins,
                         const FactManager &FactMgr, AnalysisDeclContext &ADC,
-                        LifetimeSafetyReporter *Reporter);
+                        LifetimeSafetySemaHelper *SemaHelper);
 
 } // namespace clang::lifetimes::internal
 

clang/include/clang/Analysis/Analyses/LifetimeSafety/Facts.h

@@ -195,7 +195,7 @@ class TestPointFact : public Fact {
 class FactManager {
 public:
   FactManager(const AnalysisDeclContext &AC, const CFG &Cfg)
-      : OriginMgr(AC.getASTContext()) {
+      : OriginMgr(AC.getASTContext(), AC.getDecl()) {
     BlockToFacts.resize(Cfg.getNumBlockIDs());
   }
 

clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h

@@ -42,10 +42,20 @@ enum class SuggestionScope {
   IntraTU  // For suggestions on definitions local to a Translation Unit.
 };
 
-class LifetimeSafetyReporter {
+/// Abstract interface for operations requiring Sema access.
+///
+/// This class exists to break a circular dependency: the LifetimeSafety
+/// analysis target cannot directly depend on clangSema (which would create the
+/// cycle: clangSema -> clangAnalysis -> clangAnalysisLifetimeSafety ->
+/// clangSema).
+///
+/// Instead, this interface is implemented in AnalysisBasedWarnings.cpp (part of
+/// clangSema), allowing the analysis to report diagnostics and modify the AST
+/// through Sema without introducing a circular dependency.
+class LifetimeSafetySemaHelper {
 public:
-  LifetimeSafetyReporter() = default;
-  virtual ~LifetimeSafetyReporter() = default;
+  LifetimeSafetySemaHelper() = default;
+  virtual ~LifetimeSafetySemaHelper() = default;
 
   virtual void reportUseAfterFree(const Expr *IssueExpr, const Expr *UseExpr,
                                   SourceLocation FreeLoc,
@@ -56,15 +66,24 @@ class LifetimeSafetyReporter {
                                     SourceLocation ExpiryLoc,
                                     Confidence Confidence) {}
 
-  // Suggests lifetime bound annotations for function paramters
-  virtual void suggestAnnotation(SuggestionScope Scope,
-                                 const ParmVarDecl *ParmToAnnotate,
-                                 const Expr *EscapeExpr) {}
+  // Suggests lifetime bound annotations for function paramters.
+  virtual void suggestLifetimeboundToParmVar(SuggestionScope Scope,
+                                             const ParmVarDecl *ParmToAnnotate,
+                                             const Expr *EscapeExpr) {}
+
+  // Suggests lifetime bound annotations for implicit this.
+  virtual void suggestLifetimeboundToImplicitThis(SuggestionScope Scope,
+                                                  const CXXMethodDecl *MD,
+                                                  const Expr *EscapeExpr) {}
+
+  // Adds inferred lifetime bound attribute for implicit this to its
+  // TypeSourceInfo.
+  virtual void addLifetimeBoundToImplicitThis(const CXXMethodDecl *MD) {}
 };
 
 /// The main entry point for the analysis.
 void runLifetimeSafetyAnalysis(AnalysisDeclContext &AC,
-                               LifetimeSafetyReporter *Reporter,
+                               LifetimeSafetySemaHelper *SemaHelper,
                                LifetimeSafetyStats &Stats, bool CollectStats);
 
 namespace internal {
@@ -85,7 +104,7 @@ struct LifetimeFactory {
 class LifetimeSafetyAnalysis {
 public:
   LifetimeSafetyAnalysis(AnalysisDeclContext &AC,
-                         LifetimeSafetyReporter *Reporter);
+                         LifetimeSafetySemaHelper *SemaHelper);
 
   void run();
 
@@ -98,7 +117,7 @@ class LifetimeSafetyAnalysis {
 
 private:
   AnalysisDeclContext ∾
-  LifetimeSafetyReporter *Reporter;
+  LifetimeSafetySemaHelper *SemaHelper;
   LifetimeFactory Factory;
   std::unique_ptr<FactManager> FactMgr;
   std::unique_ptr<LiveOriginsAnalysis> LiveOrigins;