merge main into amd-staging (llvm#1304)

Author: ronlieb

.ci/monolithic-linux.sh

@@ -90,23 +90,6 @@ if [[ "${runtimes}" != "" ]]; then
   INSTALL_DIR="${BUILD_DIR}/install"
   mkdir -p ${RUNTIMES_BUILD_DIR}
 
-  echo "--- cmake runtimes C++03"
-
-  cmake -S "${MONOREPO_ROOT}/runtimes" -B "${RUNTIMES_BUILD_DIR}" -GNinja \
-      -D CMAKE_C_COMPILER="${INSTALL_DIR}/bin/clang" \
-      -D CMAKE_CXX_COMPILER="${INSTALL_DIR}/bin/clang++" \
-      -D LLVM_ENABLE_RUNTIMES="${runtimes}" \
-      -D LIBCXX_CXX_ABI=libcxxabi \
-      -D CMAKE_BUILD_TYPE=RelWithDebInfo \
-      -D CMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
-      -D LIBCXX_TEST_PARAMS="std=c++03" \
-      -D LIBCXXABI_TEST_PARAMS="std=c++03" \
-      -D LLVM_LIT_ARGS="${lit_args}"
-
-  echo "--- ninja runtimes C++03"
-
-  ninja -vC "${RUNTIMES_BUILD_DIR}" ${runtime_targets}
-
   echo "--- cmake runtimes C++26"
 
   rm -rf "${RUNTIMES_BUILD_DIR}"
@@ -140,6 +123,6 @@ if [[ "${runtimes}" != "" ]]; then
       -D LLVM_LIT_ARGS="${lit_args}"
 
   echo "--- ninja runtimes clang modules"
-  
+
   ninja -vC "${RUNTIMES_BUILD_DIR}" ${runtime_targets}
 fi

.github/workflows/issue-write.yml

@@ -39,7 +39,7 @@ jobs:
 
       - name: 'Comment on PR'
         if: steps.download-artifact.outputs.artifact-id != ''
-        uses: actions/github-script@ffc2c79a5b2490bd33e0a41c1de74b877714d736 # v3.2.0
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea # v7.0.1
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
@@ -49,7 +49,7 @@ jobs:
               return;
             }
 
-            let runInfo = await github.actions.getWorkflowRun({
+            let runInfo = await github.rest.actions.getWorkflowRun({
               owner: context.repo.owner,
               repo: context.repo.repo,
               run_id: context.payload.workflow_run.id
@@ -122,7 +122,7 @@ jobs:
                 // Security check: Ensure that this comment was created by
                 // the github-actions bot, so a malicious input won't overwrite
                 // a user's comment.
-                github.issues.getComment({
+                github.rest.issues.getComment({
                   owner: context.repo.owner,
                   repo: context.repo.repo,
                   comment_id: comment.id
@@ -132,7 +132,7 @@ jobs:
                     console.log("Invalid comment id: " + comment.id);
                     return;
                   }
-                  github.issues.updateComment({
+                  github.rest.issues.updateComment({
                     owner: context.repo.owner,
                     repo: context.repo.repo,
                     issue_number: pr_number,
@@ -141,7 +141,7 @@ jobs:
                   });
                 });
               } else {
-                github.issues.createComment({
+                github.rest.issues.createComment({
                   owner: context.repo.owner,
                   repo: context.repo.repo,
                   issue_number: pr_number,

clang-tools-extra/clang-doc/Representation.h

@@ -521,7 +521,7 @@ struct ClangDocContext {
   // Path of CSS stylesheets that will be copied to OutDirectory and used to
   // style all HTML files.
   std::vector<std::string> UserStylesheets;
-  // JavaScript files that will be imported in allHTML file.
+  // JavaScript files that will be imported in all HTML files.
   std::vector<std::string> JsScripts;
   Index Idx;
 };

clang/bindings/python/clang/cindex.py

@@ -2786,7 +2786,7 @@ class _CXUnsavedFile(Structure):
 # Functions calls through the python interface are rather slow. Fortunately,
 # for most symboles, we do not need to perform a function call. Their spelling
 # never changes and is consequently provided by this spelling cache.
-SpellingCache = {
+spelling_cache = {
     # 0: CompletionChunk.Kind("Optional"),
     # 1: CompletionChunk.Kind("TypedText"),
     # 2: CompletionChunk.Kind("Text"),
@@ -2832,8 +2832,8 @@ def __repr__(self):
 
     @CachedProperty
     def spelling(self):
-        if self.__kindNumber in SpellingCache:
-            return SpellingCache[self.__kindNumber]
+        if self.__kindNumber in spelling_cache:
+            return spelling_cache[self.__kindNumber]
         return _CXString.from_result(
             conf.lib.clang_getCompletionChunkText(self.cs, self.key)
         )
@@ -3830,7 +3830,7 @@ def set_property(self, property, value):
 fields_visit_callback = CFUNCTYPE(c_int, Cursor, py_object)
 
 # Functions strictly alphabetical order.
-functionList: list[LibFunc] = [
+function_list: list[LibFunc] = [
     (
         "clang_annotateTokens",
         [TranslationUnit, POINTER(Token), c_uint, POINTER(Cursor)],
@@ -4108,7 +4108,7 @@ def register_functions(lib: CDLL, ignore_errors: bool) -> None:
     def register(item: LibFunc) -> None:
         register_function(lib, item, ignore_errors)
 
-    for f in functionList:
+    for f in function_list:
         register(f)
 
 

clang/bindings/python/tests/cindex/test_cdb.py

@@ -10,7 +10,7 @@
 import sys
 from pathlib import Path
 
-kInputsDir = os.path.join(os.path.dirname(__file__), "INPUTS")
+inputs_dir = os.path.join(os.path.dirname(__file__), "INPUTS")
 
 
 @unittest.skipIf(sys.platform == "win32", "TODO: Fix these tests on Windows")
@@ -34,23 +34,23 @@ def test_create_fail(self):
 
     def test_create(self):
         """Check we can load a compilation database"""
-        CompilationDatabase.fromDirectory(kInputsDir)
+        CompilationDatabase.fromDirectory(inputs_dir)
 
     def test_lookup_succeed(self):
         """Check we get some results if the file exists in the db"""
-        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cdb = CompilationDatabase.fromDirectory(inputs_dir)
         cmds = cdb.getCompileCommands("/home/john.doe/MyProject/project.cpp")
         self.assertNotEqual(len(cmds), 0)
 
     def test_lookup_succeed_pathlike(self):
         """Same as test_lookup_succeed, but with PathLikes"""
-        cdb = CompilationDatabase.fromDirectory(Path(kInputsDir))
+        cdb = CompilationDatabase.fromDirectory(Path(inputs_dir))
         cmds = cdb.getCompileCommands(Path("/home/john.doe/MyProject/project.cpp"))
         self.assertNotEqual(len(cmds), 0)
 
     def test_all_compilecommand(self):
         """Check we get all results from the db"""
-        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cdb = CompilationDatabase.fromDirectory(inputs_dir)
         cmds = cdb.getAllCompileCommands()
         self.assertEqual(len(cmds), 3)
         expected = [
@@ -100,7 +100,7 @@ def test_all_compilecommand(self):
 
     def test_1_compilecommand(self):
         """Check file with single compile command"""
-        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cdb = CompilationDatabase.fromDirectory(inputs_dir)
         file = "/home/john.doe/MyProject/project.cpp"
         cmds = cdb.getCompileCommands(file)
         self.assertEqual(len(cmds), 1)
@@ -119,7 +119,7 @@ def test_1_compilecommand(self):
 
     def test_2_compilecommand(self):
         """Check file with 2 compile commands"""
-        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cdb = CompilationDatabase.fromDirectory(inputs_dir)
         cmds = cdb.getCompileCommands("/home/john.doe/MyProject/project2.cpp")
         self.assertEqual(len(cmds), 2)
         expected = [
@@ -154,23 +154,23 @@ def test_2_compilecommand(self):
 
     def test_compilecommand_iterator_stops(self):
         """Check that iterator stops after the correct number of elements"""
-        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cdb = CompilationDatabase.fromDirectory(inputs_dir)
         count = 0
         for cmd in cdb.getCompileCommands("/home/john.doe/MyProject/project2.cpp"):
             count += 1
             self.assertLessEqual(count, 2)
 
     def test_compilationDB_references(self):
         """Ensure CompilationsCommands are independent of the database"""
-        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cdb = CompilationDatabase.fromDirectory(inputs_dir)
         cmds = cdb.getCompileCommands("/home/john.doe/MyProject/project.cpp")
         del cdb
         gc.collect()
         cmds[0].directory
 
     def test_compilationCommands_references(self):
         """Ensure CompilationsCommand keeps a reference to CompilationCommands"""
-        cdb = CompilationDatabase.fromDirectory(kInputsDir)
+        cdb = CompilationDatabase.fromDirectory(inputs_dir)
         cmds = cdb.getCompileCommands("/home/john.doe/MyProject/project.cpp")
         del cdb
         cmd0 = cmds[0]

clang/bindings/python/tests/cindex/test_cursor.py

@@ -21,7 +21,7 @@
 
 from .util import get_cursor, get_cursors, get_tu
 
-kInput = """\
+children_test = """\
 struct s0 {
   int a;
   int b;
@@ -41,23 +41,23 @@
 }
 """
 
-kParentTest = """\
+parent_test = """\
         class C {
             void f();
         }
 
         void C::f() { }
     """
 
-kTemplateArgTest = """\
+template_arg_test = """\
         template <int kInt, typename T, bool kBool>
         void foo();
 
         template<>
         void foo<-7, float, true>();
     """
 
-kBinops = """\
+binops = """\
 struct C {
    int m;
  };
@@ -118,7 +118,7 @@ class C {
 
 class TestCursor(unittest.TestCase):
     def test_get_children(self):
-        tu = get_tu(kInput)
+        tu = get_tu(children_test)
 
         it = tu.cursor.get_children()
         tu_nodes = list(it)
@@ -613,15 +613,15 @@ def test_underlying_type(self):
         self.assertEqual(underlying.kind, TypeKind.INT)
 
     def test_semantic_parent(self):
-        tu = get_tu(kParentTest, "cpp")
+        tu = get_tu(parent_test, "cpp")
         curs = get_cursors(tu, "f")
         decl = get_cursor(tu, "C")
         self.assertEqual(len(curs), 2)
         self.assertEqual(curs[0].semantic_parent, curs[1].semantic_parent)
         self.assertEqual(curs[0].semantic_parent, decl)
 
     def test_lexical_parent(self):
-        tu = get_tu(kParentTest, "cpp")
+        tu = get_tu(parent_test, "cpp")
         curs = get_cursors(tu, "f")
         decl = get_cursor(tu, "C")
         self.assertEqual(len(curs), 2)
@@ -865,13 +865,13 @@ def test_get_arguments(self):
         self.assertEqual(arguments[1].spelling, "j")
 
     def test_get_num_template_arguments(self):
-        tu = get_tu(kTemplateArgTest, lang="cpp")
+        tu = get_tu(template_arg_test, lang="cpp")
         foos = get_cursors(tu, "foo")
 
         self.assertEqual(foos[1].get_num_template_arguments(), 3)
 
     def test_get_template_argument_kind(self):
-        tu = get_tu(kTemplateArgTest, lang="cpp")
+        tu = get_tu(template_arg_test, lang="cpp")
         foos = get_cursors(tu, "foo")
 
         self.assertEqual(
@@ -885,20 +885,20 @@ def test_get_template_argument_kind(self):
         )
 
     def test_get_template_argument_type(self):
-        tu = get_tu(kTemplateArgTest, lang="cpp")
+        tu = get_tu(template_arg_test, lang="cpp")
         foos = get_cursors(tu, "foo")
 
         self.assertEqual(foos[1].get_template_argument_type(1).kind, TypeKind.FLOAT)
 
     def test_get_template_argument_value(self):
-        tu = get_tu(kTemplateArgTest, lang="cpp")
+        tu = get_tu(template_arg_test, lang="cpp")
         foos = get_cursors(tu, "foo")
 
         self.assertEqual(foos[1].get_template_argument_value(0), -7)
         self.assertEqual(foos[1].get_template_argument_value(2), True)
 
     def test_get_template_argument_unsigned_value(self):
-        tu = get_tu(kTemplateArgTest, lang="cpp")
+        tu = get_tu(template_arg_test, lang="cpp")
         foos = get_cursors(tu, "foo")
 
         self.assertEqual(foos[1].get_template_argument_unsigned_value(0), 2**32 - 7)
@@ -930,7 +930,7 @@ def test_mangled_name(self):
         )
 
     def test_binop(self):
-        tu = get_tu(kBinops, lang="cpp")
+        tu = get_tu(binops, lang="cpp")
 
         operators = {
             # not exposed yet

clang/bindings/python/tests/cindex/test_index.py

@@ -7,7 +7,7 @@
 
 import unittest
 
-kInputsDir = os.path.join(os.path.dirname(__file__), "INPUTS")
+inputs_dir = os.path.join(os.path.dirname(__file__), "INPUTS")
 
 
 class TestIndex(unittest.TestCase):
@@ -19,7 +19,7 @@ def test_create(self):
     def test_parse(self):
         index = Index.create()
         self.assertIsInstance(index, Index)
-        tu = index.parse(os.path.join(kInputsDir, "hello.cpp"))
+        tu = index.parse(os.path.join(inputs_dir, "hello.cpp"))
         self.assertIsInstance(tu, TranslationUnit)
-        tu = index.parse(None, ["-c", os.path.join(kInputsDir, "hello.cpp")])
+        tu = index.parse(None, ["-c", os.path.join(inputs_dir, "hello.cpp")])
         self.assertIsInstance(tu, TranslationUnit)