Merge from 'master' to 'sycl-web' (#2)

  CONFLICT (content): Merge conflict in clang/lib/Sema/SemaDeclAttr.cpp

Author: aelovikov-intel

clang-tools-extra/clangd/CMakeLists.txt

@@ -14,8 +14,11 @@ if (NOT DEFINED CLANGD_BUILD_XPC)
   unset(CLANGD_BUILD_XPC_DEFAULT)
 endif ()
 
-llvm_canonicalize_cmake_booleans(CLANGD_BUILD_XPC)
-llvm_canonicalize_cmake_booleans(CLANGD_ENABLE_REMOTE)
+llvm_canonicalize_cmake_booleans(
+  CLANGD_BUILD_XPC
+  CLANGD_ENABLE_REMOTE
+  LLVM_ENABLE_ZLIB
+)
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/Features.inc.in

clang-tools-extra/clangd/index/Serialization.cpp

@@ -21,6 +21,7 @@
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
+#include <cstdint>
 #include <vector>
 
 namespace clang {
@@ -81,12 +82,17 @@ class Reader {
 
   uint32_t consumeVar() {
     constexpr static uint8_t More = 1 << 7;
-    uint8_t B = consume8();
+
+    // Use a 32 bit unsigned here to prevent promotion to signed int (unless int
+    // is wider than 32 bits).
+    uint32_t B = consume8();
     if (LLVM_LIKELY(!(B & More)))
       return B;
     uint32_t Val = B & ~More;
     for (int Shift = 7; B & More && Shift < 32; Shift += 7) {
       B = consume8();
+      // 5th byte of a varint can only have lowest 4 bits set.
+      assert((Shift != 28 || B == (B & 0x0f)) && "Invalid varint encoding");
       Val |= (B & ~More) << Shift;
     }
     return Val;

clang-tools-extra/clangd/test/index-serialization/Inputs/sample.cpp

@@ -0,0 +1,5 @@
+// Include a file to ensure we have multiple sources.
+#include "sample.h"
+
+// This introduces a symbol, a reference and a relation.
+struct Bar : public Foo {};

clang-tools-extra/clangd/test/index-serialization/Inputs/sample.h

@@ -0,0 +1,4 @@
+#pragma once
+
+// Introduce a symbol.
+struct Foo {};

clang-tools-extra/clangd/test/index-serialization/Inputs/sample.idx

@@ -0,0 +1,14 @@
+# REQUIRES: zlib
+This test tries to parse a checked-in binary index.
+If this test fails it means there has been a backward incompatilbe change to
+serialization format.
+Please bump the version number in
+clang-tools-extra/clangd/index/Serialization.cpp and regenarate sample.idx with
+
+  clangd-indexer \
+    clang-tools-extra/clangd/test/index-serialization/Inputs/sample.cpp > \
+    clang-tools-extra/clangd/test/index-serialization/Inputs/sample.idx
+
+Also if you've introduced new slabs/chunks to serialized index, make sure
+indexing sample.cpp would yield non-trivial values for those.
+# RUN: dexp %/S/Inputs/sample.idx -c="find B" | grep Bar || not grep -v '^#' %s

clang-tools-extra/clangd/test/index-serialization/version-is-correct.test

@@ -30,3 +30,6 @@ def calculate_arch_features(arch_string):
 
 if config.clangd_enable_remote:
   config.available_features.add('clangd-remote-index')
+
+if config.have_zlib:
+  config.available_features.add('zlib')

clang-tools-extra/clangd/test/lit.cfg.py

@@ -25,6 +25,7 @@ config.clangd_source_dir = "@CMAKE_CURRENT_SOURCE_DIR@/.."
 config.clangd_binary_dir = "@CMAKE_CURRENT_BINARY_DIR@/.."
 config.clangd_build_xpc = @CLANGD_BUILD_XPC@
 config.clangd_enable_remote = @CLANGD_ENABLE_REMOTE@
+config.have_zlib = @LLVM_ENABLE_ZLIB@
 
 # Delegate logic to lit.cfg.py.
 lit_config.load_config(config, "@CMAKE_CURRENT_SOURCE_DIR@/lit.cfg.py")

clang-tools-extra/clangd/test/lit.site.cfg.py.in

@@ -141,6 +141,12 @@ TEST(RenameTest, WithinFileRename) {
           ~[[F^oo]]();
           void f([[F^oo]] x);
         };
+
+        template<typename T>
+        [[F^oo]]<T>::[[Fo^o]]() {}
+
+        template<typename T>
+        [[F^oo]]<T>::~[[Fo^o]]() {}
       )cpp",
 
       // Template class constructor.
@@ -152,6 +158,9 @@ TEST(RenameTest, WithinFileRename) {
           template<typename T>
           [[F^oo]](T t);
         };
+
+        template<typename T>
+        [[F^oo]]::[[Fo^o]]() {}
       )cpp",
 
       // Class in template argument.
@@ -199,6 +208,30 @@ TEST(RenameTest, WithinFileRename) {
         }
       )cpp",
 
+      // Templated method instantiation.
+      R"cpp(
+        template<typename T>
+        class Foo {
+        public:
+          static T [[f^oo]]() {}
+        };
+
+        void bar() {
+          Foo<int>::[[f^oo]]();
+        }
+      )cpp",
+      R"cpp(
+        template<typename T>
+        class Foo {
+        public:
+          T [[f^oo]]() {}
+        };
+
+        void bar() {
+          Foo<int>().[[f^oo]]();
+        }
+      )cpp",
+
       // Template class (partial) specializations.
       R"cpp(
         template <typename T>
@@ -272,6 +305,80 @@ TEST(RenameTest, WithinFileRename) {
         }
       )cpp",
 
+      // Templated class specialization.
+      R"cpp(
+        template<typename T, typename U=bool>
+        class [[Foo^]];
+
+        template<typename T, typename U>
+        class [[Foo^]] {};
+
+        template<typename T=int, typename U>
+        class [[Foo^]];
+      )cpp",
+      R"cpp(
+        template<typename T=float, typename U=int>
+        class [[Foo^]];
+
+        template<typename T, typename U>
+        class [[Foo^]] {};
+      )cpp",
+
+      // Function template specialization.
+      R"cpp(
+        template<typename T=int, typename U=bool>
+        U [[foo^]]();
+
+        template<typename T, typename U>
+        U [[foo^]]() {};
+      )cpp",
+      R"cpp(
+        template<typename T, typename U>
+        U [[foo^]]() {};
+
+        template<typename T=int, typename U=bool>
+        U [[foo^]]();
+      )cpp",
+      R"cpp(
+        template<typename T=int, typename U=bool>
+        U [[foo^]]();
+
+        template<typename T, typename U>
+        U [[foo^]]();
+      )cpp",
+      R"cpp(
+        template <typename T>
+        void [[f^oo]](T t);
+
+        template <>
+        void [[f^oo]](int a);
+
+        void test() {
+          [[f^oo]]<double>(1);
+        }
+      )cpp",
+
+      // Variable template.
+      R"cpp(
+        template <typename T, int U>
+        bool [[F^oo]] = true;
+
+        // Explicit template specialization
+        template <>
+        bool [[F^oo]]<int, 0> = false;
+
+        // Partial template specialization
+        template <typename T>
+        bool [[F^oo]]<T, 1> = false;
+
+        void foo() {
+          // Ref to the explicit template specialization
+          [[F^oo]]<int, 0>;
+          // Ref to the primary template.
+          [[F^oo]]<double, 2>;
+        }
+      )cpp",
+
       // Complicated class type.
       R"cpp(
          // Forward declaration.
@@ -307,6 +414,19 @@ TEST(RenameTest, WithinFileRename) {
         }
       )cpp",
 
+      // Static class member.
+      R"cpp(
+        struct Foo {
+          static Foo *[[Static^Member]];
+        };
+
+        Foo* Foo::[[Static^Member]] = nullptr;
+
+        void foo() {
+          Foo* Pointer = Foo::[[Static^Member]];
+        }
+      )cpp",
+
       // Reference in lambda parameters.
       R"cpp(
         template <class T>
@@ -588,6 +708,26 @@ TEST(RenameTest, WithinFileRename) {
           ns::[[Old^Alias]] Bar;
         }
       )cpp",
+
+      // User defined conversion.
+      R"cpp(
+        class [[F^oo]] {
+        public:
+          [[F^oo]]() {}
+        };
+
+        class Baz {
+        public:
+          operator [[F^oo]]() {
+            return [[F^oo]]();
+          }
+        };
+
+        int main() {
+          Baz boo;
+          [[F^oo]] foo = static_cast<[[F^oo]]>(boo);
+        }
+      )cpp",
   };
   llvm::StringRef NewName = "NewName";
   for (llvm::StringRef T : Tests) {

clang-tools-extra/clangd/unittests/RenameTests.cpp

@@ -366,9 +366,9 @@ TEST(SerializationTest, NoCrashOnBadArraySize) {
   Pos += FileDigest.size();
 
   // Varints are little-endian base-128 numbers, where the top-bit of each byte
-  // indicates whether there are more. 8fffffff7f -> 0xffffffff.
+  // indicates whether there are more. ffffffff0f -> 0xffffffff.
   std::string CorruptSrcs =
-      (Srcs->Data.take_front(Pos) + llvm::fromHex("8fffffff7f") +
+      (Srcs->Data.take_front(Pos) + llvm::fromHex("ffffffff0f") +
        "some_random_garbage")
           .str();
   Srcs->Data = CorruptSrcs;