Merge commit 'bcaf57cae82500f40f2348f5ee41e57b11152825' into llvmspirv_pulldown

Author: vmaksimo

clang-tools-extra/clangd/CMakeLists.txt

@@ -1,3 +1,7 @@
+# This is a no-op for building files in this dir, but is inherited by subdirs.
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
 add_subdirectory(support)
 
 # Configure the Features.inc file.

clang-tools-extra/clangd/InlayHints.cpp

@@ -32,6 +32,14 @@ class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
     TypeHintPolicy.SuppressScope = true; // keep type names short
     TypeHintPolicy.AnonymousTagLocations =
         false; // do not print lambda locations
+    // Print canonical types. Otherwise, SuppressScope would result in
+    // things like "metafunction<args>::type" being shorted to just "type",
+    // which is useless. This is particularly important for structured
+    // bindings that use the tuple_element protocol, where the non-canonical
+    // types would be "tuple_element<I, A>::type".
+    // Note, for "auto", we would often prefer sugared types, but the AST
+    // doesn't currently retain them in DeducedType anyways.
+    TypeHintPolicy.PrintCanonicalTypes = true;
   }
 
   bool VisitCXXConstructExpr(CXXConstructExpr *E) {
@@ -76,20 +84,23 @@ class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
     if (auto *AT = D->getReturnType()->getContainedAutoType()) {
       QualType Deduced = AT->getDeducedType();
       if (!Deduced.isNull()) {
-        addInlayHint(D->getFunctionTypeLoc().getRParenLoc(),
-                     InlayHintKind::TypeHint,
-                     "-> " + D->getReturnType().getAsString(TypeHintPolicy));
+        addTypeHint(D->getFunctionTypeLoc().getRParenLoc(), D->getReturnType(),
+                    "-> ");
       }
     }
 
     return true;
   }
 
   bool VisitVarDecl(VarDecl *D) {
-    // Do not show hints for the aggregate in a structured binding.
-    // In the future, we may show hints for the individual bindings.
-    if (isa<DecompositionDecl>(D))
+    // Do not show hints for the aggregate in a structured binding,
+    // but show hints for the individual bindings.
+    if (auto *DD = dyn_cast<DecompositionDecl>(D)) {
+      for (auto *Binding : DD->bindings()) {
+        addTypeHint(Binding->getLocation(), Binding->getType(), ": ");
+      }
       return true;
+    }
 
     if (D->getType()->getContainedAutoType()) {
       if (!D->getType()->isDependentType()) {
@@ -98,8 +109,7 @@ class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
         // (e.g. for `const auto& x = 42`, print `const int&`).
         // Alternatively, we could place the hint on the `auto`
         // (and then just print the type deduced for the `auto`).
-        addInlayHint(D->getLocation(), InlayHintKind::TypeHint,
-                     ": " + D->getType().getAsString(TypeHintPolicy));
+        addTypeHint(D->getLocation(), D->getType(), ": ");
       }
     }
     return true;
@@ -311,6 +321,15 @@ class InlayHintVisitor : public RecursiveASTVisitor<InlayHintVisitor> {
         Kind, Label.str()});
   }
 
+  void addTypeHint(SourceRange R, QualType T, llvm::StringRef Prefix) {
+    // Do not print useless "NULL TYPE" hint.
+    if (!T.getTypePtrOrNull())
+      return;
+
+    addInlayHint(R, InlayHintKind::TypeHint,
+                 std::string(Prefix) + T.getAsString(TypeHintPolicy));
+  }
+
   std::vector<InlayHint> &Results;
   ASTContext &AST;
   FileID MainFileID;

clang-tools-extra/clangd/TUScheduler.cpp

@@ -1380,11 +1380,13 @@ bool ASTWorker::blockUntilIdle(Deadline Timeout) const {
   };
   // Make sure ASTWorker has processed all requests, which might issue new
   // updates to PreamblePeer.
-  WaitUntilASTWorkerIsIdle();
+  if (!WaitUntilASTWorkerIsIdle())
+    return false;
   // Now that ASTWorker processed all requests, ensure PreamblePeer has served
   // all update requests. This might create new PreambleRequests for the
   // ASTWorker.
-  PreamblePeer.blockUntilIdle(Timeout);
+  if (!PreamblePeer.blockUntilIdle(Timeout))
+    return false;
   assert(Requests.empty() &&
          "No new normal tasks can be scheduled concurrently with "
          "blockUntilIdle(): ASTWorker isn't threadsafe");

clang-tools-extra/clangd/Transport.h

@@ -18,6 +18,7 @@
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_TRANSPORT_H_
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_TRANSPORT_H_
 
+#include "Features.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"

clang-tools-extra/clangd/benchmarks/CMakeLists.txt

@@ -1,5 +1,3 @@
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../)
-
 add_subdirectory(CompletionModel)
 
 add_benchmark(IndexBenchmark IndexBenchmark.cpp)

clang-tools-extra/clangd/benchmarks/CompletionModel/CMakeLists.txt

@@ -1,5 +1,3 @@
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../)
-
 add_benchmark(DecisionForestBenchmark DecisionForestBenchmark.cpp)
 
 target_link_libraries(DecisionForestBenchmark

clang-tools-extra/clangd/fuzzer/CMakeLists.txt

@@ -1,6 +1,3 @@
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..
-  ${CMAKE_CURRENT_BINARY_DIR}/..)
-
 set(LLVM_LINK_COMPONENTS
   FuzzMutate
   Support

clang-tools-extra/clangd/index/dex/dexp/CMakeLists.txt

@@ -1,6 +1,3 @@
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../../)
-include_directories(${CMAKE_CURRENT_BINARY_DIR}/../../../)
-
 set(LLVM_LINK_COMPONENTS
   LineEditor
   Support

clang-tools-extra/clangd/index/remote/CMakeLists.txt

@@ -13,8 +13,6 @@ if (CLANGD_ENABLE_REMOTE)
     MonitoringServiceProto
     )
   include_directories(${CMAKE_CURRENT_BINARY_DIR})
-  include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../)
-  include_directories(${CMAKE_CURRENT_BINARY_DIR}/../../)
 
   # FIXME(kirillbobyrev): target_compile_definitions is not working with
   # add_clang_library for some reason. Is there any way to make this

clang-tools-extra/clangd/indexer/CMakeLists.txt

@@ -1,5 +1,3 @@
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../)
-
 set(LLVM_LINK_COMPONENTS
     Support
     )

clang-tools-extra/clangd/support/CMakeLists.txt

@@ -15,7 +15,6 @@ if(NOT HAVE_CXX_ATOMICS_WITHOUT_LIB OR NOT HAVE_CXX_ATOMICS64_WITHOUT_LIB)
   list(APPEND CLANGD_ATOMIC_LIB "atomic")
 endif()
 
-include_directories(..)
 add_clang_library(clangdSupport
   Cancellation.cpp
   Context.cpp

clang-tools-extra/clangd/support/Threading.h

@@ -12,6 +12,7 @@
 #include "support/Context.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/Twine.h"
+#include <atomic>
 #include <cassert>
 #include <condition_variable>
 #include <future>

clang-tools-extra/clangd/tool/CMakeLists.txt

@@ -1,6 +1,3 @@
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
-include_directories(${CMAKE_CURRENT_BINARY_DIR}/..)
-
 add_clang_tool(clangd
   ClangdMain.cpp
   Check.cpp

clang-tools-extra/clangd/tool/ClangdMain.cpp

@@ -6,13 +6,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-// Must be before Transport.h include.
-#include "Features.h"
-
 #include "ClangdLSPServer.h"
 #include "CodeComplete.h"
 #include "Config.h"
 #include "ConfigProvider.h"
+#include "Features.h"
 #include "PathMapping.h"
 #include "Protocol.h"
 #include "TidyProvider.h"

clang-tools-extra/clangd/unittests/CMakeLists.txt

@@ -4,15 +4,6 @@ set(LLVM_LINK_COMPONENTS
   FrontendOpenMP
   )
 
-get_filename_component(CLANGD_SOURCE_DIR
-  ${CMAKE_CURRENT_SOURCE_DIR}/../../clangd REALPATH)
-get_filename_component(CLANGD_BINARY_DIR
-  ${CMAKE_CURRENT_BINARY_DIR}/../../clangd REALPATH)
-include_directories(
-  ${CLANGD_SOURCE_DIR}
-  ${CLANGD_BINARY_DIR}
-  )
-
 if(CLANG_BUILT_STANDALONE)
   # LLVMTestingSupport library is needed for clangd tests.
   if (EXISTS ${LLVM_MAIN_SRC_DIR}/lib/Testing/Support

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

@@ -461,19 +461,70 @@ TEST(TypeHints, Lambda) {
                   ExpectedHint{": int", "init"});
 }
 
-TEST(TypeHints, StructuredBindings) {
-  // FIXME: Not handled yet.
-  // To handle it, we could print:
-  //  - the aggregate type next to the 'auto', or
-  //  - the individual types inside the brackets
-  // The latter is probably more useful.
+// Structured bindings tests.
+// Note, we hint the individual bindings, not the aggregate.
+
+TEST(TypeHints, StructuredBindings_PublicStruct) {
   assertTypeHints(R"cpp(
+    // Struct with public fields.
     struct Point {
       int x;
       int y;
     };
     Point foo();
-    auto [x, y] = foo();
+    auto [$x[[x]], $y[[y]]] = foo();
+  )cpp",
+                  ExpectedHint{": int", "x"}, ExpectedHint{": int", "y"});
+}
+
+TEST(TypeHints, StructuredBindings_Array) {
+  assertTypeHints(R"cpp(
+    int arr[2];
+    auto [$x[[x]], $y[[y]]] = arr;
+  )cpp",
+                  ExpectedHint{": int", "x"}, ExpectedHint{": int", "y"});
+}
+
+TEST(TypeHints, StructuredBindings_TupleLike) {
+  assertTypeHints(R"cpp(
+    // Tuple-like type.
+    struct IntPair {
+      int a;
+      int b;
+    };
+    namespace std {
+      template <typename T>
+      struct tuple_size {};
+      template <>
+      struct tuple_size<IntPair> {
+        constexpr static unsigned value = 2;
+      };
+      template <unsigned I, typename T>
+      struct tuple_element {};
+      template <unsigned I>
+      struct tuple_element<I, IntPair> {
+        using type = int;
+      };
+    }
+    template <unsigned I>
+    int get(const IntPair& p) {
+      if constexpr (I == 0) {
+        return p.a;
+      } else if constexpr (I == 1) {
+        return p.b;
+      }
+    }
+    IntPair bar();
+    auto [$x[[x]], $y[[y]]] = bar();
+  )cpp",
+                  ExpectedHint{": int", "x"}, ExpectedHint{": int", "y"});
+}
+
+TEST(TypeHints, StructuredBindings_NoInitializer) {
+  assertTypeHints(R"cpp(
+    // No initializer (ill-formed).
+    // Do not show useless "NULL TYPE" hint.    
+    auto [x, y];  /*error-ok*/
   )cpp");
 }
 

clang-tools-extra/clangd/unittests/xpc/CMakeLists.txt

@@ -2,12 +2,6 @@ set(LLVM_LINK_COMPONENTS
   support
   )
 
-get_filename_component(CLANGD_SOURCE_DIR
-  ${CMAKE_CURRENT_SOURCE_DIR}/../../clangd REALPATH)
-include_directories(
-  ${CLANGD_SOURCE_DIR}
-  )
-
 add_custom_target(ClangdXpcUnitTests)
 add_unittest(ClangdXpcUnitTests ClangdXpcTests
   ConversionTests.cpp

clang-tools-extra/clangd/xpc/CMakeLists.txt

@@ -7,10 +7,6 @@ include(CreateClangdXPCFramework)
 add_subdirectory(framework)
 add_subdirectory(test-client)
 
-include_directories(
-  ${CMAKE_CURRENT_SOURCE_DIR}/../
-)
-
 set(LLVM_LINK_COMPONENTS
   Support
   )

clang-tools-extra/clangd/xpc/test-client/CMakeLists.txt

@@ -1,7 +1,3 @@
-include_directories(
-  ${CMAKE_CURRENT_SOURCE_DIR}/../../
-)
-
 add_clang_tool(
   clangd-xpc-test-client
   ClangdXPCTestClient.cpp

clang/include/clang/Lex/PPCallbacks.h

@@ -191,6 +191,10 @@ class PPCallbacks {
                              StringRef Str) {
   }
 
+  /// Callback invoked when a \#pragma mark comment is read.
+  virtual void PragmaMark(SourceLocation Loc, StringRef Trivia) {
+  }
+
   /// Callback invoked when a \#pragma detect_mismatch directive is
   /// read.
   virtual void PragmaDetectMismatch(SourceLocation Loc, StringRef Name,

clang/include/clang/Lex/Preprocessor.h

@@ -2365,7 +2365,7 @@ class Preprocessor {
 
 public:
   void HandlePragmaOnce(Token &OnceTok);
-  void HandlePragmaMark();
+  void HandlePragmaMark(Token &MarkTok);
   void HandlePragmaPoison();
   void HandlePragmaSystemHeader(Token &SysHeaderTok);
   void HandlePragmaDependency(Token &DependencyTok);

clang/lib/AST/ASTImporter.cpp

@@ -496,6 +496,7 @@ namespace clang {
     ExpectedDecl VisitAccessSpecDecl(AccessSpecDecl *D);
     ExpectedDecl VisitStaticAssertDecl(StaticAssertDecl *D);
     ExpectedDecl VisitTranslationUnitDecl(TranslationUnitDecl *D);
+    ExpectedDecl VisitBindingDecl(BindingDecl *D);
     ExpectedDecl VisitNamespaceDecl(NamespaceDecl *D);
     ExpectedDecl VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
     ExpectedDecl VisitTypedefNameDecl(TypedefNameDecl *D, bool IsAlias);
@@ -2297,6 +2298,35 @@ ExpectedDecl ASTNodeImporter::VisitTranslationUnitDecl(TranslationUnitDecl *D) {
   return ToD;
 }
 
+ExpectedDecl ASTNodeImporter::VisitBindingDecl(BindingDecl *D) {
+  DeclContext *DC, *LexicalDC;
+  DeclarationName Name;
+  SourceLocation Loc;
+  NamedDecl *ToND;
+  if (Error Err = ImportDeclParts(D, DC, LexicalDC, Name, ToND, Loc))
+    return std::move(Err);
+  if (ToND)
+    return ToND;
+
+  Error Err = Error::success();
+  QualType ToType = importChecked(Err, D->getType());
+  Expr *ToBinding = importChecked(Err, D->getBinding());
+  ValueDecl *ToDecomposedDecl = importChecked(Err, D->getDecomposedDecl());
+  if (Err)
+    return std::move(Err);
+
+  BindingDecl *ToD;
+  if (GetImportedOrCreateDecl(ToD, D, Importer.getToContext(), DC, Loc,
+                              Name.getAsIdentifierInfo()))
+    return ToD;
+
+  ToD->setBinding(ToType, ToBinding);
+  ToD->setDecomposedDecl(ToDecomposedDecl);
+  addDeclToContexts(D, ToD);
+
+  return ToD;
+}
+
 ExpectedDecl ASTNodeImporter::VisitAccessSpecDecl(AccessSpecDecl *D) {
   ExpectedSLoc LocOrErr = import(D->getLocation());
   if (!LocOrErr)

clang/lib/Basic/Targets/OSTargets.h

@@ -948,8 +948,16 @@ class LLVM_LIBRARY_VISIBILITY EmscriptenTargetInfo
   }
 
 public:
-  explicit EmscriptenTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
-      : WebAssemblyOSTargetInfo<Target>(Triple, Opts) {}
+  explicit EmscriptenTargetInfo(const llvm::Triple &Triple,
+                                const TargetOptions &Opts)
+      : WebAssemblyOSTargetInfo<Target>(Triple, Opts) {
+    // Keeping the alignment of long double to 8 bytes even though its size is
+    // 16 bytes allows emscripten to have an 8-byte-aligned max_align_t which
+    // in turn gives is a 8-byte aligned malloc.
+    // Emscripten's ABI is unstable and we may change this back to 128 to match
+    // the WebAssembly default in the future.
+    this->LongDoubleAlign = 64;
+  }
 };
 
 } // namespace targets